@gongxh/bit-core 0.0.3 → 0.0.6

package/dist/bit-core.mjs

@@ -1,4 +1,4 @@
-import { sys, view, ResolutionPolicy, screen, Component, _decorator, game, director } from 'cc';
+import { view, ResolutionPolicy, game, screen, Component, sys, _decorator, director, macro } from 'cc';
 
 /**
  * @Author: Gongxh
@@ -58,142 +58,6 @@ function error(...args) {
     KUNPO_DEBUG && console.error("bit-framework:", ...args);
 }
 
-/**
- * @Author: Gongxh
- * @Date: 2024-12-07
- * @Description: 平台相关
- */
-var PlatformType;
-(function (PlatformType) {
-    PlatformType[PlatformType["Android"] = 1] = "Android";
-    PlatformType[PlatformType["IOS"] = 2] = "IOS";
-    PlatformType[PlatformType["HarmonyOS"] = 3] = "HarmonyOS";
-    /** 微信小游戏 */
-    PlatformType[PlatformType["WX"] = 4] = "WX";
-    /** 支付宝小游戏 */
-    PlatformType[PlatformType["Alipay"] = 5] = "Alipay";
-    /** 字节小游戏 */
-    PlatformType[PlatformType["Bytedance"] = 6] = "Bytedance";
-    /** 华为快游戏 */
-    PlatformType[PlatformType["HuaweiQuick"] = 7] = "HuaweiQuick";
-    /** 其他都为Browser */
-    PlatformType[PlatformType["Browser"] = 1001] = "Browser";
-})(PlatformType || (PlatformType = {}));
-class Platform {
-}
-/**
- * 是否为原生平台
- * @type {boolean}
- */
-Platform.isNative = false;
-/**
- * 是否为移动平台
- * @type {boolean}
- */
-Platform.isMobile = false;
-/**
- * 是否为原生移动平台
- * @type {boolean}
- */
-Platform.isNativeMobile = false;
-/**
- * 是否为安卓平台
- * @type {boolean}
- */
-Platform.isAndroid = false;
-/**
- * 是否为IOS平台
- * @type {boolean}
- */
-Platform.isIOS = false;
-/**
- * 是否为HarmonyOS平台
- * @type {boolean}
- */
-Platform.isHarmonyOS = false;
-/**
- * 是否为微信小游戏
- * @type {boolean}
- */
-Platform.isWX = false;
-/**
- * 是否为支付宝小游戏
- * @type {boolean}
- */
-Platform.isAlipay = false;
-/**
- * 是否为字节小游戏
- * @type {boolean}
- */
-Platform.isBytedance = false;
-/**
- * 是否是华为快游戏
- * @type {boolean}
- */
-Platform.isHuaweiQuick = false;
-/**
- * 是否为浏览器
- * @type {boolean}
- */
-Platform.isBrowser = false;
-/**
- * 平台初始化器
- * @internal
- */
-class PlatformInitializer {
-    constructor() {
-        this.initPlatform();
-    }
-    /**
-     * 初始化平台
-     * @internal
-     */
-    initPlatform() {
-        // 处理平台判断
-        Platform.isNative = sys.isNative;
-        Platform.isMobile = sys.isMobile;
-        Platform.isNativeMobile = sys.isNative && sys.isMobile;
-        switch (sys.os) {
-            case sys.OS.ANDROID:
-                Platform.isAndroid = true;
-                debug("系统类型 Android");
-                break;
-            case sys.OS.IOS:
-                Platform.isIOS = true;
-                debug("系统类型 IOS");
-                break;
-            case sys.OS.OPENHARMONY:
-                Platform.isHarmonyOS = true;
-                debug("系统类型 HarmonyOS");
-                break;
-        }
-        switch (sys.platform) {
-            case sys.Platform.WECHAT_GAME:
-                Platform.isWX = true;
-                Platform.platform = PlatformType.WX;
-                break;
-            case sys.Platform.ALIPAY_MINI_GAME:
-                Platform.isAlipay = true;
-                Platform.platform = PlatformType.Alipay;
-                break;
-            case sys.Platform.BYTEDANCE_MINI_GAME:
-                Platform.isBytedance = true;
-                Platform.platform = PlatformType.Bytedance;
-                break;
-            case sys.Platform.HUAWEI_QUICK_GAME:
-                Platform.isHuaweiQuick = true;
-                Platform.platform = PlatformType.HuaweiQuick;
-                break;
-            default:
-                // 其他都设置为浏览器
-                Platform.isBrowser = true;
-                Platform.platform = PlatformType.Browser;
-                break;
-        }
-        debug(`platform: ${PlatformType[Platform.platform]}`);
-    }
-}
-
 /**
  * @Author: Gongxh
  * @Date: 2024-12-08
@@ -202,35 +66,6 @@ class PlatformInitializer {
 class Screen {
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 /**
  * @Author: Gongxh
  * @Date: 2024-12-07
@@ -238,16 +73,26 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
  */
 class Adapter {
     constructor() {
+        /**
+         * 监听器
+         * @internal
+         */
         this.listeners = [];
     }
     /**
-     * 外部监听屏幕尺寸发生变化
+     * 添加屏幕尺寸发生变化的监听
      * @param listener 监听器
-     * @internal
      */
     addResizeListener(listener) {
         this.listeners.push(listener);
     }
+    /**
+     * 移除屏幕尺寸发生变化的监听
+     * @param listener 监听器
+     */
+    removeResizeListener(listener) {
+        this.listeners = this.listeners.filter(l => l !== listener);
+    }
     /**
      * 初始化适配器
      * @internal
@@ -316,75 +161,1252 @@ class Adapter {
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 /**
  * @Author: Gongxh
- * @Date: 2024-12-08
- * @Description:
+ * @Date: 2024-12-07
+ * @Description: 二叉堆(默认最小堆) 支持最大堆和最小堆
  */
-class CocosAdapter extends Adapter {
+class HeapNode {
+}
+class BinaryHeap {
+    constructor(capacity) {
+        this._size = 0;
+        this._capacity = capacity <= 0 ? 4 : capacity;
+        this._nodes = new Array(this._capacity);
+    }
     /**
-     * 获取屏幕像素尺寸
-     * @returns {Size}
-     * @internal
+     * 清空
      */
-    getScreenSize() {
-        let windowSize = screen.windowSize;
-        let width = Math.ceil(windowSize.width / view.getScaleX());
-        let height = Math.ceil(windowSize.height / view.getScaleY());
-        return { width, height };
+    clear() {
+        this._size = 0;
     }
     /**
-     * 获取设计尺寸
-     * @returns {Size}
-     * @internal
+     * 获取节点
+     * @param index 节点索引
      */
-    getDesignSize() {
-        let designSize = view.getDesignResolutionSize();
-        return { width: designSize.width, height: designSize.height };
+    get(index) {
+        return this._nodes[index];
     }
     /**
-     * 设置尺寸发生变化的监听
-     * @param callback 回调
-     * @internal
+     * 获取顶部节点
      */
-    registerListener(listener) {
-        if (screen && screen.on) {
-            screen.on("window-resize", (...args) => {
-                debug("window-resize");
-                listener(...args);
-            }, this);
-            screen.on("orientation-change", (...args) => {
-                debug("orientation-change");
-                listener(...args);
-            }, this);
-            screen.on("fullscreen-change", (...args) => {
-                debug("fullscreen-change");
-                listener(...args);
-            }, this);
-        }
-        else {
-            // 3.8.0之前的版本
-            view.setResizeCallback(listener);
-        }
+    top() {
+        return this._nodes[0];
     }
-}
-
-/**
- * @Author: Gongxh
- * @Date: 2024-12-07
- * @Description: cocos UI模块
- */
-class Module extends Component {
     /**
-     * 模块初始化 (内部使用)
-     * @internal
+     * 是否包含节点
+     * @param node 节点
      */
-    init() {
-        this.onInit();
+    contains(node) {
+        return node.index >= 0 && node.index < this._size;
     }
-}
-
-/**
+    /**
+     * Push节点
+     * @param node 节点
+     */
+    push(node) {
+        const size = ++this._size;
+        if (size > this._capacity) {
+            this._capacity = this._nodes.length *= 2;
+        }
+        this._sortUp(node, size - 1);
+    }
+    /**
+     * Pop节点
+     * @returns
+     */
+    pop() {
+        if (this._size == 0) {
+            return null;
+        }
+        const nodes = this._nodes;
+        const node = nodes[0];
+        node.index = -1;
+        nodes[0] = null;
+        const size = --this._size;
+        if (size > 0) {
+            const finalNode = nodes[size];
+            nodes[size] = null;
+            this._sortDown(finalNode, 0);
+        }
+        return node;
+    }
+    /**
+     * 移除节点
+     * @param node 要移除的节点
+     */
+    remove(node) {
+        if (!this.contains(node)) {
+            return;
+        }
+        const size = --this._size;
+        const nodes = this._nodes;
+        // 如果删除的不是最后一个元素，需要调整堆
+        if (node.index < size) {
+            const newNode = (nodes[node.index] = nodes[size]);
+            newNode.index = node.index;
+            nodes[size] = null;
+            this.update(newNode);
+        }
+        else {
+            nodes[size] = null;
+        }
+        node.index = -1;
+    }
+    /**
+     * 更新节点
+     * @param node 要更新的节点
+     */
+    update(node) {
+        if (!this.contains(node)) {
+            return false;
+        }
+        const index = node.index;
+        const nodes = this._nodes;
+        if (index > 0 && nodes[index].lessThan(nodes[this._parent(index)])) {
+            this._sortUp(nodes[index], index);
+        }
+        else {
+            this._sortDown(nodes[index], index);
+        }
+        return true;
+    }
+    /** @internal */
+    _parent(index) {
+        return (index - 1) >> 1;
+    }
+    get count() {
+        return this._size;
+    }
+    get empty() {
+        return this._size == 0;
+    }
+    /** @internal */
+    _sortUp(node, index) {
+        let parentIndex = this._parent(index);
+        const nodes = this._nodes;
+        while (index > 0 && node.lessThan(nodes[parentIndex])) {
+            nodes[parentIndex].index = index;
+            nodes[index] = nodes[parentIndex];
+            index = parentIndex;
+            parentIndex = this._parent(parentIndex);
+        }
+        node.index = index;
+        nodes[index] = node;
+    }
+    /** @internal */
+    _sortDown(node, index) {
+        let childIndex = (index << 1) + 1;
+        const nodes = this._nodes;
+        const size = this._size;
+        while (childIndex < size) {
+            let newParent = node;
+            // left
+            if (nodes[childIndex].lessThan(newParent)) {
+                newParent = nodes[childIndex];
+            }
+            // right
+            if (childIndex + 1 < size && nodes[childIndex + 1].lessThan(newParent)) {
+                ++childIndex;
+                newParent = nodes[childIndex];
+            }
+            if (node == newParent) {
+                break;
+            }
+            // swap down
+            newParent.index = index;
+            nodes[index] = newParent;
+            index = childIndex;
+            childIndex = (childIndex << 1) + 1;
+        }
+        node.index = index;
+        nodes[index] = node;
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 计时器节点
+ */
+/** @internal */
+class TimerNode extends HeapNode {
+    constructor(id) {
+        super();
+        /** 重复次数 */
+        this.loop = 0;
+        this.id = id;
+    }
+    /**
+     * 是否比其他定时节点小
+     * @param {HeapNode} other 其他定时节点
+     * @returns {boolean}
+     */
+    lessThan(other) {
+        const otherTimerNode = other;
+        if (Math.abs(this.expireTime - otherTimerNode.expireTime) <= 1e-5) {
+            return this.orderIndex < otherTimerNode.orderIndex;
+        }
+        return this.expireTime < otherTimerNode.expireTime;
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 计时器节点回收池
+ */
+const TimerIdBit = 19;
+const TimerCount = 1 << (32 - TimerIdBit);
+const TimerVersionMask = (1 << TimerIdBit) - 1;
+const TimerMaxVersion = TimerVersionMask;
+class TimerNodePool {
+    /**
+     * 定时器池
+     * @param {number} capacity 初始容量
+     * @internal
+     */
+    constructor(capacity) {
+        /** @internal */
+        this._pool = new Array();
+        /** @internal */
+        this._freeIndices = new Array();
+        for (let i = 0; i < capacity; ++i) {
+            const timerNode = new TimerNode(i << TimerIdBit);
+            timerNode.recycled = true;
+            this._pool.push(timerNode);
+            this._freeIndices.push(i);
+        }
+    }
+    /**
+     * 分配定时器节点
+     * @returns {TimerNode} 定时器节点
+     * @internal
+     */
+    allocate() {
+        let timerNode;
+        const pools = this._pool;
+        if (this._freeIndices.length == 0) {
+            if (pools.length == TimerCount) {
+                throw new Error("超出时钟个数: " + TimerCount);
+            }
+            timerNode = new TimerNode(pools.length << TimerIdBit);
+            pools.push(timerNode);
+        }
+        else {
+            const index = this._freeIndices.pop();
+            timerNode = pools[index];
+            timerNode.recycled = false;
+            if ((timerNode.id & TimerVersionMask) == TimerMaxVersion) {
+                throw new Error("时钟版本号过高: " + TimerMaxVersion);
+            }
+            ++timerNode.id;
+        }
+        return timerNode;
+    }
+    /**
+     * 回收定时器节点
+     * @param {number} timerId 定时器ID
+     * @internal
+     */
+    recycle(timerId) {
+        const index = timerId >>> TimerIdBit;
+        if (index < 0 || index >= this._pool.length) {
+            throw new Error("定时器不存在");
+        }
+        const timerNode = this._pool[index];
+        if (timerNode.recycled) {
+            throw new Error("定时器已经被回收");
+        }
+        timerNode.recycled = true;
+        timerNode.callback = null;
+        this._freeIndices.push(index);
+    }
+    /**
+     * 根据TimerID获取定时器节点
+     * @param {number} timerId 定时器ID
+     * @returns {TimerNode}
+     * @internal
+     */
+    get(timerId) {
+        const index = timerId >>> TimerIdBit;
+        const version = timerId & TimerVersionMask;
+        if (index < 0 || index >= this._pool.length) {
+            return null;
+        }
+        const timerNode = this._pool[index];
+        if (timerNode.recycled) {
+            return null;
+        }
+        const timerNodeVersion = timerNode.id & TimerVersionMask;
+        if (timerNodeVersion != version) {
+            return null;
+        }
+        return timerNode;
+    }
+    /**
+     * 清空正在使用的Timer
+     * @internal
+     */
+    clear() {
+        const pools = this._pool;
+        const timerNodeCount = pools.length;
+        const freeIndices = this._freeIndices;
+        freeIndices.length = 0;
+        for (let i = 0; i < timerNodeCount; ++i) {
+            pools[i].recycled = true;
+            pools[i].callback = null;
+            freeIndices.push(i);
+        }
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 定时器管理类
+ */
+class Timer {
+    /**
+     * 定时器数量
+     * @readonly
+     * @type {number}
+     */
+    get timerCount() {
+        return this._heap.count;
+    }
+    /**
+     * 定时器管理类
+     * @param {number} initTimerCapacity 初始定时器容量
+     */
+    constructor(initTimerCapacity) {
+        /** @internal */
+        this._timerNodeOrder = 0;
+        /** 经过的时间 @internal */
+        this._elapsedTime = 0;
+        this._heap = new BinaryHeap(initTimerCapacity);
+        this._pool = new TimerNodePool(initTimerCapacity);
+        this._pausedTimers = new Map();
+    }
+    /**
+     * 启动一个计时器
+     * @param { Function } callback 回调方法
+     * @param {number} interval 回调间隔 (秒)
+     * @param {number} [loop=0] 重复次数：0：回调一次，1~n：回调n次，-1：无限重复
+     * @returns {number} 返回计时器id
+     */
+    start(callback, interval, loop = 0) {
+        const timerNode = this._getTimerNode(callback, interval, loop);
+        this._heap.push(timerNode);
+        return timerNode.id;
+    }
+    /**
+     * 删除指定计时器
+     * @param {number} timerId 定时器ID
+     * @memberof Timer
+     */
+    stop(timerId) {
+        const timerNode = this._pool.get(timerId);
+        if (timerNode) {
+            if (timerNode.pause) {
+                this._pausedTimers.delete(timerId);
+            }
+            this._heap.remove(timerNode);
+            this._pool.recycle(timerId);
+        }
+    }
+    /**
+     * 暂停定时器
+     *
+     * @param {number} timerId 定时器ID
+     * @memberof Timer
+     */
+    pause(timerId) {
+        const timerNode = this._pool.get(timerId);
+        if (timerNode) {
+            timerNode.pause = true;
+            timerNode.pauseRemainTime = timerNode.expireTime - this._elapsedTime;
+            this._heap.remove(timerNode);
+            this._pausedTimers.set(timerId, timerNode);
+        }
+    }
+    /**
+     * 继续定时器
+     *
+     * @param {number} timerId 定时器ID
+     * @memberof Timer
+     */
+    resume(timerId) {
+        const timerNode = this._pausedTimers.get(timerId);
+        if (timerNode) {
+            timerNode.pause = false;
+            timerNode.expireTime = this._elapsedTime + timerNode.pauseRemainTime;
+            this._pausedTimers.delete(timerId);
+            this._heap.push(timerNode);
+        }
+    }
+    /**
+     * 更新时钟
+     * @param {number} deltaTime 更新间隔
+     * @internal
+     */
+    update(deltaTime) {
+        const elapsedTime = (this._elapsedTime += deltaTime);
+        const heap = this._heap;
+        let timerNode = heap.top();
+        while (timerNode && timerNode.expireTime <= elapsedTime) {
+            const callback = timerNode.callback;
+            if (timerNode.loop == 0) {
+                heap.pop();
+                this._recycle(timerNode);
+            }
+            else if (timerNode.loop > 0) {
+                // 处理多次回调定时器
+                if (--timerNode.loop == 0) {
+                    heap.pop();
+                    this._recycle(timerNode);
+                }
+                else {
+                    // 更新下一次回调
+                    timerNode.expireTime = timerNode.expireTime + timerNode.interval;
+                    heap.update(timerNode);
+                }
+            }
+            else {
+                // 无限次数回调
+                // 更新下一次回调
+                timerNode.expireTime = timerNode.expireTime + timerNode.interval;
+                heap.update(timerNode);
+            }
+            callback();
+            timerNode = heap.top();
+        }
+    }
+    /**
+     * 清空所有定时器
+     */
+    clear() {
+        this._heap.clear();
+        this._pool.clear();
+        this._pausedTimers.clear();
+        this._timerNodeOrder = 0;
+    }
+    /** @internal */
+    _getTimerNode(callback, interval, loop) {
+        const timerNode = this._pool.allocate();
+        timerNode.orderIndex = ++this._timerNodeOrder;
+        timerNode.callback = callback;
+        timerNode.interval = interval;
+        timerNode.expireTime = this._elapsedTime + interval;
+        timerNode.loop = loop;
+        timerNode.pause = false;
+        return timerNode;
+    }
+    /** @internal */
+    _recycle(timerNode) {
+        this._pool.recycle(timerNode.id);
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description:
+ */
+class GlobalTimer {
+    /**
+     * 初始化全局定时器，设置定时器间隔为16毫秒。
+     * 此方法用于启动一个定时器实例，以便在整个应用程序中跟踪时间相关的操作。
+     * @internal
+     */
+    static initTimer() {
+        this._timer = new Timer(16);
+    }
+    /**
+     * 获取全局定时器实例。如果定时器尚未初始化，则进行初始化。
+     * @returns {Timer} 全局定时器实例
+     * @internal
+     */
+    static get Timer() {
+        if (this._timer) {
+            return this._timer;
+        }
+        this.initTimer();
+        return this._timer;
+    }
+    /**
+     * 启动一个定时器，执行指定的回调函数。
+     * @param callback - 要定时执行的回调函数。
+     * @param interval - 定时器的时间间隔（秒）。
+     * @param loop - [loop=0] 重复次数：0：回调一次，1~n：回调n次，-1：无限重复
+     * @returns 返回定时器的ID。
+     */
+    static startTimer(callback, interval, loop = 0) {
+        return this.Timer.start(callback, interval, loop);
+    }
+    /**
+     * 停止指定ID的计时器。
+     * @param timerId - 要停止的计时器的唯一标识符。
+     */
+    static stopTimer(timerId) {
+        this.Timer.stop(timerId);
+    }
+    /**
+     * 暂停指定ID的计时器。
+     * @param timerId - 要暂停的计时器的唯一标识符。
+     */
+    static pauseTimer(timerId) {
+        this.Timer.pause(timerId);
+    }
+    /**
+     * 恢复指定ID的计时器。
+     * @param timerId - 要恢复的计时器的唯一标识符。
+     */
+    static resumeTimer(timerId) {
+        this.Timer.resume(timerId);
+    }
+    /**
+     * 清除所有定时器。
+     */
+    static clearAllTimer() {
+        this.Timer.clear();
+    }
+    /**
+     * 更新定时器
+     * @param dt - 时间间隔
+     * @internal
+     */
+    static update(dt) {
+        var _a;
+        (_a = this._timer) === null || _a === void 0 ? void 0 : _a.update(dt);
+    }
+}
+/** @internal */
+GlobalTimer._timer = null;
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 内部使用的全局定时器
+ */
+class InnerTimer {
+    /**
+     * 初始化全局定时器，设置定时器间隔为16毫秒。
+     * 此方法用于启动一个定时器实例，以便在整个应用程序中跟踪时间相关的操作。
+     */
+    static initTimer() {
+        this._timer = new Timer(16);
+    }
+    /**
+     * 启动一个定时器，执行指定的回调函数。
+     * @param callback - 要定时执行的回调函数。
+     * @param interval - 定时器的时间间隔（秒）。
+     * @param loop - [loop=0] 重复次数：0：回调一次，1~n：回调n次，-1：无限重复
+     * @returns 返回定时器的ID。
+     */
+    static startTimer(callback, interval, loop = 0) {
+        return this._timer.start(callback, interval, loop);
+    }
+    /**
+     * 停止指定ID的计时器。
+     * @param timerId - 要停止的计时器的唯一标识符。
+     */
+    static stopTimer(timerId) {
+        this._timer.stop(timerId);
+    }
+    static update(dt) {
+        var _a;
+        (_a = this._timer) === null || _a === void 0 ? void 0 : _a.update(dt);
+    }
+}
+InnerTimer._timer = null;
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-03-06
+ * @Description: 时间工具
+ */
+/** 时间对象缓存 */
+let TimeCache = null;
+class Time {
+    /** 获取游戏系统启动时间戳 */
+    static get osBootTime() { return this._osBootTime; }
+    /** 获取主动设置的网络时间 单位ms */
+    static get netTime() { return this._netTime; }
+    /** 获取本地时间与网路时间的偏移量 单位ms */
+    static get netTimeDiff() { return this._netTimeDiff; }
+    /** 获取系统运行时间 */
+    static get runTime() { return Math.floor(game.totalTime); }
+    /**
+     * 配置系统启动时间
+     * @internal
+     */
+    static _configBoot() {
+        this._osBootTime = Math.floor(Date.now());
+        TimeCache = new Date();
+        this._nowTimestamp = () => {
+            return this._osBootTime + this.runTime;
+        };
+        debug("系统启动时间", this.formatTime(this._osBootTime));
+    }
+    /**
+     * 设置网络时间, 单位ms
+     * @param netTime 网络时间
+     */
+    static setNetTime(netTime) {
+        if (netTime == 0) {
+            return;
+        }
+        this._netTime = netTime;
+        const localTime = this._nowTimestamp();
+        this._netTimeDiff = Math.floor(this.netTime - localTime);
+        debug(`设置网络时间: net(${this.formatTime(this.netTime)}), boot(${this.formatTime(this.osBootTime)}), diff(${Math.abs(this.netTimeDiff / 1000)}秒)`);
+    }
+    /**
+     * 获取当前时间 单位ms
+     */
+    static now() {
+        return this._nowTimestamp() + this.netTimeDiff;
+    }
+    /**
+     * 将毫秒转换为秒
+     * @param ms 毫秒
+     */
+    static msTos(ms) {
+        return Math.floor((ms || 0) / 1000);
+    }
+    /**
+     * 将秒转换为毫秒
+     */
+    static sToMs(s) {
+        return (s || 0) * 1000;
+    }
+    /**
+     * 获取年份
+     * @param timestamp 时间戳 (ms)
+     * @returns 年份
+     */
+    static getYear(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        return TimeCache.getFullYear();
+    }
+    /**
+     * 获取月份
+     * @param timestamp 时间戳 (ms)
+     * @returns 月份
+     */
+    static getMonth(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        return TimeCache.getMonth() + 1;
+    }
+    /**
+     * 获取日期
+     * @param timestamp 时间戳 (ms)
+     * @returns 日期
+     */
+    static getDay(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        return TimeCache.getDate();
+    }
+    /**
+     * 获取小时
+     * @param timestamp 时间戳 (ms)
+     * @returns 小时
+     */
+    static getHour(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        return TimeCache.getHours();
+    }
+    /**
+     * 获取分钟
+     * @param timestamp 时间戳 (ms)
+     * @returns 分钟
+     */
+    static getMinute(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        return TimeCache.getMinutes();
+    }
+    /**
+     * 获取秒
+     * @param timestamp 时间戳 (ms)
+     * @returns 秒
+     */
+    static getSecond(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        return TimeCache.getSeconds();
+    }
+    /**
+     * 获取当天开始时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getDayStartTime(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        TimeCache.setHours(0, 0, 0, 0);
+        return TimeCache.getTime();
+    }
+    /**
+     * 获取当天的结束时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getDayEndTime(timestamp) {
+        return this.getDayStartTime(timestamp) + 86400000;
+    }
+    /**
+     * 获取传入时间是周几
+     * @param {number} [time] (ms)
+     * @returns {number}
+     */
+    static getWeekDay(time) {
+        TimeCache.setTime(time || Time.now());
+        return TimeCache.getDay() || 7;
+    }
+    /**
+     * 获取当前周的开始时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getWeekStartTime(timestamp) {
+        return this.getDayStartTime(timestamp - this.getWeekDay(timestamp) * 86400000);
+    }
+    static getWeekEndTime(timestamp) {
+        return this.getWeekStartTime(timestamp) + 86400000 * 7;
+    }
+    /**
+     * 获取当前月开始时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getMonthStartTime(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        TimeCache.setDate(1);
+        TimeCache.setHours(0, 0, 0, 0);
+        return TimeCache.getTime();
+    }
+    /**
+     * 获取当前月结束时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getMonthEndTime(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        TimeCache.setDate(1);
+        TimeCache.setHours(0, 0, 0, 0);
+        TimeCache.setMonth(TimeCache.getMonth() + 1);
+        return TimeCache.getTime();
+    }
+    /**
+     * 获取当前年份开始时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getYearStartTime(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        TimeCache.setMonth(0);
+        TimeCache.setDate(1);
+        TimeCache.setHours(0, 0, 0, 0);
+        return TimeCache.getTime();
+    }
+    /**
+     * 获取当前年份结束时间
+     * @param timestamp 时间戳 (ms)
+     * @returns 时间戳 (ms)
+     */
+    static getYearEndTime(timestamp) {
+        TimeCache.setTime(timestamp || this.now());
+        TimeCache.setMonth(0);
+        TimeCache.setDate(1);
+        TimeCache.setHours(0, 0, 0, 0);
+        TimeCache.setFullYear(TimeCache.getFullYear() + 1);
+        return TimeCache.getTime();
+    }
+    /**
+     * 获取当前月的天数
+     * @param timestamp 时间戳 (ms)
+     * @returns 天数
+     */
+    static getMonthDays(timestamp) {
+        const monthEndTime = this.getMonthEndTime(timestamp);
+        const monthStartTime = this.getMonthStartTime(timestamp);
+        return Math.round((monthEndTime - monthStartTime) / 86400000);
+    }
+    /**
+     * 是否是同一天
+     * @param timestamp1 时间戳1 (ms)
+     * @param now 时间戳2 (ms) 如果不传，则和当前时间比较
+     * @returns 是否是同一天
+     */
+    static isSameDay(timestamp1, now) {
+        now = now || this.now();
+        if (now - timestamp1 > 86400000) {
+            return false;
+        }
+        return this.getDayStartTime(timestamp1) === this.getDayStartTime(now);
+    }
+    /**
+     * 是否是同一周
+     * @param timestamp1 时间戳1 (ms)
+     * @param now 时间戳2 (ms) 如果不传，则和当前时间比较
+     * @returns 是否是同一周
+     */
+    static isSameWeek(timestamp1, now) {
+        now = now || this.now();
+        if (now - timestamp1 > 86400000 * 7) {
+            return false;
+        }
+        return this.getWeekStartTime(timestamp1) === this.getWeekStartTime(now);
+    }
+    /**
+     * 是否是同一月
+     * @param timestamp1 时间戳1 (ms)
+     * @param now 时间戳2 (ms) 如果不传，则和当前时间比较
+     * @returns 是否是同一月
+     */
+    static isSameMonth(timestamp1, now) {
+        now = now || this.now();
+        TimeCache.setTime(timestamp1);
+        const month1 = TimeCache.getMonth();
+        const year1 = TimeCache.getFullYear();
+        TimeCache.setTime(now);
+        const month2 = TimeCache.getMonth();
+        const year2 = TimeCache.getFullYear();
+        return month1 === month2 && year1 === year2;
+    }
+    /**
+     * 是否是同一年
+     * @param timestamp1 时间戳1 (ms)
+     * @param now 时间戳2 (ms) 如果不传，则和当前时间比较
+     * @returns 是否是同一年
+     */
+    static isSameYear(timestamp1, now) {
+        now = now || this.now();
+        // 直接比较年份，避免使用天数计算可能出现的边界错误
+        TimeCache.setTime(timestamp1);
+        const year1 = TimeCache.getFullYear();
+        TimeCache.setTime(now);
+        const year2 = TimeCache.getFullYear();
+        return year1 === year2;
+    }
+    /**
+     * 通用时间格式化方法
+     * @param timestamp 时间戳 (ms)
+     * @param pattern 格式化模板
+     *
+     * 支持的占位符(大写补零,小写不补零):
+     * - YYYY: 四位年份 (2025) | YY: 两位年份 (25)
+     * - MM: 两位月份 (01-12) | M: 月份 (1-12)
+     * - DD: 两位日期 (01-31) | D: 日期 (1-31)
+     * - hh: 两位小时 (00-23) | h: 小时 (0-23)
+     * - mm: 两位分钟 (00-59) | m: 分钟 (0-59)
+     * - ss: 两位秒 (00-59) | s: 秒 (0-59)
+     *
+     * @example
+     * Time.format(timestamp, 'YYYY-MM-DD hh:mm:ss') // "2025-01-05 14:30:45"
+     * Time.format(timestamp, 'YYYY年MM月DD日 hh:mm') // "2025年01月05日 14:30"
+     * Time.format(timestamp, 'M月D日 h时m分') // "1月5日 14时30分"
+     */
+    static format(timestamp, pattern) {
+        TimeCache.setTime(timestamp);
+        const year = TimeCache.getFullYear();
+        const month = TimeCache.getMonth() + 1;
+        const day = TimeCache.getDate();
+        const hour = TimeCache.getHours();
+        const minute = TimeCache.getMinutes();
+        const second = TimeCache.getSeconds();
+        const pad = (n) => n < 10 ? `0${n}` : `${n}`;
+        return pattern
+            .replace(/YYYY/g, `${year}`)
+            .replace(/YY/g, pad(year % 100))
+            .replace(/MM/g, pad(month))
+            .replace(/M/g, `${month}`)
+            .replace(/DD/g, pad(day))
+            .replace(/D/g, `${day}`)
+            .replace(/hh/g, pad(hour))
+            .replace(/h/g, `${hour}`)
+            .replace(/mm/g, pad(minute))
+            .replace(/m/g, `${minute}`)
+            .replace(/ss/g, pad(second))
+            .replace(/s/g, `${second}`);
+    }
+    /**
+     * 格式化时间 格式: xxxx-xx-xx hh:mm:ss
+     * @param timestamp 时间戳 (ms)
+     */
+    static formatTime(timestamp) {
+        return this.format(timestamp, 'YYYY-MM-DD hh:mm:ss');
+    }
+    /**
+     * 格式化时间 格式: xxxx年xx月xx日 hh:mm:ss
+     * @param timestamp 时间戳 (ms)
+     */
+    static formatTimeChinese(timestamp) {
+        return this.format(timestamp, 'YYYY年MM月DD日 hh:mm:ss');
+    }
+    /**
+     * 通用时长格式化方法
+     * @param seconds 时长(秒)
+     * @param pattern 格式化模板
+     * @param options 格式化选项
+     *
+     * 支持的占位符(大写补零,小写不补零):
+     * - DD/D: 天数
+     * - HH/H: 总小时数(可超过24)
+     * - hh/h: 小时数(0-23范围)
+     * - MM/M: 总分钟数(可超过60)
+     * - mm/m: 分钟数(0-59范围)
+     * - ss/s: 秒数(0-59范围)
+     *
+     * options.autoHide: 自动隐藏为0的高位单位(默认false)
+     *
+     * @example
+     * Time.formatDuration(3661, 'HH:mm:ss')     // "01:01:01"
+     * Time.formatDuration(3661, 'MM:ss')        // "61:01"
+     * Time.formatDuration(3661, 'H小时m分s秒')   // "1小时1分1秒"
+     * Time.formatDuration(90061, 'DD天hh:mm:ss') // "1天01:01:01"
+     * Time.formatDuration(125, 'HH:mm:ss', { autoHide: true }) // "02:05"
+     * Time.formatDuration(3661, 'DD天HH时mm分ss秒', { autoHide: true }) // "1时1分1秒"
+     */
+    static formatDuration(seconds, pattern, options) {
+        const time = Math.floor(seconds < 0 ? 0 : seconds);
+        const day = Math.floor(time / 86400);
+        const totalHours = Math.floor(time / 3600);
+        const totalMinutes = Math.floor(time / 60);
+        const hour = Math.floor((time % 86400) / 3600);
+        const minute = Math.floor((time % 3600) / 60);
+        const second = time % 60;
+        const pad = (n) => n < 10 ? `0${n}` : `${n}`;
+        // 如果启用自动隐藏，移除值为0的高位单位
+        let result = pattern;
+        if (options === null || options === void 0 ? void 0 : options.autoHide) {
+            // 检测天数
+            if (day === 0) {
+                result = result.replace(/DD天?|D天?/g, '');
+            }
+            // 检测小时（需要天数为0时才隐藏）
+            if (day === 0 && hour === 0 && totalHours === 0) {
+                result = result.replace(/HH[时:]?|H[时:]?|hh[时:]?|h[时:]?/g, '');
+            }
+            // 检测分钟（需要天数和小时都为0时才隐藏）
+            if (day === 0 && hour === 0 && totalHours === 0 && minute === 0 && totalMinutes === 0) {
+                result = result.replace(/MM[分:]?|M[分:]?|mm[分:]?|m[分:]?/g, '');
+            }
+            // 清理多余的分隔符
+            result = result.replace(/^[:\s]+|[:\s]+$/g, '').replace(/\s{2,}/g, ' ');
+        }
+        return result
+            .replace(/DD/g, pad(day))
+            .replace(/D/g, `${day}`)
+            .replace(/HH/g, pad(totalHours))
+            .replace(/H/g, `${totalHours}`)
+            .replace(/hh/g, pad(hour))
+            .replace(/h/g, `${hour}`)
+            .replace(/MM/g, pad(totalMinutes))
+            .replace(/M/g, `${totalMinutes}`)
+            .replace(/mm/g, pad(minute))
+            .replace(/m/g, `${minute}`)
+            .replace(/ss/g, pad(second))
+            .replace(/s/g, `${second}`);
+    }
+    /**
+     * 智能格式化时长 - 自动隐藏为0的高位单位
+     * @param time 时间 (s)
+     * @param pattern 格式化模板，默认 'D天h小时m分s秒'
+     *
+     * @example
+     * Time.formatSmart(86461)  // "1天1小时1分1秒"
+     * Time.formatSmart(3661)   // "1小时1分1秒"
+     * Time.formatSmart(61)     // "1分1秒"
+     * Time.formatSmart(1)      // "1秒"
+     */
+    static formatSmart(time, pattern = 'D天h小时m分s秒') {
+        return this.formatDuration(time, pattern, { autoHide: true });
+    }
+    /**
+     * 智能格式化时长(简化版) - 只显示最大的两个单位，较小单位向上取整
+     * @param time 时间 (s)
+     * @param pattern 格式化模板，默认 'D天h小时|h小时m分|m分s秒'，用 | 分隔不同级别
+     *
+     * @example
+     * Time.formatSmartSimple(90061)  // "1天2小时" (1.04小时向上取整为2)
+     * Time.formatSmartSimple(3661)   // "1小时2分" (1.02分钟向上取整为2)
+     * Time.formatSmartSimple(61)     // "1分2秒" (1.02秒向上取整为2)
+     * Time.formatSmartSimple(1)      // "1秒"
+     * Time.formatSmartSimple(90061, 'D天h时|h时m分|m分s秒')  // "1天2时"
+     */
+    static formatSmartSimple(time, pattern = 'D天h小时|h小时m分|m分s秒') {
+        const curTime = Math.floor(time < 0 ? 0 : time);
+        const [dayPattern = 'D天h小时', hourPattern = 'h小时m分', minutePattern = 'm分s秒', secondPattern = 's秒'] = pattern.split('|');
+        if (curTime >= 86400) {
+            const day = Math.floor(curTime / 86400);
+            const hour = Math.ceil((curTime % 86400) / 3600);
+            return this.formatDuration(day * 86400 + hour * 3600, dayPattern);
+        }
+        else if (curTime >= 3600) {
+            const hour = Math.floor(curTime / 3600);
+            const minute = Math.ceil((curTime % 3600) / 60);
+            return this.formatDuration(hour * 3600 + minute * 60, hourPattern);
+        }
+        else if (curTime >= 60) {
+            const minute = Math.floor(curTime / 60);
+            const second = Math.ceil(curTime % 60);
+            return this.formatDuration(minute * 60 + second, minutePattern);
+        }
+        else {
+            return this.formatDuration(curTime, secondPattern);
+        }
+    }
+}
+/**
+ * 游戏系统启动时间戳
+ * @internal
+ */
+Time._osBootTime = 0;
+/**
+ * 主动设置的网络时间 单位ms
+ * @internal
+ */
+Time._netTime = 0;
+/**
+ * 本地时间与网路时间的偏移量 单位ms
+ * @internal
+ */
+Time._netTimeDiff = 0;
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description:
+ */
+class CocosAdapter extends Adapter {
+    /**
+     * 获取屏幕像素尺寸
+     * @returns {Size}
+     * @internal
+     */
+    getScreenSize() {
+        let windowSize = screen.windowSize;
+        let width = Math.ceil(windowSize.width / view.getScaleX());
+        let height = Math.ceil(windowSize.height / view.getScaleY());
+        return { width, height };
+    }
+    /**
+     * 获取设计尺寸
+     * @returns {Size}
+     * @internal
+     */
+    getDesignSize() {
+        let designSize = view.getDesignResolutionSize();
+        return { width: designSize.width, height: designSize.height };
+    }
+    /**
+     * 设置尺寸发生变化的监听
+     * @param callback 回调
+     * @internal
+     */
+    registerListener(listener) {
+        if (screen && screen.on) {
+            screen.on("window-resize", (...args) => {
+                debug("window-resize");
+                listener(...args);
+            }, this);
+            screen.on("orientation-change", (...args) => {
+                debug("orientation-change");
+                listener(...args);
+            }, this);
+            screen.on("fullscreen-change", (...args) => {
+                debug("fullscreen-change");
+                listener(...args);
+            }, this);
+        }
+        else {
+            // 3.8.0之前的版本
+            view.setResizeCallback(listener);
+        }
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: cocos UI模块
+ */
+class Module extends Component {
+    /**
+     * 模块初始化 (内部使用)
+     * @internal
+     */
+    init() {
+        this.onInit();
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 平台相关
+ */
+var PlatformType;
+(function (PlatformType) {
+    PlatformType[PlatformType["Android"] = 1] = "Android";
+    PlatformType[PlatformType["IOS"] = 2] = "IOS";
+    PlatformType[PlatformType["HarmonyOS"] = 3] = "HarmonyOS";
+    /** 微信小游戏 */
+    PlatformType[PlatformType["WX"] = 4] = "WX";
+    /** 支付宝小游戏 */
+    PlatformType[PlatformType["Alipay"] = 5] = "Alipay";
+    /** 字节小游戏 */
+    PlatformType[PlatformType["Bytedance"] = 6] = "Bytedance";
+    /** 华为快游戏 */
+    PlatformType[PlatformType["HuaweiQuick"] = 7] = "HuaweiQuick";
+    /** 其他都为Browser */
+    PlatformType[PlatformType["Browser"] = 1001] = "Browser";
+})(PlatformType || (PlatformType = {}));
+class Platform {
+}
+/**
+ * 是否为原生平台
+ * @type {boolean}
+ */
+Platform.isNative = false;
+/**
+ * 是否为移动平台
+ * @type {boolean}
+ */
+Platform.isMobile = false;
+/**
+ * 是否为原生移动平台
+ * @type {boolean}
+ */
+Platform.isNativeMobile = false;
+/**
+ * 是否为安卓平台
+ * @type {boolean}
+ */
+Platform.isAndroid = false;
+/**
+ * 是否为IOS平台
+ * @type {boolean}
+ */
+Platform.isIOS = false;
+/**
+ * 是否为HarmonyOS平台
+ * @type {boolean}
+ */
+Platform.isHarmonyOS = false;
+/**
+ * 是否为微信小游戏
+ * @type {boolean}
+ */
+Platform.isWX = false;
+/**
+ * 是否为支付宝小游戏
+ * @type {boolean}
+ */
+Platform.isAlipay = false;
+/**
+ * 是否为字节小游戏
+ * @type {boolean}
+ */
+Platform.isBytedance = false;
+/**
+ * 是否是华为快游戏
+ * @type {boolean}
+ */
+Platform.isHuaweiQuick = false;
+/**
+ * 是否为浏览器
+ * @type {boolean}
+ */
+Platform.isBrowser = false;
+/**
+ * 平台初始化器
+ * @internal
+ */
+class PlatformInitializer {
+    constructor() {
+        this.initPlatform();
+    }
+    /**
+     * 初始化平台
+     * @internal
+     */
+    initPlatform() {
+        // 处理平台判断
+        Platform.isNative = sys.isNative;
+        Platform.isMobile = sys.isMobile;
+        Platform.isNativeMobile = sys.isNative && sys.isMobile;
+        switch (sys.os) {
+            case sys.OS.ANDROID:
+                Platform.isAndroid = true;
+                debug("系统类型 Android");
+                break;
+            case sys.OS.IOS:
+                Platform.isIOS = true;
+                debug("系统类型 IOS");
+                break;
+            case sys.OS.OPENHARMONY:
+                Platform.isHarmonyOS = true;
+                debug("系统类型 HarmonyOS");
+                break;
+        }
+        switch (sys.platform) {
+            case sys.Platform.WECHAT_GAME:
+                Platform.isWX = true;
+                Platform.platform = PlatformType.WX;
+                break;
+            case sys.Platform.ALIPAY_MINI_GAME:
+                Platform.isAlipay = true;
+                Platform.platform = PlatformType.Alipay;
+                break;
+            case sys.Platform.BYTEDANCE_MINI_GAME:
+                Platform.isBytedance = true;
+                Platform.platform = PlatformType.Bytedance;
+                break;
+            case sys.Platform.HUAWEI_QUICK_GAME:
+                Platform.isHuaweiQuick = true;
+                Platform.platform = PlatformType.HuaweiQuick;
+                break;
+            default:
+                // 其他都设置为浏览器
+                Platform.isBrowser = true;
+                Platform.platform = PlatformType.Browser;
+                break;
+        }
+        debug(`platform: ${PlatformType[Platform.platform]}`);
+    }
+}
+
+/**
  * @Author: Gongxh
  * @Date: 2024-12-07
  * @Description:cocos游戏入口 定义了游戏启动时的基本配置和初始化流程。
@@ -403,7 +1425,7 @@ class CocosEntry extends Component {
     start() {
         // 是否开启调试输出
         this.enableDebug && enableDebugMode(true);
-        debug("开始初始化【bit-framework】");
+        debug("====================开始初始化=====================");
         // 设置游戏真帧率
         game.frameRate = this.fps;
         director.addPersistRootNode(this.node);
@@ -412,10 +1434,22 @@ class CocosEntry extends Component {
         new PlatformInitializer();
         // 适配器
         new CocosAdapter().init();
+        // 时间相关
+        this.initTime();
+        // 初始化模块
         this.initModule();
-        debug("【bit-framework】初始化完成");
+        debug("=====================初始化完成=====================");
         this.onInit();
     }
+    /**
+     * 时间相关
+     */
+    initTime() {
+        Time._configBoot();
+        InnerTimer.initTimer();
+        GlobalTimer.initTimer();
+        this.schedule(this.tick.bind(this), 0, macro.REPEAT_FOREVER);
+    }
     /**
      * 初始化模块
      * @internal
@@ -426,6 +1460,15 @@ class CocosEntry extends Component {
             module.init();
         }
     }
+    /**
+     * 更新
+     * @param dt 时间间隔
+     * @internal
+     */
+    tick(dt) {
+        InnerTimer.update(dt);
+        GlobalTimer.update(dt);
+    }
 }
 __decorate([
     property({ displayName: "游戏帧率" })
@@ -434,4 +1477,939 @@ __decorate([
     property({ displayName: "开启调试输出" })
 ], CocosEntry.prototype, "enableDebug", void 0);
 
-export { CocosEntry, Module, Platform, PlatformType, Screen, debug, enableDebugMode, error, info, log, warn };
+/**
+ * @Author: Gongxh
+ * @Date: 2025-03-04
+ * @Description: 二进制工具类 - 使用 JavaScript 标准库实现
+ */
+class Binary {
+    /**
+     * 将对象转换为二进制数据
+     */
+    static toBinary(obj) {
+        // console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+        // console.log("原始数据", JSON.stringify(obj));
+        const chunks = [];
+        this.writeValue(obj, chunks);
+        // 计算总长度
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        // 合并所有数据块
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        // console.log("二进制数据", result);
+        // console.log("还原数据", JSON.stringify(this.toJson(result)));
+        return result;
+    }
+    /**
+     * 将二进制数据转换JSON数据
+     * @param binary 二进制数据
+     * @returns
+     */
+    static toJson(binary) {
+        // 如果是 ArrayBuffer, 转换为 Uint8Array
+        const uint8Array = binary instanceof ArrayBuffer ? new Uint8Array(binary) : binary;
+        // 检查是否为二进制格式
+        if (!this.isBinaryFormat(uint8Array)) {
+            // 如果不是二进制格式, 直接返回
+            return binary;
+        }
+        const view = new DataView(uint8Array.buffer);
+        let offset = 0;
+        return this.readValue(view, offset);
+    }
+    /**
+     * 检查数据是否为二进制格式
+     * @param data 要检查的数据
+     * @returns 是否为二进制格式
+     */
+    static isBinaryFormat(data) {
+        if (!data || !data.length || data.length < 1) {
+            return false;
+        }
+        // 检查第一个字节是否为有效的类型标记（0-5）
+        const firstByte = data[0];
+        if (firstByte < 0 || firstByte > 5) {
+            return false;
+        }
+        // 检查数据格式是否符合我们的二进制格式规范
+        try {
+            const view = new DataView(data.buffer);
+            let offset = 0;
+            // 递归检查数据格式
+            this.validateBinaryFormat(view, offset);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * 验证二进制数据格式
+     * @param view DataView对象
+     * @param offset 当前偏移量
+     * @returns 下一个数据的偏移量
+     * @internal
+     */
+    static validateBinaryFormat(view, offset) {
+        const type = view.getUint8(offset);
+        switch (type) {
+            case 0: // null
+                return 1;
+            case 1: // number
+                return 9;
+            case 2: { // string
+                const strLen = view.getUint32(offset + 1, true);
+                return 5 + strLen;
+            }
+            case 3: // boolean
+                return 2;
+            case 4: { // array
+                const arrLen = view.getUint32(offset + 1, true);
+                let size = 5;
+                for (let i = 0; i < arrLen; i++) {
+                    size += this.validateBinaryFormat(view, offset + size);
+                }
+                return size;
+            }
+            case 5: { // object
+                const objLen = view.getUint32(offset + 1, true);
+                let size = 5;
+                for (let i = 0; i < objLen; i++) {
+                    const keyLen = view.getUint32(offset + size, true);
+                    size += 4 + keyLen;
+                    size += this.validateBinaryFormat(view, offset + size);
+                }
+                return size;
+            }
+            default:
+                throw new Error('无效的类型标记');
+        }
+    }
+    /** @internal */
+    static readValue(view, offset) {
+        const type = view.getUint8(offset++);
+        switch (type) {
+            case 0: // null
+                return null;
+            case 1: // number
+                const num = view.getFloat64(offset, true);
+                return num;
+            case 2: { // string
+                const strLen = view.getUint32(offset, true);
+                offset += 4;
+                const strBytes = new Uint8Array(view.buffer, offset, strLen);
+                return this.utf8ArrayToString(strBytes);
+            }
+            case 3: // boolean
+                return view.getUint8(offset) === 1;
+            case 4: // array
+                const arrLen = view.getUint32(offset, true);
+                offset += 4;
+                const arr = [];
+                for (let i = 0; i < arrLen; i++) {
+                    arr.push(this.readValue(view, offset));
+                    offset += this.getNextOffset(view, offset);
+                }
+                return arr;
+            case 5: { // object
+                const objLen = view.getUint32(offset, true);
+                offset += 4;
+                const obj = {};
+                for (let i = 0; i < objLen; i++) {
+                    const keyLen = view.getUint32(offset, true);
+                    offset += 4;
+                    let key = '';
+                    for (let j = 0; j < keyLen; j++) {
+                        key += String.fromCharCode(view.getUint8(offset + j));
+                    }
+                    offset += keyLen;
+                    obj[key] = this.readValue(view, offset);
+                    offset += this.getNextOffset(view, offset);
+                }
+                return obj;
+            }
+            default:
+                throw new Error(`未知的类型: ${type}`);
+        }
+    }
+    /** @internal */
+    static writeValue(value, chunks) {
+        if (value === null) {
+            chunks.push(new Uint8Array([0]));
+            return;
+        }
+        switch (typeof value) {
+            case 'number': {
+                const numBuf = new Uint8Array(9);
+                numBuf[0] = 1;
+                const view = new DataView(numBuf.buffer);
+                view.setFloat64(1, value, true);
+                chunks.push(numBuf);
+                break;
+            }
+            case 'string': {
+                const strBytes = this.stringToUtf8Array(value);
+                const strLen = strBytes.length;
+                const strBuf = new Uint8Array(5 + strLen);
+                strBuf[0] = 2;
+                const view = new DataView(strBuf.buffer);
+                view.setUint32(1, strLen, true);
+                strBuf.set(strBytes, 5);
+                chunks.push(strBuf);
+                break;
+            }
+            case 'boolean': {
+                const boolBuf = new Uint8Array(2);
+                boolBuf[0] = 3;
+                boolBuf[1] = value ? 1 : 0;
+                chunks.push(boolBuf);
+                break;
+            }
+            case 'object': {
+                if (Array.isArray(value)) {
+                    const arrBuf = new Uint8Array(5);
+                    arrBuf[0] = 4;
+                    const view = new DataView(arrBuf.buffer);
+                    view.setUint32(1, value.length, true);
+                    chunks.push(arrBuf);
+                    for (const item of value) {
+                        this.writeValue(item, chunks);
+                    }
+                }
+                else {
+                    const keys = Object.keys(value);
+                    const objBuf = new Uint8Array(5);
+                    objBuf[0] = 5;
+                    const view = new DataView(objBuf.buffer);
+                    view.setUint32(1, keys.length, true);
+                    chunks.push(objBuf);
+                    for (const key of keys) {
+                        const keyLen = key.length;
+                        const keyBuf = new Uint8Array(4 + keyLen);
+                        const keyView = new DataView(keyBuf.buffer);
+                        keyView.setUint32(0, keyLen, true);
+                        const keyBytes = new TextEncoder().encode(key);
+                        keyBuf.set(keyBytes, 4);
+                        chunks.push(keyBuf);
+                        this.writeValue(value[key], chunks);
+                    }
+                }
+                break;
+            }
+            default:
+                throw new Error(`不支持的类型: ${typeof value}`);
+        }
+    }
+    /** @internal */
+    static getNextOffset(view, offset) {
+        const type = view.getUint8(offset);
+        switch (type) {
+            case 0: return 1; // null
+            case 1: return 9; // number
+            case 2: return 5 + view.getUint32(offset + 1, true); // string
+            case 3: return 2; // boolean
+            case 4: { // array
+                const arrLen = view.getUint32(offset + 1, true);
+                let currentSize = 5;
+                for (let i = 0; i < arrLen; i++) {
+                    currentSize += this.getNextOffset(view, offset + currentSize);
+                }
+                return currentSize;
+            }
+            case 5: { // object
+                const objLen = view.getUint32(offset + 1, true);
+                let currentSize = 5;
+                for (let i = 0; i < objLen; i++) {
+                    const keyLen = view.getUint32(offset + currentSize, true);
+                    currentSize += 4 + keyLen;
+                    currentSize += this.getNextOffset(view, offset + currentSize);
+                }
+                return currentSize;
+            }
+            default:
+                throw new Error(`未知的类型: ${type}`);
+        }
+    }
+    /** @internal */
+    static utf8ArrayToString(array) {
+        if (!array || array.length === 0) {
+            return '';
+        }
+        let out = '';
+        let i = 0;
+        try {
+            while (i < array.length) {
+                let c = array[i++];
+                if (c > 127) {
+                    if (c > 191 && c < 224) {
+                        if (i >= array.length)
+                            break;
+                        c = ((c & 31) << 6) | (array[i++] & 63);
+                    }
+                    else if (c > 223 && c < 240) {
+                        if (i + 1 >= array.length)
+                            break;
+                        c = ((c & 15) << 12) | ((array[i++] & 63) << 6) | (array[i++] & 63);
+                    }
+                    else if (c > 239 && c < 248) {
+                        if (i + 2 >= array.length)
+                            break;
+                        c = ((c & 7) << 18) | ((array[i++] & 63) << 12) | ((array[i++] & 63) << 6) | (array[i++] & 63);
+                    }
+                    else {
+                        // 无效的 UTF-8 序列
+                        continue;
+                    }
+                }
+                if (c <= 0xffff) {
+                    out += String.fromCharCode(c);
+                }
+                else if (c <= 0x10ffff) {
+                    c -= 0x10000;
+                    out += String.fromCharCode((c >> 10) | 0xd800);
+                    out += String.fromCharCode((c & 0x3FF) | 0xdc00);
+                }
+            }
+        }
+        catch (error) {
+            console.error('UTF-8 解码错误:', error);
+            return '';
+        }
+        return out;
+    }
+    /** @internal */
+    static stringToUtf8Array(str) {
+        if (!str || str.length === 0) {
+            return new Uint8Array(0);
+        }
+        const arr = [];
+        try {
+            for (let i = 0; i < str.length; i++) {
+                let charcode = str.charCodeAt(i);
+                if (charcode < 0x80) {
+                    arr.push(charcode);
+                }
+                else if (charcode < 0x800) {
+                    arr.push(0xc0 | (charcode >> 6));
+                    arr.push(0x80 | (charcode & 0x3f));
+                }
+                else if (charcode < 0xd800 || charcode >= 0xe000) {
+                    arr.push(0xe0 | (charcode >> 12));
+                    arr.push(0x80 | ((charcode >> 6) & 0x3f));
+                    arr.push(0x80 | (charcode & 0x3f));
+                }
+                else {
+                    // surrogate pair
+                    if (i + 1 >= str.length) {
+                        // 不完整的代理对
+                        break;
+                    }
+                    i++;
+                    charcode = ((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff);
+                    charcode += 0x10000;
+                    arr.push(0xf0 | (charcode >> 18));
+                    arr.push(0x80 | ((charcode >> 12) & 0x3f));
+                    arr.push(0x80 | ((charcode >> 6) & 0x3f));
+                    arr.push(0x80 | (charcode & 0x3f));
+                }
+            }
+        }
+        catch (error) {
+            console.error('UTF-8 编码错误:', error);
+            return new Uint8Array(0);
+        }
+        return new Uint8Array(arr);
+    }
+}
+
+// const base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+class Crypt {
+    // Bit-wise rotation left
+    static rotl(n, b) {
+        return (n << b) | (n >>> (32 - b));
+    }
+    // Bit-wise rotation right
+    static rotr(n, b) {
+        return (n << (32 - b)) | (n >>> b);
+    }
+    // Swap big-endian to little-endian and vice versa
+    static endianNumber(n) {
+        return (Crypt.rotl(n, 8) & 0x00ff00ff) | (Crypt.rotl(n, 24) & 0xff00ff00);
+    }
+    // Swap big-endian to little-endian and vice versa
+    static endianArray(n) {
+        for (let i = 0, l = n.length; i < l; i++) {
+            n[i] = Crypt.endianNumber(n[i]);
+        }
+        return n;
+    }
+    // Generate an array of any length of random bytes
+    static randomBytes(n) {
+        const bytes = [];
+        for (; n > 0; n--) {
+            bytes.push(Math.floor(Math.random() * 256));
+        }
+        return bytes;
+    }
+    // Convert a byte array to big-endian 32-bit words
+    static bytesToWords(bytes) {
+        const words = [];
+        for (let i = 0, b = 0, l = bytes.length; i < l; i++, b += 8) {
+            words[b >>> 5] |= bytes[i] << (24 - (b % 32));
+        }
+        return words;
+    }
+    // Convert big-endian 32-bit words to a byte array
+    static wordsToBytes(words) {
+        const bytes = [];
+        for (let b = 0, l = words.length * 32; b < l; b += 8) {
+            bytes.push((words[b >>> 5] >>> (24 - (b % 32))) & 0xff);
+        }
+        return bytes;
+    }
+    // Convert a byte array to a hex string
+    static bytesToHex(bytes) {
+        const hex = [];
+        for (let i = 0, l = bytes.length; i < l; i++) {
+            hex.push((bytes[i] >>> 4).toString(16));
+            hex.push((bytes[i] & 0xf).toString(16));
+        }
+        return hex.join("");
+    }
+    // Convert a hex string to a byte array
+    static hexToBytes(hex) {
+        const bytes = [];
+        for (let c = 0, l = hex.length; c < l; c += 2) {
+            bytes.push(parseInt(hex.substr(c, 2), 16));
+        }
+        return bytes;
+    }
+}
+// Convert a string to a byte array
+function stringToBytes(str) {
+    str = unescape(encodeURIComponent(str));
+    const bytes = [];
+    for (let i = 0, l = str.length; i < l; i++) {
+        bytes.push(str.charCodeAt(i) & 0xff);
+    }
+    return bytes;
+}
+// The core
+const md5Lib = function (message) {
+    const bytes = stringToBytes(message);
+    const m = Crypt.bytesToWords(bytes), l = bytes.length * 8;
+    let ml = m.length;
+    let a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+    // Swap endian
+    for (let i = 0; i < ml; i++) {
+        m[i] = (((m[i] << 8) | (m[i] >>> 24)) & 0x00ff00ff) | (((m[i] << 24) | (m[i] >>> 8)) & 0xff00ff00);
+    }
+    // Padding
+    m[l >>> 5] |= 0x80 << l % 32;
+    m[(((l + 64) >>> 9) << 4) + 14] = l;
+    // Method shortcuts
+    const FF = md5Lib._ff, GG = md5Lib._gg, HH = md5Lib._hh, II = md5Lib._ii;
+    ml = m.length;
+    for (let i = 0; i < ml; i += 16) {
+        const aa = a, bb = b, cc = c, dd = d;
+        a = FF(a, b, c, d, m[i + 0], 7, -680876936);
+        d = FF(d, a, b, c, m[i + 1], 12, -389564586);
+        c = FF(c, d, a, b, m[i + 2], 17, 606105819);
+        b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
+        a = FF(a, b, c, d, m[i + 4], 7, -176418897);
+        d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
+        c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
+        b = FF(b, c, d, a, m[i + 7], 22, -45705983);
+        a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
+        d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
+        c = FF(c, d, a, b, m[i + 10], 17, -42063);
+        b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
+        a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
+        d = FF(d, a, b, c, m[i + 13], 12, -40341101);
+        c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
+        b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
+        a = GG(a, b, c, d, m[i + 1], 5, -165796510);
+        d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
+        c = GG(c, d, a, b, m[i + 11], 14, 643717713);
+        b = GG(b, c, d, a, m[i + 0], 20, -373897302);
+        a = GG(a, b, c, d, m[i + 5], 5, -701558691);
+        d = GG(d, a, b, c, m[i + 10], 9, 38016083);
+        c = GG(c, d, a, b, m[i + 15], 14, -660478335);
+        b = GG(b, c, d, a, m[i + 4], 20, -405537848);
+        a = GG(a, b, c, d, m[i + 9], 5, 568446438);
+        d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
+        c = GG(c, d, a, b, m[i + 3], 14, -187363961);
+        b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
+        a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
+        d = GG(d, a, b, c, m[i + 2], 9, -51403784);
+        c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
+        b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
+        a = HH(a, b, c, d, m[i + 5], 4, -378558);
+        d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
+        c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
+        b = HH(b, c, d, a, m[i + 14], 23, -35309556);
+        a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
+        d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
+        c = HH(c, d, a, b, m[i + 7], 16, -155497632);
+        b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
+        a = HH(a, b, c, d, m[i + 13], 4, 681279174);
+        d = HH(d, a, b, c, m[i + 0], 11, -358537222);
+        c = HH(c, d, a, b, m[i + 3], 16, -722521979);
+        b = HH(b, c, d, a, m[i + 6], 23, 76029189);
+        a = HH(a, b, c, d, m[i + 9], 4, -640364487);
+        d = HH(d, a, b, c, m[i + 12], 11, -421815835);
+        c = HH(c, d, a, b, m[i + 15], 16, 530742520);
+        b = HH(b, c, d, a, m[i + 2], 23, -995338651);
+        a = II(a, b, c, d, m[i + 0], 6, -198630844);
+        d = II(d, a, b, c, m[i + 7], 10, 1126891415);
+        c = II(c, d, a, b, m[i + 14], 15, -1416354905);
+        b = II(b, c, d, a, m[i + 5], 21, -57434055);
+        a = II(a, b, c, d, m[i + 12], 6, 1700485571);
+        d = II(d, a, b, c, m[i + 3], 10, -1894986606);
+        c = II(c, d, a, b, m[i + 10], 15, -1051523);
+        b = II(b, c, d, a, m[i + 1], 21, -2054922799);
+        a = II(a, b, c, d, m[i + 8], 6, 1873313359);
+        d = II(d, a, b, c, m[i + 15], 10, -30611744);
+        c = II(c, d, a, b, m[i + 6], 15, -1560198380);
+        b = II(b, c, d, a, m[i + 13], 21, 1309151649);
+        a = II(a, b, c, d, m[i + 4], 6, -145523070);
+        d = II(d, a, b, c, m[i + 11], 10, -1120210379);
+        c = II(c, d, a, b, m[i + 2], 15, 718787259);
+        b = II(b, c, d, a, m[i + 9], 21, -343485551);
+        a = (a + aa) >>> 0;
+        b = (b + bb) >>> 0;
+        c = (c + cc) >>> 0;
+        d = (d + dd) >>> 0;
+    }
+    return Crypt.endianArray([a, b, c, d]);
+};
+// Auxiliary functions
+// eslint-disable-next-line max-params
+md5Lib._ff = function (a, b, c, d, x, s, t) {
+    const n = a + ((b & c) | (~b & d)) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+};
+// eslint-disable-next-line max-params
+md5Lib._gg = function (a, b, c, d, x, s, t) {
+    const n = a + ((b & d) | (c & ~d)) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+};
+// eslint-disable-next-line max-params
+md5Lib._hh = function (a, b, c, d, x, s, t) {
+    const n = a + (b ^ c ^ d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+};
+// eslint-disable-next-line max-params
+md5Lib._ii = function (a, b, c, d, x, s, t) {
+    const n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+};
+/**
+ * 对字符串执行md5处理
+ *
+ * @export
+ * @param {string} message 要处理的字符串
+ * @returns {string} md5
+ */
+function md5(message) {
+    if (message === undefined || message === null) {
+        throw new Error("Illegal argument " + message);
+    }
+    return Crypt.bytesToHex(Crypt.wordsToBytes(md5Lib(message)));
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-04-11
+ * @Description:
+ */
+class Utils {
+    /**
+     * 版本号比较
+     * @param version1 本地版本号
+     * @param version2 远程版本号
+     * 如果返回值大于0，则version1大于version2
+     * 如果返回值等于0，则version1等于version2
+     * 如果返回值小于0，则version1小于version2
+     */
+    static compareVersion(version1, version2) {
+        let v1 = version1.split('.');
+        let v2 = version2.split('.');
+        const len = Math.max(v1.length, v2.length);
+        while (v1.length < len) {
+            v1.push('0');
+        }
+        while (v2.length < len) {
+            v2.push('0');
+        }
+        for (let i = 0; i < len; ++i) {
+            let num1 = parseInt(v1[i]);
+            let num2 = parseInt(v2[i]);
+            if (num1 > num2) {
+                return 1;
+            }
+            else if (num1 < num2) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+    /**
+     * 判断传入的字符串是否是json格式的字符串
+     */
+    static isJsonString(str) {
+        try {
+            JSON.parse(str);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * 获取url参数
+     * @param url
+     */
+    static getUrlParam(url) {
+        let result = { url: "", params: {} };
+        let urlArr = url.split('?');
+        result.url = urlArr[0];
+        if (urlArr.length > 1) {
+            let paramsArr = urlArr[1].split("&");
+            for (let i = 0; i < paramsArr.length; i++) {
+                let item = paramsArr[i];
+                let [key, value] = item.split("=");
+                result.params[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * 给url添加参数
+     * @param url
+     * @returns 新的url
+     */
+    static addUrlParam(url, key, value) {
+        let urlData = this.getUrlParam(url);
+        urlData.params[key] = value;
+        return urlData.url + "?" + Object.entries(urlData.params).map(([key, value]) => `${key}=${value}`).join("&");
+    }
+}
+
+function defaultEquals(a, b) {
+    return a === b;
+}
+/** 单链表结结构节点 */
+class LinkedNode {
+    constructor(element) {
+        this.element = element;
+        this.next = undefined;
+    }
+}
+/** 双向链表结结构节点 */
+class DoublyNode extends LinkedNode {
+    constructor(element) {
+        super(element);
+        this.prev = undefined;
+    }
+}
+/** 单向链表 */
+class LinkedList {
+    /**
+     * create
+     * @param equalsFn 比较是否相等（支持自定义）
+     */
+    constructor(equalsFn) {
+        this._equalsFn = equalsFn || defaultEquals;
+        this._count = 0;
+        this._head = undefined;
+    }
+    /** 向链表尾部添加元素 */
+    push(element) {
+        const node = new LinkedNode(element);
+        let current;
+        if (this._head === undefined) {
+            this._head = node;
+        }
+        else {
+            current = this._head;
+            while (current.next !== undefined) {
+                current = current.next;
+            }
+            current.next = node;
+        }
+        this._count++;
+    }
+    /**
+     * 在链表的指定位置插入一个元素。
+     * @param element 要插入的元素。
+     * @param index 插入位置的索引，从0开始计数。
+     * @returns 如果插入成功返回true，否则返回false。
+     */
+    insert(element, index) {
+        if (index >= 0 && index <= this._count) {
+            const node = new LinkedNode(element);
+            if (index === 0) {
+                const current = this._head;
+                node.next = current;
+                this._head = node;
+            }
+            else {
+                const previous = this.getElementAt(index - 1);
+                const current = previous.next;
+                node.next = current;
+                previous.next = node;
+            }
+            this._count++;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 获取链表中指定位置的元素，如果不存在返回 underfined
+     * @param index
+     */
+    getElementAt(index) {
+        if (index >= 0 && index <= this._count) {
+            let node = this._head;
+            for (let i = 0; i < index && node !== undefined; i++) {
+                node = node.next;
+            }
+            return node;
+        }
+        return undefined;
+    }
+    /**
+     * 从链表中移除一个元素
+     * @param element
+     */
+    remove(element) {
+        return this.removeAt(this.indexOf(element));
+    }
+    /**
+     * 从链表的特定位置移除一个元素
+     * @param index
+     */
+    removeAt(index) {
+        if (index >= 0 && index < this._count) {
+            let current = this._head;
+            if (index === 0) {
+                this._head = current.next;
+            }
+            else {
+                const previous = this.getElementAt(index - 1);
+                current = previous.next;
+                previous.next = current.next;
+            }
+            this._count--;
+            current.next = undefined;
+            return current.element;
+        }
+        return undefined;
+    }
+    /**
+     * 返回元素在链表中的索引，如果没有则返回-1
+     * @param element
+     */
+    indexOf(element) {
+        let current = this._head;
+        for (let i = 0; i < this._count && current !== undefined; i++) {
+            if (this._equalsFn(element, current.element)) {
+                return i;
+            }
+            current = current.next;
+        }
+        return -1;
+    }
+    clear() {
+        this._head = undefined;
+        this._count = 0;
+    }
+    getHead() {
+        return this._head;
+    }
+    isEmpty() {
+        return this.size() === 0;
+    }
+    size() {
+        return this._count;
+    }
+    toString() {
+        if (this._head === undefined) {
+            return "";
+        }
+        let objString = `${this._head.element}`;
+        let current = this._head.next;
+        for (let i = 0; i < this.size() && current !== undefined; i++) {
+            objString = `${objString},${current.element}`;
+            current = current.next;
+        }
+        return objString;
+    }
+}
+/** 双向链表 */
+class DoublyLinkedList extends LinkedList {
+    /**
+     * create
+     * @param equalsFn 比较是否相等（支持自定义）
+     */
+    constructor(equalsFn) {
+        super(equalsFn);
+        this._tail = undefined;
+    }
+    /**
+     * 向链表尾部添加元素
+     * @param element
+     */
+    push(element) {
+        this.insert(element, this._count);
+    }
+    /**
+     * 向链表指定位置添加元素
+     * @param element
+     * @param index
+     */
+    insert(element, index) {
+        if (index >= 0 && index <= this._count) {
+            const node = new DoublyNode(element);
+            let current = this._head;
+            if (index === 0) {
+                if (this._head === undefined) {
+                    this._head = node;
+                    this._tail = node;
+                }
+                else {
+                    node.next = current;
+                    current.prev = node;
+                    this._head = node;
+                }
+            }
+            else if (index === this._count) {
+                current = this._tail;
+                current.next = node;
+                node.prev = current;
+                this._tail = node;
+            }
+            else {
+                const previous = this.getElementAt(index - 1);
+                current = previous.next;
+                node.next = current;
+                previous.next = node;
+                current.prev = node;
+                node.prev = previous;
+            }
+            this._count++;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 从链表的特定位置移除一个元素
+     * @param index
+     */
+    removeAt(index) {
+        if (index >= 0 && index < this._count) {
+            let current = this._head;
+            if (index === 0) {
+                this._head = current.next;
+                if (this._count === 1) {
+                    this._tail = undefined;
+                }
+                else {
+                    this._head.prev = undefined;
+                }
+            }
+            else if (index === this._count - 1) {
+                current = this._tail;
+                this._tail = current.prev;
+                this._tail.next = undefined;
+            }
+            else {
+                current = this.getElementAt(index);
+                const previous = current.prev;
+                previous.next = current.next;
+                current.next.prev = previous;
+            }
+            this._count--;
+            current.next = undefined;
+            current.prev = undefined;
+            return current.element;
+        }
+        return null;
+    }
+    /**
+     * 获取链表中指定位置的元素，如果不存在返回 null
+     * @param index
+     */
+    getElementAt(index) {
+        if (index >= 0 && index <= this._count) {
+            if (index > this._count * 0.5) {
+                // 从后向前找
+                let node = this._tail;
+                for (let i = this._count - 1; i > index && node !== undefined; i--) {
+                    node = node.prev;
+                }
+                return node;
+            }
+            else {
+                // 从前向后找
+                let node = this._head;
+                for (let i = 0; i < index && node !== undefined; i++) {
+                    node = node.next;
+                }
+                return node;
+            }
+        }
+        return undefined;
+    }
+    getHead() {
+        return this._head;
+    }
+    getTail() {
+        return this._tail;
+    }
+    clear() {
+        this._head = undefined;
+        this._tail = undefined;
+        this._count = 0;
+    }
+}
+
+class Stack {
+    constructor(equalsFn) {
+        this._items = new DoublyLinkedList(equalsFn);
+    }
+    push(element) {
+        this._items.push(element);
+    }
+    pop() {
+        if (this.isEmpty()) {
+            return undefined;
+        }
+        return this._items.removeAt(this.size() - 1);
+    }
+    peek() {
+        if (this.isEmpty()) {
+            return undefined;
+        }
+        return this._items.getTail().element;
+    }
+    size() {
+        return this._items.size();
+    }
+    isEmpty() {
+        return this._items.isEmpty();
+    }
+    clear() {
+        this._items.clear();
+    }
+    toString() {
+        return this._items.toString();
+    }
+}
+
+export { Adapter, Binary, BinaryHeap, CocosEntry, DoublyLinkedList, DoublyNode, GlobalTimer, HeapNode, InnerTimer, LinkedList, LinkedNode, Module, Platform, PlatformType, Screen, Stack, Time, Utils, debug, enableDebugMode, error, info, log, md5, warn };