icarus_groundmark 1.0.0

package/src/Icarus.ts

@@ -0,0 +1,2485 @@
+import { renderer, CCObject } from "cc";
+import { ccenum } from "cc";
+import { EventHandler } from "cc";
+import { _decorator, Animation, assetManager, AsyncDelegate, AudioClip, AudioSource, Color, Component, director, EventTarget, Game, game, instantiate, Label, math, Node, NodePool, NodeSpace, Prefab, Quat, resources, Sprite, SpriteFrame, sys, tween, UIOpacity, UITransform, Vec3, view } from "cc";
+import { KOREA, WECHAT, WECHAT_DIALOG, AGE16 } from "cc/userland/macro";
+const { ccclass, property } = _decorator;
+
+//#region 反序列化或配置解析
+
+@ccclass('EventConfig')
+export class EventConfig {
+    @property({ type: EventHandler, displayName: "事件" })
+    event: EventHandler = new EventHandler();
+    @property({ displayName: "是否延迟触发" })
+    delay_emit: boolean = false;
+    @property({ displayName: "延迟时间(ms)", min: 1 / 60, visible: function (this) { return this.delay_emit } })
+    delay_time: number = 0;
+}
+
+export interface PoolBody {
+    /**对象池名字 */
+    name: string;
+    /**路径 */
+    path: string;
+    /**数量 */
+    count: number,
+    /**自动补充阈值 */
+    auto_supplement: number,
+    /**自动扩容 */
+    auto_expansion: boolean,
+    /**自动实例 */
+    auto_example: boolean,
+    /**是否添加监听 */
+    handler: boolean;
+}
+
+export class PoolConfig {
+    pool: PoolBody[] = [];
+
+    constructor(object) {
+        object.forEach((item, index) => {
+            this.pool.push({ name: item.name, path: item.path, count: item.count, auto_supplement: item.auto_supplement, auto_expansion: item.auto_expansion, auto_example: item.auto_example, handler: item.handler });
+        })
+    }
+
+}
+
+@ccclass('BoneSynchronizationConfig')
+export class BoneSynchronizationConfig {
+    @property({ displayName: '骨骼名' })
+    bone_name: string = '';
+    @property({ type: Node, displayName: '绑定节点' })
+    bind_node: Node = null;
+    @property({ type: Node, displayName: '同步节点' })
+    sync_node: Node = null;
+}
+
+@ccclass('BoneSynchronization')
+export class BoneSynchronization {
+    @property({ type: Node, displayName: "骨架根节点" })
+    skeleton_root: Node = null;
+    @property({ type: [BoneSynchronizationConfig], displayName: '骨骼同步配置' })
+    bone_synchronization_config: BoneSynchronizationConfig[] = [];
+
+    init() {
+        if (!this.skeleton_root) {
+            return;
+        }
+        for (let i = 0; i < this.bone_synchronization_config.length; ++i) {
+            let config = this.bone_synchronization_config[i];
+            if (!config.bind_node) {
+                continue;
+            }
+            if (is_null_string(config.bone_name)) {
+                continue;
+            }
+            this.bind_bone(config);
+        }
+    }
+
+    private bind_bone(config: BoneSynchronizationConfig) {
+        let bone = this.find_bone(config.bone_name);
+        config.bind_node.parent = bone;
+        if (config.sync_node) {
+            config.bind_node.setWorldPosition(config.sync_node.worldPosition.clone());
+            config.bind_node.setWorldRotation(config.sync_node.rotation.clone());
+            config.bind_node.scale = config.sync_node.scale.clone();
+        } else {
+            config.bind_node.setPosition(Vec3.ZERO);
+            config.bind_node.setRotation(Quat.IDENTITY);
+            config.bind_node.scale = Vec3.ONE;
+        }
+    }
+
+    private find_bone(name: string): Node | null {
+        return this.recursive(this.skeleton_root, name);
+    }
+
+    private recursive(node: Node, name: string): Node | null {
+        if (node.name === name) return node;
+        for (let child of node.children) {
+            const found = this.recursive(child, name);
+            if (found) return found;
+        }
+        return null;
+    }
+}
+
+
+export enum ResourcesType {
+    None,Money,Gold,Water,Ice,Oil,Coin,Stone,Mine
+}
+ccenum(ResourcesType)
+@ccclass('Packge')
+export class Packge {
+    @property({ type: ResourcesType, displayName: "资源类型" })
+    type: ResourcesType = ResourcesType.Gold;
+    @property({ displayName: "数量" })
+    count: number = 0;
+    @property({ type: Node, displayName: "根节点" })
+    root: Node = null;
+}
+
+//#endregion
+
+//#region 组件拓展
+
+/**排序方式，不排序，升序，降序 */
+export enum SortType {
+    None, AscendingOrder, DescendingOrder
+}
+
+declare module 'cc' {
+    interface Node {
+        is_shaking: boolean;
+        /**在列表中寻找距离自己最近的 */
+        find_near(list: Node[],range:number): Node | null;
+        /**对列表进行一次排序
+         * @param list 列表
+         * @param sort 排序方式,None:不进行排序,AscendingOrder:升序排序,DescendingOrder:降序排序
+         * @param count 截取数量
+         */
+        distance_sort(list: Node[], sort: SortType, count: number,range:number): { distance: number, item: Node }[] | null;
+        init_retinue();
+    }
+
+    interface Vec3 {
+        /**
+         * 判断两个向量值是否相等
+         * @param other 另一个
+         */
+        same(other: Vec3): boolean;
+        /**
+         * 面向目标
+         * @param target 面向的目标
+         * @param up 上方
+         * @returns 相对角度
+         */
+        look(target: Vec3, up?: Vec3): Vec3;
+        threshold_check(other: Vec3, threshold: Vec3): boolean;
+        /**计算差值 */
+        difference(a: number, b: number): number;
+    }
+
+    interface Component {
+        /**
+         * 用于中止使用全局方法:timer定时器的方法
+         * PS:注意是用于中止全局timer的而不是this.timer,如需要中止this.timer请调用this.cancel_timer();
+         */
+        cancel_thred(): void;
+        /**
+         * 深拷贝一个数组
+         * @param array 
+         * @returns 
+         */
+        copy<T>(array: T[]): T[];
+        timer_thred: number;
+        /**
+         * 定时器,因为设计原因,每次只能存在一个
+         * PS:模拟器或浏览器运行时,取消定时器可能会抛出异常不必理会
+         * @param time 定时器时间,单位为秒
+         */
+        timer(time: number): Promise<unknown>;
+        /**
+         * 取消当前定时器
+         * PS:模拟器或浏览器运行时,取消定时器可能会抛出异常不必理会
+         */
+        cancel_timer(): void;
+
+    }
+
+}
+
+//#region Node拓展
+Node.prototype.find_near = function (list: Node[],range): Node | null {
+    if (list.length == 0) return null;
+    if (list.length == 1) return list[0];
+    let _list = this.distance_sort(list, SortType.AscendingOrder,1,range);
+    return _list.length > 0 ? _list[0].item : null;
+}
+
+Node.prototype.init_retinue = function () {
+    this.components[0].init();
+}
+
+Node.prototype.distance_sort = function (list: Node[], sort: SortType, count: number = 0,range:number = 0): { distance: number, item: Node }[] | null {
+    if (list.length == 0) return null;
+    if (list.length == 1) return [{ distance: 0, item: list[0] }];
+    let new_list: Node[] = list.map(x => x);
+    let distance_list: { distance: number, item: Node }[] = [];
+    let my_position: Vec3 = this.worldPosition.clone();
+    new_list.forEach(item => {
+        distance_list.push({ distance: Vec3.distance(my_position, item.worldPosition.clone()), item: item });
+    })
+    if (sort != SortType.None) {
+        distance_list.sort((a, b) => (sort == SortType.AscendingOrder ? a : b).distance - (sort == SortType.AscendingOrder ? b : a).distance);
+    }
+    if(range > 0){
+        distance_list = distance_list.filter(x => x.distance <= range);
+    }
+    if (count == 0 || count > list.length) {
+        return distance_list;
+    } else {
+        return distance_list.slice(0, count);
+    }
+}
+//#endregion
+
+//#region Component拓展
+Component.prototype.copy = function <T>(list: T[]): T[] {
+    let new_list: T[] = list.map(x => x);
+    return new_list;
+}
+
+Component.prototype.timer = function (time: number): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+        this.cancel_timer = () => {
+            clearTimeout(this.timer_thred);
+            this.timer_thred = -1;
+            this.cancel_timer = null;
+            reject('cancel');
+        }
+        this.timer_thred = setTimeout(() => {
+            resolve('');
+        }, time * 1000);
+    }).catch(error => {
+        throw new Error();
+    });
+}
+//#endregion
+
+//#region Vec3拓展
+Vec3.prototype.same = function (other: Vec3): boolean {
+    return this.x === other.x && this.y === other.y && this.z === other.z;
+}
+
+Vec3.prototype.threshold_check = function (other: Vec3, threshold: Vec3): boolean {
+    return this.difference(this.x, other.x) > threshold.x || this.difference(this.y, other.y) > threshold.y || this.difference(this.z, other.z) > threshold.z;
+}
+
+Vec3.prototype.difference = function (a: number, b: number): number {
+    if (a < 0) {
+        //负数
+        if (b > 0) {
+            return Math.abs(a) + b;
+        } else {
+            if (b == 0) {
+                return Math.abs(a);
+            } else {
+                if (a > b) {
+                    return Math.abs(b) - Math.abs(a);
+                } else if (a < b) {
+                    return Math.abs(a) - Math.abs(b);
+                } else {
+                    return 0;
+                }
+            }
+        }
+    } else {
+        //正数
+        if (b > 0) {
+            if (a > b) {
+                return a - b;
+            } else if (a < b) {
+                return b - a;
+            } else {
+                return 0;
+            }
+        } else {
+            if (b == 0) {
+                return a;
+            } else {
+                return a + Math.abs(b);
+            }
+        }
+    }
+}
+
+Vec3.prototype.look = function (target: Vec3, up: Vec3 = Vec3.UP): Vec3 {
+    Vec3.subtract(this, this, target);
+    Vec3.normalize(this, this);
+    let quat = new Quat();
+    Quat.fromViewUp(quat, this, up);
+    let euler = new Vec3();
+    quat.getEulerAngles(euler);
+    return euler;
+}
+//#endregion
+
+//#endregion
+
+//#region 管理类基类
+
+export enum GameResult{
+    Win,Lose
+}
+
+@ccclass('BaseManager')
+export abstract class BaseManager extends Component {
+
+    protected static instance: BaseManager = null;
+    protected abstract onLoad():void;
+    protected abstract onEnable(): void;
+    protected abstract start(): void;
+    protected abstract onDisable(): void;
+    protected abstract onDestroy(): void;
+    public abstract update(dt: number): void;
+    public abstract lateUpdate(dt: number): void;
+    /**注册消息 */
+    protected abstract register_message(): void;
+    /**注销消息 */
+    protected abstract cancel_message(): void;
+    /**注册监听 */
+    protected abstract register_listener(): void;
+    /**注销监听 */
+    protected abstract cancel_listener(): void;
+
+    protected abstract game_ready(): void;
+    protected abstract game_start(): void;
+    protected abstract game_pause(): void;
+    protected abstract game_resume(): void;
+    protected abstract game_over(): void;
+    protected abstract game_settlement(result: GameResult): void;
+    protected abstract game_replay(): void;
+
+}
+
+//#endregion
+
+//#region 音效控制
+
+export class AudioItem {
+    source;
+    clip;
+    volume;
+    playing;
+    loop;
+    duration;
+    start_time;
+}
+
+export class AudioManager {
+    private static _sources: AudioSource = null;
+    private static clip_map: Record<string, AudioClip> = {};
+    private static items: Record<string, AudioItem> = {};
+    private static root: Node = null;
+    private static _path: string = 'audio/';
+    public static set path(value) { AudioManager._path = value; }
+    private static music_switch: boolean = true;
+    private static sound_switch: boolean = true;
+    private static volume: number = 1.0;
+    private static first_click: boolean = true;
+
+    /**
+     * 初始化音频管理器,自动添加根节点以及AudioSource组件
+     */
+    static init() {
+        if (AudioManager._sources) {
+            return;
+        }
+        let _root = new Node('AudioManager');
+        director.addPersistRootNode(_root);
+        let _sources = _root.addComponent(AudioSource);
+        AudioManager._sources = _sources;
+        AudioManager.root = _root;
+        for (let name in AudioManager.items) {
+            const item = AudioManager.items[name];
+            item && item.playing && item.source.stop();
+        }
+        AudioManager.items = {};
+        if ('volumeSwitch' in window && window.volumeSwitch !== void 0) {
+            console.log('Init AudioManager volumeSwitch', window.volumeSwitch);
+            AudioManager.music_switch = !!window.volumeSwitch;
+            AudioManager.sound_switch = !!window.volumeSwitch;
+        }
+        if (window.__PLATFORM == 'Ironsource') {
+            //Ironsource 平台音量
+            var vs = window.volumeAudio;
+            if (vs <= 0) {
+                AudioManager.volume = 0;
+                AudioManager.music_switch = false;
+                AudioManager.sound_switch = false;
+            } else if (typeof vs == 'number') {
+                AudioManager.volume = vs;
+            }
+        }
+        console.log('Init AudioManager:', AudioManager.music_switch, AudioManager.volume);
+        game.on(Game.EVENT_HIDE, function () {
+            AudioManager.pause();
+        });
+        game.on(Game.EVENT_SHOW, function () {
+            AudioManager.resume();
+        });
+        view.on("audioVolumeChange", AudioManager.audio_volume_change, this);
+    }
+
+    static audio_volume_change(event) {
+        let last = AudioManager.music_switch;
+        AudioManager.music_switch = event;
+        AudioManager.sound_switch = event;
+        if (last && !event) {
+            AudioManager.pause();
+        } else if (!last && event) {
+            AudioManager.resume();
+        }
+    }
+
+
+    /**
+     * 暂停所有长音效和背景音
+     */
+    static pause() {
+        const source = AudioManager._sources;
+        if (source) {
+            source.pause();
+        }
+        for (let name in AudioManager.items) {
+            const item = AudioManager.items[name];
+            item && item.playing && item.source.pause();
+        }
+    }
+
+    /**
+     * 恢复所有长音效和背景音
+     */
+    static resume() {
+        if (!AudioManager.music_switch) {
+            return;
+        }
+        const source = AudioManager._sources;
+        if (source) {
+            source.play();
+        }
+        for (let name in AudioManager.items) {
+            const item = AudioManager.items[name];
+            item && item.playing && (item.loop || game.totalTime - item.start_time < item.duration - 500) && item.source.play();
+        }
+    }
+
+    /**
+     * 音效播放
+     * @param name 音效名称
+     * @param ratio 当同时或近似时间多次申请同一个音效的播放,会按照播放进度进行调整,避免多个音效同时播放
+     * @param _source 音源,如果不传入,则使用默认音源
+     * @param end_call 播放结束回调
+     * @param volume 音量
+     * @returns 
+     */
+    static sound_play(name: string, ratio: number = 0.2, _source: AudioSource = null, end_call = null, volume: number = 1) {
+        if (!AudioManager.sound_switch || !AudioManager.first_click) {
+            return;
+        }
+        if (!AudioManager._sources && !_source) {
+            return;
+        }
+        const source = _source ? _source : AudioManager._sources;
+        let path = `${AudioManager._path}${name}`;
+        let clip = AudioManager.clip_map[path];
+        if (clip) {
+            source.playOneShot(clip, volume, ratio, end_call);
+        } else {
+            assetManager.resources?.load(path, AudioClip, (err, clip) => {
+                if (err) {
+                    console.warn(err);
+                    return;
+                }
+                AudioManager.clip_map[path] = clip;
+                source.playOneShot(clip, volume, ratio, end_call);
+            });
+        }
+    }
+
+    /**
+     * 背景音播放
+     * @param name 背景音名称
+     * @param loop 是否循环播放
+     */
+    static music_play(name: string, loop: boolean = true) {
+        if (!AudioManager._sources) {
+            return;
+        }
+        const source = AudioManager._sources;
+        if (source.playing) {
+            return;
+        }
+        source.loop = loop;
+        let path = `${AudioManager._path}${name}`;
+        let clip = AudioManager.clip_map[path];
+        if (clip) {
+            source.clip = clip;
+            if (AudioManager.music_switch) {
+                source.play();
+            }
+            if (!AudioManager.first_click) {
+                source.pause();
+            }
+        } else {
+            assetManager.resources?.load(path, AudioClip, (err, clip) => {
+                if (err) {
+                    console.warn(err);
+                    return;
+                }
+                AudioManager.clip_map[path] = clip;
+                source.clip = clip;
+                if (AudioManager.music_switch) {
+                    source.play();
+                }
+                if (!AudioManager.first_click) {
+                    source.pause();
+                }
+            });
+        }
+    }
+
+    /**
+     * 背景音暂停
+     */
+    static music_pause() {
+        if (!AudioManager._sources) {
+            return;
+        }
+        const source = AudioManager._sources;
+        if (source.playing) {
+            source.pause();
+        }
+    }
+
+    /**
+     * 背景音停止
+     */
+    static music_stop() {
+        if (!AudioManager._sources) {
+            return;
+        }
+        const source = AudioManager._sources;
+        if (source.playing) {
+            source.stop();
+        }
+    }
+
+    /**
+     * 背景音恢复
+     */
+    static music_resume() {
+        if (!AudioManager.music_switch) {
+            return;
+        }
+        if (!AudioManager._sources) {
+            return;
+        }
+        const source = AudioManager._sources;
+        if (!source.playing) {
+            source.play();
+        }
+    }
+
+    static _create_new_source(name: string, loop: boolean) {
+        let node = new Node(`Audio_${name}_Source`);
+        node.parent = AudioManager.root;
+        return AudioManager.items[name] = { source: node.addComponent(AudioSource), playing: false, loop: loop, duration: 0, start_time: 0, clip: null, volume: 1 };
+    }
+
+    /**
+     * 长音频播放
+     * @param name 长音频名称
+     * @param loop 是否循环播放
+     * @param _source 音源,如果不传入,则自动寻找或创建对应音源
+     * @param volume 音量
+     * @returns 
+     */
+    static audio_play(name: string, loop: boolean = false, _source: AudioSource = null, volume: number = 1) {
+        //如果提供了音源,或存在音源,则可以直接播放
+        let item = AudioManager.items[name];
+        const source = item ? item.source : _source ? _source : (item = AudioManager._create_new_source(name, loop)).source;
+        let source_play = (item, loop, volume) => {
+            item.loop = item.source.loop = loop;
+            item.source.volume = volume && !isNaN(volume) ? AudioManager.volume * volume : AudioManager.volume;
+            item.volume = volume;
+            item.duration = item.source.duration * 1000;
+            item.playing = true;
+            if (AudioManager.sound_switch) {
+                item.source.play();
+            }
+            if (!AudioManager.first_click) {
+                item.source.pause();
+            }
+        }
+        if (source) {
+            if (!source.playing && source.clip) {
+                source_play(item, loop, volume);
+                return;
+            }
+        }
+        let path = `${AudioManager._path}${name}`;
+        let clip = AudioManager.clip_map[path];
+        if (clip) {
+            item.clip = source.clip = clip;
+            source_play(item, loop, volume);
+        } else {
+            assetManager.resources?.load(path, AudioClip, (err, clip) => {
+                if (err) {
+                    console.warn(err);
+                    return;
+                }
+                AudioManager.clip_map[path] = clip;
+                item.clip = source.clip = clip;
+                source_play(item, loop, volume);
+            });
+        }
+    }
+
+    /**
+     * 长音频暂停
+     * @param name 长音频名称,如果不传入,则暂停所有音效
+     */
+    static audio_pause(name?: string);
+    /**
+     * 长音频暂停
+     * @param name 长音频名称数组,如果不传入,则暂停所有音效
+     */
+    static audio_pause(name?: string[]);
+    static audio_pause(name: string | string[] = 'pause_all') {
+        if (name === 'pause_all') {
+            //暂停所有音效
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                if (item.playing) {
+                    item.playing = false;
+                    item.source.pause();
+                }
+            }
+            return;
+        }
+        if (name instanceof Array) {
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                if (name.indexOf(key) === -1) {
+                    continue;
+                }
+                name.splice(name.indexOf(key), 1);
+                if (item.playing) {
+                    item.playing = false;
+                    item.source.pause();
+                }
+            }
+            return;
+        }
+        let item = AudioManager.items[name];
+        if (item) {
+            item.playing = false;
+            item.source.pause();
+        }
+    }
+
+    /**
+     * 长音频停止
+     * @param name 长音频名称,如果不传入,则停止所有音效
+     */
+    static audio_stop(name?: string);
+    /**
+     * 长音频停止
+     * @param name 长音频名称数组,如果不传入,则停止所有音效
+     */
+    static audio_stop(name?: string[]);
+    static audio_stop(name: string | string[] = 'stop_all') {
+        if (name === 'stop_all') {
+            //停止所有音效
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                if (item.playing) {
+                    item.playing = false;
+                    item.source.stop();
+                }
+            }
+            return;
+        }
+        if (name instanceof Array) {
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                if (name.indexOf(key) === -1) {
+                    continue;
+                }
+                name.splice(name.indexOf(key), 1);
+                if (item.playing) {
+                    item.playing = false;
+                    item.source.stop();
+                }
+            }
+            return;
+        }
+        let item = AudioManager.items[name];
+        if (item) {
+            item.playing = false;
+            item.source.stop();
+        }
+    }
+
+    /**
+     * 长音频恢复播放
+     * @param name 长音频名称,如果不传入,则恢复所有音效
+     */
+    static audio_resume(name?: string);
+    /**
+     * 长音频恢复播放
+     * @param name 长音频名称数组,如果不传入,则恢复所有音效
+     */
+    static audio_resume(name?: string[]);
+    static audio_resume(name: string | string[] = 'resume_all') {
+        if (!AudioManager.sound_switch) {
+            return;
+        }
+        if (name === 'resume_all') {
+            //恢复所有音效
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                if (!item.playing) {
+                    item.playing = true;
+                    item.source.play();
+                }
+            }
+            return;
+        }
+        if (name instanceof Array) {
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                if (name.indexOf(key) === -1) {
+                    continue;
+                }
+                name.splice(name.indexOf(key), 1);
+                if (!item.playing) {
+                    item.playing = true;
+                    item.source.play();
+                }
+            }
+            return;
+        }
+        let item = AudioManager.items[name];
+        if (item) {
+            item.playing = true;
+            item.source.play();
+        }
+    }
+
+    /**
+     * 长音频和音效音量
+     * @param name 音量,范围0-1
+     */
+    static audio_volume(name?: number);
+    /**
+     * 长音频音量
+     * @param name 长音频名称数组,如果不传入,则设置所有音效音量
+     * @param volume 音量,范围0-1
+     */
+    static audio_volume(name?: string, volume?: number);
+    static audio_volume(name: string | number = 'volume_all', volume = 1) {
+        if (typeof (name) === 'string') {
+            let item = AudioManager.items[name];
+            if (item) {
+                item.source.volume = AudioManager.volume * volume;
+            }
+        } else {
+            //所有的音效
+            for (let key in AudioManager.items) {
+                let item = AudioManager.items[key];
+                item.source.volume = AudioManager.volume * name;
+            }
+        }
+    }
+
+    /**
+     * 整体音量
+     */
+    static set Volume(volume) {
+        if (AudioManager._sources) {
+            AudioManager.volume = volume;
+            AudioManager._sources.volume = AudioManager.volume * volume;
+        }
+        for (let key in AudioManager.items) {
+            let item = AudioManager.items[key];
+            item.source.volume = AudioManager.volume * item.volume;
+        }
+    }
+
+    /**
+     * 背景音乐开关
+     */
+    static set MusicSwitch(value) {
+        AudioManager.music_switch = value;
+        if (AudioManager._sources) {
+            if (AudioManager._sources.playing) {
+                AudioManager._sources.pause();
+            } else {
+                AudioManager._sources.play();
+            }
+        }
+    }
+
+    /**
+     * 背景音乐开关
+     */
+    static get MusicSwitch() {
+        return AudioManager.music_switch;
+    }
+
+    /**
+     * 音效开关
+     */
+    static set SoundSwitch(value) {
+        AudioManager.sound_switch = value;
+        //更新所有音效的音量
+        if (value) {
+            AudioManager.audio_resume();
+        } else {
+            AudioManager.audio_pause();
+        }
+    }
+
+    /**
+     * 音效开关
+     */
+    static get SoundSwitch() {
+        return AudioManager.sound_switch;
+    }
+}
+//#endregion
+
+//#region 国际化
+
+export class PlayableSDK {
+
+    ////////////// 上报打点数据接口，所有接口都需要实现 /////////////////////////////////////
+    ////////下面这3个函数在框架会自动调用
+    static onInitPlayable() { }	//可玩广告启动
+    static onLoaded() { }	//资源加载完成
+    static onCompleted() { }  //当用户关闭页面或离开可试玩广告时调用
+    //////// 这两个函数在PlayableSDK中自动调用
+    static onDisplay() { }  // 加载完显示也是游戏开始
+    static onInstall(type) { };  //下载安装
+
+    static androidUrl = ""
+    static iosUrl = ""
+
+    static designate_platform = '';
+    static set DesignatePlatform(value) {
+        PlayableSDK.designate_platform = value;
+    }
+
+    static isFirstClick = false;
+
+    static _platform = {
+        Aarki: 'Aarki',
+        AdColony: 'AdColony',
+        Applovin: 'Applovin',
+        Bigo: 'Bigo',
+        Chartboost: 'Chartboost',
+        Facebook: 'Facebook',
+        Google: 'Google',
+        Ironsource: 'Ironsource',
+        Kwai: 'Kwai',
+        Liftoff: 'Liftoff',
+        Mintegral: 'Mintegral',
+        Mytarget: 'Mytarget',
+        Moloco: 'Moloco',
+        Pangle: 'Pangle',
+        Snapchat: 'Snapchat',
+        Tapjoy: 'Tapjoy',
+        Tiktok: 'Tiktok',
+        Unity: 'Unity',
+        Vungle: 'Vungle',
+        Wechat: 'Wechat',
+        Douyin: 'Douyin',
+        Preview: 'Preview',
+    }
+
+    static get platform() {
+        if (!is_null_string(PlayableSDK.designate_platform)) {
+            return PlayableSDK.designate_platform;
+        }
+        if ('__PLATFORM' in window) {
+            if (window.__PLATFORM) return PlayableSDK._platform[window.__PLATFORM];
+        }
+        if (window.wx) {
+            return PlayableSDK._platform.Wechat;
+        } else if (window.tt) {
+            return PlayableSDK._platform.Douyin;
+        }
+        return PlayableSDK._platform.Preview;
+    }
+
+    /**
+     * 上报游戏进度
+     * @param progress 游戏进度，取值固定0，25，50，75，100
+     */
+    static game_progress(progress: number) {
+        PlayableSDK.trackCustomEvent('challenge progress', { progress: progress });
+    }
+
+    static hideLoadingBar() {
+        if (window.setLoadingProgress) {
+            window.setLoadingProgress(100);
+        }
+        if (window.AnalyticsIns && window.AnalyticsIns.onDisplay) {
+            window.AnalyticsIns.onDisplay();
+        }
+    }
+
+    static getGameConfs(key) {
+        if ('GameConfs' in window) {
+            return window.GameConfs[key];
+        } else {
+            return null;
+        }
+    }
+
+    static download(type = 'download') {
+        if (window.xsd_playable) {
+            window.xsd_playable.download();
+        }
+        else if (PlayableSDK.platform === PlayableSDK._platform.Wechat) {
+            window.wx.notifyMiniProgramPlayableStatus({ isEnd: true });
+        }
+        else if (PlayableSDK.platform === PlayableSDK._platform.Douyin) {
+            // 目前是30秒自动跳，没有主动跳转
+            window.tt.notifyMiniProgramPlayableStatus({
+                success(res) {
+                },
+                fail(res) {
+                }
+            });
+        }
+        if (window.AnalyticsIns && window.AnalyticsIns.onInstall) {
+            window.AnalyticsIns.onInstall(type);
+        }
+    }
+
+    /**
+     * 上报自定义事件，对于不同厂家的要求，均可以用这个来自己实现
+     * @param eventName 事件名称
+     * @param params 事件参数，字典对象
+     */
+    static trackCustomEvent(eventName, params) {
+        if (window.AnalyticsIns) {
+            window.AnalyticsIns.trackCustomEvent(eventName, params);
+        }
+    }
+
+    /**
+     * 当游戏进入结束状态（如显示得分、结算界面等）时调用
+     * @param result 本次游戏结果，通关win、通关失败lose
+     */
+    static onShowEndCard(result = 'win') {
+        if (window.AnalyticsIns) {
+            window.AnalyticsIns.onShowEndCard(result)
+        }
+    }
+
+    /**
+     * 当玩家点击重新开始游戏时调用
+     */
+    static onRetry() {
+        if (window.AnalyticsIns) {
+            window.AnalyticsIns.onRetry()
+        }
+    }
+
+    static adapter() {
+        window.xsd_playable && window.xsd_playable.adapter()
+    }
+
+    static gameReady() {
+        window.xsd_playable && window.xsd_playable.gameReady()
+    }
+
+    static gameDownload() {
+        window.xsd_playable && window.xsd_playable.install()
+    }
+
+    static gameEnd() {
+        window.xsd_playable && window.xsd_playable.gameEnd()
+    }
+
+    static onInteracted() {
+        if (!this.isFirstClick) {
+            window.xsd_playable && window.xsd_playable.onInteracted();
+            this.isFirstClick = true;
+        }
+    }
+
+    static unicodeEncode(t) {
+        for (var e = "", o = 0; o < t.length; o++) {
+            var n = t.charCodeAt(o);
+            e += "\\u" + this.padLeft(n.toString(16), "0", 4)
+        }
+        return e
+    }
+
+    static unicodeDecode(t) {
+        return t.replace(/\\u([\d\w]{4})/gi, function (t, e) {
+            return String.fromCharCode(parseInt(e, 16))
+        })
+    }
+
+    static padLeft(t, e, o) {
+        for (; t.length < o;) t = e + t;
+        return t
+    }
+
+}
+
+export class Language {
+    static _code = '';
+    static init(code = '', texture_base_path = 'Internationalization', end_call = null) {
+        if (is_null_string(code)) {
+            Language._code = Language._get();
+        } else {
+            Language._code = code;
+        }
+        if (is_null_string(texture_base_path)) {
+            texture_base_path = 'Internationalization';
+        }
+        resources.loadDir(texture_base_path + '/' + Language._code, () => {
+            end_call && end_call();
+        })
+    }
+
+    static get code() {
+        if (is_null_string(Language._code)) {
+            Language.init(KOREA ? 'ko' : '');
+        }
+        return Language._code;
+    }
+
+    static _get() {
+        if (Language._code) return Language._code;
+        let code = "";
+        switch (sys.languageCode) {
+            //繁中
+            case 'zh-tw':
+            case 'zh-hk':
+                code = 'zh-c';
+                break;
+            //简中
+            case 'zh':
+            case 'zh-cn':
+            case 'zh_CN':
+                code = 'zh-s';
+                break;
+            //未知
+            case 'unknown':
+                code = 'en';
+                break;
+            default:
+                if (sys.languageCode.includes('-')) {
+                    code = sys.languageCode.split("-")[0];
+                } else {
+                    code = sys.languageCode;
+                }
+                break;
+        }
+        Language._code = code;
+        return Language._code;
+    }
+}
+
+@ccclass('InternationalizationConfig')
+export class InternationalizationConfig {
+
+    @property({ displayName: "简中", group: '文本' })
+    zh_s = '';
+    @property({ displayName: "繁中", group: '文本' })
+    zh_c = '';
+    @property({ displayName: "英语", group: '文本' })
+    en = '';
+    @property({ displayName: "意大利", group: '文本' })
+    it = '';
+    @property({ displayName: "西班牙", group: '文本' })
+    es = '';
+    @property({ displayName: "荷兰", group: '文本' })
+    du = '';
+    @property({ displayName: "匈牙利", group: '文本' })
+    hu = '';
+    @property({ displayName: "葡萄牙", group: '文本' })
+    pt = '';
+    @property({ displayName: "挪威", group: '文本' })
+    no = '';
+    @property({ displayName: "波兰", group: '文本' })
+    pl = '';
+    @property({ displayName: "土耳其", group: '文本' })
+    tr = '';
+    @property({ displayName: "乌克兰", group: '文本' })
+    uk = '';
+    @property({ displayName: "罗马尼亚", group: '文本' })
+    ro = '';
+    @property({ displayName: "保加利亚", group: '文本' })
+    bg = '';
+    @property({ displayName: "印度", group: '文本' })
+    hi = '';
+    @property({ displayName: "未知", group: '文本' })
+    unknown = '';
+    @property({ displayName: "法国", group: '文本' })
+    fr = '';
+    @property({ displayName: "德国", group: '文本' })
+    de = '';
+    @property({ displayName: "俄语", group: '文本' })
+    ru = '';
+    @property({ displayName: "日本", group: '文本' })
+    ja = '';
+    @property({ displayName: "阿拉伯", group: '文本' })
+    ar = '';
+    @property({ displayName: "韩国", group: '文本' })
+    ko = '';
+    @property({ displayName: "越南", group: '文本' })
+    vi = '';
+
+    string_map = null;
+    get(code) {
+        if (this.string_map == null) {
+            this.set();
+        }
+        return this.string_map[code] && !is_null_string(this.string_map[code]) ? this.string_map[code] : this.string_map.en;
+    }
+
+    set() {
+        this.string_map = {};
+        this.string_map['zh-s'] = this.zh_s;
+        this.string_map['zh-c'] = this.zh_c;
+        this.string_map['en'] = this.en;
+        this.string_map['it'] = this.it;
+        this.string_map['es'] = this.es;
+        this.string_map['du'] = this.du;
+        this.string_map['hu'] = this.hu;
+        this.string_map['pt'] = this.pt;
+        this.string_map['no'] = this.no;
+        this.string_map['pl'] = this.pl;
+        this.string_map['tr'] = this.tr;
+        this.string_map['uk'] = this.uk;
+        this.string_map['ro'] = this.ro;
+        this.string_map['bg'] = this.bg;
+        this.string_map['hi'] = this.hi;
+        this.string_map['fr'] = this.fr;
+        this.string_map['de'] = this.de;
+        this.string_map['ru'] = this.ru;
+        this.string_map['ja'] = this.ja;
+        this.string_map['ar'] = this.ar;
+        this.string_map['ko'] = this.ko;
+        this.string_map['vi'] = this.vi;
+        this.string_map['unknown'] = this.unknown;
+    }
+}
+
+@ccclass('PlatformConfig')
+export class PlatformConfig {
+    @property({ displayName: '动画', tooltip: '勾选后会保留节点的动画组件' })
+    Animation = true;
+    @property({ displayName: '可见', tooltip: '勾选后会显示节点' })
+    Visable = true;
+    @property({ displayName: '精灵', tooltip: '勾选后会强制变更纹理' })
+    Sprite = false;
+    @property({ displayName: '纹理路径', tooltip: '指定纹理路径', visible: function (this) { return this.Sprite } })
+    path = '';
+    @property({ displayName: '着色器', tooltip: '勾选后会修改shader的属性' })
+    Shader = false;
+}
+
+@ccclass('Internationalization')
+export class Internationalization extends Component {
+
+    @property({ displayName: '预览', group: '平台处理', tooltip: '预览启用的规则名字,默认Google' })
+    preview = 'Google';
+    @property({ type: PlatformConfig, displayName: 'Google', group: '平台处理' })
+    google = new PlatformConfig();
+    @property({ type: PlatformConfig, displayName: 'Wechat', group: '平台处理' })
+    wechat = new PlatformConfig();
+    @property({ type: PlatformConfig, displayName: '抖音', group: '平台处理' })
+    douyin = new PlatformConfig();
+    @property({ type: InternationalizationConfig, displayName: '国际化文本', group: '国际化', visible: function (this) { return this.getComponent(Label) != null; } })
+    config = new InternationalizationConfig();
+
+    scale = null;
+    size = null;
+
+    onLoad() {
+        //优先处理平台设定
+        if (!this.platform_deploy()) {
+            this.internationalization_deploy();
+        }
+    }
+
+    /**
+     * 按渠道部署
+     * @returns 
+     */
+    platform_deploy() {
+        switch (PlayableSDK.platform) {
+            case PlayableSDK._platform.Google:
+                return this.google_deploy();
+            case PlayableSDK._platform.Wechat:
+                return this.wechat_deploy();
+            case PlayableSDK._platform.Douyin:
+                return this.douyin_deploy();
+            case PlayableSDK._platform.Preview:
+                switch (this.preview) {
+                    case PlayableSDK._platform.Google:
+                        return this.google_deploy();
+                    case PlayableSDK._platform.Wechat:
+                        return this.wechat_deploy();
+                    case PlayableSDK._platform.Douyin:
+                        return this.douyin_deploy();
+                }
+                break;
+        }
+    }
+
+    /**
+     * 部署Google平台
+     * @returns 
+     */
+    google_deploy() {
+        let deploy_visible_or_sprite = false;
+        if (!this.google.Animation) {
+            //需要禁用动画组件
+            let animation = this.getComponent(Animation);
+            if (animation != null) {
+                animation.enabled = false;
+            } else {
+                console.error('Google平台禁用动画组件失败,动画组件未获取');
+            }
+        } else {
+            if (!this.getComponent(Animation).enabled) {
+                this.getComponent(Animation).enabled = true;
+            }
+        }
+        if (!this.google.Visable) {
+            //需要禁用节点
+            this.node.active = false;
+            deploy_visible_or_sprite = true;
+        }
+        if (this.google.Sprite) {
+            //需要变更纹理
+            this.sprite_deploy(`${this.google.path}/spriteFrame`);
+            deploy_visible_or_sprite = true;
+        }
+        if (this.google.Shader) {
+            this.getComponent(Sprite).getMaterialInstance(0).setProperty('speedScale', 0);
+        }
+        return deploy_visible_or_sprite;
+    }
+
+    /**
+     * 部署Wechat平台
+     * @returns 
+     */
+    wechat_deploy() {
+        let deploy_visible_or_sprite = false;
+        if (!this.wechat.Animation) {
+            //需要禁用动画组件
+            let animation = this.getComponent(Animation);
+            if (animation != null) {
+                animation.enabled = false;
+            } else {
+                console.error('Wechat平台禁用动画组件失败,动画组件未获取');
+            }
+        } else {
+            if (!this.getComponent(Animation).enabled) {
+                this.getComponent(Animation).enabled = true;
+            }
+        }
+        if (!this.wechat.Visable) {
+            //需要禁用节点
+            this.node.active = false;
+            deploy_visible_or_sprite = true;
+        }
+        if (this.wechat.Sprite) {
+            //需要变更纹理
+            this.sprite_deploy(`${this.wechat.path}/spriteFrame`);
+            deploy_visible_or_sprite = true;
+        }
+        if (this.wechat.Shader) {
+            this.getComponent(Sprite).getMaterialInstance(0).setProperty('speedScale', 0);
+        }
+        return deploy_visible_or_sprite;
+    }
+
+    /**
+     * 部署抖音平台
+     * @returns 
+     */
+    douyin_deploy() {
+        let deploy_visible_or_sprite = false;
+        if (!this.douyin.Animation) {
+            //需要禁用动画组件
+            let animation = this.getComponent(Animation);
+            if (animation != null) {
+                animation.enabled = false;
+            } else {
+                console.error('抖音平台禁用动画组件失败,动画组件未获取');
+            }
+        }
+        if (!this.douyin.Visable) {
+            //需要禁用节点
+            this.node.active = false;
+            deploy_visible_or_sprite = true;
+        }
+        if (this.douyin.Sprite) {
+            //需要变更纹理
+            this.sprite_deploy(`${this.douyin.path}/spriteFrame`);
+            deploy_visible_or_sprite = true;
+        }
+        if (this.douyin.Shader) {
+            this.getComponent(Sprite).getMaterialInstance(0).setProperty('speedScale', 0);
+        }
+        return deploy_visible_or_sprite;
+    }
+
+    /**
+     * 变更精灵
+     * @param path 精灵路径
+     */
+    sprite_deploy(path) {
+        let sprite = this.getComponent(Sprite);
+        let self = this;
+        let adaptive = () => {
+            let new_size = self.node.getComponent(UITransform).contentSize.clone();
+            let _w = self.size.width / new_size.width, _h = self.size.height / new_size.height;
+            self.node.scale = self.scale.clone().multiplyScalar(Math.min(_w, _h));
+            if (self.node.scale.x > self.scale.x || self.node.scale.y > self.scale.y) {
+                self.node.scale = self.scale;
+            }
+        }
+        if (sprite != null) {
+            this.scale = this.node.scale.clone();
+            this.size = this.node.getComponent(UITransform).contentSize.clone();
+            let sprite_frame = resources.get(path, SpriteFrame);
+            if (sprite_frame) {
+                sprite.spriteFrame = sprite_frame;
+                adaptive();
+            } else {
+                resources.load(path, SpriteFrame, (err, sprite_frame) => {
+                    if (err) {
+                        console.error('变更精灵失败,纹理未加载', err);
+                    } else {
+                        sprite.spriteFrame = sprite_frame;
+                        adaptive();
+                    }
+                });
+            }
+        } else {
+            console.error('变更精灵失败,精灵组件未获取');
+        }
+    }
+
+    /**
+     * 按国际化部署
+     * @returns 
+     */
+    internationalization_deploy() {
+        let label = this.node.getComponent(Label);
+        if (label) {
+            label.string = this.config.get(Language.code);
+            return;
+        }
+        let sprite = this.getComponent(Sprite);
+        let uuid = sprite.spriteFrame.uuid;
+        let info : any = resources.getAssetInfo(uuid);
+        let code = Language.code;
+        if (this.size == null) {
+            this.scale = this.node.scale.clone();
+            this.size = this.node.getComponent(UITransform).contentSize.clone();
+        }
+        if (info && info.path) {
+            let path = info.path;
+            path = path.replace('/en/', '/' + code + '/');
+            this.sprite_deploy(path);
+        } else {
+            console.log('国际化更换纹理失败,未查询到原纹理信息', info);
+        }
+    }
+}
+//#endregion
+
+//#region 消息机
+export class EventSystem {
+
+    _event_target = new EventTarget();
+    _async_delegates = new Map();
+
+    /**
+     * 注册事件目标的特定事件类型回调。这种类型的事件应该被 `emit` 触发。
+     * @param event_name 事件名
+     * @param callback 回调函数
+     * @param target 目标对象
+     * @param once 是否只触发一次
+     */
+    on(event_name: string, callback: (...args: any[]) => void, target?, once?) {
+        this._event_target.on(event_name, callback , target,once);
+    }
+
+    /**
+     * 注册事件目标的特定事件类型回调，回调会在第一时间被触发后删除自身。
+     * @param event_name 事件名
+     * @param callback 回调函数
+     * @param target 目标对象
+     */
+    once(event_name: string, callback: (...args: any[]) => void, target?) {
+        this._event_target.once(event_name, callback, target);
+    }
+
+    /**
+     * 注册同步事件目标的特定事件类型回调。这种类型的事件应该被 `emit_async` 触发。支持await等待。
+     * @param event_name 事件名
+     * @param callback 回调函数
+     */
+    on_async(event_name: string, callback: (...args: any[]) => void) {
+        if (!this._async_delegates.has(event_name)) {
+            this._async_delegates.set(event_name, new AsyncDelegate());
+        }
+        this._async_delegates.get(event_name)?.add(callback);
+    }
+
+    /**
+     * 派发一个指定事件，并传递需要的参数
+     * @param event_name 事件名
+     * @param args 事件参数
+     */
+    emit(event_name: string, ...args) {
+        this._event_target.emit(event_name, ...args);
+    }
+
+
+    /**
+     * 派发一个指定事件，并传递需要的参数，支持await等待。
+     * @param event_name 事件名
+     * @param args 事件参数
+     */
+    async emit_async(event_name: string, ...args) {
+        await this._async_delegates.get(event_name)?.dispatch(...args);
+    }
+
+    /**
+     * 删除之前用同类型，回调，目标或 useCapture 注册的事件监听器，如果只传递 type，将会删除 type 类型的所有事件监听器。
+     * @param event_name 事件名
+     * @param callback 回调函数
+     * @param target 目标对象
+     */
+    off(event_name: string, callback = null, target = null) {
+        if (callback) {
+            this._event_target.off(event_name, callback, target);
+        } else {
+            this._event_target.removeAll(event_name);
+        }
+    }
+
+    /**
+     * 在当前 target 上删除指定目标（target 参数）注册的所有事件监听器。
+     * 这个函数无法删除当前 target 的所有事件监听器，也无法删除 target 参数所注册的所有事件监听器。
+     * 这个函数只能删除 target 参数在当前 target 上注册的所有事件监听器。
+     * @param target 目标对象
+     */
+    target_off(target) {
+        this._event_target.targetOff(target);
+    }
+
+    /**
+     * @zh 移除在特定事件类型中注册的所有回调或在某个目标中注册的所有回调。
+     * @param type_or_target 事件类型或目标对象
+     */
+    remove_all(type_or_target: string | EventTarget) {
+        this._event_target.removeAll(type_or_target);
+    }
+
+}
+
+//#endregion
+
+//#region 对象池
+
+class NodePoolMore extends NodePool {
+
+    static scheduler = null;
+    full_size = 0;
+    prefab = null;
+    progress = -1;
+    supplement = false;
+    expand = false;
+
+    /**
+     * @param _prefab 预制体
+     * @param prog 进度
+     * @param _full 最大数量
+     * @param _expand 是否自动扩展
+     * @param auto 是否自动实例化
+     * @param pool_handler 事件组件
+     */
+    constructor(_prefab, prog, _full, _expand = true, auto = false, pool_handler = null) {
+        super(pool_handler);
+        if (!NodePoolMore.scheduler) {
+            let node = new Node();
+            node.name = `NodePoolMoreScheduler`;
+            director.addPersistRootNode(node);
+            NodePoolMore.scheduler = node.addComponent(Component);
+        }
+        this.progress = prog;
+        this.full_size = _full;
+        this.expand = _expand;
+        if (_prefab instanceof Prefab) {
+            this.prefab = _prefab;
+            if (auto) {
+                generator(this.get_item_generator(0, this.full_size, this.prefab, this), 8, NodePoolMore.scheduler);
+            }
+        } else {
+            this.load_prefab(_prefab, auto);
+        }
+    }
+
+    /**
+     * 绑定对象池事件组件
+     * @param pool_handler 事件组件
+     */
+    set_handler(pool_handler) {
+        this.poolHandlerComp = pool_handler;
+    }
+
+    /**
+     * 加载预制体
+     * @param path 预制体路径
+     * @param auto 是否自动实例化
+     */
+    async load_prefab(path: string, auto = false) {
+        let _prefab = await load_resources(path);
+        this.prefab = _prefab;
+        if (auto) {
+            generator(this.get_item_generator(0, this.full_size, this.prefab, this), 8, NodePoolMore.scheduler);
+        }
+    }
+
+    async instantiate_pool() {
+        await generator(this.get_item_generator(0, this.full_size, this.prefab, this), 8, NodePoolMore.scheduler);
+    }
+
+    get(...args) {
+        let item = super.get(args);
+        if (this.size() < this.full_size * this.progress && !this.supplement) {
+            //补充
+            this.supplement_example();
+        }
+        if (!item) {
+            item = instantiate(this.prefab);
+        }
+        item.active = true;
+        return item;
+    }
+
+    async supplement_example() {
+        this.supplement = true;
+        if (this.expand) {
+            this.full_size *= 2;
+            console.log(`will expand : ${this.full_size},prefab : ${this.prefab.name}`);
+        }
+        console.log(`will supplement example : ${this.full_size - this.size()},prefab : ${this.prefab.name}`);
+        await generator(this.get_item_generator(0, this.full_size - this.size(), this.prefab, this), 8, NodePoolMore.scheduler);
+        this.supplement = false;
+    }
+
+    *get_item_generator(start, length, prefab, pool) {
+        for (var i = start; i < length; i++) {
+            yield this.create_item(prefab, pool);
+        }
+    }
+
+    create_item(prefab, pool) {
+        var item = instantiate(prefab);
+        pool.put(item);
+    }
+
+}
+
+export class PoolManager {
+
+    pools = {};
+
+    async init_pool(config) {
+        let start_time_gen = game.totalTime;
+        for (let i = 0; i < config.pool.length; ++i) {
+            if (config.pool[i].auto_example) {
+                this.free_pool(config.pool[i]);
+            } else {
+                await this.load_pool(config.pool[i]);
+            }
+        }
+        console.log(`prefab and nodepool complete ,start time : ${start_time_gen} ,time consuming ${game.totalTime - start_time_gen} ms`);
+    }
+
+    async free_pool(config) {
+        console.log(`free load pool ${config.name},count : ${config.count}`);
+        let prefab = await load_resources(config.path);
+        this.pools[config.name] = this.load_prefab_and_instantiate_pool(config, prefab);
+    }
+
+    async load_pool(config) {
+        console.log(`async load pool ${config.name},count : ${config.count}`);
+        let prefab = await load_resources(config.path);
+        this.pools[config.name] = this.load_prefab_and_instantiate_pool(config, prefab);
+        await this.pools[config.name].instantiate_pool();
+    }
+
+    load_prefab_and_instantiate_pool(config, prefab) {
+        return new NodePoolMore(prefab, config.auto_supplement, config.count, config.auto_expansion, config.auto_example, config.handler);
+    }
+
+    /**从对象池获取实例 */
+    get_item_from_pool(pool) {
+        let item = this.pools[pool].get();
+        return item;
+    }
+
+    /**将实例放回对象池 */
+    destroy_item(item, pool) {
+        this.pools[pool].put(item);
+    }
+
+}
+
+//#endregion
+
+//#region 防怠机
+export class PlacingSlack {
+    static thread = -1;
+    static start_time = 0;
+    static remaining_time = 0;
+    static callback = null;
+
+    static enabled(time, callback) {
+        PlacingSlack.start_time = game.totalTime;
+        PlacingSlack.callback = callback;
+        PlacingSlack.thread = setTimeout(() => {
+            PlacingSlack.callback?.();
+        }, time);
+    }
+
+    static cancel() {
+        if (PlacingSlack.thread == -1) {
+            return;
+        }
+        clearTimeout(PlacingSlack.thread);
+        PlacingSlack.thread = -1;
+    }
+
+    static pause() {
+        if (PlacingSlack.thread == -1) {
+            return;
+        }
+        clearTimeout(PlacingSlack.thread);
+        PlacingSlack.thread = -1;
+        PlacingSlack.remaining_time = game.totalTime - PlacingSlack.start_time;
+    }
+
+    static resume() {
+        if (PlacingSlack.remaining_time == -1) {
+            return;
+        }
+        PlacingSlack.thread = setTimeout(() => {
+            PlacingSlack.remaining_time = -1;
+            PlacingSlack.callback?.();
+        }, PlacingSlack.remaining_time);
+    }
+}
+//#endregion
+
+//#region 定时器
+class NewPromise {
+
+    _time = 0;
+    _handler = null;
+    _paused = false;
+    _remaining_time = 0;
+    _start_time = 0;
+    _resume = [];
+    _resolve = null;
+    _reject = null;
+    _promise = null;
+    _timeout_Id = null;
+    _check_time = 100;
+
+    /**
+     * 构造函数
+     * @param time 倒计时时间,单位毫秒
+     * @param check_time 检查时间间隔,单位毫秒
+     */
+    constructor(time, check_time) {
+        this._time = time;
+        let node = new Node();
+        this._handler = node.addComponent(Component);
+        this._handler.name = 'TimerHandler';
+        this._check_time = check_time;
+        this._paused = false;
+        this._remaining_time = time;
+        this._start_time = 0;
+        this._resume = [];
+        this._promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this._setup_timer();
+    }
+
+    _setup_timer() {
+        this._start_time = Date.now();
+        this._remaining_time = this._time;
+        this._start_countdown();
+    }
+
+    async _start_countdown() {
+        while (this._remaining_time > 0) {
+            await this._check();
+            if (this._remaining_time <= 0) break;
+            const wait_time = Math.min(this._remaining_time, this._check_time);
+            await this._delay(wait_time);
+            if (!this._paused) {
+                this._remaining_time -= wait_time;
+            }
+        }
+        if (this._remaining_time <= 0 && !this._paused) {
+            this._complete_timer();
+        }
+    }
+
+    _delay(ms) {
+        return new Promise(resolve => {
+            this._timeout_Id = setTimeout(() => {
+                this._timeout_Id = null;
+                resolve('');
+            }, ms);
+        });
+    }
+
+    async _check() {
+        if (this._paused) {
+            await new Promise(resolve => {
+                this._resume.push(resolve);
+            });
+        }
+    }
+
+    _complete_timer() {
+        this._handler.name == 'TimerHandler' && this._handler.node.destroy();
+        if (this._timeout_Id) {
+            clearTimeout(this._timeout_Id);
+            this._timeout_Id = null;
+        }
+        this._resolve("complete");
+    }
+
+    /**
+     * 取消倒计时,预览环境中会出现ErrorAlert,无需关注构建后会自动屏蔽
+     */
+    cancel() {
+        if (this._timeout_Id) {
+            clearTimeout(this._timeout_Id);
+            this._timeout_Id = null;
+        }
+        this._handler.name == 'TimerHandler' && this._handler.node.destroy();
+        this._reject("cancel");
+    }
+
+    /**
+     * 暂停
+     */
+    pause() {
+        if (this._paused) return;
+        this._paused = true;
+        if (this._timeout_Id) {
+            clearTimeout(this._timeout_Id);
+            this._timeout_Id = null;
+        }
+        if (!this._paused) {
+            const elapsed = Date.now() - this._start_time;
+            this._remaining_time = Math.max(0, this._time - elapsed);
+        }
+    }
+
+    /**
+     * 恢复
+     */
+    resume() {
+        if (!this._paused) return;
+        this._paused = false;
+        this._start_time = Date.now();
+        this._resume.forEach(callback => callback());
+        this._resume = [];
+        this._start_countdown();
+    }
+
+    /**
+     * 获取当前倒计时时间
+     * @returns 倒计时时间,单位毫秒
+     */
+    get_remaining_time() {
+        if (this._paused) {
+            return this._remaining_time;
+        } else {
+            const elapsed = Date.now() - this._start_time;
+            return Math.max(0, this._time - elapsed);
+        }
+    }
+
+    /**
+     * 获取原始倒计时
+     * @returns 
+     */
+    get_promise() {
+        return this._promise;
+    }
+
+    then(fulfilled, rejected) {
+        return this._promise.then(fulfilled, rejected);
+    }
+
+    catch(rejected) {
+        return this._promise.catch(rejected);
+    }
+}
+
+/**
+ * 
+ * @param {*} time 倒计时时间
+ * @param {*} check_time 检查时间间隔
+ * @returns {Promise<any> & {pause: () => void;resume: () => void;cancel: () => void;get_remaining_time: () => number;}}
+ */
+export function timer(time, check_time = 16) {
+    const pausableTimer = new NewPromise(time, check_time);
+    const timer_promise = pausableTimer.get_promise();
+    timer_promise.pause = () => pausableTimer.pause();
+    timer_promise.resume = () => pausableTimer.resume();
+    timer_promise.cancel = () => pausableTimer.cancel();
+    timer_promise.get_remaining_time = () => pausableTimer.get_remaining_time();
+    return timer_promise;
+}
+//#endregion
+
+//#region 生成器
+/**
+ * 生成器函数，用于按指定时间间隔执行迭代操作
+ * @param generator 生成器函数
+ * @param duration 每个迭代的时间间隔
+ * @param scheduler 调度器组件
+ * @param callback 完成回调
+ * @returns Promise<string>
+ */
+export function generator(generator:Generator, duration:number, scheduler = null, callback = null) {
+    let component;
+    if (scheduler) {
+        component = scheduler;
+    } else {
+        let node = new Node();
+        node.setParent(director.getScene());
+        component = node.addComponent(Component);
+    }
+    return new Promise((resolve, reject) => {
+        var gen = generator;
+        var execute = () => {
+            var startTime = new Date().getTime();
+            for (var iter = gen.next(); ; iter = gen.next()) {
+                if (iter == null || iter.done) {
+                    /**分帧完成 */
+                    if (!scheduler) {
+                        component.node.destroy();
+                    }
+                    callback && callback();
+                    resolve("");
+                    return;
+                }
+                if (new Date().getTime() - startTime > duration) {
+                    component.scheduleOnce(() => {
+                        execute();
+                    });
+                    return;
+                }
+            }
+        };
+        // 运行执行函数
+        execute();
+    });
+}
+//#endregion
+
+//#region 命令  
+/**
+ * 命令函数，用于按指定时间间隔检查条件并执行处理函数
+ * @param check_func 检查函数
+ * @param handler 处理函数
+ * @param interval 检查间隔
+ * @param max_wait 最大等待时间
+ * @returns Promise<string>
+ */
+export function command(check_func:Function, handler:Component, interval = 16.6, max_wait = 100000) {
+    return new Promise((resolve, reject) => {
+        let wait_time = 0;
+        try {
+            handler.cancel_thred = () => {
+                reject(`cancel`);
+                handler.cancel_thred = null;
+            };
+        } catch (error) {
+            console.log(error);
+        }
+        const interfal_thread = setInterval(() => {
+            wait_time += interval;
+            if (check_func()) {
+                clearInterval(interfal_thread);
+                resolve('');
+            }
+            if (wait_time >= max_wait) {
+                reject('Time Out');
+            }
+        }, interval);
+    })
+}
+//#endregion
+
+//#region 贝塞尔
+
+/**
+ * 击退效果
+ * @param target 目标节点
+ * @param direction 击退方向
+ * @param distance 击退距离
+ * @param height 击退高度
+ * @param speed 击退速度
+ * @param control_ratio 控制点比例
+ * @param peak_call 峰值回调
+ * @param complete_call 完成回调
+ */
+export function knock_back(target: Node, direction: Vec3, distance: number, height: number, speed: number, control_ratio: number, peak_call = null, complete_call = null) {
+    const normalizedDir = direction.clone().normalize();
+    const start_position = target.position.clone();
+    const complete_position = start_position.clone().add(normalizedDir.multiplyScalar(distance));
+    const control_point = start_position.clone().lerp(complete_position, control_ratio);
+    control_point.y += height;
+    const peak_time = get_peak_time(start_position, control_point, complete_position);
+    let peak_pass = false;
+    let last_position = start_position.clone();
+    tween(target)
+        .to(distance / speed, {}, {
+            onUpdate: (target, ratio) => {
+                const pos = bezier_on_update(start_position, control_point, complete_position, ratio);
+                target.position = pos;
+                if (!peak_pass && ratio >= peak_time) {
+                    peak_pass = true;
+                    peak_call?.();
+                }
+                last_position = pos;
+            }
+        })
+        .call(() => {
+            complete_call?.();
+        })
+        .start();
+}
+
+/**
+ * 获取贝塞尔曲线的峰值时间
+ * @param start_position 起点
+ * @param control_point 控制点
+ * @param complete_position 终点
+ * @returns 峰值时间
+ */
+export function get_peak_time(start_position: Vec3, control_point: Vec3, complete_position: Vec3) : number{
+    const denominator = start_position.y - 2 * control_point.y + complete_position.y;
+    if (Math.abs(denominator) < 0.0001) {
+        return 0.5;
+    }
+    const t = (start_position.y - control_point.y) / denominator;
+    return Math.min(Math.max(t, 0), 1);
+}
+
+/**
+ * 贝塞尔曲线路径计算
+ * @param c1 起点
+ * @param c2 控制点
+ * @param c3 终点
+ * @param t 时间参数，范围0-1
+ * @returns 贝塞尔曲线上的点
+ */
+export function bezier_on_update(c1: Vec3, c2: Vec3, c3: Vec3, t: number) : Vec3{
+    const t1 = 1 - t;
+    const tt = t * t;
+    let x = t1 * t1 * c1.x + 2 * t * t1 * c2.x + tt * c3.x;
+    let y = t1 * t1 * c1.y + 2 * t * t1 * c2.y + tt * c3.y;
+    let z = t1 * t1 * c1.z + 2 * t * t1 * c2.z + tt * c3.z;
+    return new Vec3(x, y, z);
+}
+
+//#endregion
+
+//#region 其他工具方法
+
+/**
+ * 角度转换为弧度
+ * @param angle 角度
+ * @returns 弧度
+ */
+export function angle_to_radians(angle) {
+    return angle * 180 / Math.PI;
+}
+
+/**
+ * 获取两个节点之间的角度
+ * PS 仅获取Y轴，建议用于人物转向
+ * @param center_item 中心节点
+ * @param target_item 目标节点
+ * @returns 欧拉角
+ */
+export function lookat(center_item: Node, target_item: Node) : Vec3{
+    let my_position = center_item.worldPosition.clone();
+    let look_position = target_item.worldPosition.clone();
+    const direction = new Vec3(
+        look_position.x - my_position.x,
+        0,
+        look_position.z - my_position.z
+    ).normalize();
+    const angleRad = Math.atan2(direction.x, direction.z);
+    const angleDeg = math.toDegree(angleRad);
+    return new Vec3(0, angleDeg, 0);
+}
+
+/**
+ * 判断字符串是否为空
+ * @param str 字符串
+ * @returns 是否为空
+ */
+export function is_null_string(str: string) : boolean{
+    return !str || str.length === 0 || str === 'null' || str === 'Null' || str === 'undefined' || str === 'Undefined' || str === undefined;
+}
+
+/**
+ * 加载资源
+ * @param path 资源路径
+ * @param bundle 资源包名
+ * @param callback 回调函数
+ * @returns 资源
+ */
+export function load_resources<T>(path: string, bundle: string = 'resources', callback: (asset: T) => void = null) : Promise<T>{
+    return new Promise((resolve, reject) => {
+        let loader = assetManager.getBundle(bundle);
+        if (loader) {
+            let assets = loader.get(path);
+            if (assets) {
+                callback && callback(assets as T);
+                resolve(assets as T);
+            } else {
+                loader.load(path, (error, asset) => {
+                    if (asset) {
+                        callback && callback(asset as T);
+                        resolve(asset as T);
+                    } else {
+                        reject(error);
+                    }
+                })
+            }
+        } else {
+            assetManager.loadBundle(bundle, (error, bundle_instance) => {
+                let assets = bundle_instance.get(path);
+                if (assets) {
+                    callback && callback(assets as T);
+                    resolve(assets as T);
+                } else {
+                    bundle_instance.load(path, (error, asset) => {
+                        if (asset) {
+                            callback && callback(asset as T);
+                            resolve(asset as T);
+                        } else {
+                            reject(error);
+                        }
+                    })
+                }
+            })
+        }
+    })
+}
+
+const UNITS: number[] = [1e18, 1e15, 1e12, 1e9, 1e6, 1e3];
+
+/**
+ * 格式化数字，将大数字转换为K、M、B、T等单位
+ * @param num 数字
+ * @returns 格式化后的字符串
+ */
+export function format(num: number) :string{
+    let str = '';
+    if (num >= UNITS[0]) {
+        str = (num / UNITS[0]).toFixed(1) + 'Z';
+    } else if (num >= UNITS[1]) {
+        str = (num / UNITS[1]).toFixed(1) + 'J';
+    } else if (num >= UNITS[2]) {
+        str = (num / UNITS[2]).toFixed(1) + 'T';
+    } else if (num >= UNITS[3]) {
+        str = (num / UNITS[3]).toFixed(1) + 'B';
+    } else if (num >= UNITS[4]) {
+        str = (num / UNITS[4]).toFixed(1) + 'M';
+    } else if (num >= UNITS[5]) {
+        str = (num / UNITS[5]).toFixed(1) + 'K';
+    } else {
+        str = `${num}`;
+    }
+    return str.replace(/\.0/g, '');
+}
+
+/**
+ * 获取两个节点之间在指定轴上的距离
+ * @param node1 节点1
+ * @param node2 节点2
+ * @param axis 轴向量
+ * @returns 距离
+ */
+export function get_axis_distance(node1: Node, node2: Node, axis: Vec3) :number{
+    const vec = new Vec3();
+    Vec3.subtract(vec, node2.worldPosition, node1.worldPosition);
+    const norm_axis = new Vec3(axis);
+    Vec3.normalize(norm_axis, norm_axis);
+    return Math.abs(Vec3.dot(vec, norm_axis));
+}
+
+/**
+ * 计算扩展位置(注意统一坐标系,建议使用WorldSpace)
+ * @param start_position 起点
+ * @param aim_position 目标点
+ * @param distance 延长距离（米）
+ * @returns 延长后的坐标
+ */
+export function calculate_extended_position(start_position: Vec3, aim_position: Vec3, distance: number) :Vec3{
+    const direction = Vec3.subtract(new Vec3(), aim_position, start_position);
+    Vec3.normalize(direction, direction);
+    const extended = Vec3.multiplyScalar(new Vec3(), direction, distance);
+    return Vec3.add(new Vec3(), aim_position, extended);
+}
+
+/**
+ * 在环上通过时钟模式生成指定数量坐标(如果密度较高,则会有重复或近似坐标)
+ * @param center 原点
+ * @param min 圆环内径,内外径任意顺序传入,但值不能相同
+ * @param max 圆环外径,内外径任意顺序传入,但值不能相同
+ * @param count 生成数量,生成数量不得小于1
+ * @param start 起始角度（时钟模式）如果不填入默认12点钟方向
+ * @param end 结束角度（时钟模式）如果不填入默认12点钟方向
+ * @param clockwise 是否顺时针方向
+ * @returns 生成的随机坐标组
+ */
+export function get_random_position_with_clock(center: Vec3, min: number, max: number, count = 1, start = 12, end = 12, clockwise = true) :Vec3[] | null{
+    if (count < 1) {
+        console.error(`生成数量不得小于1`)
+        return null;
+    }
+    if (min === max) {
+        console.error(`内外径不能相同`)
+        return null;
+    }
+    let real_min = Math.min(min, max);
+    let real_max = Math.max(min, max);
+    const clock_to_rad = (clock) => {
+        const normalized_clock = clock % 12
+        return -Math.PI / 2 + (normalized_clock * Math.PI / 6);
+    };
+    let start_angle = clock_to_rad(start);
+    let end_angle = clock_to_rad(end);
+    if (start % 12 === end % 12) {
+        end_angle = start_angle + Math.PI * 2;
+    } else {
+        if (clockwise) {
+            if (end_angle < start_angle) {
+                end_angle += Math.PI * 2;
+            }
+        } else {
+            if (end_angle > start_angle) {
+                end_angle -= Math.PI * 2;
+            }
+        }
+    }
+    let points = [];
+    for (let i = 0; i < count; ++i) {
+        points.push(get_random_position_in_ring(center, real_min, real_max, start_angle, end_angle));
+    }
+    return points;
+}
+
+/**
+ * 在环上生成随机坐标
+ * @param center 原点
+ * @param min 圆环内径,内外径任意顺序传入,但值不能相同
+ * @param max 圆环外径,内外径任意顺序传入,但值不能相同
+ * @param start 起始角度（时钟模式）如果不填入默认0点钟方向
+ * @param end 结束角度（时钟模式）如果不填入默认0点钟方向
+ * @returns 生成的随机坐标
+ */
+export function get_random_position_in_ring(center: Vec3, min: number, max: number, start = 0, end = Math.PI * 2) :Vec3{
+    const random_angle = Math.random() * (end - start) + start;
+    const random_radius = Math.random() * (max - min) + min;
+    const x = center.x + Math.cos(random_angle) * random_radius;
+    const z = center.z + Math.sin(random_angle) * random_radius;
+    const y = center.y;
+    return new Vec3(x, y, z);
+}
+
+/**
+ * 查找子节点
+ * @param parent 父节点
+ * @param name 子节点名称
+ * @param component 组件类型,寻找到组件,会返回组件实例,否则为null
+ * @returns 子节点或组件实例
+ */
+export function find(parent: Node, name: string, component?: typeof Component) :Node | Component | null{
+    for (let child of parent.children) {
+        if (child.name === name) {
+            return component ? child.getComponent(component) ? child.getComponent(component) : null : child;
+        }
+        const result = find(child, name, component);
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+}
+
+/**
+ * 从字符串创建颜色, 支持 "#RRGGBB" 和 "#RRGGBBAA" 格式
+ * @param value 颜色字符串，格式为 "#RRGGBB" 或 "#RRGGBBAA"
+ * @returns 颜色实例
+ */
+export function color_from_string(value: string) :Color{
+    if (value == null || value.length < 7) {
+        return null;
+    }
+    let color = value.toLowerCase();
+    if (color.charAt(0) != "#") {
+        return;
+    }
+    color = color.slice(1);
+    let r = parseInt(color[0] + color[1], 16);
+    let g = parseInt(color[2] + color[3], 16);
+    let b = parseInt(color[4] + color[5], 16);
+    let a = color.length > 7 ? parseInt(color[6] + color[7], 16) : 255;
+    return new Color(r, g, b, a);
+}
+
+/**
+ * 插值旋转四元数
+ * @param now_rotation 当前旋转四元数
+ * @param target_rotation 目标旋转四元数
+ * @returns 插值后的旋转四元数
+ */
+export function lerp_rotate(now_rotation: Quat, target_rotation: Quat) :Quat{
+    const temp_quat = new Quat();
+    const result = new Quat();
+    const dot = Quat.dot(now_rotation, target_rotation);
+    if (dot < 0) {
+        Quat.multiplyScalar(temp_quat, target_rotation, -1);
+        Quat.slerp(result, now_rotation, temp_quat, 1 / 10);
+    } else {
+        Quat.slerp(result, now_rotation, target_rotation, 1 / 10);
+    }
+    return result;
+}
+
+/**
+ * 插值旋转向量
+ * @param now_rotation 当前旋转向量
+ * @param target_rotation 目标旋转向量
+ * @param speed 插值速度
+ * @param delta_time 时间间隔
+ * @returns 插值后的旋转向量
+ */
+export function lerp_rotate_by_speed(now_rotation: Vec3, target_rotation: Vec3, speed: number, delta_time: number) :Vec3{
+    now_rotation.y = (now_rotation.y + 360) % 360;
+    let left_turn = (target_rotation.y - now_rotation.y + 360) % 360;
+    let right_turn = (now_rotation.y - target_rotation.y + 360) % 360;
+    let euler = new Vec3();
+    if (left_turn > right_turn) {
+        euler = new Vec3(now_rotation.x, now_rotation.y - speed * delta_time, now_rotation.z);
+        if (euler.y < target_rotation.y) {
+            euler.y = target_rotation.y;
+        }
+        return euler;
+    } else {
+        euler = new Vec3(now_rotation.x, now_rotation.y + speed * delta_time, now_rotation.z);
+        if (euler.y > target_rotation.y) {
+            euler.y = target_rotation.y;
+        }
+        return euler;
+    }
+}
+
+/**
+ * 插值移动向量
+ * @param start 起点
+ * @param now 当前位置
+ * @param target 目标位置
+ * @param speed 插值速度
+ * @param delta_time 时间间隔
+ * @returns 插值后的位置和移动距离
+ */
+export function lerp_move_by_speed(start: Vec3 | Node, now: Vec3 | Node, target: Vec3 | Node, speed: number, delta_time: number) :{position: Vec3, step: number} {
+    let new_position = new Vec3(), start_position = start instanceof Vec3 ? start : start.worldPosition.clone(), now_position = now instanceof Vec3 ? now : now.worldPosition.clone(), target_position = target instanceof Vec3 ? target : target.worldPosition.clone();
+    let t = 0;
+    const current_distance = Vec3.distance(now_position, start_position);
+    const total_distance = Vec3.distance(start_position, target_position);
+    t = (current_distance + speed * delta_time) / total_distance;
+    Vec3.lerp(new_position, start_position, target_position, Math.min(t, 1));
+    return { position: new_position, step: t };
+}
+
+/**
+ * 按方向和速度移动节点
+ * @param target 目标节点
+ * @param direction 移动方向
+ * @param speed 移动速度
+ * @param delta_time 时间间隔
+ * @param space 空间参考，默认世界空间
+ */
+export function move_by_direction(target: Node, direction: Vec3, speed: number, delta_time: number, space: NodeSpace = NodeSpace.WORLD) {
+    const move_delta = new Vec3();
+    Vec3.multiplyScalar(move_delta, direction, speed * delta_time);
+    target.translate(move_delta, space);
+}
+
+/**
+ * 按方向和距离移动节点
+ * @param start_position 起点位置
+ * @param target 目标节点
+ * @param direction 移动方向
+ * @param distance 移动距离
+ */
+export function move_with_direction_and_distance(start_position: Vec3, target: Node, direction: Vec3, distance: number) {
+    let move_delta = new Vec3();
+    Vec3.scaleAndAdd(move_delta, start_position, direction, distance);
+    target.setWorldPosition(move_delta);
+}
+
+/**
+ * 按前方向移动节点
+ * @param target 目标节点
+ * @param speed 移动速度
+ * @param delta_time 时间间隔
+ */
+export function move_forward(target: Node, speed: number, delta_time: number) {
+    let forward = target.forward;
+    forward.z *= -1;
+    forward.x *= -1;
+    let director = forward.multiplyScalar(speed * delta_time);
+    const newPos = target.worldPosition.clone().add(director);
+    target.setWorldPosition(newPos);
+}
+
+
+/**
+ * 获取两个节点或向量之间的方向向量
+ * @param start 起点节点或向量
+ * @param end 终点节点或向量
+ * @returns 方向向量
+ */
+export function get_direction(start: Node | Vec3 | Component, end: Node | Vec3 | Component) :Vec3{
+    let start_position = start instanceof Node ? start.getWorldPosition().clone() : start instanceof Component ? start.node.getWorldPosition().clone() : start.clone();
+    let end_position = end instanceof Node ? end.getWorldPosition().clone() : end instanceof Component ? end.node.getWorldPosition().clone() : end.clone();
+    return end_position.subtract(start_position).normalize();
+}
+
+
+
+/**
+ * 果冻效果
+ * @param node 动效节点
+ * @param ratio 缩放比例
+ * @param callback 动效完成回调
+ */
+export function jelly_effect(node: Node, ratio: number, callback?:Function) {
+    node.setScale(Vec3.ZERO);
+    tween(node)
+        .to(.05, { scale: new Vec3(1.2 * ratio, 0.8 * ratio, 1.2 * ratio) })
+        .to(.1, { scale: new Vec3(0.8 * ratio, 1.1 * ratio, 0.8 * ratio) })
+        .to(.05, { scale: new Vec3(1.1 * ratio, 0.9 * ratio, 1.1 * ratio) })
+        .to(.04, { scale: new Vec3(.85 * ratio, 1.1 * ratio, .85 * ratio) })
+        .to(.04, { scale: new Vec3(1 * ratio, 1 * ratio, 1 * ratio) })
+        .call(() => {
+            callback?.();
+        })
+        .start();
+}
+
+/**
+ * 呼吸效果
+ * @param node 节点
+ * @param delay 呼吸间隔
+ */
+export function breath_effect(node: Node, delay:number = 0.5) {
+    let opacity = node.getComponent(UIOpacity);
+    opacity.opacity = 0;
+    node.active = true;
+    tween(opacity)
+        .repeatForever(
+            tween(opacity)
+                .to(0.8, { opacity: 255 }, { easing: 'quadInOut' })
+                .to(0.8, { opacity: 0 }, { easing: 'quadInOut' })
+                .delay(delay)
+        )
+        .start();
+}
+
+/**
+ *  脉冲效果
+ * @param node 节点
+ */
+export function pulsation_effect(node: Node) {
+    tween(node)
+        .repeatForever(
+            tween(node)
+                .by(0.25, { scale: new Vec3(0.05, 0.05, 0) }, { easing: 'sineOut' })
+                .by(0.25, { scale: new Vec3(-0.05, -0.05, 0) }, { easing: 'sineOut' })
+                .by(0.35, { scale: new Vec3(0.14, 0.14, 0) }, { easing: 'sineOut' })
+                .by(0.35, { scale: new Vec3(-0.14, -0.14, 0) }, { easing: 'sineIn' })
+                .delay(1)
+        )
+        .start();
+}
+
+/**
+ * 放大后缩小
+ * @param node 动效节点
+ * @param amplitude 缩放幅度
+ */
+export function scale_b_s(node: Node, amplitude: number) {
+    tween(node)
+        .by(0.25, { scale: new Vec3(amplitude, amplitude, 0) }, { easing: 'quadOut' })
+        .by(0.25, { scale: new Vec3(-amplitude, -amplitude, 0) }, { easing: 'quadOut' })
+        .start()
+}
+
+/**
+ * 缩放效果，从小到大
+ * @param node 节点
+ * @param amplitude 振幅
+ */
+export function scale_s_b(node: Node, amplitude: number) {
+    tween(node)
+        .by(0.25, { scale: new Vec3(-amplitude, -amplitude, 0) }, { easing: 'quadOut' })
+        .by(0.25, { scale: new Vec3(amplitude, amplitude, 0) }, { easing: 'quadOut' })
+        .start()
+}
+
+/**
+ * 延迟调用
+ * @param node 节点
+ * @param delay 延迟时间
+ * @param callback 回调函数
+ */
+export function delay_call(node:Node, delay:number, callback?:Function) {
+    tween(node)
+        .delay(delay)
+        .call(() => { callback?.(); })
+        .start();
+}
+//#endregion
+
+
+
+export let MessageSystem = new EventSystem();
+
+export let pool: PoolManager = new PoolManager();