@esengine/ecs-framework 2.0.6 → 2.0.8

package/bin/Testing/Performance/benchmark.js

@@ -0,0 +1,639 @@
+"use strict";
+/**
+ * ECS框架性能基准测试
+ * 测试框架在不同场景下的性能表现
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const Scene_1 = require("../../ECS/Scene");
+const Component_1 = require("../../ECS/Component");
+console.log('🚀 ECS框架性能基准测试');
+console.log('============================================================');
+console.log('测试目标: 评估ECS框架在不同场景下的性能表现');
+console.log('============================================================');
+/**
+ * 位置组件
+ */
+class PositionComponent extends Component_1.Component {
+    constructor(x = 0, y = 0) {
+        super();
+        this.x = 0;
+        this.y = 0;
+        this.x = x;
+        this.y = y;
+    }
+}
+/**
+ * 速度组件
+ */
+class VelocityComponent extends Component_1.Component {
+    constructor(vx = 0, vy = 0) {
+        super();
+        this.vx = 0;
+        this.vy = 0;
+        this.vx = vx;
+        this.vy = vy;
+    }
+}
+/**
+ * 生命值组件
+ */
+class HealthComponent extends Component_1.Component {
+    constructor(health = 100) {
+        super();
+        this.health = 100;
+        this.maxHealth = 100;
+        this.health = health;
+        this.maxHealth = health;
+    }
+}
+/**
+ * 渲染组件
+ */
+class RenderComponent extends Component_1.Component {
+    constructor(sprite = '') {
+        super();
+        this.sprite = '';
+        this.visible = true;
+        this.sprite = sprite;
+    }
+}
+/**
+ * AI组件
+ */
+class AIComponent extends Component_1.Component {
+    constructor(state = 'idle') {
+        super();
+        this.state = 'idle';
+        this.target = null;
+        this.state = state;
+    }
+}
+/**
+ * 测试配置
+ */
+const TEST_CONFIG = {
+    entityCounts: [1000, 5000, 10000, 25000, 50000, 100000, 200000, 500000],
+    queryIterations: 1000,
+    updateIterations: 100
+};
+/**
+ * 测试创建实体的性能
+ */
+function testEntityCreation(scene, count) {
+    const startTime = performance.now();
+    let entityCreationTime = 0;
+    let componentAdditionTime = 0;
+    let tagAssignmentTime = 0;
+    // 批量创建实体（不添加组件）
+    const entityStart = performance.now();
+    const entities = scene.createEntities(count, "Entity");
+    entityCreationTime = performance.now() - entityStart;
+    // 批量添加组件
+    const componentStart = performance.now();
+    for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        // 所有实体都有位置组件
+        entity.addComponent(new PositionComponent(Math.random() * 1000, Math.random() * 1000));
+        // 70%的实体有速度组件
+        if (Math.random() < 0.7) {
+            entity.addComponent(new VelocityComponent((Math.random() - 0.5) * 10, (Math.random() - 0.5) * 10));
+        }
+        // 50%的实体有生命值组件
+        if (Math.random() < 0.5) {
+            entity.addComponent(new HealthComponent(Math.floor(Math.random() * 100) + 50));
+        }
+        // 30%的实体有渲染组件
+        if (Math.random() < 0.3) {
+            entity.addComponent(new RenderComponent(`sprite_${i % 10}`));
+        }
+        // 20%的实体有AI组件
+        if (Math.random() < 0.2) {
+            entity.addComponent(new AIComponent(['idle', 'patrol', 'chase'][Math.floor(Math.random() * 3)]));
+        }
+    }
+    componentAdditionTime = performance.now() - componentStart;
+    // 批量设置标签
+    const tagStart = performance.now();
+    for (const entity of entities) {
+        entity.tag = Math.floor(Math.random() * 10);
+    }
+    tagAssignmentTime = performance.now() - tagStart;
+    const totalTime = performance.now() - startTime;
+    return {
+        totalTime,
+        averageTime: totalTime / count,
+        entitiesPerSecond: count / (totalTime / 1000),
+        breakdown: {
+            entityCreation: entityCreationTime,
+            componentAddition: componentAdditionTime,
+            tagAssignment: tagAssignmentTime
+        }
+    };
+}
+/**
+ * 创建测试实体
+ */
+function createTestEntities(scene, count) {
+    const entities = [];
+    for (let i = 0; i < count; i++) {
+        const entity = scene.createEntity(`Entity_${i}`);
+        // 所有实体都有位置组件
+        entity.addComponent(new PositionComponent(Math.random() * 1000, Math.random() * 1000));
+        // 70%的实体有速度组件
+        if (Math.random() < 0.7) {
+            entity.addComponent(new VelocityComponent((Math.random() - 0.5) * 10, (Math.random() - 0.5) * 10));
+        }
+        // 50%的实体有生命值组件
+        if (Math.random() < 0.5) {
+            entity.addComponent(new HealthComponent(Math.floor(Math.random() * 100) + 50));
+        }
+        // 30%的实体有渲染组件
+        if (Math.random() < 0.3) {
+            entity.addComponent(new RenderComponent(`sprite_${i % 10}`));
+        }
+        // 20%的实体有AI组件
+        if (Math.random() < 0.2) {
+            entity.addComponent(new AIComponent(['idle', 'patrol', 'chase'][Math.floor(Math.random() * 3)]));
+        }
+        // 设置随机标签
+        entity.tag = Math.floor(Math.random() * 10);
+        entities.push(entity);
+    }
+    return entities;
+}
+/**
+ * 测试单组件查询性能
+ */
+function testSingleComponentQuery(scene, iterations) {
+    const startTime = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        scene.querySystem.queryAll(PositionComponent);
+    }
+    return performance.now() - startTime;
+}
+/**
+ * 测试多组件查询性能
+ */
+function testMultiComponentQuery(scene, iterations) {
+    const startTime = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        scene.querySystem.queryAll(PositionComponent, VelocityComponent);
+    }
+    return performance.now() - startTime;
+}
+/**
+ * 测试复杂查询性能
+ */
+function testComplexQuery(scene, iterations) {
+    const startTime = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        scene.querySystem.queryAll(PositionComponent, VelocityComponent, HealthComponent);
+    }
+    return performance.now() - startTime;
+}
+/**
+ * 测试标签查询性能
+ */
+function testTagQuery(scene, iterations) {
+    const startTime = performance.now();
+    // 优化：预先获取所有标签查询结果，然后重复使用
+    // 这更符合实际游戏中的使用模式
+    const tags = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    for (let i = 0; i < iterations; i++) {
+        // 批量查询所有标签
+        for (const tag of tags) {
+            scene.querySystem.queryByTag(tag);
+        }
+    }
+    return performance.now() - startTime;
+}
+/**
+ * 测试单个标签查询性能
+ */
+function testSingleTagQuery(scene, iterations) {
+    const startTime = performance.now();
+    // 只查询标签0，测试单个标签的查询性能和缓存效果
+    for (let i = 0; i < iterations; i++) {
+        scene.querySystem.queryByTag(0);
+    }
+    return performance.now() - startTime;
+}
+/**
+ * 测试实体更新性能
+ */
+function testEntityUpdate(scene, iterations) {
+    const entities = scene.querySystem.queryAll(PositionComponent, VelocityComponent).entities;
+    const startTime = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        for (const entity of entities) {
+            const pos = entity.getComponent(PositionComponent);
+            const vel = entity.getComponent(VelocityComponent);
+            if (pos && vel) {
+                pos.x += vel.vx;
+                pos.y += vel.vy;
+            }
+        }
+    }
+    return performance.now() - startTime;
+}
+/**
+ * 获取内存使用情况
+ */
+function getMemoryUsage() {
+    if (typeof process !== 'undefined' && process.memoryUsage) {
+        return process.memoryUsage().heapUsed / 1024 / 1024; // MB
+    }
+    return 0;
+}
+/**
+ * 运行性能测试
+ */
+function runPerformanceTest(scene, entityCount, config) {
+    console.log(`\n📊 测试 ${entityCount.toLocaleString()} 个实体...`);
+    // 测试实体创建性能
+    const startMemory = getMemoryUsage();
+    console.log(`   🔧 测试实体创建性能...`);
+    const creationStats = testEntityCreation(scene, entityCount);
+    const endMemory = getMemoryUsage();
+    console.log(`   📈 实体创建性能分析:`);
+    console.log(`      总时间: ${creationStats.totalTime.toFixed(2)}ms`);
+    console.log(`      平均时间: ${creationStats.averageTime.toFixed(4)}ms/实体`);
+    console.log(`      创建速度: ${creationStats.entitiesPerSecond.toFixed(0)} 实体/秒`);
+    console.log(`      时间分解:`);
+    console.log(`        - 实体创建: ${creationStats.breakdown.entityCreation.toFixed(2)}ms (${(creationStats.breakdown.entityCreation / creationStats.totalTime * 100).toFixed(1)}%)`);
+    console.log(`        - 组件添加: ${creationStats.breakdown.componentAddition.toFixed(2)}ms (${(creationStats.breakdown.componentAddition / creationStats.totalTime * 100).toFixed(1)}%)`);
+    console.log(`        - 标签分配: ${creationStats.breakdown.tagAssignment.toFixed(2)}ms (${(creationStats.breakdown.tagAssignment / creationStats.totalTime * 100).toFixed(1)}%)`);
+    console.log(`      内存使用: ${(endMemory - startMemory).toFixed(1)}MB`);
+    // 运行测试
+    console.log(`   🔍 执行查询测试...`);
+    const singleQuery = testSingleComponentQuery(scene, config.queryIterations);
+    const multiQuery = testMultiComponentQuery(scene, config.queryIterations);
+    const complexQuery = testComplexQuery(scene, config.queryIterations);
+    const tagQuery = testTagQuery(scene, config.queryIterations);
+    const singleTagQuery = testSingleTagQuery(scene, config.queryIterations);
+    console.log(`   ⚡ 执行更新测试...`);
+    const entityUpdate = testEntityUpdate(scene, config.updateIterations);
+    console.log(`   ✅ 测试完成`);
+    return {
+        entityCount,
+        singleQuery,
+        multiQuery,
+        complexQuery,
+        tagQuery,
+        singleTagQuery,
+        entityUpdate,
+        memoryUsage: endMemory - startMemory
+    };
+}
+/**
+ * 显示系统信息
+ */
+function displaySystemInfo(scene) {
+    const status = scene.querySystem.getAccelerationStatus();
+    const stats = scene.querySystem.getStats();
+    console.log('\n🔍 系统信息:');
+    console.log(`   当前提供者: ${status.currentProvider}`);
+    console.log(`   WebAssembly: ${status.wasmEnabled ? '已启用' : '未启用'}`);
+    console.log(`   可用提供者: ${status.availableProviders.join(', ')}`);
+    console.log(`   索引统计:`);
+    console.log(`     组件掩码索引: ${stats.indexStats.maskIndexSize}`);
+    console.log(`     组件类型索引: ${stats.indexStats.componentIndexSize}`);
+    console.log(`     标签索引: ${stats.indexStats.tagIndexSize}`);
+    console.log(`     名称索引: ${stats.indexStats.nameIndexSize}`);
+    if (status.performanceInfo?.cacheStats) {
+        console.log(`   查询缓存:`);
+        console.log(`     缓存大小: ${status.performanceInfo.cacheStats.size}`);
+        console.log(`     命中率: ${status.performanceInfo.cacheStats.hitRate}`);
+    }
+}
+/**
+ * 显示性能结果
+ */
+function displayResults(results, scene) {
+    console.log('\n📈 ECS框架性能测试结果');
+    console.log('='.repeat(130));
+    console.log('| 实体数量   | 单组件查询 | 双组件查询 | 三组件查询 | 多标签查询 | 单标签查询 | 实体更新  | 内存使用  |');
+    console.log('|' + '-'.repeat(128) + '|');
+    for (const result of results) {
+        const entityCount = result.entityCount.toLocaleString().padStart(9);
+        const singleQuery = `${result.singleQuery.toFixed(2)}ms`.padStart(10);
+        const multiQuery = `${result.multiQuery.toFixed(2)}ms`.padStart(10);
+        const complexQuery = `${result.complexQuery.toFixed(2)}ms`.padStart(10);
+        const tagQuery = `${result.tagQuery.toFixed(2)}ms`.padStart(10);
+        const singleTagQuery = `${result.singleTagQuery.toFixed(2)}ms`.padStart(10);
+        const entityUpdate = `${result.entityUpdate.toFixed(2)}ms`.padStart(9);
+        const memoryUsage = `${result.memoryUsage.toFixed(1)}MB`.padStart(9);
+        console.log(`| ${entityCount} | ${singleQuery} | ${multiQuery} | ${complexQuery} | ${tagQuery} | ${singleTagQuery} | ${entityUpdate} | ${memoryUsage} |`);
+    }
+    console.log('|' + '-'.repeat(128) + '|');
+    // 计算性能指标
+    const maxEntities = Math.max(...results.map(r => r.entityCount));
+    const maxResult = results.find(r => r.entityCount === maxEntities);
+    console.log(`\n🎯 性能峰值 (${maxEntities.toLocaleString()} 个实体):`);
+    console.log(`   单组件查询: ${(TEST_CONFIG.queryIterations / maxResult.singleQuery * 1000).toFixed(0)} 次/秒`);
+    console.log(`   双组件查询: ${(TEST_CONFIG.queryIterations / maxResult.multiQuery * 1000).toFixed(0)} 次/秒`);
+    console.log(`   三组件查询: ${(TEST_CONFIG.queryIterations / maxResult.complexQuery * 1000).toFixed(0)} 次/秒`);
+    console.log(`   多标签查询: ${(TEST_CONFIG.queryIterations * 10 / maxResult.tagQuery * 1000).toFixed(0)} 次/秒`);
+    console.log(`   单标签查询: ${(TEST_CONFIG.queryIterations / maxResult.singleTagQuery * 1000).toFixed(0)} 次/秒`);
+    console.log(`   实体更新: ${(maxResult.entityCount * TEST_CONFIG.updateIterations / maxResult.entityUpdate * 1000).toFixed(0)} 个/秒`);
+    console.log(`   内存效率: ${(maxResult.entityCount / (maxResult.memoryUsage || 1)).toFixed(0)} 实体/MB`);
+    // 性能评级
+    const avgQueryTime = (maxResult.singleQuery + maxResult.multiQuery + maxResult.complexQuery + maxResult.singleTagQuery) / 4;
+    let rating = '';
+    if (avgQueryTime < 50)
+        rating = '🚀 优秀';
+    else if (avgQueryTime < 100)
+        rating = '✅ 良好';
+    else if (avgQueryTime < 200)
+        rating = '⚠️ 一般';
+    else
+        rating = '❌ 需要优化';
+    console.log(`\n📊 性能评级: ${rating}`);
+    console.log(`   平均查询时间: ${avgQueryTime.toFixed(2)}ms`);
+    // 显示查询统计信息
+    const queryStats = scene.querySystem.getStats().queryStats;
+    console.log(`\n🔍 查询统计:`);
+    console.log(`   总查询次数: ${queryStats.totalQueries.toLocaleString()}`);
+    console.log(`   缓存命中: ${queryStats.cacheHits.toLocaleString()}`);
+    console.log(`   索引命中: ${queryStats.indexHits.toLocaleString()}`);
+    console.log(`   线性扫描: ${queryStats.linearScans.toLocaleString()}`);
+    console.log(`   缓存命中率: ${queryStats.cacheHitRate}`);
+    // 标签查询性能分析
+    console.log(`\n🏷️ 标签查询分析:`);
+    const tagQueryRatio = maxResult.tagQuery / maxResult.singleTagQuery;
+    console.log(`   多标签查询 vs 单标签查询: ${tagQueryRatio.toFixed(2)}x (预期约10x)`);
+    if (tagQueryRatio > 15) {
+        console.log(`   ⚠️ 多标签查询性能异常，可能存在缓存问题`);
+    }
+    else if (tagQueryRatio < 5) {
+        console.log(`   ✅ 标签查询缓存效果良好`);
+    }
+    else {
+        console.log(`   📊 标签查询性能正常`);
+    }
+    // 性能改进分析
+    const improvement = calculatePerformanceImprovement(results);
+    if (improvement) {
+        console.log(`\n📈 性能改进分析:`);
+        console.log(`   双组件查询改进: ${improvement.multiQuery}x`);
+        console.log(`   三组件查询改进: ${improvement.complexQuery}x`);
+        console.log(`   整体查询改进: ${improvement.overall}x`);
+    }
+    // 扩展性分析
+    console.log(`\n📊 扩展性分析:`);
+    analyzeScalability(results);
+}
+/**
+ * 计算性能改进（与优化前对比）
+ */
+function calculatePerformanceImprovement(results) {
+    // 基于50,000实体的结果进行分析
+    const maxResult = results.find(r => r.entityCount === 50000);
+    if (!maxResult)
+        return null;
+    // 优化前的基准时间（基于之前的测试结果）
+    const baselineMultiQuery = 1270.54; // ms
+    const baselineComplexQuery = 981.76; // ms
+    const multiImprovement = (baselineMultiQuery / maxResult.multiQuery).toFixed(2);
+    const complexImprovement = (baselineComplexQuery / maxResult.complexQuery).toFixed(2);
+    const overallImprovement = ((baselineMultiQuery + baselineComplexQuery) /
+        (maxResult.multiQuery + maxResult.complexQuery)).toFixed(2);
+    return {
+        multiQuery: multiImprovement,
+        complexQuery: complexImprovement,
+        overall: overallImprovement
+    };
+}
+/**
+ * 分析系统扩展性
+ */
+function analyzeScalability(results) {
+    if (results.length < 2)
+        return;
+    // 分析查询时间随实体数量的变化趋势
+    const first = results[0];
+    const last = results[results.length - 1];
+    const entityRatio = last.entityCount / first.entityCount;
+    const singleQueryRatio = last.singleQuery / first.singleQuery;
+    const multiQueryRatio = last.multiQuery / first.multiQuery;
+    const complexQueryRatio = last.complexQuery / first.complexQuery;
+    console.log(`   实体数量增长: ${entityRatio.toFixed(1)}x (${first.entityCount.toLocaleString()} → ${last.entityCount.toLocaleString()})`);
+    console.log(`   单组件查询时间增长: ${singleQueryRatio.toFixed(2)}x`);
+    console.log(`   双组件查询时间增长: ${multiQueryRatio.toFixed(2)}x`);
+    console.log(`   三组件查询时间增长: ${complexQueryRatio.toFixed(2)}x`);
+    // 计算复杂度
+    const avgComplexity = (singleQueryRatio + multiQueryRatio + complexQueryRatio) / 3;
+    let complexityRating = '';
+    if (avgComplexity < entityRatio * 0.1)
+        complexityRating = '🚀 近似O(1) - 优秀';
+    else if (avgComplexity < entityRatio * 0.5)
+        complexityRating = '✅ 亚线性 - 良好';
+    else if (avgComplexity < entityRatio)
+        complexityRating = '⚠️ 接近线性 - 一般';
+    else
+        complexityRating = '❌ 超线性 - 需要优化';
+    console.log(`   时间复杂度评估: ${complexityRating}`);
+    // 内存效率分析
+    const memoryEfficiencyFirst = first.entityCount / first.memoryUsage;
+    const memoryEfficiencyLast = last.entityCount / last.memoryUsage;
+    const memoryEfficiencyRatio = memoryEfficiencyLast / memoryEfficiencyFirst;
+    console.log(`   内存效率变化: ${memoryEfficiencyRatio.toFixed(2)}x (${memoryEfficiencyFirst.toFixed(0)} → ${memoryEfficiencyLast.toFixed(0)} 实体/MB)`);
+}
+/**
+ * 专门测试实体创建性能
+ */
+async function runEntityCreationBenchmark() {
+    console.log('\n🚀 实体创建性能基准测试');
+    console.log('='.repeat(60));
+    const testCounts = [1000, 5000, 10000, 50000, 100000];
+    for (const count of testCounts) {
+        console.log(`\n📊 测试创建 ${count.toLocaleString()} 个实体:`);
+        // 创建新场景
+        const scene = new Scene_1.Scene();
+        // 测试创建性能
+        const stats = testEntityCreation(scene, count);
+        console.log(`   总时间: ${stats.totalTime.toFixed(2)}ms`);
+        console.log(`   平均时间: ${stats.averageTime.toFixed(4)}ms/实体`);
+        console.log(`   创建速度: ${stats.entitiesPerSecond.toFixed(0)} 实体/秒`);
+        console.log(`   时间分解:`);
+        console.log(`     - 实体创建: ${stats.breakdown.entityCreation.toFixed(2)}ms (${(stats.breakdown.entityCreation / stats.totalTime * 100).toFixed(1)}%)`);
+        console.log(`     - 组件添加: ${stats.breakdown.componentAddition.toFixed(2)}ms (${(stats.breakdown.componentAddition / stats.totalTime * 100).toFixed(1)}%)`);
+        console.log(`     - 标签分配: ${stats.breakdown.tagAssignment.toFixed(2)}ms (${(stats.breakdown.tagAssignment / stats.totalTime * 100).toFixed(1)}%)`);
+        // 分析性能瓶颈
+        const { entityCreation, componentAddition, tagAssignment } = stats.breakdown;
+        const total = stats.totalTime;
+        console.log(`   性能瓶颈分析:`);
+        if (componentAddition / total > 0.5) {
+            console.log(`     ⚠️  组件添加是主要瓶颈 (${(componentAddition / total * 100).toFixed(1)}%)`);
+        }
+        if (entityCreation / total > 0.3) {
+            console.log(`     ⚠️  实体创建开销较高 (${(entityCreation / total * 100).toFixed(1)}%)`);
+        }
+        if (tagAssignment / total > 0.1) {
+            console.log(`     ⚠️  标签分配开销异常 (${(tagAssignment / total * 100).toFixed(1)}%)`);
+        }
+        // 分析组件添加性能（仅对较小的测试集）
+        if (count <= 10000) {
+            analyzeComponentAdditionPerformance(new Scene_1.Scene(), Math.min(count, 5000));
+        }
+        // 清理场景
+        scene.end();
+    }
+    console.log('\n📈 实体创建性能总结:');
+    console.log('   主要性能瓶颈通常在组件添加阶段');
+    console.log('   建议优化方向:');
+    console.log('   1. 减少组件注册开销');
+    console.log('   2. 优化位掩码计算');
+    console.log('   3. 减少内存分配次数');
+    console.log('   4. 使用对象池复用组件实例');
+}
+/**
+ * 测试组件添加性能的详细分析
+ */
+function analyzeComponentAdditionPerformance(scene, count) {
+    console.log(`\n🔬 组件添加性能详细分析 (${count.toLocaleString()} 个实体):`);
+    // 创建实体但不添加组件
+    const entities = scene.createEntities(count, "TestEntity");
+    // 分别测试每种组件的添加性能
+    const componentTests = [
+        {
+            name: "PositionComponent",
+            create: () => new PositionComponent(Math.random() * 1000, Math.random() * 1000),
+            probability: 1.0
+        },
+        {
+            name: "VelocityComponent",
+            create: () => new VelocityComponent((Math.random() - 0.5) * 10, (Math.random() - 0.5) * 10),
+            probability: 0.7
+        },
+        {
+            name: "HealthComponent",
+            create: () => new HealthComponent(Math.floor(Math.random() * 100) + 50),
+            probability: 0.5
+        },
+        {
+            name: "RenderComponent",
+            create: () => new RenderComponent(`sprite_${Math.floor(Math.random() * 10)}`),
+            probability: 0.3
+        },
+        {
+            name: "AIComponent",
+            create: () => new AIComponent(['idle', 'patrol', 'chase'][Math.floor(Math.random() * 3)]),
+            probability: 0.2
+        }
+    ];
+    for (const test of componentTests) {
+        const startTime = performance.now();
+        let addedCount = 0;
+        for (const entity of entities) {
+            if (Math.random() < test.probability) {
+                entity.addComponent(test.create());
+                addedCount++;
+            }
+        }
+        const endTime = performance.now();
+        const totalTime = endTime - startTime;
+        console.log(`   ${test.name}:`);
+        console.log(`     添加数量: ${addedCount.toLocaleString()}`);
+        console.log(`     总时间: ${totalTime.toFixed(2)}ms`);
+        console.log(`     平均时间: ${(totalTime / addedCount).toFixed(4)}ms/组件`);
+        console.log(`     添加速度: ${(addedCount / (totalTime / 1000)).toFixed(0)} 组件/秒`);
+    }
+}
+/**
+ * 主测试函数
+ */
+async function runBenchmarks() {
+    console.log('🎯 ECS框架性能基准测试');
+    console.log('='.repeat(60));
+    // 先运行实体创建性能测试
+    await runEntityCreationBenchmark();
+    // 然后运行完整的框架测试
+    console.log('\n🚀 完整框架性能测试');
+    console.log('='.repeat(60));
+    console.log(`\n⚙️ 测试配置:`);
+    console.log(`   实体数量: ${TEST_CONFIG.entityCounts.map(n => n.toLocaleString()).join(', ')}`);
+    console.log(`   查询迭代: ${TEST_CONFIG.queryIterations.toLocaleString()}`);
+    console.log(`   更新迭代: ${TEST_CONFIG.updateIterations.toLocaleString()}`);
+    console.log(`   预计测试时间: ${(TEST_CONFIG.entityCounts.length * 2).toFixed(0)}-${(TEST_CONFIG.entityCounts.length * 5).toFixed(0)} 分钟`);
+    console.log('\n🔧 初始化ECS框架...');
+    // 初始化WebAssembly模块
+    try {
+        const { ecsCore } = await Promise.resolve().then(() => __importStar(require('../../Utils/WasmCore')));
+        await ecsCore.initialize();
+        console.log(`✅ WebAssembly模块: ${ecsCore.isUsingWasm() ? '已加载' : '未加载'}`);
+    }
+    catch (error) {
+        console.log('⚠️ WebAssembly模块加载失败，使用JavaScript实现');
+    }
+    const scene = new Scene_1.Scene();
+    // 等待初始化完成
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    displaySystemInfo(scene);
+    const results = [];
+    const totalTests = TEST_CONFIG.entityCounts.length;
+    // 运行不同规模的测试
+    for (let i = 0; i < TEST_CONFIG.entityCounts.length; i++) {
+        const entityCount = TEST_CONFIG.entityCounts[i];
+        console.log(`\n🔄 进度: ${i + 1}/${totalTests} (${((i + 1) / totalTests * 100).toFixed(1)}%)`);
+        const result = runPerformanceTest(scene, entityCount, TEST_CONFIG);
+        results.push(result);
+        // 清理场景，准备下一轮测试
+        console.log(`   🧹 清理内存...`);
+        scene.end();
+        scene.begin();
+        // 强制垃圾回收
+        if (typeof global !== 'undefined' && global.gc) {
+            global.gc();
+        }
+        // 大规模测试间隔稍作休息
+        if (entityCount >= 100000) {
+            console.log(`   ⏱️ 等待系统稳定...`);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+    }
+    displayResults(results, scene);
+    scene.end();
+    console.log('\n✅ 性能测试完成！');
+    console.log(`📊 总测试时间: ${((Date.now() - startTime) / 1000 / 60).toFixed(1)} 分钟`);
+}
+// 记录开始时间
+const startTime = Date.now();
+// 运行测试
+runBenchmarks().catch(error => {
+    console.error('❌ 测试失败:', error);
+});
+//# sourceMappingURL=benchmark.js.map