first commit

.gitignore

@@ -0,0 +1,9 @@
+# 文件
+.DS_Store
+package-lock.json
+
+# 文件夹
+.vscode/
+node_modules/
+dist/
+build/

.npmignore

@@ -0,0 +1,5 @@
+# 文件夹
+node_modules/
+libs/
+build/
+src/

package.json

@@ -0,0 +1,57 @@
+{
+    "name": "kunpocc",
+    "version": "1.0.18",
+    "type": "module",
+    "description": "基于creator3.0+的kunpocc库",
+    "main": "./dist/kunpocc.cjs",
+    "module": "./dist/kunpocc.mjs",
+    "types": "./dist/kunpocc.d.ts",
+    "exports": {
+        ".": {
+            "require": "./dist/kunpocc.cjs",
+            "import": "./dist/kunpocc.mjs",
+            "types": "./dist/kunpocc.d.ts",
+            "default": "./dist/kunpocc.cjs"
+        },
+        "./min": {
+            "require": "./dist/kunpocc.min.cjs",
+            "import": "./dist/kunpocc.min.mjs"
+        }
+    },
+    "scripts": {
+        "clean": "rm -rf dist",
+        "build": "npm run clean && rollup -c rollup.config.mjs",
+        "copy": "cp -r dist/* /Users/gongxh/work/kunpo-lib/KunpoDemo/node_modules/kunpocc/dist/",
+        "build:all": "npm run build && npm run copy"
+    },
+    "files": [
+        "dist/kunpocc.cjs",
+        "dist/kunpocc.mjs",
+        "dist/kunpocc.min.cjs",
+        "dist/kunpocc.min.mjs",
+        "dist/kunpocc.d.ts"
+    ],
+    "author": "gongxh",
+    "license": "ISC",
+    "repository": {
+        "type": "gitlab",
+        "url": "https://git.lanfeitech.com/gongxinhai/kunpolibrary/-/tree/main/KunpoLib"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "dependencies": {
+        "fairygui-cc": "^1.2.2"
+    },
+    "devDependencies": {
+        "@cocos/creator-types": "^3.8.0",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.2",
+        "@types/lodash": "^4.17.13",
+        "@types/node": "^22.10.2",
+        "rollup": "^4.28.1",
+        "rollup-plugin-dts": "^6.1.1",
+        "ts-node": "^10.9.2",
+        "tslib": "^2.6.2"
+    }
+}

rollup.config.mjs

@@ -0,0 +1,62 @@
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+import dts from 'rollup-plugin-dts';
+
+export default [
+    {
+        // 生成未压缩的 JS 文件
+        input: 'src/kunpocc.ts',
+        external: ['cc', 'fairygui-cc'],
+        output: [
+            {
+                file: 'dist/kunpocc.mjs',
+                format: 'esm',
+                name: 'kunpocc'
+            },
+            {
+                file: 'dist/kunpocc.cjs',
+                format: 'cjs',
+                name: 'kunpocc'
+            }
+        ],
+        plugins: [
+            typescript({
+                tsconfig: './tsconfig.json',
+                importHelpers: false
+            })
+        ]
+    },
+    {
+        // 生成压缩的 JS 文件
+        input: 'src/kunpocc.ts',
+        external: ['cc', 'fairygui-cc'],
+        output: [
+            {
+                file: 'dist/kunpocc.min.mjs',
+                format: 'esm',
+                name: 'kunpocc'
+            },
+            {
+                file: 'dist/kunpocc.min.cjs',
+                format: 'cjs',
+                name: 'kunpocc'
+            }
+        ],
+        plugins: [
+            typescript({
+                tsconfig: './tsconfig.json',
+                importHelpers: false
+            }),
+            terser()
+        ]
+    },
+    {
+        // 生成声明文件的配置
+        input: 'src/kunpocc.ts',
+        output: {
+            file: 'dist/kunpocc.d.ts',
+            format: 'es'
+        },
+        plugins: [dts()]
+    }
+]; 

src/asset/AssetLoader.ts

@@ -0,0 +1,251 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-11
+ * @Description: 资源加载器
+ */
+
+import { Asset, AssetManager, resources } from "cc";
+import { log } from "../tool/log";
+import { MathTool } from "../tool/Math";
+import { AssetPool } from "./AssetPool";
+import { AssetUtils } from "./AssetUtils";
+
+export interface IAssetConfig {
+    /** 资源类型 */
+    type: typeof Asset;
+    /** 资源路径 */
+    path: string;
+    /** 是否是单个文件 默认是文件夹 */
+    isFile?: boolean;
+    /** 资源包名 默认 resources */
+    bundle?: string;
+}
+
+/** 资源加载的状态类型 */
+enum StateType {
+    Error,
+    Wait,
+    Loading,
+    Finish,
+}
+
+export class AssetLoader {
+    /** 资源加载器名称 */
+    private _name: string = "";
+    /** 资源总数 */
+    private _total: number = 0;
+    /** 最大并行加载数量 */
+    private _maxParallel: number = 10;
+    /** 当前并行加载数量 */
+    private _parallel: number = 0;
+    /** 失败重试次数 */
+    private _maxRetry: number = 3;
+    /** 失败重试次数 */
+    private _retry: number = 0;
+
+    /** 获取资源数量是否成功 */
+    private _initSuccess: boolean = false;
+
+    private _progress: (percent: number) => void;
+
+    private _complete: () => void;
+    private _fail: (msg: string, err: Error) => void;
+
+    private _configs: IAssetConfig[] = [];
+    private _items: { type: typeof Asset, bundle: string, path: string, isFile?: boolean, status: StateType, count: number }[] = [];
+    /** load完成数量 */
+    private _completeCounts: Map<string, number> = new Map();
+    constructor(name?: string) {
+        this._name = name || "AssetLoader";
+    }
+
+    /**
+     * 开始加载资源
+     * @param {IAssetConfig[]} res.configs 资源配置
+     * @param {number} res.parallel 并行加载数量 默认 10
+     * @param {number} res.retry 失败重试次数 默认 3
+     * @param {Function} res.complete 加载完成回调
+     * @param {Function} res.progress 加载进度回调
+     * @param {Function} res.fail 加载失败回调
+     */
+    public start(res: { configs: IAssetConfig[], parallel?: number, retry?: number, complete: () => void, fail: (msg: string, err: Error) => void, progress?: (percent: number) => void }): void {
+        this._configs = res.configs;
+        this._maxParallel = res.parallel || 10;
+        this._maxRetry = res.retry || 3;
+        this._complete = res.complete;
+        this._progress = res.progress;
+        this._fail = res.fail;
+
+        this._total = 0;
+        this._initSuccess = false;
+        this._items.length = 0;
+
+        let initCount = res.configs.length;
+        for (const item of res.configs) {
+            let bundlename = item.bundle || "resources";
+            let count = 0;
+            if (bundlename == "resources") {
+                count = AssetUtils.getResourceCount(item.path, item.type);
+                this._total += count;
+
+                this._items.push({ type: item.type, bundle: item.bundle || "resources", path: item.path, isFile: item.isFile || false, status: StateType.Wait, count: count })
+                initCount--;
+
+                initCount <= 0 && this.initSuccess();
+            } else {
+                AssetUtils.loadBundle(bundlename).then((bundle: AssetManager.Bundle) => {
+                    count = AssetUtils.getResourceCount(item.path, item.type, bundle);
+                    this._total += count;
+
+                    this._items.push({ type: item.type, bundle: item.bundle || "resources", path: item.path, isFile: item.isFile || false, status: StateType.Wait, count: count })
+                    initCount--;
+
+                    initCount <= 0 && this.initSuccess();
+                }).catch((err: Error) => {
+                    if (this._retry < this._maxRetry) {
+                        this.retryStart();
+                    } else {
+                        this._fail(`加载资源包[${bundlename}]失败`, err);
+                    }
+                });
+            }
+        }
+    }
+
+    /** 重试 (重新加载失败的资源) */
+    public retry(): void {
+        this._parallel = 0;
+        this._retry = 0;
+        if (!this._initSuccess) {
+            this.retryStart();
+        } else {
+            this.retryLoad();
+        }
+    }
+
+    /** 重试开始 */
+    private retryStart(): void {
+        this._retry++;
+        this.start({
+            configs: this._configs,
+            parallel: this._maxParallel,
+            retry: this._maxRetry,
+            complete: this._complete,
+            fail: this._fail,
+            progress: this._progress
+        });
+    }
+
+    /** 重试加载资源 */
+    private retryLoad(): void {
+        this._retry++;
+        let count = this.resetErrorItem();
+        let maxLoad = Math.min(count, this._maxParallel);
+        for (let i = 0; i < maxLoad; i++) {
+            this.loadNext();
+        }
+    }
+
+    /** 初始化成功后，开始批量加载资源 */
+    private initSuccess(): void {
+        this._initSuccess = true;
+        this._parallel = 0;
+        let maxLoad = Math.min(this._items.length, this._maxParallel);
+        for (let i = 0; i < maxLoad; i++) {
+            this.loadNext();
+        }
+    }
+
+    /** 加载下一个资源 */
+    private loadNext(): void {
+        // 找到第一个等待中的资源
+        let index = this._items.findIndex(item => item.status == StateType.Wait);
+        if (index > -1) {
+            this.loadItem(index);
+        } else if (!this._items.some(item => item.status != StateType.Finish)) {
+            // 所有资源全部完成了
+            this._complete();
+        } else if (this._parallel <= 0 && this._retry < this._maxRetry) {
+            this.retryLoad();
+        }
+    }
+
+    /** 重置失败资源状态为等待中 */
+    private resetErrorItem(): number {
+        let count = 0;
+        for (const item of this._items) {
+            if (item.status == StateType.Error) {
+                item.status = StateType.Wait;
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private async loadItem(index: number): Promise<void> {
+        let item = this._items[index];
+        item.status = StateType.Loading;
+        this._parallel++;
+
+        let bundle = null;
+        if (item.bundle == "resources") {
+            bundle = resources;
+        } else {
+            bundle = await AssetUtils.loadBundle(item.bundle);
+        }
+        if (item.isFile) {
+            this.loadFile(index, bundle);
+        } else {
+            this.loadDir(index, bundle);
+        }
+    }
+
+    private loadDir(index: number, bundle: AssetManager.Bundle): void {
+        let item = this._items[index];
+        bundle.loadDir(item.path, item.type, (finish: number, total: number) => {
+            if (total > 0 && finish > 0) {
+                this._completeCounts.set(`${item.bundle}:${item.path}`, finish);
+                this._progress && this.updateProgress();
+            }
+        }, (error: Error, assets: Array<Asset>) => {
+            this._parallel--;
+            if (error) {
+                log(`load dir error, bundle:${item.bundle}, dir:${item.path}`);
+                item.status = StateType.Error;
+            } else {
+                item.status = StateType.Finish;
+                this._completeCounts.set(`${item.bundle}:${item.path}`, assets.length);
+                AssetPool.add(assets, bundle);
+            }
+            this._progress && this.updateProgress();
+            this.loadNext();
+        });
+    }
+
+    private loadFile(index: number, bundle: AssetManager.Bundle): void {
+        let item = this._items[index];
+        bundle.load(item.path, item.type, (error: Error, asset: Asset) => {
+            this._parallel--;
+            if (error) {
+                log(`load file error, bundle:${item.bundle}, filename:${item.path}`);
+                item.status = StateType.Error;
+            } else {
+                item.status = StateType.Finish;
+                this._completeCounts.set(`${item.bundle}:${item.path}`, 1);
+                AssetPool.add(asset, bundle);
+            }
+
+            this._progress && this.updateProgress();
+            this.loadNext();
+        });
+    }
+
+    /** 更新进度 */
+    private updateProgress(): void {
+        let value = 0;
+        for (const count of this._completeCounts.values()) {
+            value += count;
+        }
+        this._progress(MathTool.clampf(value / this._total, 0, 1));
+    }
+}

src/asset/AssetPool.ts

@@ -0,0 +1,118 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-11
+ * @Description: 资源池
+ */
+
+import { Asset, AssetManager, resources } from "cc";
+import { log } from "../tool/log";
+import { AssetUtils } from "./AssetUtils";
+
+export class AssetPool {
+    private static _assets: { [path: string]: Asset } = {};
+    private static _uuidToName: Map<string, string> = new Map();
+
+    /** 批量添加资源 */
+    public static add(asset: Asset[] | Asset, bundle: AssetManager.Bundle = resources): void {
+        if (Array.isArray(asset)) {
+            for (const item of asset) {
+                this.add(item, bundle);
+            }
+        } else {
+            let uuid = asset.uuid;
+            if (this._uuidToName.has(uuid)) {
+                return;
+            }
+            // 增加引用计数
+            asset.addRef();
+            let info = bundle.getAssetInfo(uuid);
+            let key = this.getKey(info.path, bundle.name);
+            // log(`>>>uuid:${uuid}, path:${info.path}`);
+            this._uuidToName.set(uuid, key);
+            this._assets[key] = asset;
+        }
+    }
+
+    public static has(path: string, bundlename: string = "resources"): boolean {
+        let key = this.getKey(path, bundlename);
+        if (!this._assets[key]) {
+            return false;
+        }
+        return true;
+    }
+
+    public static get<T extends Asset>(path: string, bundlename: string = "resources"): T {
+        let key = this.getKey(path, bundlename);
+        if (!this._assets[key]) {
+            log(`获取资源失败: 资源 bundle:${bundlename}, path:${path} 未加载`);
+        }
+        return this._assets[key] as T;
+    }
+
+    /** 按 uuid 判断资源是否存在 */
+    public static hasUUID(uuid: string): boolean {
+        if (!this._uuidToName.has(uuid)) {
+            return false;
+        }
+        return true;
+    }
+
+    /** 按 uuid 获取资源 */
+    public static getByUUID<T extends Asset>(uuid: string): T {
+        if (!this._uuidToName.has(uuid)) {
+            log(`获取资源失败: 资源 uuid:${uuid} 未加载`);
+        }
+        let key = this._uuidToName.get(uuid);
+        return this._assets[key] as T;
+    }
+
+    /** 按资源路径释放资源 */
+    public static releasePath(path: string, bundlename: string = "resources"): void {
+        let key = this.getKey(path, bundlename);
+        this.release(key);
+    }
+
+    /** 按 bundle 和 文件夹释放资源 */
+    public static async releaseDir(dir: string, bundlename: string = "resources", asset: typeof Asset): Promise<void> {
+        let bundle = null;
+        if (bundlename == "resources") {
+            bundle = resources;
+        } else {
+            bundle = await AssetUtils.loadBundle(bundlename);
+        }
+        let uuids = AssetUtils.getUUIDs(dir, asset, bundle);
+        for (const uuid of uuids) {
+            this.releaseUUID(uuid);
+        }
+    }
+
+    /** 按 uuid 释放资源 */
+    public static releaseUUID(uuid: string): void {
+        if (this._uuidToName.has(uuid)) {
+            let key = this._uuidToName.get(uuid);
+            this.release(key);
+        }
+    }
+
+    private static release(key: string): void {
+        if (this._assets[key]) {
+            this._uuidToName.delete(this._assets[key].uuid);
+
+            this._assets[key].decRef();
+            delete this._assets[key];
+        }
+    }
+
+    /** 释放所有加载的资源 */
+    public static releaseAll(): void {
+        for (const key in this._assets) {
+            this._assets[key].decRef();
+        }
+        this._assets = {};
+        this._uuidToName.clear();
+    }
+
+    private static getKey(path: string, bundlename: string = "resources"): string {
+        return `${bundlename}:${path}`;
+    }
+}

src/asset/AssetUtils.ts

@@ -0,0 +1,52 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-11
+ * @Description: 资源工具类
+ */
+
+import { Asset, AssetManager, assetManager, resources } from "cc";
+
+
+export class AssetUtils {
+    /** 获取资源数量 */
+    public static getResourceCount(dir: string, type: typeof Asset, bundle: AssetManager.Bundle = resources): number {
+        dir = assetManager.utils.normalize(dir);
+        if (dir[dir.length - 1] === "/") {
+            dir = dir.slice(0, -1);
+        }
+        let list = bundle.getDirWithPath(dir, type);
+        return list.length;
+    }
+
+    /** 获取资源名称 */
+    public static getUUIDs(dir: string, type: typeof Asset, bundle: AssetManager.Bundle = resources): string[] {
+        let uuids: string[] = [];
+        let path = assetManager.utils.normalize(dir);
+        if (path[path.length - 1] === "/") {
+            path = path.slice(0, -1);
+        }
+        let list = bundle.getDirWithPath(path, type);
+        for (const asset of list) {
+            uuids.push(asset.uuid);
+        }
+        return uuids;
+    }
+
+    /** 加载 bundle */
+    public static async loadBundle(bundlename: string): Promise<AssetManager.Bundle> {
+        return new Promise((resolve, reject) => {
+            let bundle = assetManager.getBundle(bundlename);
+            if (bundle) {
+                resolve(bundle);
+            } else {
+                assetManager.loadBundle(bundlename, (err: Error, bundle: AssetManager.Bundle) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(bundle);
+                    }
+                });
+            }
+        });
+    }
+}

src/behaviortree/Agent.ts

@@ -0,0 +1,42 @@
+import { BehaviorTree } from "./BehaviorTree";
+import { Blackboard } from "./Blackboard";
+import { Ticker } from "./Ticker";
+
+/** 代理 */
+export class Agent {
+    public tree: BehaviorTree;
+    public blackboard: Blackboard;
+    public ticker: Ticker;
+    /**
+     * constructor
+     * @param subject // 主体
+     * @param tree 行为树
+     */
+    constructor(subject: any, tree: BehaviorTree) {
+        this.tree = tree;
+        this.blackboard = new Blackboard();
+        this.ticker = new Ticker(subject, this.blackboard, tree);
+    }
+
+    public tick(): void {
+        this.tree.tick(this, this.blackboard, this.ticker);
+        if (this.blackboard.interrupt) {
+            this.blackboard.interrupt = false;
+
+            let ticker = this.ticker;
+            ticker.openNodes.length = 0;
+            ticker.nodeCount = 0;
+
+            this.blackboard.clear();
+        }
+    }
+
+    /**
+     * 打断行为树，重新开始执行（如果当前在节点中，下一帧才会清理）
+     */
+    public interruptBTree(): void {
+        if (!this.blackboard.interruptDefend) {
+            this.blackboard.interrupt = true;
+        }
+    }
+}

src/behaviortree/BTNode/Action.ts

@@ -0,0 +1,143 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { BaseNode } from "./BaseNode";
+
+/**
+ * 动作节点
+ * 没有子节点
+ */
+export abstract class Action extends BaseNode {
+    constructor() {
+        super();
+    }
+}
+
+/**
+ * 失败节点(无子节点)
+ * 直接返回FAILURE
+ */
+export class Failure extends Action {
+    private _func: () => void;
+    constructor(func: () => void) {
+        super();
+        this._func = func;
+    }
+
+    public tick(ticker: Ticker): Status {
+        this._func();
+        return Status.FAILURE;
+    }
+}
+
+/**
+ * 逻辑节点，一直执行 (无子节点)
+ * 直接返回RUNING
+ */
+export class Running extends Action {
+    private _func: () => void;
+    constructor(func: () => void) {
+        super();
+        this._func = func;
+    }
+
+    public tick(ticker: Ticker): Status {
+        this._func();
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 成功节点 无子节点
+ * 直接返回SUCCESS
+ */
+export class Success extends Action {
+    private _func: () => void;
+    constructor(func: () => void) {
+        super();
+        this._func = func;
+    }
+
+    public tick(ticker: Ticker): Status {
+        this._func();
+        return Status.SUCCESS;
+    }
+}
+/**
+ * 次数等待节点(无子节点)
+ * 次数内，返回RUNING
+ * 超次，返回SUCCESS
+ */
+export class WaitTicks extends Action {
+    /** 最大次数 */
+    private _maxTicks: number;
+    /** 经过的次数 */
+    private _elapsedTicks: number;
+    constructor(maxTicks: number = 0) {
+        super();
+        this._maxTicks = maxTicks;
+        this._elapsedTicks = 0;
+    }
+
+    public open(ticker: Ticker): void {
+        this._elapsedTicks = 0;
+    }
+
+    public tick(ticker: Ticker): Status {
+        if (++this._elapsedTicks >= this._maxTicks) {
+            this._elapsedTicks = 0;
+            return Status.SUCCESS;
+        }
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 时间等待节点(无子节点)
+ * 时间到后返回SUCCESS，否则返回RUNING
+ */
+export class WaitTime extends Action {
+    /** 等待时间(毫秒 ms) */
+    private _duration: number;
+    constructor(duration: number = 0) {
+        super();
+        this._duration = duration * 1000;
+    }
+
+    public open(ticker: Ticker): void {
+        let startTime = new Date().getTime();
+        ticker.blackboard.set("startTime", startTime, ticker.tree.id, this.id);
+    }
+
+    public tick(ticker: Ticker): Status {
+        let currTime = new Date().getTime();
+        let startTime = ticker.blackboard.get("startTime", ticker.tree.id, this.id);
+        if (currTime - startTime >= this._duration) {
+            return Status.SUCCESS;
+        }
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 行为树防止被打断节点
+ * 直接返回 SUCCESS
+ * 和 InterruptDefendCancel 必须成对出现
+ */
+export class InterruptDefend extends Action {
+    public tick(ticker: Ticker): Status {
+        ticker.blackboard.interruptDefend = true;
+        return Status.SUCCESS;
+    }
+}
+
+/**
+ * 行为树被打断取消节点
+ * 直接返回 SUCCESS
+ * 和 InterruptDefend 必须成对出现
+ */
+export class InterruptDefendCancel extends Action {
+    public tick(ticker: Ticker): Status {
+        ticker.blackboard.interruptDefend = false;
+        return Status.SUCCESS;
+    }
+}

src/behaviortree/BTNode/BaseNode.ts

@@ -0,0 +1,104 @@
+import { createUUID, Status } from "../header";
+import { Ticker } from "../Ticker";
+
+/**
+ * 基础节点
+ * 所有节点全部继承自 BaseNode
+ */
+export abstract class BaseNode {
+    /** 唯一标识 */
+    public id: string;
+    /** 子节点 */
+    public children: BaseNode[];
+
+    /**
+     * 创建
+     * @param children 子节点列表
+     */
+    constructor(children?: BaseNode[]) {
+        this.id = createUUID();
+        this.children = [];
+        if (!children) {
+            return;
+        }
+        for (let i = 0; i < children.length; i++) {
+            this.children.push(children[i]);
+        }
+    }
+
+    /** 执行节点 */
+    public _execute(ticker: Ticker): Status {
+        /* ENTER */
+        this._enter(ticker);
+        if (!ticker.blackboard.get("isOpen", ticker.tree.id, this.id)) {
+            this._open(ticker);
+        }
+        let status = this._tick(ticker);
+        if (status !== Status.RUNNING) {
+            this._close(ticker);
+        }
+        this._exit(ticker);
+        return status;
+    }
+
+    /**
+     * 进入节点
+     * @param ticker 更新器
+     */
+    public _enter(ticker: Ticker): void {
+        ticker.enterNode(this);
+        this.enter(ticker);
+    }
+
+    /**
+     * 打开节点
+     * @param ticker 更新器
+     */
+    public _open(ticker: Ticker): void {
+        ticker.openNode(this);
+        ticker.blackboard.set("isOpen", true, ticker.tree.id, this.id);
+        this.open(ticker);
+    }
+
+    /**
+     * 更新节点
+     * @param ticker 更新器
+     */
+    public _tick(ticker: Ticker): Status {
+        ticker.tickNode(this);
+        return this.tick(ticker);
+    }
+
+    /**
+     * 关闭节点
+     * @param ticker 更新器
+     */
+    public _close(ticker: Ticker): void {
+        ticker.closeNode(this);
+        ticker.blackboard.set("isOpen", false, ticker.tree.id, this.id);
+        this.close(ticker);
+    }
+
+    /**
+     * 退出节点
+     * @param ticker 更新器
+     */
+    public _exit(ticker: Ticker): void {
+        ticker.exitNode(this);
+        this.exit(ticker);
+    }
+
+    enter(ticker: Ticker): void {
+
+    }
+    open(ticker: Ticker): void {
+
+    }
+    close(ticker: Ticker): void {
+
+    }
+    exit(ticker: Ticker): void {
+
+    }
+    abstract tick(ticker: Ticker): Status;
+}

src/behaviortree/BTNode/Composite.ts

@@ -0,0 +1,163 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { BaseNode } from "./BaseNode";
+
+/**
+ * 可以包含多个节点的集合装饰器基类
+ *
+ */
+export abstract class Composite extends BaseNode {
+    constructor(...children: BaseNode[]) {
+        super(children);
+    }
+}
+
+/**
+ * 记忆选择节点
+ * 选择不为 FAILURE 的节点
+ * 任意一个Child Node返回不为 FAILURE, 本Node向自己的Parent Node也返回Child Node状态
+ */
+export class MemSelector extends Composite {
+    open(ticker: Ticker): void {
+        super.open(ticker);
+        ticker.blackboard.set("runningChild", 0, ticker.tree.id, this.id);
+    }
+
+    tick(ticker: Ticker): Status {
+        let childIndex = ticker.blackboard.get("runningChild", ticker.tree.id, this.id) as number;
+
+        for (let i = childIndex; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+
+            if (status !== Status.FAILURE) {
+                if (status === Status.RUNNING) {
+                    ticker.blackboard.set("runningChild", i, ticker.tree.id, this.id);
+                }
+                return status;
+            }
+        }
+
+        return Status.FAILURE;
+    }
+}
+
+/**
+ * 记忆顺序节点
+ * 如果上次执行到 RUNING 的节点, 下次进入节点后, 直接从 RUNING 节点开始
+ * 遇到 RUNING 或者 FAILURE 停止迭代
+ * 任意一个Child Node返回不为 SUCCESS, 本Node向自己的Parent Node也返回Child Node状态
+ * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ */
+export class MemSequence extends Composite {
+    open(ticker: Ticker): void {
+        super.open(ticker);
+        ticker.blackboard.set("runningChild", 0, ticker.tree.id, this.id);
+    }
+
+    tick(ticker: Ticker): Status {
+        let childIndex = ticker.blackboard.get("runningChild", ticker.tree.id, this.id) as number;
+        for (let i = childIndex; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status !== Status.SUCCESS) {
+                if (status === Status.RUNNING) {
+                    ticker.blackboard.set("runningChild", i, ticker.tree.id, this.id);
+                }
+                return status;
+            }
+        }
+        return Status.SUCCESS;
+    }
+}
+
+/**
+ * 随机选择节点
+ * 从Child Node中随机选择一个执行
+ */
+export class RandomSelector extends Composite {
+    tick(ticker: Ticker): Status {
+        let childIndex = (Math.random() * this.children.length) | 0;
+        let child = this.children[childIndex];
+        let status = child._execute(ticker);
+
+        return status;
+    }
+}
+
+/**
+ * 选择节点，选择不为 FAILURE 的节点
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 如遇到一个Child Node执行后返回 SUCCESS 或者 RUNING，那停止迭代，本Node向自己的Parent Node也返回 SUCCESS 或 RUNING
+ */
+export class Selector extends Composite {
+    tick(ticker: Ticker): Status {
+        for (let i = 0; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status !== Status.FAILURE) {
+                return status;
+            }
+        }
+        return Status.FAILURE;
+    }
+}
+
+/**
+ * 顺序节点
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 遇到 FAILURE 或 RUNING, 那停止迭代，返回FAILURE 或 RUNING
+ * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ */
+export class Sequence extends Composite {
+    public tick(ticker: Ticker): Status {
+        for (let i = 0; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status !== Status.SUCCESS) {
+                return status;
+            }
+        }
+        return Status.SUCCESS;
+    }
+}
+
+/**
+ * 并行节点 每次进入全部重新执行一遍
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 1. 当存在Child Node执行后返回 FAILURE, 本节点返回 FAILURE
+ * 2. 当存在Child Node执行后返回 RUNING, 本节点返回 RUNING
+ * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ */
+export class Parallel extends Composite {
+    public tick(ticker: Ticker): Status {
+        let result = Status.SUCCESS;
+        for (let i = 0; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status == Status.FAILURE) {
+                result = Status.FAILURE;
+            } else if (result == Status.SUCCESS && status == Status.RUNNING) {
+                result = Status.RUNNING;
+            }
+        }
+        return result;
+    }
+}
+
+/**
+ * 并行节点 每次进入全部重新执行一遍
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 1. 当存在Child Node执行后返回 FAILURE, 本节点返回 FAILURE
+ * 2. 任意 Child Node 返回 SUCCESS, 本节点返回 SUCCESS
+ * 否则返回 RUNNING
+ */
+export class ParallelAnySuccess extends Composite {
+    public tick(ticker: Ticker): Status {
+        let result = Status.RUNNING;
+        for (let i = 0; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status == Status.FAILURE) {
+                result = Status.FAILURE;
+            } else if (result == Status.RUNNING && status == Status.SUCCESS) {
+                result = Status.SUCCESS;
+            }
+        }
+        return result;
+    }
+}

src/behaviortree/BTNode/Condition.ts

@@ -0,0 +1,18 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { Action } from "./Action";
+
+/**
+ * 条件节点
+ */
+export class Condition extends Action {
+    private _func: (subject: any) => boolean = null;
+    constructor(func: (subject: any) => boolean) {
+        super();
+        this._func = func;
+    }
+
+    tick(ticker: Ticker): Status {
+        return this._func(ticker.subject) ? Status.SUCCESS : Status.FAILURE;
+    }
+}

src/behaviortree/BTNode/Decorator.ts

@@ -0,0 +1,288 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { BaseNode } from "./BaseNode";
+
+/**
+ * 修饰节点基类
+ * 只能包含一个子节点
+ */
+export abstract class Decorator extends BaseNode {
+    constructor(child: BaseNode) {
+        super([child]);
+    }
+}
+
+/**
+ * 失败节点
+ * 必须且只能包含一个子节点
+ * 直接返回 FAILURE
+ * @extends Decorator
+ */
+export class Failer extends Decorator {
+    public tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Failer)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        child._execute(ticker);
+        return Status.FAILURE;
+    }
+}
+
+/**
+ * 结果反转节点
+ * 必须且只能包含一个子节点
+ * 第一个Child Node节点, 返回 FAILURE, 本Node向自己的Parent Node也返回 SUCCESS
+ * 第一个Child Node节点, 返回 SUCCESS, 本Node向自己的Parent Node也返回 FAILURE
+ */
+export class Inverter extends Decorator {
+    tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Inverter)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        let status = child._execute(ticker);
+        if (status === Status.SUCCESS) {
+            status = Status.FAILURE;
+        } else if (status === Status.FAILURE) {
+            status = Status.SUCCESS;
+        }
+        return status;
+    }
+}
+
+/**
+ * 次数限制节点
+ * 必须且只能包含一个子节点
+ * 次数限制内, 根据Child Node的结果, 本Node向自己的Parent Node也返回相同的结果
+ * 次数超过后, 直接返回 FAILURE
+ */
+export class LimiterTicks extends Decorator {
+    /** 最大次数 */
+    private _maxTicks: number;
+    /** 当前执行过的次数 */
+    private _elapsedTicks: number;
+
+    /**
+     * 创建
+     * @param maxTicks 最大次数
+     * @param child 子节点
+     */
+    constructor(maxTicks: number, child: BaseNode) {
+        super(child);
+        this._maxTicks = maxTicks;
+        this._elapsedTicks = 0;
+    }
+
+    open(ticker: Ticker): void {
+        super.open(ticker);
+        this._elapsedTicks = 0;
+    }
+
+    tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(LimiterTicks)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        if (++this._elapsedTicks > this._maxTicks) {
+            this._elapsedTicks = 0;
+            return Status.FAILURE;
+        }
+        return child._execute(ticker);
+    }
+}
+
+/**
+ * 时间限制节点
+ * 只能包含一个子节点
+ * 规定时间内, 根据Child Node的结果, 本Node向自己的Parent Node也返回相同的结果
+ * 超时后, 直接返回 FAILURE
+ */
+export class LimiterTime extends Decorator {
+    /** 最大时间 (毫秒 ms) */
+    private _maxTime: number;
+
+    /**
+     * 时间限制节点
+     * @param maxTime 最大时间 (微秒ms)
+     * @param child 子节点
+     */
+    constructor(maxTime: number, child: BaseNode) {
+        super(child);
+        this._maxTime = maxTime * 1000;
+    }
+
+    open(ticker: Ticker): void {
+        super.open(ticker);
+        let startTime = new Date().getTime();
+        ticker.blackboard.set("startTime", startTime, ticker.tree.id, this.id);
+    }
+
+    tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(LimiterTime)节点必须包含一个子节点");
+        }
+
+        let child = this.children[0];
+        let currTime = new Date().getTime();
+        let startTime = ticker.blackboard.get("startTime", ticker.tree.id, this.id);
+
+        if (currTime - startTime > this._maxTime) {
+            return Status.FAILURE;
+        }
+
+        return child._execute(ticker);
+    }
+}
+
+/**
+ * 循环节点
+ * 必须且只能包含一个子节点
+ * 如果maxLoop < 0, 直接返回成功
+ * 否则等待次数超过之后, 返回Child Node的结果（RUNING的次数不计算在内）
+ */
+export class Repeater extends Decorator {
+    maxLoop: number;
+
+    constructor(child: BaseNode, maxLoop: number = -1) {
+        super(child);
+        this.maxLoop = maxLoop;
+    }
+
+    open(ticker: Ticker): void {
+        ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
+    }
+
+    tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Repeater)节点必须包含一个子节点");
+        }
+
+        let child = this.children[0];
+        let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
+        let status = Status.SUCCESS;
+
+        while (this.maxLoop < 0 || i < this.maxLoop) {
+            status = child._execute(ticker);
+
+            if (status === Status.SUCCESS || status === Status.FAILURE) {
+                i++;
+            } else {
+                break;
+            }
+        }
+
+        ticker.blackboard.set("i", i, ticker.tree.id, this.id);
+        return status;
+    }
+}
+
+/**
+ * 循环节点
+ * 只能包含一个子节点
+ * 如果maxLoop < 0, 直接返回成功
+ * 当Child Node返回 FAILURE, 本Node向自己的Parent Node返回 FAILURE
+ * 循环次数大于等于maxLoop时, 返回Child Node的结果
+ */
+export class RepeatUntilFailure extends Decorator {
+    maxLoop: number;
+
+    constructor(child: BaseNode, maxLoop: number = -1) {
+        super(child);
+        this.maxLoop = maxLoop;
+    }
+
+    open(ticker: Ticker): void {
+        ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
+    }
+
+    tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(RepeatUntilFailure)节点必须包含一个子节点");
+        }
+
+        let child = this.children[0];
+        let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
+        let status = Status.SUCCESS;
+
+        while (this.maxLoop < 0 || i < this.maxLoop) {
+            status = child._execute(ticker);
+
+            if (status === Status.SUCCESS) {
+                i++;
+            } else {
+                break;
+            }
+        }
+
+        ticker.blackboard.set("i", i, ticker.tree.id, this.id);
+        return status;
+    }
+}
+
+/**
+ * 循环节点(只能包含一个子节点)
+ * 如果maxLoop < 0, 直接返回失败
+ * 当Child Node返回 SUCCESS, 本Node向自己的Parent Node返回 SUCCESS
+ * 循环次数大于等于maxLoop时, 返回Child Node的结果
+ */
+export class RepeatUntilSuccess extends Decorator {
+    private _maxLoop: number;
+    constructor(child: BaseNode, maxLoop: number = -1) {
+        super(child);
+        this._maxLoop = maxLoop;
+    }
+
+    open(ticker: Ticker): void {
+        ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
+    }
+
+    tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(RepeatUntilSuccess)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
+        let status = Status.FAILURE;
+        while (this._maxLoop < 0 || i < this._maxLoop) {
+            status = child._execute(ticker);
+            if (status === Status.FAILURE) {
+                i++;
+            } else {
+                break;
+            }
+        }
+        ticker.blackboard.set("i", i, ticker.tree.id, this.id);
+        return status;
+    }
+}
+
+/**
+ * 逻辑节点, 一直执行(只能包含一个子节点)
+ * 直接返回 RUNING
+ */
+export class Runner extends Decorator {
+    public tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Runner)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        child._execute(ticker);
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 成功节点(包含一个子节点)
+ * 直接返回 SUCCESS
+ */
+export class Succeeder extends Decorator {
+    public tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Succeeder)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        child._execute(ticker);
+        return Status.SUCCESS;
+    }
+}

