@esengine/ecs-framework 2.2.20 → 2.3.0

package/bin/ECS/Systems/WorkerEntitySystem.js

@@ -0,0 +1,792 @@
+import { EntitySystem } from './EntitySystem';
+import { Time } from '../../Utils/Time';
+import { PlatformManager } from '../../Platform/PlatformManager';
+import { getSystemInstanceTypeName } from '../Decorators';
+/**
+ * 支持Worker并行处理的EntitySystem基类
+ *
+ * 支持传统Worker和SharedArrayBuffer两种优化模式：
+ * - 传统模式：数据序列化传输，适用于复杂计算
+ * - SharedArrayBuffer模式：零拷贝数据共享，适用于大量简单计算
+ *
+ * 用户需要实现：
+ * 1. extractEntityData - 定义数据提取逻辑
+ * 2. workerProcess - 编写处理函数（纯函数，可序列化）
+ * 3. applyResult - 定义结果应用逻辑
+ * 4. (可选) SharedArrayBuffer相关方法
+ *
+ * @example
+ * ```typescript
+ * class PhysicsSystem extends WorkerEntitySystem<PhysicsData> {
+ *     constructor() {
+ *         super(Matcher.all(Transform, Velocity), {
+ *             enableWorker: true,
+ *             workerCount: 8, // 指定8个worker，系统会自动限制在系统最大值内
+ *             entitiesPerWorker: 100, // 每个worker处理100个实体
+ *             useSharedArrayBuffer: true,
+ *             entityDataSize: 6, // x, y, vx, vy, radius, mass
+ *             maxEntities: 10000,
+ *             systemConfig: { gravity: 100, friction: 0.95 }
+ *         });
+ *     }
+ *
+ *     protected getDefaultEntityDataSize(): number {
+ *         return 6; // x, y, vx, vy, radius, mass
+ *     }
+ *
+ *     protected extractEntityData(entity: Entity): PhysicsData {
+ *         const transform = entity.getComponent(Transform);
+ *         const velocity = entity.getComponent(Velocity);
+ *         const physics = entity.getComponent(PhysicsComponent);
+ *         return {
+ *             x: transform.x,
+ *             y: transform.y,
+ *             vx: velocity.x,
+ *             vy: velocity.y,
+ *             radius: physics.radius,
+ *             mass: physics.mass
+ *         };
+ *     }
+ *
+ *     protected workerProcess(entities: PhysicsData[], deltaTime: number, config: any): PhysicsData[] {
+ *         return entities.map(entity => {
+ *             // 应用重力
+ *             entity.vy += config.gravity * deltaTime;
+ *
+ *             // 更新位置
+ *             entity.x += entity.vx * deltaTime;
+ *             entity.y += entity.vy * deltaTime;
+ *
+ *             // 应用摩擦力
+ *             entity.vx *= config.friction;
+ *             entity.vy *= config.friction;
+ *
+ *             return entity;
+ *         });
+ *     }
+ *
+ *     protected applyResult(entity: Entity, result: PhysicsData): void {
+ *         const transform = entity.getComponent(Transform);
+ *         const velocity = entity.getComponent(Velocity);
+ *
+ *         transform.x = result.x;
+ *         transform.y = result.y;
+ *         velocity.x = result.vx;
+ *         velocity.y = result.vy;
+ *     }
+ *
+ *     // SharedArrayBuffer优化支持
+ *     protected writeEntityToBuffer(entityData: PhysicsData, offset: number): void {
+ *         if (!this.sharedFloatArray) return;
+ *
+ *         this.sharedFloatArray[offset] = entityData.x;
+ *         this.sharedFloatArray[offset + 1] = entityData.y;
+ *         this.sharedFloatArray[offset + 2] = entityData.vx;
+ *         this.sharedFloatArray[offset + 3] = entityData.vy;
+ *         this.sharedFloatArray[offset + 4] = entityData.radius;
+ *         this.sharedFloatArray[offset + 5] = entityData.mass;
+ *     }
+ *
+ *     protected readEntityFromBuffer(offset: number): PhysicsData | null {
+ *         if (!this.sharedFloatArray) return null;
+ *
+ *         return {
+ *             x: this.sharedFloatArray[offset],
+ *             y: this.sharedFloatArray[offset + 1],
+ *             vx: this.sharedFloatArray[offset + 2],
+ *             vy: this.sharedFloatArray[offset + 3],
+ *             radius: this.sharedFloatArray[offset + 4],
+ *             mass: this.sharedFloatArray[offset + 5]
+ *         };
+ *     }
+ *
+ *     protected getSharedArrayBufferProcessFunction(): SharedArrayBufferProcessFunction {
+ *         return function(sharedFloatArray: Float32Array, startIndex: number, endIndex: number, deltaTime: number, config: any) {
+ *             const entitySize = 6;
+ *             for (let i = startIndex; i < endIndex; i++) {
+ *                 const offset = i * entitySize;
+ *
+ *                 // 读取数据
+ *                 let x = sharedFloatArray[offset];
+ *                 let y = sharedFloatArray[offset + 1];
+ *                 let vx = sharedFloatArray[offset + 2];
+ *                 let vy = sharedFloatArray[offset + 3];
+ *                 const radius = sharedFloatArray[offset + 4];
+ *                 const mass = sharedFloatArray[offset + 5];
+ *
+ *                 // 物理计算
+ *                 vy += config.gravity * deltaTime;
+ *                 x += vx * deltaTime;
+ *                 y += vy * deltaTime;
+ *                 vx *= config.friction;
+ *                 vy *= config.friction;
+ *
+ *                 // 写回数据
+ *                 sharedFloatArray[offset] = x;
+ *                 sharedFloatArray[offset + 1] = y;
+ *                 sharedFloatArray[offset + 2] = vx;
+ *                 sharedFloatArray[offset + 3] = vy;
+ *             }
+ *         };
+ *     }
+ * }
+ *
+ * interface PhysicsData {
+ *     x: number;
+ *     y: number;
+ *     vx: number;
+ *     vy: number;
+ *     radius: number;
+ *     mass: number;
+ * }
+ * ```
+ */
+export class WorkerEntitySystem extends EntitySystem {
+    constructor(matcher, config = {}) {
+        super(matcher);
+        this.workerPool = null;
+        this.isProcessing = false;
+        this.sharedBuffer = null;
+        this.sharedFloatArray = null;
+        this.hasLoggedSyncMode = false;
+        // 获取平台适配器
+        this.platformAdapter = PlatformManager.getInstance().getAdapter();
+        // 验证和调整 worker 数量，确保不超过系统最大值
+        const requestedWorkerCount = config.workerCount ?? this.getMaxSystemWorkerCount();
+        const maxSystemWorkerCount = this.getMaxSystemWorkerCount();
+        const validatedWorkerCount = Math.min(requestedWorkerCount, maxSystemWorkerCount);
+        // 如果用户请求的数量超过系统最大值，给出警告
+        if (requestedWorkerCount > maxSystemWorkerCount) {
+            this.logger.warn(`请求 ${requestedWorkerCount} 个Worker，但系统最多支持 ${maxSystemWorkerCount} 个。实际使用 ${validatedWorkerCount} 个Worker。`);
+        }
+        this.config = {
+            enableWorker: config.enableWorker ?? true,
+            workerCount: validatedWorkerCount,
+            systemConfig: config.systemConfig,
+            ...(config.entitiesPerWorker !== undefined && { entitiesPerWorker: config.entitiesPerWorker }),
+            useSharedArrayBuffer: config.useSharedArrayBuffer ?? this.isSharedArrayBufferSupported(),
+            entityDataSize: config.entityDataSize ?? this.getDefaultEntityDataSize(),
+            maxEntities: config.maxEntities ?? 10000
+        };
+        if (this.config.enableWorker && this.isWorkerSupported()) {
+            // 先初始化SharedArrayBuffer，再初始化Worker池
+            if (this.config.useSharedArrayBuffer) {
+                this.initializeSharedArrayBuffer();
+            }
+            this.initializeWorkerPool();
+        }
+    }
+    /**
+     * 检查是否支持Worker
+     */
+    isWorkerSupported() {
+        return this.platformAdapter.isWorkerSupported();
+    }
+    /**
+     * 检查是否支持SharedArrayBuffer
+     */
+    isSharedArrayBufferSupported() {
+        return this.platformAdapter.isSharedArrayBufferSupported();
+    }
+    /**
+     * 获取系统支持的最大Worker数量
+     */
+    getMaxSystemWorkerCount() {
+        const platformConfig = this.platformAdapter.getPlatformConfig();
+        return platformConfig.maxWorkerCount;
+    }
+    /**
+     * 初始化SharedArrayBuffer
+     */
+    initializeSharedArrayBuffer() {
+        try {
+            // 检查是否支持SharedArrayBuffer
+            if (!this.isSharedArrayBufferSupported()) {
+                this.logger.warn(`${this.systemName}: 平台不支持SharedArrayBuffer，降级到单Worker模式以保证数据处理完整性`);
+                this.config.useSharedArrayBuffer = false;
+                // 降级到单Worker模式：确保所有实体在同一个Worker中处理，维持实体间交互的完整性
+                this.config.workerCount = 1;
+                return;
+            }
+            // 使用配置的实体数据大小和最大实体数量
+            // 预分配缓冲区：maxEntities * entityDataSize * 4字节
+            const bufferSize = this.config.maxEntities * this.config.entityDataSize * 4;
+            this.sharedBuffer = this.platformAdapter.createSharedArrayBuffer(bufferSize);
+            if (this.sharedBuffer) {
+                this.sharedFloatArray = new Float32Array(this.sharedBuffer);
+            }
+            this.logger.info(`${this.systemName}: SharedArrayBuffer初始化成功 (${bufferSize} 字节)`);
+        }
+        catch (error) {
+            this.logger.warn(`${this.systemName}: SharedArrayBuffer初始化失败，降级到单Worker模式以保证数据处理完整性`, error);
+            this.config.useSharedArrayBuffer = false;
+            this.sharedBuffer = null;
+            this.sharedFloatArray = null;
+            this.config.workerCount = 1;
+        }
+    }
+    /**
+     * 初始化Worker池
+     */
+    initializeWorkerPool() {
+        try {
+            const script = this.createWorkerScript();
+            // 在WorkerEntitySystem中处理平台相关逻辑
+            const workers = [];
+            const platformConfig = this.platformAdapter.getPlatformConfig();
+            const fullScript = (platformConfig.workerScriptPrefix || '') + script;
+            for (let i = 0; i < this.config.workerCount; i++) {
+                try {
+                    const worker = this.platformAdapter.createWorker(fullScript, {
+                        name: `WorkerEntitySystem-${i}`
+                    });
+                    workers.push(worker);
+                }
+                catch (error) {
+                    this.logger.error(`创建Worker ${i} 失败:`, error);
+                    throw error;
+                }
+            }
+            this.workerPool = new PlatformWorkerPool(workers);
+        }
+        catch (error) {
+            this.logger.error(`${this.systemName}: Worker池初始化失败`, error);
+            this.config.enableWorker = false;
+        }
+    }
+    /**
+     * 创建Worker脚本
+     */
+    createWorkerScript() {
+        // 获取方法字符串并提取函数体
+        const methodStr = this.workerProcess.toString();
+        // 提取函数体部分（去掉方法签名）
+        const functionBodyMatch = methodStr.match(/\{([\s\S]*)\}/);
+        if (!functionBodyMatch) {
+            throw new Error('无法解析workerProcess方法');
+        }
+        const functionBody = functionBodyMatch[1];
+        const entityDataSize = this.config.entityDataSize;
+        // 获取SharedArrayBuffer处理函数的字符串
+        const sharedProcessMethod = this.getSharedArrayBufferProcessFunction?.() || null;
+        let sharedProcessFunctionBody = '';
+        if (sharedProcessMethod) {
+            const sharedMethodStr = sharedProcessMethod.toString();
+            const sharedFunctionBodyMatch = sharedMethodStr.match(/\{([\s\S]*)\}/);
+            if (sharedFunctionBodyMatch) {
+                sharedProcessFunctionBody = sharedFunctionBodyMatch[1] ?? '';
+            }
+        }
+        return `
+            // Worker脚本 - 支持SharedArrayBuffer
+            let sharedFloatArray = null;
+            const ENTITY_DATA_SIZE = ${entityDataSize};
+
+            self.onmessage = function(e) {
+                const { type, id, entities, deltaTime, systemConfig, startIndex, endIndex, sharedBuffer } = e.data;
+
+
+                try {
+                    // 处理SharedArrayBuffer初始化
+                    if (type === 'init' && sharedBuffer) {
+                        sharedFloatArray = new Float32Array(sharedBuffer);
+                        self.postMessage({ type: 'init', success: true });
+                        return;
+                    }
+
+                    // 处理SharedArrayBuffer数据
+                    if (type === 'shared' && sharedFloatArray) {
+                        processSharedArrayBuffer(startIndex, endIndex, deltaTime, systemConfig);
+                        self.postMessage({ id, result: null }); // SharedArrayBuffer不需要返回数据
+                        return;
+                    }
+
+                    // 传统处理方式
+                    if (entities) {
+                        // 定义处理函数
+                        function workerProcess(entities, deltaTime, systemConfig) {
+                            ${functionBody}
+                        }
+
+                        // 执行处理
+                        const result = workerProcess(entities, deltaTime, systemConfig);
+
+                        // 处理Promise返回值
+                        if (result && typeof result.then === 'function') {
+                            result.then(finalResult => {
+                                self.postMessage({ id, result: finalResult });
+                            }).catch(error => {
+                                self.postMessage({ id, error: error.message });
+                            });
+                        } else {
+                            self.postMessage({ id, result });
+                        }
+                    }
+                } catch (error) {
+                    self.postMessage({ id, error: error.message });
+                }
+            };
+
+            // SharedArrayBuffer处理函数 - 由子类定义
+            function processSharedArrayBuffer(startIndex, endIndex, deltaTime, systemConfig) {
+                if (!sharedFloatArray) return;
+
+                ${sharedProcessFunctionBody ? `
+                    // 用户定义的处理函数
+                    const userProcessFunction = function(sharedFloatArray, startIndex, endIndex, deltaTime, systemConfig) {
+                        ${sharedProcessFunctionBody}
+                    };
+                    userProcessFunction(sharedFloatArray, startIndex, endIndex, deltaTime, systemConfig);
+                ` : ''}
+            }
+        `;
+    }
+    /**
+     * 重写process方法，支持Worker并行处理
+     */
+    process(entities) {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        try {
+            if (this.config.enableWorker && this.workerPool) {
+                // 检查SharedArrayBuffer是否真正可用
+                if (this.config.useSharedArrayBuffer && this.sharedFloatArray && this.isSharedArrayBufferSupported()) {
+                    // 使用SharedArrayBuffer优化的异步处理
+                    this.processWithSharedArrayBuffer(entities).finally(() => {
+                        this.isProcessing = false;
+                    });
+                }
+                else {
+                    // 如果配置了SharedArrayBuffer但不可用，记录降级信息
+                    if (this.config.useSharedArrayBuffer) {
+                        this.logger.info(`${this.systemName}: 本帧降级到传统Worker模式`);
+                    }
+                    // 传统Worker异步处理
+                    this.processWithWorker(entities).finally(() => {
+                        this.isProcessing = false;
+                    });
+                }
+            }
+            else {
+                // 同步处理（最后的fallback）
+                if (!this.hasLoggedSyncMode) {
+                    this.logger.info(`${this.systemName}: Worker不可用，使用同步处理`);
+                    this.hasLoggedSyncMode = true;
+                }
+                this.processSynchronously(entities);
+                this.isProcessing = false;
+            }
+        }
+        catch (error) {
+            this.isProcessing = false;
+            this.logger.error(`${this.systemName}: 处理失败`, error);
+            throw error;
+        }
+    }
+    /**
+     * 使用SharedArrayBuffer优化的Worker处理
+     */
+    async processWithSharedArrayBuffer(entities) {
+        if (!this.sharedFloatArray) {
+            throw new Error('SharedArrayBuffer not initialized');
+        }
+        // 1. 将实体数据写入SharedArrayBuffer
+        this.writeEntitiesToSharedBuffer(entities);
+        // 2. 通知Workers处理数据
+        const promises = this.createSharedArrayBufferTasks(entities.length);
+        await Promise.all(promises);
+        // 3. 从SharedArrayBuffer读取结果并应用
+        this.readResultsFromSharedBuffer(entities);
+    }
+    /**
+     * 使用Worker并行处理
+     */
+    async processWithWorker(entities) {
+        // 1. 数据提取阶段
+        const entityData = [];
+        for (let i = 0; i < entities.length; i++) {
+            entityData[i] = this.extractEntityData(entities[i]);
+        }
+        // 2. 分批处理
+        const batches = this.createBatches(entityData);
+        const deltaTime = Time.deltaTime;
+        // 3. Worker执行阶段
+        const promises = batches.map((batch) => this.workerPool.execute({
+            entities: batch,
+            deltaTime,
+            systemConfig: this.config.systemConfig
+        }));
+        const results = await Promise.all(promises);
+        // 4. 结果应用阶段
+        let entityIndex = 0;
+        for (const batchResult of results) {
+            for (const result of batchResult) {
+                if (entityIndex < entities.length) {
+                    const entity = entities[entityIndex];
+                    // 只对有效实体应用结果
+                    if (entity && result) {
+                        this.applyResult(entity, result);
+                    }
+                }
+                entityIndex++;
+            }
+        }
+    }
+    /**
+     * 同步处理（fallback）
+     */
+    processSynchronously(entities) {
+        // 1. 数据提取阶段
+        const entityData = entities.map((entity) => this.extractEntityData(entity));
+        // 2. 主线程处理阶段
+        const deltaTime = Time.deltaTime;
+        const results = this.workerProcess(entityData, deltaTime, this.config.systemConfig);
+        // 3. 结果应用阶段
+        // 处理Promise返回值
+        if (results && typeof results.then === 'function') {
+            results.then((finalResults) => {
+                entities.forEach((entity, index) => {
+                    this.applyResult(entity, finalResults[index]);
+                });
+            });
+        }
+        else {
+            entities.forEach((entity, index) => {
+                this.applyResult(entity, results[index]);
+            });
+        }
+    }
+    /**
+     * 创建数据批次 - 支持用户指定每个Worker的实体数量
+     */
+    createBatches(data) {
+        const workerCount = this.config.workerCount;
+        const batches = [];
+        // 如果用户指定了每个Worker处理的实体数量
+        if (this.config.entitiesPerWorker) {
+            const entitiesPerWorker = this.config.entitiesPerWorker;
+            for (let i = 0; i < data.length; i += entitiesPerWorker) {
+                const endIndex = Math.min(i + entitiesPerWorker, data.length);
+                batches.push(data.slice(i, endIndex));
+            }
+            // 限制批次数量不超过Worker数量
+            if (batches.length > workerCount) {
+                this.logger.warn(`${this.systemName}: 创建了 ${batches.length} 个批次，但只有 ${workerCount} 个Worker。某些Worker将依次处理多个批次。`);
+            }
+        }
+        else {
+            // 默认行为：按Worker数量平均分配
+            const batchSize = Math.ceil(data.length / workerCount);
+            for (let i = 0; i < workerCount; i++) {
+                const startIndex = i * batchSize;
+                const endIndex = Math.min(startIndex + batchSize, data.length);
+                if (startIndex < data.length) {
+                    batches.push(data.slice(startIndex, endIndex));
+                }
+            }
+        }
+        return batches;
+    }
+    /**
+     * 将实体数据写入SharedArrayBuffer
+     */
+    writeEntitiesToSharedBuffer(entities) {
+        if (!this.sharedFloatArray)
+            return;
+        for (let i = 0; i < entities.length && i < this.config.maxEntities; i++) {
+            const entity = entities[i];
+            const data = this.extractEntityData(entity);
+            const offset = i * this.config.entityDataSize; // 使用配置的数据大小
+            // 使用子类提供的数据提取方法，然后转换为标准格式
+            this.writeEntityToBuffer(data, offset);
+        }
+    }
+    /**
+     * 创建SharedArrayBuffer任务 - 支持用户指定每个Worker的实体数量
+     */
+    createSharedArrayBufferTasks(entityCount) {
+        const promises = [];
+        // 如果用户指定了每个Worker处理的实体数量
+        if (this.config.entitiesPerWorker) {
+            const entitiesPerWorker = this.config.entitiesPerWorker;
+            const tasksNeeded = Math.ceil(entityCount / entitiesPerWorker);
+            const availableWorkers = this.config.workerCount;
+            // 如果任务数超过Worker数量，警告用户
+            if (tasksNeeded > availableWorkers) {
+                this.logger.warn(`${this.systemName}: 需要 ${tasksNeeded} 个任务处理 ${entityCount} 个实体（每任务 ${entitiesPerWorker} 个），但只有 ${availableWorkers} 个Worker。某些Worker将依次处理多个任务。`);
+            }
+            for (let i = 0; i < entityCount; i += entitiesPerWorker) {
+                const startIndex = i;
+                const endIndex = Math.min(i + entitiesPerWorker, entityCount);
+                const promise = this.workerPool.executeSharedBuffer({
+                    startIndex,
+                    endIndex,
+                    deltaTime: Time.deltaTime,
+                    systemConfig: this.config.systemConfig
+                });
+                promises.push(promise);
+            }
+        }
+        else {
+            // 默认行为：按Worker数量平均分配
+            const entitiesPerWorker = Math.ceil(entityCount / this.config.workerCount);
+            for (let i = 0; i < this.config.workerCount; i++) {
+                const startIndex = i * entitiesPerWorker;
+                const endIndex = Math.min(startIndex + entitiesPerWorker, entityCount);
+                if (startIndex < entityCount) {
+                    const promise = this.workerPool.executeSharedBuffer({
+                        startIndex,
+                        endIndex,
+                        deltaTime: Time.deltaTime,
+                        systemConfig: this.config.systemConfig
+                    });
+                    promises.push(promise);
+                }
+            }
+        }
+        return promises;
+    }
+    /**
+     * 从SharedArrayBuffer读取结果并应用
+     */
+    readResultsFromSharedBuffer(entities) {
+        if (!this.sharedFloatArray)
+            return;
+        for (let i = 0; i < entities.length && i < this.config.maxEntities; i++) {
+            const entity = entities[i];
+            const offset = i * this.config.entityDataSize; // 使用配置的数据大小
+            // 从SharedArrayBuffer读取数据
+            const result = this.readEntityFromBuffer(offset);
+            if (result) {
+                this.applyResult(entity, result);
+            }
+        }
+    }
+    /**
+     * 更新Worker配置
+     */
+    updateConfig(newConfig) {
+        const oldConfig = { ...this.config };
+        // 如果更新了workerCount，需要验证并调整
+        if (newConfig.workerCount !== undefined) {
+            const maxSystemWorkerCount = this.getMaxSystemWorkerCount();
+            const validatedWorkerCount = Math.min(newConfig.workerCount, maxSystemWorkerCount);
+            if (newConfig.workerCount > maxSystemWorkerCount) {
+                this.logger.warn(`请求 ${newConfig.workerCount} 个Worker，但系统最多支持 ${maxSystemWorkerCount} 个。实际使用 ${validatedWorkerCount} 个Worker。`);
+            }
+            newConfig.workerCount = validatedWorkerCount;
+        }
+        Object.assign(this.config, newConfig);
+        // 如果 SharedArrayBuffer 设置发生变化，需要重新初始化
+        if (oldConfig.useSharedArrayBuffer !== this.config.useSharedArrayBuffer) {
+            this.reinitializeWorkerSystem();
+            return;
+        }
+        // 如果 Worker 数量发生变化，需要重新创建 Worker 池
+        if (oldConfig.workerCount !== this.config.workerCount) {
+            this.reinitializeWorkerPool();
+            return;
+        }
+        // 如果禁用Worker，清理Worker池
+        if (!this.config.enableWorker && this.workerPool) {
+            this.workerPool.destroy();
+            this.workerPool = null;
+        }
+        // 如果启用Worker但池不存在，重新创建
+        if (this.config.enableWorker && !this.workerPool && this.isWorkerSupported()) {
+            this.initializeWorkerPool();
+        }
+    }
+    /**
+     * 重新初始化整个 Worker 系统（包括 SharedArrayBuffer）
+     */
+    reinitializeWorkerSystem() {
+        // 清理现有资源
+        if (this.workerPool) {
+            this.workerPool.destroy();
+            this.workerPool = null;
+        }
+        this.sharedBuffer = null;
+        this.sharedFloatArray = null;
+        // 如果禁用 SharedArrayBuffer，降级到单 Worker 模式
+        if (!this.config.useSharedArrayBuffer) {
+            this.config.workerCount = 1;
+        }
+        // 重新初始化
+        if (this.config.enableWorker && this.isWorkerSupported()) {
+            if (this.config.useSharedArrayBuffer) {
+                this.initializeSharedArrayBuffer();
+            }
+            this.initializeWorkerPool();
+        }
+    }
+    /**
+     * 重新初始化 Worker 池（保持 SharedArrayBuffer）
+     */
+    reinitializeWorkerPool() {
+        if (this.workerPool) {
+            this.workerPool.destroy();
+            this.workerPool = null;
+        }
+        if (this.config.enableWorker && this.isWorkerSupported()) {
+            this.initializeWorkerPool();
+        }
+    }
+    /**
+     * 获取系统性能信息
+     */
+    getWorkerInfo() {
+        let currentMode = 'sync';
+        if (this.config.enableWorker && this.workerPool) {
+            if (this.config.useSharedArrayBuffer && this.sharedFloatArray && this.isSharedArrayBufferSupported()) {
+                currentMode = 'shared-buffer';
+            }
+            else {
+                currentMode = 'worker';
+            }
+        }
+        return {
+            enabled: this.config.enableWorker,
+            workerCount: this.config.workerCount,
+            ...(this.config.entitiesPerWorker !== undefined && { entitiesPerWorker: this.config.entitiesPerWorker }),
+            maxSystemWorkerCount: this.getMaxSystemWorkerCount(),
+            isProcessing: this.isProcessing,
+            sharedArrayBufferSupported: this.isSharedArrayBufferSupported(),
+            sharedArrayBufferEnabled: this.config.useSharedArrayBuffer,
+            currentMode
+        };
+    }
+    /**
+     * 销毁系统时清理Worker池
+     */
+    onDestroy() {
+        super.onDestroy();
+        if (this.workerPool) {
+            this.workerPool.destroy();
+            this.workerPool = null;
+        }
+    }
+    getLoggerName() {
+        return getSystemInstanceTypeName(this);
+    }
+}
+/**
+ * 平台适配的Worker池管理器
+ */
+class PlatformWorkerPool {
+    constructor(workers) {
+        this.workers = [];
+        this.taskQueue = [];
+        this.busyWorkers = new Set();
+        this.taskCounter = 0;
+        this.workers = workers;
+        // 为每个Worker设置消息处理器
+        for (let i = 0; i < workers.length; i++) {
+            const worker = workers[i];
+            if (!worker)
+                continue;
+            // 设置消息处理器
+            worker.onMessage((event) => this.handleWorkerMessage(i, event.data));
+            worker.onError((error) => this.handleWorkerError(i, error));
+        }
+    }
+    /**
+     * 执行SharedArrayBuffer任务
+     */
+    executeSharedBuffer(data) {
+        return new Promise((resolve, reject) => {
+            const task = {
+                id: `shared-task-${++this.taskCounter}`,
+                data: { ...data, type: 'shared' },
+                resolve: () => resolve(), // SharedArrayBuffer不需要返回数据
+                reject
+            };
+            this.taskQueue.push(task);
+            this.processQueue();
+        });
+    }
+    /**
+     * 执行任务
+     */
+    execute(data) {
+        return new Promise((resolve, reject) => {
+            const task = {
+                id: `task-${++this.taskCounter}`,
+                data,
+                resolve: (result) => {
+                    resolve(result);
+                },
+                reject
+            };
+            this.taskQueue.push(task);
+            this.processQueue();
+        });
+    }
+    /**
+     * 处理任务队列
+     */
+    processQueue() {
+        if (this.taskQueue.length === 0)
+            return;
+        // 找到空闲的Worker
+        for (let i = 0; i < this.workers.length; i++) {
+            if (!this.busyWorkers.has(i) && this.taskQueue.length > 0) {
+                const task = this.taskQueue.shift();
+                this.busyWorkers.add(i);
+                const worker = this.workers[i];
+                worker.postMessage({
+                    id: task.id,
+                    ...task.data
+                });
+                // 存储任务信息以便后续处理
+                worker._currentTask = task;
+            }
+        }
+    }
+    /**
+     * 处理Worker消息
+     */
+    handleWorkerMessage(workerIndex, data) {
+        const worker = this.workers[workerIndex];
+        const task = worker._currentTask;
+        if (!task)
+            return;
+        this.busyWorkers.delete(workerIndex);
+        worker._currentTask = null;
+        if (data.error) {
+            task.reject(new Error(data.error));
+        }
+        else {
+            task.resolve(data.result);
+        }
+        // 处理下一个任务
+        this.processQueue();
+    }
+    /**
+     * 处理Worker错误
+     */
+    handleWorkerError(workerIndex, error) {
+        const worker = this.workers[workerIndex];
+        const task = worker._currentTask;
+        if (task) {
+            this.busyWorkers.delete(workerIndex);
+            worker._currentTask = null;
+            task.reject(new Error(error.message));
+        }
+        // 处理下一个任务
+        this.processQueue();
+    }
+    /**
+     * 销毁Worker池
+     */
+    destroy() {
+        for (const worker of this.workers) {
+            worker.terminate();
+        }
+        this.workers.length = 0;
+        this.taskQueue.length = 0;
+        this.busyWorkers.clear();
+    }
+}
+//# sourceMappingURL=WorkerEntitySystem.js.map