@esengine/ecs-framework 2.1.4 → 2.1.6

package/bin/Utils/Pool.d.ts

@@ -1,239 +0,0 @@
-/**
- * 可池化对象接口
- */
-export interface IPoolable {
-    /**
-     * 重置对象状态，准备重用
-     */
-    reset(): void;
-}
-/**
- * 对象池统计信息
- */
-export interface PoolStats {
-    /** 池中对象数量 */
-    size: number;
-    /** 池的最大大小 */
-    maxSize: number;
-    /** 总共创建的对象数量 */
-    totalCreated: number;
-    /** 总共获取的次数 */
-    totalObtained: number;
-    /** 总共释放的次数 */
-    totalReleased: number;
-    /** 命中率（从池中获取的比例） */
-    hitRate: number;
-    /** 内存使用估算（字节） */
-    estimatedMemoryUsage: number;
-}
-/**
- * 高性能通用对象池
- * 支持任意类型的对象池化，包含详细的统计信息
- */
-export declare class Pool<T extends IPoolable> {
-    private static _pools;
-    private _objects;
-    private _createFn;
-    private _maxSize;
-    private _stats;
-    private _objectSize;
-    /**
-     * 构造函数
-     * @param createFn 创建对象的函数
-     * @param maxSize 池的最大大小，默认100
-     * @param estimatedObjectSize 估算的单个对象大小（字节），默认1024
-     */
-    constructor(createFn: () => T, maxSize?: number, estimatedObjectSize?: number);
-    /**
-     * 获取指定类型的对象池
-     * @param type 对象类型
-     * @param maxSize 池的最大大小
-     * @param estimatedObjectSize 估算的单个对象大小
-     * @returns 对象池实例
-     */
-    static getPool<T extends IPoolable>(type: new (...args: any[]) => T, maxSize?: number, estimatedObjectSize?: number): Pool<T>;
-    /**
-     * 从池中获取对象
-     * @returns 对象实例
-     */
-    obtain(): T;
-    /**
-     * 将对象归还到池中
-     * @param obj 要归还的对象
-     */
-    free(obj: T): void;
-    /**
-     * 预热池，创建指定数量的对象
-     * @param count 要创建的对象数量
-     */
-    warmUp(count: number): void;
-    /**
-     * 清空池
-     */
-    clear(): void;
-    /**
-     * 获取池中对象数量
-     */
-    get size(): number;
-    /**
-     * 获取池的最大大小
-     */
-    get maxSize(): number;
-    /**
-     * 设置池的最大大小
-     */
-    set maxSize(value: number);
-    /**
-     * 获取池的统计信息
-     */
-    getStats(): PoolStats;
-    /**
-     * 重置统计信息
-     */
-    resetStats(): void;
-    /**
-     * 更新命中率
-     */
-    private _updateHitRate;
-    /**
-     * 更新内存使用估算
-     */
-    private _updateMemoryUsage;
-    /**
-     * 静态方法：从指定类型的池中获取对象
-     * @param type 对象类型
-     * @returns 对象实例
-     */
-    static obtain<T extends IPoolable>(type: new (...args: any[]) => T): T;
-    /**
-     * 静态方法：将对象归还到对应类型的池中
-     * @param type 对象类型
-     * @param obj 要归还的对象
-     */
-    static free<T extends IPoolable>(type: new (...args: any[]) => T, obj: T): void;
-    /**
-     * 静态方法：预热指定类型的池
-     * @param type 对象类型
-     * @param count 要创建的对象数量
-     */
-    static warmUp<T extends IPoolable>(type: new (...args: any[]) => T, count: number): void;
-    /**
-     * 静态方法：清空指定类型的池
-     * @param type 对象类型
-     */
-    static clearPool<T extends IPoolable>(type: new (...args: any[]) => T): void;
-    /**
-     * 静态方法：清空所有池
-     */
-    static clearAllPools(): void;
-    /**
-     * 静态方法：获取池的统计信息
-     * @returns 池的统计信息
-     */
-    static getStats(): {
-        [typeName: string]: PoolStats;
-    };
-    /**
-     * 静态方法：获取所有池的总内存使用量
-     * @returns 总内存使用量（字节）
-     */
-    static getTotalMemoryUsage(): number;
-    /**
-     * 静态方法：获取性能报告
-     * @returns 格式化的性能报告
-     */
-    static getPerformanceReport(): string;
-}
-/**
- * 分层对象池
- * 使用多个不同大小的池来优化内存使用
- */
-export declare class TieredObjectPool<T extends IPoolable> {
-    private pools;
-    private createFn;
-    private resetFn;
-    private tierSizes;
-    private totalObtained;
-    private totalReleased;
-    /**
-     * 构造函数
-     * @param createFn 创建对象的函数
-     * @param resetFn 重置对象的函数
-     * @param tierSizes 各层级的大小，默认[10, 50, 200]
-     * @param estimatedObjectSize 估算的单个对象大小
-     */
-    constructor(createFn: () => T, resetFn: (obj: T) => void, tierSizes?: number[], estimatedObjectSize?: number);
-    /**
-     * 获取对象
-     * @returns 对象实例
-     */
-    obtain(): T;
-    /**
-     * 释放对象
-     * @param obj 要释放的对象
-     */
-    release(obj: T): void;
-    /**
-     * 预热所有池
-     * @param totalCount 总预热数量
-     */
-    warmUp(totalCount: number): void;
-    /**
-     * 清空所有池
-     */
-    clear(): void;
-    /**
-     * 获取统计信息
-     */
-    getStats(): {
-        totalSize: number;
-        totalMaxSize: number;
-        totalMemoryUsage: number;
-        tierStats: PoolStats[];
-        hitRate: number;
-    };
-    /**
-     * 获取总创建数量
-     */
-    private getTotalCreated;
-}
-/**
- * 池管理器
- * 统一管理所有对象池
- */
-export declare class PoolManager {
-    private static instance;
-    private pools;
-    private autoCompactInterval;
-    private lastCompactTime;
-    static getInstance(): PoolManager;
-    /**
-     * 注册池
-     * @param name 池名称
-     * @param pool 池实例
-     */
-    registerPool<T extends IPoolable>(name: string, pool: Pool<T> | TieredObjectPool<T>): void;
-    /**
-     * 获取池
-     * @param name 池名称
-     * @returns 池实例
-     */
-    getPool<T extends IPoolable>(name: string): Pool<T> | TieredObjectPool<T> | null;
-    /**
-     * 更新池管理器（应在游戏循环中调用）
-     */
-    update(): void;
-    /**
-     * 压缩所有池（清理碎片）
-     */
-    compactAllPools(): void;
-    /**
-     * 获取所有池的统计信息
-     */
-    getAllStats(): Map<string, any>;
-    /**
-     * 生成性能报告
-     */
-    generateReport(): string;
-}
-//# sourceMappingURL=Pool.d.ts.map