src/behaviortree/BehaviorTree.ts

@@ -0,0 +1,51 @@
+import { Blackboard } from "./Blackboard";
+import { BaseNode } from "./BTNode/BaseNode";
+import { createUUID } from "./header";
+import { Ticker } from "./Ticker";
+
+/**
+ * 行为树
+ * 所有节点全部添加到树中
+ */
+export class BehaviorTree {
+    /** 行为树ID */
+    private _id: string;
+    /** 行为树跟节点 */
+    private _root: BaseNode;
+    constructor(root: BaseNode) {
+        this._id = createUUID();
+        this._root = root;
+    }
+
+    public tick(subject: any, blackboard: Blackboard, ticker?: Ticker): void {
+        ticker = ticker || new Ticker(subject, blackboard, this);
+        ticker.openNodes.length = 0;
+        this._root._execute(ticker);
+        // 上次打开的节点
+        let lastOpenNodes = blackboard.get("openNodes", this._id) as BaseNode[];
+        // 当前打开的节点
+        let currOpenNodes = ticker.openNodes;
+        let start = 0;
+        for (let i = 0; i < Math.min(lastOpenNodes.length, currOpenNodes.length); i++) {
+            start = i + 1;
+            if (lastOpenNodes[i] !== currOpenNodes[i]) {
+                break;
+            }
+        }
+        // 关闭不需要的节点
+        for (let i = lastOpenNodes.length - 1; i >= start; i--) {
+            lastOpenNodes[i]._close(ticker);
+        }
+        /* POPULATE BLACKBOARD */
+        blackboard.set("openNodes", currOpenNodes, this._id);
+        blackboard.set("nodeCount", ticker.nodeCount, this._id);
+    }
+
+    get id(): string {
+        return this._id;
+    }
+
+    get root(): BaseNode {
+        return this._root;
+    }
+}

src/behaviortree/Blackboard.ts

@@ -0,0 +1,64 @@
+/**
+ * 行为树数据
+ */
+interface ITreeData {
+    nodeMemory: { [nodeScope: string]: any };
+    openNodes: any[];
+}
+
+/** 平台 */
+export class Blackboard {
+    public interruptDefend: boolean = false; // 行为树打断保护
+    public interrupt: boolean = false; // 打断行为树的标记
+    private _baseMemory: any;
+    private _treeMemory: { [treeScope: string]: ITreeData };
+
+    constructor() {
+        this._baseMemory = {};
+        this._treeMemory = {};
+    }
+
+    clear(): void {
+        this._baseMemory = {};
+        this._treeMemory = {};
+    }
+
+    set(key: string, value: any, treeScope?: string, nodeScope?: string): void {
+        let memory = this._getMemory(treeScope, nodeScope);
+        memory[key] = value;
+    }
+
+    get(key: string, treeScope?: string, nodeScope?: string): any {
+        let memory = this._getMemory(treeScope, nodeScope);
+        return memory[key];
+    }
+
+    private _getTreeMemory(treeScope: string): ITreeData {
+        if (!this._treeMemory[treeScope]) {
+            this._treeMemory[treeScope] = {
+                nodeMemory: {},
+                openNodes: [],
+            };
+        }
+        return this._treeMemory[treeScope];
+    }
+
+    private _getNodeMemory(treeMemory: ITreeData, nodeScope: string): { [key: string]: any } {
+        let memory = treeMemory.nodeMemory;
+        if (!memory[nodeScope]) {
+            memory[nodeScope] = {};
+        }
+        return memory[nodeScope];
+    }
+
+    private _getMemory(treeScope?: string, nodeScope?: string): { [key: string]: any } {
+        let memory = this._baseMemory;
+        if (treeScope) {
+            memory = this._getTreeMemory(treeScope);
+            if (nodeScope) {
+                memory = this._getNodeMemory(memory, nodeScope);
+            }
+        }
+        return memory;
+    }
+}

src/behaviortree/Ticker.ts

@@ -0,0 +1,40 @@
+import { BehaviorTree } from "./BehaviorTree";
+import { Blackboard } from "./Blackboard";
+import { BaseNode } from "./BTNode/BaseNode";
+
+export class Ticker {
+    tree: BehaviorTree; // 行为树跟节点
+    openNodes: BaseNode[]; // 当前打开的节点
+    nodeCount: number; // 当前打开的节点数量
+    blackboard: Blackboard; // 数据容器
+    debug: any;
+    subject: any;
+    constructor(subject: any, blackboard: Blackboard, tree: BehaviorTree) {
+        this.tree = tree;
+        this.openNodes = [];
+        this.nodeCount = 0;
+        this.debug = null;
+        this.subject = subject;
+        this.blackboard = blackboard;
+    }
+
+    /** 进入节点 */
+    enterNode(node: BaseNode): void {
+        this.nodeCount++;
+        this.openNodes.push(node);
+    }
+
+    /** 打开节点 */
+    openNode(node: BaseNode): void { }
+
+    /** 更新节点 */
+    tickNode(node: BaseNode): void { }
+
+    /** 关闭节点 */
+    closeNode(node: BaseNode): void {
+        this.openNodes.pop();
+    }
+
+    /** 退出节点 */
+    exitNode(node: BaseNode): void { }
+}

src/behaviortree/header.ts

@@ -0,0 +1,22 @@
+export const enum Status {
+    FAILURE,
+    SUCCESS,
+    RUNNING,
+}
+
+export function createUUID(): string {
+    let s: string[] = Array(36);
+    let hexDigits = "0123456789abcdef";
+    for (let i = 0; i < 36; i++) {
+        let start = Math.floor(Math.random() * 0x10);
+        s[i] = hexDigits.substring(start, start + 1);
+    }
+    // bits 12-15 of the time_hi_and_version field to 0010
+    s[14] = "4";
+    // bits 6-7 of the clock_seq_hi_and_reserved to 01
+    let start = (parseInt(s[19], 16) & 0x3) | 0x8;
+    s[19] = hexDigits.substring(start, start + 1);
+    s[8] = s[13] = s[18] = s[23] = "-";
+    let uuid = s.join("");
+    return uuid;
+}

src/cocos/CocosAdapter.ts

@@ -0,0 +1,51 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 
+ */
+
+import { screen as ccScreen, view } from "cc";
+import { Adapter } from "../global/Adapter";
+import { size } from "../global/header";
+import { info } from "../tool/log";
+
+export class CocosAdapter extends Adapter {
+    /**
+     * 获取屏幕像素尺寸
+     * @returns {size}
+     */
+    protected getScreenSize(): size {
+        let windowSize = ccScreen.windowSize;
+        let width = Math.ceil(windowSize.width / view.getScaleX());
+        let height = Math.ceil(windowSize.height / view.getScaleY());
+        return { width, height };
+    }
+
+    /**
+     * 获取设计尺寸
+     * @returns {size}
+     */
+    protected getDesignSize(): size {
+        let designSize = view.getDesignResolutionSize();
+        return { width: designSize.width, height: designSize.height };
+    }
+
+    /**
+     * 设置尺寸发生变化的监听
+     * @param callback 
+     */
+    protected registerResizeCallback(callback: (...args: any) => void): void {
+        ccScreen.on("window-resize", (...args: any) => {
+            info("window-resize");
+            callback(...args);
+        }, this);
+        ccScreen.on("orientation-change", (...args: any) => {
+            info("orientation-change");
+            callback(...args);
+        }, this);
+        ccScreen.on("fullscreen-change", (...args: any) => {
+            info("fullscreen-change");
+            callback(...args);
+        }, this);
+    }
+}

src/cocos/CocosEntry.ts

@@ -0,0 +1,134 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description:cocos游戏入口 定义了游戏启动时的基本配置和初始化流程。
+ */
+
+import { _decorator, Component, director, game, JsonAsset, macro, sys } from "cc";
+import { ECDataHelper } from "../ecmodule/ECDataHelper";
+import { GlobalEvent } from "../global/GlobalEvent";
+import { GlobalTimer } from "../global/GlobalTimer";
+import { enableDebugMode, FrameConfig } from "../global/header";
+import { InnerTimer } from "../global/InnerTimer";
+import { Platform, PlatformType } from "../global/Platform";
+import { ECManager } from "../kunpocc";
+import { ModuleBase } from "../module/ModuleBase";
+import { info } from "../tool/log";
+import { PropsHelper } from "../ui/PropsHelper";
+import { CocosAdapter } from "./CocosAdapter";
+const { property } = _decorator;
+export abstract class CocosEntry extends Component {
+    @property({ displayName: "uiConfig", type: JsonAsset, tooltip: "编辑器导出的UI配置, 可不设置, 之后通过 PropsHelper.setConfig 手动设置" }) uiConfig: JsonAsset = null;
+    @property({ displayName: "ecConfig", type: JsonAsset, tooltip: "编辑器导出的实体配置, 可不设置, 之后通过 ECManager.registerEntityConfig 手动设置" }) ecConfig: JsonAsset = null;
+    @property({ displayName: "游戏帧率" }) fps: number = 60;
+
+    /**
+     * 虚函数，子类需要实现
+     * kunpo库初始化完成后调用
+     */
+    public abstract onInit(): void;
+
+    public getConfig(): FrameConfig {
+        return {};
+    }
+
+    protected start(): void {
+        info("开始初始化kunpo框架");
+
+        const config = this.getConfig();
+        enableDebugMode(config.debug);
+
+        // 设置游戏真帧率
+        game.frameRate = this.fps;
+        director.addPersistRootNode(this.node);
+        this.node.setSiblingIndex(this.node.children.length - 1);
+        PropsHelper.setConfig(this.uiConfig?.json);
+        ECManager.registerEntityConfig(this.ecConfig?.json);
+        this.initPlatform();
+        this.initEvent();
+        this.initTime();
+        this.initAdapter();
+        this.initModule();
+        // 注册所有组件
+        ECDataHelper.registerComponents();
+        info("kunpo框架初始化完成");
+        this.onInit();
+    }
+
+    private initPlatform(): void {
+        // 处理平台判断
+        Platform.isNative = sys.isNative;
+        Platform.isMobile = sys.isMobile;
+        Platform.isNativeMobile = sys.isNative && sys.isMobile;
+
+        switch (sys.os) {
+            case sys.OS.ANDROID:
+                Platform.isAndroid = true;
+                info("系统类型 Android");
+                break;
+            case sys.OS.IOS:
+                Platform.isIOS = true;
+                info("系统类型 IOS");
+                break;
+            case sys.OS.OPENHARMONY:
+                Platform.isHarmonyOS = true;
+                info("系统类型 HarmonyOS");
+                break;
+            default:
+                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;
+        }
+        info(`platform: ${PlatformType[Platform.platform]}`);
+    }
+
+    private initEvent(): void {
+        GlobalEvent._initGlobalEvent();
+    }
+
+    private initTime(): void {
+        InnerTimer.initTimer();
+        GlobalTimer.initTimer();
+        this.schedule(this.tick.bind(this), 0, macro.REPEAT_FOREVER);
+    }
+
+    private initAdapter(): void {
+        new CocosAdapter().init();
+    }
+
+    private initModule(): void {
+        info(`初始化模块`);
+        // 递归查找自身或所有子节点中指定类型的组件。
+        for (const module of this.getComponentsInChildren(ModuleBase)) {
+            info(`module:${module.moduleName}`);
+            module.init();
+        }
+    }
+
+    private tick(dt: number): void {
+        InnerTimer.update(dt);
+        GlobalTimer.update(dt);
+    }
+}

src/cocos/CocosUIModule.ts

@@ -0,0 +1,45 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: cocos UI模块
+ */
+import { _decorator } from "cc";
+
+import { GRoot } from "fairygui-cc";
+import { ModuleBase } from "../module/ModuleBase";
+import { info } from "../tool/log";
+import { WindowManager } from "../ui/WindowManager";
+import { WindowResPool } from "../ui/WindowResPool";
+import { CocosWindowContainer } from "./CocosWindowContainer";
+
+const { ccclass, menu, property } = _decorator;
+
+@ccclass("CocosUIModule")
+@menu("kunpo/UI/UIModule")
+export class CocosUIModule extends ModuleBase {
+    /** 模块名称 */
+    public moduleName: string = "UI模块";
+    /** 模块初始化 (内部使用) */
+    public init(): void {
+        /** 初始化窗口管理系统 */
+        WindowManager._init(new WindowResPool());
+        GRoot.create();
+        info("初始化 WindowContainers");
+        for (const child of this.node.children) {
+            const containerComponent = child.getComponent(CocosWindowContainer);
+            containerComponent?.init();
+        }
+        // fgui.UIObjectFactory.setLoaderExtension(GLoader);
+        // this._uiInitializer = new UIInitializer(this.node, this.getPackageLoader());
+        // this._uiInitializer.init(this.reAdaptWhenScreenResize, this.fullIfWideScreen);
+        this.node.destroyAllChildren();
+        /** 注册窗口信息 */
+        WindowManager.registerUI()
+        this.onInit();
+    }
+
+    /** 模块初始化完成后调用的函数 */
+    protected onInit(): void {
+        info("UIModule init complete");
+    }
+}

src/cocos/CocosWindowContainer.ts

@@ -0,0 +1,35 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 
+ */
+
+import { Component, _decorator } from "cc";
+import { GComponent, GRoot } from "fairygui-cc";
+import { Screen } from "../global/Screen";
+import { info } from "../tool/log";
+import { WindowGroup } from "../ui/WindowGroup";
+import { WindowManager } from "../ui/WindowManager";
+const { ccclass, property, menu } = _decorator;
+@ccclass("CocosWindowContainer")
+@menu("kunpo/UI/UIContainer")
+export class CocosWindowContainer extends Component {
+    @property({ displayName: "忽略顶部窗口查询", tooltip: "当通过窗口管理器获取顶部窗口时，是否忽略查询" }) ignoreQuery: boolean = false;
+    @property({ displayName: "吞噬触摸事件", tooltip: "窗口组是否会吞噬触摸事件，防止层级下的窗口接收触摸事件" }) swallowTouch: boolean = false;
+    @property({ displayName: "底部遮罩透明度", tooltip: "底部半透明遮罩的默认透明度", min: 0, max: 1, step: 0.01 }) bgAlpha: number = 0.75;
+    /**
+     * 初始化窗口容器
+     */
+    public init(): void {
+        let name = this.node.name;
+        info(`\tUIContainer name:${name} 忽略顶部窗口查询:${this.ignoreQuery} 吞噬触摸事件:${this.swallowTouch}`);
+        const root = new GComponent();
+        root.name = name;
+        root.node.name = name;
+        root.visible = false;
+        root.opaque = this.swallowTouch;
+        root.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+        GRoot.inst.addChild(root);
+        WindowManager._addWindowGroup(new WindowGroup(name, root, this.ignoreQuery, this.swallowTouch, this.bgAlpha));
+    }
+}

src/condition/ConditionDecorator.ts

@@ -0,0 +1,25 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-17
+ * @Description: 条件装饰器
+ */
+export namespace _conditionDecorator {
+    /** 用来存储条件注册信息 */
+    const cdClassMap: Map<number, any> = new Map();
+
+    /** 获取组件注册信息 */
+    export function getConditionMaps(): Map<number, any> {
+        return cdClassMap;
+    }
+
+    /**
+     * 条件装饰器
+     * @param {number} conditionType 条件类型
+     */
+    export function conditionClass(conditionType: number): Function {
+        /** target 类的构造函数 */
+        return function (ctor: any): void {
+            cdClassMap.set(conditionType, ctor);
+        };
+    }
+}

src/condition/ConditionManager.ts

@@ -0,0 +1,210 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 
+ */
+import { warn } from "../tool/log";
+import { _conditionDecorator } from "./ConditionDecorator";
+import { ConditionMode } from "./ConditionMode";
+import { ConditionBase } from "./node/ConditionBase";
+import { ConditionNode } from "./node/ConditionNode";
+export class ConditionManager {
+    /** 注册的 条件类型对应条件的信息 */
+    private static readonly _typeToCondition: Map<number, ConditionBase> = new Map<number, ConditionBase>();
+
+    /** 条件类型 对应 条件节点 */
+    private static readonly _typeToNotifyNodes: Map<number, Set<ConditionNode>> = new Map<number, Set<ConditionNode>>();
+    /** 条件节点 对应 条件类型 */
+    private static readonly _nodeToConditionTypes: Map<ConditionNode, Set<number>> = new Map<ConditionNode, Set<number>>();
+
+    /** 需要更新的条件 */
+    private static readonly _needUpdateConditions: Set<ConditionBase> = new Set<ConditionBase>();
+    /** 需要更新的节点 */
+    private static readonly _needUpdateNodes: Set<ConditionNode> = new Set<ConditionNode>();
+
+    /** 是否正在更新 */
+    private static _updating: boolean = false;
+
+    /** 初始化所有条件，并全部更新一次 */
+    public static initCondition(): void {
+        const conditionMaps = _conditionDecorator.getConditionMaps();
+        conditionMaps.forEach((ctor, conditionType) => {
+            if (!this._typeToCondition.has(conditionType)) {
+                const condition = new ctor();
+                condition.type = conditionType;
+                condition._init();
+                this._addCondition(condition);
+            } else {
+                warn(`条件（${conditionType}）已经被注册, 跳过`);
+            }
+        });
+        this._refreshAllConditions();
+    }
+
+    /**
+     * 添加条件
+     * @param {IConditionBase} condition 条件
+     */
+    private static _addCondition(condition: ConditionBase): void {
+        if (this._updating) {
+            throw new Error("请不要在ConditionManager更新过程中添加要更新的条件");
+        }
+        this._typeToNotifyNodes.set(condition.type, new Set<ConditionNode>());
+        this._typeToCondition.set(condition.type, condition);
+        this._needUpdateConditions.add(condition);
+    }
+
+
+    private static _refreshAllConditions(): void {
+        let allCondition = this._typeToCondition;
+        for (const condition of allCondition.values()) {
+            condition._updateCondition();
+        }
+    }
+
+    /**
+     * 添加到更新列表中
+     * @param conditionType 条件类型
+     */
+    public static _addUpdateCondition(conditionType: number): void {
+        if (this._updating) {
+            throw new Error("请不要在ConditionManager更新过程中添加要更新的条件");
+        }
+        // 添加待更新的条件;
+        const condition = this._typeToCondition.get(conditionType);
+        if (condition) {
+            this._needUpdateConditions.add(condition);
+        }
+    }
+
+    /**
+     * 添加条件节点
+     * @param notifyNode 条件节点
+     * @param conditionType 条件类型
+     */
+    public static _addConditionNode(conditionNode: ConditionNode, conditionType: number): void {
+        const condition = this._typeToCondition.get(conditionType);
+        if (!condition) {
+            warn(`不存在条件类型（${conditionType}），请通过装饰器()注册条件类型`);
+            return;
+        }
+        // 添加通知类型对应节点
+        let nodes = this._typeToNotifyNodes.get(condition.type);
+        if (!nodes.has(conditionNode)) {
+            nodes.add(conditionNode);
+        }
+        // 添加节点对应通知类型
+        let conditionTypes = this._nodeToConditionTypes.get(conditionNode);
+        if (!conditionTypes) {
+            conditionTypes = new Set<number>();
+            this._nodeToConditionTypes.set(conditionNode, conditionTypes);
+        }
+        if (!conditionTypes.has(condition.type)) {
+            conditionTypes.add(condition.type);
+        }
+    }
+
+    /**
+     * 移除条件节点
+     * @param conditionNode 条件节点
+     * @param conditionType 条件类型
+     */
+    public static _removeConditionNode(conditionNode: ConditionNode): void {
+        let types = this._nodeToConditionTypes.get(conditionNode);
+        for (const conditionType of types.values()) {
+            let nodes = this._typeToNotifyNodes.get(conditionType);
+            nodes.delete(conditionNode);
+        }
+        this._nodeToConditionTypes.delete(conditionNode);
+    }
+
+    /**
+     * 立即更新条件节点（内部使用）
+     * @param conditionNode 条件节点
+     */
+    public static _nowUpdateConditionNode(conditionNode: ConditionNode): void {
+        this._tryUpdateConditionNode(conditionNode);
+    }
+
+    /** 更新函数（内部使用）*/
+    public static _update(): void {
+        this._updating = true;
+        // 更新条件
+        let needUpdateConditions = this._needUpdateConditions;
+        if (needUpdateConditions.size > 0) {
+            for (const condition of needUpdateConditions.values()) {
+                this._tryUpdateCondition(condition);
+            }
+            needUpdateConditions.clear();
+        }
+        // 更新条件节点
+        let needUpdateConditionNodes = this._needUpdateNodes;
+        if (needUpdateConditionNodes.size > 0) {
+            for (const conditionNode of needUpdateConditionNodes.values()) {
+                this._tryUpdateConditionNode(conditionNode);
+            }
+            needUpdateConditionNodes.clear();
+        }
+        this._updating = false;
+    }
+
+    /**
+     * 更新条件节点，如果状态改变，收集需要更新的通知节点(内部使用)
+     * @param {ConditionNode} conditionNode 条件节点
+     */
+    private static _tryUpdateCondition(condition: ConditionBase): void {
+        // 更新条件
+        if (!condition._updateCondition()) {
+            return;
+        }
+        // 条件改变，收集需要更新的通知节点
+        if (this._typeToNotifyNodes.has(condition.type)) {
+            let nodes = this._typeToNotifyNodes.get(condition.type);
+            let needUpdateConditionNodes = this._needUpdateNodes;
+            for (const conditionNode of nodes) {
+                if (!needUpdateConditionNodes.has(conditionNode)) {
+                    needUpdateConditionNodes.add(conditionNode);
+                }
+            }
+        }
+    }
+
+    /**
+     * 更新条件节点(内部使用)
+     * @param {ConditionNode} conditionNode 条件节点
+     */
+    private static _tryUpdateConditionNode(conditionNode: ConditionNode): void {
+        if (!this._nodeToConditionTypes.has(conditionNode)) {
+            return;
+        }
+        // 获取节点对应的所有通知条件
+        const conditionTypes = this._nodeToConditionTypes.get(conditionNode);
+        const conditions = this._typeToCondition;
+        let canNotify = false;
+        let modeType = conditionNode._modeType;
+        switch (modeType) {
+            case ConditionMode.Any:
+                for (const conditionType of conditionTypes.values()) {
+                    // 有一个满足就退出
+                    if (conditions.get(conditionType).canNotify()) {
+                        canNotify = true;
+                        break;
+                    }
+                }
+                break;
+            case ConditionMode.All:
+                canNotify = true;
+                for (const conditionType of conditionTypes.values()) {
+                    // 有任意一个不满足就退出
+                    if (!conditions.get(conditionType).canNotify()) {
+                        canNotify = false;
+                        break;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        conditionNode.notify(canNotify);
+    }
+}

src/condition/ConditionMode.ts

@@ -0,0 +1,12 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 条件模式
+ */
+
+export enum ConditionMode {
+    /** 满足任意条件显示 */
+    Any,
+    /** 满足所有条件显示 */
+    All,
+}

src/condition/ConditionModule.ts

@@ -0,0 +1,44 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 条件显示模块
+ */
+import { _decorator } from "cc";
+import { InnerTimer } from "../global/InnerTimer";
+import { ModuleBase } from "../module/ModuleBase";
+import { info } from "../tool/log";
+import { ConditionManager } from "./ConditionManager";
+
+const { ccclass, menu, property } = _decorator;
+
+@ccclass("ConditionModule")
+@menu("kunpo/condition/ConditionModule")
+export class ConditionModule extends ModuleBase {
+    @property({
+        displayName: "更新间隔（秒）",
+        min: 0.1,
+        step: 0.1,
+    })
+    updateDeltaTime: number = 0.3;
+
+    /** 模块名称 */
+    public moduleName: string = "条件显示模块";
+
+    private _timer: number = 0;
+    public init(): void {
+        this.onInit();
+
+        this._timer = InnerTimer.startTimer(() => {
+            ConditionManager._update();
+        }, this.updateDeltaTime, -1);
+    }
+
+    /** 模块初始化完成后调用的函数 */
+    protected onInit(): void {
+        info("ConditionModule init complete");
+    }
+
+    public onDestroy(): void {
+        InnerTimer.stopTimer(this._timer);
+    }
+}

src/condition/node/ConditionAllNode.ts

@@ -0,0 +1,18 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 满足所有条件显示
+ */
+import { GObject } from "fairygui-cc";
+import { ConditionMode } from "../ConditionMode";
+import { ConditionFGUINode } from "./ConditionFGUINode";
+export class ConditionAllNode extends ConditionFGUINode {
+    /**
+     * 构建红点节点
+     * @param {GObject} node 关联节点
+     * @param {...number[]} conditionTypes 条件类型
+     */
+    public constructor(node: GObject, ...conditionTypes: number[]) {
+        super(node, ConditionMode.All, ...conditionTypes);
+    }
+}

src/condition/node/ConditionAnyNode.ts

@@ -0,0 +1,18 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 满足任意条件显示
+ */
+import { GObject } from "fairygui-cc";
+import { ConditionMode } from "../ConditionMode";
+import { ConditionFGUINode } from "./ConditionFGUINode";
+export class ConditionAnyNode extends ConditionFGUINode {
+    /**
+     * 构建红点节点
+     * @param {GObject} node 关联节点
+     * @param {...number[]} conditionTypes 条件类型
+     */
+    public constructor(node: GObject, ...conditionTypes: number[]) {
+        super(node, ConditionMode.Any, ...conditionTypes);
+    }
+}

src/condition/node/ConditionBase.ts

@@ -0,0 +1,54 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 条件基类
+ */
+
+import { ConditionManager } from "../ConditionManager";
+
+export abstract class ConditionBase {
+    /** 初始化 */
+    public _init(): void {
+        this.onInit();
+    }
+
+    /** 条件类型 */
+    public type: number;
+
+    private _canNotify: boolean;
+    /**
+     * 是否可以通知
+     * @returns {boolean}
+     */
+    public canNotify(): boolean {
+        return this._canNotify;
+    }
+
+    public tryUpdate(): void {
+        ConditionManager._addUpdateCondition(this.type);
+    }
+
+    /**
+     * 更新条件
+     * @returns {boolean} 是否发生变化
+     */
+    public _updateCondition(): boolean {
+        let canNotify = this.evaluate();
+        if (canNotify == this._canNotify) {
+            return;
+        }
+        this._canNotify = canNotify;
+        return true;
+    }
+
+    /**
+     * 初始化
+     */
+    protected abstract onInit(): void;
+
+    /**
+     * 返回条件结果 子类实现
+     * @returns {boolean}
+     */
+    protected abstract evaluate(): boolean;
+}

src/condition/node/ConditionFGUINode.ts

@@ -0,0 +1,52 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-17
+ * @Description: 
+ */
+
+import { GObject } from "fairygui-cc";
+import { ConditionManager } from "../ConditionManager";
+import { ConditionMode } from "../ConditionMode";
+import { ConditionNode } from "./ConditionNode";
+export class ConditionFGUINode extends ConditionNode {
+    /**
+     * 红点节点
+     * @protected
+     * @type {GObject | Node} fgui节点 或 node节点
+     * @memberof NotityFGUINode
+     */
+    protected node: GObject;
+
+    private _oldRemoveFromParent: () => void;
+
+    /**
+     * 构建红点节点
+     * @param {GObject} node 关联节点
+     * @param {...number[]} conditionTypes 条件类型
+     */
+    public constructor(node: GObject, modeType: ConditionMode, ...conditionTypes: number[]) {
+        super(modeType, ...conditionTypes);
+        this.node = node;
+        const oldRemoveFromParent = (this._oldRemoveFromParent = node.removeFromParent);
+        node.removeFromParent = (): void => {
+            super.destroy();
+            oldRemoveFromParent.call(node);
+            this.node.removeFromParent = this._oldRemoveFromParent;
+            this.node = null;
+        };
+        // 立即更新一次
+        ConditionManager._nowUpdateConditionNode(this);
+    }
+
+    public destroy(): void {
+        super.destroy();
+        if (this.node) {
+            this.node.removeFromParent = this._oldRemoveFromParent;
+            this.node = null;
+        }
+    }
+
+    public notify(visible: boolean): void {
+        this.node.visible = visible;
+    }
+}

src/condition/node/ConditionNode.ts

@@ -0,0 +1,36 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 条件节点
+ */
+
+import { ConditionManager } from "../ConditionManager";
+import { ConditionMode } from "../ConditionMode";
+
+export abstract class ConditionNode {
+    /** 条件类型 */
+    public _modeType: ConditionMode;
+
+    /**
+     * 构建红点节点
+     * @param {GObject} node 关联节点
+     * @param {...number[]} conditionTypes 条件类型
+     */
+    public constructor(modeType: ConditionMode, ...conditionTypes: number[]) {
+        this._modeType = modeType;
+        for (const conditionType of conditionTypes) {
+            ConditionManager._addConditionNode(this, conditionType);
+        }
+    }
+
+    /** 移除节点 */
+    public destroy(): void {
+        ConditionManager._removeConditionNode(this);
+    }
+
+    /**
+     * 通知节点更新
+     * @param {boolean} visible 节点显示状态
+     */
+    public abstract notify(visible: boolean): void;
+}

src/ecmodule/Component.ts

@@ -0,0 +1,112 @@
+import { ComponentManager } from "./ComponentManager";
+import { Entity } from "./Entity";
+import { ObjectBase } from "./ObjectBase";
+
+export abstract class Component extends ObjectBase {
+    /** 组件名 */
+    public name: string;
+
+    /** 组件类型 */
+    public type: number;
+
+    /** 是否需要更新 */
+    public needUpdate: boolean;
+
+    /** 所属实体 */
+    public entity: Entity;
+
+    /** 所属组件管理器 */
+    public componentManager: ComponentManager;
+
+    /** 是否需要销毁 */
+    public _needDestroy: boolean;
+
+    /** 更新ID */
+    public _updateId: number = -1;
+
+    /** 是否更新中 */
+    public get _updating(): boolean {
+        return this._updateId != -1;
+    }
+
+    /** 生命周期函数 添加到实体 */
+    public _add(): void {
+        this.onAdd();
+    }
+
+    /** 生命周期函数 销毁 */
+    public _destroy(): void {
+        this.onDestroy();
+    }
+
+    /** 生命周期函数 添加到实体后 在这个函数中可以获取其他组件 */
+    public _enter(): void {
+        // 自动开启更新
+        if (this.needUpdate) {
+            this.componentManager.startUpdateComponent(this);
+        }
+        this.onEnter();
+    }
+
+    /** 生命周期函数 从实体中移除 */
+    public _remove(): void {
+        this.stopUpdate();
+        this.onRemove();
+        this.componentManager._destroyComponent(this);
+    }
+
+    /** 更新 */
+    public _update(dt: number): void {
+        this.onUpdate(dt);
+    }
+
+    /** 开启更新 */
+    public startUpdate(): void {
+        if (!this.needUpdate) {
+            this.needUpdate = true;
+            this.componentManager?.startUpdateComponent(this);
+        }
+    }
+
+    /** 停止更新 */
+    public stopUpdate(): void {
+        if (this.needUpdate) {
+            this.needUpdate = false;
+            this.componentManager?.stopUpdateComponent(this);
+        }
+    }
+
+    /**
+     * 获取组件
+     * @param {number} componentType 组件类型
+     * @returns {T}
+     */
+    public getComponent<T extends Component>(componentType: number): T {
+        return this.entity.getComponent<T>(componentType);
+    }
+
+    /**
+     * 删除自己
+     */
+    public destroySelf(): void {
+        this.entity.removeComponent(this.type);
+    }
+
+    /**
+     * 被添加到实体 对应onDestroy
+     */
+    protected onAdd(): void { }
+
+    /**
+     * 组件被销毁 对应onAdd
+     */
+    protected onDestroy(): void { }
+
+    protected onUpdate(dt: number): void { }
+
+    /** 可在此方法获取实体其他组件 */
+    protected abstract onEnter(): void;
+
+    /** 从实体中删除 */
+    protected abstract onRemove(): void;
+}

src/ecmodule/ComponentManager.ts

@@ -0,0 +1,254 @@
+import { Component } from "./Component";
+import { ComponentPool } from "./ComponentPool";
+
+/**
+ * 组件更新信息
+ *
+ * @export
+ * @class ComponentUpdate
+ */
+export class ComponentUpdate {
+    /** 组件更新类型 */
+    public componentType: number;
+
+    /** 组件更新列表 */
+    private readonly _components: Component[] = [];
+
+    /** create constructor */
+    public constructor(componentType: number) {
+        this.componentType = componentType;
+    }
+
+    /**
+     * 添加要更新的组件
+     * @param component 组件
+     */
+    public addComponent(component: Component): void {
+        this._components.push(component);
+        component._updateId = this._components.length - 1;
+    }
+
+    /**
+     * 删除要更新的组件
+     * @param {Component} component 组件
+     */
+    public removeComponent(component: Component): void {
+        const components = this._components;
+        const finalUpdateID = components.length - 1;
+        const updateID = component._updateId;
+
+        component._updateId = -1;
+        /** 最后一个和当前要删除的不是同一个，交换位置 */
+        if (finalUpdateID != updateID) {
+            const finalComponent = components[finalUpdateID];
+            // #EC_DEBUG_BEGIN
+            if (finalComponent._updateId != finalUpdateID) {
+                throw new Error(`组件(${finalComponent.toString()})更新ID(${finalUpdateID})与存储更新ID(${finalComponent._updateId})不一致`);
+            }
+            // #EC_DEBUG_END
+            finalComponent._updateId = updateID;
+            components[updateID] = finalComponent;
+        }
+        components.pop();
+    }
+
+    /** 更新 */
+    public _update(dt: number): void {
+        const components = this._components;
+        const componentCount = components.length;
+
+        if (componentCount > 0) {
+            for (let i = 0; i < componentCount; ++i) {
+                const component = components[i];
+
+                if (component.needUpdate && component._updating) {
+                    component._update(dt);
+                }
+            }
+        }
+    }
+}
+
+export class ComponentManager {
+    /**
+     * 组件池
+     * @type {ComponentPool}
+     */
+    protected componentPool: ComponentPool;
+
+    /** 更新组件池 */
+    protected readonly updatingComponents: ComponentUpdate[] = [];
+    protected readonly componentUpdateOrderList: number[] = [];
+
+    /** 新添加的或者新停止更新的组件池 */
+    private readonly _toUpdateComponents: Component[] = [];
+    private readonly _toStopComponents: Component[] = [];
+
+    /** 当前更新的组件类型 */
+    private _currentUpdateComponentType: number = -1;
+
+    /**
+     *Creates an instance of ComponentManager.
+     * @param {ComponentPool} componentPool 组件池
+     * @param {number[]} componentUpdateOrderList 组件更新顺序
+     */
+    constructor(componentPool: ComponentPool, componentUpdateOrderList: number[]) {
+        this.componentPool = componentPool;
+        this._toUpdateComponents.length = 0;
+        this._toStopComponents.length = 0;
+        for (const componentType of componentUpdateOrderList) {
+            this._addComponentUpdateOrder(componentType);
+        }
+    }
+
+    public destroy(): void {
+        this.componentPool.clear();
+        this.updatingComponents.length = 0;
+        this.componentUpdateOrderList.length = 0;
+        this._toUpdateComponents.length = 0;
+        this._toStopComponents.length = 0;
+    }
+
+    /**
+     * 创建组件
+     * @template T
+     * @param {string} componentName 组件名
+     * @returns {T} 创建的组件
+     */
+    public createComponent<T extends Component>(componentName: string): T {
+        const component = this.componentPool.get(componentName) as T;
+        // component._enable = true;
+        // component.needDestroy = false;
+        component.componentManager = this;
+        return component;
+    }
+
+    /**
+     * 开始更新组件
+     * @param {Component} component 组件
+     */
+    public startUpdateComponent(component: Component): void {
+        if (component._updating) {
+            return;
+        }
+        if (this._currentUpdateComponentType != component.type) {
+            this._addComponentToUpdateList(component);
+            return;
+        }
+        this._toUpdateComponents.push(component);
+    }
+
+    /**
+     * 停止更新组件
+     * @param {Component} component 组件
+     */
+    public stopUpdateComponent(component: Component): void {
+        if (!component._updating) {
+            return;
+        }
+
+        if (this._currentUpdateComponentType != component.type) {
+            this._removeComponentToUpdateList(component);
+            return;
+        }
+
+        this._toStopComponents.push(component);
+    }
+
+    /**
+     * 销毁组件（内部使用）
+     * @param {Component} component
+     */
+    public _destroyComponent(component: Component): void {
+        if (!component._updating) {
+            component._destroy();
+            this.componentPool.recycle(component);
+        } else {
+            component._needDestroy = true;
+        }
+    }
+
+    /** 更新所有组件（内部使用） */
+    public _update(dt: number): void {
+        this._updateAllComponents(dt);
+        this._currentUpdateComponentType = -1;
+
+        this._clearStopComponents();
+        this._addUpdateComponents();
+    }
+
+    /**
+     * 添加组件更新顺序，先添加的先更新
+     * @param {number} componentType 组件类型
+     */
+    private _addComponentUpdateOrder(componentType: number): ComponentManager {
+        this.componentUpdateOrderList.push(componentType);
+        const updatingComponents = this.updatingComponents;
+        for (let i = updatingComponents.length; i <= componentType; ++i) {
+            updatingComponents.push(null);
+        }
+        if (updatingComponents[componentType]) {
+            throw new Error(`组件类型（${componentType}:${this.componentPool.className(componentType)}）已经添加到更新列表`);
+        }
+        updatingComponents[componentType] = new ComponentUpdate(componentType);
+        return this;
+    }
+
+    /** 添加组件到组件更新列表 */
+    private _addComponentToUpdateList(component: Component): void {
+        if (component.type >= this.updatingComponents.length || !this.updatingComponents[component.type]) {
+            throw new Error(`组件（${component.constructor.name}）没有添加到组件更新列表，请使用addComponentUpdateOrder添加更新`);
+        }
+        this.updatingComponents[component.type].addComponent(component);
+    }
+
+    /** 组件更新列表中删除组件 */
+    private _removeComponentToUpdateList(component: Component): void {
+        this.updatingComponents[component.type].removeComponent(component);
+    }
+
+    /** 更新所有组件 */
+    private _updateAllComponents(dt: number): void {
+        // 按优先级更新所有组件
+        const updateList = this.componentUpdateOrderList;
+        const updatingComponents = this.updatingComponents;
+        let componentType: number;
+
+        for (let i = 0, l = updateList.length; i < l; ++i) {
+            componentType = updateList[i];
+            this._currentUpdateComponentType = componentType;
+            updatingComponents[componentType]._update(dt);
+        }
+    }
+
+    private _clearStopComponents(): void {
+        const toStopComponents = this._toStopComponents;
+        const l = toStopComponents.length;
+        if (l > 0) {
+            for (let i = 0; i < l; ++i) {
+                const component = toStopComponents[i];
+                if (!component.needUpdate && component._updating) {
+                    this._removeComponentToUpdateList(component);
+                    if (component._needDestroy) {
+                        this._destroyComponent(component);
+                    }
+                }
+            }
+            toStopComponents.length = 0;
+        }
+    }
+
+    private _addUpdateComponents(): void {
+        const toUpdateComponents = this._toUpdateComponents;
+        const l = toUpdateComponents.length;
+        if (l > 0) {
+            for (let i = 0; i < l; ++i) {
+                const component = toUpdateComponents[i];
+                if (component.needUpdate && !component._updating) {
+                    this._addComponentToUpdateList(component);
+                }
+            }
+            toUpdateComponents.length = 0;
+        }
+    }
+}

src/ecmodule/ComponentPool.ts

@@ -0,0 +1,84 @@
+import { Component } from "./Component";
+import { ObjectBase } from "./ObjectBase";
+import { ObjectFactory } from "./ObjectFactory";
+
+export class ComponentPool {
+    /** 组件对象类型到组件类型转换 */
+    private readonly _objectTypeToComponentType: number[] = new Array<number>(128);
+    private _pools: Map<number, ObjectFactory> = new Map();
+    private _nameToObjectType: Map<string, number> = new Map();
+    /**
+     * 注册组件
+     * @param {number} componentObjectType 组件对象类型
+     * @param {number} componentType 组件类型
+     * @param {string} name 组件名称
+     * @param {new () => Component} ctor 构造函数
+     */
+    public register(componentObjectType: number, componentType: number, name: string, ctor: new () => ObjectBase): void {
+        if (this._pools.has(componentObjectType)) {
+            throw new Error(`组件(${name})已注册, 不允许重复注册`);
+        }
+        this._pools.set(componentObjectType, new ObjectFactory(componentObjectType, 128, name, ctor));
+        this._nameToObjectType.set(name, componentObjectType);
+
+        const objectTypeToComponentType = this._objectTypeToComponentType;
+        for (let i = objectTypeToComponentType.length; i <= componentObjectType; ++i) {
+            objectTypeToComponentType.push(i);
+        }
+        objectTypeToComponentType[componentObjectType] = componentType;
+    }
+
+    public getObjectTypeByName(componentName: string): number {
+        return this._nameToObjectType.get(componentName);
+    }
+
+    /**
+     * 创建组件
+     * @param {number} componentName 组件名
+     * @returns {T} 创建的组件
+     */
+    public get<T extends Component>(componentName: string): T {
+        let objectType = this.getObjectTypeByName(componentName);
+
+        const factory = this._pools.get(objectType);
+        if (!factory) {
+            throw new Error(`组件（${componentName}）未注册，使用组件装饰器 ecclass 注册组件`);
+        }
+        const component = factory.allocate() as T;
+        component.name = factory.name;
+        component.type = this._objectTypeToComponentType[objectType];
+        return component;
+    }
+
+    /**
+     * 通过组件对象类型获取组件类名
+     * @param {number} componentObjectType 组件类型
+     * @returns {string}
+     */
+    public className(componentObjectType: number): string {
+        const factory = this._pools.get(componentObjectType);
+        if (!factory) {
+            throw new Error(
+                `组件（${componentObjectType}）没有注册，使用ComponentPool.register(componentObjectType, componentType, componentClass)注册组件`
+            );
+        }
+        return factory.name;
+    }
+
+    /**
+     * 回收组件
+     * @param {BaseComponent} component 要回收的组件
+     * @memberof ComponentPool
+     */
+    public recycle(component: Component): void {
+        const objectFactory = this._pools.get(component.objectType);
+        objectFactory.recycle(component);
+    }
+
+    /** 清理缓存 */
+    public clear(): void {
+        for (const factory of this._pools.values()) {
+            factory._clear();
+        }
+    }
+}

src/ecmodule/ECDataHelper.ts

@@ -0,0 +1,109 @@
+import { color, size, v2, v3 } from "cc";
+import { _ecdecorator, ComponentPool, warn } from "../kunpocc";
+import { Component } from "./Component";
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-24
+ * @Description: 
+ */
+export class ECDataHelper {
+    /** 组件池 */
+    public static _componentPool: ComponentPool = new ComponentPool();
+    /** 注册所有组件 */
+    public static registerComponents(): void {
+        let index = 0;
+        let maps = _ecdecorator.getComponentMaps();
+        maps.forEach((info: _ecdecorator.ECComponentInfo, ctor: any) => {
+            this._componentPool.register(index++, info.componentType, info.name, ctor);
+        });
+    }
+
+    public static getComponentPool(): ComponentPool {
+        return this._componentPool;
+    }
+
+    /** 解析组件数据 */
+    public static parse(component: Component, data: Record<string, any>): void {
+        const maps = _ecdecorator.getComponentMaps();
+        const ctor = component.constructor;
+        if (!maps.has(ctor)) {
+            return;
+        }
+        const info = maps.get(ctor);
+        for (const property in data) {
+            let propInfo = info.props[property];
+            if (!propInfo) {
+                warn(`组件 ${component.name} 属性 ${property} 未注册`);
+                continue;
+            }
+            let value = data[property];
+            (component as any)[property] = this.getPropValue(propInfo, value);
+        }
+    }
+
+    private static getPropValue(propInfo: _ecdecorator.ECPropInfo, value: any): any {
+        switch (propInfo.type) {
+            case "int":
+                if (typeof value === "number") {
+                    return value;
+                }
+                return propInfo.defaultValue || 0;
+            case "float":
+                if (typeof value === "number") {
+                    return value;
+                }
+                return propInfo.defaultValue || 0;
+            case "boolean":
+                if (typeof value === "boolean") {
+                    return value;
+                }
+                return propInfo.defaultValue || false;
+            case "size":
+                if (typeof value === "object" && typeof value.width === "number" && typeof value.height === "number") {
+                    return size(value.width, value.height);
+                }
+                return propInfo.defaultValue || size(0, 0);
+            case "vec2":
+                if (typeof value === "object" && typeof value.x === "number" && typeof value.y === "number") {
+                    return v2(value.x, value.y);
+                }
+                return propInfo.defaultValue || v2(0, 0);
+            case "vec3":
+                if (typeof value === "object" && typeof value.x === "number" && typeof value.y === "number" && typeof value.z === "number") {
+                    return v3(value.x, value.y, value.z);
+                }
+                return propInfo.defaultValue || v3(0, 0, 0);
+            case "color":
+                if (typeof value === "object" && typeof value[0] === "number" && typeof value[1] === "number" && typeof value[2] === "number") {
+                    return color(value[0], value[1], value[2], typeof value[3] === "number" ? value[3] : 255);
+                }
+                return propInfo.defaultValue || color(255, 255, 255, 255);
+            case "asset":
+            case "spriteframe":
+            case "prefab":
+            case "jsonAsset":
+            case "particle":
+            case "animation":
+            case "audio":
+            case "skeleton":
+            case "entity":
+                return typeof value === "string" ? value : (propInfo.defaultValue || "");
+            case "enum":
+                return value;
+            case "array":
+                if (Array.isArray(value)) {
+                    return value;
+                }
+                return propInfo.defaultValue || [];
+            case "object":
+                if (typeof value === "object") {
+                    return value;
+                }
+                return propInfo.defaultValue || {};
+            default:
+                break;
+        }
+        return undefined;
+    }
+}

src/ecmodule/ECDecorator.ts

@@ -0,0 +1,140 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-14
+ * @Description: 实体组件装饰器
+ */
+
+import { Color, Size, Vec2, Vec3 } from "cc";
+import { ObjectHelper } from "../tool/helper/ObjectHelper";
+
+
+export namespace _ecdecorator {
+    const ECPropMeta = "__ecpropmeta__"
+
+    type ECPropType = "int" | "float" | "string" | "boolean" | "size" | "vec2" | "vec3" | "color" | "asset" | "spriteframe" | "jsonAsset" | "particle" | "animation" | "audio" | "prefab" | "skeleton" | "enum" | "array" | "object" | "entity";
+
+    interface ECPropInfoBase {
+        /** 属性默认值 */
+        defaultValue?: any,
+        /** 编辑器中的显示名称 */
+        displayName?: string,
+        /** 编辑器中的提示 */
+        tips?: string
+    }
+
+    interface ECPropInfoNumber extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "int" | "float";
+        /** 默认值:0 */
+        defaultValue?: number;
+    }
+
+    interface ECPropInfoBoolean extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "boolean";
+        /** 默认值:false */
+        defaultValue?: boolean;
+    }
+
+    interface ECPropInfoSize extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "size";
+        /** 默认值:Size(0,0) */
+        defaultValue?: Size;
+    }
+
+    interface ECPropInfoVec extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "vec2" | "vec3";
+        /** 默认值: Vec2(0,0) | Vec3(0,0,0) */
+        defaultValue?: Vec2 | Vec3;
+    }
+
+    interface ECPropInfoString extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "string" | "asset" | "spriteframe" | "jsonAsset" | "particle" | "animation" | "audio" | "prefab" | "skeleton" | "entity";
+        /** 默认值: "" */
+        defaultValue?: string;
+    }
+
+    interface ECPropInfoColor extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "color";
+        /** 默认值:Color(255, 255, 255, 255) */
+        defaultValue?: Color;
+    }
+
+    interface ECPropInfoArray extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "array";
+        /** 类型格式 当类型是复合类型enum、array、object时必须 */
+        format: ECPropType | ECPropInfo;
+    }
+
+    interface ECPropInfoObject extends ECPropInfoBase {
+        /** 属性类型 */
+        type: "object";
+        /** 类型格式 当类型是复合类型enum、array、object时必须 */
+        format: Record<string, ECPropType> | Record<string, ECPropInfo>;
+    }
+
+    interface ECPropInfoEnum extends ECPropInfoBase {
+        type: "enum";
+        /** 枚举值 */
+        format: object;
+        /** 默认值 */
+        defaultValue?: string | number;
+    }
+
+    export type ECPropInfo = ECPropInfoNumber | ECPropInfoBoolean | ECPropInfoSize | ECPropInfoVec | ECPropInfoString | ECPropInfoColor | ECPropInfoArray | ECPropInfoObject | ECPropInfoEnum;
+
+    /**
+     * 组件注册数据结构
+     */
+    export interface ECComponentInfo {
+        /** 组件名 */
+        name: string;
+        /** 组件类型 */
+        componentType: number;
+        /** 组件描述 */
+        describe: string;
+        /** 属性 */
+        props: Record<string, ECPropInfo>;
+    }
+    /** 用来存储组件注册信息 */
+    const eclassMap: Map<any, ECComponentInfo> = new Map();
+
+    /** 获取组件注册信息 */
+    export function getComponentMaps(): Map<any, ECComponentInfo> {
+        return eclassMap;
+    }
+
+    /**
+     * 实体组件装饰器
+     * @param {string} res.describe 组件组描述
+     */
+    export function ecclass(name: string, componentType: number, res?: { describe?: string }): Function {
+        /** target 类的构造函数 */
+        return function (ctor: any): void {
+            // console.log(`组件装饰器 组件【${name}】属性:`, JSON.stringify(ctor[ECPropMeta]));
+            eclassMap.set(ctor, {
+                name: name,
+                componentType: componentType,
+                props: ctor[ECPropMeta],
+                describe: res?.describe || name
+            });
+        };
+    }
+
+    /** 组件属性装饰器 */
+    export function ecprop(options: ECPropInfo): any {
+        return function (target: any, propName: any): void {
+            ObjectHelper.getObjectProp(target.constructor, ECPropMeta)[propName] = options;
+        };
+    }
+}
+
+let _global = globalThis || window || global;
+(_global as any)["getKunpoRegisterECMaps"] = function () {
+    return _ecdecorator.getComponentMaps() as any;
+};

src/ecmodule/ECManager.ts