package/bin/Utils/Pool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Pool.d.ts","sourceRoot":"","sources":["../../src/Utils/Pool.ts"],"names":[],"mappings":"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"}

package/bin/Utils/Pool.js

@@ -1,449 +0,0 @@
-/**
- * 高性能通用对象池
- * 支持任意类型的对象池化，包含详细的统计信息
- */
-export class Pool {
-    /**
-     * 构造函数
-     * @param createFn 创建对象的函数
-     * @param maxSize 池的最大大小，默认100
-     * @param estimatedObjectSize 估算的单个对象大小（字节），默认1024
-     */
-    constructor(createFn, maxSize = 100, estimatedObjectSize = 1024) {
-        this._objects = [];
-        this._createFn = createFn;
-        this._maxSize = maxSize;
-        this._objectSize = estimatedObjectSize;
-        this._stats = {
-            size: 0,
-            maxSize,
-            totalCreated: 0,
-            totalObtained: 0,
-            totalReleased: 0,
-            hitRate: 0,
-            estimatedMemoryUsage: 0
-        };
-    }
-    /**
-     * 获取指定类型的对象池
-     * @param type 对象类型
-     * @param maxSize 池的最大大小
-     * @param estimatedObjectSize 估算的单个对象大小
-     * @returns 对象池实例
-     */
-    static getPool(type, maxSize = 100, estimatedObjectSize = 1024) {
-        let pool = this._pools.get(type);
-        if (!pool) {
-            pool = new Pool(() => new type(), maxSize, estimatedObjectSize);
-            this._pools.set(type, pool);
-        }
-        return pool;
-    }
-    /**
-     * 从池中获取对象
-     * @returns 对象实例
-     */
-    obtain() {
-        this._stats.totalObtained++;
-        if (this._objects.length > 0) {
-            const obj = this._objects.pop();
-            this._stats.size--;
-            this._updateHitRate();
-            this._updateMemoryUsage();
-            return obj;
-        }
-        // 池中没有对象，创建新的
-        const obj = this._createFn();
-        this._stats.totalCreated++;
-        this._updateHitRate();
-        return obj;
-    }
-    /**
-     * 将对象归还到池中
-     * @param obj 要归还的对象
-     */
-    free(obj) {
-        if (this._objects.length < this._maxSize) {
-            obj.reset();
-            this._objects.push(obj);
-            this._stats.size++;
-            this._stats.totalReleased++;
-            this._updateMemoryUsage();
-        }
-        // 如果池已满，对象会被丢弃（由GC回收）
-    }
-    /**
-     * 预热池，创建指定数量的对象
-     * @param count 要创建的对象数量
-     */
-    warmUp(count) {
-        const targetSize = Math.min(count, this._maxSize);
-        while (this._objects.length < targetSize) {
-            const obj = this._createFn();
-            this._stats.totalCreated++;
-            this._objects.push(obj);
-            this._stats.size++;
-        }
-        this._updateMemoryUsage();
-    }
-    /**
-     * 清空池
-     */
-    clear() {
-        this._objects.length = 0;
-        this._stats.size = 0;
-        this._updateMemoryUsage();
-    }
-    /**
-     * 获取池中对象数量
-     */
-    get size() {
-        return this._objects.length;
-    }
-    /**
-     * 获取池的最大大小
-     */
-    get maxSize() {
-        return this._maxSize;
-    }
-    /**
-     * 设置池的最大大小
-     */
-    set maxSize(value) {
-        this._maxSize = value;
-        this._stats.maxSize = value;
-        // 如果当前池大小超过新的最大值，则移除多余的对象
-        while (this._objects.length > this._maxSize) {
-            this._objects.pop();
-            this._stats.size--;
-        }
-        this._updateMemoryUsage();
-    }
-    /**
-     * 获取池的统计信息
-     */
-    getStats() {
-        return { ...this._stats };
-    }
-    /**
-     * 重置统计信息
-     */
-    resetStats() {
-        this._stats.totalCreated = 0;
-        this._stats.totalObtained = 0;
-        this._stats.totalReleased = 0;
-        this._stats.hitRate = 0;
-    }
-    /**
-     * 更新命中率
-     */
-    _updateHitRate() {
-        if (this._stats.totalObtained > 0) {
-            const hits = this._stats.totalObtained - this._stats.totalCreated;
-            this._stats.hitRate = hits / this._stats.totalObtained;
-        }
-    }
-    /**
-     * 更新内存使用估算
-     */
-    _updateMemoryUsage() {
-        this._stats.estimatedMemoryUsage = this._stats.size * this._objectSize;
-    }
-    /**
-     * 静态方法：从指定类型的池中获取对象
-     * @param type 对象类型
-     * @returns 对象实例
-     */
-    static obtain(type) {
-        return this.getPool(type).obtain();
-    }
-    /**
-     * 静态方法：将对象归还到对应类型的池中
-     * @param type 对象类型
-     * @param obj 要归还的对象
-     */
-    static free(type, obj) {
-        this.getPool(type).free(obj);
-    }
-    /**
-     * 静态方法：预热指定类型的池
-     * @param type 对象类型
-     * @param count 要创建的对象数量
-     */
-    static warmUp(type, count) {
-        this.getPool(type).warmUp(count);
-    }
-    /**
-     * 静态方法：清空指定类型的池
-     * @param type 对象类型
-     */
-    static clearPool(type) {
-        const pool = this._pools.get(type);
-        if (pool) {
-            pool.clear();
-        }
-    }
-    /**
-     * 静态方法：清空所有池
-     */
-    static clearAllPools() {
-        for (const pool of this._pools.values()) {
-            pool.clear();
-        }
-        this._pools.clear();
-    }
-    /**
-     * 静态方法：获取池的统计信息
-     * @returns 池的统计信息
-     */
-    static getStats() {
-        const stats = {};
-        for (const [type, pool] of this._pools.entries()) {
-            const typeName = type.name || 'Unknown';
-            stats[typeName] = pool.getStats();
-        }
-        return stats;
-    }
-    /**
-     * 静态方法：获取所有池的总内存使用量
-     * @returns 总内存使用量（字节）
-     */
-    static getTotalMemoryUsage() {
-        let total = 0;
-        for (const pool of this._pools.values()) {
-            total += pool.getStats().estimatedMemoryUsage;
-        }
-        return total;
-    }
-    /**
-     * 静态方法：获取性能报告
-     * @returns 格式化的性能报告
-     */
-    static getPerformanceReport() {
-        const stats = this.getStats();
-        const lines = [];
-        lines.push('=== Object Pool Performance Report ===');
-        lines.push(`Total Memory Usage: ${(this.getTotalMemoryUsage() / 1024 / 1024).toFixed(2)} MB`);
-        lines.push('');
-        for (const [typeName, stat] of Object.entries(stats)) {
-            lines.push(`${typeName}:`);
-            lines.push(`  Size: ${stat.size}/${stat.maxSize}`);
-            lines.push(`  Hit Rate: ${(stat.hitRate * 100).toFixed(1)}%`);
-            lines.push(`  Total Created: ${stat.totalCreated}`);
-            lines.push(`  Total Obtained: ${stat.totalObtained}`);
-            lines.push(`  Memory: ${(stat.estimatedMemoryUsage / 1024).toFixed(1)} KB`);
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-}
-Pool._pools = new Map();
-/**
- * 分层对象池
- * 使用多个不同大小的池来优化内存使用
- */
-export class TieredObjectPool {
-    /**
-     * 构造函数
-     * @param createFn 创建对象的函数
-     * @param resetFn 重置对象的函数
-     * @param tierSizes 各层级的大小，默认[10, 50, 200]
-     * @param estimatedObjectSize 估算的单个对象大小
-     */
-    constructor(createFn, resetFn, tierSizes = [10, 50, 200], estimatedObjectSize = 1024) {
-        this.pools = [];
-        this.totalObtained = 0;
-        this.totalReleased = 0;
-        this.createFn = createFn;
-        this.resetFn = resetFn;
-        this.tierSizes = tierSizes;
-        // 初始化不同层级的池
-        for (const size of tierSizes) {
-            this.pools.push(new Pool(createFn, size, estimatedObjectSize));
-        }
-    }
-    /**
-     * 获取对象
-     * @returns 对象实例
-     */
-    obtain() {
-        this.totalObtained++;
-        // 从最小的池开始尝试获取
-        for (const pool of this.pools) {
-            if (pool.size > 0) {
-                return pool.obtain();
-            }
-        }
-        // 所有池都空了，创建新对象
-        return this.createFn();
-    }
-    /**
-     * 释放对象
-     * @param obj 要释放的对象
-     */
-    release(obj) {
-        this.totalReleased++;
-        this.resetFn(obj);
-        // 放入第一个有空间的池
-        for (const pool of this.pools) {
-            if (pool.size < pool.maxSize) {
-                pool.free(obj);
-                return;
-            }
-        }
-        // 所有池都满了，直接丢弃
-    }
-    /**
-     * 预热所有池
-     * @param totalCount 总预热数量
-     */
-    warmUp(totalCount) {
-        let remaining = totalCount;
-        for (const pool of this.pools) {
-            const warmUpCount = Math.min(remaining, pool.maxSize);
-            pool.warmUp(warmUpCount);
-            remaining -= warmUpCount;
-            if (remaining <= 0)
-                break;
-        }
-    }
-    /**
-     * 清空所有池
-     */
-    clear() {
-        for (const pool of this.pools) {
-            pool.clear();
-        }
-    }
-    /**
-     * 获取统计信息
-     */
-    getStats() {
-        let totalSize = 0;
-        let totalMaxSize = 0;
-        let totalMemoryUsage = 0;
-        const tierStats = [];
-        for (const pool of this.pools) {
-            const stats = pool.getStats();
-            tierStats.push(stats);
-            totalSize += stats.size;
-            totalMaxSize += stats.maxSize;
-            totalMemoryUsage += stats.estimatedMemoryUsage;
-        }
-        const hitRate = this.totalObtained > 0 ?
-            (this.totalObtained - this.getTotalCreated()) / this.totalObtained : 0;
-        return {
-            totalSize,
-            totalMaxSize,
-            totalMemoryUsage,
-            tierStats,
-            hitRate
-        };
-    }
-    /**
-     * 获取总创建数量
-     */
-    getTotalCreated() {
-        return this.pools.reduce((total, pool) => total + pool.getStats().totalCreated, 0);
-    }
-}
-/**
- * 池管理器
- * 统一管理所有对象池
- */
-export class PoolManager {
-    constructor() {
-        this.pools = new Map();
-        this.autoCompactInterval = 60000; // 60秒
-        this.lastCompactTime = 0;
-    }
-    static getInstance() {
-        if (!PoolManager.instance) {
-            PoolManager.instance = new PoolManager();
-        }
-        return PoolManager.instance;
-    }
-    /**
-     * 注册池
-     * @param name 池名称
-     * @param pool 池实例
-     */
-    registerPool(name, pool) {
-        this.pools.set(name, pool);
-    }
-    /**
-     * 获取池
-     * @param name 池名称
-     * @returns 池实例
-     */
-    getPool(name) {
-        return this.pools.get(name) || null;
-    }
-    /**
-     * 更新池管理器（应在游戏循环中调用）
-     */
-    update() {
-        const now = Date.now();
-        if (now - this.lastCompactTime > this.autoCompactInterval) {
-            this.compactAllPools();
-            this.lastCompactTime = now;
-        }
-    }
-    /**
-     * 压缩所有池（清理碎片）
-     */
-    compactAllPools() {
-        // 对于标准池，可以考虑清理一些长时间未使用的对象
-        // 这里简单实现为重置统计信息
-        for (const pool of this.pools.values()) {
-            if (pool instanceof Pool) {
-                pool.resetStats();
-            }
-        }
-    }
-    /**
-     * 获取所有池的统计信息
-     */
-    getAllStats() {
-        const stats = new Map();
-        for (const [name, pool] of this.pools.entries()) {
-            if (pool instanceof Pool) {
-                stats.set(name, pool.getStats());
-            }
-            else if (pool instanceof TieredObjectPool) {
-                stats.set(name, pool.getStats());
-            }
-        }
-        return stats;
-    }
-    /**
-     * 生成性能报告
-     */
-    generateReport() {
-        const lines = [];
-        lines.push('=== Pool Manager Report ===');
-        let totalMemory = 0;
-        for (const [name, pool] of this.pools.entries()) {
-            lines.push(`\n${name}:`);
-            if (pool instanceof Pool) {
-                const stats = pool.getStats();
-                lines.push(`  Type: Standard Pool`);
-                lines.push(`  Size: ${stats.size}/${stats.maxSize}`);
-                lines.push(`  Hit Rate: ${(stats.hitRate * 100).toFixed(1)}%`);
-                lines.push(`  Memory: ${(stats.estimatedMemoryUsage / 1024).toFixed(1)} KB`);
-                totalMemory += stats.estimatedMemoryUsage;
-            }
-            else if (pool instanceof TieredObjectPool) {
-                const stats = pool.getStats();
-                lines.push(`  Type: Tiered Pool`);
-                lines.push(`  Total Size: ${stats.totalSize}/${stats.totalMaxSize}`);
-                lines.push(`  Hit Rate: ${(stats.hitRate * 100).toFixed(1)}%`);
-                lines.push(`  Memory: ${(stats.totalMemoryUsage / 1024).toFixed(1)} KB`);
-                totalMemory += stats.totalMemoryUsage;
-            }
-        }
-        lines.push(`\nTotal Memory Usage: ${(totalMemory / 1024 / 1024).toFixed(2)} MB`);
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=Pool.js.map