@@ -0,0 +1,162 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-14
+ * @Description: 实体组件管理对外接口
+ */
+
+import { Node } from "cc";
+import { ECDataHelper } from "./ECDataHelper";
+import { Entity } from "./Entity";
+import { EntityManager } from "./EntityManager";
+
+interface IEntityConfig {
+    [componentName: string]: Record<string, any>
+}
+
+interface IWorldConfig {
+    /** 实体管理器 */
+    world: EntityManager;
+    /** 世界节点 */
+    worldNode: Node;
+}
+
+export class ECManager {
+    /** 实体管理器 */
+    private static _worlds: Map<string, IWorldConfig> = new Map();
+    /** 实体配置信息 */
+    private static _entityList: { [name: string]: Record<string, any> } = {};
+
+    /** 注册所有组件 如果GameEntry因分包导致，组件的代码注册晚于 CocosEntry的 onInit函数, 则需要在合适的时机手动调用此方法 */
+    public static registerComponents(): void {
+        ECDataHelper.registerComponents();
+    }
+
+    /**
+     * 创建EC世界 创建EC世界前必须先注册组件
+     * @param {string} worldName 名称
+     * @param {Node} node 世界节点
+     * @param {number[]} componentUpdateOrderList 组件更新顺序列表 (只传需要更新的组件列表)
+     * @param {number} [maxCapacityInPool=128] 实体池最大容量，多余的实体不会缓存
+     * @param {number} [preloadEntityCount=32] 预加载Entity数量
+     */
+    public static createECWorld(worldName: string, node: Node, componentUpdateOrderList: number[], maxCapacityInPool = 128, preloadEntityCount = 32): EntityManager {
+        if (this._worlds.has(worldName)) {
+            throw new Error(`ECWorld ${worldName} already exists`);
+        }
+        const entityManager = new EntityManager(worldName, ECDataHelper.getComponentPool(), componentUpdateOrderList, maxCapacityInPool, preloadEntityCount);
+        this._worlds.set(worldName, { world: entityManager, worldNode: node });
+        return entityManager;
+    }
+
+    /** 获取EC世界 */
+    public static getECWorld(worldName: string): EntityManager {
+        if (!this._worlds.has(worldName)) {
+            throw new Error(`ECWorld ${worldName} not found`);
+        }
+        const entityManager = this._worlds.get(worldName).world;
+        if (!entityManager) {
+            throw new Error(`ECWorld ${worldName} is null`);
+        }
+        return entityManager;
+    }
+
+    /** 获取EC世界节点 */
+    public static getECWorldNode(worldName: string): Node {
+        if (!this._worlds.has(worldName)) {
+            throw new Error(`ECWorld ${worldName} not found`);
+        }
+        const node = this._worlds.get(worldName).worldNode;
+        if (!node) {
+            throw new Error(`ECWorld ${worldName} is null`);
+        }
+        return node;
+    }
+
+    /** 销毁EC世界 */
+    public static destroyECWorld(worldName: string): void {
+        let entityManager = this.getECWorld(worldName);
+        if (entityManager) {
+            entityManager.destroy();
+            this._worlds.delete(worldName);
+        }
+    }
+
+    /**
+     * 注册配置表中的实体信息
+     * @param config 实体配置信息，格式为 {实体名: {组件名: 组件数据}}
+     */
+    public static registerEntityConfig(config: { [entityName: string]: IEntityConfig }): void {
+        // 遍历并注册每个实体的配置
+        for (const entityName in config) {
+            this._entityList[entityName] = config[entityName];
+        }
+    }
+
+    /**
+     * 添加实体信息 (如果已经存在, 则数据组合)
+     * 如果存在编辑器编辑不了的数据 用来给编辑器导出的实体信息 添加扩展数据
+     * @param name 实体名
+     * @param info 实体信息 
+     */
+    public static addEntityInfo(name: string, info: IEntityConfig): void {
+        if (this._entityList[name]) {
+            this._entityList[name] = Object.assign(this._entityList[name], info);
+        } else {
+            this._entityList[name] = info;
+        }
+    }
+
+    /** 获取实体配置信息 */
+    public static getEntityInfo(name: string): Record<string, any> {
+        if (!this._entityList[name]) {
+            throw new Error(`Entity ${name} info not found, please register it first`);
+        }
+        return this._entityList[name];
+    }
+
+    /**
+     * 创建实体
+     * @param worldName 实体管理器名称
+     * @param name 实体名字
+     * @returns {kunpo.Entity} 实体
+     */
+    public static createEntity(worldName: string, name: string): Entity {
+        let info = this.getEntityInfo(name);
+        let world = this.getECWorld(worldName);
+        let entity = world.createEntity(name);
+        info && this._addComponentToEntity(world, entity, info);
+
+        world.addEntity(entity);
+        return entity;
+    }
+
+    private static _addComponentToEntity(world: EntityManager, entity: Entity, componentsData: Record<string, any>): void {
+        for (const componentName in componentsData) {
+            let component = world.createComponent(componentName);
+            ECDataHelper.parse(component, componentsData[componentName]);
+            entity.addComponent(component);
+        }
+    }
+
+    /**
+     * 销毁实体
+     * @param worldName 世界名称
+     * @param entity 实体
+     */
+    public static destroyEntity(worldName: string, entity: Entity): void {
+        if (!entity || !entity.id) {
+            return;
+        }
+        this.destroyEntityById(worldName, entity.id);
+    }
+
+    /**
+     * 销毁实体
+     * @param worldName 世界名称
+     * @param entityId 实体ID
+     */
+    public static destroyEntityById(worldName: string, entityId: number): void {
+        let world = this.getECWorld(worldName);
+        world.destroyEntityById(entityId);
+    }
+}

src/ecmodule/ECType.ts

@@ -0,0 +1,79 @@
+/**
+ * @type {&} AND，按位与处理两个长度相同的二进制数，两个相应的二进位都为 1，该位的结果值才为 1，否则为 0
+ * @type {|} OR，按位或处理两个长度相同的二进制数，两个相应的二进位中只要有一个为 1，该位的结果值为 1
+ * @type {~} 取反，取反是一元运算符，对一个二进制数的每一位执行逻辑反操作。使数字 1 成为 0，0 成为 1
+ * @type {^} 异或，按位异或运算，对等长二进制模式按位或二进制数的每一位执行逻辑异按位或操作。操作的结果是如果某位不同则该位为 1，否则该位为 0
+ * @type {<<} 左移，把 << 左边的运算数的各二进位全部左移若干位，由 << 右边的数指定移动的位数，高位丢弃，低位补0; 将一个值左移一个位置相当于将其乘以2，移位两个位置相当于乘以4，依此类推。
+ * @type {>>} 右移，把 >> 左边的运算数的各二进位全部右移若干位，>> 右边的数指定移动的位数
+ * @type {>>>} 无符号右移，与有符号右移位类似，除了左边一律使用0 补位
+ */
+import { Stack } from "../tool/DataStruct/Stack";
+
+export const EntityIndexBits = 16;
+export const EntityIndexMask = (1 << EntityIndexBits) - 1;
+export const MaxEntityCount = 1 << EntityIndexBits;
+export type EntityId = number;
+
+/**
+ * 2进制转10进制 (不支持小数和负数)
+ * @param {number} bitNumber 二进制数
+ * @return {number} 十进制数
+ */
+export function bit2Decimal(bitNumber: number): number {
+    let bitString = String(bitNumber);
+    let len = bitString.length;
+    let index = len - 1;
+    let result: number = 0;
+    do {
+        result += Number(bitString[index]) * Math.pow(2, len - index - 1);
+        index--;
+    } while (index >= 0);
+    return result;
+}
+/**
+ * 10进制转2进制 (不支持小数和负数)
+ * @param {number} num 十进制数
+ * @return {number} 二进制数
+ */
+export function decimal2Bit(num: number): number {
+    let stack = new Stack<number>();
+    let dividend: number = Math.floor(num);
+    let remainder: number;
+    do {
+        remainder = dividend % 2;
+        stack.push(remainder);
+        dividend = Math.floor(dividend / 2);
+    } while (dividend > 0);
+    let result = "";
+    while (!stack.isEmpty()) {
+        result += stack.pop().toString();
+    }
+    return Number(result);
+}
+
+/**
+ * 通过实体id获取实体index
+ * @param id 实体id
+ */
+export function getEntityIndex(id: EntityId): number {
+    return id & EntityIndexMask;
+}
+
+/**
+ * 通过实体id获取实体版本
+ * @param id
+ */
+export function getEntityVersion(id: EntityId): number {
+    return id >>> EntityIndexBits;
+}
+
+/**
+ * 实体描述
+ * @param id 实体id
+ */
+export function entityIdString(id: EntityId): string {
+    return `${getEntityIndex(id)}:${getEntityVersion(id)}`;
+}
+// console.log("-------->", EntityIndexBits);  16
+// console.log("-------->", EntityIndexMask);  65535
+// console.log("-------->", MaxEntityCount);  65536

src/ecmodule/Entity.ts

@@ -0,0 +1,277 @@
+import { Component } from "./Component";
+import { EntityId } from "./ECType";
+import { EntityManager } from "./EntityManager";
+
+export class Entity {
+    /**
+     * 实体名称
+     * @type {String}
+     */
+    public name: string;
+
+    /**
+     * 实体ID
+     * @type {EntityId}
+     */
+    public id: EntityId;
+
+    /**
+     * 实体标识
+     * @type {Set<number>}
+     * @memberof Entity
+     */
+    public tags: Set<number>;
+
+    /**
+     * 实体状态
+     * @type {Map<number, number>}
+     * @memberof Entity
+     */
+    public states: Map<number, number>;
+    /**
+     * 是否被激活 （添加到实体管理器时激活）
+     * @type {boolean}
+     */
+    public active: boolean = false;
+
+    /**
+     * 所属实体管理器 （实体创建后直接赋值）
+     * @private
+     * @type {EntityManager}
+     */
+    public entityManager: EntityManager;
+
+    /**
+     * 所有组件
+     * @type {Map<number, Component>}
+     * @type {number} 组件类型
+     * @type {Component} 组件
+     */
+    public readonly components: Map<number, Component> = new Map();
+
+    /**
+     * 实体被添加到EntityManager
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public _add(): void {
+        this.active = true;
+        for (const component of this.components.values()) {
+            component._enter();
+        }
+    }
+
+    /**
+     * 实体销毁，不要手动调用
+     * @memberof Entity
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public _destroy(): void {
+        this.removeAllComponents();
+        this.tags && this.tags.clear();
+        this.states && this.states.clear();
+        this.active = false;
+        this.entityManager = null;
+    }
+
+    /**
+     * 添加标签
+     * @param {number[]} ...tags 标签除了表示Entity，还可以通过EntityManager获取指定标签的Entity
+     */
+    public addTag(...tag: number[]): void {
+        let tags = this.tags;
+        if (!tags) {
+            tags = this.tags = new Set<number>();
+        }
+        for (let i = 0; i < tag.length; i++) {
+            tags.add(tag[i]);
+            this.active && this.entityManager && this.entityManager._addEntityTag(this.id, tag[i]);
+        }
+    }
+
+    /**
+     * 删除标签
+     * @param {number} tag 删除的标签
+     */
+    public removeTag(tag: number): void {
+        if (this.tags) {
+            this.tags.delete(tag);
+            this.active && this.entityManager && this.entityManager._removeEntityTagById(this.id, tag);
+        }
+    }
+
+    /**
+     * 是否包含标签
+     * @param {number} tag 标签
+     * @returns {boolean} 是否包含
+     */
+    public hasTag(...tag: number[]): boolean {
+        let tags = this.tags;
+        if (!tags) {
+            return false;
+        }
+        for (let i = 0; i < tag.length; i++) {
+            if (tags.has(tag[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 获取组件
+     * @param {number} componentType 组件类型
+     * @returns {T}
+     */
+    public getComponent<T extends Component>(componentType: number): T {
+        return this.components.get(componentType) as T;
+    }
+
+    /**
+     * 添加组件
+     * @param {Component} component 组件
+     */
+    public addComponent(component: Component): void {
+        if (this.hasComponent(component.type)) {
+            throw new Error(`组件{${component.constructor.name}类型:${component.type}）已经存在，不允许添加同一类型组件`);
+        }
+        this.components.set(component.type, component);
+        component.entity = this;
+        component._add();
+
+        if (this.active) {
+            component._enter();
+        }
+    }
+
+    /**
+     * 删除组件
+     * @param {number} componentType 组件类型
+     */
+    public removeComponent(componentType: number): void {
+        const component = this.components.get(componentType);
+
+        if (component) {
+            this.components.delete(componentType);
+            component._remove();
+        }
+    }
+
+    /**
+     * 删除所有组件
+     */
+    public removeAllComponents(): void {
+        for (const component of this.components.values()) {
+            component._remove();
+        }
+        this.components.clear();
+    }
+
+    /**
+     * 是否包含组件
+     * @param {number} componentType 组件类型
+     * @returns {boolean} 是否包含组件
+     */
+    public hasComponent(componentType: number): boolean {
+        return this.components.has(componentType);
+    }
+
+    /**
+     * 销毁自己
+     */
+    public destroy(): void {
+        this.entityManager.destroyEntityById(this.id);
+    }
+
+    /**
+     * 添加监听
+     * @param eventName 监听的消息名
+     * @param callback 回调
+     * @param entityId 实体ID
+     * @param once 是否单次监听
+     */
+    public addEvent(eventName: string, callback: (...args: any[]) => void, once: boolean = false): void {
+        this.entityManager && this.entityManager._addEvent(eventName, callback, this, once);
+    }
+
+    /**
+     * 发送消息
+     * @param eventName 消息名
+     * @param entityId 实体ID
+     * @param args 发送参数
+     */
+    public sendListener(eventName: string, ...args: any[]): void {
+        this.entityManager && this.entityManager._sendEvent(eventName, this, ...args);
+    }
+
+    public removeListener(eventName: string, callback?: (...args: any[]) => void): void {
+        this.entityManager && this.entityManager._removeEvent(eventName, this, callback);
+    }
+
+    /**
+     * 添加状态
+     *  状态采用计数方式，对状态处理时需要保证addState和removeState成对存在
+     * @param {number} state 状态类型
+     * @memberof Entity
+     */
+    public addState(state: number): void {
+        let states = this.states;
+        if (!states) {
+            states = this.states = new Map<number, number>();
+        }
+        states.set(state, (states.get(state) || 0) + 1);
+    }
+
+    /**
+     * 删除状态
+     *
+     * @param {number} state 状态类型
+     * @returns {boolean} 如果计数为0或状态不存在，则返回true
+     * @memberof Entity
+     */
+    public removeState(state: number): boolean {
+        const states = this.states;
+        if (!states) {
+            return false;
+        }
+        let stateCount = states.get(state);
+        if (stateCount) {
+            // 处理状态计数，为0则删除状态
+            --stateCount;
+            if (stateCount == 0) {
+                states.delete(state);
+                return true;
+            }
+
+            states.set(state, stateCount);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * 是否包含指定状态
+     * @param {number} state 状态
+     * @returns {boolean}
+     * @memberof Entity
+     */
+    public hasState(state: number): boolean {
+        return this.states && this.states.has(state);
+    }
+
+    /**
+     * 清除状态
+     * @param {number} state 状态
+     * @memberof Entity
+     */
+    public clearState(state: number): void {
+        this.states && this.states.delete(state);
+    }
+
+    /**
+     * 清除所有状态
+     * @memberof Entity
+     */
+    public clearAllStates(): void {
+        this.states && this.states.clear();
+    }
+}

src/ecmodule/EntityManager.ts

@@ -0,0 +1,420 @@
+import { EventManager } from "../event/EventManager";
+import { warn } from "../tool/log";
+import { Component } from "./Component";
+import { ComponentManager } from "./ComponentManager";
+import { ComponentPool } from "./ComponentPool";
+import { EntityId, entityIdString, EntityIndexBits, getEntityIndex, getEntityVersion, MaxEntityCount } from "./ECType";
+import { Entity } from "./Entity";
+
+export class EntityManager {
+    /**
+     * 名称
+     * @type {string}
+     */
+    public name: string;
+
+    /**
+     * 单例实体
+     * @type {Entity}
+     */
+    public readonly insEntity: Entity = new Entity();
+
+    /**
+     * 单例实体激活状态
+     * @type {boolean}
+     */
+    public insActive: boolean = false;
+
+    /**
+     * 组件管理
+     * @type {ComponentManager}
+     */
+    public componentManager: ComponentManager;
+
+    /**
+     * 普通实体事件容器
+     * @type {EventManager}
+     */
+    private _eventManager: EventManager;
+
+    /**
+     * 单例实体消息监听容器
+     * @type {EventManager}
+     */
+    private _insEventManager: EventManager;
+
+    /** 实体池 */
+    private readonly _entityPool: Entity[] = [];
+    /** tag标记池 */
+    private readonly _tagToEntity: Map<number, Set<EntityId>> = new Map<number, Set<EntityId>>();
+    /** 实体回收池 */
+    private _recyclePool: Entity[] = [];
+    /** 实体回收池最大容量 */
+    private _maxCapacityInPool: number;
+    /** 实体回收版本 */
+    private _entityVersion: number[] = [];
+    /** 回收实体ID */
+    private _recycleEntityIds: EntityId[] = [];
+    /** 世界是否删除 */
+    private _isDestroyed: boolean;
+    /** 是否正在更新 */
+    private _updating: boolean;
+    /**
+     * 实体池最大容量，回收的多余的实体不会缓存
+     * @param {string} name 名称
+     * @param {ComponentPool} componentPool 组件池
+     * @param {ComponentPool} componentUpdateOrderList 组件更新顺序
+     * @param {number} [maxCapacityInPool=128] 实体回收池最大容量
+     * @param {number} [preloadEntityCount=32] 预加载Entity数量
+     */
+    // eslint-disable-next-line prettier/prettier
+    constructor(name: string, componentPool: ComponentPool, componentUpdateOrderList: number[], maxCapacityInPool: number = 128, preloadEntityCount: number = 32) {
+        this.name = name;
+        if (preloadEntityCount >= MaxEntityCount) {
+            throw new Error(`预加载超出实体最大数量：${preloadEntityCount} >= max(${MaxEntityCount})`);
+        }
+        // 占位
+        this._entityPool.push(null);
+        this._entityVersion.push(1);
+        this._maxCapacityInPool = maxCapacityInPool;
+        // 预创建
+        for (let i = 0; i < preloadEntityCount; ++i) {
+            this._recyclePool.push(new Entity());
+        }
+        // 组件管理器
+        this.componentManager = new ComponentManager(componentPool, componentUpdateOrderList);
+        this.insEntity.entityManager = this;
+    }
+
+    /**
+     * 添加实体标签（内部使用）
+     * @param {EntityId} entityId 实体Id
+     * @param {number} tag 标签
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public _addEntityTag(entityId: EntityId, tag: number): void {
+        this._validateEntityById(entityId);
+        let entitiesByTag = this._tagToEntity.get(tag);
+        if (!entitiesByTag) {
+            entitiesByTag = new Set<EntityId>();
+            this._tagToEntity.set(tag, entitiesByTag);
+        }
+        entitiesByTag.add(entityId);
+    }
+
+    /**
+     * 删除实体Tag（内部使用）
+     * @param {Entity} entity 实体
+     * @param {number} tag 标签
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public _removeEntityTag(entity: Entity, tag: number): void {
+        this._removeEntityTagById(entity.id, tag);
+    }
+
+    /**
+     * 通过实体ID删除实体Tag（内部使用）
+     * @param {EntityId} entityId 实体Id
+     * @param {number} tag 标签
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public _removeEntityTagById(entityId: EntityId, tag: number): void {
+        this._validateEntityById(entityId);
+        const entitiesByTag = this._tagToEntity.get(tag);
+        if (entitiesByTag) {
+            entitiesByTag.delete(entityId);
+        }
+    }
+
+    /**
+     * 创建实体
+     * @returns {Entity} 实体
+     */
+    public createEntity(name: string): Entity {
+        const entity = this._recyclePool.pop() || new Entity();
+        entity.id = 0;
+        entity.name = name;
+        entity.entityManager = this;
+        return entity;
+    }
+
+    /**
+     * 添加实体
+     * @param {Entity} entity 要添加的实体
+     */
+    public addEntity(entity: Entity): void {
+        if (this.exists(entity.id)) {
+            throw new Error(`实体（${entityIdString(entity.id)}）已经添加到EntityManager`);
+        }
+        // 分配实体Id
+        if (this._recycleEntityIds.length > 0) {
+            const newIndex = this._recycleEntityIds.pop();
+            this._entityPool[newIndex] = entity;
+            entity.id = (this._entityVersion[newIndex] << EntityIndexBits) | newIndex;
+        } else {
+            this._entityPool.push(entity);
+            this._entityVersion.push(1);
+            entity.id = MaxEntityCount | (this._entityPool.length - 1);
+        }
+        this._addEntityToTag(entity);
+        entity._add();
+    }
+
+    /**
+     * 销毁实体
+     * @param {Entity} entity 要删除的实体
+     */
+    public destroyEntity(entity: Entity): void {
+        this.destroyEntityById(entity.id);
+    }
+
+    /**
+     * 销毁指定ID实体
+     * @param {EntityId} entityId 实体Id
+     */
+    public destroyEntityById(entityId: EntityId): void {
+        const entity = this.getEntity(entityId);
+        if (!entity) {
+            warn(`实体(${entityIdString(entityId)})已经被销毁`);
+            return;
+        }
+        this._recycleEntity(entity);
+        this._eventManager && this._eventManager.removeList(entity);
+    }
+
+    /**
+     * 销毁所有实体
+     * @param {boolean} ignoreSingletonEntity 是否忽略单例实体
+     */
+    public destroyAllEntities(ignoreSingletonEntity: boolean): void {
+        const entities = this._entityPool;
+        for (let i = 1, len = entities.length; i < len; ++i) {
+            if (entities[i]) {
+                this._destroyEntity(entities[i]);
+            }
+        }
+        this._recycleEntityIds.length = 0;
+        this._entityPool.length = 0;
+        this._entityVersion.length = 0;
+        this._tagToEntity.clear();
+
+        // 占位
+        this._entityPool.push(null);
+        this._entityVersion.push(1);
+        this._eventManager && this._eventManager.destroyAll();
+
+        // 销毁单例实体组件
+        if (!ignoreSingletonEntity) {
+            this.insEntity._destroy();
+            this.insActive = false;
+            this._insEventManager && this._insEventManager.destroyAll();
+        }
+    }
+
+    /**
+     * 通过实体ID获取实体
+     * @param {EntityId} entityId 实体Id
+     * @returns {(Entity | null)} 实体
+     */
+    public getEntity(entityId: EntityId): Entity | null {
+        const index = getEntityIndex(entityId);
+        if (index <= 0 || index >= this._entityPool.length) {
+            return null;
+        }
+        if (this._entityVersion[index] == getEntityVersion(entityId)) {
+            return this._entityPool[index];
+        }
+        return null;
+    }
+
+    /**
+     * 获取指定标签的实体
+     * @param {number} tag 标签
+     * @returns {Entity[]} 返回的实体池
+     */
+    public getEntitiesByTag(tag: number): Entity[] {
+        let buffer: Entity[] = [];
+        const entitiesByTag = this._tagToEntity.get(tag);
+        if (entitiesByTag) {
+            for (const entityId of entitiesByTag) {
+                const entity = this.getEntity(entityId);
+                entity && buffer.push(entity);
+            }
+        }
+        return buffer;
+    }
+
+    /**
+     * 根据实体ID判断实体是否存在
+     * @param {EntityId} entityId 实体Id
+     * @returns {boolean}
+     */
+    public exists(entityId: EntityId): boolean {
+        const index = getEntityIndex(entityId);
+        if (index <= 0 || index >= this._entityPool.length) {
+            return false;
+        }
+        const entity = this._entityPool[index];
+        return entity && this._entityVersion[index] == getEntityVersion(entityId);
+    }
+
+    /**
+     * 创建组件
+     * @template T 组件类型
+     * @param {string} componentName 组件名
+     * @returns {T} 创建的组件
+     */
+    public createComponent<T extends Component>(componentName: string): T {
+        return this.componentManager.createComponent<T>(componentName);
+    }
+
+    /**
+     * 添加单例组件
+     * @param component
+     */
+    public addSingleton(component: Component): void {
+        this.insEntity.addComponent(component);
+    }
+
+    /**
+     * 获取单例组件
+     */
+    public getSingleton<T extends Component>(componentType: number): T {
+        return this.insEntity.getComponent<T>(componentType);
+    }
+
+    /**
+     * 删除单例组件
+     */
+    public removeSingleton(componentType: number): void {
+        this.insEntity.removeComponent(componentType);
+    }
+
+    /**
+     * 是否存在对应的单例组件
+     */
+    public hasSingleton(componentType: number): boolean {
+        return this.insEntity.hasComponent(componentType);
+    }
+
+    /**
+     * 激活单例组件
+     */
+    public activeSingleton(): void {
+        const insEntity = this.insEntity;
+        if (this.insActive) {
+            throw new Error("单例实体已经被激活");
+        }
+        this.insActive = true;
+        insEntity.id = -1;
+        insEntity._add();
+    }
+
+    /**
+     * 销毁EntityManager
+     */
+    public destroy(): void {
+        if (this._isDestroyed) {
+            return;
+        }
+        if (this._updating) {
+            throw new Error("请勿在更新时销毁EntityManager");
+        }
+        this.destroyAllEntities(false);
+        this.componentManager.destroy();
+        this._isDestroyed = true;
+    }
+
+    /**
+     * 添加消息监听 (内部使用)
+     * @param eventName 消息名
+     * @param callback 事件回调
+     * @param entityId 实体ID
+     * @param once 是否单次事件
+     */
+    public _addEvent(eventName: string, callback: (...args: any[]) => void, entity: Entity, once: boolean = false): void {
+        if (entity == this.insEntity) {
+            this._insEventManager = this._insEventManager ? this._insEventManager : new EventManager();
+            this._insEventManager._addEvent(eventName, callback, once, entity);
+            return;
+        }
+        this._eventManager = this._eventManager ? this._eventManager : new EventManager();
+        this._eventManager._addEvent(eventName, callback, once, entity);
+    }
+
+    /**
+     * 发送消息 (内部使用)
+     * @param eventName 消息名
+     * @param entityId 实体ID
+     * @param args 发送参数
+     */
+    public _sendEvent(eventName: string, entity: Entity, ...args: any[]): void {
+        if (entity == this.insEntity) {
+            this._insEventManager && this._insEventManager.send(eventName, entity, ...args);
+            return;
+        }
+        this._eventManager && this._eventManager.send(eventName, entity, ...args);
+    }
+
+    public _removeEvent(eventName: string, entity: Entity, callback?: (...args: any[]) => void): void {
+        if (entity == this.insEntity) {
+            this._insEventManager && this._insEventManager.remove(eventName, callback, entity);
+            return;
+        }
+        this._eventManager && this._eventManager.remove(eventName, callback, entity);
+    }
+
+    /** 更新 */
+    public update(dt: number): void {
+        this._updating = true;
+        this.componentManager._update(dt);
+        this._updating = false;
+    }
+
+    /**
+     * 回收Entity
+     * @param {Entity} entity 要回收的Entity
+     */
+    private _recycleEntity(entity: Entity): void {
+        // 回收实体Id
+        const entityIndex = getEntityIndex(entity.id);
+        this._recycleEntityIds.push(entityIndex);
+        this._entityPool[entityIndex] = null;
+        ++this._entityVersion[entityIndex];
+
+        this._destroyEntity(entity);
+    }
+
+    /**
+     * 销毁实体
+     * @param {Entity} entity
+     */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    private _destroyEntity(entity: Entity): void {
+        entity._destroy();
+        if (this._recyclePool.length < this._maxCapacityInPool) {
+            this._recyclePool.push(entity);
+        }
+    }
+
+    /**
+     * 实体根据tag添加到tag列表中
+     * @param entity
+     */
+    private _addEntityToTag(entity: Entity): void {
+        const tags = entity.tags;
+        if (!tags || tags.size == 0) {
+            return;
+        }
+        const entityId = entity.id;
+        for (const tag of tags.values()) {
+            this._addEntityTag(entityId, tag);
+        }
+    }
+
+    private _validateEntityById(entityId: EntityId): void {
+        if (!this.exists(entityId)) {
+            throw new Error(`实体（${entityId}）不存在`);
+        }
+    }
+}

src/ecmodule/ObjectBase.ts

@@ -0,0 +1,17 @@
+export class ObjectBase {
+    /** 是否被回收 */
+    public recycled: boolean;
+
+    /** 对象类型 */
+    public objectType: number;
+
+    /** 回收 */
+    public _recycle(): void {
+        this.recycled = true;
+    }
+
+    /** 重新利用 */
+    public _reuse(): void {
+        this.recycled = false;
+    }
+}

src/ecmodule/ObjectFactory.ts

@@ -0,0 +1,64 @@
+import { ObjectBase } from "./ObjectBase";
+
+export class ObjectFactory {
+    /** 对象类 */
+    private _ctor: new () => ObjectBase;
+    /** 对象名称 */
+    private _name: string;
+    /** 对象类型 */
+    private _objectType: number;
+    /** 最大容量 */
+    private _maxCapacity: number;
+    /** 对象池 */
+    private _stack: ObjectBase[] = [];
+
+    constructor(objectType: number, capacity: number, name: string, objectClass: new () => ObjectBase) {
+        this._objectType = objectType;
+        this._maxCapacity = capacity;
+        this._name = name;
+        this._ctor = objectClass;
+    }
+
+    /**
+     * 获取对象名称
+     * @returns {string} 对象名称
+     */
+    public get name(): string {
+        return this._name;
+    }
+
+    /**
+     * 获取对象
+     * @returns {T} 返回的组件
+     */
+    public allocate<T extends ObjectBase>(): T {
+        if (this._stack.length == 0) {
+            const ret = new this._ctor() as T;
+            ret.objectType = this._objectType;
+            return ret;
+        }
+        const ret = this._stack.pop() as T;
+        ret._reuse();
+        return ret;
+    }
+
+    /**
+     * 回收对象
+     * @returns {boolean}
+     */
+    public recycle(ret: ObjectBase): boolean {
+        if (ret.recycled) {
+            throw new Error(`对象（${ret.constructor.name}）已经被回收了`);
+        }
+        if (this._maxCapacity > 0 && this._stack.length < this._maxCapacity) {
+            ret._recycle();
+            this._stack.push(ret);
+            return true;
+        }
+        return false;
+    }
+
+    public _clear(): void {
+        this._stack.length = 0;
+    }
+}

src/event/Event.ts

@@ -0,0 +1,20 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 
+ */
+
+export class Event {
+    public id: number;
+    public name: string;
+    public target: any;
+    public once: boolean = false;
+    public callback: (...arg: any[]) => void;
+    public _destroy: boolean = false;
+    public _reset(): void {
+        this._destroy = false;
+    }
+    public _recycle(): void {
+        this._destroy = true;
+    }
+}

src/event/EventFactory.ts

@@ -0,0 +1,43 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 
+ */
+
+import { Event } from "./Event";
+
+export class EventFactory {
+    private _id: number = 0;
+    private _stack: Event[] = [];
+    private _maxCapacity: number = 64;
+    private _msgClass: new () => Event;
+
+    get id(): number {
+        return this._id++;
+    }
+
+    constructor(capacity: number, objectClass: new () => Event) {
+        this._maxCapacity = capacity;
+        this._msgClass = objectClass;
+    }
+
+    public allocate<T extends Event>(): T {
+        if (this._stack.length == 0) {
+            const ret = new this._msgClass() as T;
+            ret.id = this.id;
+            return ret;
+        }
+        const ret = this._stack.pop() as T;
+        ret._reset();
+        return ret;
+    }
+
+    public recycle(ret: Event): boolean {
+        if (this._maxCapacity > 0 && this._stack.length < this._maxCapacity) {
+            ret._recycle();
+            this._stack.push(ret);
+            return true;
+        }
+        return false;
+    }
+}

src/event/EventManager.ts

@@ -0,0 +1,213 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 
+ */
+
+import { Event } from "./Event";
+import { EventFactory } from "./EventFactory";
+
+export class EventManager {
+    private _idToEvent: Map<number, Event> = new Map<number, Event>();
+    private _nameToIds: Map<string, Set<number>> = new Map<string, Set<number>>();
+    private _targetToIds: Map<any, Set<number>> = new Map<any, Set<number>>();
+    private _factroy: EventFactory = new EventFactory(64, Event);
+    /**
+     * 添加事件监听器。
+     * @param name - 事件名称。
+     * @param callback - 回调函数，当事件触发时执行。
+     * @param target - 可选参数，指定事件监听的目标对象。
+     * 该方法将事件和回调函数注册到事件管理器中，以便在事件触发时执行相应的回调函数。
+     */
+    public addEvent(name: string, callback: (...args: any[]) => void, target?: any): void {
+        this._addEvent(name, callback, false, target);
+    }
+
+    /**
+     * 添加一个只触发一次的事件监听器。
+     * @param name - 事件名称。
+     * @param callback - 事件触发时要执行的回调函数。
+     * @param target - 可选参数，指定事件监听器的目标对象。
+     */
+    public addEventOnce(name: string, callback: (...args: any[]) => void, target?: any): void {
+        this._addEvent(name, callback, true, target);
+    }
+
+    /**
+     * 发送事件给所有注册的监听器。
+     * @param name - 事件名称。
+     * @param target - 可选参数，指定目标对象，只有目标对象匹配时才会触发监听器。 (制定目标对象 效率更高)
+     * @param args - 传递给监听器回调函数的参数。
+     */
+    public send(name: string, target?: any, ...args: any[]): void {
+        let nameToIds = this._nameToIds;
+        if (!nameToIds.has(name)) {
+            return;
+        }
+        let ids = nameToIds.get(name);
+        let listenerMap = this._idToEvent;
+
+        let needRemoveIds: number[] = [];
+        let triggerList: Event[] = [];
+        for (const id of ids.values()) {
+            if (!listenerMap.has(id)) {
+                throw new Error(`消息ID:【${id}】不存在`);
+            }
+            let listener = listenerMap.get(id);
+            if (!listener._destroy && (!target || target == listener.target)) {
+                triggerList.push(listener);
+                if (listener.once) {
+                    listener._destroy = true;
+                    needRemoveIds.push(listener.id);
+                }
+            }
+        }
+        for (const listener of triggerList) {
+            listener.callback(...args);
+        }
+        if (needRemoveIds.length > 0) {
+            for (const id of needRemoveIds) {
+                this._remove(id);
+            }
+        }
+    }
+
+    /**
+     * 移除指定名称的事件监听器。
+     * @param name - 事件名称。
+     * @param callback - 要移除的回调函数。
+     * @param target - 回调函数绑定的目标对象。
+     * 该方法会遍历与指定名称关联的所有监听器ID，检查每个监听器的回调函数和目标对象，
+     * 如果匹配则将其ID添加到待移除列表中，最后统一移除这些监听器。
+     */
+    public remove(name: string, callback: () => void, target: any): void {
+        let nameToIds = this._nameToIds;
+        if (!nameToIds.has(name)) {
+            return;
+        }
+        let ids = nameToIds.get(name);
+        if (ids.size == 0) {
+            return;
+        }
+
+        let needRemoveIds: number[] = [];
+        for (const id of ids.values()) {
+            let listener = this._idToEvent.get(id);
+            let needRemove = true;
+            if (callback && listener.callback != callback) {
+                needRemove = false;
+            }
+            if (target && listener.target != target) {
+                needRemove = false;
+            }
+            needRemove && needRemoveIds.push(id);
+        }
+        if (needRemoveIds.length > 0) {
+            for (const id of needRemoveIds) {
+                this._remove(id);
+            }
+        }
+    }
+
+    public removeByNameAndTarget(name: string, target: any): void {
+        this.remove(name, null, target);
+    }
+
+    public removeByNameAndCallback(name: string, callback: () => void): void {
+        this.remove(name, callback, null);
+    }
+
+    /**
+     * 移除与指定目标关联的所有监听器。
+     * 如果目标不存在或关联的监听器ID集合为空，则不执行任何操作。
+     * 对于每个监听器ID，从_idToEvent映射中删除监听器，并将其回收到工厂中。
+     * 同时，更新_nameToIds映射，确保名称到ID集合的映射保持最新。
+     * @param target - 要移除监听器的目标对象。
+     */
+    public removeList(target: any): void {
+        let targetToIds = this._targetToIds;
+        if (!targetToIds.has(target)) {
+            return;
+        }
+        let ids = targetToIds.get(target);
+        if (ids.size == 0) {
+            return;
+        }
+        for (const id of ids.values()) {
+            let listener = this._idToEvent.get(id);
+            let name = listener.name;
+
+            this._idToEvent.delete(id);
+            this._factroy.recycle(listener);
+
+            let nameToIds = this._nameToIds;
+            if (nameToIds.has(name)) {
+                nameToIds.get(name).delete(id);
+            }
+        }
+        ids.clear();
+    }
+
+    public destroyAll(): void {
+        let listeners = this._idToEvent;
+        for (const listener of listeners.values()) {
+            this._factroy.recycle(listener);
+        }
+        this._idToEvent.clear();
+        this._nameToIds.clear();
+        this._targetToIds.clear();
+    }
+
+    public _addEvent(name: string, callback: (...arg: any[]) => void, once: boolean, target: any): void {
+        let listener = this._factroy.allocate<Event>();
+        listener.name = name;
+        listener.target = target;
+        listener.once = once;
+        listener.callback = callback;
+        this._idToEvent.set(listener.id, listener);
+
+        let nameToIds = this._nameToIds;
+        let ids: Set<number>;
+        if (nameToIds.has(name)) {
+            ids = nameToIds.get(name);
+        } else {
+            ids = new Set<number>();
+            nameToIds.set(name, ids);
+        }
+        ids.add(listener.id);
+        if (target) {
+            let targetToIds = this._targetToIds;
+            if (!targetToIds.has(target)) {
+                let ids = new Set<number>();
+                ids.add(listener.id);
+                targetToIds.set(target, ids);
+            } else {
+                let ids = targetToIds.get(target);
+                ids.add(listener.id);
+            }
+        }
+    }
+
+    private _remove(id: number): void {
+        if (!this._idToEvent.has(id)) {
+            return;
+        }
+        let ids = this._idToEvent.get(id);
+        let name = ids.name;
+        let target = ids.target;
+
+        this._idToEvent.delete(id);
+        this._factroy.recycle(ids);
+
+        let nameToIds = this._nameToIds;
+        if (nameToIds.has(name)) {
+            nameToIds.get(name).delete(id);
+        }
+        if (target) {
+            let targetToIds = this._targetToIds;
+            if (targetToIds.has(target)) {
+                targetToIds.get(target).delete(id);
+            }
+        }
+    }
+}

src/fgui/Window.ts

@@ -0,0 +1,70 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-14
+ * @Description: 
+ */
+import { WindowBase } from "./WindowBase";
+
+export abstract class Window extends WindowBase {
+    protected onAdapted(): void {
+
+    }
+    /**
+     * 初始化窗口时调用的方法。
+     * 子类必须实现的方法，用来设置窗口的属性。
+     */
+    protected abstract onInit(): void
+    /**
+     * 窗口关闭时的处理逻辑。
+     * 子类可以重写此方法以实现自定义的关闭行为。
+     */
+    protected onClose(): void {
+
+    }
+
+    /**
+     * 窗口显示时的回调函数。
+     * @param userdata 可选参数，传递给窗口显示时的用户数据。
+     */
+    protected onShow(userdata?: any): void {
+
+    }
+    /**
+     * 隐藏窗口时的处理逻辑。
+     * 重写此方法以实现自定义的隐藏行为。
+     */
+    protected onHide(): void {
+
+    }
+
+    /**
+     * 当窗口从隐藏状态变为显示状态时调用。
+     * 这个方法可以被子类重写以实现特定的显示逻辑。
+     */
+    protected onShowFromHide(): void {
+
+    }
+
+    /**
+     * 当窗口被覆盖时触发的事件处理函数。
+     * 子类可以重写此方法以添加自定义行为。
+     */
+    protected onCover(): void {
+
+    }
+    /**
+     * 恢复窗口状态时的处理逻辑。
+     * 此方法在窗口从隐藏或最小化状态恢复时被调用。
+     */
+    protected onRecover(): void {
+
+    }
+
+    /**
+     * 空白区域点击事件处理函数。
+     * 当用户点击窗口的空白区域时触发此方法。
+     */
+    protected onEmptyAreaClick(): void {
+
+    }
+}

src/fgui/WindowBase.ts

@@ -0,0 +1,155 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-14
+ * @Description: 窗口基类
+ */
+
+import { GComponent } from "fairygui-cc";
+import { Screen } from "../global/Screen";
+import { AdapterType, WindowType } from "../ui/header";
+import { IWindow } from "../ui/IWindow";
+import { IWindowHeader } from "../ui/IWindowHeader";
+import { WindowHeaderInfo } from "../ui/WindowHeaderInfo";
+import { WindowHeader } from "./WindowHeader";
+
+export abstract class WindowBase extends GComponent implements IWindow {
+    /** 窗口类型 */
+    public type: WindowType = WindowType.Normal;
+    /** 窗口适配类型 */
+    public adapterType: AdapterType = AdapterType.Full;
+    /** 底部遮罩的透明度 */
+    public bgAlpha: number;
+    /** header (内部使用) */
+    private _header: IWindowHeader = null;
+    /** 窗口是否被遮挡了 */
+    private _isCover: boolean = false;
+    /**
+     * 初始化方法 (框架内部使用)
+     * @param swallowTouch 是否吞噬触摸事件
+     */
+    public _init(swallowTouch: boolean, bgAlpha: number): void {
+        if (swallowTouch) {
+            // 吞噬触摸事件，需要一个全屏的节点, 窗口本身可能留有安全区的边
+            let bgNode = new GComponent();
+            bgNode.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+            bgNode.setPivot(0.5, 0.5, true);
+            bgNode.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+            this.addChild(bgNode);
+            // 调整显示层级
+            bgNode.parent.setChildIndex(bgNode, 0);
+            bgNode.onClick(this.onEmptyAreaClick, this);
+            bgNode.opaque = swallowTouch;
+        }
+        // 窗口自身也要设置是否吞噬触摸
+        this.opaque = swallowTouch;
+        this.bgAlpha = bgAlpha;
+        this.onInit();
+    }
+
+    public _adapted(): void {
+        this.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+        this.setPivot(0.5, 0.5, true);
+        switch (this.adapterType) {
+            case AdapterType.Full:
+                this.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+                break;
+            case AdapterType.Bang:
+                this.setSize(Screen.SafeWidth, Screen.SafeHeight, true);
+                break;
+            default:
+                break;
+        }
+        this.onAdapted();
+    }
+
+    /** 
+     * 窗口关闭 (框架内部使用)
+     */
+    public _close(): void {
+        this.onClose();
+        this.dispose();
+    }
+    /**
+     * 显示窗口 (框架内部使用)
+     * @param userdata 用户自定义数据
+     */
+    public _show(userdata?: any): void {
+        this.visible = true;
+        this.onShow(userdata);
+    }
+    /** 
+     * 隐藏窗口 (框架内部使用)
+     */
+    public _hide(): void {
+        this.visible = false;
+        this.onHide();
+    }
+    /**
+     * 从隐藏状态恢复显示
+     */
+    public _showFromHide(): void {
+        this.visible = true;
+        this.onShowFromHide();
+    }
+
+    /**
+     * 遮挡窗口 被同组或者不同组的其他窗口覆盖 (框架内部使用)
+     */
+    public _cover(): void {
+        this._isCover = true;
+        this.onCover();
+    }
+    /**
+     * 遮挡恢复窗口 被同组或者不同组的其他窗口覆盖恢复 (框架内部使用)
+     */
+    public _recover(): void {
+        this._isCover = false;
+        this.onRecover();
+    }
+
+    public _setDepth(depth: number): void {
+        this.parent.setChildIndex(this, depth);
+    }
+
+    public isShowing(): boolean {
+        return this.visible;
+    }
+
+    public isCover(): boolean {
+        return this._isCover;
+    }
+
+    public screenResize(): void {
+        this._adapted();
+    }
+
+    /**
+     * 获取窗口顶部资源栏数据 默认返回空数组
+     * @returns {WindowHeaderInfo[]}
+     */
+    public getHeaderInfo(): WindowHeaderInfo {
+        return null;
+    }
+
+    public getHeader<T extends WindowHeader>(): T | null {
+        return this._header as T;
+    }
+
+    public setHeader<T extends IWindowHeader>(header: T): void {
+        this._header = header;
+    }
+
+    protected abstract onAdapted(): void;
+
+    protected abstract onInit(): void;
+    protected abstract onClose(): void;
+
+    protected abstract onShow(userdata?: any): void;
+    protected abstract onShowFromHide(): void;
+    protected abstract onHide(): void;
+
+    protected abstract onCover(): void;
+    protected abstract onRecover(): void;
+
+    protected abstract onEmptyAreaClick(): void;
+}

src/fgui/WindowHeader.ts

@@ -0,0 +1,97 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-11
+ * @Description: 窗口顶边栏
+ * 窗口顶边资源栏 同组中只会有一个显示
+ */
+
+import { GComponent } from "fairygui-cc";
+import { Screen } from "../global/Screen";
+import { AdapterType } from "../kunpocc";
+import { IWindow } from "../ui/IWindow";
+import { IWindowHeader } from "../ui/IWindowHeader";
+
+
+export abstract class WindowHeader extends GComponent implements IWindowHeader {
+    /** 窗口适配类型 */
+    public adapterType: AdapterType = AdapterType.Full;
+    /** 引用计数 */
+    public _refCount: number = 0;
+
+    protected abstract onInit(): void;
+    protected abstract onShow(window: IWindow, userdata?: any): void;
+    protected abstract onClose(): void;
+
+    protected onHide(): void {
+
+    }
+    protected onAdapted(): void {
+
+    }
+
+    /**
+     * 初始化 (内部方法)
+     */
+    public _init(): void {
+        this.onInit();
+    }
+
+    /**
+     * 窗口适配 (内部方法)
+     */
+    public _adapted(): void {
+        this.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+        this.setPivot(0.5, 0.5, true);
+        switch (this.adapterType) {
+            case AdapterType.Full:
+                this.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+                break;
+            case AdapterType.Bang:
+                this.setSize(Screen.SafeWidth, Screen.SafeHeight, true);
+                break;
+            default:
+                break;
+        }
+        this.onAdapted();
+    }
+
+    /**
+     * 显示 (内部方法)
+     * @param {IWindow} window 所属窗口
+     */
+    public _show(window: IWindow): void {
+        this.visible = true;
+        this.onShow(window, window.getHeaderInfo()?.userdata);
+    }
+
+    /**
+     * 隐藏 (内部方法)
+     */
+    public _hide(): void {
+        this.visible = false;
+        this.onHide();
+    }
+
+    /**
+     * 关闭 (内部方法)
+     */
+    public _close(): void {
+        this.onClose();
+        this.dispose();
+    }
+
+    /** 增加引用计数 (内部方法) */
+    public _addRef(): void {
+        this._refCount++;
+    }
+
+    /** 减少引用计数 (内部方法) */
+    public _decRef(): number {
+        return --this._refCount;
+    }
+
+    /** 屏幕大小改变时被调用 (内部方法) */
+    public _screenResize(): void {
+        this._adapted();
+    }
+}

src/global/Adapter.ts

@@ -0,0 +1,85 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 适配用的类
+ */
+
+import { ResolutionPolicy, view } from "cc";
+import { info } from "../tool/log";
+import { WindowManager } from "../ui/WindowManager";
+import { Screen } from "./Screen";
+import { size } from "./header";
+
+export abstract class Adapter {
+    public init() {
+        // 设计尺寸 不会变化
+        let designSize = this.getDesignSize();
+        Screen.DesignHeight = designSize.height;
+        Screen.DesignWidth = designSize.width;
+        view.setDesignResolutionSize(Screen.DesignWidth, Screen.DesignWidth, ResolutionPolicy.SHOW_ALL);
+
+        this.resize();
+        this.registerResizeCallback((...args: any) => {
+            info("屏幕发生变化", ...args);
+            this.resize();
+        });
+    }
+
+    protected resize(): void {
+        Screen.SafeAreaHeight = 60;
+        // 屏幕像素尺寸
+        const winSize = this.getScreenSize();
+        const isDesignLandscape = Screen.DesignWidth > Screen.DesignHeight;
+        const isLandscape = winSize.width > winSize.height;
+        if (isDesignLandscape == isLandscape) {
+            Screen.ScreenWidth = winSize.width;
+            Screen.ScreenHeight = winSize.height;
+        } else {
+            Screen.ScreenWidth = winSize.height;
+            Screen.ScreenHeight = winSize.width;
+        }
+        if (isDesignLandscape) {
+            // 横屏
+            /** 安全区的宽度 */
+            Screen.SafeWidth = Screen.ScreenWidth - Screen.SafeAreaHeight * 2;
+            /** 安全区的高度 */
+            Screen.SafeHeight = Screen.ScreenHeight;
+        } else {
+            // 竖屏
+            /** 安全区的宽度 */
+            Screen.SafeWidth = Screen.ScreenWidth;
+            /** 安全区的高度 */
+            Screen.SafeHeight = Screen.ScreenHeight - Screen.SafeAreaHeight * 2;
+        }
+        WindowManager._screenResize();
+        this.printScreen();
+    }
+
+    private printScreen() {
+        info(`设计分辨率: ${Screen.DesignWidth}x${Screen.DesignHeight}`);
+        info(`屏幕分辨率: ${Screen.ScreenWidth}x${Screen.ScreenHeight}`);
+        info(`安全区域高度: ${Screen.SafeAreaHeight}`);
+        info(`安全区宽高: ${Screen.SafeWidth}x${Screen.SafeHeight}`);
+    }
+
+    /**
+     * 获取屏幕尺寸
+     * @abstract 子类实现
+     * @returns {size}
+     */
+    protected abstract getScreenSize(): size;
+
+    /**
+     * 获取设计尺寸
+     * @abstract 子类实现
+     * @returns {size}
+     */
+    protected abstract getDesignSize(): size;
+
+    /**
+     * 设置尺寸发生变化的监听
+     * @abstract 子类实现
+     * @param callback 
+     */
+    protected abstract registerResizeCallback(callback: () => void): void;
+}

src/global/GlobalEvent.ts

@@ -0,0 +1,44 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-22
+ * @Description: 全局事件
+ */
+
+import { EventManager } from "../event/EventManager";
+
+export class GlobalEvent {
+    private static _globalEvent: EventManager = null;
+    public static add(eventName: string, callback: (...args: any[]) => void, target: any): void {
+        this._globalEvent.addEvent(eventName, callback, target);
+    }
+
+    public static addOnce(eventName: string, callback: (...args: any[]) => void, target: any): void {
+        this._globalEvent.addEventOnce(eventName, callback, target);
+    }
+
+    public static send(eventName: string, ...args: any[]): void {
+        this._globalEvent.send(eventName, null, ...args);
+    }
+
+    public static sendToTarget(eventName: string, target: any, ...args: any[]) {
+        this._globalEvent.send(eventName, target, ...args);
+    }
+
+    public static remove(eventName: string, callback: (...args: any[]) => void, target?: any): void {
+        this._globalEvent.remove(eventName, callback, target);
+    }
+
+    public static removeByNameAndTarget(eventName: string, target: any) {
+        this._globalEvent.removeByNameAndTarget(eventName, target);
+    }
+
+    public static removeByTarget(target: any): void {
+        this._globalEvent.removeList(target);
+    }
+
+    public static _initGlobalEvent(): void {
+        if (!this._globalEvent) {
+            this._globalEvent = new EventManager();
+        }
+    }
+}

src/global/GlobalTimer.ts

@@ -0,0 +1,76 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 
+ */
+
+import { Timer } from "../tool/timer/Timer";
+
+export class GlobalTimer {
+    private static _timer: Timer = null;
+    /**
+     * 初始化全局定时器，设置定时器间隔为16毫秒。
+     * 此方法用于启动一个定时器实例，以便在整个应用程序中跟踪时间相关的操作。
+     */
+    public static initTimer(): void {
+        this._timer = new Timer(16);
+    }
+
+    /**
+     * 获取全局定时器实例。如果定时器尚未初始化，则进行初始化。
+     * @returns {Timer} 全局定时器实例
+     */
+    public static get Timer(): 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。
+     */
+    public static startTimer(callback: () => void, interval: number, loop: number = 0): number {
+        return this.Timer.start(callback, interval, loop);
+    }
+
+    /**
+     * 停止指定ID的计时器。
+     * @param timerId - 要停止的计时器的唯一标识符。
+     */
+    public static stopTimer(timerId: number): void {
+        this.Timer.stop(timerId);
+    }
+
+    /**
+     * 暂停指定ID的计时器。
+     * @param timerId - 要暂停的计时器的唯一标识符。
+     */
+    public static pauseTimer(timerId: number): void {
+        this.Timer.pause(timerId);
+    }
+
+    /**
+     * 恢复指定ID的计时器。
+     * @param timerId - 要恢复的计时器的唯一标识符。
+     */
+    public static resumeTimer(timerId: number): void {
+        this.Timer.resume(timerId);
+    }
+
+    /**
+     * 清除所有定时器。
+     */
+    public static clearAllTimer(): void {
+        this.Timer.clear();
+    }
+
+    public static update(dt: number): void {
+        this._timer?.update(dt);
+    }
+}

src/global/IModule.ts

@@ -0,0 +1,13 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 模块接口
+ */
+
+export interface IModule {
+    /** 模块名称 */
+    moduleName: string;
+
+    /** 模块初始化 */
+    init(): void;
+}

src/global/InnerTimer.ts

@@ -0,0 +1,40 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-02-14
+ * @Description: 内部使用的全局定时器
+ */
+import { Timer } from "../tool/timer/Timer";
+
+export class InnerTimer {
+    private static _timer: Timer = null;
+    /**
+     * 初始化全局定时器，设置定时器间隔为16毫秒。
+     * 此方法用于启动一个定时器实例，以便在整个应用程序中跟踪时间相关的操作。
+     */
+    public static initTimer(): void {
+        this._timer = new Timer(16);
+    }
+
+    /**
+     * 启动一个定时器，执行指定的回调函数。
+     * @param callback - 要定时执行的回调函数。
+     * @param interval - 定时器的时间间隔（秒）。
+     * @param loop - [loop=0] 重复次数：0：回调一次，1~n：回调n次，-1：无限重复
+     * @returns 返回定时器的ID。
+     */
+    public static startTimer(callback: () => void, interval: number, loop: number = 0): number {
+        return this._timer.start(callback, interval, loop);
+    }
+
+    /**
+     * 停止指定ID的计时器。
+     * @param timerId - 要停止的计时器的唯一标识符。
+     */
+    public static stopTimer(timerId: number): void {
+        this._timer.stop(timerId);
+    }
+
+    public static update(dt: number): void {
+        this._timer?.update(dt);
+    }
+}

src/global/Platform.ts

@@ -0,0 +1,101 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 平台相关
+ */
+
+export enum PlatformType {
+    Android = 1,
+    IOS,
+    HarmonyOS,
+    /** 微信小游戏 */
+    WX,
+    /** 支付宝小游戏 */
+    Alipay,
+    /** 字节小游戏 */
+    Bytedance,
+    /** 华为快游戏 */
+    HuaweiQuick,
+    /** 其他都为Browser */
+    Browser,
+}
+
+export class Platform {
+    /**
+     * 是否为原生平台
+     * @type {boolean}
+     */
+    public static isNative: boolean = false;
+
+    /**
+     * 是否为移动平台
+     * @type {boolean}
+     */
+    public static isMobile: boolean = false;
+
+    /**
+     * 是否为原生移动平台
+     * @type {boolean}
+     */
+    public static isNativeMobile: boolean = false;
+
+    /**
+     * 是否为安卓平台
+     * @type {boolean}
+     */
+    public static isAndroid: boolean = false;
+
+    /**
+     * 是否为IOS平台
+     * @type {boolean}
+     */
+    public static isIOS: boolean = false;
+
+    /**
+     * 是否为HarmonyOS平台
+     * @type {boolean}
+     */
+    public static isHarmonyOS: boolean = false;
+
+    /**
+     * 是否为微信小游戏
+     * @type {boolean}
+     */
+    public static isWX: boolean = false;
+
+    /**
+     * 是否为支付宝小游戏
+     * @type {boolean}
+     */
+    public static isAlipay: boolean = false;
+
+    /**
+     * 是否为字节小游戏
+     * @type {boolean}
+     */
+    public static isBytedance: boolean = false;
+
+    /** 
+     * 是否是华为快游戏
+     * @type {boolean}
+     */
+    public static isHuaweiQuick: boolean = false;
+
+    /**
+     * 是否为浏览器
+     * @type {boolean}
+     */
+    public static isBrowser: boolean = false;
+
+    /**
+     * 平台名
+     * @type {string}
+     */
+    public static platform: PlatformType;
+
+    /**
+     * 设备ID
+     * @type {string}
+     */
+    public static deviceId: string;
+}

src/global/Screen.ts

@@ -0,0 +1,21 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 屏幕尺寸信息接口
+ */
+export class Screen {
+    /** 屏幕宽度 */
+    public static ScreenWidth: number;
+    /** 屏幕高度 */
+    public static ScreenHeight: number;
+    /** 设计分辨率宽 */
+    public static DesignWidth: number;
+    /** 设计分辨率高 */
+    public static DesignHeight: number;
+    /** 安全区外一侧的高度 或 宽度 */
+    public static SafeAreaHeight: number;
+    /** 安全区的宽度 */
+    public static SafeWidth: number;
+    /** 安全区的高度 */
+    public static SafeHeight: number;
+}

src/global/header.ts

@@ -0,0 +1,31 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 一些数据结构
+ */
+
+import { warn } from "../tool/log";
+
+export interface size {
+    width: number;
+    height: number;
+}
+
+export interface FrameConfig {
+    /** 开启debug 默认: false */
+    debug?: boolean;
+}
+
+export let KUNPO_DEBUG: boolean = false;
+/**
+ * 启用或禁用调试模式。
+ * @param enable - 如果为 true，则启用调试模式；如果为 false，则禁用调试模式。不设置默认不开启
+ */
+export function enableDebugMode(enable: boolean): void {
+    if (enable == true) {
+        KUNPO_DEBUG = true;
+        warn("调试模式已开启");
+    } else {
+        KUNPO_DEBUG = false;
+    }
+}

src/kunpocc.ts

@@ -0,0 +1,74 @@
+/** 一些全局工具 */
+export { GlobalEvent } from "./global/GlobalEvent";
+export { GlobalTimer } from "./global/GlobalTimer";
+export { enableDebugMode, FrameConfig, KUNPO_DEBUG } from "./global/header";
+export { Platform, PlatformType } from "./global/Platform";
+export { Screen } from "./global/Screen";
+
+/** tool */
+export * from "./tool/log";
+export { MathTool } from "./tool/Math";
+export { md5 } from "./tool/MD5";
+
+/** 消息监听 */
+export { EventManager } from "./event/EventManager";
+
+/** 网络 */
+export * from "./net/http/HttpManager";
+export { HttpTask } from "./net/http/HttpTask";
+export { IHttpEvent } from "./net/http/IHttpEvent";
+export { IHttpRequest } from "./net/http/IHttpRequest";
+export { IHttpResponse } from "./net/http/IHttpResponse";
+
+/** 四叉树 */
+export { Box } from "./quadtree/Box";
+export { Circle } from "./quadtree/Circle";
+export { Polygon } from "./quadtree/Polygon";
+export { QTConfig, QuadTree } from "./quadtree/QuadTree";
+
+/** 行为树 */
+export { Agent as BTAgent } from "./behaviortree/Agent";
+export { BehaviorTree } from "./behaviortree/BehaviorTree";
+export { Blackboard as BTBlackboard } from "./behaviortree/Blackboard";
+export * as BTAction from "./behaviortree/BTNode/Action";
+export * as BTNode from "./behaviortree/BTNode/BaseNode";
+export * as BTComposite from "./behaviortree/BTNode/Composite";
+export * as BTCondition from "./behaviortree/BTNode/Condition";
+export * as BTDecorator from "./behaviortree/BTNode/Decorator";
+export { Status as BTStatus } from "./behaviortree/header";
+export { Ticker as BTTicker } from "./behaviortree/Ticker";
+
+/** UI */
+export { Window } from "./fgui/Window";
+export { WindowHeader } from "./fgui/WindowHeader";
+export * from "./ui/header";
+export { _uidecorator } from "./ui/UIDecorator";
+export { WindowGroup } from "./ui/WindowGroup";
+export { WindowHeaderInfo } from "./ui/WindowHeaderInfo";
+export { WindowManager } from "./ui/WindowManager";
+
+/** EC */
+export { Component } from './ecmodule/Component';
+export { ComponentManager } from './ecmodule/ComponentManager';
+export { ComponentPool } from './ecmodule/ComponentPool';
+export { _ecdecorator } from './ecmodule/ECDecorator';
+export { ECManager } from './ecmodule/ECManager';
+export { Entity } from './ecmodule/Entity';
+export { EntityManager } from './ecmodule/EntityManager';
+
+/** 引擎相关 */
+export { CocosEntry } from "./cocos/CocosEntry";
+export { CocosUIModule } from "./cocos/CocosUIModule";
+
+/** 资源相关 */
+export { AssetLoader, IAssetConfig } from "./asset/AssetLoader";
+export { AssetPool } from "./asset/AssetPool";
+
+/** 条件显示节点 */
+export { _conditionDecorator } from "./condition/ConditionDecorator";
+export { ConditionManager } from "./condition/ConditionManager";
+export { ConditionModule } from "./condition/ConditionModule";
+export { ConditionAllNode } from "./condition/node/ConditionAllNode";
+export { ConditionAnyNode } from "./condition/node/ConditionAnyNode";
+export { ConditionBase } from "./condition/node/ConditionBase";
+

src/module/ModuleBase.ts

@@ -0,0 +1,20 @@
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 模块基类
+ */
+
+import { Component } from "cc";
+import { IModule } from "../global/IModule";
+
+export abstract class ModuleBase extends Component implements IModule {
+    /** 模块名称 */
+    public moduleName: string;
+
+    /** 模块初始化 (内部使用) */
+    public init(): void { }
+
+    /** 模块初始化完成后调用的函数 */
+    protected abstract onInit(): void;
+}

src/net/http/HttpManager.ts

@@ -0,0 +1,110 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-28
+ * @Description: 网络请求管理器
+ */
+
+import { GlobalEvent } from "../../global/GlobalEvent";
+import { HttpRequest } from "./HttpRequest";
+import { IHttpEvent } from "./IHttpEvent";
+import { IHttpResponse } from "./IHttpResponse";
+
+/** http请求方法 */
+export type HttpRequestMethod = "GET" | "POST" | "HEAD" | "PUT"
+/** http响应类型 */
+export type HttpResponseType = "text" | "json" | "arraybuffer";
+/** http响应数据类型 */
+export type HttpResponseDataType = string | ArrayBuffer | object;
+
+export class HttpManager {
+    public static HttpEvent: string = "event::http";
+
+    /**
+     * 发送post请求
+     * @param {string} url 请求地址
+     * @param {any} data 请求数据
+     * @param {HttpResponseType} responseType 响应类型
+     * @param {IHttpEvent} netEvent 网络事件
+     * @param {any[]} headers 请求头 [key1, value1, key2, value2, ...] 形式
+     * @param {number} timeout (单位s) 请求超时时间 默认0 (0表示不超时)
+     */
+    public static post(url: string, data: any, responseType: HttpResponseType = "json", netEvent: IHttpEvent, headers?: any[], timeout: number = 0): HttpRequest {
+        return this._send("POST", url, data, responseType, netEvent, headers, timeout);
+    }
+
+    /**
+     * 发送get请求
+     * @param {string} url 请求地址
+     * @param {any} data 请求数据
+     * @param {HttpResponseType} responseType 响应类型
+     * @param {IHttpEvent} netEvent 网络事件
+     * @param {any[]} headers 请求头 [key1, value1, key2, value2, ...] 形式
+     * @param {number} timeout (单位s) 请求超时时间 默认0 (0表示不超时)
+     */
+    public static get(url: string, data: any, responseType: HttpResponseType = "json", netEvent: IHttpEvent, headers?: any[], timeout: number = 0): HttpRequest {
+        return this._send("GET", url, data, responseType, netEvent, headers, timeout);
+    }
+
+    /**
+     * 发送put请求
+     * @param {string} url 请求地址
+     * @param {any} data 请求数据
+     * @param {HttpResponseType} responseType 响应类型
+     * @param {IHttpEvent} netEvent 网络事件
+     * @param {any[]} headers 请求头 [key1, value1, key2, value2, ...] 形式
+     * @param {number} timeout (单位s) 请求超时时间 默认0 (0表示不超时)
+     */
+    public static put(url: string, data: any, responseType: HttpResponseType = "json", netEvent: IHttpEvent, headers?: any[], timeout: number = 0): HttpRequest {
+        return this._send("PUT", url, data, responseType, netEvent, headers, timeout);
+    }
+
+    /**
+     * 发送head请求
+     * @param {string} url 请求地址
+     * @param {any} data 请求数据
+     * @param {HttpResponseType} responseType 响应类型
+     * @param {IHttpEvent} netEvent 网络事件
+     * @param {any[]} headers 请求头 [key1, value1, key2, value2, ...] 形式
+     * @param {number} timeout (单位s) 请求超时时间 默认0 (0表示不超时)
+     */
+    public static head(url: string, data: any, responseType: HttpResponseType = "json", netEvent: IHttpEvent, headers?: any[], timeout: number = 0): HttpRequest {
+        return this._send("HEAD", url, data, responseType, netEvent, headers, timeout);
+    }
+
+    /**
+     * 发送http请求
+     * @param {HttpRequestMethod} method 请求方式
+     * @param {string} url 请求地址
+     * @param {any} data 请求数据
+     * @param {HttpResponseType} responseType 响应类型
+     * @param {IHttpEvent} netEvent 网络事件
+     * @param {any[]} headers 请求头 [key1, value1, key2, value2, ...] 形式
+     * @param {number} timeout (单位s) 请求超时时间 默认0 (0表示不超时)
+     */
+    private static _send(method: HttpRequestMethod, url: string, data: any, responseType: HttpResponseType, netEvent?: IHttpEvent, headers?: any[], timeout?: number): HttpRequest {
+        let http = new HttpRequest()
+        http.setNetCallback((result: "succeed" | "fail", response: IHttpResponse) => {
+            switch (result) {
+                case "succeed":
+                    if (netEvent) {
+                        netEvent.onComplete(response);
+                    } else {
+                        GlobalEvent.send(HttpManager.HttpEvent, result, response);
+                    }
+                    break;
+                case "fail":
+                    if (netEvent) {
+                        netEvent.onError(response);
+                    } else {
+                        GlobalEvent.send(HttpManager.HttpEvent, result, response);
+                    }
+                    break;
+            }
+        });
+        http.method = method;
+        http.timeout = timeout;
+        http.responseType = responseType;
+        http.send(url, data, headers);
+        return http;
+    }
+}

src/net/http/HttpRequest.ts

@@ -0,0 +1,151 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-28
+ * @Description: 网络请求
+ */
+import { Platform } from "../../global/Platform";
+import { HttpRequestMethod, HttpResponseDataType, HttpResponseType } from "./HttpManager";
+import { IHttpRequest } from "./IHttpRequest";
+import { IHttpResponse } from "./IHttpResponse";
+
+export class HttpRequest implements IHttpRequest, IHttpResponse {
+    /** 请求方法 */
+    public method: HttpRequestMethod;
+    /** xhr实例 */
+    private _xhr: XMLHttpRequest;
+    /** 请求超时时间 (s) */
+    public timeout: number;
+    /** 响应类型 */
+    public responseType: HttpResponseType;
+    /** 信息 */
+    public message: string;
+    /** 响应数据 */
+    public data: HttpResponseDataType;
+
+    /** 网络事件回调 */
+    private _callback: (result: "succeed" | "fail", response: IHttpResponse) => void;
+
+    /**
+     * http相应状态码
+     * @readonly
+     * @type {number}
+     */
+    public get statusCode(): number {
+        return this._xhr.status;
+    }
+
+    /** 相应头 */
+    public get headers(): any {
+        return this._xhr.getAllResponseHeaders();
+    }
+
+    constructor() {
+        this._xhr = new XMLHttpRequest();
+    }
+
+    public setNetCallback(callback: (result: "succeed" | "fail", response: IHttpResponse) => void): void {
+        this._callback = callback;
+    }
+
+    public send(url: string, data: any, headers: any[]): void {
+        let xhr = this._xhr;
+        /** 设置请求超时时间 */
+        xhr.timeout = this.timeout * 1000;
+        /** 设置响应类型 */
+        xhr.responseType = this.responseType;
+        xhr.onabort = this._onHttpAbort.bind(this);
+        xhr.onerror = this._onHttpError.bind(this);
+        xhr.onload = this._onHttpLoad.bind(this);
+        xhr.ontimeout = this._onHttpTimeout.bind(this);
+        xhr.open(this.method, encodeURI(url));
+        if (headers) {
+            for (let i = 0; i < headers.length; i += 2) {
+                xhr.setRequestHeader(headers[i], headers[i + 1]);
+            }
+        } else if (!Platform.isMobile && Platform.isBrowser) {
+            if (!data || typeof data == "string") {
+                xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+            } else {
+                xhr.setRequestHeader("Content-Type", "application/json");
+            }
+        }
+        xhr.send(data);
+    }
+
+    /**
+     * 终止Http请求
+     * @param {boolean} [silent=false] 如果为true则不会回调错误信息
+     */
+    public abort(silent: boolean = false): void {
+        if (silent) {
+            this._clear();
+        }
+        this._xhr.abort();
+    }
+
+    /**
+     * 请求中断
+     * 
+     */
+    private _onHttpAbort(): void {
+        this.message = "request aborted by user";
+        this.onError();
+    }
+
+    private _onHttpError(): void {
+        this.message = "request error";
+        this.onError();
+    }
+
+    private _onHttpLoad(): void {
+        const xhr = this._xhr;
+        const status = xhr.status !== undefined ? xhr.status : 200;
+        if (status === 200 || status === 204 || status === 0) {
+            this.onComplete();
+        } else {
+            this.message = 'status:' + xhr.status + 'statusText:' + xhr.statusText + "responseURL:" + xhr.responseURL;
+            this.onError();
+        }
+    }
+
+    private _onHttpTimeout(): void {
+        this.message = "request timeout";
+        this.onError();
+    }
+
+    /**
+     * 请求发生错误
+     */
+    private onError(): void {
+        this._callback?.("fail", this);
+        this._clear();
+    }
+
+    /**
+     * 请求完成
+     */
+    private onComplete(): void {
+        try {
+            if (this.responseType == "json") {
+                this.data = this._xhr.response;
+            } else if (this.responseType == "arraybuffer") {
+                this.data = this._xhr.response;
+            } else if (this.responseType == "text") {
+                this.data = this._xhr.responseText;
+            }
+            this._callback?.("succeed", this);
+            this._clear();
+        } catch (e) {
+            console.warn(`http响应数据解析错误，HttpResponseType(${this.responseType})\n    url: ${this._xhr.responseURL}\n    error: ` + e);
+            this.onError();
+        }
+    }
+
+    private _clear(): void {
+        this._xhr.onabort = null;
+        this._xhr.onerror = null;
+        this._xhr.onload = null;
+        this._xhr.ontimeout = null;
+        this._callback = null;
+    }
+}

src/net/http/HttpTask.ts

@@ -0,0 +1,21 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-28
+ * @Description: 网络任务
+ */
+
+import { IHttpEvent } from "./IHttpEvent";
+import { IHttpResponse } from "./IHttpResponse";
+
+export abstract class HttpTask implements IHttpEvent {
+    /** 名称 */
+    public name: string;
+    /** 自定义参数 */
+    public data?: any;
+    /** 请求完成 */
+    public abstract onComplete(response: IHttpResponse): void;
+    /** 请求错误 */
+    public abstract onError(response: IHttpResponse): void;
+    /** 请求开始 */
+    public abstract start(): void;
+}

src/net/http/IHttpEvent.ts

@@ -0,0 +1,18 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-28
+ * @Description: 网络事件 
+ */
+
+import { IHttpResponse } from "./IHttpResponse";
+
+export interface IHttpEvent {
+    /** 名称 */
+    name: string;
+    /** 自定义参数 */
+    data?: any;
+    /** 网络请求成功 */
+    onComplete(response: IHttpResponse): void;
+    /** 网络请求失败 */
+    onError(response: IHttpResponse): void;
+}

src/net/http/IHttpRequest.ts

@@ -0,0 +1,15 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-28
+ * @Description: 网络请求接口
+ */
+
+import { HttpRequestMethod, HttpResponseType } from "./HttpManager";
+export interface IHttpRequest {
+    /** 请求方法 */
+    readonly method: HttpRequestMethod;
+    /** 请求超时时间 (s) */
+    readonly timeout: number;
+    /** 响应类型 */
+    readonly responseType: HttpResponseType;
+}

src/net/http/IHttpResponse.ts

@@ -0,0 +1,20 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-28
+ * @Description: 网络响应接口
+ */
+
+import { HttpResponseDataType } from "./HttpManager";
+export interface IHttpResponse {
+    /** 信息 */
+    readonly message: string;
+
+    /** 响应数据 */
+    readonly data: HttpResponseDataType;
+
+    /** http状态码 */
+    readonly statusCode: number;
+
+    /** 相应头 */
+    readonly headers: any;
+}

src/quadtree/Box.ts

@@ -0,0 +1,32 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 矩形
+ */
+import { v2, Vec2 } from "cc";
+import { Polygon } from "./Polygon";
+
+// 3|2
+// --
+// 0|1
+// 矩形的四个点
+
+export class Box extends Polygon {
+    constructor(x: number, y: number, width: number, height: number, tag: number = -1) {
+        let points: Vec2[] = new Array(4);
+        points[0] = v2(x, y);
+        points[1] = v2(x + width, y);
+        points[2] = v2(x + width, y + height);
+        points[3] = v2(x, y + height);
+        super(points, tag);
+    }
+
+    public resetPoints(x: number, y: number, width: number, height: number): void {
+        let points: Vec2[] = new Array(4);
+        points[0] = v2(x, y);
+        points[1] = v2(x + width, y);
+        points[2] = v2(x + width, y + height);
+        points[3] = v2(x, y + height);
+        this.points = points;
+    }
+}

src/quadtree/Circle.ts

@@ -0,0 +1,28 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 原型
+ */
+
+import { Graphics, Rect } from "cc";
+import { Shape } from "./Shape";
+
+export class Circle extends Shape {
+    public radius: number; // 半径
+    constructor(radius: number, tag: number = -1) {
+        super(tag);
+        this.radius = radius;
+        this.boundingBox.x = -this.radius;
+        this.boundingBox.y = -this.radius;
+        this.boundingBox.width = this.radius * 2;
+        this.boundingBox.height = this.radius * 2;
+    }
+
+    public getBoundingBox(): Rect {
+        return this.boundingBox;
+    }
+
+    public drawShape(draw: Graphics): void {
+        draw && draw.circle(this.position.x, this.position.y, this.radius * this.scale);
+    }
+}

src/quadtree/Polygon.ts

@@ -0,0 +1,96 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 多边形
+ */
+
+import { Graphics, Rect, v2, Vec2 } from "cc";
+import { Shape } from "./Shape";
+
+
+const vec2 = new Vec2();
+/** 点绕原点旋转 radians 弧度后的新点 */
+function rotate(radians: number, x: number, y: number): Vec2 {
+    let sin = Math.sin(radians);
+    let cos = Math.cos(radians);
+    vec2.x = x * cos - y * sin;
+    vec2.y = y * cos + x * sin;
+    return vec2;
+}
+
+// /** 点绕点旋转 radians 弧度后的新点 */
+// export function rotateByPoint(radians: number, x: number, y: number, cx: number, cy: number): Vec2 {
+//     let sin = Math.sin(radians);
+//     let cos = Math.cos(radians);
+//     vec2.x = (x - cx) * cos - (y - cy) * sin + cx;
+//     vec2.y = (y - cy) * cos + (x - cx) * sin + cy;
+//     return vec2;
+// }
+
+export class Polygon extends Shape {
+    protected _points: Vec2[] = []; // 多边形
+    protected _realPoints: Vec2[];
+    constructor(points: Vec2[], tag: number = -1) {
+        super(tag);
+        this._points = points;
+        this._realPoints = new Array(points.length);
+        for (let i = 0, len = points.length; i < len; i++) {
+            this._realPoints[i] = v2(points[i].x, points[i].y);
+        }
+        this.getBoundingBox();
+    }
+
+    public getBoundingBox(): Rect {
+        if (this.isDirty) {
+            let minX = Number.MAX_VALUE;
+            let maxX = Number.MIN_VALUE;
+            let minY = Number.MAX_VALUE;
+            let maxY = Number.MIN_VALUE;
+            for (const point of this._points) {
+                let a = rotate(Math.PI / 180 * this._rotation, point.x, point.y);
+                minX = Math.min(minX, a.x);
+                minY = Math.min(minY, a.y);
+                maxX = Math.max(maxX, a.x);
+                maxY = Math.max(maxY, a.y);
+            }
+            this.boundingBox.x = minX;
+            this.boundingBox.y = minY;
+            this.boundingBox.width = maxX - minX;
+            this.boundingBox.height = maxY - minY;
+            this.isDirty = false;
+        }
+        return this.boundingBox;
+    }
+
+    public get points(): Vec2[] {
+        let points = this._points;
+        let len = points.length;
+        for (let i = 0; i < len; i++) {
+            let m = points[i];
+            this._realPoints[i] = m.rotate(Math.PI / 180 * this.rotation);
+            let a = this._realPoints[i];
+            a.x = a.x * this.scale + this.position.x;
+            a.y = a.y * this.scale + this.position.y;
+        }
+        return this._realPoints;
+    }
+
+    public set points(pts: Vec2[]) {
+        this._points = pts;
+        this._realPoints = new Array(pts.length);
+        for (let i = 0, len = pts.length; i < len; i++) {
+            this._realPoints[i] = v2(pts[i].x, pts[i].y);
+        }
+    }
+
+    public drawShape(draw: Graphics): void {
+        if (draw) {
+            let points = this.points;
+            draw.moveTo(points[0].x, points[0].y);
+            for (let i = 1; i < points.length; i++) {
+                draw.lineTo(points[i].x, points[i].y);
+            }
+            draw.lineTo(points[0].x, points[0].y);
+        }
+    }
+}

src/quadtree/QuadTree.ts

@@ -0,0 +1,341 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 树节点
+ */
+
+import { Color, Graphics, Intersection2D, rect, Rect } from "cc";
+import { Box } from "./Box";
+import { Circle } from "./Circle";
+import { Polygon } from "./Polygon";
+import { Shape } from "./Shape";
+
+// 1|0
+// ---
+// 2|3
+const enum Quadrant {
+    ONE = 0,
+    TWO,
+    THREE,
+    FOUR,
+    MORE, // 多个象限
+}
+
+const circleCircle = Intersection2D.circleCircle;
+const polygonCircle = Intersection2D.polygonCircle;
+const polygonPolygon = Intersection2D.polygonPolygon;
+/** 两个形状是否碰撞 */
+function isCollide(shape1: Shape, shape2: Shape): boolean {
+    if (shape1 instanceof Circle) {
+        if (shape2 instanceof Circle) {
+            return circleCircle(shape1.position, shape1.radius * shape1.scale, shape2.position, shape2.radius * shape2.scale);
+        } else if (shape2 instanceof Box || shape2 instanceof Polygon) {
+            return polygonCircle(shape2.points, shape1.position, shape1.radius * shape1.scale);
+        }
+    } else if (shape1 instanceof Box || shape1 instanceof Polygon) {
+        if (shape2 instanceof Circle) {
+            return polygonCircle(shape1.points, shape2.position, shape2.radius * shape2.scale);
+        } else if (shape2 instanceof Box || shape2 instanceof Polygon) {
+            return polygonPolygon(shape2.points, shape1.points);
+        }
+    }
+    return false;
+}
+
+export const QTConfig = {
+    /** 每个节点（象限）所能包含物体的最大数量 */
+    MAX_SHAPES: 12,
+    /** 四叉树的最大深度 */
+    MAX_LEVELS: 5,
+}
+
+export class QuadTree {
+    private _draw: Graphics;
+    private _shapes_map: Map<number, Shape[]>; // 根据类型存储形状对象
+    private _trees: QuadTree[] = []; // 存储四个子节点
+    private _level: number; // 树的深度
+    private _bounds: Rect; // 树的外框
+    private _ignore_shapes: Shape[] = []; // 不在树中的形状
+    /**
+     * 创建一个四叉树
+     * @param rect 该节点对应的象限在屏幕上的范围
+     * @param level 该节点的深度，根节点的默认深度为0
+     * @param draw cc中用于绘制树的绘制组件
+     */
+    constructor(rect: Rect, level: number = 0, draw: Graphics = undefined) {
+        this._shapes_map = new Map();
+        this._trees = [];
+        this._level = level || 0;
+        this._bounds = rect;
+        this._draw = draw;
+    }
+
+    /**
+     * 插入形状
+     * @param shape 形状数据
+     * 如果当前节点存在子节点，则检查物体到底属于哪个子节点，如果能匹配到子节点，则将该物体插入到该子节点中
+     * 如果当前节点不存在子节点，将该物体存储在当前节点。随后，检查当前节点的存储数量，如果超过了最大存储数量，则对当前节点进行划分，划分完成后，将当前节点存储的物体重新分配到四个子节点中。
+     */
+    public insert(shape: Shape): void {
+        // 如果该节点下存在子节点
+        if (this._trees.length > 0) {
+            let quadrant = this._getQuadrant(shape);
+            if (quadrant !== Quadrant.MORE) {
+                this._trees[quadrant].insert(shape);
+                return;
+            }
+        }
+        if (this._level == 0 && !this._isInner(shape, this._bounds)) {
+            // 插入跟节点并且形状不在根节点的框内，则把形状放入忽略列表中
+            this._ignore_shapes.push(shape);
+        } else {
+            // 存储在当前节点下
+            this._insert(shape);
+            // 如果当前节点存储的数量超过了 MAX_OBJECTS，并且深度没超过 MAX_LEVELS，则继续拆分
+            if (!this._trees.length && this._size() > QTConfig.MAX_SHAPES && this._level < QTConfig.MAX_LEVELS) {
+                this._split();
+                for (const shapes of this._shapes_map.values()) {
+                    let length = shapes.length - 1;
+                    for (let i = length; i >= 0; i--) {
+                        let quadrant = this._getQuadrant(shapes[i]);
+                        if (quadrant !== Quadrant.MORE) {
+                            this._trees[quadrant].insert(shapes.splice(i, 1)[0]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private _insert(shape: Shape): void {
+        if (!this._shapes_map.has(shape.tag)) {
+            this._shapes_map.set(shape.tag, []);
+        }
+        this._shapes_map.get(shape.tag).push(shape);
+    }
+
+    /**
+     * 检索功能：
+     * 给出一个物体对象，该函数负责将该物体可能发生碰撞的所有物体选取出来。该函数先查找物体所属的象限，该象限下的物体都是有可能发生碰撞的，然后再递归地查找子象限...
+     */
+    public collide(shape: Shape, tag: number = -1): Shape[] {
+        let result: any[] = [];
+        if (this._trees.length > 0) {
+            let quadrant = this._getQuadrant(shape);
+            if (quadrant === Quadrant.MORE) {
+                let len = this._trees.length - 1;
+                for (let i = len; i >= 0; i--) {
+                    result = result.concat(this._trees[i].collide(shape, tag));
+                }
+            } else {
+                result = result.concat(this._trees[quadrant].collide(shape, tag));
+            }
+        }
+
+        for (const key of this._shapes_map.keys()) {
+            if (!(tag & key)) {
+                continue;
+            }
+            let shapes = this._shapes_map.get(key);
+            for (const other_shape of shapes) {
+                if (!other_shape.invalid && shape !== other_shape && isCollide(shape, other_shape)) {
+                    result.push(other_shape);
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 动态更新
+     */
+    public update(root?: QuadTree): void {
+        root = root || this;
+        let isRoot = (root === this);
+        isRoot && this._strokeClear()
+        this._updateIgnoreShapes(root);
+        this._updateShapes(root);
+        // 递归刷新子象限
+        for (const tree of this._trees) {
+            tree.update(root);
+        }
+        this._removeChildTree();
+        this._drawTreeBound(root);
+
+        if (isRoot && this._draw) {
+            this._draw.stroke();
+        }
+    }
+
+    public clear(): void {
+        this._level = 0;
+        this._ignore_shapes.length = 0;
+        this._shapes_map.clear();
+        for (const tree of this._trees) {
+            tree.clear();
+        }
+        this._trees.length = 0;
+    }
+
+    /** 当前形状是否包含在象限内 */
+    private _isInner(shape: Shape, bounds: Rect): boolean {
+        let rect = shape.getBoundingBox();
+        return (
+            rect.xMin * shape.scale + shape.position.x > bounds.xMin &&
+            rect.xMax * shape.scale + shape.position.x < bounds.xMax &&
+            rect.yMin * shape.scale + shape.position.y > bounds.yMin &&
+            rect.yMax * shape.scale + shape.position.y < bounds.yMax
+        );
+    }
+
+    /**
+     * 获取形状对应的象限序号，以中心为界限切割:
+     * @param {Shape} shape 形状
+     * 右上：象限一
+     * 左上：象限二
+     * 左下：象限三
+     * 右下：象限四
+     */
+    private _getQuadrant(shape: Shape): Quadrant {
+        let bounds = this._bounds;
+        let rect = shape.getBoundingBox();
+        let center = bounds.center;
+
+        let onTop = rect.yMin * shape.scale + shape.position.y > center.y;
+        let onBottom = rect.yMax * shape.scale + shape.position.y < center.y;
+        let onLeft = rect.xMax * shape.scale + shape.position.x < center.x;
+        let onRight = rect.xMin * shape.scale + shape.position.x > center.x;
+        if (onTop) {
+            if (onRight) {
+                return Quadrant.ONE;
+            } else if (onLeft) {
+                return Quadrant.TWO;
+            }
+        } else if (onBottom) {
+            if (onLeft) {
+                return Quadrant.THREE;
+            } else if (onRight) {
+                return Quadrant.FOUR;
+            }
+        }
+        return Quadrant.MORE; // 跨越多个象限
+    }
+
+    /**
+     * 划分函数
+     * 如果某一个象限（节点）内存储的物体数量超过了MAX_OBJECTS最大数量
+     * 则需要对这个节点进行划分
+     * 它的工作就是将一个象限看作一个屏幕，将其划分为四个子象限
+     */
+    private _split(): void {
+        let bounds = this._bounds;
+        let x = bounds.x;
+        let y = bounds.y;
+        let halfwidth = bounds.width * 0.5;
+        let halfheight = bounds.height * 0.5;
+        let nextLevel = this._level + 1;
+        this._trees.push(
+            new QuadTree(rect(bounds.center.x, bounds.center.y, halfwidth, halfheight), nextLevel, this._draw),
+            new QuadTree(rect(x, bounds.center.y, halfwidth, halfheight), nextLevel, this._draw),
+            new QuadTree(rect(x, y, halfwidth, halfheight), nextLevel, this._draw),
+            new QuadTree(rect(bounds.center.x, y, halfwidth, halfheight), nextLevel, this._draw)
+        );
+    }
+
+    /** 删除子树 */
+    private _removeChildTree(): void {
+        if (this._trees.length > 0) {
+            if (this._totalSize() <= 0) {
+                this._trees.length = 0;
+            }
+        }
+    }
+
+    /** 更新忽略掉的形状 */
+    private _updateIgnoreShapes(root: QuadTree): void {
+        let len = this._ignore_shapes.length;
+        if (len <= 0) {
+            return;
+        }
+        for (let i = len - 1; i >= 0; i--) {
+            let shape = this._ignore_shapes[i];
+            if (shape.invalid) {
+                this._ignore_shapes.splice(i, 1);
+                continue;
+            }
+            if (!this._isInner(shape, this._bounds)) {
+                continue;
+            }
+            root.insert(this._ignore_shapes.splice(i, 1)[0]);
+        }
+    }
+
+    /** 更新有效的形状 */
+    private _updateShapes(root: QuadTree): void {
+        for (const shapes of this._shapes_map.values()) {
+            let len = shapes.length;
+            for (let i = len - 1; i >= 0; i--) {
+                let shape = shapes[i];
+                if (shape.invalid) {
+                    shapes.splice(i, 1);
+                    continue;
+                }
+                if (!this._isInner(shape, this._bounds)) {
+                    // 如果矩形不属于该象限，则将该矩形重新插入根节点
+                    root.insert(shapes.splice(i, 1)[0]);
+                } else if (this._trees.length > 0) {
+                    // 如果矩形属于该象限且该象限具有子象限，则将该矩形安插到子象限中
+                    let quadrant = this._getQuadrant(shape);
+                    if (quadrant !== Quadrant.MORE) {
+                        this._trees[quadrant].insert(shapes.splice(i, 1)[0]);
+                    }
+                }
+                shape.drawShape(this._draw);
+            }
+        }
+    }
+
+    /** 当前树以及子树中所有的形状数量 */
+    private _totalSize(): number {
+        let size = this._size();
+        for (const tree of this._trees) {
+            size += tree._totalSize();
+        }
+        return size;
+    }
+
+    private _size(): number {
+        let size = 0;
+        for (const shapes of this._shapes_map.values()) {
+            size += shapes.length;
+        }
+        return size + this._ignore_shapes.length;
+    }
+
+    /** 画出当前树的边界 */
+    private _drawTreeBound(root: QuadTree): void {
+        if (!this._draw) {
+            return;
+        }
+        this._draw.lineWidth = 4;
+        this._draw.strokeColor = Color.BLUE;
+        if (this._trees.length > 0) {
+            this._draw.moveTo(this._bounds.x, this._bounds.center.y);
+            this._draw.lineTo(this._bounds.x + this._bounds.width, this._bounds.center.y);
+
+            this._draw.moveTo(this._bounds.center.x, this._bounds.y);
+            this._draw.lineTo(this._bounds.center.x, this._bounds.y + this._bounds.height);
+        }
+        if (this == root) {
+            this._draw.moveTo(this._bounds.xMin, this._bounds.yMin);
+            this._draw.lineTo(this._bounds.xMax, this._bounds.yMin);
+            this._draw.lineTo(this._bounds.xMax, this._bounds.yMax);
+            this._draw.lineTo(this._bounds.xMin, this._bounds.yMax);
+            this._draw.lineTo(this._bounds.xMin, this._bounds.yMin);
+        }
+    }
+
+    private _strokeClear(): void {
+        this._draw && this._draw.clear();
+    }
+}

src/quadtree/Shape.ts

@@ -0,0 +1,71 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-21
+ * @Description: 四叉树的 形状基类
+ */
+
+import { Graphics, Rect, Vec2 } from "cc";
+
+export abstract class Shape {
+    /**
+     * 形状的标记 用来过滤不需要检测的形状
+     * 通过 & 来匹配形状是否需要被检测
+     * -1 表示和所有物体碰撞
+     */
+    public tag: number = -1;
+
+    /** 被标记为无效 下次更新时删除 */
+    public invalid: boolean = false;
+
+    /** 缩放 */
+    public scale: number; // 缩放
+
+    /** 脏标记 用来重置包围盒 */
+    protected isDirty: boolean;
+
+    /** 包围盒 */
+    protected boundingBox: Rect;
+
+    /** 位置 */
+    protected _position: Vec2;
+
+    /** 旋转角度 */
+    protected _rotation: number;
+
+    constructor(tag: number) {
+        this.tag = tag;
+        this.scale = 1.0;
+        this._rotation = 0;
+        this.isDirty = true;
+        this.boundingBox = new Rect();
+        this._position = new Vec2();
+    }
+
+    set position(pos: Vec2) {
+        this._position.x = pos.x;
+        this._position.y = pos.y;
+    }
+
+    get position(): Vec2 {
+        return this._position;
+    }
+
+    set rotation(angle: number) {
+        if (this._rotation !== angle) {
+            this._rotation = angle;
+            this.isDirty = true;
+        }
+    }
+
+    get rotation(): number {
+        return this._rotation;
+    }
+
+    /** 包围盒 子类重写 */
+    public abstract getBoundingBox(): Rect;
+
+    public drawShape(draw: Graphics): void {
+
+    }
+}
+

src/tool/DataStruct/BinaryHeap.ts

@@ -0,0 +1,195 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 二叉堆(默认最小堆) 支持最大堆和最小堆
+ */
+
+export abstract class HeapNode {
+    public index: number;
+    public abstract lessThan(other: HeapNode): boolean;
+}
+
+
+export class BinaryHeap<T extends HeapNode> {
+    private _nodes: Array<T>;
+    private _size: number;
+    private _capacity: number;
+
+    constructor(capacity: number) {
+        this._size = 0;
+        this._capacity = capacity <= 0 ? 4 : capacity;
+        this._nodes = new Array<T>(this._capacity);
+    }
+
+    /**
+     * 清空
+     */
+    public clear(): void {
+        this._size = 0;
+    }
+
+    /**
+     * 获取节点
+     * @param index 节点索引
+     */
+    public get(index: number): T {
+        return this._nodes[index];
+    }
+
+    /**
+     * 获取顶部节点
+     */
+    public top(): T {
+        return this._nodes[0];
+    }
+
+    /**
+     * 是否包含节点
+     * @param node 节点
+     */
+    public contains(node: T): boolean {
+        return node.index >= 0 && node.index < this._size;
+    }
+
+    /**
+     * Push节点
+     * @param node 节点
+     */
+    public push(node: T): void {
+        const size = ++this._size;
+
+        if (size > this._capacity) {
+            this._capacity = this._nodes.length *= 2;
+        }
+
+        this._sortUp(node, size - 1);
+    }
+
+    /**
+     * Pop节点
+     * @returns
+     */
+    public pop(): T {
+        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 要移除的节点
+     */
+    public remove(node: T): void {
+        if (!this.contains(node)) {
+            return;
+        }
+
+        const size = --this._size;
+        const nodes = this._nodes;
+        const newNode = (nodes[node.index] = nodes[size]);
+
+        newNode.index = node.index;
+        nodes[size] = null;
+        this.update(newNode);
+        node.index = -1;
+    }
+
+    /**
+     * 更新节点
+     * @param node 要更新的节点
+     */
+    public update(node: T): boolean {
+        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;
+    }
+
+    private _parent(index: number): number {
+        return (index - 1) >> 1;
+    }
+
+    public get count(): number {
+        return this._size;
+    }
+
+    public get empty(): boolean {
+        return this._size == 0;
+    }
+
+    private _sortUp(node: T, index: number): void {
+        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;
+    }
+
+    private _sortDown(node: T, index: number): void {
+        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;
+    }
+}

src/tool/DataStruct/LinkedList.ts

@@ -0,0 +1,301 @@
+
+function defaultEquals<T>(a: T, b: T): boolean {
+    return a === b;
+}
+
+/** 单链表结结构节点 */
+export class LinkedNode<T> {
+    public element: T;
+    public next: LinkedNode<T>; // 下一项元素的指针
+    constructor(element: T) {
+        this.element = element;
+        this.next = undefined;
+    }
+}
+
+/** 双向链表结结构节点 */
+export class DoublyNode<T> extends LinkedNode<T> {
+    public prev: DoublyNode<T>; // 上一项元素的指针
+    public next: DoublyNode<T>; // 下一元素的指针（重新定义下一个元素的类型）
+    constructor(element: T) {
+        super(element);
+        this.prev = undefined;
+    }
+}
+
+/** 单向链表 */
+export class LinkedList<T> {
+    protected _equalsFn: (a: T, b: T) => boolean;
+    protected _count: number;
+    protected _head: LinkedNode<T>;
+    /**
+     * create
+     * @param equalsFn 比较是否相等（支持自定义）
+     */
+    constructor(equalsFn?: (a: T, b: T) => boolean) {
+        this._equalsFn = equalsFn || defaultEquals;
+        this._count = 0;
+        this._head = undefined;
+    }
+
+    /** 向链表尾部添加元素 */
+    public push(element: T): void {
+        const node = new LinkedNode<T>(element);
+        let current: LinkedNode<T>;
+        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。
+     */
+    public insert(element: T, index: number): boolean {
+        if (index >= 0 && index <= this._count) {
+            const node = new LinkedNode<T>(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
+     */
+    public getElementAt(index: number): LinkedNode<T> {
+        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
+     */
+    public remove(element: T): T {
+        return this.removeAt(this.indexOf(element));
+    }
+
+    /**
+     * 从链表的特定位置移除一个元素
+     * @param index
+     */
+    public removeAt(index: number): T {
+        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
+     */
+    public indexOf(element: T): number {
+        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;
+    }
+
+    public clear(): void {
+        this._head = undefined;
+        this._count = 0;
+    }
+
+    public getHead(): LinkedNode<T> {
+        return this._head;
+    }
+
+    public isEmpty(): boolean {
+        return this.size() === 0;
+    }
+
+    public size(): number {
+        return this._count;
+    }
+
+    public toString(): string {
+        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;
+    }
+}
+
+/** 双向链表 */
+export class DoublyLinkedList<T> extends LinkedList<T> {
+    protected _head: DoublyNode<T>; // 重新定义 head 类型
+    protected _tail: DoublyNode<T>;
+    /**
+     * create
+     * @param equalsFn 比较是否相等（支持自定义）
+     */
+    constructor(equalsFn?: (a: T, b: T) => boolean) {
+        super(equalsFn);
+        this._tail = undefined;
+    }
+
+    /**
+     * 向链表尾部添加元素
+     * @param element
+     */
+    public push(element: T): void {
+        this.insert(element, this._count);
+    }
+
+    /**
+     * 向链表指定位置添加元素
+     * @param element
+     * @param index
+     */
+    public insert(element: T, index: number): boolean {
+        if (index >= 0 && index <= this._count) {
+            const node = new DoublyNode<T>(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
+     */
+    public removeAt(index: number): T {
+        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
+     */
+    public getElementAt(index: number): DoublyNode<T> {
+        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;
+    }
+
+    public getHead(): DoublyNode<T> {
+        return this._head;
+    }
+
+    public getTail(): DoublyNode<T> {
+        return this._tail;
+    }
+
+    public clear(): void {
+        this._head = undefined;
+        this._tail = undefined;
+        this._count = 0;
+    }
+}

src/tool/DataStruct/Stack.ts

@@ -0,0 +1,42 @@
+import { DoublyLinkedList } from "./LinkedList";
+
+export class Stack<T> {
+    private _items: DoublyLinkedList<T>;
+    constructor(equalsFn?: (a: T, b: T) => boolean) {
+        this._items = new DoublyLinkedList<T>(equalsFn);
+    }
+
+    public push(element: T): void {
+        this._items.push(element);
+    }
+
+    public pop(): T {
+        if (this.isEmpty()) {
+            return undefined;
+        }
+        return this._items.removeAt(this.size() - 1);
+    }
+
+    public peek(): T {
+        if (this.isEmpty()) {
+            return undefined;
+        }
+        return this._items.getTail().element;
+    }
+
+    public size(): number {
+        return this._items.size();
+    }
+
+    public isEmpty(): boolean {
+        return this._items.isEmpty();
+    }
+
+    public clear(): void {
+        this._items.clear();
+    }
+
+    public toString(): string {
+        return this._items.toString();
+    }
+}

src/tool/MD5.ts

@@ -0,0 +1,250 @@
+// const base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+class Crypt {
+    // Bit-wise rotation left
+    public static rotl(n: number, b: number): number {
+        return (n << b) | (n >>> (32 - b));
+    }
+
+    // Bit-wise rotation right
+    public static rotr(n: number, b: number): number {
+        return (n << (32 - b)) | (n >>> b);
+    }
+
+    // Swap big-endian to little-endian and vice versa
+    public static endianNumber(n: number): any {
+        return (Crypt.rotl(n, 8) & 0x00ff00ff) | (Crypt.rotl(n, 24) & 0xff00ff00);
+    }
+
+    // Swap big-endian to little-endian and vice versa
+    public static endianArray(n: number[]): any {
+        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
+    public static randomBytes(n: number): number[] {
+        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
+    public static bytesToWords(bytes: number[]): number[] {
+        const words: any[] = [];
+
+        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
+    public static wordsToBytes(words: number[]): number[] {
+        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
+    public static bytesToHex(bytes: number[]): string {
+        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
+    public static hexToBytes(hex: string): number[] {
+        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: string): number[] {
+    str = unescape(encodeURIComponent(str));
+    const bytes = [];
+
+    for (let i = 0, l = str.length; i < l; i++) {
+        bytes.push(str.charCodeAt(i) & 0xff);
+    }
+    return bytes;
+}
+
+function isFastBuffer(obj: any): boolean {
+    return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer(obj: any): boolean {
+    return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+}
+
+function isBuffer(obj: any): boolean {
+    return obj && (isFastBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+}
+
+// The core
+const md5Lib = function (message: string): number[] {
+    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: any, b: any, c: any, d: any, x: any, s: any, t: any): any {
+    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: any, b: any, c: any, d: any, x: any, s: any, t: any): any {
+    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: any, b: any, c: any, d: any, x: any, s: any, t: any): any {
+    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: any, b: any, c: any, d: any, x: any, s: any, t: any): any {
+    const n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+
+    return ((n << s) | (n >>> (32 - s))) + b;
+};
+
+/**
+ * 对字符串执行md5处理
+ *
+ * @export
+ * @param {string} message 要处理的字符串
+ * @returns {string} md5
+ */
+export function md5(message: string): string {
+    if (message === undefined || message === null) {
+        throw new Error("Illegal argument " + message);
+    }
+    return Crypt.bytesToHex(Crypt.wordsToBytes(md5Lib(message)));
+}

src/tool/Math.ts

@@ -0,0 +1,36 @@
+const MathMin = Math.min;
+const MathMax = Math.max;
+const MathFloor = Math.floor;
+const MathRandom = Math.random;
+
+export class MathTool {
+    public static clampf(value: number, min: number, max: number): number {
+        return MathMin(MathMax(value, min), max);
+    }
+
+    /** 随机 min 到 max之间的整数 (包含 min 和 max) */
+    public static rand(min: number, max: number): number {
+        return MathFloor(MathRandom() * (max - min + 1) + min);
+    }
+
+    /** 随机 min 到 max之间的浮点数 (包含 min 和 max) */
+    public static randRange(min: number, max: number): number {
+        return MathRandom() * (max - min) + min;
+    }
+
+    public static rad(angle: number): number {
+        return (angle * Math.PI) / 180;
+    }
+
+    public static deg(radian: number): number {
+        return (radian * 180) / Math.PI;
+    }
+
+    public static smooth(num1: number, num2: number, elapsedTime: number, responseTime: number): number {
+        let out: number = num1;
+        if (elapsedTime > 0) {
+            out = out + (num2 - num1) * (elapsedTime / (elapsedTime + responseTime));
+        }
+        return out;
+    }
+}

src/tool/header.ts

@@ -0,0 +1,7 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-14
+ * @Description: tools 导出
+ */
+
+

src/tool/helper/ObjectHelper.ts

@@ -0,0 +1,13 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-12
+ * @Description: 对象帮助类
+ */
+export class ObjectHelper {
+    public static getObjectProp(obj: Record<string, any>, key: string): any {
+        if (obj.hasOwnProperty(key)) {
+            return obj[key];
+        }
+        return (obj[key] = Object.assign({}, obj[key]));
+    }
+}

src/tool/log.ts

@@ -0,0 +1,44 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-05
+ * @Description: log相关的api
+ */
+
+import { KUNPO_DEBUG } from "../global/header";
+
+function log(...args: any[]) {
+    console.log("kunpo:", ...args);
+}
+
+/**
+ * 开启debug模式后 输出调试信息 
+ * @param args 
+ */
+function debug(...args: any[]): void {
+    KUNPO_DEBUG && console.log("kunpo:", ...args);
+}
+
+/**
+ * 信息性消息 某些浏览器中会带有小图标，但颜色通常与 log 相同
+ * @param args 
+ */
+function info(...args: any[]): void {
+    console.info("kunpo:", ...args);
+}
+
+/**
+ * 警告信息 黄色背景，通常带有警告图标
+ * @param args 
+ */
+function warn(...args: any[]): void {
+    console.warn("kunpo:", ...args);
+}
+
+/**
+ * 错误消息 红色背景，通常带有错误图标
+ * @param args 
+ */
+function error(...args: any[]): void {
+    console.error("kunpo:", ...args);
+}
+export { debug, error, info, log, warn };

src/tool/timer/Timer.ts

@@ -0,0 +1,199 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 定时器管理类
+ */
+
+import { BinaryHeap } from "../DataStruct/BinaryHeap";
+import { TimerNode } from "./TimerNode";
+import { TimerNodePool } from "./TimerNodePool";
+
+export class Timer {
+    private _timerNodeOrder: number = 0;
+
+    /** 经过的时间 */
+    private _elapsedTime: number = 0;
+
+    private _pool: TimerNodePool;
+    private _heap: BinaryHeap<TimerNode>;
+
+    /** 暂停的计时器 */
+    private _pausedTimers: Map<number, TimerNode>;
+
+    /**
+     * 定时器数量
+     * @readonly
+     * @type {number}
+     */
+    public get timerCount(): number {
+        return this._heap.count;
+    }
+
+    /**
+     * 定时器管理类
+     *
+     * @param {number} initTimerCapacity 初始定时器容量
+     * @memberof Timer
+     */
+    public constructor(initTimerCapacity: number) {
+        this._heap = new BinaryHeap<TimerNode>(initTimerCapacity);
+        this._pool = new TimerNodePool(initTimerCapacity);
+        this._pausedTimers = new Map<number, TimerNode>();
+    }
+
+    /**
+     * 启动一个计时器
+     * @param { Function } callback 回调方法
+     * @param {number} interval 回调间隔 (秒)
+     * @param {number} [loop=0] 重复次数：0：回调一次，1~n：回调n次，-1：无限重复
+     * @returns {number} 返回计时器id
+     */
+    public start(callback: () => void, interval: number, loop: number = 0): number {
+        const timerNode = this._getTimerNode(callback, interval, loop);
+        this._heap.push(timerNode);
+        return timerNode.id;
+    }
+
+    /**
+     * 删除指定计时器
+     *
+     * @param {number} timerId 定时器ID
+     * @memberof Timer
+     */
+    public stop(timerId: number): void {
+        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
+     */
+    public pause(timerId: number): void {
+        const timerNode = this._pool.get(timerId);
+
+        if (timerNode) {
+            timerNode.pauseRemainTime = timerNode.expireTime - this._elapsedTime;
+            this._heap.remove(timerNode);
+            this._pausedTimers.set(timerId, timerNode);
+        }
+    }
+
+    /**
+     * 继续定时器
+     *
+     * @param {number} timerId 定时器ID
+     * @memberof Timer
+     */
+    public resume(timerId: number): void {
+        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} timerId 定时器ID
+    //  * @param {number} interval 回调间隔
+    //  * @param {number} loop 重复次数
+    //  * @param {boolean} [resetTime=false] 是否更新下次回调时间（从当前时间开始计时）
+    //  * @returns {boolean} 如果TimerID存在则返回true
+    //  * @memberof Timer
+    //  */
+    // public updateTimer(timerId: number, interval: number, loop: number, resetTime: boolean = false): boolean {
+    //     const timerNode = this._pool.get(timerId);
+    //     if (!timerNode) {
+    //         return false;
+    //     }
+    //     timerNode.interval = interval;
+    //     timerNode.loop = loop;
+    //     if (resetTime) {
+    //         timerNode.expireTime = this._elapsedTime + interval;
+    //     }
+    //     return this._heap.update(timerNode);
+    // }
+
+    /**
+     * 更新时钟
+     *
+     * @param {number} deltaTime 更新间隔
+     * @memberof Timer
+     */
+    public update(deltaTime: number): void {
+        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();
+        }
+    }
+
+    /**
+     * 清空所有定时器
+     *
+     * @memberof Timer
+     */
+    public clear(): void {
+        this._heap.clear();
+        this._pool.clear();
+        this._pausedTimers.clear();
+        this._timerNodeOrder = 0;
+    }
+
+    private _getTimerNode(callback: () => void, interval: number, loop: number): TimerNode {
+        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;
+    }
+
+    private _recycle(timerNode: TimerNode): void {
+        this._pool.recycle(timerNode.id);
+    }
+}

src/tool/timer/TimerNode.ts

@@ -0,0 +1,55 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 计时器节点
+ */
+import { HeapNode } from "../DataStruct/BinaryHeap";
+
+export class TimerNode extends HeapNode {
+    /** 定时器ID */
+    public id: number;
+
+    /** 定时器添加索引，同一时间回调根据OrderIndex排序 */
+    public orderIndex: number;
+
+    /** 定时间隔 */
+    public interval: number;
+
+    /** 回调时间点 */
+    public expireTime: number;
+
+    /** 重复次数 */
+    public loop: number = 0;
+
+    /** 定时回调 */
+    public callback: () => void;
+
+    /** 暂停时剩余时间 */
+    public pauseRemainTime: number;
+
+    /** 是否暂停 */
+    public pause: boolean;
+
+    /** * 是否被回收 */
+    public recycled: boolean;
+
+    constructor(id: number) {
+        super();
+        this.id = id;
+    }
+
+    /**
+     * 是否比其他定时节点小
+     * @param {HeapNode} other 其他定时节点
+     * @returns {boolean} 
+     */
+    public lessThan(other: HeapNode): boolean {
+        const otherTimerNode = other as TimerNode;
+
+        if (Math.abs(this.expireTime - otherTimerNode.expireTime) <= 1e-5) {
+            return this.orderIndex < otherTimerNode.orderIndex;
+        }
+
+        return this.expireTime < otherTimerNode.expireTime;
+    }
+}

src/tool/timer/TimerNodePool.ts

@@ -0,0 +1,123 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 计时器节点回收池
+ */
+import { TimerNode } from "./TimerNode";
+
+const TimerIdBit = 19;
+const TimerCount = 1 << (32 - TimerIdBit);
+const TimerVersionMask = (1 << TimerIdBit) - 1;
+const TimerMaxVersion = TimerVersionMask;
+
+export class TimerNodePool {
+    private _pool: Array<TimerNode> = new Array<TimerNode>();
+    private _freeIndices: Array<number> = new Array<number>();
+
+    /**
+     * 定时器池
+     * @param {number} capacity 初始容量
+     */
+    public constructor(capacity: number) {
+        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} 定时器节点
+     */
+    public allocate(): TimerNode {
+        let timerNode: 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
+     */
+    public recycle(timerId: number): void {
+        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}
+     */
+    public get(timerId: number): TimerNode | undefined {
+        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
+     */
+    public clear(): void {
+        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);
+        }
+    }
+}

src/ui/ComponentExtendHelper.ts

@@ -0,0 +1,33 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-26
+ * @Description: 自定义组件扩展帮助类
+ */
+import { UIObjectFactory } from "fairygui-cc";
+import { debug } from "../tool/log";
+import { PropsHelper } from "./PropsHelper";
+import { _uidecorator } from "./UIDecorator";
+
+export class ComponentExtendHelper {
+    public static register(): void {
+        for (const { ctor, res } of _uidecorator.getComponentMaps().values()) {
+            debug(`自定义组件注册  组件名:${res.name} 包名:${res.pkg}`);
+            this.registerComponent(ctor, res.pkg, res.name);
+        }
+    }
+
+    /**
+     * 注册自定义组件信息
+     * @param info 
+     */
+    private static registerComponent(ctor: any, pkg: string, name: string): void {
+        // 自定义组件扩展
+        const onConstruct = function (this: any): void {
+            PropsHelper.serializeProps(this, pkg);
+            this.onInit && this.onInit();
+        };
+        ctor.prototype.onConstruct = onConstruct;
+        // 自定义组件扩展
+        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    }
+}

src/ui/IWindow.ts

@@ -0,0 +1,79 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 
+ */
+
+import { AdapterType, WindowType } from "./header";
+import { IWindowHeader } from "./IWindowHeader";
+import { WindowHeaderInfo } from "./WindowHeaderInfo";
+
+export interface IWindow {
+    /** 窗口类型 */
+    type: WindowType;
+    /** 窗口适配类型 */
+    adapterType: AdapterType;
+    /** 底部遮罩的透明度 */
+    bgAlpha: number;
+    /**
+     * 窗口适配  (框架内部使用)
+     */
+    _adapted(): void;
+
+    /**
+     * 初始化方法 (框架内部使用)
+     * @param swallowTouch 是否吞噬触摸事件
+     */
+    _init(swallowTouch: boolean, bgAlpha: number): void;
+    /** 
+     * 窗口关闭 (框架内部使用)
+     */
+    _close(): void;
+    /**
+     * 显示窗口 (框架内部使用)
+     * @param userdata 用户自定义数据
+     */
+    _show(userdata?: any): void;
+    /**
+     * 从隐藏状态恢复显示
+     */
+    _showFromHide(): void;
+    /** 
+     * 隐藏窗口 (框架内部使用)
+     */
+    _hide(): void;
+    /**
+     * 窗口被遮挡 被同组或者不同组的其他窗口覆盖 (框架内部使用)
+     */
+    _cover(): void;
+    /**
+     * 恢复窗口遮挡 被同组或者不同组的其他窗口覆盖恢复 (框架内部使用)
+     */
+    _recover(): void;
+
+    /**
+     * 调整窗口的显示层级
+     * @param depth 
+     */
+    _setDepth(depth: number): void;
+
+    /**
+     * 窗口是否显示
+     */
+    isShowing(): boolean;
+
+    /**
+     * 窗口是否被遮挡了
+     */
+    isCover(): boolean;
+
+    /** 
+     * 窗口尺寸发生改变时被调用 
+     */
+    screenResize(): void;
+
+    /** 获取资源栏数据 */
+    getHeaderInfo(): WindowHeaderInfo;
+
+    setHeader(header: IWindowHeader): void;
+}

src/ui/IWindowHeader.ts

@@ -0,0 +1,45 @@
+import { AdapterType } from "./header";
+import { IWindow } from "./IWindow";
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 窗口顶边资源栏
+ */
+export interface IWindowHeader {
+    /** 资源栏名称 */
+    name: string;
+    /** 窗口适配类型 */
+    adapterType: AdapterType;
+    /** 引用计数 */
+    _refCount: number;
+    /**
+     * 初始化 (内部方法)
+     */
+    _init(): void;
+    /**
+     * 窗口适配 (内部方法)
+     */
+    _adapted(): void;
+    /**
+     * 显示 (内部方法)
+     * @param {IWindow} window 所属窗口
+     */
+    _show(window: IWindow): void;
+    /**
+     * 隐藏 (内部方法)
+     */
+    _hide(): void;
+    /**
+     * 关闭 (内部方法)
+     */
+    _close(): void;
+
+    /** 增加引用计数 (内部方法) */
+    _addRef(): void;
+    /** 减少引用计数 (内部方法) */
+    _decRef(): number;
+
+    /** 屏幕大小改变时被调用 (内部方法) */
+    _screenResize(): void;
+}

src/ui/PropsHelper.ts

@@ -0,0 +1,89 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-09
+ * @Description: 属性辅助类
+ */
+
+import { GComponent } from "fairygui-cc";
+import { warn } from "../tool/log";
+
+interface IPropsConfig {
+    [packageName: string]: { [componentName: string]: IPropsInfo };
+}
+
+interface IPropsInfo {
+    props: (string | number)[];
+    callbacks: (string | number)[];
+}
+
+export class PropsHelper {
+    private static _config: IPropsConfig = {};
+    public static setConfig(config: IPropsConfig): void {
+        this._config = config;
+    }
+
+    /** 序列化属性 */
+    public static serializeProps(component: GComponent, packageName: string): void {
+        if (!this._config) {
+            return;
+        }
+        const config = this._config[packageName];
+        if (!config) {
+            return;
+        }
+        const componentName = component.name;
+        const propsInfo = config[componentName];
+        if (!propsInfo) {
+            return;
+        }
+        // 设置属性
+        const props = propsInfo.props;
+        this.serializationPropsNode(component, props);
+
+        // 设置回调
+        const callbacks = propsInfo.callbacks;
+        this.serializationCallbacksNode(component, callbacks);
+    }
+
+    /** 给界面中定义的属性赋值 */
+    private static serializationPropsNode(component: GComponent, props: (string | number)[]) {
+        const propsCount = props.length;
+        // [name1, len, ...props1, name2, len, ...props2, ...]
+        let index = 0;
+        while (index < propsCount) {
+            const propName = props[index++] as string;
+            const endIndex = index + (props[index] as number);
+            let uinode = component;
+            while (++index <= endIndex) {
+                uinode = uinode.getChildAt(props[index] as number);
+                if (!uinode) {
+                    warn(`无法对UI类（${component.name}）属性（${propName}）赋值，请检查节点配置是否正确`);
+                    break;
+                }
+            }
+            (component as any)[propName] = (uinode == component ? null : uinode);
+        }
+    }
+
+    private static serializationCallbacksNode(component: GComponent, callbacks: (string | number)[]) {
+        const propsCount = callbacks.length;
+        // [name1, len, ...props1, name2, len, ...props2, ...]
+        let index = 0;
+        while (index < propsCount) {
+            const propName = callbacks[index++] as string;
+            const endIndex = index + (callbacks[index] as number);
+            let uinode = component;
+            while (++index <= endIndex) {
+                uinode = uinode.getChildAt(callbacks[index] as number);
+                if (!uinode) {
+                    warn(`无法对UI类（${component.name}）的（${propName}）设置回调，请检查节点配置是否正确`);
+                    break;
+                }
+            }
+            if (uinode != component) {
+                uinode.onClick((component as any)[propName], component);
+            }
+        }
+    }
+}
+

src/ui/UIDecorator.ts

@@ -0,0 +1,180 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-11
+ * @Description: UI 装饰器
+ */
+
+import { ObjectHelper } from "../tool/helper/ObjectHelper";
+export namespace _uidecorator {
+    const UIPropMeta = "__uipropmeta__"
+    const UICBMeta = "__uicbmeta__"
+
+    interface IUIInfoBase {
+        /** 构造函数 */
+        ctor: any;
+        /** 属性 */
+        props: Record<string, 1>;
+        /** 方法 */
+        callbacks: Record<string, Function>;
+    }
+
+    /**
+     * 窗口属性注册数据结构
+     */
+    interface UIWindowInfo extends IUIInfoBase {
+        /** 配置信息 */
+        res: {
+            /** 窗口组名称 */
+            group: string;
+            /** fgui包名 */
+            pkg: string;
+            /** 窗口名 */
+            name: string;
+        };
+    }
+    /** 用来存储窗口注册信息 */
+    const uiclassMap: Map<any, UIWindowInfo> = new Map();
+
+    /** 获取窗口注册信息 */
+    export function getWindowMaps(): Map<any, UIWindowInfo> {
+        return uiclassMap;
+    }
+
+    /**
+     * 窗口装饰器
+     * @param {string} groupName 窗口组名称
+     * @param {string} pkgName fgui包名
+     * @param {string} name 窗口名 (与fgui中的组件名一一对应)
+     */
+    export function uiclass(groupName: string, pkgName: string, name: string): Function {
+        /** target 类的构造函数 */
+        return function (ctor: any): void {
+            // debug(`uiclass >${JSON.stringify(res)}<`);
+            // debug(`uiclass prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            uiclassMap.set(ctor, {
+                ctor: ctor,
+                props: ctor[UIPropMeta] || null,
+                callbacks: ctor[UICBMeta] || null,
+                res: {
+                    group: groupName,
+                    pkg: pkgName,
+                    name: name,
+                },
+            });
+        };
+    }
+
+
+    /**
+     * 组件属性注册数据结构
+     */
+    interface IUIComInfo extends IUIInfoBase {
+        /** 配置信息 */
+        res: {
+            /** fgui包名 */
+            pkg: string;
+            /** 组件名 */
+            name: string;
+        };
+    }
+    /** 用来存储组件注册信息 */
+    let uicomponentMap: Map<string, IUIComInfo> = new Map();
+
+    /** 获取组件注册信息 */
+    export function getComponentMaps(): Map<any, IUIComInfo> {
+        return uicomponentMap;
+    }
+
+    /**
+     * UI组件装饰器
+     * @param {string} pkg 包名
+     * @param {string} name 组件名
+     */
+    export function uicom(pkg: string, name: string): Function {
+        return function (ctor: any): void {
+            // log(`pkg:【${pkg}】 uicom prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            uicomponentMap.set(ctor, {
+                ctor: ctor,
+                props: ctor[UIPropMeta] || null,
+                callbacks: ctor[UICBMeta] || null,
+                res: {
+                    pkg: pkg,
+                    name: name,
+                }
+            });
+        };
+    }
+
+    /**
+     * header属性注册数据结构
+     */
+    interface IUIHeaderInfo extends IUIInfoBase {
+        /** 配置信息 */
+        res: {
+            /** fgui包名 */
+            pkg: string;
+            /** 组件名 */
+            name: string;
+        };
+    }
+    /** 用来存储组件注册信息 */
+    let uiheaderMap: Map<string, IUIHeaderInfo> = new Map();
+
+    /** 获取header注册信息 */
+    export function getHeaderMaps(): Map<any, IUIHeaderInfo> {
+        return uiheaderMap;
+    }
+
+    /**
+     * UI header装饰器
+     * @param {string} pkg 包名
+     * @param {string} name 组件名
+     */
+    export function uiheader(pkg: string, name: string): Function {
+        return function (ctor: any): void {
+            // log(`pkg:【${pkg}】 uiheader prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            uiheaderMap.set(ctor, {
+                ctor: ctor,
+                props: ctor[UIPropMeta] || null,
+                callbacks: ctor[UICBMeta] || null,
+                res: {
+                    pkg: pkg,
+                    name: name,
+                }
+            });
+        };
+    }
+
+    /**
+     * UI属性装饰器
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 属性名
+     * 
+     * example: @uiprop node: GObject
+     */
+    export function uiprop(target: Object, name: string): any {
+        // debug("属性装饰器:", target.constructor, name);
+        ObjectHelper.getObjectProp(target.constructor, UIPropMeta)[name] = 1;
+    }
+
+    /**
+     * 方法装饰器 (给点击事件用)
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 方法名
+     */
+    export function uiclick(target: Object, name: string, descriptor: PropertyDescriptor): void {
+        // debug("方法装饰器:", target.constructor, name, descriptor);
+        ObjectHelper.getObjectProp(target.constructor, UICBMeta)[name] = descriptor.value;
+    }
+}
+
+let _global = globalThis || window || global;
+(_global as any)["getKunpoRegisterWindowMaps"] = function () {
+    return _uidecorator.getWindowMaps() as any;
+};
+(_global as any)["getKunpoRegisterComponentMaps"] = function () {
+    return _uidecorator.getComponentMaps() as any;
+};
+(_global as any)["getKunpoRegisterHeaderMaps"] = function () {
+    return _uidecorator.getHeaderMaps() as any;
+};

src/ui/WindowGroup.ts

@@ -0,0 +1,393 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 窗口组 (在同一个窗口容器的上的窗口)
+ */
+
+import { Color, warn } from "cc";
+import { GComponent, GGraph, UIPackage } from "fairygui-cc";
+import { WindowBase } from "../fgui/WindowBase";
+import { WindowHeader } from "../fgui/WindowHeader";
+import { Screen } from "../global/Screen";
+import { WindowType } from "./header";
+import { IWindow } from "./IWindow";
+import { PropsHelper } from "./PropsHelper";
+import { WindowManager } from "./WindowManager";
+import { WindowInfo } from "./WindowResPool";
+
+export class WindowGroup {
+    /** 窗口组的名字 */
+    private _name: string = "";
+    /** 窗口组的根节点 */
+    private _root: GComponent;
+    /** 忽略顶部窗口查询 */
+    private _ignoreQuery: boolean = false;
+    /** 吞噬触摸事件 */
+    private _swallowTouch: boolean = false;
+    /** 窗口容器中的窗口名列表 */
+    private _windowNames: string[] = [];
+    /** 窗口顶部资源栏 */
+    private _headers: Map<string, WindowHeader> = new Map();
+    /** 半透明遮罩的透明度 */
+    private _bgAlpha: number = 0;
+    /** 半透明节点 */
+    private _alphaGraph: GGraph;
+    /** 半透明遮罩的颜色 */
+    private _color: Color = new Color(0, 0, 0, 255);
+
+    /**
+     * 获取窗口组的名称。
+     * @returns {string} 窗口组的名称。
+     */
+    public get name(): string {
+        return this._name;
+    }
+
+    /**
+     * 获取当前窗口组中窗口的数量。
+     * @returns 窗口数量
+     */
+    public get size(): number {
+        return this._windowNames.length;
+    }
+
+    /**
+     * 获取是否忽略查询的状态。
+     * @returns {boolean} 如果忽略查询，则返回 true，否则返回 false。
+     */
+    public get isIgnore(): boolean {
+        return this._ignoreQuery;
+    }
+
+    /**
+     * 实例化 
+     * @param name 组名
+     * @param root 窗口组的根节点 一个fgui的组件
+     * @param ignoreQuery 是否忽略顶部窗口查询
+     * @param swallowTouch 是否吞掉触摸事件
+     */
+    constructor(name: string, root: GComponent, ignoreQuery: boolean, swallowTouch: boolean, bgAlpha: number) {
+        this._name = name;
+        this._root = root;
+        this._ignoreQuery = ignoreQuery;
+        this._swallowTouch = swallowTouch;
+        this._bgAlpha = bgAlpha;
+
+        const alphaGraph = new GGraph();
+        alphaGraph.touchable = false;
+        alphaGraph.name = "bgAlpha";
+        alphaGraph.setPosition(root.width * 0.5, root.height * 0.5);
+        alphaGraph.setSize(root.width, root.height, true);
+        alphaGraph.setPivot(0.5, 0.5, true);
+        root.addChild(alphaGraph);
+        this._alphaGraph = alphaGraph;
+    }
+
+    /**
+     * 根据窗口名创建窗口 并添加到显示节点
+     * @param windowName 窗口名
+     */
+    private _createWindow(pkg: string, name: string): WindowBase {
+        let window = UIPackage.createObject(pkg, name) as WindowBase;
+        window.name = name;
+        PropsHelper.serializeProps(window, pkg);
+        window._init(this._swallowTouch, this._bgAlpha);
+        window._adapted();
+        this._createHeader(window);
+        // 添加到显示节点
+        this._addWindow(window);
+        return window;
+    }
+
+    private _addWindow(window: WindowBase): void {
+        this._root.addChild(window);
+        WindowManager._addWindow(window.name, window);
+    }
+
+    public showWindow(info: WindowInfo, userdata?: any): void {
+        let name = info.name;
+        let window = WindowManager.getWindow(name);
+        if (window) {
+            window._show(userdata);
+        } else {
+            window = this._createWindow(info.pkg, name);
+            this._processWindowCloseStatus(window);
+            this._windowNames.push(name);
+            window._show(userdata);
+        }
+        this._moveWindowToTop(name);
+        // 处理header的显示
+        this._processHeaderStatus();
+        // 显示窗口组
+        this._root.visible = true;
+    }
+
+    /**
+     * 移除指定名称的窗口。
+     * @param name 窗口的名称。
+     */
+    public _removeWindow(name: string): void {
+        let index = this._windowNames.lastIndexOf(name);
+        let lastIndex = this.size - 1;
+        if (index < 0) {
+            warn(`窗口组${this._name}中未找到窗口${name} 删除失败`);
+            return;
+        }
+        let window = WindowManager.getWindow<WindowBase>(name);
+        let header = window.getHeader();
+        header && this._removeHeader(header);
+
+        this._windowNames.splice(index, 1);
+
+        // 关闭窗口 并从窗口map中移除
+        WindowManager._removeWindow(name);
+
+        // 处理窗口显示和隐藏状态
+        this._processWindowHideStatus(this.size - 1, true);
+        if (this.size == 0) {
+            // 窗口组中不存在窗口时 隐藏窗口组节点
+            this._root.visible = false;
+        } else if (lastIndex == index && index > 0) {
+            // 删除的窗口是最后一个 并且前边还有窗口 调整半透明节点的显示层级
+            let topName = this.getTopWindowName();
+            let window = WindowManager.getWindow(topName);
+            // 调整半透明遮罩
+            this._adjustAlphaGraph(window);
+            // 调整窗口的显示层级
+            window._setDepth(this._root.numChildren - 1);
+        }
+        this._processHeaderStatus();
+    }
+
+    /**
+     * 将指定名称的窗口移动到窗口组的最顶层。
+     * @param name 窗口的名称。
+     */
+    public _moveWindowToTop(name: string): boolean {
+        let isMoved = false;
+        if (this.size == 0) {
+            warn(`WindowGroup.moveWindowToTop: window group 【${this._name}】 is empty`);
+            return;
+        }
+        if (this._windowNames[this.size - 1] == name) {
+            // 已经在最顶层了
+        } else {
+            const index = this._windowNames.indexOf(name);
+            if (index == -1) {
+                warn(`WindowGroup.moveWindowToTop: window 【${name}】 not found in window group 【${this._name}】`);
+                return;
+            }
+            if (index < this._windowNames.length - 1) {
+                this._windowNames.splice(index, 1);
+                // 放到数组的末尾
+                this._windowNames.push(name);
+                isMoved = true;
+            }
+        }
+
+        let window = WindowManager.getWindow(name);
+        // 先调整半透明遮罩
+        this._adjustAlphaGraph(window);
+        // 再调整窗口的显示层级
+        window._setDepth(this._root.numChildren - 1);
+        // 处理窗口显示和隐藏状态
+        this._processWindowHideStatus(this.size - 1, isMoved);
+    }
+
+    /**
+     * 处理index下层窗口的隐藏状态的私有方法。递归调用
+     * @param index - 窗口索引
+     * @param isRecursion - 是否递归调用
+     */
+    private _processWindowHideStatus(index: number, isRecursion: boolean = true): void {
+        if (index < 0) {
+            return;
+        }
+        let windowName = this._windowNames[index];
+        let curWindow = WindowManager.getWindow(windowName);
+        // 如果当前是当前组中的最后一个窗口并且当前窗口是隐藏状态 则恢复隐藏
+        if (index == this.size - 1 && !curWindow.isShowing()) {
+            curWindow._showFromHide();
+        }
+        if (index == 0) {
+            return;
+        }
+        let windowType = curWindow.type;
+        if (windowType == WindowType.HideAll) {
+            for (let i = index - 1; i >= 0; --i) {
+                let name = this._windowNames[i];
+                const window = WindowManager.getWindow(name);
+                window.isShowing() && window._hide();
+            }
+            return;
+        } else if (windowType == WindowType.HideOne) {
+            // 隐藏前一个
+            let prevWindowName = this._windowNames[index - 1];
+            let prevWindow = WindowManager.getWindow(prevWindowName);
+            prevWindow.isShowing() && prevWindow._hide();
+        } else {
+            // 如果前一个窗口被隐藏了 需要恢复显示
+            let prevWindowName = this._windowNames[index - 1];
+            let prevWindow = WindowManager.getWindow(prevWindowName);
+            !prevWindow.isShowing() && prevWindow._showFromHide();
+        }
+        isRecursion && this._processWindowHideStatus(index - 1, isRecursion);
+    }
+
+    /**
+     * 新创建窗口时，根据新创建的窗口类型
+     * 处理上一个窗口或者所有窗口的关闭
+     */
+    private _processWindowCloseStatus(window: IWindow): void {
+        // 新创建窗口 如果需要关闭窗口或者关闭所有窗口 处理窗口的关闭
+        if (window.type == WindowType.CloseOne) {
+            let size = this.size;
+            while (size > 0) {
+                let name = this._windowNames.pop();
+                let window = WindowManager.getWindow<WindowBase>(name);
+                let header = window.getHeader();
+                header && this._removeHeader(header);
+                WindowManager._removeWindow(name);
+                break;
+            }
+        } else if (window.type == WindowType.CloseAll) {
+            let size = this.size;
+            for (let i = size; i > 0;) {
+                let name = this._windowNames[--i]
+                let window = WindowManager.getWindow<WindowBase>(name);
+                let header = window.getHeader();
+                header && this._removeHeader(header);
+                WindowManager._removeWindow(name);
+            }
+            this._windowNames.length = 0;
+        }
+    }
+
+    /** 处理header的显示状态 并调整层级 */
+    private _processHeaderStatus(): void {
+        // 找到第一个要显示的header
+        let firstHeader: WindowHeader = null;
+        let firstWindow: IWindow = null;
+        let index = this.size - 1;
+        for (let i = this.size - 1; i >= 0; --i) {
+            let name = this._windowNames[i];
+            let window = WindowManager.getWindow<WindowBase>(name);;
+            if (window.isShowing() && window.getHeader()) {
+                firstWindow = window;
+                firstHeader = window.getHeader();
+                index = i;
+                break;
+            }
+        }
+        this._headers.forEach((header, name) => {
+            this._root.setChildIndex(header, 0);
+            if (!firstHeader && header.visible) {
+                header._hide();
+            } else if (firstHeader) {
+                if (firstHeader.name == name && !header.visible) {
+                    header._show(firstWindow);
+                } else if (firstHeader.name != name && header.visible) {
+                    header._hide();
+                }
+            }
+        });
+        if (firstHeader) {
+            if (index == this.size - 1) {
+                this._root.setChildIndex(firstHeader, this._root.numChildren - 1);
+            } else {
+                this._root.setChildIndex(firstHeader, this._root.numChildren - this.size + index - 1);
+            }
+        }
+    }
+
+    /**
+     * 调整指定窗口的透明度图形。并根据窗口的背景透明度绘制半透明遮罩。
+     * @param window - 需要调整透明度的窗口对象。
+     */
+    private _adjustAlphaGraph(window: IWindow): void {
+        this._root.setChildIndex(this._alphaGraph, this._root.numChildren - 1);
+
+        // 半透明遮罩绘制
+        this._color.a = window.bgAlpha * 255;
+        this._alphaGraph.clearGraphics();
+        this._alphaGraph.drawRect(0, this._color, this._color);
+    }
+
+    public hasWindow(name: string): boolean {
+        return this._windowNames.indexOf(name) >= 0;
+    }
+
+    /**
+     * 获取窗口组中顶部窗口的名称。
+     * @returns {string} 顶部窗口的名称。
+     */
+    public getTopWindowName(): string {
+        if (this.size > 0) {
+            return this._windowNames[this.size - 1];
+        }
+        warn(`WindowGroup.getTopWindowName: window group 【${this._name}】 is empty`);
+    }
+
+
+    /** 根据窗口 创建顶部资源栏 (内部方法) */
+    private _createHeader(window: IWindow): void {
+        // 只有创建界面的时候, 才会尝试创建顶部资源栏
+        let headerInfo = window.getHeaderInfo();
+        if (!headerInfo) {
+            return;
+        }
+        let name = headerInfo.name;
+        let header = this._getHeader(name);
+        if (header) {
+            window.setHeader(header);
+            header._addRef();
+        } else {
+            // 创建header节点
+            let { pkg } = WindowManager._getResPool().getHeader(name);
+            let newHeader = UIPackage.createObject(pkg, name) as WindowHeader;
+            newHeader.name = name;
+            newHeader.opaque = false;
+            window.setHeader(newHeader);
+            newHeader.visible = false;
+            PropsHelper.serializeProps(newHeader, pkg);
+            newHeader._init();
+            newHeader._adapted();
+            this._root.addChild(newHeader);
+            // 添加到显示节点
+            newHeader._addRef();
+            this._headers.set(newHeader.name, newHeader);
+        }
+    }
+
+    /**
+     * 顶部资源栏窗口 从管理器中移除 (内部方法)
+     * @param header 资源栏
+     */
+    public _removeHeader(header: WindowHeader): void {
+        if (this._headers.has(header.name)) {
+            let refCount = header._decRef();
+            if (refCount <= 0) {
+                this._headers.delete(header.name);
+                header._close();
+            }
+        }
+    }
+
+    /**
+     * 获取顶部资源栏 (内部方法)
+     * @param name 资源栏的名称
+     */
+    public _getHeader<T extends WindowHeader>(name: string): T | null {
+        return this._headers.get(name) as T;
+    }
+
+    /** 屏幕大小改变时被调用 (内部方法) */
+    public _screenResize(): void {
+        this._headers.forEach((header) => {
+            header._screenResize();
+        });
+        this._alphaGraph.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+        this._alphaGraph.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+        this._alphaGraph.setPivot(0.5, 0.5, true);
+    }
+}

src/ui/WindowHeaderInfo.ts

@@ -0,0 +1,25 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-10
+ * @Description: 窗口顶部资源栏信息
+ */
+
+export class WindowHeaderInfo {
+    /** header名字 */
+    name: string;
+    /** 自定义数据 用于Header窗口 onShow方法的自定义参数 */
+    userdata: any;
+
+    /**
+     * 创建 WindowHeaderInfo
+     * @param {string} name header窗口名
+     * @param {*} [userdata] 自定义数据
+     * @returns {WindowHeaderInfo}
+     */
+    static create(name: string, userdata?: any): WindowHeaderInfo {
+        const info = new WindowHeaderInfo();
+        info.name = name;
+        info.userdata = userdata;
+        return info;
+    }
+}

src/ui/WindowManager.ts

@@ -0,0 +1,216 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 窗口管理类
+ */
+
+import { debug, warn } from "../tool/log";
+import { ComponentExtendHelper } from "./ComponentExtendHelper";
+import { IWindow } from "./IWindow";
+import { _uidecorator } from "./UIDecorator";
+import { WindowGroup } from "./WindowGroup";
+import { WindowResPool } from "./WindowResPool";
+
+export class WindowManager {
+    /** 窗口组 */
+    private static _groups: Map<string, WindowGroup> = new Map();
+    /** 不忽略查询的窗口组名 */
+    private static _queryGroupNames: string[] = [];
+    /** 所有窗口全部放到这个map中 */
+    private static _windows: Map<string, IWindow> = new Map();
+    /** 初始化时传入实例 */
+    private static _resPool: WindowResPool;
+
+    /**
+     * 打开一个窗口
+     * @param windowName 窗口名
+     * @param userdata 用户数据
+     */
+    public static showWindow(windowName: string, userdata?: any): void {
+        //TODO::如果没有资源 加载资源
+        this.showWindowIm(windowName, userdata);
+    }
+
+    /**
+     * 显示指定名称的窗口，并传递可选的用户数据。
+     * @param windowName - 窗口的名称。
+     * @param userdata - 可选参数，用于传递给窗口的用户数据。
+     */
+    public static showWindowIm(windowName: string, userdata?: any): void {
+        const info = this._resPool.get(windowName);
+        const windowGroup = this.getWindowGroup(info.group);
+        windowGroup.showWindow(info, userdata);
+    }
+
+    /**
+     * 关闭窗口
+     * @param windowName 窗口名
+     */
+    public static closeWindow(windowName: string): void {
+        if (!this._windows.has(windowName)) {
+            warn(`窗口不存在 ${windowName} 不需要关闭`);
+            return;
+        }
+        // 先在窗口组中移除
+        let info = this._resPool.get(windowName);
+        const windowGroup = this.getWindowGroup(info.group);
+        windowGroup._removeWindow(windowName);
+        // 窗口组中没有窗口了
+        if (windowGroup.size == 0) {
+            let index = this._queryGroupNames.indexOf(windowGroup.name);
+            if (index > 0 && windowGroup.name == this.getTopGroupName()) {
+                do {
+                    const groupName = this._queryGroupNames[--index];
+                    let group = this.getWindowGroup(groupName);
+                    if (group.size > 0) {
+                        this.getWindow(group.getTopWindowName())._recover();
+                        break;
+                    }
+                } while (index >= 0);
+            }
+        }
+    }
+
+    /**
+     * 获取当前最顶层的窗口实例。
+     * @template T - 窗口实例的类型，必须继承自 IWindow 接口。
+     * @returns {T | null} - 返回最顶层的窗口实例，如果没有找到则返回 null。
+     * @description 该方法会遍历所有窗口组，找到最顶层的窗口并返回其实例。
+     */
+    public static getTopWindow<T extends IWindow>(): T | null {
+        let len = this._queryGroupNames.length;
+        for (let i = len; i > 0;) {
+            let group = this.getWindowGroup(this._queryGroupNames[--i]);
+            if (group.size > 0) {
+                return this.getWindow<T>(group.getTopWindowName());
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 根据窗口名称获取窗口实例。
+     * @template T 窗口类型，必须继承自IWindow接口。
+     * @param name 窗口的名称。
+     * @returns 如果找到窗口，则返回对应类型的窗口实例；否则返回null。
+     */
+    public static getWindow<T extends IWindow>(name: string): T | null {
+        return this._windows.get(name) as T;
+    }
+
+    /**
+     * 检查是否存在指定名称的窗口。
+     * @param name 窗口的名称。
+     * @returns 如果存在指定名称的窗口，则返回 true，否则返回 false。
+     */
+    public static hasWindow(name: string): boolean {
+        return this._windows.has(name);
+    }
+
+    /**
+     * 根据给定的组名获取窗口组。如果组不存在，则抛出错误。
+     * @param groupName 窗口组的名称。
+     * @returns 返回找到的窗口组。
+     */
+    public static getWindowGroup(groupName: string): WindowGroup {
+        if (this._groups.has(groupName)) {
+            return this._groups.get(groupName);
+        }
+        throw new Error(`WindowManager.getWindowGroup: window group 【${groupName}】 not found`);
+    }
+
+
+    /**
+     * 获取当前顶层窗口组的名称。
+     * 返回第一个包含至少一个窗口的窗口组名称。(该方法只检查不忽略查询的窗口组)
+     * 如果没有找到任何包含窗口的组，则返回空字符串。
+     */
+    public static getTopGroupName(): string {
+        let len = this._queryGroupNames.length;
+        for (let i = len - 1; i >= 0; i--) {
+            let name = this._queryGroupNames[i];
+            let group = this._groups.get(name);
+            if (group.size > 0) {
+                return name;
+            }
+        }
+        return "";
+    }
+
+    /**
+     * 初始化窗口管理器，设置资源池。 （框架内部使用）
+     * @param resPool - 窗口资源池实例。
+     */
+    public static _init(resPool: WindowResPool): void {
+        this._resPool = resPool;
+    }
+
+    /**
+     * 向窗口管理器添加一个新窗口。 (框架内部使用)
+     * @param name 窗口的唯一标识符。
+     * @param window 要添加的窗口对象，需实现 IWindow 接口。
+     */
+    public static _addWindow(name: string, window: IWindow): void {
+        this._windows.set(name, window);
+    }
+
+    /**
+     * 移除指定名称的窗口。 (框架内部使用)
+     * @param name 窗口的名称。
+     */
+    public static _removeWindow(name: string): void {
+        if (this.hasWindow(name)) {
+            this._windows.get(name)._close();
+            this._windows.delete(name);
+        }
+    }
+
+    /**
+     * 注册所有UI窗口类到资源池中。 （框架内部使用）
+     * 该方法遍历所有通过_uidecorator.getWindowMaps()获取的窗口映射，
+     * 并将每个窗口的资源名称、构造函数、分组和包信息添加到资源池中。
+     */
+    public static registerUI(): void {
+        // 窗口注册
+        for (const { ctor, res } of _uidecorator.getWindowMaps().values()) {
+            debug(`窗口注册  窗口名:${res.name} 包名:${res.pkg} 组名:${res.group}`);
+            this._resPool.add(ctor, res.group, res.pkg, res.name);
+        }
+        // 窗口header注册
+        for (const { ctor, res } of _uidecorator.getHeaderMaps().values()) {
+            debug(`header注册  header名:${res.name} 包名:${res.pkg}`);
+            this._resPool.addHeader(ctor, res.pkg, res.name);
+        }
+        // 组件注册
+        ComponentExtendHelper.register();
+    }
+
+    /**
+     * 向窗口管理器添加一个窗口组 如果窗口组名称已存在，则抛出错误. (内部方法)
+     * @param group 要添加的窗口组
+     */
+    public static _addWindowGroup(group: WindowGroup): void {
+        if (this._groups.has(group.name)) {
+            throw new Error(`WindowManager._addWindowGroup: window group 【${group.name}】 already exists`);
+        }
+        this._groups.set(group.name, group);
+        // 不忽略查询 加到列表中
+        !group.isIgnore && this._queryGroupNames.push(group.name);
+    }
+
+    /**
+     * 屏幕大小改变时 调用所有窗口的screenResize方法 (内部方法)
+     */
+    public static _screenResize(): void {
+        this._windows.forEach((window: IWindow) => {
+            window.screenResize();
+        });
+        this._groups.forEach((group: WindowGroup) => {
+            group._screenResize();
+        });
+    }
+
+    public static _getResPool(): WindowResPool {
+        return this._resPool;
+    }
+}

src/ui/WindowResPool.ts

@@ -0,0 +1,85 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-13
+ * @Description: 
+ */
+
+import { UIObjectFactory } from "fairygui-cc";
+
+export interface WindowInfo {
+    /** 类的构造函数 */
+    ctor: any;
+    /** 窗口组名 */
+    group: string;
+    /** fgui包名 */
+    pkg: string;
+    /** 窗口名 */
+    name: string;
+}
+
+export interface HeaderInfo {
+    ctor: any;
+    pkg: string;
+}
+
+export class WindowResPool {
+    /** 窗口信息池 */
+    protected _windowInfos: Map<string, WindowInfo> = new Map<string, any>();
+    /** 窗口header信息池 */
+    protected _headerInfos: Map<string, HeaderInfo> = new Map<string, any>();
+
+    /** 可扩展 窗口资源引用计数 */
+
+    /**
+     * 注册窗口信息
+     * @param info 
+     */
+    public add(ctor: any, group: string, pkg: string, name: string): void {
+        if (this.has(name)) {
+            throw new Error(`窗口【${name}】信息已注册 请勿重复注册`);
+        }
+        this._windowInfos.set(name, {
+            ctor: ctor,
+            group: group,
+            pkg: pkg,
+            name: name
+        });
+        // 窗口组件扩展
+        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    }
+
+    public has(name: string): boolean {
+        return this._windowInfos.has(name);
+    }
+
+    public get(name: string): WindowInfo {
+        if (!this.has(name)) {
+            throw new Error(`窗口【${name}】未注册，请使用 _uidecorator.uiclass 注册窗口`);
+        }
+        return this._windowInfos.get(name);
+    }
+
+    /**
+     * 注册窗口header信息
+     * @param info 
+     */
+    public addHeader(ctor: any, pkg: string, name: string): void {
+        this._headerInfos.set(name, {
+            ctor: ctor,
+            pkg: pkg
+        });
+        // 窗口header扩展
+        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    }
+
+    public hasHeader(name: string): boolean {
+        return this._headerInfos.has(name);
+    }
+
+    public getHeader(name: string): HeaderInfo {
+        if (!this.hasHeader(name)) {
+            throw new Error(`窗口header【${name}】未注册，请使用 _uidecorator.uiheader 注册窗口header`);
+        }
+        return this._headerInfos.get(name);
+    }
+}

src/ui/header.ts

@@ -0,0 +1,30 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 窗口的一些类型配置 
+ */
+
+/** 窗口显示时，对其他窗口的隐藏处理类型 */
+export enum WindowType {
+    /** 不做任何处理 */
+    Normal = 0,
+    /** 关闭所有 */
+    CloseAll = 1 << 0,
+    /** 关闭上一个 */
+    CloseOne = 1 << 1,
+    /** 隐藏所有 */
+    HideAll = 1 << 2,
+    /** 隐藏上一个 */
+    HideOne = 1 << 3,
+}
+
+/** 窗口适配类型，默认全屏 */
+export enum AdapterType {
+    /** 全屏适配 */
+    Full = 0,
+    /** 空出刘海 */
+    Bang = 1,
+    /** 固定的 不适配 */
+    Fixed = 2,
+}
+

tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "target": "es6",    // 
+        "module": "es6",    // 
+        "experimentalDecorators": true, // 启用ES装饰器。
+        "strict": true,
+        "strictNullChecks": false,
+        "moduleResolution": "Node",
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "types": [
+            "@cocos/creator-types/engine",
+            "@cocos/creator-types/editor",
+        ]
+    },
+    "include": [
+        "./src/**/*"
+        // "libs"
+    ],
+    // 排除
+    "exclude": [
+        "node_modules",
+        "dist",
+        "build"
+    ]
+}