esengine/docs/public/demos/worker-system/assets/index-CrID--xK.js

(function polyfill() {
  const relList = document.createElement("link").relList;
  if (relList && relList.supports && relList.supports("modulepreload")) {
    return;
  }
  for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
    processPreload(link);
  }
  new MutationObserver((mutations) => {
    for (const mutation of mutations) {
      if (mutation.type !== "childList") {
        continue;
      }
      for (const node of mutation.addedNodes) {
        if (node.tagName === "LINK" && node.rel === "modulepreload")
          processPreload(node);
      }
    }
  }).observe(document, { childList: true, subtree: true });
  function getFetchOpts(link) {
    const fetchOpts = {};
    if (link.integrity) fetchOpts.integrity = link.integrity;
    if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
    if (link.crossOrigin === "use-credentials")
      fetchOpts.credentials = "include";
    else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
    else fetchOpts.credentials = "same-origin";
    return fetchOpts;
  }
  function processPreload(link) {
    if (link.ep)
      return;
    link.ep = true;
    const fetchOpts = getFetchOpts(link);
    fetch(link.href, fetchOpts);
  }
})();
class GlobalManager {
  constructor() {
    this._enabled = false;
  }
  /**
   * 获取或设置管理器是否启用
   */
  get enabled() {
    return this._enabled;
  }
  set enabled(value) {
    this.setEnabled(value);
  }
  /**
   * 设置管理器是否启用
   * @param isEnabled 如果为true，则启用管理器；否则禁用管理器
   */
  setEnabled(isEnabled) {
    if (this._enabled != isEnabled) {
      this._enabled = isEnabled;
      if (this._enabled) {
        this.onEnabled();
      } else {
        this.onDisabled();
      }
    }
  }
  /**
   * 在启用管理器时调用的回调方法
   */
  onEnabled() {
  }
  /**
   * 在禁用管理器时调用的回调方法
   */
  onDisabled() {
  }
  /**
   * 更新管理器状态的方法
   */
  update() {
  }
}
class Time {
  /**
   * 使用外部引擎提供的deltaTime更新时间信息
   * @param deltaTime 外部引擎提供的帧时间间隔（秒）
   */
  static update(deltaTime) {
    this.unscaledDeltaTime = deltaTime;
    this.deltaTime = deltaTime * this.timeScale;
    this.unscaledTotalTime += this.unscaledDeltaTime;
    this.totalTime += this.deltaTime;
    this.frameCount++;
  }
  /**
   * 场景改变时重置时间
   */
  static sceneChanged() {
    this.frameCount = 0;
    this.totalTime = 0;
    this.unscaledTotalTime = 0;
    this.deltaTime = 0;
    this.unscaledDeltaTime = 0;
  }
  /**
   * 检查指定的时间间隔是否已经过去
   * @param interval 时间间隔（秒）
   * @param lastTime 上次检查的时间
   * @returns 是否已经过去指定时间
   */
  static checkEvery(interval, lastTime) {
    return this.totalTime - lastTime >= interval;
  }
}
Time.deltaTime = 0;
Time.unscaledDeltaTime = 0;
Time.totalTime = 0;
Time.unscaledTotalTime = 0;
Time.timeScale = 1;
Time.frameCount = 0;
class Timer {
  constructor() {
    this._timeInSeconds = 0;
    this._repeats = false;
    this._isDone = false;
    this._elapsedTime = 0;
  }
  getContext() {
    return this.context;
  }
  /**
   * 定时器是否已完成
   */
  get isDone() {
    return this._isDone;
  }
  /**
   * 定时器已运行的时间
   */
  get elapsedTime() {
    return this._elapsedTime;
  }
  reset() {
    this._elapsedTime = 0;
  }
  stop() {
    this._isDone = true;
  }
  tick() {
    if (!this._isDone && this._elapsedTime > this._timeInSeconds) {
      this._elapsedTime -= this._timeInSeconds;
      this._onTime(this);
      if (!this._isDone && !this._repeats)
        this._isDone = true;
    }
    this._elapsedTime += Time.deltaTime;
    return this._isDone;
  }
  initialize(timeInsSeconds, repeats, context, onTime) {
    this._timeInSeconds = timeInsSeconds;
    this._repeats = repeats;
    this.context = context;
    this._onTime = onTime.bind(context);
  }
  /**
   * 空出对象引用，以便在js需要时GC可以清理它们的引用
   */
  unload() {
    this.context = null;
    this._onTime = null;
  }
}
class TimerManager extends GlobalManager {
  constructor() {
    super(...arguments);
    this._timers = [];
  }
  update() {
    for (let i = this._timers.length - 1; i >= 0; i--) {
      if (this._timers[i].tick()) {
        this._timers[i].unload();
        this._timers.splice(i, 1);
      }
    }
  }
  /**
   * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
   * @param timeInSeconds
   * @param repeats
   * @param context
   * @param onTime
   */
  schedule(timeInSeconds, repeats, context, onTime) {
    let timer = new Timer();
    timer.initialize(timeInSeconds, repeats, context, onTime);
    this._timers.push(timer);
    return timer;
  }
}
var PerformanceWarningType;
(function(PerformanceWarningType2) {
  PerformanceWarningType2["HIGH_EXECUTION_TIME"] = "high_execution_time";
  PerformanceWarningType2["HIGH_MEMORY_USAGE"] = "high_memory_usage";
  PerformanceWarningType2["HIGH_CPU_USAGE"] = "high_cpu_usage";
  PerformanceWarningType2["FREQUENT_GC"] = "frequent_gc";
  PerformanceWarningType2["LOW_FPS"] = "low_fps";
  PerformanceWarningType2["HIGH_ENTITY_COUNT"] = "high_entity_count";
})(PerformanceWarningType || (PerformanceWarningType = {}));
class PerformanceMonitor {
  /**
   * 获取单例实例
   */
  static get instance() {
    if (!PerformanceMonitor._instance) {
      PerformanceMonitor._instance = new PerformanceMonitor();
    }
    return PerformanceMonitor._instance;
  }
  constructor() {
    this._systemData = /* @__PURE__ */ new Map();
    this._systemStats = /* @__PURE__ */ new Map();
    this._warnings = [];
    this._isEnabled = false;
    this._maxRecentSamples = 60;
    this._maxWarnings = 100;
    this._thresholds = {
      executionTime: { warning: 16.67, critical: 33.33 },
      // 60fps和30fps对应的帧时间
      memoryUsage: { warning: 100, critical: 200 },
      // MB
      cpuUsage: { warning: 70, critical: 90 },
      // 百分比
      fps: { warning: 45, critical: 30 },
      entityCount: { warning: 1e3, critical: 5e3 }
    };
    this._fpsHistory = [];
    this._lastFrameTime = 0;
    this._frameCount = 0;
    this._fpsUpdateInterval = 1e3;
    this._lastFpsUpdate = 0;
    this._currentFps = 60;
    this._memoryCheckInterval = 5e3;
    this._lastMemoryCheck = 0;
    this._memoryHistory = [];
    this._gcCount = 0;
    this._lastGcCheck = 0;
    this._gcCheckInterval = 1e3;
  }
  /**
   * 启用性能监控
   */
  enable() {
    this._isEnabled = true;
  }
  /**
   * 禁用性能监控
   */
  disable() {
    this._isEnabled = false;
  }
  /**
   * 检查是否启用了性能监控
   */
  get isEnabled() {
    return this._isEnabled;
  }
  /**
   * 开始监控系统性能
   * @param systemName 系统名称
   * @returns 开始时间戳
   */
  startMonitoring(systemName) {
    if (!this._isEnabled) {
      return 0;
    }
    return performance.now();
  }
  /**
   * 结束监控并记录性能数据
   * @param systemName 系统名称
   * @param startTime 开始时间戳
   * @param entityCount 处理的实体数量
   */
  endMonitoring(systemName, startTime, entityCount = 0) {
    if (!this._isEnabled || startTime === 0) {
      return;
    }
    const endTime = performance.now();
    const executionTime = endTime - startTime;
    const averageTimePerEntity = entityCount > 0 ? executionTime / entityCount : 0;
    const data = {
      name: systemName,
      executionTime,
      entityCount,
      averageTimePerEntity,
      lastUpdateTime: endTime
    };
    this._systemData.set(systemName, data);
    this.updateStats(systemName, executionTime);
  }
  /**
   * 更新系统统计信息
   * @param systemName 系统名称
   * @param executionTime 执行时间
   */
  updateStats(systemName, executionTime) {
    let stats = this._systemStats.get(systemName);
    if (!stats) {
      stats = {
        totalTime: 0,
        averageTime: 0,
        minTime: Number.MAX_VALUE,
        maxTime: 0,
        executionCount: 0,
        recentTimes: [],
        standardDeviation: 0,
        percentile95: 0,
        percentile99: 0
      };
      this._systemStats.set(systemName, stats);
    }
    stats.totalTime += executionTime;
    stats.executionCount++;
    stats.averageTime = stats.totalTime / stats.executionCount;
    stats.minTime = Math.min(stats.minTime, executionTime);
    stats.maxTime = Math.max(stats.maxTime, executionTime);
    stats.recentTimes.push(executionTime);
    if (stats.recentTimes.length > this._maxRecentSamples) {
      stats.recentTimes.shift();
    }
    this.calculateAdvancedStats(stats);
  }
  /**
   * 计算高级统计信息
   * @param stats 统计信息对象
   */
  calculateAdvancedStats(stats) {
    if (stats.recentTimes.length === 0)
      return;
    const mean = stats.recentTimes.reduce((a, b) => a + b, 0) / stats.recentTimes.length;
    const variance = stats.recentTimes.reduce((acc, time) => acc + Math.pow(time - mean, 2), 0) / stats.recentTimes.length;
    stats.standardDeviation = Math.sqrt(variance);
    const sortedTimes = [...stats.recentTimes].sort((a, b) => a - b);
    const len = sortedTimes.length;
    stats.percentile95 = sortedTimes[Math.floor(len * 0.95)] || 0;
    stats.percentile99 = sortedTimes[Math.floor(len * 0.99)] || 0;
  }
  /**
   * 获取系统的当前性能数据
   * @param systemName 系统名称
   * @returns 性能数据或undefined
   */
  getSystemData(systemName) {
    return this._systemData.get(systemName);
  }
  /**
   * 获取系统的统计信息
   * @param systemName 系统名称
   * @returns 统计信息或undefined
   */
  getSystemStats(systemName) {
    return this._systemStats.get(systemName);
  }
  /**
   * 获取所有系统的性能数据
   * @returns 所有系统的性能数据
   */
  getAllSystemData() {
    return new Map(this._systemData);
  }
  /**
   * 获取所有系统的统计信息
   * @returns 所有系统的统计信息
   */
  getAllSystemStats() {
    return new Map(this._systemStats);
  }
  /**
   * 获取性能报告
   * @returns 格式化的性能报告字符串
   */
  getPerformanceReport() {
    if (!this._isEnabled) {
      return "Performance monitoring is disabled.";
    }
    const lines = [];
    lines.push("=== ECS Performance Report ===");
    lines.push("");
    const sortedSystems = Array.from(this._systemStats.entries()).sort((a, b) => b[1].averageTime - a[1].averageTime);
    for (const [systemName, stats] of sortedSystems) {
      const data = this._systemData.get(systemName);
      lines.push(`System: ${systemName}`);
      lines.push(`  Current: ${data?.executionTime.toFixed(2)}ms (${data?.entityCount} entities)`);
      lines.push(`  Average: ${stats.averageTime.toFixed(2)}ms`);
      lines.push(`  Min/Max: ${stats.minTime.toFixed(2)}ms / ${stats.maxTime.toFixed(2)}ms`);
      lines.push(`  Total: ${stats.totalTime.toFixed(2)}ms (${stats.executionCount} calls)`);
      if (data?.averageTimePerEntity && data.averageTimePerEntity > 0) {
        lines.push(`  Per Entity: ${data.averageTimePerEntity.toFixed(4)}ms`);
      }
      lines.push("");
    }
    const totalCurrentTime = Array.from(this._systemData.values()).reduce((sum, data) => sum + data.executionTime, 0);
    lines.push(`Total Frame Time: ${totalCurrentTime.toFixed(2)}ms`);
    lines.push(`Systems Count: ${this._systemData.size}`);
    return lines.join("\n");
  }
  /**
   * 重置所有性能数据
   */
  reset() {
    this._systemData.clear();
    this._systemStats.clear();
  }
  /**
   * 重置指定系统的性能数据
   * @param systemName 系统名称
   */
  resetSystem(systemName) {
    this._systemData.delete(systemName);
    this._systemStats.delete(systemName);
  }
  /**
   * 获取性能警告
   * @param thresholdMs 警告阈值（毫秒）
   * @returns 超过阈值的系统列表
   */
  getPerformanceWarnings(thresholdMs = 16.67) {
    const warnings = [];
    for (const [systemName, data] of this._systemData.entries()) {
      if (data.executionTime > thresholdMs) {
        warnings.push(`${systemName}: ${data.executionTime.toFixed(2)}ms (>${thresholdMs}ms)`);
      }
    }
    return warnings;
  }
  /**
   * 设置最大保留样本数
   * @param maxSamples 最大样本数
   */
  setMaxRecentSamples(maxSamples) {
    this._maxRecentSamples = maxSamples;
    for (const stats of this._systemStats.values()) {
      while (stats.recentTimes.length > maxSamples) {
        stats.recentTimes.shift();
      }
    }
  }
}
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;
    }
    this._stats.totalCreated++;
    this._updateHitRate();
    return this._createFn();
  }
  /**
   * 释放对象回池中
   * @param obj 要释放的对象
   */
  release(obj) {
    if (!obj)
      return;
    this._stats.totalReleased++;
    if (this._stats.size < this._maxSize) {
      obj.reset();
      this._objects.push(obj);
      this._stats.size++;
      this._updateMemoryUsage();
    }
  }
  /**
   * 获取池统计信息
   * @returns 统计信息对象
   */
  getStats() {
    return { ...this._stats };
  }
  /**
   * 清空池
   */
  clear() {
    for (const obj of this._objects) {
      obj.reset();
    }
    this._objects.length = 0;
    this._stats.size = 0;
    this._updateMemoryUsage();
  }
  /**
   * 压缩池（移除多余的对象）
   * @param targetSize 目标大小，默认为当前大小的一半
   */
  compact(targetSize) {
    const target = targetSize ?? Math.floor(this._objects.length / 2);
    while (this._objects.length > target) {
      const obj = this._objects.pop();
      if (obj) {
        obj.reset();
        this._stats.size--;
      }
    }
    this._updateMemoryUsage();
  }
  /**
   * 预填充池
   * @param count 预填充的对象数量
   */
  prewarm(count) {
    const actualCount = Math.min(count, this._maxSize - this._objects.length);
    for (let i = 0; i < actualCount; i++) {
      const obj = this._createFn();
      obj.reset();
      this._objects.push(obj);
      this._stats.totalCreated++;
      this._stats.size++;
    }
    this._updateMemoryUsage();
  }
  /**
   * 设置最大池大小
   * @param maxSize 新的最大大小
   */
  setMaxSize(maxSize) {
    this._maxSize = maxSize;
    this._stats.maxSize = maxSize;
    if (this._objects.length > maxSize) {
      this.compact(maxSize);
    }
  }
  /**
   * 获取池中可用对象数量
   * @returns 可用对象数量
   */
  getAvailableCount() {
    return this._objects.length;
  }
  /**
   * 检查池是否为空
   * @returns 如果池为空返回true
   */
  isEmpty() {
    return this._objects.length === 0;
  }
  /**
   * 检查池是否已满
   * @returns 如果池已满返回true
   */
  isFull() {
    return this._objects.length >= this._maxSize;
  }
  /**
   * 获取所有已注册的池类型
   * @returns 所有池类型的数组
   */
  static getAllPoolTypes() {
    return Array.from(this._pools.keys());
  }
  /**
   * 获取所有池的统计信息
   * @returns 包含所有池统计信息的对象
   */
  static getAllPoolStats() {
    const stats = {};
    for (const [type, pool] of this._pools) {
      const typeName = type.name || type.toString();
      stats[typeName] = pool.getStats();
    }
    return stats;
  }
  /**
   * 压缩所有池
   */
  static compactAllPools() {
    for (const pool of this._pools.values()) {
      pool.compact();
    }
  }
  /**
   * 清空所有池
   */
  static clearAllPools() {
    for (const pool of this._pools.values()) {
      pool.clear();
    }
    this._pools.clear();
  }
  /**
   * 获取全局池统计信息的格式化字符串
   * @returns 格式化的统计信息字符串
   */
  static getGlobalStatsString() {
    const stats = this.getAllPoolStats();
    const lines = ["=== Object Pool Global Statistics ===", ""];
    if (Object.keys(stats).length === 0) {
      lines.push("No pools registered");
      return lines.join("\n");
    }
    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");
  }
  /**
   * 更新命中率
   */
  _updateHitRate() {
    if (this._stats.totalObtained === 0) {
      this._stats.hitRate = 0;
    } else {
      const hits = this._stats.totalObtained - this._stats.totalCreated;
      this._stats.hitRate = hits / this._stats.totalObtained;
    }
  }
  /**
   * 更新内存使用估算
   */
  _updateMemoryUsage() {
    this._stats.estimatedMemoryUsage = this._stats.size * this._objectSize;
  }
}
Pool._pools = /* @__PURE__ */ new Map();
class PoolManager {
  constructor() {
    this.pools = /* @__PURE__ */ new Map();
    this.autoCompactInterval = 6e4;
    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;
    }
  }
  /**
   * 创建或获取标准池
   * @param name 池名称
   * @param createFn 创建函数
   * @param maxSize 最大大小
   * @param estimatedObjectSize 估算对象大小
   * @returns 池实例
   */
  createPool(name, createFn, maxSize = 100, estimatedObjectSize = 1024) {
    let pool = this.pools.get(name);
    if (!pool) {
      pool = new Pool(createFn, maxSize, estimatedObjectSize);
      this.pools.set(name, pool);
    }
    return pool;
  }
  /**
   * 移除池
   * @param name 池名称
   * @returns 是否成功移除
   */
  removePool(name) {
    const pool = this.pools.get(name);
    if (pool) {
      pool.clear();
      this.pools.delete(name);
      return true;
    }
    return false;
  }
  /**
   * 获取所有池名称
   * @returns 池名称数组
   */
  getPoolNames() {
    return Array.from(this.pools.keys());
  }
  /**
   * 获取池数量
   * @returns 池数量
   */
  getPoolCount() {
    return this.pools.size;
  }
  /**
   * 压缩所有池
   */
  compactAllPools() {
    for (const pool of this.pools.values()) {
      pool.compact();
    }
  }
  /**
   * 清空所有池
   */
  clearAllPools() {
    for (const pool of this.pools.values()) {
      pool.clear();
    }
  }
  /**
   * 获取所有池的统计信息
   * @returns 统计信息映射
   */
  getAllStats() {
    const stats = /* @__PURE__ */ new Map();
    for (const [name, pool] of this.pools) {
      stats.set(name, pool.getStats());
    }
    return stats;
  }
  /**
   * 获取总体统计信息
   * @returns 总体统计信息
   */
  getGlobalStats() {
    let totalSize = 0;
    let totalMaxSize = 0;
    let totalCreated = 0;
    let totalObtained = 0;
    let totalReleased = 0;
    let totalMemoryUsage = 0;
    for (const pool of this.pools.values()) {
      const stats = pool.getStats();
      totalSize += stats.size;
      totalMaxSize += stats.maxSize;
      totalCreated += stats.totalCreated;
      totalObtained += stats.totalObtained;
      totalReleased += stats.totalReleased;
      totalMemoryUsage += stats.estimatedMemoryUsage;
    }
    const hitRate = totalObtained === 0 ? 0 : (totalObtained - totalCreated) / totalObtained;
    return {
      size: totalSize,
      maxSize: totalMaxSize,
      totalCreated,
      totalObtained,
      totalReleased,
      hitRate,
      estimatedMemoryUsage: totalMemoryUsage
    };
  }
  /**
   * 获取格式化的统计信息字符串
   * @returns 格式化字符串
   */
  getStatsString() {
    const lines = ["=== Pool Manager Statistics ===", ""];
    if (this.pools.size === 0) {
      lines.push("No pools registered");
      return lines.join("\n");
    }
    const globalStats = this.getGlobalStats();
    lines.push(`Total Pools: ${this.pools.size}`);
    lines.push(`Global Hit Rate: ${(globalStats.hitRate * 100).toFixed(1)}%`);
    lines.push(`Global Memory Usage: ${(globalStats.estimatedMemoryUsage / 1024).toFixed(1)} KB`);
    lines.push("");
    for (const [name, pool] of this.pools) {
      const stats = pool.getStats();
      lines.push(`${name}:`);
      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`);
      lines.push("");
    }
    return lines.join("\n");
  }
  /**
   * 设置自动压缩间隔
   * @param intervalMs 间隔毫秒数
   */
  setAutoCompactInterval(intervalMs) {
    this.autoCompactInterval = intervalMs;
  }
  /**
   * 预填充所有池
   */
  prewarmAllPools() {
    for (const pool of this.pools.values()) {
      const stats = pool.getStats();
      const prewarmCount = Math.floor(stats.maxSize * 0.2);
      pool.prewarm(prewarmCount);
    }
  }
  /**
   * 重置池管理器
   */
  reset() {
    this.clearAllPools();
    this.pools.clear();
    this.lastCompactTime = 0;
  }
}
class BitMask64Utils {
  /**
   * 根据位索引创建64位掩码
   * @param bitIndex 位索引，范围 [0, 63]
   * @returns 包含指定位设置为1的掩码
   * @throws 当位索引超出范围时抛出错误
   */
  static create(bitIndex) {
    if (bitIndex < 0 || bitIndex >= 64) {
      throw new Error(`Bit index ${bitIndex} out of range [0, 63]`);
    }
    if (bitIndex < 32) {
      return { lo: 1 << bitIndex, hi: 0 };
    } else {
      return { lo: 0, hi: 1 << bitIndex - 32 };
    }
  }
  /**
   * 从32位数字创建64位掩码
   * @param value 32位数字值
   * @returns 低32位为输入值、高32位为0的掩码
   */
  static fromNumber(value) {
    return { lo: value >>> 0, hi: 0 };
  }
  /**
   * 检查掩码是否包含任意指定的位
   * @param mask 要检查的掩码
   * @param bits 指定的位模式
   * @returns 如果掩码包含bits中的任意位则返回true
   */
  static hasAny(mask, bits) {
    return (mask.lo & bits.lo) !== 0 || (mask.hi & bits.hi) !== 0;
  }
  /**
   * 检查掩码是否包含所有指定的位
   * @param mask 要检查的掩码
   * @param bits 指定的位模式
   * @returns 如果掩码包含bits中的所有位则返回true
   */
  static hasAll(mask, bits) {
    return (mask.lo & bits.lo) === bits.lo && (mask.hi & bits.hi) === bits.hi;
  }
  /**
   * 检查掩码是否不包含任何指定的位
   * @param mask 要检查的掩码
   * @param bits 指定的位模式
   * @returns 如果掩码不包含bits中的任何位则返回true
   */
  static hasNone(mask, bits) {
    return (mask.lo & bits.lo) === 0 && (mask.hi & bits.hi) === 0;
  }
  /**
   * 检查掩码是否为零
   * @param mask 要检查的掩码
   * @returns 如果掩码所有位都为0则返回true
   */
  static isZero(mask) {
    return mask.lo === 0 && mask.hi === 0;
  }
  /**
   * 检查两个掩码是否相等
   * @param a 第一个掩码
   * @param b 第二个掩码
   * @returns 如果两个掩码完全相等则返回true
   */
  static equals(a, b) {
    return a.lo === b.lo && a.hi === b.hi;
  }
  /**
   * 设置掩码中指定位为1
   * @param mask 要修改的掩码（原地修改）
   * @param bitIndex 位索引，范围 [0, 63]
   * @throws 当位索引超出范围时抛出错误
   */
  static setBit(mask, bitIndex) {
    if (bitIndex < 0 || bitIndex >= 64) {
      throw new Error(`Bit index ${bitIndex} out of range [0, 63]`);
    }
    if (bitIndex < 32) {
      mask.lo |= 1 << bitIndex;
    } else {
      mask.hi |= 1 << bitIndex - 32;
    }
  }
  /**
   * 清除掩码中指定位为0
   * @param mask 要修改的掩码（原地修改）
   * @param bitIndex 位索引，范围 [0, 63]
   * @throws 当位索引超出范围时抛出错误
   */
  static clearBit(mask, bitIndex) {
    if (bitIndex < 0 || bitIndex >= 64) {
      throw new Error(`Bit index ${bitIndex} out of range [0, 63]`);
    }
    if (bitIndex < 32) {
      mask.lo &= ~(1 << bitIndex);
    } else {
      mask.hi &= ~(1 << bitIndex - 32);
    }
  }
  /**
   * 对目标掩码执行按位或操作
   * @param target 目标掩码（原地修改）
   * @param other 用于按位或的掩码
   */
  static orInPlace(target, other) {
    target.lo |= other.lo;
    target.hi |= other.hi;
  }
  /**
   * 对目标掩码执行按位与操作
   * @param target 目标掩码（原地修改）
   * @param other 用于按位与的掩码
   */
  static andInPlace(target, other) {
    target.lo &= other.lo;
    target.hi &= other.hi;
  }
  /**
   * 对目标掩码执行按位异或操作
   * @param target 目标掩码（原地修改）
   * @param other 用于按位异或的掩码
   */
  static xorInPlace(target, other) {
    target.lo ^= other.lo;
    target.hi ^= other.hi;
  }
  /**
   * 清除掩码的所有位为0
   * @param mask 要清除的掩码（原地修改）
   */
  static clear(mask) {
    mask.lo = 0;
    mask.hi = 0;
  }
  /**
   * 将源掩码的值复制到目标掩码
   * @param source 源掩码
   * @param target 目标掩码（原地修改）
   */
  static copy(source, target) {
    target.lo = source.lo;
    target.hi = source.hi;
  }
  /**
   * 创建掩码的深拷贝
   * @param mask 要拷贝的掩码
   * @returns 新的掩码对象，内容与源掩码相同
   */
  static clone(mask) {
    return { lo: mask.lo, hi: mask.hi };
  }
  /**
   * 将掩码转换为字符串表示
   * @param mask 要转换的掩码
   * @param radix 进制，支持2（二进制）或16（十六进制），默认为2
   * @returns 掩码的字符串表示，二进制不带前缀，十六进制带0x前缀
   * @throws 当进制不支持时抛出错误
   */
  static toString(mask, radix = 2) {
    if (radix === 2) {
      if (mask.hi === 0) {
        return mask.lo.toString(2);
      } else {
        const hiBits = mask.hi.toString(2);
        const loBits = mask.lo.toString(2).padStart(32, "0");
        return hiBits + loBits;
      }
    } else if (radix === 16) {
      if (mask.hi === 0) {
        return "0x" + mask.lo.toString(16).toUpperCase();
      } else {
        const hiBits = mask.hi.toString(16).toUpperCase();
        const loBits = mask.lo.toString(16).toUpperCase().padStart(8, "0");
        return "0x" + hiBits + loBits;
      }
    } else {
      throw new Error("Only radix 2 and 16 are supported");
    }
  }
  /**
   * 计算掩码中设置为1的位数
   * @param mask 要计算的掩码
   * @returns 掩码中1的位数
   */
  static popCount(mask) {
    let count = 0;
    let lo = mask.lo;
    let hi = mask.hi;
    while (lo) {
      lo &= lo - 1;
      count++;
    }
    while (hi) {
      hi &= hi - 1;
      count++;
    }
    return count;
  }
}
BitMask64Utils.ZERO = { lo: 0, hi: 0 };
var LogLevel;
(function(LogLevel2) {
  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
  LogLevel2[LogLevel2["Info"] = 1] = "Info";
  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
  LogLevel2[LogLevel2["Error"] = 3] = "Error";
  LogLevel2[LogLevel2["Fatal"] = 4] = "Fatal";
  LogLevel2[LogLevel2["None"] = 5] = "None";
})(LogLevel || (LogLevel = {}));
const Colors = {
  RED: "\x1B[31m",
  GREEN: "\x1B[32m",
  YELLOW: "\x1B[33m",
  // 亮色版本
  BRIGHT_BLACK: "\x1B[90m",
  BRIGHT_RED: "\x1B[91m",
  // 特殊
  RESET: "\x1B[0m"
};
class ConsoleLogger {
  constructor(config = {}) {
    this._config = {
      level: LogLevel.Info,
      enableTimestamp: true,
      enableColors: typeof window === "undefined",
      ...config
    };
  }
  /**
   * 输出调试级别日志
   * @param message 日志消息
   * @param args 附加参数
   */
  debug(message, ...args) {
    this.log(LogLevel.Debug, message, ...args);
  }
  /**
   * 输出信息级别日志
   * @param message 日志消息
   * @param args 附加参数
   */
  info(message, ...args) {
    this.log(LogLevel.Info, message, ...args);
  }
  /**
   * 输出警告级别日志
   * @param message 日志消息
   * @param args 附加参数
   */
  warn(message, ...args) {
    this.log(LogLevel.Warn, message, ...args);
  }
  /**
   * 输出错误级别日志
   * @param message 日志消息
   * @param args 附加参数
   */
  error(message, ...args) {
    this.log(LogLevel.Error, message, ...args);
  }
  /**
   * 输出致命错误级别日志
   * @param message 日志消息
   * @param args 附加参数
   */
  fatal(message, ...args) {
    this.log(LogLevel.Fatal, message, ...args);
  }
  /**
   * 设置日志级别
   * @param level 日志级别
   */
  setLevel(level) {
    this._config.level = level;
  }
  /**
   * 设置颜色配置
   * @param colors 颜色配置
   */
  setColors(colors) {
    if (Object.keys(colors).length === 0) {
      delete this._config.colors;
    } else {
      this._config.colors = {
        ...this._config.colors,
        ...colors
      };
    }
  }
  /**
   * 设置日志前缀
   * @param prefix 前缀字符串
   */
  setPrefix(prefix) {
    this._config.prefix = prefix;
  }
  /**
   * 内部日志输出方法
   * @param level 日志级别
   * @param message 日志消息
   * @param args 附加参数
   */
  log(level, message, ...args) {
    if (level < this._config.level) {
      return;
    }
    let formattedMessage = message;
    if (this._config.enableTimestamp) {
      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
      formattedMessage = `[${timestamp}] ${formattedMessage}`;
    }
    if (this._config.prefix) {
      formattedMessage = `[${this._config.prefix}] ${formattedMessage}`;
    }
    const levelName = LogLevel[level].toUpperCase();
    formattedMessage = `[${levelName}] ${formattedMessage}`;
    if (this._config.output) {
      this._config.output(level, formattedMessage);
    } else {
      this.outputToConsole(level, formattedMessage, ...args);
    }
  }
  /**
   * 输出到控制台
   * @param level 日志级别
   * @param message 格式化后的消息
   * @param args 附加参数
   */
  outputToConsole(level, message, ...args) {
    const colors = this._config.enableColors ? this.getColors() : null;
    switch (level) {
      case LogLevel.Debug:
        if (colors) {
          console.debug(`${colors.debug}${message}${colors.reset}`, ...args);
        } else {
          console.debug(message, ...args);
        }
        break;
      case LogLevel.Info:
        if (colors) {
          console.info(`${colors.info}${message}${colors.reset}`, ...args);
        } else {
          console.info(message, ...args);
        }
        break;
      case LogLevel.Warn:
        if (colors) {
          console.warn(`${colors.warn}${message}${colors.reset}`, ...args);
        } else {
          console.warn(message, ...args);
        }
        break;
      case LogLevel.Error:
        if (colors) {
          console.error(`${colors.error}${message}${colors.reset}`, ...args);
        } else {
          console.error(message, ...args);
        }
        break;
      case LogLevel.Fatal:
        if (colors) {
          console.error(`${colors.fatal}${message}${colors.reset}`, ...args);
        } else {
          console.error(message, ...args);
        }
        break;
    }
  }
  /**
   * 获取控制台颜色配置
   * @returns 颜色配置对象
   */
  getColors() {
    const defaultColors = {
      debug: Colors.BRIGHT_BLACK,
      // 灰色
      info: Colors.GREEN,
      // 绿色
      warn: Colors.YELLOW,
      // 黄色
      error: Colors.RED,
      // 红色
      fatal: Colors.BRIGHT_RED,
      // 亮红色
      reset: Colors.RESET
      // 重置
    };
    return {
      ...defaultColors,
      ...this._config.colors
    };
  }
}
class LoggerManager {
  constructor() {
    this._loggers = /* @__PURE__ */ new Map();
    this._defaultLevel = LogLevel.Info;
    this._defaultLogger = new ConsoleLogger({
      level: this._defaultLevel
    });
  }
  /**
   * 获取日志管理器实例
   * @returns 日志管理器实例
   */
  static getInstance() {
    if (!LoggerManager._instance) {
      LoggerManager._instance = new LoggerManager();
    }
    return LoggerManager._instance;
  }
  /**
   * 获取或创建日志器
   * @param name 日志器名称
   * @returns 日志器实例
   */
  getLogger(name) {
    if (!name) {
      return this._defaultLogger;
    }
    if (!this._loggers.has(name)) {
      const logger2 = new ConsoleLogger({
        prefix: name,
        level: this._defaultLevel
      });
      this._loggers.set(name, logger2);
    }
    return this._loggers.get(name);
  }
  /**
   * 设置日志器
   * @param name 日志器名称
   * @param logger 日志器实例
   */
  setLogger(name, logger2) {
    this._loggers.set(name, logger2);
  }
  /**
   * 设置全局日志级别
   * @param level 日志级别
   */
  setGlobalLevel(level) {
    this._defaultLevel = level;
    if (this._defaultLogger instanceof ConsoleLogger) {
      this._defaultLogger.setLevel(level);
    }
    for (const logger2 of this._loggers.values()) {
      if (logger2 instanceof ConsoleLogger) {
        logger2.setLevel(level);
      }
    }
  }
  /**
   * 创建子日志器
   * @param parentName 父日志器名称
   * @param childName 子日志器名称
   * @returns 子日志器实例
   */
  createChildLogger(parentName, childName) {
    const fullName = `${parentName}.${childName}`;
    return this.getLogger(fullName);
  }
  /**
   * 设置全局颜色配置
   * @param colors 颜色配置
   */
  setGlobalColors(colors) {
    if (this._defaultLogger instanceof ConsoleLogger) {
      this._defaultLogger.setColors(colors);
    }
    for (const logger2 of this._loggers.values()) {
      if (logger2 instanceof ConsoleLogger) {
        logger2.setColors(colors);
      }
    }
  }
  /**
   * 重置为默认颜色配置
   */
  resetColors() {
    if (this._defaultLogger instanceof ConsoleLogger) {
      this._defaultLogger.setColors({});
    }
    for (const logger2 of this._loggers.values()) {
      if (logger2 instanceof ConsoleLogger) {
        logger2.setColors({});
      }
    }
  }
}
LoggerManager.getInstance().getLogger();
function createLogger(name) {
  return LoggerManager.getInstance().getLogger(name);
}
class SoAStorage {
  constructor(componentType) {
    this.fields = /* @__PURE__ */ new Map();
    this.stringFields = /* @__PURE__ */ new Map();
    this.serializedFields = /* @__PURE__ */ new Map();
    this.complexFields = /* @__PURE__ */ new Map();
    this.entityToIndex = /* @__PURE__ */ new Map();
    this.indexToEntity = [];
    this.freeIndices = [];
    this._size = 0;
    this._capacity = 1e3;
    this.type = componentType;
    this.initializeFields(componentType);
  }
  initializeFields(componentType) {
    const instance = new componentType();
    const highPrecisionFields = componentType.__highPrecisionFields || /* @__PURE__ */ new Set();
    const float64Fields = componentType.__float64Fields || /* @__PURE__ */ new Set();
    const float32Fields = componentType.__float32Fields || /* @__PURE__ */ new Set();
    const int32Fields = componentType.__int32Fields || /* @__PURE__ */ new Set();
    const serializeMapFields = componentType.__serializeMapFields || /* @__PURE__ */ new Set();
    const serializeSetFields = componentType.__serializeSetFields || /* @__PURE__ */ new Set();
    const serializeArrayFields = componentType.__serializeArrayFields || /* @__PURE__ */ new Set();
    for (const key in instance) {
      if (instance.hasOwnProperty(key) && key !== "id") {
        const value = instance[key];
        const type = typeof value;
        if (type === "number") {
          if (highPrecisionFields.has(key)) ;
          else if (float64Fields.has(key)) {
            this.fields.set(key, new Float64Array(this._capacity));
          } else if (int32Fields.has(key)) {
            this.fields.set(key, new Int32Array(this._capacity));
          } else if (float32Fields.has(key)) {
            this.fields.set(key, new Float32Array(this._capacity));
          } else {
            this.fields.set(key, new Float32Array(this._capacity));
          }
        } else if (type === "boolean") {
          this.fields.set(key, new Float32Array(this._capacity));
        } else if (type === "string") {
          this.stringFields.set(key, new Array(this._capacity));
        } else if (type === "object" && value !== null) {
          if (serializeMapFields.has(key) || serializeSetFields.has(key) || serializeArrayFields.has(key)) {
            this.serializedFields.set(key, new Array(this._capacity));
          }
        }
      }
    }
  }
  addComponent(entityId, component) {
    if (this.entityToIndex.has(entityId)) {
      const index2 = this.entityToIndex.get(entityId);
      this.updateComponentAtIndex(index2, component);
      return;
    }
    let index;
    if (this.freeIndices.length > 0) {
      index = this.freeIndices.pop();
    } else {
      index = this._size;
      if (index >= this._capacity) {
        this.resize(this._capacity * 2);
      }
    }
    this.entityToIndex.set(entityId, index);
    this.indexToEntity[index] = entityId;
    this.updateComponentAtIndex(index, component);
    this._size++;
  }
  updateComponentAtIndex(index, component) {
    const entityId = this.indexToEntity[index];
    const complexFieldMap = /* @__PURE__ */ new Map();
    const highPrecisionFields = this.type.__highPrecisionFields || /* @__PURE__ */ new Set();
    const serializeMapFields = this.type.__serializeMapFields || /* @__PURE__ */ new Set();
    const serializeSetFields = this.type.__serializeSetFields || /* @__PURE__ */ new Set();
    const serializeArrayFields = this.type.__serializeArrayFields || /* @__PURE__ */ new Set();
    const deepCopyFields = this.type.__deepCopyFields || /* @__PURE__ */ new Set();
    for (const key in component) {
      if (component.hasOwnProperty(key) && key !== "id") {
        const value = component[key];
        const type = typeof value;
        if (type === "number") {
          if (highPrecisionFields.has(key) || !this.fields.has(key)) {
            complexFieldMap.set(key, value);
          } else {
            const array = this.fields.get(key);
            array[index] = value;
          }
        } else if (type === "boolean" && this.fields.has(key)) {
          const array = this.fields.get(key);
          array[index] = value ? 1 : 0;
        } else if (this.stringFields.has(key)) {
          const stringArray = this.stringFields.get(key);
          stringArray[index] = String(value);
        } else if (this.serializedFields.has(key)) {
          const serializedArray = this.serializedFields.get(key);
          serializedArray[index] = this.serializeValue(value, key, serializeMapFields, serializeSetFields, serializeArrayFields);
        } else {
          if (deepCopyFields.has(key)) {
            complexFieldMap.set(key, this.deepClone(value));
          } else {
            complexFieldMap.set(key, value);
          }
        }
      }
    }
    if (complexFieldMap.size > 0) {
      this.complexFields.set(entityId, complexFieldMap);
    }
  }
  /**
   * 序列化值为JSON字符串
   */
  serializeValue(value, key, mapFields, setFields, arrayFields) {
    try {
      if (mapFields.has(key) && value instanceof Map) {
        return JSON.stringify(Array.from(value.entries()));
      } else if (setFields.has(key) && value instanceof Set) {
        return JSON.stringify(Array.from(value));
      } else if (arrayFields.has(key) && Array.isArray(value)) {
        return JSON.stringify(value);
      } else {
        return JSON.stringify(value);
      }
    } catch (error) {
      SoAStorage._logger.warn(`SoA序列化字段 ${key} 失败:`, error);
      return "{}";
    }
  }
  /**
   * 反序列化JSON字符串为值
   */
  deserializeValue(serialized, key, mapFields, setFields, arrayFields) {
    try {
      const parsed = JSON.parse(serialized);
      if (mapFields.has(key)) {
        return new Map(parsed);
      } else if (setFields.has(key)) {
        return new Set(parsed);
      } else if (arrayFields.has(key)) {
        return parsed;
      } else {
        return parsed;
      }
    } catch (error) {
      SoAStorage._logger.warn(`SoA反序列化字段 ${key} 失败:`, error);
      return null;
    }
  }
  /**
   * 深拷贝对象
   */
  deepClone(obj) {
    if (obj === null || typeof obj !== "object") {
      return obj;
    }
    if (obj instanceof Date) {
      return new Date(obj.getTime());
    }
    if (obj instanceof Array) {
      return obj.map((item) => this.deepClone(item));
    }
    if (obj instanceof Map) {
      const cloned2 = /* @__PURE__ */ new Map();
      for (const [key, value] of obj.entries()) {
        cloned2.set(key, this.deepClone(value));
      }
      return cloned2;
    }
    if (obj instanceof Set) {
      const cloned2 = /* @__PURE__ */ new Set();
      for (const value of obj.values()) {
        cloned2.add(this.deepClone(value));
      }
      return cloned2;
    }
    const cloned = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        cloned[key] = this.deepClone(obj[key]);
      }
    }
    return cloned;
  }
  getComponent(entityId) {
    const index = this.entityToIndex.get(entityId);
    if (index === void 0) {
      return null;
    }
    const component = new this.type();
    const serializeMapFields = this.type.__serializeMapFields || /* @__PURE__ */ new Set();
    const serializeSetFields = this.type.__serializeSetFields || /* @__PURE__ */ new Set();
    const serializeArrayFields = this.type.__serializeArrayFields || /* @__PURE__ */ new Set();
    for (const [fieldName, array] of this.fields.entries()) {
      const value = array[index];
      const fieldType = this.getFieldType(fieldName);
      if (fieldType === "boolean") {
        component[fieldName] = value === 1;
      } else {
        component[fieldName] = value;
      }
    }
    for (const [fieldName, stringArray] of this.stringFields.entries()) {
      component[fieldName] = stringArray[index];
    }
    for (const [fieldName, serializedArray] of this.serializedFields.entries()) {
      const serialized = serializedArray[index];
      if (serialized) {
        component[fieldName] = this.deserializeValue(serialized, fieldName, serializeMapFields, serializeSetFields, serializeArrayFields);
      }
    }
    const complexFieldMap = this.complexFields.get(entityId);
    if (complexFieldMap) {
      for (const [fieldName, value] of complexFieldMap.entries()) {
        component[fieldName] = value;
      }
    }
    return component;
  }
  getFieldType(fieldName) {
    const tempInstance = new this.type();
    const value = tempInstance[fieldName];
    return typeof value;
  }
  hasComponent(entityId) {
    return this.entityToIndex.has(entityId);
  }
  removeComponent(entityId) {
    const index = this.entityToIndex.get(entityId);
    if (index === void 0) {
      return null;
    }
    const component = this.getComponent(entityId);
    this.complexFields.delete(entityId);
    this.entityToIndex.delete(entityId);
    this.freeIndices.push(index);
    this._size--;
    return component;
  }
  resize(newCapacity) {
    for (const [fieldName, oldArray] of this.fields.entries()) {
      let newArray;
      if (oldArray instanceof Float32Array) {
        newArray = new Float32Array(newCapacity);
      } else if (oldArray instanceof Float64Array) {
        newArray = new Float64Array(newCapacity);
      } else {
        newArray = new Int32Array(newCapacity);
      }
      newArray.set(oldArray);
      this.fields.set(fieldName, newArray);
    }
    for (const [fieldName, oldArray] of this.stringFields.entries()) {
      const newArray = new Array(newCapacity);
      for (let i = 0; i < oldArray.length; i++) {
        newArray[i] = oldArray[i];
      }
      this.stringFields.set(fieldName, newArray);
    }
    for (const [fieldName, oldArray] of this.serializedFields.entries()) {
      const newArray = new Array(newCapacity);
      for (let i = 0; i < oldArray.length; i++) {
        newArray[i] = oldArray[i];
      }
      this.serializedFields.set(fieldName, newArray);
    }
    this._capacity = newCapacity;
  }
  getActiveIndices() {
    return Array.from(this.entityToIndex.values());
  }
  getFieldArray(fieldName) {
    return this.fields.get(fieldName) || null;
  }
  getTypedFieldArray(fieldName) {
    return this.fields.get(String(fieldName)) || null;
  }
  getEntityIndex(entityId) {
    return this.entityToIndex.get(entityId);
  }
  getEntityIdByIndex(index) {
    return this.indexToEntity[index];
  }
  size() {
    return this._size;
  }
  clear() {
    this.entityToIndex.clear();
    this.indexToEntity = [];
    this.freeIndices = [];
    this.complexFields.clear();
    this._size = 0;
    for (const array of this.fields.values()) {
      array.fill(0);
    }
    for (const stringArray of this.stringFields.values()) {
      for (let i = 0; i < stringArray.length; i++) {
        stringArray[i] = void 0;
      }
    }
    for (const serializedArray of this.serializedFields.values()) {
      for (let i = 0; i < serializedArray.length; i++) {
        serializedArray[i] = void 0;
      }
    }
  }
  compact() {
    if (this.freeIndices.length === 0) {
      return;
    }
    const activeEntries = Array.from(this.entityToIndex.entries()).sort((a, b) => a[1] - b[1]);
    const newEntityToIndex = /* @__PURE__ */ new Map();
    const newIndexToEntity = [];
    for (let newIndex = 0; newIndex < activeEntries.length; newIndex++) {
      const [entityId, oldIndex] = activeEntries[newIndex];
      newEntityToIndex.set(entityId, newIndex);
      newIndexToEntity[newIndex] = entityId;
      if (newIndex !== oldIndex) {
        for (const [, array] of this.fields.entries()) {
          array[newIndex] = array[oldIndex];
        }
        for (const [, stringArray] of this.stringFields.entries()) {
          stringArray[newIndex] = stringArray[oldIndex];
        }
        for (const [, serializedArray] of this.serializedFields.entries()) {
          serializedArray[newIndex] = serializedArray[oldIndex];
        }
      }
    }
    this.entityToIndex = newEntityToIndex;
    this.indexToEntity = newIndexToEntity;
    this.freeIndices = [];
    this._size = activeEntries.length;
  }
  getStats() {
    let totalMemory = 0;
    const fieldStats = /* @__PURE__ */ new Map();
    for (const [fieldName, array] of this.fields.entries()) {
      let bytesPerElement;
      let typeName;
      if (array instanceof Float32Array) {
        bytesPerElement = 4;
        typeName = "float32";
      } else if (array instanceof Float64Array) {
        bytesPerElement = 8;
        typeName = "float64";
      } else {
        bytesPerElement = 4;
        typeName = "int32";
      }
      const memory = array.length * bytesPerElement;
      totalMemory += memory;
      fieldStats.set(fieldName, {
        size: this._size,
        capacity: array.length,
        type: typeName,
        memory
      });
    }
    return {
      size: this._size,
      capacity: this._capacity,
      usedSlots: this._size,
      // 兼容原测试
      fragmentation: this.freeIndices.length / this._capacity,
      memoryUsage: totalMemory,
      fieldStats
    };
  }
  /**
   * 执行向量化批量操作
   * @param operation 操作函数，接收字段数组和活跃索引
   */
  performVectorizedOperation(operation) {
    const activeIndices = this.getActiveIndices();
    operation(this.fields, activeIndices);
  }
}
SoAStorage._logger = createLogger("SoAStorage");
const COMPONENT_TYPE_NAME = Symbol("ComponentTypeName");
const SYSTEM_TYPE_NAME = Symbol("SystemTypeName");
function ECSComponent(typeName) {
  return function(target) {
    if (!typeName || typeof typeName !== "string") {
      throw new Error("ECSComponent装饰器必须提供有效的类型名称");
    }
    target[COMPONENT_TYPE_NAME] = typeName;
    return target;
  };
}
function ECSSystem(typeName) {
  return function(target) {
    if (!typeName || typeof typeName !== "string") {
      throw new Error("ECSSystem装饰器必须提供有效的类型名称");
    }
    target[SYSTEM_TYPE_NAME] = typeName;
    return target;
  };
}
function getComponentTypeName(componentType) {
  const decoratorName = componentType[COMPONENT_TYPE_NAME];
  if (decoratorName) {
    return decoratorName;
  }
  return componentType.name || "UnknownComponent";
}
function getSystemTypeName(systemType) {
  const decoratorName = systemType[SYSTEM_TYPE_NAME];
  if (decoratorName) {
    return decoratorName;
  }
  return systemType.name || "UnknownSystem";
}
function getComponentInstanceTypeName(component) {
  return getComponentTypeName(component.constructor);
}
function getSystemInstanceTypeName(system) {
  return getSystemTypeName(system.constructor);
}
class ComponentRegistry {
  /**
   * 注册组件类型并分配位掩码
   * @param componentType 组件类型
   * @returns 分配的位索引
   */
  static register(componentType) {
    const typeName = getComponentTypeName(componentType);
    if (this.componentTypes.has(componentType)) {
      const existingIndex = this.componentTypes.get(componentType);
      return existingIndex;
    }
    if (this.nextBitIndex >= this.maxComponents) {
      throw new Error(`Maximum number of component types (${this.maxComponents}) exceeded`);
    }
    const bitIndex = this.nextBitIndex++;
    this.componentTypes.set(componentType, bitIndex);
    this.componentNameToType.set(typeName, componentType);
    this.componentNameToId.set(typeName, bitIndex);
    return bitIndex;
  }
  /**
   * 获取组件类型的位掩码
   * @param componentType 组件类型
   * @returns 位掩码
   */
  static getBitMask(componentType) {
    const bitIndex = this.componentTypes.get(componentType);
    if (bitIndex === void 0) {
      const typeName = getComponentTypeName(componentType);
      throw new Error(`Component type ${typeName} is not registered`);
    }
    return BitMask64Utils.create(bitIndex);
  }
  /**
   * 获取组件类型的位索引
   * @param componentType 组件类型
   * @returns 位索引
   */
  static getBitIndex(componentType) {
    const bitIndex = this.componentTypes.get(componentType);
    if (bitIndex === void 0) {
      const typeName = getComponentTypeName(componentType);
      throw new Error(`Component type ${typeName} is not registered`);
    }
    return bitIndex;
  }
  /**
   * 检查组件类型是否已注册
   * @param componentType 组件类型
   * @returns 是否已注册
   */
  static isRegistered(componentType) {
    return this.componentTypes.has(componentType);
  }
  /**
   * 通过名称获取组件类型
   * @param componentName 组件名称
   * @returns 组件类型构造函数
   */
  static getComponentType(componentName) {
    return this.componentNameToType.get(componentName) || null;
  }
  /**
   * 获取所有已注册的组件类型
   * @returns 组件类型映射
   */
  static getAllRegisteredTypes() {
    return new Map(this.componentTypes);
  }
  /**
   * 获取所有组件名称到类型的映射
   * @returns 名称到类型的映射
   */
  static getAllComponentNames() {
    return new Map(this.componentNameToType);
  }
  /**
   * 通过名称获取组件类型ID
   * @param componentName 组件名称
   * @returns 组件类型ID
   */
  static getComponentId(componentName) {
    return this.componentNameToId.get(componentName);
  }
  /**
   * 注册组件类型（通过名称）
   * @param componentName 组件名称
   * @returns 分配的组件ID
   */
  static registerComponentByName(componentName) {
    if (this.componentNameToId.has(componentName)) {
      return this.componentNameToId.get(componentName);
    }
    if (this.nextBitIndex >= this.maxComponents) {
      throw new Error(`Maximum number of component types (${this.maxComponents}) exceeded`);
    }
    const bitIndex = this.nextBitIndex++;
    this.componentNameToId.set(componentName, bitIndex);
    return bitIndex;
  }
  /**
   * 创建单个组件的掩码
   * @param componentName 组件名称
   * @returns 组件掩码
   */
  static createSingleComponentMask(componentName) {
    const cacheKey = `single:${componentName}`;
    if (this.maskCache.has(cacheKey)) {
      return this.maskCache.get(cacheKey);
    }
    const componentId = this.getComponentId(componentName);
    if (componentId === void 0) {
      throw new Error(`Component type ${componentName} is not registered`);
    }
    const mask = BitMask64Utils.create(componentId);
    this.maskCache.set(cacheKey, mask);
    return mask;
  }
  /**
   * 创建多个组件的掩码
   * @param componentNames 组件名称数组
   * @returns 组合掩码
   */
  static createComponentMask(componentNames) {
    const sortedNames = [...componentNames].sort();
    const cacheKey = `multi:${sortedNames.join(",")}`;
    if (this.maskCache.has(cacheKey)) {
      return this.maskCache.get(cacheKey);
    }
    let mask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    for (const name of componentNames) {
      const componentId = this.getComponentId(name);
      if (componentId !== void 0) {
        const componentMask = BitMask64Utils.create(componentId);
        BitMask64Utils.orInPlace(mask, componentMask);
      }
    }
    this.maskCache.set(cacheKey, mask);
    return mask;
  }
  /**
   * 清除掩码缓存
   */
  static clearMaskCache() {
    this.maskCache.clear();
  }
  /**
   * 重置注册表（用于测试）
   */
  static reset() {
    this.componentTypes.clear();
    this.componentNameToType.clear();
    this.componentNameToId.clear();
    this.maskCache.clear();
    this.nextBitIndex = 0;
  }
}
ComponentRegistry._logger = createLogger("ComponentStorage");
ComponentRegistry.componentTypes = /* @__PURE__ */ new Map();
ComponentRegistry.componentNameToType = /* @__PURE__ */ new Map();
ComponentRegistry.componentNameToId = /* @__PURE__ */ new Map();
ComponentRegistry.maskCache = /* @__PURE__ */ new Map();
ComponentRegistry.nextBitIndex = 0;
ComponentRegistry.maxComponents = 64;
class ComponentStorage {
  constructor(componentType) {
    this.dense = [];
    this.entityIds = [];
    this.entityToIndex = /* @__PURE__ */ new Map();
    this.componentType = componentType;
    if (!ComponentRegistry.isRegistered(componentType)) {
      ComponentRegistry.register(componentType);
    }
  }
  /**
   * 添加组件
   * @param entityId 实体ID
   * @param component 组件实例
   */
  addComponent(entityId, component) {
    if (this.entityToIndex.has(entityId)) {
      throw new Error(`Entity ${entityId} already has component ${getComponentTypeName(this.componentType)}`);
    }
    const index = this.dense.length;
    this.dense.push(component);
    this.entityIds.push(entityId);
    this.entityToIndex.set(entityId, index);
  }
  /**
   * 获取组件
   * @param entityId 实体ID
   * @returns 组件实例或null
   */
  getComponent(entityId) {
    const index = this.entityToIndex.get(entityId);
    return index !== void 0 ? this.dense[index] : null;
  }
  /**
   * 检查实体是否有此组件
   * @param entityId 实体ID
   * @returns 是否有组件
   */
  hasComponent(entityId) {
    return this.entityToIndex.has(entityId);
  }
  /**
   * 移除组件
   * @param entityId 实体ID
   * @returns 被移除的组件或null
   */
  removeComponent(entityId) {
    const index = this.entityToIndex.get(entityId);
    if (index === void 0) {
      return null;
    }
    const component = this.dense[index];
    const lastIndex = this.dense.length - 1;
    if (index !== lastIndex) {
      const lastComponent = this.dense[lastIndex];
      const lastEntityId = this.entityIds[lastIndex];
      this.dense[index] = lastComponent;
      this.entityIds[index] = lastEntityId;
      this.entityToIndex.set(lastEntityId, index);
    }
    this.dense.pop();
    this.entityIds.pop();
    this.entityToIndex.delete(entityId);
    return component;
  }
  /**
   * 高效遍历所有组件
   * @param callback 回调函数
   */
  forEach(callback) {
    for (let i = 0; i < this.dense.length; i++) {
      callback(this.dense[i], this.entityIds[i], i);
    }
  }
  /**
   * 获取所有组件
   * @returns 组件数组
   */
  getDenseArray() {
    return {
      components: [...this.dense],
      entityIds: [...this.entityIds]
    };
  }
  /**
   * 清空所有组件
   */
  clear() {
    this.dense.length = 0;
    this.entityIds.length = 0;
    this.entityToIndex.clear();
  }
  /**
   * 获取组件数量
   */
  get size() {
    return this.dense.length;
  }
  /**
   * 获取组件类型
   */
  get type() {
    return this.componentType;
  }
  /**
   * 获取存储统计信息
   */
  getStats() {
    const totalSlots = this.dense.length;
    const usedSlots = this.dense.length;
    const freeSlots = 0;
    const fragmentation = 0;
    return {
      totalSlots,
      usedSlots,
      freeSlots,
      fragmentation
    };
  }
}
class ComponentStorageManager {
  constructor() {
    this.storages = /* @__PURE__ */ new Map();
  }
  /**
   * 检查组件类型是否启用SoA存储
   * @param componentType 组件类型
   * @returns 是否为SoA存储
   */
  isSoAStorage(componentType) {
    const storage = this.storages.get(componentType);
    return storage instanceof SoAStorage;
  }
  /**
   * 获取SoA存储器（类型安全）
   * @param componentType 组件类型
   * @returns SoA存储器或null
   */
  getSoAStorage(componentType) {
    const storage = this.getStorage(componentType);
    return storage instanceof SoAStorage ? storage : null;
  }
  /**
   * 直接获取SoA字段数组（类型安全）
   * @param componentType 组件类型
   * @param fieldName 字段名
   * @returns TypedArray或null
   */
  getFieldArray(componentType, fieldName) {
    const soaStorage = this.getSoAStorage(componentType);
    return soaStorage ? soaStorage.getFieldArray(fieldName) : null;
  }
  /**
   * 直接获取SoA字段数组（类型安全，带字段名检查）
   * @param componentType 组件类型
   * @param fieldName 字段名（类型检查）
   * @returns TypedArray或null
   */
  getTypedFieldArray(componentType, fieldName) {
    const soaStorage = this.getSoAStorage(componentType);
    return soaStorage ? soaStorage.getTypedFieldArray(fieldName) : null;
  }
  /**
   * 获取SoA存储的活跃索引
   * @param componentType 组件类型
   * @returns 活跃索引数组或空数组
   */
  getActiveIndices(componentType) {
    const soaStorage = this.getSoAStorage(componentType);
    return soaStorage ? soaStorage.getActiveIndices() : [];
  }
  /**
   * 获取实体在SoA存储中的索引
   * @param componentType 组件类型
   * @param entityId 实体ID
   * @returns 存储索引或undefined
   */
  getEntityIndex(componentType, entityId) {
    const soaStorage = this.getSoAStorage(componentType);
    return soaStorage ? soaStorage.getEntityIndex(entityId) : void 0;
  }
  /**
   * 根据索引获取实体ID
   * @param componentType 组件类型
   * @param index 存储索引
   * @returns 实体ID或undefined
   */
  getEntityIdByIndex(componentType, index) {
    const soaStorage = this.getSoAStorage(componentType);
    return soaStorage ? soaStorage.getEntityIdByIndex(index) : void 0;
  }
  /**
   * 获取或创建组件存储器（默认原始存储）
   * @param componentType 组件类型
   * @returns 组件存储器
   */
  getStorage(componentType) {
    let storage = this.storages.get(componentType);
    if (!storage) {
      const enableSoA = componentType.__enableSoA;
      if (enableSoA) {
        storage = new SoAStorage(componentType);
        ComponentStorageManager._logger.info(`为 ${getComponentTypeName(componentType)} 启用SoA优化（适用于大规模批量操作）`);
      } else {
        storage = new ComponentStorage(componentType);
      }
      this.storages.set(componentType, storage);
    }
    return storage;
  }
  /**
   * 添加组件
   * @param entityId 实体ID
   * @param component 组件实例
   */
  addComponent(entityId, component) {
    const componentType = component.constructor;
    const storage = this.getStorage(componentType);
    storage.addComponent(entityId, component);
  }
  /**
   * 获取组件
   * @param entityId 实体ID
   * @param componentType 组件类型
   * @returns 组件实例或null
   */
  getComponent(entityId, componentType) {
    const storage = this.storages.get(componentType);
    return storage ? storage.getComponent(entityId) : null;
  }
  /**
   * 检查实体是否有组件
   * @param entityId 实体ID
   * @param componentType 组件类型
   * @returns 是否有组件
   */
  hasComponent(entityId, componentType) {
    const storage = this.storages.get(componentType);
    return storage ? storage.hasComponent(entityId) : false;
  }
  /**
   * 移除组件
   * @param entityId 实体ID
   * @param componentType 组件类型
   * @returns 被移除的组件或null
   */
  removeComponent(entityId, componentType) {
    const storage = this.storages.get(componentType);
    return storage ? storage.removeComponent(entityId) : null;
  }
  /**
   * 移除实体的所有组件
   * @param entityId 实体ID
   */
  removeAllComponents(entityId) {
    for (const storage of this.storages.values()) {
      storage.removeComponent(entityId);
    }
  }
  /**
   * 获取实体的组件位掩码
   * @param entityId 实体ID
   * @returns 组件位掩码
   */
  getComponentMask(entityId) {
    let mask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    for (const [componentType, storage] of this.storages.entries()) {
      if (storage.hasComponent(entityId)) {
        const componentMask = ComponentRegistry.getBitMask(componentType);
        BitMask64Utils.orInPlace(mask, componentMask);
      }
    }
    return mask;
  }
  /**
   * 获取所有存储器的统计信息
   */
  getAllStats() {
    const stats = /* @__PURE__ */ new Map();
    for (const [componentType, storage] of this.storages.entries()) {
      const typeName = getComponentTypeName(componentType);
      stats.set(typeName, storage.getStats());
    }
    return stats;
  }
  /**
   * 清空所有存储器
   */
  clear() {
    for (const storage of this.storages.values()) {
      storage.clear();
    }
    this.storages.clear();
  }
}
ComponentStorageManager._logger = createLogger("ComponentStorage");
class EntityComparer {
  /**
   * 比较两个实体
   *
   * @param self - 第一个实体
   * @param other - 第二个实体
   * @returns 比较结果，负数表示self优先级更高，正数表示other优先级更高，0表示相等
   */
  compare(self2, other) {
    let compare = self2.updateOrder - other.updateOrder;
    if (compare == 0)
      compare = self2.id - other.id;
    return compare;
  }
}
class Entity {
  /**
   * 通知Scene中的QuerySystem实体组件发生变动
   *
   * @param entity 发生组件变动的实体
   */
  static notifyQuerySystems(entity) {
    if (entity.scene && entity.scene.querySystem) {
      entity.scene.querySystem.updateEntity(entity);
      entity.scene.clearSystemEntityCaches();
    }
  }
  /**
   * 构造函数
   *
   * @param name - 实体名称
   * @param id - 实体唯一标识符
   */
  constructor(name, id) {
    this.components = [];
    this.scene = null;
    this.updateInterval = 1;
    this._isDestroyed = false;
    this._parent = null;
    this._children = [];
    this._active = true;
    this._tag = 0;
    this._enabled = true;
    this._updateOrder = 0;
    this._componentMask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    this._componentsByTypeId = [];
    this._componentDenseIndexByTypeId = [];
    this.name = name;
    this.id = id;
  }
  /**
   * 获取销毁状态
   * @returns 如果实体已被销毁则返回true
   */
  get isDestroyed() {
    return this._isDestroyed;
  }
  /**
   * 获取父实体
   * @returns 父实体，如果没有父实体则返回null
   */
  get parent() {
    return this._parent;
  }
  /**
   * 获取子实体数组的只读副本
   *
   * @returns 子实体数组的副本
   */
  get children() {
    return [...this._children];
  }
  /**
   * 获取子实体数量
   *
   * @returns 子实体的数量
   */
  get childCount() {
    return this._children.length;
  }
  /**
   * 获取活跃状态
   *
   * @returns 如果实体处于活跃状态则返回true
   */
  get active() {
    return this._active;
  }
  /**
   * 设置活跃状态
   *
   * 设置实体的活跃状态，会影响子实体的有效活跃状态。
   *
   * @param value - 新的活跃状态
   */
  set active(value) {
    if (this._active !== value) {
      this._active = value;
      this.onActiveChanged();
    }
  }
  /**
   * 获取实体的有效活跃状态
   *
   * 考虑父实体的活跃状态，只有当实体本身和所有父实体都处于活跃状态时才返回true。
   *
   * @returns 有效的活跃状态
   */
  get activeInHierarchy() {
    if (!this._active)
      return false;
    if (this._parent)
      return this._parent.activeInHierarchy;
    return true;
  }
  /**
   * 获取实体标签
   *
   * @returns 实体的数字标签
   */
  get tag() {
    return this._tag;
  }
  /**
   * 设置实体标签
   *
   * @param value - 新的标签值
   */
  set tag(value) {
    this._tag = value;
  }
  /**
   * 获取启用状态
   *
   * @returns 如果实体已启用则返回true
   */
  get enabled() {
    return this._enabled;
  }
  /**
   * 设置启用状态
   *
   * @param value - 新的启用状态
   */
  set enabled(value) {
    this._enabled = value;
  }
  /**
   * 获取更新顺序
   *
   * @returns 实体的更新顺序值
   */
  get updateOrder() {
    return this._updateOrder;
  }
  /**
   * 设置更新顺序
   *
   * @param value - 新的更新顺序值
   */
  set updateOrder(value) {
    this._updateOrder = value;
  }
  /**
   * 获取组件位掩码
   *
   * @returns 实体的组件位掩码
   */
  get componentMask() {
    return this._componentMask;
  }
  /**
   * 创建并添加组件
   *
   * @param componentType - 组件类型
   * @param args - 组件构造函数参数
   * @returns 创建的组件实例
   */
  createComponent(componentType, ...args) {
    const component = new componentType(...args);
    return this.addComponent(component);
  }
  /**
   * 内部添加组件方法（不进行重复检查，用于初始化）
   *
   * @param component - 要添加的组件实例
   * @returns 添加的组件实例
   */
  addComponentInternal(component) {
    const componentType = component.constructor;
    if (!ComponentRegistry.isRegistered(componentType)) {
      ComponentRegistry.register(componentType);
    }
    const typeId = ComponentRegistry.getBitIndex(componentType);
    component.entity = this;
    this._componentsByTypeId[typeId] = component;
    const denseIndex = this.components.length;
    this._componentDenseIndexByTypeId[typeId] = denseIndex;
    this.components.push(component);
    const componentMask = ComponentRegistry.getBitMask(componentType);
    BitMask64Utils.orInPlace(this._componentMask, componentMask);
    return component;
  }
  /**
   * 添加组件到实体
   *
   * @param component - 要添加的组件实例
   * @returns 添加的组件实例
   * @throws {Error} 如果组件类型已存在
   */
  addComponent(component) {
    const componentType = component.constructor;
    if (this.hasComponent(componentType)) {
      throw new Error(`Entity ${this.name} already has component ${getComponentTypeName(componentType)}`);
    }
    this.addComponentInternal(component);
    if (this.scene && this.scene.componentStorageManager) {
      this.scene.componentStorageManager.addComponent(this.id, component);
    }
    component.onAddedToEntity();
    if (Entity.eventBus) {
      Entity.eventBus.emitComponentAdded({
        timestamp: Date.now(),
        source: "Entity",
        entityId: this.id,
        entityName: this.name,
        entityTag: this.tag?.toString(),
        componentType: getComponentTypeName(componentType),
        component
      });
    }
    Entity.notifyQuerySystems(this);
    return component;
  }
  /**
   * 获取指定类型的组件
   *
   * @param type - 组件类型
   * @returns 组件实例或null
   */
  getComponent(type) {
    if (!ComponentRegistry.isRegistered(type)) {
      return null;
    }
    const mask = ComponentRegistry.getBitMask(type);
    if (BitMask64Utils.hasNone(this._componentMask, mask)) {
      return null;
    }
    const typeId = ComponentRegistry.getBitIndex(type);
    const component = this._componentsByTypeId[typeId];
    if (component && component.constructor === type) {
      return component;
    }
    if (this.scene && this.scene.componentStorageManager) {
      const storageComponent = this.scene.componentStorageManager.getComponent(this.id, type);
      if (storageComponent) {
        this._componentsByTypeId[typeId] = storageComponent;
        if (!this.components.includes(storageComponent)) {
          const denseIndex = this.components.length;
          this._componentDenseIndexByTypeId[typeId] = denseIndex;
          this.components.push(storageComponent);
        }
        return storageComponent;
      }
    }
    for (let i = 0; i < this.components.length; i++) {
      const component2 = this.components[i];
      if (component2 instanceof type) {
        this._componentsByTypeId[typeId] = component2;
        this._componentDenseIndexByTypeId[typeId] = i;
        return component2;
      }
    }
    return null;
  }
  /**
   * 检查实体是否有指定类型的组件
   *
   * @param type - 组件类型
   * @returns 如果有该组件则返回true
   */
  hasComponent(type) {
    if (!ComponentRegistry.isRegistered(type)) {
      return false;
    }
    const mask = ComponentRegistry.getBitMask(type);
    return BitMask64Utils.hasAny(this._componentMask, mask);
  }
  /**
   * 获取或创建指定类型的组件
   *
   * @param type - 组件类型
   * @param args - 组件构造函数参数（仅在创建时使用）
   * @returns 组件实例
   */
  getOrCreateComponent(type, ...args) {
    let component = this.getComponent(type);
    if (!component) {
      component = this.createComponent(type, ...args);
    }
    return component;
  }
  /**
   * 移除指定的组件
   *
   * @param component - 要移除的组件实例
   */
  removeComponent(component) {
    const componentType = component.constructor;
    if (!ComponentRegistry.isRegistered(componentType)) {
      return;
    }
    const typeId = ComponentRegistry.getBitIndex(componentType);
    this._componentsByTypeId[typeId] = void 0;
    BitMask64Utils.clearBit(this._componentMask, typeId);
    const denseIndex = this._componentDenseIndexByTypeId[typeId];
    if (denseIndex !== void 0 && denseIndex < this.components.length) {
      const lastIndex = this.components.length - 1;
      if (denseIndex !== lastIndex) {
        const lastComponent = this.components[lastIndex];
        this.components[denseIndex] = lastComponent;
        const lastComponentType = lastComponent.constructor;
        const lastTypeId = ComponentRegistry.getBitIndex(lastComponentType);
        this._componentDenseIndexByTypeId[lastTypeId] = denseIndex;
      }
      this.components.pop();
    }
    this._componentDenseIndexByTypeId[typeId] = -1;
    if (this.scene && this.scene.componentStorageManager) {
      this.scene.componentStorageManager.removeComponent(this.id, componentType);
    }
    if (component.onRemovedFromEntity) {
      component.onRemovedFromEntity();
    }
    if (Entity.eventBus) {
      Entity.eventBus.emitComponentRemoved({
        timestamp: Date.now(),
        source: "Entity",
        entityId: this.id,
        entityName: this.name,
        entityTag: this.tag?.toString(),
        componentType: getComponentTypeName(componentType),
        component
      });
    }
    component.entity = null;
    Entity.notifyQuerySystems(this);
  }
  /**
   * 移除指定类型的组件
   *
   * @param type - 组件类型
   * @returns 被移除的组件实例或null
   */
  removeComponentByType(type) {
    const component = this.getComponent(type);
    if (component) {
      this.removeComponent(component);
      return component;
    }
    return null;
  }
  /**
   * 移除所有组件
   */
  removeAllComponents() {
    const componentsToRemove = [...this.components];
    this._componentsByTypeId.length = 0;
    this._componentDenseIndexByTypeId.length = 0;
    BitMask64Utils.clear(this._componentMask);
    for (const component of componentsToRemove) {
      const componentType = component.constructor;
      if (this.scene && this.scene.componentStorageManager) {
        this.scene.componentStorageManager.removeComponent(this.id, componentType);
      }
      component.onRemovedFromEntity();
      component.entity = null;
    }
    this.components.length = 0;
    Entity.notifyQuerySystems(this);
  }
  /**
   * 批量添加组件
   *
   * @param components - 要添加的组件数组
   * @returns 添加的组件数组
   */
  addComponents(components) {
    const addedComponents = [];
    for (const component of components) {
      try {
        addedComponents.push(this.addComponent(component));
      } catch (error) {
        Entity._logger.warn(`添加组件失败 ${getComponentInstanceTypeName(component)}:`, error);
      }
    }
    return addedComponents;
  }
  /**
   * 批量移除组件类型
   *
   * @param componentTypes - 要移除的组件类型数组
   * @returns 被移除的组件数组
   */
  removeComponentsByTypes(componentTypes) {
    const removedComponents = [];
    for (const componentType of componentTypes) {
      removedComponents.push(this.removeComponentByType(componentType));
    }
    return removedComponents;
  }
  /**
   * 获取所有指定类型的组件
   *
   * @param type - 组件类型
   * @returns 组件实例数组
   */
  getComponents(type) {
    const result = [];
    for (const component of this.components) {
      if (component instanceof type) {
        result.push(component);
      }
    }
    return result;
  }
  /**
   * 添加子实体
   *
   * @param child - 要添加的子实体
   * @returns 添加的子实体
   */
  addChild(child) {
    if (child === this) {
      throw new Error("Entity cannot be its own child");
    }
    if (child._parent === this) {
      return child;
    }
    if (child._parent) {
      child._parent.removeChild(child);
    }
    child._parent = this;
    this._children.push(child);
    if (!child.scene && this.scene) {
      child.scene = this.scene;
      this.scene.addEntity(child);
    }
    return child;
  }
  /**
   * 移除子实体
   *
   * @param child - 要移除的子实体
   * @returns 是否成功移除
   */
  removeChild(child) {
    const index = this._children.indexOf(child);
    if (index === -1) {
      return false;
    }
    this._children.splice(index, 1);
    child._parent = null;
    return true;
  }
  /**
   * 移除所有子实体
   */
  removeAllChildren() {
    const childrenToRemove = [...this._children];
    for (const child of childrenToRemove) {
      this.removeChild(child);
    }
  }
  /**
   * 根据名称查找子实体
   *
   * @param name - 子实体名称
   * @param recursive - 是否递归查找
   * @returns 找到的子实体或null
   */
  findChild(name, recursive = false) {
    for (const child of this._children) {
      if (child.name === name) {
        return child;
      }
    }
    if (recursive) {
      for (const child of this._children) {
        const found = child.findChild(name, true);
        if (found) {
          return found;
        }
      }
    }
    return null;
  }
  /**
   * 根据标签查找子实体
   *
   * @param tag - 标签
   * @param recursive - 是否递归查找
   * @returns 找到的子实体数组
   */
  findChildrenByTag(tag, recursive = false) {
    const result = [];
    for (const child of this._children) {
      if (child.tag === tag) {
        result.push(child);
      }
    }
    if (recursive) {
      for (const child of this._children) {
        result.push(...child.findChildrenByTag(tag, true));
      }
    }
    return result;
  }
  /**
   * 获取根实体
   *
   * @returns 层次结构的根实体
   */
  getRoot() {
    let root = this;
    while (root._parent) {
      root = root._parent;
    }
    return root;
  }
  /**
   * 检查是否是指定实体的祖先
   *
   * @param entity - 要检查的实体
   * @returns 如果是祖先则返回true
   */
  isAncestorOf(entity) {
    let current = entity._parent;
    while (current) {
      if (current === this) {
        return true;
      }
      current = current._parent;
    }
    return false;
  }
  /**
   * 检查是否是指定实体的后代
   *
   * @param entity - 要检查的实体
   * @returns 如果是后代则返回true
   */
  isDescendantOf(entity) {
    return entity.isAncestorOf(this);
  }
  /**
   * 获取层次深度
   *
   * @returns 在层次结构中的深度（根实体为0）
   */
  getDepth() {
    let depth = 0;
    let current = this._parent;
    while (current) {
      depth++;
      current = current._parent;
    }
    return depth;
  }
  /**
   * 遍历所有子实体（深度优先）
   *
   * @param callback - 对每个子实体执行的回调函数
   * @param recursive - 是否递归遍历
   */
  forEachChild(callback, recursive = false) {
    this._children.forEach((child, index) => {
      callback(child, index);
      if (recursive) {
        child.forEachChild(callback, true);
      }
    });
  }
  /**
   * 活跃状态改变时的回调
   */
  onActiveChanged() {
    for (const component of this.components) {
      if ("onActiveChanged" in component && typeof component.onActiveChanged === "function") {
        component.onActiveChanged();
      }
    }
    if (this.scene && this.scene.eventSystem) {
      this.scene.eventSystem.emitSync("entity:activeChanged", {
        entity: this,
        active: this._active,
        activeInHierarchy: this.activeInHierarchy
      });
    }
  }
  /**
   * 更新实体
   *
   * 调用所有组件的更新方法，并更新子实体。
   */
  update() {
    if (!this.activeInHierarchy || this._isDestroyed) {
      return;
    }
    for (const component of this.components) {
      if (component.enabled) {
        component.update();
      }
    }
    for (const child of this._children) {
      child.update();
    }
  }
  /**
   * 销毁实体
   *
   * 移除所有组件、子实体并标记为已销毁。
   */
  destroy() {
    if (this._isDestroyed) {
      return;
    }
    this._isDestroyed = true;
    const childrenToDestroy = [...this._children];
    for (const child of childrenToDestroy) {
      child.destroy();
    }
    if (this._parent) {
      this._parent.removeChild(this);
    }
    this.removeAllComponents();
    if (this.scene) {
      if (this.scene.querySystem) {
        this.scene.querySystem.removeEntity(this);
      }
      if (this.scene.entities) {
        this.scene.entities.remove(this);
      }
    }
  }
  /**
   * 比较实体
   *
   * @param other - 另一个实体
   * @returns 比较结果
   */
  compareTo(other) {
    return EntityComparer.prototype.compare(this, other);
  }
  /**
   * 获取实体的字符串表示
   *
   * @returns 实体的字符串描述
   */
  toString() {
    return `Entity[${this.name}:${this.id}]`;
  }
  /**
   * 获取实体的调试信息（包含组件缓存信息）
   *
   * @returns 包含实体详细信息的对象
   */
  getDebugInfo() {
    return {
      name: this.name,
      id: this.id,
      enabled: this._enabled,
      active: this._active,
      activeInHierarchy: this.activeInHierarchy,
      destroyed: this._isDestroyed,
      componentCount: this.components.length,
      componentTypes: this.components.map((c) => getComponentInstanceTypeName(c)),
      componentMask: BitMask64Utils.toString(this._componentMask, 2),
      // 二进制表示
      parentId: this._parent?.id || null,
      childCount: this._children.length,
      childIds: this._children.map((c) => c.id),
      depth: this.getDepth(),
      indexMappingSize: this._componentsByTypeId.filter((c) => c !== void 0).length,
      denseIndexMappingSize: this._componentDenseIndexByTypeId.filter((idx) => idx !== -1 && idx !== void 0).length
    };
  }
}
Entity._logger = createLogger("Entity");
Entity.entityComparer = new EntityComparer();
Entity.eventBus = null;
class EntityBuilder {
  constructor(scene, storageManager) {
    this.scene = scene;
    this.storageManager = storageManager;
    this.entity = new Entity("", scene.identifierPool.checkOut());
  }
  /**
   * 设置实体名称
   * @param name 实体名称
   * @returns 实体构建器
   */
  named(name) {
    this.entity.name = name;
    return this;
  }
  /**
   * 设置实体标签
   * @param tag 标签
   * @returns 实体构建器
   */
  tagged(tag) {
    this.entity.tag = tag;
    return this;
  }
  /**
   * 添加组件
   * @param component 组件实例
   * @returns 实体构建器
   */
  with(component) {
    this.entity.addComponent(component);
    return this;
  }
  /**
   * 添加多个组件
   * @param components 组件数组
   * @returns 实体构建器
   */
  withComponents(...components) {
    for (const component of components) {
      this.entity.addComponent(component);
    }
    return this;
  }
  /**
   * 条件性添加组件
   * @param condition 条件
   * @param component 组件实例
   * @returns 实体构建器
   */
  withIf(condition, component) {
    if (condition) {
      this.entity.addComponent(component);
    }
    return this;
  }
  /**
   * 使用工厂函数创建并添加组件
   * @param factory 组件工厂函数
   * @returns 实体构建器
   */
  withFactory(factory) {
    const component = factory();
    this.entity.addComponent(component);
    return this;
  }
  /**
   * 配置组件属性
   * @param componentType 组件类型
   * @param configurator 配置函数
   * @returns 实体构建器
   */
  configure(componentType, configurator) {
    const component = this.entity.getComponent(componentType);
    if (component) {
      configurator(component);
    }
    return this;
  }
  /**
   * 设置实体为启用状态
   * @param enabled 是否启用
   * @returns 实体构建器
   */
  enabled(enabled = true) {
    this.entity.enabled = enabled;
    return this;
  }
  /**
   * 设置实体为活跃状态
   * @param active 是否活跃
   * @returns 实体构建器
   */
  active(active = true) {
    this.entity.active = active;
    return this;
  }
  /**
   * 添加子实体
   * @param childBuilder 子实体构建器
   * @returns 实体构建器
   */
  withChild(childBuilder) {
    const child = childBuilder.build();
    this.entity.addChild(child);
    return this;
  }
  /**
   * 批量添加子实体
   * @param childBuilders 子实体构建器数组
   * @returns 实体构建器
   */
  withChildren(...childBuilders) {
    for (const childBuilder of childBuilders) {
      const child = childBuilder.build();
      this.entity.addChild(child);
    }
    return this;
  }
  /**
   * 使用工厂函数创建子实体
   * @param childFactory 子实体工厂函数
   * @returns 实体构建器
   */
  withChildFactory(childFactory) {
    const childBuilder = childFactory(this.entity);
    const child = childBuilder.build();
    this.entity.addChild(child);
    return this;
  }
  /**
   * 条件性添加子实体
   * @param condition 条件
   * @param childBuilder 子实体构建器
   * @returns 实体构建器
   */
  withChildIf(condition, childBuilder) {
    if (condition) {
      const child = childBuilder.build();
      this.entity.addChild(child);
    }
    return this;
  }
  /**
   * 构建并返回实体
   * @returns 构建的实体
   */
  build() {
    return this.entity;
  }
  /**
   * 构建实体并添加到场景
   * @returns 构建的实体
   */
  spawn() {
    this.scene.addEntity(this.entity);
    return this.entity;
  }
  /**
   * 克隆当前构建器
   * @returns 新的实体构建器
   */
  clone() {
    const newBuilder = new EntityBuilder(this.scene, this.storageManager);
    newBuilder.entity = this.entity;
    return newBuilder;
  }
}
class EntityList {
  get count() {
    return this.buffer.length;
  }
  constructor(scene) {
    this.buffer = [];
    this._idToEntity = /* @__PURE__ */ new Map();
    this._nameToEntities = /* @__PURE__ */ new Map();
    this._entitiesToAdd = [];
    this._entitiesToRemove = [];
    this._isUpdating = false;
    this._enableEntityDirectUpdate = false;
    this._scene = scene;
  }
  /**
   * 设置是否启用实体直接更新
   */
  setEnableEntityDirectUpdate(enabled) {
    this._enableEntityDirectUpdate = enabled;
  }
  /**
   * 添加实体（立即添加或延迟添加）
   * @param entity 要添加的实体
   */
  add(entity) {
    if (this._isUpdating) {
      this._entitiesToAdd.push(entity);
    } else {
      this.addImmediate(entity);
    }
  }
  /**
   * 立即添加实体
   * @param entity 要添加的实体
   */
  addImmediate(entity) {
    if (this._idToEntity.has(entity.id)) {
      return;
    }
    this.buffer.push(entity);
    this._idToEntity.set(entity.id, entity);
    this.updateNameIndex(entity, true);
  }
  /**
   * 移除实体（立即移除或延迟移除）
   * @param entity 要移除的实体
   */
  remove(entity) {
    if (this._isUpdating) {
      this._entitiesToRemove.push(entity);
    } else {
      this.removeImmediate(entity);
    }
  }
  /**
   * 立即移除实体
   * @param entity 要移除的实体
   */
  removeImmediate(entity) {
    const index = this.buffer.indexOf(entity);
    if (index !== -1) {
      this.buffer.splice(index, 1);
      this._idToEntity.delete(entity.id);
      this.updateNameIndex(entity, false);
      if (this._scene && this._scene.identifierPool) {
        this._scene.identifierPool.checkIn(entity.id);
      }
    }
  }
  /**
   * 移除所有实体
   */
  removeAllEntities() {
    const idsToRecycle = [];
    for (let i = this.buffer.length - 1; i >= 0; i--) {
      idsToRecycle.push(this.buffer[i].id);
      this.buffer[i].destroy();
    }
    if (this._scene && this._scene.identifierPool) {
      for (const id of idsToRecycle) {
        this._scene.identifierPool.checkIn(id);
      }
    }
    this.buffer.length = 0;
    this._idToEntity.clear();
    this._nameToEntities.clear();
    this._entitiesToAdd.length = 0;
    this._entitiesToRemove.length = 0;
  }
  /**
   * 更新实体列表，处理延迟操作
   */
  updateLists() {
    if (this._entitiesToAdd.length > 0) {
      for (const entity of this._entitiesToAdd) {
        this.addImmediate(entity);
      }
      this._entitiesToAdd.length = 0;
    }
    if (this._entitiesToRemove.length > 0) {
      for (const entity of this._entitiesToRemove) {
        this.removeImmediate(entity);
      }
      this._entitiesToRemove.length = 0;
    }
  }
  /**
   * 更新实体列表和实体
   */
  update() {
    this._isUpdating = true;
    try {
      if (this._enableEntityDirectUpdate) {
        for (let i = 0; i < this.buffer.length; i++) {
          const entity = this.buffer[i];
          if (entity.enabled && !entity.isDestroyed) {
            entity.update();
          }
        }
      }
    } finally {
      this._isUpdating = false;
    }
    this.updateLists();
  }
  /**
   * 根据名称查找实体（使用索引，O(1)复杂度）
   * @param name 实体名称
   * @returns 找到的第一个实体或null
   */
  findEntity(name) {
    const entities = this._nameToEntities.get(name);
    return entities && entities.length > 0 ? entities[0] : null;
  }
  /**
   * 根据名称查找所有实体
   * @param name 实体名称
   * @returns 找到的所有实体数组
   */
  findEntitiesByName(name) {
    return this._nameToEntities.get(name) || [];
  }
  /**
   * 根据ID查找实体（使用索引，O(1)复杂度）
   * @param id 实体ID
   * @returns 找到的实体或null
   */
  findEntityById(id) {
    return this._idToEntity.get(id) || null;
  }
  /**
   * 根据标签查找实体
   * @param tag 标签
   * @returns 找到的所有实体数组
   */
  findEntitiesByTag(tag) {
    const result = [];
    for (const entity of this.buffer) {
      if (entity.tag === tag) {
        result.push(entity);
      }
    }
    return result;
  }
  /**
   * 根据组件类型查找实体
   * @param componentType 组件类型
   * @returns 找到的所有实体数组
   */
  findEntitiesWithComponent(componentType) {
    const result = [];
    for (const entity of this.buffer) {
      if (entity.hasComponent(componentType)) {
        result.push(entity);
      }
    }
    return result;
  }
  /**
   * 批量操作：对所有实体执行指定操作
   * @param action 要执行的操作
   */
  forEach(action) {
    for (const entity of this.buffer) {
      action(entity);
    }
  }
  /**
   * 批量操作：对符合条件的实体执行指定操作
   * @param predicate 筛选条件
   * @param action 要执行的操作
   */
  forEachWhere(predicate, action) {
    for (const entity of this.buffer) {
      if (predicate(entity)) {
        action(entity);
      }
    }
  }
  /**
   * 更新名称索引
   * @param entity 实体
   * @param isAdd 是否为添加操作
   */
  updateNameIndex(entity, isAdd) {
    if (!entity.name) {
      return;
    }
    if (isAdd) {
      let entities = this._nameToEntities.get(entity.name);
      if (!entities) {
        entities = [];
        this._nameToEntities.set(entity.name, entities);
      }
      entities.push(entity);
    } else {
      const entities = this._nameToEntities.get(entity.name);
      if (entities) {
        const index = entities.indexOf(entity);
        if (index !== -1) {
          entities.splice(index, 1);
          if (entities.length === 0) {
            this._nameToEntities.delete(entity.name);
          }
        }
      }
    }
  }
  /**
   * 获取实体列表的统计信息
   * @returns 统计信息
   */
  getStats() {
    let activeCount = 0;
    for (const entity of this.buffer) {
      if (entity.enabled && !entity.isDestroyed) {
        activeCount++;
      }
    }
    return {
      totalEntities: this.buffer.length,
      activeEntities: activeCount,
      pendingAdd: this._entitiesToAdd.length,
      pendingRemove: this._entitiesToRemove.length,
      nameIndexSize: this._nameToEntities.size
    };
  }
}
class EntityProcessorList {
  constructor() {
    this._processors = [];
    this._isDirty = false;
  }
  /**
   * 设置为脏状态，需要重新排序
   */
  setDirty() {
    this._isDirty = true;
  }
  /**
   * 添加实体处理器
   * @param processor 要添加的处理器
   */
  add(processor) {
    this._processors.push(processor);
    this.setDirty();
  }
  /**
   * 移除实体处理器
   * @param processor 要移除的处理器
   */
  remove(processor) {
    const index = this._processors.indexOf(processor);
    if (index !== -1) {
      this._processors.splice(index, 1);
    }
  }
  /**
   * 获取指定类型的处理器
   * @param type 处理器类型
   */
  getProcessor(type) {
    for (const processor of this._processors) {
      if (processor instanceof type) {
        return processor;
      }
    }
    return null;
  }
  /**
   * 开始处理
   *
   * 对所有处理器进行排序以确保正确的执行顺序。
   */
  begin() {
    this.sortProcessors();
  }
  /**
   * 结束处理
   */
  end() {
    for (const processor of this._processors) {
      try {
        processor.reset();
      } catch (error) {
        EntityProcessorList._logger.error(`Error in processor ${getSystemInstanceTypeName(processor)}:`, error);
      }
    }
    this._isDirty = false;
    this._processors.length = 0;
  }
  /**
   * 更新所有处理器
   */
  update() {
    this.sortProcessors();
    for (const processor of this._processors) {
      try {
        processor.update();
      } catch (error) {
        EntityProcessorList._logger.error(`Error in processor ${getSystemInstanceTypeName(processor)}:`, error);
      }
    }
  }
  /**
   * 后期更新所有处理器
   */
  lateUpdate() {
    for (const processor of this._processors) {
      processor.lateUpdate();
    }
  }
  /**
   * 排序处理器
   */
  sortProcessors() {
    if (this._isDirty) {
      this._processors.sort((a, b) => a.updateOrder - b.updateOrder);
      this._isDirty = false;
    }
  }
  /** 获取处理器列表 */
  get processors() {
    return this._processors;
  }
  /** 获取处理器数量 */
  get count() {
    return this._processors.length;
  }
}
EntityProcessorList._logger = createLogger("EntityProcessorList");
class IdentifierPool {
  /**
   * 构造函数
   *
   * @param recycleDelay 延迟回收时间（毫秒），默认为100ms
   * @param expansionBlockSize 内存扩展块大小，默认为1024
   */
  constructor(recycleDelay = 100, expansionBlockSize = 1024) {
    this._nextAvailableIndex = 0;
    this._freeIndices = [];
    this._generations = /* @__PURE__ */ new Map();
    this._pendingRecycle = [];
    this._recycleDelay = 100;
    this._stats = {
      totalAllocated: 0,
      totalRecycled: 0,
      currentActive: 0,
      memoryExpansions: 0
    };
    this._recycleDelay = recycleDelay;
    this._expansionBlockSize = expansionBlockSize;
    this._preAllocateGenerations(0, this._expansionBlockSize);
  }
  /**
   * 获取一个可用的ID
   *
   * 返回一个32位ID，高16位为世代版本，低16位为索引。
   *
   * @returns 新分配的实体ID
   * @throws {Error} 当达到索引限制时抛出错误
   */
  checkOut() {
    this._processDelayedRecycle();
    let index;
    if (this._freeIndices.length > 0) {
      index = this._freeIndices.pop();
    } else {
      if (this._nextAvailableIndex > IdentifierPool.MAX_INDEX) {
        throw new Error(`实体索引已达到框架设计限制 (${IdentifierPool.MAX_INDEX})。这意味着您已经分配了超过65535个不同的实体索引。这是16位索引设计的限制，考虑优化实体回收策略或升级到64位ID设计。`);
      }
      index = this._nextAvailableIndex++;
      this._ensureGenerationCapacity(index);
    }
    const generation = this._generations.get(index) || 1;
    this._stats.totalAllocated++;
    this._stats.currentActive++;
    return this._packId(index, generation);
  }
  /**
   * 回收一个ID
   *
   * 验证ID的有效性后，将其加入延迟回收队列。
   * ID不会立即可重用，而是在延迟时间后才真正回收。
   *
   * @param id 要回收的实体ID
   * @returns 是否成功回收（ID是否有效且未被重复回收）
   */
  checkIn(id) {
    const index = this._unpackIndex(id);
    const generation = this._unpackGeneration(id);
    if (!this._isValidId(index, generation)) {
      return false;
    }
    const alreadyPending = this._pendingRecycle.some((item) => item.index === index && item.generation === generation);
    if (alreadyPending) {
      return false;
    }
    this._pendingRecycle.push({
      index,
      generation,
      timestamp: Date.now()
    });
    this._stats.currentActive--;
    this._stats.totalRecycled++;
    return true;
  }
  /**
   * 验证ID是否有效
   *
   * 检查ID的索引和世代版本是否匹配当前状态。
   *
   * @param id 要验证的实体ID
   * @returns ID是否有效
   */
  isValid(id) {
    const index = this._unpackIndex(id);
    const generation = this._unpackGeneration(id);
    return this._isValidId(index, generation);
  }
  /**
   * 获取统计信息
   *
   * @returns 池的当前状态统计
   */
  getStats() {
    let totalGeneration = 0;
    let generationCount = 0;
    for (const [index, generation] of this._generations) {
      if (index < this._nextAvailableIndex) {
        totalGeneration += generation;
        generationCount++;
      }
    }
    const averageGeneration = generationCount > 0 ? totalGeneration / generationCount : 1;
    return {
      totalAllocated: this._stats.totalAllocated,
      totalRecycled: this._stats.totalRecycled,
      currentActive: this._stats.currentActive,
      currentlyFree: this._freeIndices.length,
      pendingRecycle: this._pendingRecycle.length,
      maxPossibleEntities: IdentifierPool.MAX_INDEX + 1,
      maxUsedIndex: this._nextAvailableIndex - 1,
      memoryUsage: this._calculateMemoryUsage(),
      memoryExpansions: this._stats.memoryExpansions,
      averageGeneration: Math.round(averageGeneration * 100) / 100,
      generationStorageSize: this._generations.size
    };
  }
  /**
   * 强制执行延迟回收处理
   *
   * 在某些情况下可能需要立即处理延迟回收队列，
   * 比如内存压力大或者需要精确的统计信息时。
   */
  forceProcessDelayedRecycle() {
    this._processDelayedRecycle(true);
  }
  /**
   * 清理过期的延迟回收项
   *
   * 将超过延迟时间的回收项真正回收到空闲列表中。
   *
   * @param forceAll 是否强制处理所有延迟回收项
   * @private
   */
  _processDelayedRecycle(forceAll = false) {
    if (this._pendingRecycle.length === 0)
      return;
    const now = Date.now();
    const readyToRecycle = [];
    const stillPending = [];
    for (const item of this._pendingRecycle) {
      if (forceAll || now - item.timestamp >= this._recycleDelay) {
        readyToRecycle.push(item);
      } else {
        stillPending.push(item);
      }
    }
    for (const item of readyToRecycle) {
      if (this._isValidId(item.index, item.generation)) {
        let newGeneration = item.generation + 1;
        if (newGeneration > IdentifierPool.MAX_GENERATION) {
          newGeneration = 1;
        }
        this._generations.set(item.index, newGeneration);
        this._freeIndices.push(item.index);
      }
    }
    this._pendingRecycle = stillPending;
  }
  /**
   * 预分配世代信息
   *
   * @param startIndex 起始索引
   * @param count 分配数量
   * @private
   */
  _preAllocateGenerations(startIndex, count) {
    for (let i = 0; i < count; i++) {
      const index = startIndex + i;
      if (index <= IdentifierPool.MAX_INDEX) {
        this._generations.set(index, 1);
      }
    }
    this._stats.memoryExpansions++;
  }
  /**
   * 确保指定索引的世代信息存在
   *
   * @param index 索引
   * @private
   */
  _ensureGenerationCapacity(index) {
    if (!this._generations.has(index)) {
      const expansionStart = Math.floor(index / this._expansionBlockSize) * this._expansionBlockSize;
      this._preAllocateGenerations(expansionStart, this._expansionBlockSize);
    }
  }
  /**
   * 计算内存使用量
   *
   * @returns 内存使用字节数
   * @private
   */
  _calculateMemoryUsage() {
    const generationMapSize = this._generations.size * 16;
    const freeIndicesSize = this._freeIndices.length * 8;
    const pendingRecycleSize = this._pendingRecycle.length * 32;
    return generationMapSize + freeIndicesSize + pendingRecycleSize;
  }
  /**
   * 打包索引和世代为32位ID
   *
   * @param index 索引（16位）
   * @param generation 世代版本（16位）
   * @returns 打包后的32位ID
   * @private
   */
  _packId(index, generation) {
    return generation << 16 | index;
  }
  /**
   * 从ID中解包索引
   *
   * @param id 32位ID
   * @returns 索引部分（16位）
   * @private
   */
  _unpackIndex(id) {
    return id & 65535;
  }
  /**
   * 从ID中解包世代版本
   *
   * @param id 32位ID
   * @returns 世代版本部分（16位）
   * @private
   */
  _unpackGeneration(id) {
    return id >>> 16 & 65535;
  }
  /**
   * 内部ID有效性检查
   *
   * @param index 索引
   * @param generation 世代版本
   * @returns 是否有效
   * @private
   */
  _isValidId(index, generation) {
    if (index < 0 || index >= this._nextAvailableIndex) {
      return false;
    }
    const currentGeneration = this._generations.get(index);
    return currentGeneration !== void 0 && currentGeneration === generation;
  }
}
IdentifierPool.MAX_INDEX = 65535;
IdentifierPool.MAX_GENERATION = 65535;
class SparseSet {
  constructor() {
    this._dense = [];
    this._sparse = /* @__PURE__ */ new Map();
  }
  /**
   * 添加元素到集合
   *
   * @param item 要添加的元素
   * @returns 是否成功添加（false表示元素已存在）
   */
  add(item) {
    if (this._sparse.has(item)) {
      return false;
    }
    const index = this._dense.length;
    this._dense.push(item);
    this._sparse.set(item, index);
    return true;
  }
  /**
   * 从集合中移除元素
   *
   * 使用swap-and-pop技术保持数组紧凑性：
   * 1. 将要删除的元素与最后一个元素交换
   * 2. 删除最后一个元素
   * 3. 更新映射表
   *
   * @param item 要移除的元素
   * @returns 是否成功移除（false表示元素不存在）
   */
  remove(item) {
    const index = this._sparse.get(item);
    if (index === void 0) {
      return false;
    }
    const lastIndex = this._dense.length - 1;
    if (index !== lastIndex) {
      const lastItem = this._dense[lastIndex];
      this._dense[index] = lastItem;
      this._sparse.set(lastItem, index);
    }
    this._dense.pop();
    this._sparse.delete(item);
    return true;
  }
  /**
   * 检查元素是否存在于集合中
   *
   * @param item 要检查的元素
   * @returns 元素是否存在
   */
  has(item) {
    return this._sparse.has(item);
  }
  /**
   * 获取元素在密集数组中的索引
   *
   * @param item 要查询的元素
   * @returns 索引，如果元素不存在则返回undefined
   */
  getIndex(item) {
    return this._sparse.get(item);
  }
  /**
   * 根据索引获取元素
   *
   * @param index 索引
   * @returns 元素，如果索引无效则返回undefined
   */
  getByIndex(index) {
    return this._dense[index];
  }
  /**
   * 获取集合大小
   */
  get size() {
    return this._dense.length;
  }
  /**
   * 检查集合是否为空
   */
  get isEmpty() {
    return this._dense.length === 0;
  }
  /**
   * 遍历集合中的所有元素
   *
   * 保证遍历顺序与添加顺序一致（除非中间有删除操作）。
   * 遍历性能优秀，因为数据在内存中连续存储。
   *
   * @param callback 遍历回调函数
   */
  forEach(callback) {
    for (let i = 0; i < this._dense.length; i++) {
      callback(this._dense[i], i);
    }
  }
  /**
   * 映射集合中的所有元素
   *
   * @param callback 映射回调函数
   * @returns 映射后的新数组
   */
  map(callback) {
    const result = [];
    for (let i = 0; i < this._dense.length; i++) {
      result.push(callback(this._dense[i], i));
    }
    return result;
  }
  /**
   * 过滤集合中的元素
   *
   * @param predicate 过滤条件
   * @returns 满足条件的元素数组
   */
  filter(predicate) {
    const result = [];
    for (let i = 0; i < this._dense.length; i++) {
      if (predicate(this._dense[i], i)) {
        result.push(this._dense[i]);
      }
    }
    return result;
  }
  /**
   * 查找第一个满足条件的元素
   *
   * @param predicate 查找条件
   * @returns 找到的元素，如果没有则返回undefined
   */
  find(predicate) {
    for (let i = 0; i < this._dense.length; i++) {
      if (predicate(this._dense[i], i)) {
        return this._dense[i];
      }
    }
    return void 0;
  }
  /**
   * 检查是否存在满足条件的元素
   *
   * @param predicate 检查条件
   * @returns 是否存在满足条件的元素
   */
  some(predicate) {
    for (let i = 0; i < this._dense.length; i++) {
      if (predicate(this._dense[i], i)) {
        return true;
      }
    }
    return false;
  }
  /**
   * 检查是否所有元素都满足条件
   *
   * @param predicate 检查条件
   * @returns 是否所有元素都满足条件
   */
  every(predicate) {
    for (let i = 0; i < this._dense.length; i++) {
      if (!predicate(this._dense[i], i)) {
        return false;
      }
    }
    return true;
  }
  /**
   * 获取密集数组的只读副本
   *
   * 返回数组的浅拷贝，确保外部无法直接修改内部数据。
   */
  getDenseArray() {
    return [...this._dense];
  }
  /**
   * 获取密集数组的直接引用（内部使用）
   *
   * 警告：直接修改返回的数组会破坏数据结构的完整性。
   * 仅在性能关键场景下使用，并确保不会修改数组内容。
   */
  getDenseArrayUnsafe() {
    return this._dense;
  }
  /**
   * 清空集合
   */
  clear() {
    this._dense.length = 0;
    this._sparse.clear();
  }
  /**
   * 转换为数组
   */
  toArray() {
    return [...this._dense];
  }
  /**
   * 转换为Set
   */
  toSet() {
    return new Set(this._dense);
  }
  /**
   * 获取内存使用统计信息
   */
  getMemoryStats() {
    const denseArraySize = this._dense.length * 8;
    const sparseMapSize = this._sparse.size * 16;
    return {
      denseArraySize,
      sparseMapSize,
      totalMemory: denseArraySize + sparseMapSize
    };
  }
  /**
   * 验证数据结构的完整性
   *
   * 调试用方法，检查内部数据结构是否一致。
   */
  validate() {
    if (this._dense.length !== this._sparse.size) {
      return false;
    }
    for (let i = 0; i < this._dense.length; i++) {
      const item = this._dense[i];
      const mappedIndex = this._sparse.get(item);
      if (mappedIndex !== i) {
        return false;
      }
    }
    for (const [item, index] of this._sparse) {
      if (index >= this._dense.length || this._dense[index] !== item) {
        return false;
      }
    }
    return true;
  }
}
class PoolableEntitySet extends Set {
  constructor(...args) {
    super();
  }
  reset() {
    this.clear();
  }
}
class ComponentSparseSet {
  constructor() {
    this._componentMasks = [];
    this._componentToEntities = /* @__PURE__ */ new Map();
    this._entities = new SparseSet();
  }
  /**
   * 添加实体到组件索引
   *
   * 分析实体的组件组成，生成位掩码，并更新所有相关索引。
   *
   * @param entity 要添加的实体
   */
  addEntity(entity) {
    if (this._entities.has(entity)) {
      this.removeEntity(entity);
    }
    let componentMask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    const entityComponents = /* @__PURE__ */ new Set();
    for (const component of entity.components) {
      const componentType = component.constructor;
      entityComponents.add(componentType);
      if (!ComponentRegistry.isRegistered(componentType)) {
        ComponentRegistry.register(componentType);
      }
      const bitMask = ComponentRegistry.getBitMask(componentType);
      BitMask64Utils.orInPlace(componentMask, bitMask);
    }
    this._entities.add(entity);
    const entityIndex = this._entities.getIndex(entity);
    while (this._componentMasks.length <= entityIndex) {
      this._componentMasks.push(BitMask64Utils.clone(BitMask64Utils.ZERO));
    }
    this._componentMasks[entityIndex] = componentMask;
    this.updateComponentMappings(entity, entityComponents, true);
  }
  /**
   * 从组件索引中移除实体
   *
   * 清理实体相关的所有索引数据，保持数据结构的紧凑性。
   *
   * @param entity 要移除的实体
   */
  removeEntity(entity) {
    const entityIndex = this._entities.getIndex(entity);
    if (entityIndex === void 0) {
      return;
    }
    const entityComponents = this.getEntityComponentTypes(entity);
    this.updateComponentMappings(entity, entityComponents, false);
    this._entities.remove(entity);
    const lastIndex = this._componentMasks.length - 1;
    if (entityIndex !== lastIndex) {
      this._componentMasks[entityIndex] = this._componentMasks[lastIndex];
    }
    this._componentMasks.pop();
  }
  /**
   * 查询包含指定组件的所有实体
   *
   * @param componentType 组件类型
   * @returns 包含该组件的实体集合
   */
  queryByComponent(componentType) {
    const entities = this._componentToEntities.get(componentType);
    return entities ? new Set(entities) : /* @__PURE__ */ new Set();
  }
  /**
   * 多组件查询（AND操作）
   *
   * 查找同时包含所有指定组件的实体。
   *
   * @param componentTypes 组件类型数组
   * @returns 满足条件的实体集合
   */
  queryMultipleAnd(componentTypes) {
    if (componentTypes.length === 0) {
      return /* @__PURE__ */ new Set();
    }
    if (componentTypes.length === 1) {
      return this.queryByComponent(componentTypes[0]);
    }
    let targetMask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    for (const componentType of componentTypes) {
      if (!ComponentRegistry.isRegistered(componentType)) {
        return /* @__PURE__ */ new Set();
      }
      const bitMask = ComponentRegistry.getBitMask(componentType);
      BitMask64Utils.orInPlace(targetMask, bitMask);
    }
    const result = ComponentSparseSet._entitySetPool.obtain();
    this._entities.forEach((entity, index) => {
      const entityMask = this._componentMasks[index];
      if (BitMask64Utils.hasAll(entityMask, targetMask)) {
        result.add(entity);
      }
    });
    return result;
  }
  /**
   * 多组件查询（OR操作）
   *
   * 查找包含任意一个指定组件的实体。
   *
   * @param componentTypes 组件类型数组
   * @returns 满足条件的实体集合
   */
  queryMultipleOr(componentTypes) {
    if (componentTypes.length === 0) {
      return /* @__PURE__ */ new Set();
    }
    if (componentTypes.length === 1) {
      return this.queryByComponent(componentTypes[0]);
    }
    let targetMask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    for (const componentType of componentTypes) {
      if (ComponentRegistry.isRegistered(componentType)) {
        const bitMask = ComponentRegistry.getBitMask(componentType);
        BitMask64Utils.orInPlace(targetMask, bitMask);
      }
    }
    if (BitMask64Utils.equals(targetMask, BitMask64Utils.ZERO)) {
      return /* @__PURE__ */ new Set();
    }
    const result = ComponentSparseSet._entitySetPool.obtain();
    this._entities.forEach((entity, index) => {
      const entityMask = this._componentMasks[index];
      if (BitMask64Utils.hasAny(entityMask, targetMask)) {
        result.add(entity);
      }
    });
    return result;
  }
  /**
   * 检查实体是否包含指定组件
   *
   * @param entity 实体
   * @param componentType 组件类型
   * @returns 是否包含该组件
   */
  hasComponent(entity, componentType) {
    const entityIndex = this._entities.getIndex(entity);
    if (entityIndex === void 0) {
      return false;
    }
    if (!ComponentRegistry.isRegistered(componentType)) {
      return false;
    }
    const entityMask = this._componentMasks[entityIndex];
    const componentMask = ComponentRegistry.getBitMask(componentType);
    return BitMask64Utils.hasAny(entityMask, componentMask);
  }
  /**
   * 获取实体的组件位掩码
   *
   * @param entity 实体
   * @returns 组件位掩码，如果实体不存在则返回undefined
   */
  getEntityMask(entity) {
    const entityIndex = this._entities.getIndex(entity);
    if (entityIndex === void 0) {
      return void 0;
    }
    return this._componentMasks[entityIndex];
  }
  /**
   * 获取所有实体
   *
   * @returns 所有实体的数组
   */
  getAllEntities() {
    return this._entities.toArray();
  }
  /**
   * 获取实体数量
   */
  get size() {
    return this._entities.size;
  }
  /**
   * 检查是否为空
   */
  get isEmpty() {
    return this._entities.isEmpty;
  }
  /**
   * 遍历所有实体
   *
   * @param callback 遍历回调函数
   */
  forEach(callback) {
    this._entities.forEach((entity, index) => {
      callback(entity, this._componentMasks[index], index);
    });
  }
  /**
   * 清空所有数据
   */
  clear() {
    this._entities.clear();
    this._componentMasks.length = 0;
    for (const entitySet of this._componentToEntities.values()) {
      ComponentSparseSet._entitySetPool.release(entitySet);
    }
    this._componentToEntities.clear();
  }
  /**
   * 获取内存使用统计
   */
  getMemoryStats() {
    const entitiesStats = this._entities.getMemoryStats();
    const masksMemory = this._componentMasks.length * 16;
    let mappingsMemory = this._componentToEntities.size * 16;
    for (const entitySet of this._componentToEntities.values()) {
      mappingsMemory += entitySet.size * 8;
    }
    return {
      entitiesMemory: entitiesStats.totalMemory,
      masksMemory,
      mappingsMemory,
      totalMemory: entitiesStats.totalMemory + masksMemory + mappingsMemory
    };
  }
  /**
   * 验证数据结构完整性
   */
  validate() {
    if (!this._entities.validate()) {
      return false;
    }
    if (this._componentMasks.length !== this._entities.size) {
      return false;
    }
    const allMappedEntities = /* @__PURE__ */ new Set();
    for (const entitySet of this._componentToEntities.values()) {
      for (const entity of entitySet) {
        allMappedEntities.add(entity);
      }
    }
    for (const entity of allMappedEntities) {
      if (!this._entities.has(entity)) {
        return false;
      }
    }
    return true;
  }
  /**
   * 获取实体的组件类型集合
   */
  getEntityComponentTypes(entity) {
    const componentTypes = /* @__PURE__ */ new Set();
    for (const component of entity.components) {
      componentTypes.add(component.constructor);
    }
    return componentTypes;
  }
  /**
   * 更新组件类型到实体的映射
   */
  updateComponentMappings(entity, componentTypes, add) {
    for (const componentType of componentTypes) {
      let entities = this._componentToEntities.get(componentType);
      if (add) {
        if (!entities) {
          entities = ComponentSparseSet._entitySetPool.obtain();
          this._componentToEntities.set(componentType, entities);
        }
        entities.add(entity);
      } else {
        if (entities) {
          entities.delete(entity);
          if (entities.size === 0) {
            this._componentToEntities.delete(componentType);
            ComponentSparseSet._entitySetPool.release(entities);
          }
        }
      }
    }
  }
}
ComponentSparseSet._entitySetPool = Pool.getPool(PoolableEntitySet, 50, 512);
class ComponentIndex {
  constructor() {
    this._queryCount = 0;
    this._totalQueryTime = 0;
    this._lastUpdated = Date.now();
    this._sparseSet = new ComponentSparseSet();
  }
  addEntity(entity) {
    this._sparseSet.addEntity(entity);
    this._lastUpdated = Date.now();
  }
  removeEntity(entity) {
    this._sparseSet.removeEntity(entity);
    this._lastUpdated = Date.now();
  }
  query(componentType) {
    const startTime = performance.now();
    const result = this._sparseSet.queryByComponent(componentType);
    this._queryCount++;
    this._totalQueryTime += performance.now() - startTime;
    return result;
  }
  queryMultiple(componentTypes, operation) {
    const startTime = performance.now();
    let result;
    if (componentTypes.length === 0) {
      result = /* @__PURE__ */ new Set();
    } else if (componentTypes.length === 1) {
      result = this.query(componentTypes[0]);
    } else if (operation === "AND") {
      result = this._sparseSet.queryMultipleAnd(componentTypes);
    } else {
      result = this._sparseSet.queryMultipleOr(componentTypes);
    }
    this._queryCount++;
    this._totalQueryTime += performance.now() - startTime;
    return result;
  }
  clear() {
    this._sparseSet.clear();
    this._lastUpdated = Date.now();
  }
  getStats() {
    const memoryStats = this._sparseSet.getMemoryStats();
    return {
      size: this._sparseSet.size,
      memoryUsage: memoryStats.totalMemory,
      queryCount: this._queryCount,
      avgQueryTime: this._queryCount > 0 ? this._totalQueryTime / this._queryCount : 0,
      lastUpdated: this._lastUpdated
    };
  }
}
class ComponentIndexManager {
  constructor() {
    this._index = new ComponentIndex();
  }
  /**
   * 添加实体到索引
   */
  addEntity(entity) {
    this._index.addEntity(entity);
  }
  /**
   * 从索引中移除实体
   */
  removeEntity(entity) {
    this._index.removeEntity(entity);
  }
  /**
   * 查询包含指定组件的实体
   */
  query(componentType) {
    return this._index.query(componentType);
  }
  /**
   * 批量查询多个组件
   */
  queryMultiple(componentTypes, operation) {
    return this._index.queryMultiple(componentTypes, operation);
  }
  /**
   * 获取索引统计信息
   */
  getStats() {
    return this._index.getStats();
  }
  /**
   * 清空索引
   */
  clear() {
    this._index.clear();
  }
}
class ArchetypeSystem {
  constructor() {
    this._archetypes = /* @__PURE__ */ new Map();
    this._entityToArchetype = /* @__PURE__ */ new Map();
    this._componentToArchetypes = /* @__PURE__ */ new Map();
    this._queryCache = /* @__PURE__ */ new Map();
    this._cacheTimeout = 5e3;
    this._maxCacheSize = 100;
  }
  /**
   * 添加实体到原型系统
   */
  addEntity(entity) {
    const componentTypes = this.getEntityComponentTypes(entity);
    const archetypeId = this.generateArchetypeId(componentTypes);
    let archetype = this._archetypes.get(archetypeId);
    if (!archetype) {
      archetype = this.createArchetype(componentTypes);
    }
    archetype.entities.push(entity);
    archetype.updatedAt = Date.now();
    this._entityToArchetype.set(entity, archetype);
    this.updateComponentIndexes(archetype, componentTypes, true);
    this.invalidateQueryCache();
  }
  /**
   * 从原型系统中移除实体
   */
  removeEntity(entity) {
    const archetype = this._entityToArchetype.get(entity);
    if (!archetype)
      return;
    const index = archetype.entities.indexOf(entity);
    if (index !== -1) {
      archetype.entities.splice(index, 1);
      archetype.updatedAt = Date.now();
    }
    this._entityToArchetype.delete(entity);
    this.invalidateQueryCache();
  }
  /**
   * 更新实体的原型归属
   *
   * 当实体的组件组合发生变化时调用此方法，将实体从旧原型移动到新原型。
   * 如果新的组件组合对应的原型不存在，将自动创建新原型。
   *
   * @param entity 要更新的实体
   */
  updateEntity(entity) {
    const currentArchetype = this._entityToArchetype.get(entity);
    const newComponentTypes = this.getEntityComponentTypes(entity);
    const newArchetypeId = this.generateArchetypeId(newComponentTypes);
    if (currentArchetype && currentArchetype.id === newArchetypeId) {
      return;
    }
    if (currentArchetype) {
      const index = currentArchetype.entities.indexOf(entity);
      if (index !== -1) {
        currentArchetype.entities.splice(index, 1);
        currentArchetype.updatedAt = Date.now();
      }
    }
    let newArchetype = this._archetypes.get(newArchetypeId);
    if (!newArchetype) {
      newArchetype = this.createArchetype(newComponentTypes);
    }
    newArchetype.entities.push(entity);
    newArchetype.updatedAt = Date.now();
    this._entityToArchetype.set(entity, newArchetype);
    if (currentArchetype) {
      this.updateComponentIndexes(currentArchetype, currentArchetype.componentTypes, false);
    }
    this.updateComponentIndexes(newArchetype, newComponentTypes, true);
    this.invalidateQueryCache();
  }
  /**
   * 查询包含指定组件组合的原型
   */
  queryArchetypes(componentTypes, operation = "AND") {
    const startTime = performance.now();
    const cacheKey = `${operation}:${componentTypes.map((t) => getComponentTypeName(t)).sort().join(",")}`;
    const cached = this._queryCache.get(cacheKey);
    if (cached && Date.now() - cached.timestamp < this._cacheTimeout) {
      return {
        ...cached.result,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    const matchingArchetypes = [];
    let totalEntities = 0;
    if (operation === "AND") {
      for (const archetype of this._archetypes.values()) {
        if (this.archetypeContainsAllComponents(archetype, componentTypes)) {
          matchingArchetypes.push(archetype);
          totalEntities += archetype.entities.length;
        }
      }
    } else {
      const foundArchetypes = /* @__PURE__ */ new Set();
      for (const componentType of componentTypes) {
        const archetypes = this._componentToArchetypes.get(componentType);
        if (archetypes) {
          for (const archetype of archetypes) {
            foundArchetypes.add(archetype);
          }
        }
      }
      for (const archetype of foundArchetypes) {
        matchingArchetypes.push(archetype);
        totalEntities += archetype.entities.length;
      }
    }
    const result = {
      archetypes: matchingArchetypes,
      totalEntities,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
    this._queryCache.set(cacheKey, {
      result,
      timestamp: Date.now()
    });
    return result;
  }
  /**
   * 获取实体所属的原型
   */
  getEntityArchetype(entity) {
    return this._entityToArchetype.get(entity);
  }
  /**
   * 获取所有原型
   */
  getAllArchetypes() {
    return Array.from(this._archetypes.values());
  }
  /**
   * 清空所有数据
   */
  clear() {
    this._archetypes.clear();
    this._entityToArchetype.clear();
    this._componentToArchetypes.clear();
    this._queryCache.clear();
  }
  /**
   * 获取实体的组件类型列表
   */
  getEntityComponentTypes(entity) {
    return entity.components.map((component) => component.constructor);
  }
  /**
   * 生成原型ID
   */
  generateArchetypeId(componentTypes) {
    return componentTypes.map((type) => getComponentTypeName(type)).sort().join("|");
  }
  /**
   * 创建新原型
   */
  createArchetype(componentTypes) {
    const id = this.generateArchetypeId(componentTypes);
    const archetype = {
      id,
      componentTypes: [...componentTypes],
      entities: [],
      createdAt: Date.now(),
      updatedAt: Date.now()
    };
    this._archetypes.set(id, archetype);
    return archetype;
  }
  /**
   * 检查原型是否包含所有指定组件
   */
  archetypeContainsAllComponents(archetype, componentTypes) {
    for (const componentType of componentTypes) {
      if (!archetype.componentTypes.includes(componentType)) {
        return false;
      }
    }
    return true;
  }
  /**
   * 更新组件索引
   */
  updateComponentIndexes(archetype, componentTypes, add) {
    for (const componentType of componentTypes) {
      let archetypes = this._componentToArchetypes.get(componentType);
      if (!archetypes) {
        archetypes = /* @__PURE__ */ new Set();
        this._componentToArchetypes.set(componentType, archetypes);
      }
      if (add) {
        archetypes.add(archetype);
      } else {
        archetypes.delete(archetype);
        if (archetypes.size === 0) {
          this._componentToArchetypes.delete(componentType);
        }
      }
    }
  }
  /**
   * 使查询缓存失效
   */
  invalidateQueryCache() {
    this._queryCache.clear();
  }
}
var QueryConditionType;
(function(QueryConditionType2) {
  QueryConditionType2["ALL"] = "all";
  QueryConditionType2["ANY"] = "any";
  QueryConditionType2["NONE"] = "none";
})(QueryConditionType || (QueryConditionType = {}));
class QuerySystem {
  constructor() {
    this._logger = createLogger("QuerySystem");
    this.entities = [];
    this._version = 0;
    this.queryCache = /* @__PURE__ */ new Map();
    this.cacheMaxSize = 1e3;
    this.cacheTimeout = 5e3;
    this.componentNameCache = /* @__PURE__ */ new WeakMap();
    this.cacheKeyCache = /* @__PURE__ */ new Map();
    this.componentMaskCache = /* @__PURE__ */ new Map();
    this.queryStats = {
      totalQueries: 0,
      cacheHits: 0,
      indexHits: 0,
      linearScans: 0,
      archetypeHits: 0,
      dirtyChecks: 0
    };
    this.entityIndex = {
      byMask: /* @__PURE__ */ new Map(),
      byComponentType: /* @__PURE__ */ new Map(),
      byTag: /* @__PURE__ */ new Map(),
      byName: /* @__PURE__ */ new Map()
    };
    this.componentIndexManager = new ComponentIndexManager();
    this.archetypeSystem = new ArchetypeSystem();
  }
  /**
   * 设置实体列表并重建索引
   *
   * 当实体集合发生大规模变化时调用此方法。
   * 系统将重新构建所有索引以确保查询性能。
   *
   * @param entities 新的实体列表
   */
  setEntities(entities) {
    this.entities = entities;
    this.clearQueryCache();
    this.rebuildIndexes();
  }
  /**
   * 添加单个实体到查询系统
   *
   * 将新实体添加到查询系统中，并自动更新相关索引。
   * 为了提高批量添加性能，可以延迟缓存清理。
   *
   * @param entity 要添加的实体
   * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
   */
  addEntity(entity, deferCacheClear = false) {
    if (!this.entities.includes(entity)) {
      this.entities.push(entity);
      this.addEntityToIndexes(entity);
      this.componentIndexManager.addEntity(entity);
      this.archetypeSystem.addEntity(entity);
      if (!deferCacheClear) {
        this.clearQueryCache();
      }
      this._version++;
    }
  }
  /**
   * 批量添加实体
   *
   * 高效地批量添加多个实体，减少缓存清理次数。
   * 使用Set来避免O(n)的重复检查。
   *
   * @param entities 要添加的实体列表
   */
  addEntities(entities) {
    if (entities.length === 0)
      return;
    const existingIds = new Set(this.entities.map((e) => e.id));
    let addedCount = 0;
    for (const entity of entities) {
      if (!existingIds.has(entity.id)) {
        this.entities.push(entity);
        this.addEntityToIndexes(entity);
        this.componentIndexManager.addEntity(entity);
        this.archetypeSystem.addEntity(entity);
        existingIds.add(entity.id);
        addedCount++;
      }
    }
    if (addedCount > 0) {
      this.clearQueryCache();
    }
  }
  /**
   * 批量添加实体（无重复检查版本）
   *
   * 假设所有实体都是新的，跳过重复检查以获得最大性能。
   * 仅在确保没有重复实体时使用。
   *
   * @param entities 要添加的实体列表
   */
  addEntitiesUnchecked(entities) {
    if (entities.length === 0)
      return;
    for (const entity of entities) {
      this.entities.push(entity);
    }
    for (const entity of entities) {
      this.addEntityToIndexes(entity);
      this.componentIndexManager.addEntity(entity);
      this.archetypeSystem.addEntity(entity);
    }
    this.clearQueryCache();
  }
  /**
   * 从查询系统移除实体
   *
   * 从查询系统中移除指定实体，并清理相关索引。
   *
   * @param entity 要移除的实体
   */
  removeEntity(entity) {
    const index = this.entities.indexOf(entity);
    if (index !== -1) {
      this.entities.splice(index, 1);
      this.removeEntityFromIndexes(entity);
      this.componentIndexManager.removeEntity(entity);
      this.archetypeSystem.removeEntity(entity);
      this.clearQueryCache();
      this._version++;
    }
  }
  /**
   * 更新实体在查询系统中的索引
   *
   * 当实体的组件组合发生变化时调用此方法，高效地更新实体在查询系统中的索引。
   *
   * @param entity 要更新的实体
   */
  updateEntity(entity) {
    if (!this.entities.includes(entity)) {
      this.addEntity(entity);
      return;
    }
    this.removeEntityFromIndexes(entity);
    this.archetypeSystem.updateEntity(entity);
    this.componentIndexManager.removeEntity(entity);
    this.componentIndexManager.addEntity(entity);
    this.addEntityToIndexes(entity);
    this.clearQueryCache();
    this._version++;
  }
  /**
   * 将实体添加到各种索引中
   */
  addEntityToIndexes(entity) {
    const mask = entity.componentMask;
    const maskKey = mask.toString();
    const maskSet = this.entityIndex.byMask.get(maskKey) || this.createAndSetMaskIndex(maskKey);
    maskSet.add(entity);
    const components = entity.components;
    for (let i = 0; i < components.length; i++) {
      const componentType = components[i].constructor;
      const typeSet = this.entityIndex.byComponentType.get(componentType) || this.createAndSetComponentIndex(componentType);
      typeSet.add(entity);
    }
    const tag = entity.tag;
    if (tag !== void 0) {
      const tagSet = this.entityIndex.byTag.get(tag) || this.createAndSetTagIndex(tag);
      tagSet.add(entity);
    }
    const name = entity.name;
    if (name) {
      const nameSet = this.entityIndex.byName.get(name) || this.createAndSetNameIndex(name);
      nameSet.add(entity);
    }
  }
  createAndSetMaskIndex(maskKey) {
    const set = /* @__PURE__ */ new Set();
    this.entityIndex.byMask.set(maskKey, set);
    return set;
  }
  createAndSetComponentIndex(componentType) {
    const set = /* @__PURE__ */ new Set();
    this.entityIndex.byComponentType.set(componentType, set);
    return set;
  }
  createAndSetTagIndex(tag) {
    const set = /* @__PURE__ */ new Set();
    this.entityIndex.byTag.set(tag, set);
    return set;
  }
  createAndSetNameIndex(name) {
    const set = /* @__PURE__ */ new Set();
    this.entityIndex.byName.set(name, set);
    return set;
  }
  /**
   * 从各种索引中移除实体
   */
  removeEntityFromIndexes(entity) {
    const mask = entity.componentMask;
    const maskKey = mask.toString();
    const maskSet = this.entityIndex.byMask.get(maskKey);
    if (maskSet) {
      maskSet.delete(entity);
      if (maskSet.size === 0) {
        this.entityIndex.byMask.delete(maskKey);
      }
    }
    for (const component of entity.components) {
      const componentType = component.constructor;
      const typeSet = this.entityIndex.byComponentType.get(componentType);
      if (typeSet) {
        typeSet.delete(entity);
        if (typeSet.size === 0) {
          this.entityIndex.byComponentType.delete(componentType);
        }
      }
    }
    if (entity.tag !== void 0) {
      const tagSet = this.entityIndex.byTag.get(entity.tag);
      if (tagSet) {
        tagSet.delete(entity);
        if (tagSet.size === 0) {
          this.entityIndex.byTag.delete(entity.tag);
        }
      }
    }
    if (entity.name) {
      const nameSet = this.entityIndex.byName.get(entity.name);
      if (nameSet) {
        nameSet.delete(entity);
        if (nameSet.size === 0) {
          this.entityIndex.byName.delete(entity.name);
        }
      }
    }
  }
  /**
   * 重建所有索引
   *
   * 清空并重新构建所有查询索引。
   * 通常在大量实体变更后调用以确保索引一致性。
   */
  rebuildIndexes() {
    this.entityIndex.byMask.clear();
    this.entityIndex.byComponentType.clear();
    this.entityIndex.byTag.clear();
    this.entityIndex.byName.clear();
    this.archetypeSystem.clear();
    this.componentIndexManager.clear();
    for (const entity of this.entities) {
      this.addEntityToIndexes(entity);
      this.componentIndexManager.addEntity(entity);
      this.archetypeSystem.addEntity(entity);
    }
  }
  /**
   * 查询包含所有指定组件的实体
   *
   * 返回同时包含所有指定组件类型的实体列表。
   * 系统会自动选择最高效的查询策略，包括索引查找和缓存机制。
   *
   * @param componentTypes 要查询的组件类型列表
   * @returns 查询结果，包含匹配的实体和性能信息
   *
   * @example
   * ```typescript
   * // 查询同时具有位置和速度组件的实体
   * const result = querySystem.queryAll(PositionComponent, VelocityComponent);
   * logger.info(`找到 ${result.count} 个移动实体`);
   * ```
   */
  queryAll(...componentTypes) {
    const startTime = performance.now();
    this.queryStats.totalQueries++;
    const cacheKey = this.generateCacheKey("all", componentTypes);
    const cached = this.getFromCache(cacheKey);
    if (cached) {
      this.queryStats.cacheHits++;
      return {
        entities: cached,
        count: cached.length,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    let entities = [];
    const archetypeResult = this.archetypeSystem.queryArchetypes(componentTypes, "AND");
    if (archetypeResult.archetypes.length > 0) {
      this.queryStats.archetypeHits++;
      for (const archetype of archetypeResult.archetypes) {
        entities.push(...archetype.entities);
      }
    } else {
      try {
        if (componentTypes.length === 1) {
          this.queryStats.indexHits++;
          const indexResult = this.componentIndexManager.query(componentTypes[0]);
          entities = Array.from(indexResult);
        } else {
          const indexResult = this.componentIndexManager.queryMultiple(componentTypes, "AND");
          entities = Array.from(indexResult);
        }
      } catch (error) {
        entities = [];
      }
    }
    this.addToCache(cacheKey, entities);
    return {
      entities,
      count: entities.length,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 多组件查询算法
   *
   * 针对多组件查询场景的高效算法实现。
   * 通过选择最小的组件集合作为起点，减少需要检查的实体数量。
   *
   * @param componentTypes 组件类型列表
   * @returns 匹配的实体列表
   */
  queryMultipleComponents(componentTypes) {
    let smallestSet = null;
    let smallestSize = Infinity;
    for (const componentType of componentTypes) {
      const set = this.entityIndex.byComponentType.get(componentType);
      if (!set || set.size === 0) {
        return [];
      }
      if (set.size < smallestSize) {
        smallestSize = set.size;
        smallestSet = set;
      }
    }
    if (!smallestSet) {
      return [];
    }
    const mask = this.createComponentMask(componentTypes);
    const result = [];
    for (const entity of smallestSet) {
      if (BitMask64Utils.hasAll(entity.componentMask, mask)) {
        result.push(entity);
      }
    }
    return result;
  }
  /**
   * 查询包含任意指定组件的实体
   *
   * 返回包含任意一个指定组件类型的实体列表。
   * 使用集合合并算法确保高效的查询性能。
   *
   * @param componentTypes 要查询的组件类型列表
   * @returns 查询结果，包含匹配的实体和性能信息
   *
   * @example
   * ```typescript
   * // 查询具有武器或护甲组件的实体
   * const result = querySystem.queryAny(WeaponComponent, ArmorComponent);
   * logger.info(`找到 ${result.count} 个装备实体`);
   * ```
   */
  queryAny(...componentTypes) {
    const startTime = performance.now();
    this.queryStats.totalQueries++;
    const cacheKey = this.generateCacheKey("any", componentTypes);
    const cached = this.getFromCache(cacheKey);
    if (cached) {
      this.queryStats.cacheHits++;
      return {
        entities: cached,
        count: cached.length,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    const archetypeResult = this.archetypeSystem.queryArchetypes(componentTypes, "OR");
    let entities;
    if (archetypeResult.archetypes.length > 0) {
      this.queryStats.archetypeHits++;
      entities = [];
      for (const archetype of archetypeResult.archetypes) {
        entities.push(...archetype.entities);
      }
    } else {
      const indexResult = this.componentIndexManager.queryMultiple(componentTypes, "OR");
      entities = Array.from(indexResult);
    }
    this.addToCache(cacheKey, entities);
    return {
      entities,
      count: entities.length,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 查询不包含任何指定组件的实体
   *
   * 返回不包含任何指定组件类型的实体列表。
   * 适用于排除特定类型实体的查询场景。
   *
   * @param componentTypes 要排除的组件类型列表
   * @returns 查询结果，包含匹配的实体和性能信息
   *
   * @example
   * ```typescript
   * // 查询不具有AI和玩家控制组件的实体（如静态物体）
   * const result = querySystem.queryNone(AIComponent, PlayerControlComponent);
   * logger.info(`找到 ${result.count} 个静态实体`);
   * ```
   */
  queryNone(...componentTypes) {
    const startTime = performance.now();
    this.queryStats.totalQueries++;
    const cacheKey = this.generateCacheKey("none", componentTypes);
    const cached = this.getFromCache(cacheKey);
    if (cached) {
      this.queryStats.cacheHits++;
      return {
        entities: cached,
        count: cached.length,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    const mask = this.createComponentMask(componentTypes);
    const entities = this.entities.filter((entity) => BitMask64Utils.hasNone(entity.componentMask, mask));
    this.addToCache(cacheKey, entities);
    return {
      entities,
      count: entities.length,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 按标签查询实体
   *
   * 返回具有指定标签的所有实体。
   * 标签查询使用专用索引，具有很高的查询性能。
   *
   * @param tag 要查询的标签值
   * @returns 查询结果，包含匹配的实体和性能信息
   *
   * @example
   * ```typescript
   * // 查询所有玩家实体
   * const players = querySystem.queryByTag(PLAYER_TAG);
   * ```
   */
  queryByTag(tag) {
    const startTime = performance.now();
    this.queryStats.totalQueries++;
    const cacheKey = `tag:${tag}`;
    const cached = this.getFromCache(cacheKey);
    if (cached) {
      this.queryStats.cacheHits++;
      return {
        entities: cached,
        count: cached.length,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    this.queryStats.indexHits++;
    const entities = Array.from(this.entityIndex.byTag.get(tag) || []);
    this.addToCache(cacheKey, entities);
    return {
      entities,
      count: entities.length,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 按名称查询实体
   *
   * 返回具有指定名称的所有实体。
   * 名称查询使用专用索引，适用于查找特定的命名实体。
   *
   * @param name 要查询的实体名称
   * @returns 查询结果，包含匹配的实体和性能信息
   *
   * @example
   * ```typescript
   * // 查找名为"Player"的实体
   * const player = querySystem.queryByName("Player");
   * ```
   */
  queryByName(name) {
    const startTime = performance.now();
    this.queryStats.totalQueries++;
    const cacheKey = `name:${name}`;
    const cached = this.getFromCache(cacheKey);
    if (cached) {
      this.queryStats.cacheHits++;
      return {
        entities: cached,
        count: cached.length,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    this.queryStats.indexHits++;
    const entities = Array.from(this.entityIndex.byName.get(name) || []);
    this.addToCache(cacheKey, entities);
    return {
      entities,
      count: entities.length,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 按单个组件类型查询实体
   *
   * 返回包含指定组件类型的所有实体。
   * 这是最基础的查询方法，具有最高的查询性能。
   *
   * @param componentType 要查询的组件类型
   * @returns 查询结果，包含匹配的实体和性能信息
   *
   * @example
   * ```typescript
   * // 查询所有具有位置组件的实体
   * const entitiesWithPosition = querySystem.queryByComponent(PositionComponent);
   * ```
   */
  queryByComponent(componentType) {
    const startTime = performance.now();
    this.queryStats.totalQueries++;
    const cacheKey = this.generateCacheKey("component", [componentType]);
    const cached = this.getFromCache(cacheKey);
    if (cached) {
      this.queryStats.cacheHits++;
      return {
        entities: cached,
        count: cached.length,
        executionTime: performance.now() - startTime,
        fromCache: true
      };
    }
    this.queryStats.indexHits++;
    const entities = Array.from(this.entityIndex.byComponentType.get(componentType) || []);
    this.addToCache(cacheKey, entities);
    return {
      entities,
      count: entities.length,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 从缓存获取查询结果
   */
  getFromCache(cacheKey) {
    const entry = this.queryCache.get(cacheKey);
    if (!entry)
      return null;
    if (Date.now() - entry.timestamp > this.cacheTimeout || entry.version !== this._version) {
      this.queryCache.delete(cacheKey);
      return null;
    }
    entry.hitCount++;
    return entry.entities;
  }
  /**
   * 添加查询结果到缓存
   */
  addToCache(cacheKey, entities) {
    if (this.queryCache.size >= this.cacheMaxSize) {
      this.cleanupCache();
    }
    this.queryCache.set(cacheKey, {
      entities,
      // 直接使用引用，通过版本号控制失效
      timestamp: Date.now(),
      hitCount: 0,
      version: this._version
    });
  }
  /**
   * 清理缓存
   */
  cleanupCache() {
    const now = Date.now();
    for (const [key, entry] of this.queryCache.entries()) {
      if (now - entry.timestamp > this.cacheTimeout) {
        this.queryCache.delete(key);
      }
    }
    if (this.queryCache.size >= this.cacheMaxSize) {
      let minHitCount = Infinity;
      let oldestKey = "";
      let oldestTimestamp = Infinity;
      for (const [key, entry] of this.queryCache.entries()) {
        if (entry.hitCount < minHitCount || entry.hitCount === minHitCount && entry.timestamp < oldestTimestamp) {
          minHitCount = entry.hitCount;
          oldestKey = key;
          oldestTimestamp = entry.timestamp;
        }
      }
      if (oldestKey) {
        this.queryCache.delete(oldestKey);
      }
    }
  }
  /**
   * 清除所有查询缓存
   */
  clearQueryCache() {
    this.queryCache.clear();
    this.cacheKeyCache.clear();
    this.componentMaskCache.clear();
  }
  /**
   * 高效的缓存键生成
   */
  generateCacheKey(prefix, componentTypes) {
    if (componentTypes.length === 1) {
      let name = this.componentNameCache.get(componentTypes[0]);
      if (!name) {
        name = getComponentTypeName(componentTypes[0]);
        this.componentNameCache.set(componentTypes[0], name);
      }
      return `${prefix}:${name}`;
    }
    const sortKey = componentTypes.map((t) => {
      let name = this.componentNameCache.get(t);
      if (!name) {
        name = getComponentTypeName(t);
        this.componentNameCache.set(t, name);
      }
      return name;
    }).sort().join(",");
    const fullKey = `${prefix}:${sortKey}`;
    let cachedKey = this.cacheKeyCache.get(fullKey);
    if (!cachedKey) {
      cachedKey = fullKey;
      this.cacheKeyCache.set(fullKey, cachedKey);
    }
    return cachedKey;
  }
  /**
   * 清理查询缓存
   *
   * 用于外部调用清理缓存，通常在批量操作后使用。
   */
  clearCache() {
    this.clearQueryCache();
  }
  /**
   * 创建组件掩码
   *
   * 根据组件类型列表生成对应的位掩码。
   * 使用缓存避免重复计算。
   *
   * @param componentTypes 组件类型列表
   * @returns 生成的位掩码
   */
  createComponentMask(componentTypes) {
    const cacheKey = componentTypes.map((t) => {
      let name = this.componentNameCache.get(t);
      if (!name) {
        name = getComponentTypeName(t);
        this.componentNameCache.set(t, name);
      }
      return name;
    }).sort().join(",");
    const cached = this.componentMaskCache.get(cacheKey);
    if (cached) {
      return cached;
    }
    let mask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    let hasValidComponents = false;
    for (const type of componentTypes) {
      try {
        const bitMask = ComponentRegistry.getBitMask(type);
        BitMask64Utils.orInPlace(mask, bitMask);
        hasValidComponents = true;
      } catch (error) {
        this._logger.warn(`组件类型 ${getComponentTypeName(type)} 未注册，跳过`);
      }
    }
    if (!hasValidComponents) {
      mask = { lo: 4294967295, hi: 4294967295 };
    }
    this.componentMaskCache.set(cacheKey, mask);
    return mask;
  }
  /**
   * 获取当前版本号（用于缓存失效）
   */
  get version() {
    return this._version;
  }
  /**
   * 获取所有实体
   */
  getAllEntities() {
    return this.entities;
  }
  /**
   * 获取系统统计信息
   *
   * 返回查询系统的详细统计信息，包括实体数量、索引状态、
   * 查询性能统计等，用于性能监控和调试。
   *
   * @returns 系统统计信息对象
   */
  getStats() {
    return {
      entityCount: this.entities.length,
      indexStats: {
        maskIndexSize: this.entityIndex.byMask.size,
        componentIndexSize: this.entityIndex.byComponentType.size,
        tagIndexSize: this.entityIndex.byTag.size,
        nameIndexSize: this.entityIndex.byName.size
      },
      queryStats: {
        ...this.queryStats,
        cacheHitRate: this.queryStats.totalQueries > 0 ? (this.queryStats.cacheHits / this.queryStats.totalQueries * 100).toFixed(2) + "%" : "0%"
      },
      optimizationStats: {
        componentIndex: this.componentIndexManager.getStats(),
        archetypeSystem: this.archetypeSystem.getAllArchetypes().map((a) => ({
          id: a.id,
          componentTypes: a.componentTypes.map((t) => getComponentTypeName(t)),
          entityCount: a.entities.length
        }))
      },
      cacheStats: {
        size: this.queryCache.size,
        hitRate: this.queryStats.totalQueries > 0 ? (this.queryStats.cacheHits / this.queryStats.totalQueries * 100).toFixed(2) + "%" : "0%"
      }
    };
  }
  /**
   * 获取实体所属的原型信息
   *
   * @param entity 要查询的实体
   */
  getEntityArchetype(entity) {
    return this.archetypeSystem.getEntityArchetype(entity);
  }
}
class QueryBuilder {
  constructor(querySystem) {
    this._logger = createLogger("QueryBuilder");
    this.conditions = [];
    this.querySystem = querySystem;
  }
  /**
   * 添加"必须包含所有组件"条件
   *
   * @param componentTypes 必须包含的组件类型
   * @returns 查询构建器实例，支持链式调用
   */
  withAll(...componentTypes) {
    this.conditions.push({
      type: QueryConditionType.ALL,
      componentTypes,
      mask: this.createComponentMask(componentTypes)
    });
    return this;
  }
  /**
   * 添加"必须包含任意组件"条件
   *
   * @param componentTypes 必须包含其中任意一个的组件类型
   * @returns 查询构建器实例，支持链式调用
   */
  withAny(...componentTypes) {
    this.conditions.push({
      type: QueryConditionType.ANY,
      componentTypes,
      mask: this.createComponentMask(componentTypes)
    });
    return this;
  }
  /**
   * 添加"不能包含任何组件"条件
   *
   * @param componentTypes 不能包含的组件类型
   * @returns 查询构建器实例，支持链式调用
   */
  without(...componentTypes) {
    this.conditions.push({
      type: QueryConditionType.NONE,
      componentTypes,
      mask: this.createComponentMask(componentTypes)
    });
    return this;
  }
  /**
   * 执行查询并返回结果
   *
   * 根据已添加的查询条件执行实体查询。
   *
   * @returns 查询结果，包含匹配的实体和性能信息
   */
  execute() {
    const startTime = performance.now();
    if (this.conditions.length === 1) {
      const condition = this.conditions[0];
      switch (condition.type) {
        case QueryConditionType.ALL:
          return this.querySystem.queryAll(...condition.componentTypes);
        case QueryConditionType.ANY:
          return this.querySystem.queryAny(...condition.componentTypes);
        case QueryConditionType.NONE:
          return this.querySystem.queryNone(...condition.componentTypes);
      }
    }
    return {
      entities: [],
      count: 0,
      executionTime: performance.now() - startTime,
      fromCache: false
    };
  }
  /**
   * 创建组件掩码
   */
  createComponentMask(componentTypes) {
    let mask = BitMask64Utils.clone(BitMask64Utils.ZERO);
    for (const type of componentTypes) {
      try {
        const bitMask = ComponentRegistry.getBitMask(type);
        BitMask64Utils.orInPlace(mask, bitMask);
      } catch (error) {
        this._logger.warn(`组件类型 ${getComponentTypeName(type)} 未注册，跳过`);
      }
    }
    return mask;
  }
  /**
   * 重置查询构建器
   *
   * 清除所有已添加的查询条件，重新开始构建查询。
   *
   * @returns 查询构建器实例，支持链式调用
   */
  reset() {
    this.conditions = [];
    return this;
  }
}
class TypeSafeEventSystem {
  constructor() {
    this.listeners = /* @__PURE__ */ new Map();
    this.stats = /* @__PURE__ */ new Map();
    this.batchQueue = /* @__PURE__ */ new Map();
    this.batchTimers = /* @__PURE__ */ new Map();
    this.batchConfigs = /* @__PURE__ */ new Map();
    this.nextListenerId = 0;
    this.isEnabled = true;
    this.maxListeners = 100;
  }
  /**
   * 添加事件监听器
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @param config 监听器配置
   * @returns 监听器ID（用于移除）
   */
  on(eventType, handler, config = {}) {
    return this.addListener(eventType, handler, config);
  }
  /**
   * 添加一次性事件监听器
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @param config 监听器配置
   * @returns 监听器ID
   */
  once(eventType, handler, config = {}) {
    return this.addListener(eventType, handler, { ...config, once: true });
  }
  /**
   * 添加异步事件监听器
   * @param eventType 事件类型
   * @param handler 异步事件处理器
   * @param config 监听器配置
   * @returns 监听器ID
   */
  onAsync(eventType, handler, config = {}) {
    return this.addListener(eventType, handler, { ...config, async: true });
  }
  /**
   * 移除事件监听器
   * @param eventType 事件类型
   * @param listenerId 监听器ID
   * @returns 是否成功移除
   */
  off(eventType, listenerId) {
    const listeners = this.listeners.get(eventType);
    if (!listeners)
      return false;
    const index = listeners.findIndex((l) => l.id === listenerId);
    if (index === -1)
      return false;
    listeners.splice(index, 1);
    if (listeners.length === 0) {
      this.listeners.delete(eventType);
      this.stats.delete(eventType);
    }
    return true;
  }
  /**
   * 移除指定事件类型的所有监听器
   * @param eventType 事件类型
   */
  offAll(eventType) {
    this.listeners.delete(eventType);
    this.stats.delete(eventType);
    this.clearBatch(eventType);
  }
  /**
   * 触发事件
   * @param eventType 事件类型
   * @param event 事件数据
   * @returns Promise（如果有异步监听器）
   */
  async emit(eventType, event) {
    if (!this.isEnabled)
      return;
    const batchConfig = this.batchConfigs.get(eventType);
    if (batchConfig?.enabled) {
      this.addToBatch(eventType, event);
      return;
    }
    await this.executeEvent(eventType, event);
  }
  /**
   * 同步触发事件（忽略异步监听器）
   * @param eventType 事件类型
   * @param event 事件数据
   */
  emitSync(eventType, event) {
    if (!this.isEnabled)
      return;
    const listeners = this.listeners.get(eventType);
    if (!listeners || listeners.length === 0)
      return;
    const startTime = performance.now();
    const toRemove = [];
    const sortedListeners = this.sortListenersByPriority(listeners);
    for (const listener of sortedListeners) {
      if (listener.config.async)
        continue;
      try {
        if (listener.config.context) {
          listener.handler.call(listener.config.context, event);
        } else {
          listener.handler(event);
        }
        if (listener.config.once) {
          toRemove.push(listener.id);
        }
      } catch (error) {
        TypeSafeEventSystem._logger.error(`事件处理器执行错误 ${eventType}:`, error);
      }
    }
    this.removeListeners(eventType, toRemove);
    this.updateStats(eventType, performance.now() - startTime);
  }
  /**
   * 设置事件批处理配置
   * @param eventType 事件类型
   * @param config 批处理配置
   */
  setBatchConfig(eventType, config) {
    this.batchConfigs.set(eventType, config);
  }
  /**
   * 立即处理指定事件类型的批处理队列
   * @param eventType 事件类型
   */
  flushBatch(eventType) {
    const batch = this.batchQueue.get(eventType);
    if (!batch || batch.length === 0)
      return;
    const timer = this.batchTimers.get(eventType);
    if (timer) {
      clearTimeout(timer);
      this.batchTimers.delete(eventType);
    }
    this.processBatch(eventType, batch);
    this.batchQueue.delete(eventType);
  }
  /**
   * 获取事件统计信息
   * @param eventType 事件类型（可选）
   * @returns 统计信息
   */
  getStats(eventType) {
    if (eventType) {
      return this.stats.get(eventType) || this.createEmptyStats(eventType);
    }
    return new Map(this.stats);
  }
  /**
   * 重置统计信息
   * @param eventType 事件类型（可选，不指定则重置所有）
   */
  resetStats(eventType) {
    if (eventType) {
      this.stats.delete(eventType);
    } else {
      this.stats.clear();
    }
  }
  /**
   * 启用/禁用事件系统
   * @param enabled 是否启用
   */
  setEnabled(enabled) {
    this.isEnabled = enabled;
  }
  /**
   * 检查是否有指定事件类型的监听器
   * @param eventType 事件类型
   * @returns 是否有监听器
   */
  hasListeners(eventType) {
    const listeners = this.listeners.get(eventType);
    return listeners ? listeners.length > 0 : false;
  }
  /**
   * 获取指定事件类型的监听器数量
   * @param eventType 事件类型
   * @returns 监听器数量
   */
  getListenerCount(eventType) {
    const listeners = this.listeners.get(eventType);
    return listeners ? listeners.length : 0;
  }
  /**
   * 清空所有事件监听器和数据
   */
  clear() {
    this.listeners.clear();
    this.stats.clear();
    this.clearAllBatches();
  }
  /**
   * 设置每个事件类型的最大监听器数量
   * @param max 最大数量
   */
  setMaxListeners(max) {
    this.maxListeners = max;
  }
  /**
   * 添加监听器的内部实现
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @param config 配置
   * @returns 监听器ID
   */
  addListener(eventType, handler, config) {
    let listeners = this.listeners.get(eventType);
    if (!listeners) {
      listeners = [];
      this.listeners.set(eventType, listeners);
    }
    if (listeners.length >= this.maxListeners) {
      TypeSafeEventSystem._logger.warn(`事件类型 ${eventType} 的监听器数量超过最大限制 (${this.maxListeners})`);
      return "";
    }
    const listenerId = `listener_${this.nextListenerId++}`;
    const listener = {
      handler,
      config: {
        priority: 0,
        ...config
      },
      id: listenerId
    };
    listeners.push(listener);
    if (!this.stats.has(eventType)) {
      this.stats.set(eventType, this.createEmptyStats(eventType));
    }
    return listenerId;
  }
  /**
   * 执行事件的内部实现
   * @param eventType 事件类型
   * @param event 事件数据
   */
  async executeEvent(eventType, event) {
    const listeners = this.listeners.get(eventType);
    if (!listeners || listeners.length === 0)
      return;
    const startTime = performance.now();
    const toRemove = [];
    const sortedListeners = this.sortListenersByPriority(listeners);
    const syncListeners = sortedListeners.filter((l) => !l.config.async);
    const asyncListeners = sortedListeners.filter((l) => l.config.async);
    for (const listener of syncListeners) {
      try {
        if (listener.config.context) {
          listener.handler.call(listener.config.context, event);
        } else {
          listener.handler(event);
        }
        if (listener.config.once) {
          toRemove.push(listener.id);
        }
      } catch (error) {
        TypeSafeEventSystem._logger.error(`同步事件处理器执行错误 ${eventType}:`, error);
      }
    }
    const asyncPromises = asyncListeners.map(async (listener) => {
      try {
        if (listener.config.context) {
          await listener.handler.call(listener.config.context, event);
        } else {
          await listener.handler(event);
        }
        if (listener.config.once) {
          toRemove.push(listener.id);
        }
      } catch (error) {
        TypeSafeEventSystem._logger.error(`异步事件处理器执行错误 ${eventType}:`, error);
      }
    });
    await Promise.all(asyncPromises);
    this.removeListeners(eventType, toRemove);
    this.updateStats(eventType, performance.now() - startTime);
  }
  /**
   * 按优先级排序监听器
   * @param listeners 监听器数组
   * @returns 排序后的监听器数组
   */
  sortListenersByPriority(listeners) {
    return listeners.slice().sort((a, b) => (b.config.priority || 0) - (a.config.priority || 0));
  }
  /**
   * 移除指定的监听器
   * @param eventType 事件类型
   * @param listenerIds 要移除的监听器ID数组
   */
  removeListeners(eventType, listenerIds) {
    if (listenerIds.length === 0)
      return;
    const listeners = this.listeners.get(eventType);
    if (!listeners)
      return;
    for (const id of listenerIds) {
      const index = listeners.findIndex((l) => l.id === id);
      if (index !== -1) {
        listeners.splice(index, 1);
      }
    }
    if (listeners.length === 0) {
      this.listeners.delete(eventType);
      this.stats.delete(eventType);
    }
  }
  /**
   * 添加事件到批处理队列
   * @param eventType 事件类型
   * @param event 事件数据
   */
  addToBatch(eventType, event) {
    let batch = this.batchQueue.get(eventType);
    if (!batch) {
      batch = [];
      this.batchQueue.set(eventType, batch);
    }
    batch.push(event);
    const config = this.batchConfigs.get(eventType);
    if (batch.length >= config.batchSize) {
      this.flushBatch(eventType);
      return;
    }
    if (!this.batchTimers.has(eventType)) {
      const timer = setTimeout(() => {
        this.flushBatch(eventType);
      }, config.delay);
      this.batchTimers.set(eventType, timer);
    }
  }
  /**
   * 处理批处理事件
   * @param eventType 事件类型
   * @param batch 批处理事件数组
   */
  async processBatch(eventType, batch) {
    const batchEvent = {
      type: eventType,
      events: batch,
      count: batch.length,
      timestamp: Date.now()
    };
    await this.executeEvent(`${eventType}:batch`, batchEvent);
  }
  /**
   * 清除指定事件类型的批处理
   * @param eventType 事件类型
   */
  clearBatch(eventType) {
    this.batchQueue.delete(eventType);
    const timer = this.batchTimers.get(eventType);
    if (timer) {
      clearTimeout(timer);
      this.batchTimers.delete(eventType);
    }
  }
  /**
   * 清除所有批处理
   */
  clearAllBatches() {
    this.batchQueue.clear();
    for (const timer of this.batchTimers.values()) {
      clearTimeout(timer);
    }
    this.batchTimers.clear();
    this.batchConfigs.clear();
  }
  /**
   * 更新事件统计信息
   * @param eventType 事件类型
   * @param executionTime 执行时间
   */
  updateStats(eventType, executionTime) {
    let stats = this.stats.get(eventType);
    if (!stats) {
      stats = this.createEmptyStats(eventType);
      this.stats.set(eventType, stats);
    }
    stats.triggerCount++;
    stats.totalExecutionTime += executionTime;
    stats.averageExecutionTime = stats.totalExecutionTime / stats.triggerCount;
    stats.lastTriggerTime = Date.now();
    stats.listenerCount = this.getListenerCount(eventType);
  }
  /**
   * 创建空的统计信息
   * @param eventType 事件类型
   * @returns 空的统计信息
   */
  createEmptyStats(eventType) {
    return {
      eventType,
      listenerCount: 0,
      triggerCount: 0,
      totalExecutionTime: 0,
      averageExecutionTime: 0,
      lastTriggerTime: 0
    };
  }
}
TypeSafeEventSystem._logger = createLogger("EventSystem");
var ECSEventType;
(function(ECSEventType2) {
  ECSEventType2["ENTITY_CREATED"] = "entity:created";
  ECSEventType2["ENTITY_DESTROYED"] = "entity:destroyed";
  ECSEventType2["ENTITY_ENABLED"] = "entity:enabled";
  ECSEventType2["ENTITY_DISABLED"] = "entity:disabled";
  ECSEventType2["ENTITY_TAG_ADDED"] = "entity:tag:added";
  ECSEventType2["ENTITY_TAG_REMOVED"] = "entity:tag:removed";
  ECSEventType2["ENTITY_NAME_CHANGED"] = "entity:name:changed";
  ECSEventType2["COMPONENT_ADDED"] = "component:added";
  ECSEventType2["COMPONENT_REMOVED"] = "component:removed";
  ECSEventType2["COMPONENT_MODIFIED"] = "component:modified";
  ECSEventType2["COMPONENT_ENABLED"] = "component:enabled";
  ECSEventType2["COMPONENT_DISABLED"] = "component:disabled";
  ECSEventType2["SYSTEM_ADDED"] = "system:added";
  ECSEventType2["SYSTEM_REMOVED"] = "system:removed";
  ECSEventType2["SYSTEM_ENABLED"] = "system:enabled";
  ECSEventType2["SYSTEM_DISABLED"] = "system:disabled";
  ECSEventType2["SYSTEM_PROCESSING_START"] = "system:processing:start";
  ECSEventType2["SYSTEM_PROCESSING_END"] = "system:processing:end";
  ECSEventType2["SYSTEM_ERROR"] = "system:error";
  ECSEventType2["SCENE_CREATED"] = "scene:created";
  ECSEventType2["SCENE_DESTROYED"] = "scene:destroyed";
  ECSEventType2["SCENE_ACTIVATED"] = "scene:activated";
  ECSEventType2["SCENE_DEACTIVATED"] = "scene:deactivated";
  ECSEventType2["SCENE_PAUSED"] = "scene:paused";
  ECSEventType2["SCENE_RESUMED"] = "scene:resumed";
  ECSEventType2["QUERY_EXECUTED"] = "query:executed";
  ECSEventType2["QUERY_CACHE_HIT"] = "query:cache:hit";
  ECSEventType2["QUERY_CACHE_MISS"] = "query:cache:miss";
  ECSEventType2["QUERY_OPTIMIZED"] = "query:optimized";
  ECSEventType2["PERFORMANCE_WARNING"] = "performance:warning";
  ECSEventType2["PERFORMANCE_CRITICAL"] = "performance:critical";
  ECSEventType2["MEMORY_USAGE_HIGH"] = "memory:usage:high";
  ECSEventType2["FRAME_RATE_DROP"] = "frame:rate:drop";
  ECSEventType2["INDEX_CREATED"] = "index:created";
  ECSEventType2["INDEX_UPDATED"] = "index:updated";
  ECSEventType2["INDEX_OPTIMIZED"] = "index:optimized";
  ECSEventType2["ARCHETYPE_CREATED"] = "archetype:created";
  ECSEventType2["ARCHETYPE_ENTITY_ADDED"] = "archetype:entity:added";
  ECSEventType2["ARCHETYPE_ENTITY_REMOVED"] = "archetype:entity:removed";
  ECSEventType2["DIRTY_MARK_ADDED"] = "dirty:mark:added";
  ECSEventType2["DIRTY_BATCH_PROCESSED"] = "dirty:batch:processed";
  ECSEventType2["ERROR_OCCURRED"] = "error:occurred";
  ECSEventType2["WARNING_ISSUED"] = "warning:issued";
  ECSEventType2["FRAMEWORK_INITIALIZED"] = "framework:initialized";
  ECSEventType2["FRAMEWORK_SHUTDOWN"] = "framework:shutdown";
  ECSEventType2["DEBUG_INFO"] = "debug:info";
  ECSEventType2["DEBUG_STATS_UPDATED"] = "debug:stats:updated";
})(ECSEventType || (ECSEventType = {}));
var EventPriority;
(function(EventPriority2) {
  EventPriority2[EventPriority2["LOWEST"] = 0] = "LOWEST";
  EventPriority2[EventPriority2["LOW"] = 25] = "LOW";
  EventPriority2[EventPriority2["NORMAL"] = 50] = "NORMAL";
  EventPriority2[EventPriority2["HIGH"] = 75] = "HIGH";
  EventPriority2[EventPriority2["HIGHEST"] = 100] = "HIGHEST";
  EventPriority2[EventPriority2["CRITICAL"] = 200] = "CRITICAL";
})(EventPriority || (EventPriority = {}));
const EVENT_TYPES = {
  // 实体事件
  ENTITY: {
    CREATED: ECSEventType.ENTITY_CREATED,
    DESTROYED: ECSEventType.ENTITY_DESTROYED,
    ENABLED: ECSEventType.ENTITY_ENABLED,
    DISABLED: ECSEventType.ENTITY_DISABLED,
    TAG_ADDED: ECSEventType.ENTITY_TAG_ADDED,
    TAG_REMOVED: ECSEventType.ENTITY_TAG_REMOVED,
    NAME_CHANGED: ECSEventType.ENTITY_NAME_CHANGED
  },
  // 组件事件
  COMPONENT: {
    ADDED: ECSEventType.COMPONENT_ADDED,
    REMOVED: ECSEventType.COMPONENT_REMOVED,
    MODIFIED: ECSEventType.COMPONENT_MODIFIED,
    ENABLED: ECSEventType.COMPONENT_ENABLED,
    DISABLED: ECSEventType.COMPONENT_DISABLED
  },
  // 系统事件
  SYSTEM: {
    ADDED: ECSEventType.SYSTEM_ADDED,
    REMOVED: ECSEventType.SYSTEM_REMOVED,
    ENABLED: ECSEventType.SYSTEM_ENABLED,
    DISABLED: ECSEventType.SYSTEM_DISABLED,
    PROCESSING_START: ECSEventType.SYSTEM_PROCESSING_START,
    PROCESSING_END: ECSEventType.SYSTEM_PROCESSING_END,
    ERROR: ECSEventType.SYSTEM_ERROR
  },
  // 性能事件
  PERFORMANCE: {
    WARNING: ECSEventType.PERFORMANCE_WARNING,
    CRITICAL: ECSEventType.PERFORMANCE_CRITICAL,
    MEMORY_HIGH: ECSEventType.MEMORY_USAGE_HIGH,
    FRAME_DROP: ECSEventType.FRAME_RATE_DROP
  }
};
class EventTypeValidator {
  /**
   * 验证事件类型是否有效
   * @param eventType 事件类型
   * @returns 是否有效
   */
  static isValid(eventType) {
    return this.validTypes.has(eventType);
  }
  /**
   * 获取所有有效的事件类型
   * @returns 事件类型数组
   */
  static getAllValidTypes() {
    return Array.from(this.validTypes);
  }
  /**
   * 添加自定义事件类型
   * @param eventType 事件类型
   */
  static addCustomType(eventType) {
    this.validTypes.add(eventType);
  }
  /**
   * 移除自定义事件类型
   * @param eventType 事件类型
   */
  static removeCustomType(eventType) {
    this.validTypes.delete(eventType);
  }
}
EventTypeValidator.validTypes = /* @__PURE__ */ new Set([
  ...Object.values(ECSEventType),
  ...Object.values(EVENT_TYPES.ENTITY),
  ...Object.values(EVENT_TYPES.COMPONENT),
  ...Object.values(EVENT_TYPES.SYSTEM),
  ...Object.values(EVENT_TYPES.PERFORMANCE)
]);
class EventBus {
  constructor(debugMode = false) {
    this.eventIdCounter = 0;
    this.isDebugMode = false;
    this.eventSystem = new TypeSafeEventSystem();
    this.isDebugMode = debugMode;
  }
  /**
   * 发射事件
   * @param eventType 事件类型
   * @param data 事件数据
   * @param enhance 是否增强事件数据（添加timestamp、eventId等），默认false提升性能
   */
  emit(eventType, data, enhance = false) {
    this.validateEventType(eventType);
    const finalData = enhance ? this.enhanceEventData(eventType, data) : data;
    if (this.isDebugMode) {
      EventBus._logger.info(`发射事件: ${eventType}`, finalData);
    }
    this.eventSystem.emitSync(eventType, finalData);
  }
  /**
   * 异步发射事件
   * @param eventType 事件类型
   * @param data 事件数据
   * @param enhance 是否增强事件数据（添加timestamp、eventId等），默认false提升性能
   */
  async emitAsync(eventType, data, enhance = false) {
    this.validateEventType(eventType);
    const finalData = enhance ? this.enhanceEventData(eventType, data) : data;
    if (this.isDebugMode) {
      EventBus._logger.info(`发射异步事件: ${eventType}`, finalData);
    }
    await this.eventSystem.emit(eventType, finalData);
  }
  /**
   * 监听事件
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @param config 监听器配置
   * @returns 监听器ID
   */
  on(eventType, handler, config = {}) {
    this.validateEventType(eventType);
    const eventConfig = {
      once: config.once || false,
      priority: config.priority || EventPriority.NORMAL,
      async: config.async || false,
      context: config.context
    };
    if (this.isDebugMode) {
      EventBus._logger.info(`添加监听器: ${eventType}`, eventConfig);
    }
    return this.eventSystem.on(eventType, handler, eventConfig);
  }
  /**
   * 监听事件（一次性）
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @param config 监听器配置
   * @returns 监听器ID
   */
  once(eventType, handler, config = {}) {
    return this.on(eventType, handler, { ...config, once: true });
  }
  /**
   * 异步监听事件
   * @param eventType 事件类型
   * @param handler 异步事件处理器
   * @param config 监听器配置
   * @returns 监听器ID
   */
  onAsync(eventType, handler, config = {}) {
    return this.on(eventType, handler, { ...config, async: true });
  }
  /**
   * 移除事件监听器
   * @param eventType 事件类型
   * @param listenerId 监听器ID
   */
  off(eventType, listenerId) {
    if (this.isDebugMode) {
      EventBus._logger.info(`移除监听器: ${listenerId} 事件: ${eventType}`);
    }
    return this.eventSystem.off(eventType, listenerId);
  }
  /**
   * 移除指定事件类型的所有监听器
   * @param eventType 事件类型
   */
  offAll(eventType) {
    if (this.isDebugMode) {
      EventBus._logger.info(`移除所有监听器: ${eventType}`);
    }
    this.eventSystem.offAll(eventType);
  }
  /**
   * 检查是否有指定事件的监听器
   * @param eventType 事件类型
   */
  hasListeners(eventType) {
    return this.eventSystem.hasListeners(eventType);
  }
  /**
   * 获取事件统计信息
   * @param eventType 事件类型（可选）
   */
  getStats(eventType) {
    const stats = this.eventSystem.getStats(eventType);
    if (stats instanceof Map) {
      const result = /* @__PURE__ */ new Map();
      stats.forEach((stat, key) => {
        result.set(key, this.convertEventStats(stat));
      });
      return result;
    } else {
      return this.convertEventStats(stats);
    }
  }
  /**
   * 清空所有监听器
   */
  clear() {
    if (this.isDebugMode) {
      EventBus._logger.info("清空所有监听器");
    }
    this.eventSystem.clear();
  }
  /**
   * 启用或禁用事件系统
   * @param enabled 是否启用
   */
  setEnabled(enabled) {
    this.eventSystem.setEnabled(enabled);
  }
  /**
   * 设置调试模式
   * @param debug 是否启用调试
   */
  setDebugMode(debug) {
    this.isDebugMode = debug;
  }
  /**
   * 设置最大监听器数量
   * @param max 最大数量
   */
  setMaxListeners(max) {
    this.eventSystem.setMaxListeners(max);
  }
  /**
   * 获取监听器数量
   * @param eventType 事件类型
   */
  getListenerCount(eventType) {
    return this.eventSystem.getListenerCount(eventType);
  }
  /**
   * 设置事件批处理配置
   * @param eventType 事件类型
   * @param batchSize 批处理大小
   * @param delay 延迟时间（毫秒）
   */
  setBatchConfig(eventType, batchSize, delay) {
    this.eventSystem.setBatchConfig(eventType, {
      batchSize,
      delay,
      enabled: true
    });
  }
  /**
   * 刷新指定事件的批处理队列
   * @param eventType 事件类型
   */
  flushBatch(eventType) {
    this.eventSystem.flushBatch(eventType);
  }
  /**
   * 重置事件统计
   * @param eventType 事件类型（可选）
   */
  resetStats(eventType) {
    this.eventSystem.resetStats(eventType);
  }
  // 便捷方法：发射预定义的ECS事件
  /**
   * 发射实体创建事件
   * @param entityData 实体事件数据
   */
  emitEntityCreated(entityData) {
    this.emit(ECSEventType.ENTITY_CREATED, entityData);
  }
  /**
   * 发射实体销毁事件
   * @param entityData 实体事件数据
   */
  emitEntityDestroyed(entityData) {
    this.emit(ECSEventType.ENTITY_DESTROYED, entityData);
  }
  /**
   * 发射组件添加事件
   * @param componentData 组件事件数据
   */
  emitComponentAdded(componentData) {
    this.emit(ECSEventType.COMPONENT_ADDED, componentData);
  }
  /**
   * 发射组件移除事件
   * @param componentData 组件事件数据
   */
  emitComponentRemoved(componentData) {
    this.emit(ECSEventType.COMPONENT_REMOVED, componentData);
  }
  /**
   * 发射系统添加事件
   * @param systemData 系统事件数据
   */
  emitSystemAdded(systemData) {
    this.emit(ECSEventType.SYSTEM_ADDED, systemData);
  }
  /**
   * 发射系统移除事件
   * @param systemData 系统事件数据
   */
  emitSystemRemoved(systemData) {
    this.emit(ECSEventType.SYSTEM_REMOVED, systemData);
  }
  /**
   * 发射场景变化事件
   * @param sceneData 场景事件数据
   */
  emitSceneChanged(sceneData) {
    this.emit(ECSEventType.SCENE_ACTIVATED, sceneData);
  }
  /**
   * 发射性能警告事件
   * @param performanceData 性能事件数据
   */
  emitPerformanceWarning(performanceData) {
    this.emit(ECSEventType.PERFORMANCE_WARNING, performanceData);
  }
  // 便捷方法：监听预定义的ECS事件
  /**
   * 监听实体创建事件
   * @param handler 事件处理器
   * @param config 监听器配置
   */
  onEntityCreated(handler, config) {
    return this.on(ECSEventType.ENTITY_CREATED, handler, config);
  }
  /**
   * 监听组件添加事件
   * @param handler 事件处理器
   * @param config 监听器配置
   */
  onComponentAdded(handler, config) {
    return this.on(ECSEventType.COMPONENT_ADDED, handler, config);
  }
  /**
   * 监听系统错误事件
   * @param handler 事件处理器
   * @param config 监听器配置
   */
  onSystemError(handler, config) {
    return this.on(ECSEventType.SYSTEM_ERROR, handler, config);
  }
  /**
   * 监听性能警告事件
   * @param handler 事件处理器
   * @param config 监听器配置
   */
  onPerformanceWarning(handler, config) {
    return this.on(ECSEventType.PERFORMANCE_WARNING, handler, config);
  }
  // 私有方法
  /**
   * 验证事件类型（仅在debug模式下执行，提升性能）
   * @param eventType 事件类型
   */
  validateEventType(eventType) {
    if (this.isDebugMode) {
      if (!EventTypeValidator.isValid(eventType)) {
        EventBus._logger.warn(`未知事件类型: ${eventType}`);
        EventTypeValidator.addCustomType(eventType);
      }
    }
  }
  /**
   * 增强事件数据
   * @param eventType 事件类型
   * @param data 原始数据
   */
  enhanceEventData(eventType, data) {
    if (data === null || data === void 0) {
      return {
        timestamp: Date.now(),
        eventId: `${eventType}_${++this.eventIdCounter}`,
        source: "EventBus"
      };
    }
    const enhanced = data;
    if (!enhanced.timestamp) {
      enhanced.timestamp = Date.now();
    }
    if (!enhanced.eventId) {
      enhanced.eventId = `${eventType}_${++this.eventIdCounter}`;
    }
    if (!enhanced.source) {
      enhanced.source = "EventBus";
    }
    return enhanced;
  }
  /**
   * 转换EventStats为IEventStats
   * @param stats EventStats实例
   */
  convertEventStats(stats) {
    return {
      eventType: stats.eventType,
      listenerCount: stats.listenerCount,
      triggerCount: stats.triggerCount,
      totalExecutionTime: stats.totalExecutionTime,
      averageExecutionTime: stats.averageExecutionTime,
      lastTriggerTime: stats.lastTriggerTime
    };
  }
}
EventBus._logger = createLogger("EventBus");
class Scene {
  /**
   * 获取系统列表（兼容性属性）
   */
  get systems() {
    return this.entityProcessors.processors;
  }
  /**
   * 创建场景实例
   */
  constructor(config) {
    this.name = "";
    this._didSceneBegin = false;
    this.entities = new EntityList(this);
    this.entityProcessors = new EntityProcessorList();
    this.identifierPool = new IdentifierPool();
    this.componentStorageManager = new ComponentStorageManager();
    this.querySystem = new QuerySystem();
    this.eventSystem = new TypeSafeEventSystem();
    if (config?.name) {
      this.name = config.name;
    }
    if (config?.enableEntityDirectUpdate !== void 0) {
      this.entities.setEnableEntityDirectUpdate(config.enableEntityDirectUpdate);
    }
    if (!Entity.eventBus) {
      Entity.eventBus = new EventBus(false);
    }
    if (Entity.eventBus) {
      Entity.eventBus.onComponentAdded((data) => {
        this.eventSystem.emitSync("component:added", data);
      });
    }
  }
  /**
   * 初始化场景
   *
   * 在场景创建时调用，子类可以重写此方法来设置初始实体和组件。
   */
  initialize() {
  }
  /**
   * 场景开始运行时的回调
   *
   * 在场景开始运行时调用，可以在此方法中执行场景启动逻辑。
   */
  onStart() {
  }
  /**
   * 场景卸载时的回调
   *
   * 在场景被销毁时调用，可以在此方法中执行清理工作。
   */
  unload() {
  }
  /**
   * 开始场景，启动实体处理器等
   *
   * 这个方法会启动场景。它将启动实体处理器等，并调用onStart方法。
   */
  begin() {
    if (this.entityProcessors != null)
      this.entityProcessors.begin();
    this._didSceneBegin = true;
    this.onStart();
  }
  /**
   * 结束场景，清除实体、实体处理器等
   *
   * 这个方法会结束场景。它将移除所有实体，结束实体处理器等，并调用unload方法。
   */
  end() {
    this._didSceneBegin = false;
    this.entities.removeAllEntities();
    this.querySystem.setEntities([]);
    this.componentStorageManager.clear();
    if (this.entityProcessors)
      this.entityProcessors.end();
    this.unload();
  }
  /**
   * 更新场景
   */
  update() {
    this.entities.updateLists();
    if (this.entityProcessors != null)
      this.entityProcessors.update();
    this.entities.update();
    if (this.entityProcessors != null)
      this.entityProcessors.lateUpdate();
  }
  /**
   * 将实体添加到此场景，并返回它
   * @param name 实体名称
   */
  createEntity(name) {
    let entity = new Entity(name, this.identifierPool.checkOut());
    this.eventSystem.emitSync("entity:created", { entityName: name, entity, scene: this });
    return this.addEntity(entity);
  }
  /**
   * 清除所有EntitySystem的实体缓存
   * 当实体或组件发生变化时调用
   */
  clearSystemEntityCaches() {
    for (const system of this.entityProcessors.processors) {
      system.clearEntityCache();
    }
  }
  /**
   * 在场景的实体列表中添加一个实体
   * @param entity 要添加的实体
   * @param deferCacheClear 是否延迟缓存清理（用于批量操作）
   */
  addEntity(entity, deferCacheClear = false) {
    this.entities.add(entity);
    entity.scene = this;
    this.querySystem.addEntity(entity, deferCacheClear);
    if (!deferCacheClear) {
      this.clearSystemEntityCaches();
    }
    this.eventSystem.emitSync("entity:added", { entity, scene: this });
    return entity;
  }
  /**
   * 批量创建实体（高性能版本）
   * @param count 要创建的实体数量
   * @param namePrefix 实体名称前缀
   * @returns 创建的实体列表
   */
  createEntities(count, namePrefix = "Entity") {
    const entities = [];
    for (let i = 0; i < count; i++) {
      const entity = new Entity(`${namePrefix}_${i}`, this.identifierPool.checkOut());
      entity.scene = this;
      entities.push(entity);
    }
    for (const entity of entities) {
      this.entities.add(entity);
    }
    this.querySystem.addEntitiesUnchecked(entities);
    this.eventSystem.emitSync("entities:batch_added", { entities, scene: this, count });
    return entities;
  }
  /**
   * 从场景中删除所有实体
   */
  destroyAllEntities() {
    this.entities.removeAllEntities();
    this.querySystem.setEntities([]);
  }
  /**
   * 搜索并返回第一个具有名称的实体
   * @param name 实体名称
   */
  findEntity(name) {
    return this.entities.findEntity(name);
  }
  /**
   * 根据ID查找实体
   * @param id 实体ID
   */
  findEntityById(id) {
    return this.entities.findEntityById(id);
  }
  /**
   * 根据标签查找实体
   * @param tag 实体标签
   */
  findEntitiesByTag(tag) {
    const result = [];
    for (const entity of this.entities.buffer) {
      if (entity.tag === tag) {
        result.push(entity);
      }
    }
    return result;
  }
  /**
   * 根据名称查找实体（别名方法）
   * @param name 实体名称
   */
  getEntityByName(name) {
    return this.findEntity(name);
  }
  /**
   * 根据标签查找实体（别名方法）
   * @param tag 实体标签
   */
  getEntitiesByTag(tag) {
    return this.findEntitiesByTag(tag);
  }
  /**
   * 在场景中添加一个EntitySystem处理器
   * @param processor 处理器
   */
  addEntityProcessor(processor) {
    if (this.entityProcessors.processors.includes(processor)) {
      return processor;
    }
    processor.scene = this;
    this.entityProcessors.add(processor);
    processor.initialize();
    processor.setUpdateOrder(this.entityProcessors.count - 1);
    return processor;
  }
  /**
   * 添加系统到场景（addEntityProcessor的别名）
   * @param system 系统
   */
  addSystem(system) {
    return this.addEntityProcessor(system);
  }
  /**
   * 从场景中删除EntitySystem处理器
   * @param processor 要删除的处理器
   */
  removeEntityProcessor(processor) {
    this.entityProcessors.remove(processor);
    processor.reset();
  }
  /**
   * 从场景中删除系统（removeEntityProcessor的别名）
   * @param system 系统
   */
  removeSystem(system) {
    this.removeEntityProcessor(system);
  }
  /**
   * 获取指定类型的EntitySystem处理器
   * @param type 处理器类型
   */
  getEntityProcessor(type) {
    return this.entityProcessors.getProcessor(type);
  }
  /**
   * 获取场景统计信息
   */
  getStats() {
    return {
      entityCount: this.entities.count,
      processorCount: this.entityProcessors.count,
      componentStorageStats: this.componentStorageManager.getAllStats()
    };
  }
  /**
   * 获取场景的调试信息
   */
  getDebugInfo() {
    return {
      name: this.name || this.constructor.name,
      entityCount: this.entities.count,
      processorCount: this.entityProcessors.count,
      isRunning: this._didSceneBegin,
      entities: this.entities.buffer.map((entity) => ({
        name: entity.name,
        id: entity.id,
        componentCount: entity.components.length,
        componentTypes: entity.components.map((c) => getComponentInstanceTypeName(c))
      })),
      processors: this.entityProcessors.processors.map((processor) => ({
        name: getSystemInstanceTypeName(processor),
        updateOrder: processor.updateOrder,
        entityCount: processor._entities?.length || 0
      })),
      componentStats: this.componentStorageManager.getAllStats()
    };
  }
}
class SceneBuilder {
  constructor() {
    this.scene = new Scene();
  }
  /**
   * 设置场景名称
   * @param name 场景名称
   * @returns 场景构建器
   */
  named(name) {
    this.scene.name = name;
    return this;
  }
  /**
   * 添加实体
   * @param entity 实体
   * @returns 场景构建器
   */
  withEntity(entity) {
    this.scene.addEntity(entity);
    return this;
  }
  /**
   * 使用实体构建器添加实体
   * @param builderFn 实体构建器函数
   * @returns 场景构建器
   */
  withEntityBuilder(builderFn) {
    const builder = new EntityBuilder(this.scene, this.scene.componentStorageManager);
    const configuredBuilder = builderFn(builder);
    const entity = configuredBuilder.build();
    this.scene.addEntity(entity);
    return this;
  }
  /**
   * 批量添加实体
   * @param entities 实体数组
   * @returns 场景构建器
   */
  withEntities(...entities) {
    for (const entity of entities) {
      this.scene.addEntity(entity);
    }
    return this;
  }
  /**
   * 添加系统
   * @param system 系统实例
   * @returns 场景构建器
   */
  withSystem(system) {
    this.scene.addSystem(system);
    return this;
  }
  /**
   * 批量添加系统
   * @param systems 系统数组
   * @returns 场景构建器
   */
  withSystems(...systems) {
    for (const system of systems) {
      this.scene.addSystem(system);
    }
    return this;
  }
  /**
   * 构建并返回场景
   * @returns 构建的场景
   */
  build() {
    return this.scene;
  }
}
class ComponentBuilder {
  constructor(componentClass, ...args) {
    this.component = new componentClass(...args);
  }
  /**
   * 设置组件属性
   * @param property 属性名
   * @param value 属性值
   * @returns 组件构建器
   */
  set(property, value) {
    this.component[property] = value;
    return this;
  }
  /**
   * 使用配置函数设置组件
   * @param configurator 配置函数
   * @returns 组件构建器
   */
  configure(configurator) {
    configurator(this.component);
    return this;
  }
  /**
   * 条件性设置属性
   * @param condition 条件
   * @param property 属性名
   * @param value 属性值
   * @returns 组件构建器
   */
  setIf(condition, property, value) {
    if (condition) {
      this.component[property] = value;
    }
    return this;
  }
  /**
   * 构建并返回组件
   * @returns 构建的组件
   */
  build() {
    return this.component;
  }
}
class EntityBatchOperator {
  constructor(entities) {
    this.entities = entities;
  }
  /**
   * 批量添加组件
   * @param component 组件实例
   * @returns 批量操作器
   */
  addComponent(component) {
    for (const entity of this.entities) {
      entity.addComponent(component);
    }
    return this;
  }
  /**
   * 批量移除组件
   * @param componentType 组件类型
   * @returns 批量操作器
   */
  removeComponent(componentType) {
    for (const entity of this.entities) {
      entity.removeComponentByType(componentType);
    }
    return this;
  }
  /**
   * 批量设置活跃状态
   * @param active 是否活跃
   * @returns 批量操作器
   */
  setActive(active) {
    for (const entity of this.entities) {
      entity.active = active;
    }
    return this;
  }
  /**
   * 批量设置标签
   * @param tag 标签
   * @returns 批量操作器
   */
  setTag(tag) {
    for (const entity of this.entities) {
      entity.tag = tag;
    }
    return this;
  }
  /**
   * 批量执行操作
   * @param operation 操作函数
   * @returns 批量操作器
   */
  forEach(operation) {
    this.entities.forEach(operation);
    return this;
  }
  /**
   * 过滤实体
   * @param predicate 过滤条件
   * @returns 新的批量操作器
   */
  filter(predicate) {
    return new EntityBatchOperator(this.entities.filter(predicate));
  }
  /**
   * 获取实体数组
   * @returns 实体数组
   */
  toArray() {
    return this.entities.slice();
  }
  /**
   * 获取实体数量
   * @returns 实体数量
   */
  count() {
    return this.entities.length;
  }
}
class ECSFluentAPI {
  constructor(scene, querySystem, eventSystem) {
    this.scene = scene;
    this.querySystem = querySystem;
    this.eventSystem = eventSystem;
  }
  /**
   * 创建实体构建器
   * @returns 实体构建器
   */
  createEntity() {
    return new EntityBuilder(this.scene, this.scene.componentStorageManager);
  }
  /**
   * 创建场景构建器
   * @returns 场景构建器
   */
  createScene() {
    return new SceneBuilder();
  }
  /**
   * 创建组件构建器
   * @param componentClass 组件类
   * @param args 构造参数
   * @returns 组件构建器
   */
  createComponent(componentClass, ...args) {
    return new ComponentBuilder(componentClass, ...args);
  }
  /**
   * 创建查询构建器
   * @returns 查询构建器
   */
  query() {
    return new QueryBuilder(this.querySystem);
  }
  /**
   * 查找实体
   * @param componentTypes 组件类型
   * @returns 实体数组
   */
  find(...componentTypes) {
    return this.querySystem.queryAll(...componentTypes).entities;
  }
  /**
   * 查找第一个匹配的实体
   * @param componentTypes 组件类型
   * @returns 实体或null
   */
  findFirst(...componentTypes) {
    const result = this.querySystem.queryAll(...componentTypes);
    return result.entities.length > 0 ? result.entities[0] : null;
  }
  /**
   * 按名称查找实体
   * @param name 实体名称
   * @returns 实体或null
   */
  findByName(name) {
    return this.scene.findEntity(name);
  }
  /**
   * 按标签查找实体
   * @param tag 标签
   * @returns 实体数组
   */
  findByTag(tag) {
    return this.scene.findEntitiesByTag(tag);
  }
  /**
   * 触发事件
   * @param eventType 事件类型
   * @param event 事件数据
   */
  emit(eventType, event) {
    this.eventSystem.emitSync(eventType, event);
  }
  /**
   * 异步触发事件
   * @param eventType 事件类型
   * @param event 事件数据
   */
  async emitAsync(eventType, event) {
    await this.eventSystem.emit(eventType, event);
  }
  /**
   * 监听事件
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @returns 监听器ID
   */
  on(eventType, handler) {
    return this.eventSystem.on(eventType, handler);
  }
  /**
   * 一次性监听事件
   * @param eventType 事件类型
   * @param handler 事件处理器
   * @returns 监听器ID
   */
  once(eventType, handler) {
    return this.eventSystem.once(eventType, handler);
  }
  /**
   * 移除事件监听器
   * @param eventType 事件类型
   * @param listenerId 监听器ID
   */
  off(eventType, listenerId) {
    this.eventSystem.off(eventType, listenerId);
  }
  /**
   * 批量操作实体
   * @param entities 实体数组
   * @returns 批量操作器
   */
  batch(entities) {
    return new EntityBatchOperator(entities);
  }
  /**
   * 获取场景统计信息
   * @returns 统计信息
   */
  getStats() {
    return {
      entityCount: this.scene.entities.count,
      systemCount: this.scene.systems.length,
      componentStats: this.scene.componentStorageManager.getAllStats(),
      queryStats: this.querySystem.getStats(),
      eventStats: this.eventSystem.getStats()
    };
  }
}
function createECSAPI(scene, querySystem, eventSystem) {
  return new ECSFluentAPI(scene, querySystem, eventSystem);
}
const logger$1 = createLogger("World");
class World {
  constructor(config = {}) {
    this._scenes = /* @__PURE__ */ new Map();
    this._activeScenes = /* @__PURE__ */ new Set();
    this._globalSystems = [];
    this._isActive = false;
    this._config = {
      name: "World",
      debug: false,
      maxScenes: 10,
      autoCleanup: true,
      ...config
    };
    this.name = this._config.name;
    this._createdAt = Date.now();
    logger$1.info(`创建World: ${this.name}`);
  }
  // ===== Scene管理 =====
  /**
   * 创建并添加Scene到World
   */
  createScene(sceneId, sceneInstance) {
    if (this._scenes.has(sceneId)) {
      throw new Error(`Scene ID '${sceneId}' 已存在于World '${this.name}' 中`);
    }
    if (this._scenes.size >= this._config.maxScenes) {
      throw new Error(`World '${this.name}' 已达到最大Scene数量限制: ${this._config.maxScenes}`);
    }
    const scene = sceneInstance || new Scene();
    if ("id" in scene) {
      scene.id = sceneId;
    }
    if ("name" in scene && !scene.name) {
      scene.name = sceneId;
    }
    this._scenes.set(sceneId, scene);
    scene.initialize();
    logger$1.info(`在World '${this.name}' 中创建Scene: ${sceneId}`);
    return scene;
  }
  /**
   * 移除Scene
   */
  removeScene(sceneId) {
    const scene = this._scenes.get(sceneId);
    if (!scene) {
      return false;
    }
    if (this._activeScenes.has(sceneId)) {
      this.setSceneActive(sceneId, false);
    }
    scene.end();
    this._scenes.delete(sceneId);
    logger$1.info(`从World '${this.name}' 中移除Scene: ${sceneId}`);
    return true;
  }
  /**
   * 获取Scene
   */
  getScene(sceneId) {
    return this._scenes.get(sceneId) || null;
  }
  /**
   * 获取所有Scene ID
   */
  getSceneIds() {
    return Array.from(this._scenes.keys());
  }
  /**
   * 获取所有Scene
   */
  getAllScenes() {
    return Array.from(this._scenes.values());
  }
  /**
   * 设置Scene激活状态
   */
  setSceneActive(sceneId, active) {
    const scene = this._scenes.get(sceneId);
    if (!scene) {
      logger$1.warn(`Scene '${sceneId}' 不存在于World '${this.name}' 中`);
      return;
    }
    if (active) {
      this._activeScenes.add(sceneId);
      if (scene.begin) {
        scene.begin();
      }
      logger$1.debug(`在World '${this.name}' 中激活Scene: ${sceneId}`);
    } else {
      this._activeScenes.delete(sceneId);
      logger$1.debug(`在World '${this.name}' 中停用Scene: ${sceneId}`);
    }
  }
  /**
   * 检查Scene是否激活
   */
  isSceneActive(sceneId) {
    return this._activeScenes.has(sceneId);
  }
  /**
   * 获取活跃Scene数量
   */
  getActiveSceneCount() {
    return this._activeScenes.size;
  }
  // ===== 全局System管理 =====
  /**
   * 添加全局System
   * 全局System会在所有激活Scene之前更新
   */
  addGlobalSystem(system) {
    if (this._globalSystems.includes(system)) {
      return system;
    }
    this._globalSystems.push(system);
    if (system.initialize) {
      system.initialize();
    }
    logger$1.debug(`在World '${this.name}' 中添加全局System: ${system.name}`);
    return system;
  }
  /**
   * 移除全局System
   */
  removeGlobalSystem(system) {
    const index = this._globalSystems.indexOf(system);
    if (index === -1) {
      return false;
    }
    this._globalSystems.splice(index, 1);
    if (system.reset) {
      system.reset();
    }
    logger$1.debug(`从World '${this.name}' 中移除全局System: ${system.name}`);
    return true;
  }
  /**
   * 获取全局System
   */
  getGlobalSystem(type) {
    for (const system of this._globalSystems) {
      if (system instanceof type) {
        return system;
      }
    }
    return null;
  }
  // ===== World生命周期 =====
  /**
   * 启动World
   */
  start() {
    if (this._isActive) {
      return;
    }
    this._isActive = true;
    for (const system of this._globalSystems) {
      if (system.initialize) {
        system.initialize();
      }
    }
    logger$1.info(`启动World: ${this.name}`);
  }
  /**
   * 停止World
   */
  stop() {
    if (!this._isActive) {
      return;
    }
    for (const sceneId of this._activeScenes) {
      this.setSceneActive(sceneId, false);
    }
    for (const system of this._globalSystems) {
      if (system.reset) {
        system.reset();
      }
    }
    this._isActive = false;
    logger$1.info(`停止World: ${this.name}`);
  }
  /**
   * 更新World中的全局System
   * 注意：此方法由Core.update()调用，不应直接调用
   */
  updateGlobalSystems() {
    if (!this._isActive) {
      return;
    }
    for (const system of this._globalSystems) {
      if (system.update) {
        system.update();
      }
    }
  }
  /**
   * 更新World中的所有激活Scene
   * 注意：此方法由Core.update()调用，不应直接调用
   */
  updateScenes() {
    if (!this._isActive) {
      return;
    }
    for (const sceneId of this._activeScenes) {
      const scene = this._scenes.get(sceneId);
      if (scene && scene.update) {
        scene.update();
      }
    }
    if (this._config.autoCleanup && this.shouldAutoCleanup()) {
      this.cleanup();
    }
  }
  /**
   * 销毁World
   */
  destroy() {
    logger$1.info(`销毁World: ${this.name}`);
    this.stop();
    const sceneIds = Array.from(this._scenes.keys());
    for (const sceneId of sceneIds) {
      this.removeScene(sceneId);
    }
    for (const system of this._globalSystems) {
      if (system.destroy) {
        system.destroy();
      } else if (system.reset) {
        system.reset();
      }
    }
    this._globalSystems.length = 0;
    this._scenes.clear();
    this._activeScenes.clear();
  }
  // ===== 状态信息 =====
  /**
   * 获取World状态
   */
  getStatus() {
    return {
      name: this.name,
      isActive: this._isActive,
      sceneCount: this._scenes.size,
      activeSceneCount: this._activeScenes.size,
      globalSystemCount: this._globalSystems.length,
      createdAt: this._createdAt,
      config: { ...this._config },
      scenes: Array.from(this._scenes.keys()).map((sceneId) => ({
        id: sceneId,
        isActive: this._activeScenes.has(sceneId),
        name: this._scenes.get(sceneId)?.name || sceneId
      }))
    };
  }
  /**
   * 获取World统计信息
   */
  getStats() {
    const stats = {
      totalEntities: 0,
      totalSystems: this._globalSystems.length,
      memoryUsage: 0,
      performance: {
        averageUpdateTime: 0,
        maxUpdateTime: 0
      }
    };
    for (const scene of this._scenes.values()) {
      if (scene.entities) {
        stats.totalEntities += scene.entities.count;
      }
      if (scene.systems) {
        stats.totalSystems += scene.systems.length;
      }
    }
    return stats;
  }
  // ===== 私有方法 =====
  /**
   * 检查是否应该执行自动清理
   */
  shouldAutoCleanup() {
    const currentTime = Date.now();
    const cleanupThreshold = 5 * 60 * 1e3;
    for (const [sceneId, scene] of this._scenes) {
      if (!this._activeScenes.has(sceneId) && scene.entities && scene.entities.count === 0 && currentTime - this._createdAt > cleanupThreshold) {
        return true;
      }
    }
    return false;
  }
  /**
   * 执行清理操作
   */
  cleanup() {
    const sceneIds = Array.from(this._scenes.keys());
    const currentTime = Date.now();
    const cleanupThreshold = 5 * 60 * 1e3;
    for (const sceneId of sceneIds) {
      const scene = this._scenes.get(sceneId);
      if (scene && !this._activeScenes.has(sceneId) && scene.entities && scene.entities.count === 0 && currentTime - this._createdAt > cleanupThreshold) {
        this.removeScene(sceneId);
        logger$1.debug(`自动清理空Scene: ${sceneId} from World ${this.name}`);
      }
    }
  }
  // ===== 访问器 =====
  /**
   * 检查World是否激活
   */
  get isActive() {
    return this._isActive;
  }
  /**
   * 获取Scene数量
   */
  get sceneCount() {
    return this._scenes.size;
  }
  /**
   * 获取创建时间
   */
  get createdAt() {
    return this._createdAt;
  }
}
const logger = createLogger("WorldManager");
class WorldManager {
  constructor(config = {}) {
    this._worlds = /* @__PURE__ */ new Map();
    this._activeWorlds = /* @__PURE__ */ new Set();
    this._cleanupTimer = null;
    this._isRunning = false;
    this._config = {
      maxWorlds: 50,
      autoCleanup: true,
      cleanupInterval: 3e4,
      // 30秒
      debug: false,
      ...config
    };
    logger.info("WorldManager已初始化", {
      maxWorlds: this._config.maxWorlds,
      autoCleanup: this._config.autoCleanup,
      cleanupInterval: this._config.cleanupInterval
    });
    this.startCleanupTimer();
  }
  /**
   * 获取WorldManager单例实例
   */
  static getInstance(config) {
    if (!this._instance) {
      this._instance = new WorldManager(config);
    }
    return this._instance;
  }
  /**
   * 重置WorldManager实例（主要用于测试）
   */
  static reset() {
    if (this._instance) {
      this._instance.destroy();
      this._instance = null;
    }
  }
  // ===== World管理 =====
  /**
   * 创建新World
   */
  createWorld(worldId, config) {
    if (!worldId || typeof worldId !== "string" || worldId.trim() === "") {
      throw new Error("World ID不能为空");
    }
    if (this._worlds.has(worldId)) {
      throw new Error(`World ID '${worldId}' 已存在`);
    }
    if (this._worlds.size >= this._config.maxWorlds) {
      throw new Error(`已达到最大World数量限制: ${this._config.maxWorlds}`);
    }
    const worldConfig = {
      name: worldId,
      debug: this._config.debug,
      ...config
    };
    const world = new World(worldConfig);
    this._worlds.set(worldId, world);
    logger.info(`创建World: ${worldId}`, { config: worldConfig });
    return world;
  }
  /**
   * 移除World
   */
  removeWorld(worldId) {
    const world = this._worlds.get(worldId);
    if (!world) {
      return false;
    }
    if (this._activeWorlds.has(worldId)) {
      this.setWorldActive(worldId, false);
    }
    world.destroy();
    this._worlds.delete(worldId);
    logger.info(`移除World: ${worldId}`);
    return true;
  }
  /**
   * 获取World
   */
  getWorld(worldId) {
    return this._worlds.get(worldId) || null;
  }
  /**
   * 获取所有World ID
   */
  getWorldIds() {
    return Array.from(this._worlds.keys());
  }
  /**
   * 获取所有World
   */
  getAllWorlds() {
    return Array.from(this._worlds.values());
  }
  /**
   * 设置World激活状态
   */
  setWorldActive(worldId, active) {
    const world = this._worlds.get(worldId);
    if (!world) {
      logger.warn(`World '${worldId}' 不存在`);
      return;
    }
    if (active) {
      this._activeWorlds.add(worldId);
      world.start();
      logger.debug(`激活World: ${worldId}`);
    } else {
      this._activeWorlds.delete(worldId);
      world.stop();
      logger.debug(`停用World: ${worldId}`);
    }
  }
  /**
   * 检查World是否激活
   */
  isWorldActive(worldId) {
    return this._activeWorlds.has(worldId);
  }
  // ===== 批量操作 =====
  /**
   * 获取所有激活的World
   * 注意：此方法供Core.update()使用
   */
  getActiveWorlds() {
    const activeWorlds = [];
    for (const worldId of this._activeWorlds) {
      const world = this._worlds.get(worldId);
      if (world) {
        activeWorlds.push(world);
      }
    }
    return activeWorlds;
  }
  /**
   * 启动所有World
   */
  startAll() {
    this._isRunning = true;
    for (const worldId of this._worlds.keys()) {
      this.setWorldActive(worldId, true);
    }
    logger.info("启动所有World");
  }
  /**
   * 停止所有World
   */
  stopAll() {
    this._isRunning = false;
    for (const worldId of this._activeWorlds) {
      this.setWorldActive(worldId, false);
    }
    logger.info("停止所有World");
  }
  /**
   * 查找满足条件的World
   */
  findWorlds(predicate) {
    const results = [];
    for (const world of this._worlds.values()) {
      if (predicate(world)) {
        results.push(world);
      }
    }
    return results;
  }
  /**
   * 根据名称查找World
   */
  findWorldByName(name) {
    for (const world of this._worlds.values()) {
      if (world.name === name) {
        return world;
      }
    }
    return null;
  }
  // ===== 统计和监控 =====
  /**
   * 获取WorldManager统计信息
   */
  getStats() {
    const stats = {
      totalWorlds: this._worlds.size,
      activeWorlds: this._activeWorlds.size,
      totalScenes: 0,
      totalEntities: 0,
      totalSystems: 0,
      memoryUsage: 0,
      isRunning: this._isRunning,
      config: { ...this._config },
      worlds: []
    };
    for (const [worldId, world] of this._worlds) {
      const worldStats = world.getStats();
      stats.totalScenes += worldStats.totalSystems;
      stats.totalEntities += worldStats.totalEntities;
      stats.totalSystems += worldStats.totalSystems;
      stats.worlds.push({
        id: worldId,
        name: world.name,
        isActive: this._activeWorlds.has(worldId),
        sceneCount: world.sceneCount,
        ...worldStats
      });
    }
    return stats;
  }
  /**
   * 获取详细状态信息
   */
  getDetailedStatus() {
    return {
      ...this.getStats(),
      worlds: Array.from(this._worlds.entries()).map(([worldId, world]) => ({
        id: worldId,
        isActive: this._activeWorlds.has(worldId),
        status: world.getStatus()
      }))
    };
  }
  // ===== 生命周期管理 =====
  /**
   * 清理空World
   */
  cleanup() {
    const worldsToRemove = [];
    for (const [worldId, world] of this._worlds) {
      if (this.shouldCleanupWorld(world)) {
        worldsToRemove.push(worldId);
      }
    }
    for (const worldId of worldsToRemove) {
      this.removeWorld(worldId);
    }
    if (worldsToRemove.length > 0) {
      logger.debug(`清理了 ${worldsToRemove.length} 个World`);
    }
    return worldsToRemove.length;
  }
  /**
   * 销毁WorldManager
   */
  destroy() {
    logger.info("正在销毁WorldManager...");
    this.stopCleanupTimer();
    this.stopAll();
    const worldIds = Array.from(this._worlds.keys());
    for (const worldId of worldIds) {
      this.removeWorld(worldId);
    }
    this._worlds.clear();
    this._activeWorlds.clear();
    this._isRunning = false;
    logger.info("WorldManager已销毁");
  }
  // ===== 私有方法 =====
  /**
   * 启动清理定时器
   */
  startCleanupTimer() {
    if (!this._config.autoCleanup || this._cleanupTimer) {
      return;
    }
    this._cleanupTimer = setInterval(() => {
      this.cleanup();
    }, this._config.cleanupInterval);
    logger.debug(`启动World清理定时器，间隔: ${this._config.cleanupInterval}ms`);
  }
  /**
   * 停止清理定时器
   */
  stopCleanupTimer() {
    if (this._cleanupTimer) {
      clearInterval(this._cleanupTimer);
      this._cleanupTimer = null;
      logger.debug("停止World清理定时器");
    }
  }
  /**
   * 判断World是否应该被清理
   */
  shouldCleanupWorld(world) {
    if (world.isActive) {
      return false;
    }
    if (world.sceneCount === 0) {
      const age = Date.now() - world.createdAt;
      return age > 10 * 60 * 1e3;
    }
    const allScenes = world.getAllScenes();
    const hasEntities = allScenes.some((scene) => scene.entities && scene.entities.count > 0);
    if (!hasEntities) {
      const age = Date.now() - world.createdAt;
      return age > 10 * 60 * 1e3;
    }
    return false;
  }
  // ===== 访问器 =====
  /**
   * 获取World总数
   */
  get worldCount() {
    return this._worlds.size;
  }
  /**
   * 获取激活World数量
   */
  get activeWorldCount() {
    return this._activeWorlds.size;
  }
  /**
   * 检查是否正在运行
   */
  get isRunning() {
    return this._isRunning;
  }
  /**
   * 获取配置
   */
  get config() {
    return { ...this._config };
  }
}
WorldManager._instance = null;
class Bits {
  /**
   * 构造函数，创建位集合
   * @param initialValue 初始值，可以是BitMask64Data对象、数字或字符串
   */
  constructor(initialValue) {
    if (initialValue && typeof initialValue === "object") {
      this._value = BitMask64Utils.clone(initialValue);
    } else if (typeof initialValue === "number") {
      this._value = BitMask64Utils.fromNumber(initialValue);
    } else if (typeof initialValue === "string") {
      const num = parseInt(initialValue, 10);
      this._value = BitMask64Utils.fromNumber(num);
    } else {
      this._value = BitMask64Utils.clone(BitMask64Utils.ZERO);
    }
  }
  /**
   * 设置指定位为1
   * @param index 位索引，范围 [0, 63]
   * @throws 当位索引为负数或超过64位限制时抛出错误
   */
  set(index) {
    if (index < 0) {
      throw new Error("Bit index cannot be negative");
    }
    if (index >= 64) {
      throw new Error("Bit index exceeds 64-bit limit. ECS framework supports max 64 component types.");
    }
    BitMask64Utils.setBit(this._value, index);
  }
  /**
   * 清除指定位为0
   * @param index 位索引，范围 [0, 63]
   * @throws 当位索引为负数时抛出错误
   */
  clear(index) {
    if (index < 0) {
      throw new Error("Bit index cannot be negative");
    }
    if (index >= 64) {
      return;
    }
    BitMask64Utils.clearBit(this._value, index);
  }
  /**
   * 获取指定位的值
   * @param index 位索引
   * @returns 如果位被设置为1则返回true，否则返回false
   */
  get(index) {
    if (index < 0 || index >= 64) {
      return false;
    }
    const mask = BitMask64Utils.create(index);
    return BitMask64Utils.hasAny(this._value, mask);
  }
  /**
   * 检查是否包含另一个位集合的所有位
   * @param other 另一个位集合
   * @returns 如果包含other的所有设置位则返回true
   */
  containsAll(other) {
    return BitMask64Utils.hasAll(this._value, other._value);
  }
  /**
   * 检查是否与另一个位集合有交集
   * @param other 另一个位集合
   * @returns 如果有共同的设置位则返回true
   */
  intersects(other) {
    return BitMask64Utils.hasAny(this._value, other._value);
  }
  /**
   * 检查是否与另一个位集合没有交集
   * @param other 另一个位集合
   * @returns 如果没有共同的设置位则返回true
   */
  excludes(other) {
    return BitMask64Utils.hasNone(this._value, other._value);
  }
  /**
   * 清除所有位为0
   */
  clearAll() {
    BitMask64Utils.clear(this._value);
  }
  /**
   * 检查位集合是否为空
   * @returns 如果所有位都为0则返回true
   */
  isEmpty() {
    return BitMask64Utils.isZero(this._value);
  }
  /**
   * 计算设置为1的位数
   * @returns 设置位的总数
   */
  cardinality() {
    return BitMask64Utils.popCount(this._value);
  }
  /**
   * 与另一个位集合执行按位与操作
   * @param other 另一个位集合
   * @returns 新的位集合，包含按位与的结果
   */
  and(other) {
    const result = new Bits();
    BitMask64Utils.copy(this._value, result._value);
    BitMask64Utils.andInPlace(result._value, other._value);
    return result;
  }
  /**
   * 与另一个位集合执行按位或操作
   * @param other 另一个位集合
   * @returns 新的位集合，包含按位或的结果
   */
  or(other) {
    const result = new Bits();
    BitMask64Utils.copy(this._value, result._value);
    BitMask64Utils.orInPlace(result._value, other._value);
    return result;
  }
  /**
   * 与另一个位集合执行按位异或操作
   * @param other 另一个位集合
   * @returns 新的位集合，包含按位异或的结果
   */
  xor(other) {
    const result = new Bits();
    BitMask64Utils.copy(this._value, result._value);
    BitMask64Utils.xorInPlace(result._value, other._value);
    return result;
  }
  /**
   * 执行按位取反操作
   * @param maxBits 最大位数，默认为64
   * @returns 新的位集合，包含按位取反的结果
   */
  not(maxBits = 64) {
    if (maxBits > 64) {
      maxBits = 64;
    }
    const result = new Bits();
    BitMask64Utils.copy(this._value, result._value);
    if (maxBits <= 32) {
      const mask = (1 << maxBits) - 1;
      result._value.lo = ~result._value.lo & mask;
      result._value.hi = 0;
    } else {
      result._value.lo = ~result._value.lo;
      if (maxBits < 64) {
        const remainingBits = maxBits - 32;
        const mask = (1 << remainingBits) - 1;
        result._value.hi = ~result._value.hi & mask;
      } else {
        result._value.hi = ~result._value.hi;
      }
    }
    return result;
  }
  /**
   * 从另一个位集合复制值
   * @param other 源位集合
   */
  copyFrom(other) {
    BitMask64Utils.copy(other._value, this._value);
  }
  /**
   * 创建当前位集合的深拷贝
   * @returns 新的位集合，内容与当前位集合相同
   */
  clone() {
    return new Bits(this._value);
  }
  /**
   * 获取内部的64位掩码数据
   * @returns 内部存储的BitMask64Data对象
   */
  getValue() {
    return this._value;
  }
  /**
   * 设置位集合的值
   * @param value 新值，可以是BitMask64Data对象、数字或字符串
   */
  setValue(value) {
    if (typeof value === "object") {
      BitMask64Utils.copy(value, this._value);
    } else if (typeof value === "number") {
      this._value = BitMask64Utils.fromNumber(value);
    } else {
      const num = parseInt(value, 10);
      this._value = BitMask64Utils.fromNumber(num);
    }
  }
  /**
   * 将位集合转换为可读字符串
   * @returns 格式为"Bits[index1, index2, ...]"的字符串
   */
  toString() {
    const bits = [];
    for (let i = 0; i < 64; i++) {
      if (this.get(i)) {
        bits.push(i.toString());
      }
    }
    return `Bits[${bits.join(", ")}]`;
  }
  /**
   * 将位集合转换为二进制字符串
   * @param maxBits 最大位数，默认为64
   * @returns 二进制字符串表示，每8位用空格分隔
   */
  toBinaryString(maxBits = 64) {
    if (maxBits > 64)
      maxBits = 64;
    let result = "";
    for (let i = maxBits - 1; i >= 0; i--) {
      result += this.get(i) ? "1" : "0";
      if (i % 8 === 0 && i > 0) {
        result += " ";
      }
    }
    return result;
  }
  /**
   * 将位集合转换为十六进制字符串
   * @returns 十六进制字符串表示，带0x前缀
   */
  toHexString() {
    return BitMask64Utils.toString(this._value, 16);
  }
  /**
   * 从二进制字符串创建位集合
   * @param binaryString 二进制字符串，可以包含空格
   * @returns 新的位集合对象
   */
  static fromBinaryString(binaryString) {
    const cleanString = binaryString.replace(/\s/g, "");
    let data;
    if (cleanString.length <= 32) {
      const num = parseInt(cleanString, 2);
      data = { lo: num >>> 0, hi: 0 };
    } else {
      const loBits = cleanString.substring(cleanString.length - 32);
      const hiBits = cleanString.substring(0, cleanString.length - 32);
      const lo = parseInt(loBits, 2);
      const hi = parseInt(hiBits, 2);
      data = { lo: lo >>> 0, hi: hi >>> 0 };
    }
    return new Bits(data);
  }
  /**
   * 从十六进制字符串创建位集合
   * @param hexString 十六进制字符串，可以带或不带0x前缀
   * @returns 新的位集合对象
   */
  static fromHexString(hexString) {
    const cleanString = hexString.replace(/^0x/i, "");
    let data;
    if (cleanString.length <= 8) {
      const num = parseInt(cleanString, 16);
      data = { lo: num >>> 0, hi: 0 };
    } else {
      const loBits = cleanString.substring(cleanString.length - 8);
      const hiBits = cleanString.substring(0, cleanString.length - 8);
      const lo = parseInt(loBits, 16);
      const hi = parseInt(hiBits, 16);
      data = { lo: lo >>> 0, hi: hi >>> 0 };
    }
    return new Bits(data);
  }
  /**
   * 检查是否与另一个位集合相等
   * @param other 另一个位集合
   * @returns 如果两个位集合完全相同则返回true
   */
  equals(other) {
    return BitMask64Utils.equals(this._value, other._value);
  }
  /**
   * 获取最高位设置位的索引
   * @returns 最高位设置位的索引，如果位集合为空则返回-1
   */
  getHighestBitIndex() {
    if (BitMask64Utils.isZero(this._value)) {
      return -1;
    }
    if (this._value.hi !== 0) {
      for (let i = 31; i >= 0; i--) {
        if ((this._value.hi & 1 << i) !== 0) {
          return i + 32;
        }
      }
    }
    for (let i = 31; i >= 0; i--) {
      if ((this._value.lo & 1 << i) !== 0) {
        return i;
      }
    }
    return -1;
  }
  /**
   * 获取最低位设置位的索引
   * @returns 最低位设置位的索引，如果位集合为空则返回-1
   */
  getLowestBitIndex() {
    if (BitMask64Utils.isZero(this._value)) {
      return -1;
    }
    for (let i = 0; i < 32; i++) {
      if ((this._value.lo & 1 << i) !== 0) {
        return i;
      }
    }
    for (let i = 0; i < 32; i++) {
      if ((this._value.hi & 1 << i) !== 0) {
        return i + 32;
      }
    }
    return -1;
  }
}
class ComponentTypeManager {
  /**
   * 获取单例实例
   */
  static get instance() {
    if (!ComponentTypeManager._instance) {
      ComponentTypeManager._instance = new ComponentTypeManager();
    }
    return ComponentTypeManager._instance;
  }
  constructor() {
    this._componentTypes = /* @__PURE__ */ new Map();
    this._typeNames = /* @__PURE__ */ new Map();
    this._nextTypeId = 0;
  }
  /**
   * 获取组件类型的ID
   * @param componentType 组件类型构造函数
   * @returns 组件类型ID
   */
  getTypeId(componentType) {
    let typeId = this._componentTypes.get(componentType);
    if (typeId === void 0) {
      typeId = this._nextTypeId++;
      this._componentTypes.set(componentType, typeId);
      this._typeNames.set(typeId, getComponentTypeName(componentType));
    }
    return typeId;
  }
  /**
   * 获取组件类型名称
   * @param typeId 组件类型ID
   * @returns 组件类型名称
   */
  getTypeName(typeId) {
    return this._typeNames.get(typeId) || "Unknown";
  }
  /**
   * 创建包含指定组件类型的Bits对象
   * @param componentTypes 组件类型构造函数数组
   * @returns Bits对象
   */
  createBits(...componentTypes) {
    const bits = new Bits();
    for (const componentType of componentTypes) {
      const typeId = this.getTypeId(componentType);
      bits.set(typeId);
    }
    return bits;
  }
  /**
   * 获取实体的组件位掩码
   * @param components 组件数组
   * @returns Bits对象
   */
  getEntityBits(components) {
    const bits = new Bits();
    for (const component of components) {
      const typeId = this.getTypeId(component.constructor);
      bits.set(typeId);
    }
    return bits;
  }
  /**
   * 重置管理器（主要用于测试）
   */
  reset() {
    this._componentTypes.clear();
    this._typeNames.clear();
    this._nextTypeId = 0;
  }
  /**
   * 获取已注册的组件类型数量
   */
  get registeredTypeCount() {
    return this._componentTypes.size;
  }
}
class EntityDataCollector {
  /**
   * 收集实体数据
   * @param scene 场景实例
   */
  collectEntityData(scene) {
    if (!scene) {
      return this.getEmptyEntityDebugData();
    }
    const entityList = scene.entities;
    if (!entityList) {
      return this.getEmptyEntityDebugData();
    }
    let stats;
    try {
      stats = entityList.getStats ? entityList.getStats() : this.calculateFallbackEntityStats(entityList);
    } catch (error) {
      return {
        totalEntities: 0,
        activeEntities: 0,
        pendingAdd: 0,
        pendingRemove: 0,
        entitiesPerArchetype: [],
        topEntitiesByComponents: [],
        entityHierarchy: [],
        entityDetailsMap: {}
      };
    }
    const archetypeData = this.collectArchetypeData(scene);
    return {
      totalEntities: stats.totalEntities,
      activeEntities: stats.activeEntities,
      pendingAdd: stats.pendingAdd || 0,
      pendingRemove: stats.pendingRemove || 0,
      entitiesPerArchetype: archetypeData.distribution,
      topEntitiesByComponents: archetypeData.topEntities,
      entityHierarchy: [],
      entityDetailsMap: {}
    };
  }
  /**
   * 获取原始实体列表
   * @param scene 场景实例
   */
  getRawEntityList(scene) {
    if (!scene)
      return [];
    const entityList = scene.entities;
    if (!entityList?.buffer)
      return [];
    return entityList.buffer.map((entity) => ({
      id: entity.id,
      name: entity.name || `Entity_${entity.id}`,
      active: entity.active !== false,
      enabled: entity.enabled !== false,
      activeInHierarchy: entity.activeInHierarchy !== false,
      componentCount: entity.components.length,
      componentTypes: entity.components.map((component) => getComponentInstanceTypeName(component)),
      parentId: entity.parent?.id || null,
      childIds: entity.children?.map((child) => child.id) || [],
      depth: entity.getDepth ? entity.getDepth() : 0,
      tag: entity.tag || 0,
      updateOrder: entity.updateOrder || 0
    }));
  }
  /**
   * 获取实体详细信息
   * @param entityId 实体ID
   * @param scene 场景实例
   */
  getEntityDetails(entityId, scene) {
    try {
      if (!scene)
        return null;
      const entityList = scene.entities;
      if (!entityList?.buffer)
        return null;
      const entity = entityList.buffer.find((e) => e.id === entityId);
      if (!entity)
        return null;
      const baseDebugInfo = entity.getDebugInfo ? entity.getDebugInfo() : this.buildFallbackEntityInfo(entity, scene);
      const componentDetails = this.extractComponentDetails(entity.components);
      const sceneInfo = this.getSceneInfo(scene);
      return {
        ...baseDebugInfo,
        scene: sceneInfo.name,
        sceneName: sceneInfo.name,
        sceneType: sceneInfo.type,
        parentName: entity.parent?.name || null,
        components: componentDetails || [],
        componentCount: entity.components?.length || 0,
        componentTypes: entity.components?.map((comp) => getComponentInstanceTypeName(comp)) || []
      };
    } catch (error) {
      return {
        error: `获取实体详情失败: ${error instanceof Error ? error.message : String(error)}`,
        scene: "获取失败",
        components: [],
        componentCount: 0,
        componentTypes: []
      };
    }
  }
  getSceneInfo(scene) {
    let sceneName = "当前场景";
    let sceneType = "Scene";
    try {
      if (scene.name && typeof scene.name === "string" && scene.name.trim()) {
        sceneName = scene.name.trim();
      } else if (scene.constructor && scene.constructor.name) {
        sceneName = scene.constructor.name;
        sceneType = scene.constructor.name;
      } else if (scene._name && typeof scene._name === "string" && scene._name.trim()) {
        sceneName = scene._name.trim();
      } else {
        const sceneClassName = Object.getPrototypeOf(scene)?.constructor?.name;
        if (sceneClassName && sceneClassName !== "Object") {
          sceneName = sceneClassName;
          sceneType = sceneClassName;
        }
      }
    } catch (error) {
      sceneName = "场景名获取失败";
    }
    return { name: sceneName, type: sceneType };
  }
  /**
   * 收集实体数据（包含内存信息）
   * @param scene 场景实例
   */
  collectEntityDataWithMemory(scene) {
    if (!scene) {
      return this.getEmptyEntityDebugData();
    }
    const entityList = scene.entities;
    if (!entityList) {
      return this.getEmptyEntityDebugData();
    }
    let stats;
    try {
      stats = entityList.getStats ? entityList.getStats() : this.calculateFallbackEntityStats(entityList);
    } catch (error) {
      return {
        totalEntities: 0,
        activeEntities: 0,
        pendingAdd: 0,
        pendingRemove: 0,
        entitiesPerArchetype: [],
        topEntitiesByComponents: [],
        entityHierarchy: [],
        entityDetailsMap: {}
      };
    }
    const archetypeData = this.collectArchetypeDataWithMemory(scene);
    return {
      totalEntities: stats.totalEntities,
      activeEntities: stats.activeEntities,
      pendingAdd: stats.pendingAdd || 0,
      pendingRemove: stats.pendingRemove || 0,
      entitiesPerArchetype: archetypeData.distribution,
      topEntitiesByComponents: archetypeData.topEntities,
      entityHierarchy: this.buildEntityHierarchyTree(entityList),
      entityDetailsMap: this.buildEntityDetailsMap(entityList, scene)
    };
  }
  collectArchetypeData(scene) {
    if (scene && scene.archetypeSystem && typeof scene.archetypeSystem.getAllArchetypes === "function") {
      return this.extractArchetypeStatistics(scene.archetypeSystem);
    }
    const entityContainer = { entities: scene.entities?.buffer || [] };
    return {
      distribution: this.getArchetypeDistributionFast(entityContainer),
      topEntities: this.getTopEntitiesByComponentsFast(entityContainer)
    };
  }
  getArchetypeDistributionFast(entityContainer) {
    const distribution = /* @__PURE__ */ new Map();
    if (entityContainer && entityContainer.entities) {
      entityContainer.entities.forEach((entity) => {
        const componentTypes = entity.components?.map((comp) => getComponentInstanceTypeName(comp)) || [];
        const signature = componentTypes.length > 0 ? componentTypes.sort().join(", ") : "无组件";
        const existing = distribution.get(signature);
        if (existing) {
          existing.count++;
        } else {
          distribution.set(signature, { count: 1, componentTypes });
        }
      });
    }
    return Array.from(distribution.entries()).map(([signature, data]) => ({
      signature,
      count: data.count,
      memory: 0
    })).sort((a, b) => b.count - a.count).slice(0, 20);
  }
  getTopEntitiesByComponentsFast(entityContainer) {
    if (!entityContainer || !entityContainer.entities) {
      return [];
    }
    return entityContainer.entities.map((entity) => ({
      id: entity.id.toString(),
      name: entity.name || `Entity_${entity.id}`,
      componentCount: entity.components?.length || 0,
      memory: 0
    })).sort((a, b) => b.componentCount - a.componentCount).slice(0, 10);
  }
  collectArchetypeDataWithMemory(scene) {
    if (scene && scene.archetypeSystem && typeof scene.archetypeSystem.getAllArchetypes === "function") {
      return this.extractArchetypeStatisticsWithMemory(scene.archetypeSystem);
    }
    const entityContainer = { entities: scene.entities?.buffer || [] };
    return {
      distribution: this.getArchetypeDistributionWithMemory(entityContainer),
      topEntities: this.getTopEntitiesByComponentsWithMemory(entityContainer)
    };
  }
  extractArchetypeStatistics(archetypeSystem) {
    const archetypes = archetypeSystem.getAllArchetypes();
    const distribution = [];
    const topEntities = [];
    archetypes.forEach((archetype) => {
      const signature = archetype.componentTypes?.map((type) => type.name).join(",") || "Unknown";
      const entityCount = archetype.entities?.length || 0;
      distribution.push({
        signature,
        count: entityCount,
        memory: 0
      });
      if (archetype.entities) {
        archetype.entities.slice(0, 5).forEach((entity) => {
          topEntities.push({
            id: entity.id.toString(),
            name: entity.name || `Entity_${entity.id}`,
            componentCount: entity.components?.length || 0,
            memory: 0
          });
        });
      }
    });
    distribution.sort((a, b) => b.count - a.count);
    topEntities.sort((a, b) => b.componentCount - a.componentCount);
    return { distribution, topEntities };
  }
  extractArchetypeStatisticsWithMemory(archetypeSystem) {
    const archetypes = archetypeSystem.getAllArchetypes();
    const distribution = [];
    const topEntities = [];
    archetypes.forEach((archetype) => {
      const signature = archetype.componentTypes?.map((type) => type.name).join(",") || "Unknown";
      const entityCount = archetype.entities?.length || 0;
      let actualMemory = 0;
      if (archetype.entities && archetype.entities.length > 0) {
        const sampleSize = Math.min(5, archetype.entities.length);
        let sampleMemory = 0;
        for (let i = 0; i < sampleSize; i++) {
          sampleMemory += this.estimateEntityMemoryUsage(archetype.entities[i]);
        }
        actualMemory = sampleMemory / sampleSize * entityCount;
      }
      distribution.push({
        signature,
        count: entityCount,
        memory: actualMemory
      });
      if (archetype.entities) {
        archetype.entities.slice(0, 5).forEach((entity) => {
          topEntities.push({
            id: entity.id.toString(),
            name: entity.name || `Entity_${entity.id}`,
            componentCount: entity.components?.length || 0,
            memory: this.estimateEntityMemoryUsage(entity)
          });
        });
      }
    });
    distribution.sort((a, b) => b.count - a.count);
    topEntities.sort((a, b) => b.componentCount - a.componentCount);
    return { distribution, topEntities };
  }
  getArchetypeDistribution(entityContainer) {
    const distribution = /* @__PURE__ */ new Map();
    if (entityContainer && entityContainer.entities) {
      entityContainer.entities.forEach((entity) => {
        const signature = entity.componentMask?.toString() || "0";
        const existing = distribution.get(signature);
        distribution.set(signature, (existing || 0) + 1);
      });
    }
    return Array.from(distribution.entries()).map(([signature, count]) => ({ signature, count, memory: 0 })).sort((a, b) => b.count - a.count);
  }
  getArchetypeDistributionWithMemory(entityContainer) {
    const distribution = /* @__PURE__ */ new Map();
    if (entityContainer && entityContainer.entities) {
      entityContainer.entities.forEach((entity) => {
        const componentTypes = entity.components?.map((comp) => getComponentInstanceTypeName(comp)) || [];
        const signature = componentTypes.length > 0 ? componentTypes.sort().join(", ") : "无组件";
        const existing = distribution.get(signature);
        let memory = this.estimateEntityMemoryUsage(entity);
        if (isNaN(memory) || memory < 0) {
          memory = 0;
        }
        if (existing) {
          existing.count++;
          existing.memory += memory;
        } else {
          distribution.set(signature, { count: 1, memory, componentTypes });
        }
      });
    }
    return Array.from(distribution.entries()).map(([signature, data]) => ({
      signature,
      count: data.count,
      memory: isNaN(data.memory) ? 0 : data.memory
    })).sort((a, b) => b.count - a.count);
  }
  getTopEntitiesByComponents(entityContainer) {
    if (!entityContainer || !entityContainer.entities) {
      return [];
    }
    return entityContainer.entities.map((entity) => ({
      id: entity.id.toString(),
      name: entity.name || `Entity_${entity.id}`,
      componentCount: entity.components?.length || 0,
      memory: 0
    })).sort((a, b) => b.componentCount - a.componentCount);
  }
  getTopEntitiesByComponentsWithMemory(entityContainer) {
    if (!entityContainer || !entityContainer.entities) {
      return [];
    }
    return entityContainer.entities.map((entity) => ({
      id: entity.id.toString(),
      name: entity.name || `Entity_${entity.id}`,
      componentCount: entity.components?.length || 0,
      memory: this.estimateEntityMemoryUsage(entity)
    })).sort((a, b) => b.componentCount - a.componentCount);
  }
  getEmptyEntityDebugData() {
    return {
      totalEntities: 0,
      activeEntities: 0,
      pendingAdd: 0,
      pendingRemove: 0,
      entitiesPerArchetype: [],
      topEntitiesByComponents: [],
      entityHierarchy: [],
      entityDetailsMap: {}
    };
  }
  calculateFallbackEntityStats(entityList) {
    const allEntities = entityList.buffer || [];
    const activeEntities = allEntities.filter((entity) => entity.enabled && !entity._isDestroyed);
    return {
      totalEntities: allEntities.length,
      activeEntities: activeEntities.length,
      pendingAdd: 0,
      pendingRemove: 0,
      averageComponentsPerEntity: activeEntities.length > 0 ? allEntities.reduce((sum, e) => sum + (e.components?.length || 0), 0) / activeEntities.length : 0
    };
  }
  estimateEntityMemoryUsage(entity) {
    try {
      let totalSize = 0;
      const entitySize = this.calculateObjectSize(entity, ["components", "children", "parent"]);
      if (!isNaN(entitySize) && entitySize > 0) {
        totalSize += entitySize;
      }
      if (entity.components && Array.isArray(entity.components)) {
        entity.components.forEach((component) => {
          const componentSize = this.calculateObjectSize(component, ["entity"]);
          if (!isNaN(componentSize) && componentSize > 0) {
            totalSize += componentSize;
          }
        });
      }
      return isNaN(totalSize) || totalSize < 0 ? 0 : totalSize;
    } catch (error) {
      return 0;
    }
  }
  calculateObjectSize(obj, excludeKeys = []) {
    if (!obj || typeof obj !== "object")
      return 0;
    const visited = /* @__PURE__ */ new WeakSet();
    const maxDepth = 2;
    const calculate = (item, depth = 0) => {
      if (!item || typeof item !== "object" || depth >= maxDepth) {
        return 0;
      }
      if (visited.has(item))
        return 0;
      visited.add(item);
      let itemSize = 32;
      try {
        const keys = Object.keys(item);
        const maxKeys = Math.min(keys.length, 20);
        for (let i = 0; i < maxKeys; i++) {
          const key = keys[i];
          if (excludeKeys.includes(key) || key === "constructor" || key === "__proto__" || key.startsWith("_cc_") || key.startsWith("__")) {
            continue;
          }
          const value = item[key];
          itemSize += key.length * 2;
          if (typeof value === "string") {
            itemSize += Math.min(value.length * 2, 200);
          } else if (typeof value === "number") {
            itemSize += 8;
          } else if (typeof value === "boolean") {
            itemSize += 4;
          } else if (Array.isArray(value)) {
            itemSize += 40 + Math.min(value.length * 8, 160);
          } else if (typeof value === "object" && value !== null) {
            itemSize += calculate(value, depth + 1);
          }
        }
      } catch (error) {
        return 64;
      }
      return itemSize;
    };
    try {
      const size = calculate(obj);
      return Math.max(size, 32);
    } catch (error) {
      return 64;
    }
  }
  buildEntityHierarchyTree(entityList) {
    if (!entityList?.buffer)
      return [];
    const rootEntities = [];
    entityList.buffer.forEach((entity) => {
      if (!entity.parent) {
        const hierarchyNode = this.buildEntityHierarchyNode(entity);
        rootEntities.push(hierarchyNode);
      }
    });
    rootEntities.sort((nodeA, nodeB) => {
      if (nodeA.name < nodeB.name)
        return -1;
      if (nodeA.name > nodeB.name)
        return 1;
      return nodeA.id - nodeB.id;
    });
    return rootEntities;
  }
  /**
   * 构建实体层次结构节点
   */
  buildEntityHierarchyNode(entity) {
    let node = {
      id: entity.id,
      name: entity.name || `Entity_${entity.id}`,
      active: entity.active !== false,
      enabled: entity.enabled !== false,
      activeInHierarchy: entity.activeInHierarchy !== false,
      componentCount: entity.components.length,
      componentTypes: entity.components.map((component) => getComponentInstanceTypeName(component)),
      parentId: entity.parent?.id || null,
      children: [],
      depth: entity.getDepth ? entity.getDepth() : 0,
      tag: entity.tag || 0,
      updateOrder: entity.updateOrder || 0
    };
    if (entity.children && entity.children.length > 0) {
      node.children = entity.children.map((child) => this.buildEntityHierarchyNode(child));
    }
    if (typeof entity.getDebugInfo === "function") {
      const debugInfo = entity.getDebugInfo();
      node = {
        ...node,
        ...debugInfo
      };
    }
    if (entity.components && entity.components.length > 0) {
      node.componentDetails = this.extractComponentDetails(entity.components);
    }
    return node;
  }
  /**
   * 构建实体详情映射
   */
  buildEntityDetailsMap(entityList, scene) {
    if (!entityList?.buffer)
      return {};
    const entityDetailsMap = {};
    const entities = entityList.buffer;
    const batchSize = 100;
    for (let i = 0; i < entities.length; i += batchSize) {
      const batch = entities.slice(i, i + batchSize);
      batch.forEach((entity) => {
        const baseDebugInfo = entity.getDebugInfo ? entity.getDebugInfo() : this.buildFallbackEntityInfo(entity, scene);
        const componentCacheStats = entity.getComponentCacheStats ? entity.getComponentCacheStats() : null;
        const componentDetails = this.extractComponentDetails(entity.components);
        entityDetailsMap[entity.id] = {
          ...baseDebugInfo,
          parentName: entity.parent?.name || null,
          components: componentDetails,
          componentTypes: baseDebugInfo.componentTypes || componentDetails.map((comp) => comp.typeName),
          cachePerformance: componentCacheStats ? {
            hitRate: componentCacheStats.cacheStats.hitRate,
            size: componentCacheStats.cacheStats.size,
            maxSize: componentCacheStats.cacheStats.maxSize
          } : null
        };
      });
    }
    return entityDetailsMap;
  }
  /**
   * 构建实体基础信息
   */
  buildFallbackEntityInfo(entity, scene) {
    const sceneInfo = this.getSceneInfo(scene);
    return {
      name: entity.name || `Entity_${entity.id}`,
      id: entity.id,
      enabled: entity.enabled !== false,
      active: entity.active !== false,
      activeInHierarchy: entity.activeInHierarchy !== false,
      destroyed: entity.isDestroyed || false,
      scene: sceneInfo.name,
      sceneName: sceneInfo.name,
      sceneType: sceneInfo.type,
      componentCount: entity.components.length,
      componentTypes: entity.components.map((component) => getComponentInstanceTypeName(component)),
      componentMask: entity.componentMask?.toString() || "0",
      parentId: entity.parent?.id || null,
      childCount: entity.children?.length || 0,
      childIds: entity.children.map((child) => child.id) || [],
      depth: entity.getDepth ? entity.getDepth() : 0,
      tag: entity.tag || 0,
      updateOrder: entity.updateOrder || 0
    };
  }
  /**
   * 提取组件详细信息
   */
  extractComponentDetails(components) {
    return components.map((component) => {
      let typeName = getComponentInstanceTypeName(component);
      if (!typeName || typeName === "Object" || typeName === "Function") {
        try {
          const typeManager = ComponentTypeManager.instance;
          const componentType = component.constructor;
          const typeId = typeManager.getTypeId(componentType);
          typeName = typeManager.getTypeName(typeId);
        } catch (error) {
          typeName = "UnknownComponent";
        }
      }
      const properties = {};
      try {
        const propertyKeys = Object.keys(component);
        propertyKeys.forEach((propertyKey) => {
          if (!propertyKey.startsWith("_") && propertyKey !== "entity" && propertyKey !== "constructor") {
            const propertyValue = component[propertyKey];
            if (propertyValue !== void 0 && propertyValue !== null) {
              properties[propertyKey] = this.formatPropertyValue(propertyValue);
            }
          }
        });
        if (Object.keys(properties).length === 0) {
          properties._info = "该组件没有公开属性";
          properties._componentId = getComponentInstanceTypeName(component);
        }
      } catch (error) {
        properties._error = "属性提取失败";
        properties._componentId = getComponentInstanceTypeName(component);
      }
      return {
        typeName,
        properties
      };
    });
  }
  /**
   * 获取组件的完整属性信息（仅在需要时调用）
   * @param entityId 实体ID
   * @param componentIndex 组件索引
   * @param scene 场景实例
   */
  getComponentProperties(entityId, componentIndex, scene) {
    try {
      if (!scene)
        return {};
      const entityList = scene.entities;
      if (!entityList?.buffer)
        return {};
      const entity = entityList.buffer.find((e) => e.id === entityId);
      if (!entity || componentIndex >= entity.components.length)
        return {};
      const component = entity.components[componentIndex];
      const properties = {};
      const propertyKeys = Object.keys(component);
      propertyKeys.forEach((propertyKey) => {
        if (!propertyKey.startsWith("_") && propertyKey !== "entity") {
          const propertyValue = component[propertyKey];
          if (propertyValue !== void 0 && propertyValue !== null) {
            properties[propertyKey] = this.formatPropertyValue(propertyValue);
          }
        }
      });
      return properties;
    } catch (error) {
      return { _error: "属性提取失败" };
    }
  }
  /**
   * 格式化属性值
   */
  formatPropertyValue(value, depth = 0) {
    if (value === null || value === void 0) {
      return value;
    }
    if (typeof value !== "object") {
      if (typeof value === "string" && value.length > 200) {
        return `[长字符串: ${value.length}字符] ${value.substring(0, 100)}...`;
      }
      return value;
    }
    if (depth === 0) {
      return this.formatObjectFirstLevel(value);
    } else {
      return this.createLazyLoadPlaceholder(value);
    }
  }
  /**
   * 格式化对象第一层
   */
  formatObjectFirstLevel(obj) {
    try {
      if (Array.isArray(obj)) {
        if (obj.length === 0)
          return [];
        if (obj.length > 10) {
          const sample = obj.slice(0, 3).map((item) => this.formatPropertyValue(item, 1));
          return {
            _isLazyArray: true,
            _arrayLength: obj.length,
            _sample: sample,
            _summary: `数组[${obj.length}个元素]`
          };
        }
        return obj.map((item) => this.formatPropertyValue(item, 1));
      }
      const keys = Object.keys(obj);
      if (keys.length === 0)
        return {};
      const result = {};
      let processedCount = 0;
      const maxProperties = 15;
      for (const key of keys) {
        if (processedCount >= maxProperties) {
          result._hasMoreProperties = true;
          result._totalProperties = keys.length;
          result._hiddenCount = keys.length - processedCount;
          break;
        }
        if (key.startsWith("_") || key.startsWith("$") || typeof obj[key] === "function") {
          continue;
        }
        try {
          const value = obj[key];
          if (value !== null && value !== void 0) {
            result[key] = this.formatPropertyValue(value, 1);
            processedCount++;
          }
        } catch (error) {
          result[key] = `[访问失败: ${error instanceof Error ? error.message : String(error)}]`;
          processedCount++;
        }
      }
      return result;
    } catch (error) {
      return `[对象解析失败: ${error instanceof Error ? error.message : String(error)}]`;
    }
  }
  /**
   * 创建懒加载占位符
   */
  createLazyLoadPlaceholder(obj) {
    try {
      const typeName = obj.constructor?.name || "Object";
      const summary = this.getObjectSummary(obj, typeName);
      return {
        _isLazyObject: true,
        _typeName: typeName,
        _summary: summary,
        _objectId: this.generateObjectId(obj)
      };
    } catch (error) {
      return {
        _isLazyObject: true,
        _typeName: "Unknown",
        _summary: `无法分析的对象: ${error instanceof Error ? error.message : String(error)}`,
        _objectId: Math.random().toString(36).substr(2, 9)
      };
    }
  }
  /**
   * 获取对象摘要信息
   */
  getObjectSummary(obj, typeName) {
    try {
      if (typeName.toLowerCase().includes("vec") || typeName.toLowerCase().includes("vector")) {
        if (obj.x !== void 0 && obj.y !== void 0) {
          const z = obj.z !== void 0 ? obj.z : "";
          return `${typeName}(${obj.x}, ${obj.y}${z ? ", " + z : ""})`;
        }
      }
      if (typeName.toLowerCase().includes("color")) {
        if (obj.r !== void 0 && obj.g !== void 0 && obj.b !== void 0) {
          const a = obj.a !== void 0 ? obj.a : 1;
          return `${typeName}(${obj.r}, ${obj.g}, ${obj.b}, ${a})`;
        }
      }
      if (typeName.toLowerCase().includes("node")) {
        const name = obj.name || obj._name || "未命名";
        return `${typeName}: ${name}`;
      }
      if (typeName.toLowerCase().includes("component")) {
        const nodeName = obj.node?.name || obj.node?._name || "";
        return `${typeName}${nodeName ? ` on ${nodeName}` : ""}`;
      }
      const keys = Object.keys(obj);
      if (keys.length === 0) {
        return `${typeName} (空对象)`;
      }
      return `${typeName} (${keys.length}个属性)`;
    } catch (error) {
      return `${typeName} (无法分析)`;
    }
  }
  /**
   * 生成对象ID
   */
  generateObjectId(obj) {
    try {
      if (obj.id !== void 0)
        return `obj_${obj.id}`;
      if (obj._id !== void 0)
        return `obj_${obj._id}`;
      if (obj.uuid !== void 0)
        return `obj_${obj.uuid}`;
      if (obj._uuid !== void 0)
        return `obj_${obj._uuid}`;
      return `obj_${Math.random().toString(36).substr(2, 9)}`;
    } catch {
      return `obj_${Math.random().toString(36).substr(2, 9)}`;
    }
  }
  /**
   * 展开懒加载对象（供调试面板调用）
   * @param entityId 实体ID
   * @param componentIndex 组件索引
   * @param propertyPath 属性路径
   * @param scene 场景实例
   */
  expandLazyObject(entityId, componentIndex, propertyPath, scene) {
    try {
      if (!scene)
        return null;
      const entityList = scene.entities;
      if (!entityList?.buffer)
        return null;
      const entity = entityList.buffer.find((e) => e.id === entityId);
      if (!entity)
        return null;
      if (componentIndex >= entity.components.length)
        return null;
      const component = entity.components[componentIndex];
      const targetObject = this.getObjectByPath(component, propertyPath);
      if (!targetObject)
        return null;
      return this.formatObjectFirstLevel(targetObject);
    } catch (error) {
      return {
        error: `展开失败: ${error instanceof Error ? error.message : String(error)}`
      };
    }
  }
  /**
   * 根据路径获取对象
   */
  getObjectByPath(root, path) {
    if (!path)
      return root;
    const parts = path.split(".");
    let current = root;
    for (const part of parts) {
      if (current === null || current === void 0)
        return null;
      if (part.includes("[") && part.includes("]")) {
        const arrayName = part.substring(0, part.indexOf("["));
        const index = parseInt(part.substring(part.indexOf("[") + 1, part.indexOf("]")));
        if (arrayName) {
          current = current[arrayName];
        }
        if (Array.isArray(current) && index >= 0 && index < current.length) {
          current = current[index];
        } else {
          return null;
        }
      } else {
        current = current[part];
      }
    }
    return current;
  }
}
class SystemDataCollector {
  /**
   * 收集系统数据
   * @param performanceMonitor 性能监视器实例
   * @param scene 场景实例
   */
  collectSystemData(performanceMonitor, scene) {
    if (!scene) {
      return {
        totalSystems: 0,
        systemsInfo: []
      };
    }
    const entityProcessors = scene.entityProcessors;
    if (!entityProcessors) {
      return {
        totalSystems: 0,
        systemsInfo: []
      };
    }
    const systems = entityProcessors.processors || [];
    let systemStats = /* @__PURE__ */ new Map();
    let systemData = /* @__PURE__ */ new Map();
    if (performanceMonitor) {
      try {
        systemStats = performanceMonitor.getAllSystemStats();
        systemData = performanceMonitor.getAllSystemData();
      } catch (error) {
      }
    }
    return {
      totalSystems: systems.length,
      systemsInfo: systems.map((system) => {
        const systemName = system.systemName || getSystemInstanceTypeName(system);
        const stats = systemStats.get(systemName);
        const data = systemData.get(systemName);
        return {
          name: systemName,
          type: getSystemInstanceTypeName(system),
          entityCount: system.entities?.length || 0,
          executionTime: stats?.averageTime || data?.executionTime || 0,
          minExecutionTime: stats?.minTime === Number.MAX_VALUE ? 0 : stats?.minTime || 0,
          maxExecutionTime: stats?.maxTime || 0,
          executionTimeHistory: stats?.recentTimes || [],
          updateOrder: system.updateOrder || 0,
          enabled: system.enabled !== false,
          lastUpdateTime: data?.lastUpdateTime || 0
        };
      })
    };
  }
}
class PerformanceDataCollector {
  constructor() {
    this.frameTimeHistory = [];
    this.maxHistoryLength = 60;
    this.lastGCCount = 0;
    this.gcCollections = 0;
    this.lastMemoryCheck = 0;
  }
  /**
   * 收集性能数据
   */
  collectPerformanceData(performanceMonitor) {
    const frameTimeSeconds = Time.deltaTime;
    const engineFrameTimeMs = frameTimeSeconds * 1e3;
    const currentFps = frameTimeSeconds > 0 ? Math.round(1 / frameTimeSeconds) : 0;
    const ecsPerformanceData = this.getECSPerformanceData(performanceMonitor);
    const ecsExecutionTimeMs = ecsPerformanceData.totalExecutionTime;
    const ecsPercentage = engineFrameTimeMs > 0 ? ecsExecutionTimeMs / engineFrameTimeMs * 100 : 0;
    let memoryUsage = 0;
    if (performance.memory) {
      memoryUsage = performance.memory.usedJSHeapSize / 1024 / 1024;
    }
    this.frameTimeHistory.push(ecsExecutionTimeMs);
    if (this.frameTimeHistory.length > this.maxHistoryLength) {
      this.frameTimeHistory.shift();
    }
    const history = this.frameTimeHistory.filter((t) => t >= 0);
    const averageECSTime = history.length > 0 ? history.reduce((a, b) => a + b, 0) / history.length : ecsExecutionTimeMs;
    const minECSTime = history.length > 0 ? Math.min(...history) : ecsExecutionTimeMs;
    const maxECSTime = history.length > 0 ? Math.max(...history) : ecsExecutionTimeMs;
    return {
      frameTime: ecsExecutionTimeMs,
      engineFrameTime: engineFrameTimeMs,
      ecsPercentage,
      memoryUsage,
      fps: currentFps,
      averageFrameTime: averageECSTime,
      minFrameTime: minECSTime,
      maxFrameTime: maxECSTime,
      frameTimeHistory: [...this.frameTimeHistory],
      systemPerformance: this.getSystemPerformance(performanceMonitor),
      systemBreakdown: ecsPerformanceData.systemBreakdown,
      memoryDetails: this.getMemoryDetails()
    };
  }
  /**
   * 获取ECS框架整体性能数据
   */
  getECSPerformanceData(performanceMonitor) {
    if (!performanceMonitor) {
      return { totalExecutionTime: 0, systemBreakdown: [] };
    }
    if (!performanceMonitor.enabled) {
      try {
        performanceMonitor.enabled = true;
      } catch (error) {
      }
      return { totalExecutionTime: 0, systemBreakdown: [] };
    }
    try {
      let totalTime = 0;
      const systemBreakdown = [];
      const stats = performanceMonitor.getAllSystemStats();
      if (stats.size === 0) {
        return { totalExecutionTime: 0, systemBreakdown: [] };
      }
      for (const [systemName, stat] of stats.entries()) {
        const systemTime = stat.recentTimes && stat.recentTimes.length > 0 ? stat.recentTimes[stat.recentTimes.length - 1] : stat.averageTime || 0;
        totalTime += systemTime;
        systemBreakdown.push({
          systemName,
          executionTime: systemTime,
          percentage: 0
          // 后面计算
        });
      }
      systemBreakdown.forEach((system) => {
        system.percentage = totalTime > 0 ? system.executionTime / totalTime * 100 : 0;
      });
      systemBreakdown.sort((a, b) => b.executionTime - a.executionTime);
      return {
        totalExecutionTime: totalTime,
        systemBreakdown
      };
    } catch (error) {
      return { totalExecutionTime: 0, systemBreakdown: [] };
    }
  }
  /**
   * 获取系统性能数据
   */
  getSystemPerformance(performanceMonitor) {
    if (!performanceMonitor) {
      return [];
    }
    try {
      const stats = performanceMonitor.getAllSystemStats();
      const systemData = performanceMonitor.getAllSystemData();
      return Array.from(stats.entries()).map(([systemName, stat]) => {
        const data = systemData.get(systemName);
        return {
          systemName,
          averageTime: stat.averageTime || 0,
          maxTime: stat.maxTime || 0,
          minTime: stat.minTime === Number.MAX_VALUE ? 0 : stat.minTime || 0,
          samples: stat.executionCount || 0,
          percentage: 0,
          entityCount: data?.entityCount || 0,
          lastExecutionTime: data?.executionTime || 0
        };
      });
    } catch (error) {
      return [];
    }
  }
  /**
   * 获取内存详情
   */
  getMemoryDetails() {
    const memoryInfo = {
      entities: 0,
      components: 0,
      systems: 0,
      pooled: 0,
      totalMemory: 0,
      usedMemory: 0,
      freeMemory: 0,
      gcCollections: this.updateGCCount()
    };
    try {
      if (performance.memory) {
        const perfMemory = performance.memory;
        memoryInfo.totalMemory = perfMemory.jsHeapSizeLimit || 512 * 1024 * 1024;
        memoryInfo.usedMemory = perfMemory.usedJSHeapSize || 0;
        memoryInfo.freeMemory = memoryInfo.totalMemory - memoryInfo.usedMemory;
        if (this.lastMemoryCheck > 0) {
          const memoryDrop = this.lastMemoryCheck - memoryInfo.usedMemory;
          if (memoryDrop > 1024 * 1024) {
            this.gcCollections++;
          }
        }
        this.lastMemoryCheck = memoryInfo.usedMemory;
      } else {
        memoryInfo.totalMemory = 512 * 1024 * 1024;
        memoryInfo.freeMemory = 512 * 1024 * 1024;
      }
    } catch (error) {
      return {
        totalMemory: 0,
        usedMemory: 0,
        freeMemory: 0,
        entityMemory: 0,
        componentMemory: 0,
        systemMemory: 0,
        pooledMemory: 0,
        gcCollections: this.gcCollections
      };
    }
    return memoryInfo;
  }
  /**
   * 更新GC计数
   */
  updateGCCount() {
    try {
      if (typeof PerformanceObserver !== "undefined") {
        return this.gcCollections;
      }
      if (performance.measureUserAgentSpecificMemory) {
        return this.gcCollections;
      }
      return this.gcCollections;
    } catch (error) {
      return this.gcCollections;
    }
  }
}
class ComponentPool {
  constructor(createFn, resetFn, maxSize = 1e3) {
    this.pool = [];
    this.createFn = createFn;
    this.resetFn = resetFn;
    this.maxSize = maxSize;
  }
  /**
   * 获取一个组件实例
   */
  acquire() {
    if (this.pool.length > 0) {
      return this.pool.pop();
    }
    return this.createFn();
  }
  /**
   * 释放一个组件实例回池中
   */
  release(component) {
    if (this.pool.length < this.maxSize) {
      if (this.resetFn) {
        this.resetFn(component);
      }
      this.pool.push(component);
    }
  }
  /**
   * 预填充对象池
   */
  prewarm(count) {
    for (let i = 0; i < count && this.pool.length < this.maxSize; i++) {
      this.pool.push(this.createFn());
    }
  }
  /**
   * 清空对象池
   */
  clear() {
    this.pool.length = 0;
  }
  /**
   * 获取池中可用对象数量
   */
  getAvailableCount() {
    return this.pool.length;
  }
  /**
   * 获取池的最大容量
   */
  getMaxSize() {
    return this.maxSize;
  }
}
class ComponentPoolManager {
  constructor() {
    this.pools = /* @__PURE__ */ new Map();
  }
  static getInstance() {
    if (!ComponentPoolManager.instance) {
      ComponentPoolManager.instance = new ComponentPoolManager();
    }
    return ComponentPoolManager.instance;
  }
  /**
   * 注册组件池
   */
  registerPool(componentName, createFn, resetFn, maxSize) {
    this.pools.set(componentName, new ComponentPool(createFn, resetFn, maxSize));
  }
  /**
   * 获取组件实例
   */
  acquireComponent(componentName) {
    const pool = this.pools.get(componentName);
    return pool ? pool.acquire() : null;
  }
  /**
   * 释放组件实例
   */
  releaseComponent(componentName, component) {
    const pool = this.pools.get(componentName);
    if (pool) {
      pool.release(component);
    }
  }
  /**
   * 预热所有池
   */
  prewarmAll(count = 100) {
    for (const pool of this.pools.values()) {
      pool.prewarm(count);
    }
  }
  /**
   * 清空所有池
   */
  clearAll() {
    for (const pool of this.pools.values()) {
      pool.clear();
    }
  }
  /**
   * 重置管理器，移除所有注册的池
   */
  reset() {
    this.pools.clear();
  }
  /**
   * 获取池统计信息
   */
  getPoolStats() {
    const stats = /* @__PURE__ */ new Map();
    for (const [name, pool] of this.pools) {
      stats.set(name, {
        available: pool.getAvailableCount(),
        maxSize: pool.getMaxSize()
      });
    }
    return stats;
  }
  /**
   * 获取池利用率信息（用于调试）
   */
  getPoolUtilization() {
    const utilization = /* @__PURE__ */ new Map();
    for (const [name, pool] of this.pools) {
      const available = pool.getAvailableCount();
      const maxSize = pool.getMaxSize();
      const used = maxSize - available;
      const utilRate = maxSize > 0 ? used / maxSize * 100 : 0;
      utilization.set(name, {
        used,
        total: maxSize,
        utilization: utilRate
      });
    }
    return utilization;
  }
  /**
   * 获取指定组件的池利用率
   */
  getComponentUtilization(componentName) {
    const pool = this.pools.get(componentName);
    if (!pool)
      return 0;
    const available = pool.getAvailableCount();
    const maxSize = pool.getMaxSize();
    const used = maxSize - available;
    return maxSize > 0 ? used / maxSize * 100 : 0;
  }
}
class ComponentDataCollector {
  /**
   * 收集组件数据（轻量版，不计算实际内存大小）
   * @param scene 场景实例
   */
  collectComponentData(scene) {
    if (!scene) {
      return {
        componentTypes: 0,
        componentInstances: 0,
        componentStats: []
      };
    }
    const entityList = scene.entities;
    if (!entityList?.buffer) {
      return {
        componentTypes: 0,
        componentInstances: 0,
        componentStats: []
      };
    }
    const componentStats = /* @__PURE__ */ new Map();
    let totalInstances = 0;
    entityList.buffer.forEach((entity) => {
      if (entity.components) {
        entity.components.forEach((component) => {
          const typeName = getComponentInstanceTypeName(component);
          const stats = componentStats.get(typeName) || { count: 0, entities: 0 };
          stats.count++;
          totalInstances++;
          componentStats.set(typeName, stats);
        });
      }
    });
    let poolUtilizations = /* @__PURE__ */ new Map();
    let poolSizes = /* @__PURE__ */ new Map();
    try {
      const poolManager = ComponentPoolManager.getInstance();
      const poolStats = poolManager.getPoolStats();
      const utilizations = poolManager.getPoolUtilization();
      for (const [typeName, stats] of poolStats.entries()) {
        poolSizes.set(typeName, stats.maxSize);
      }
      for (const [typeName, util] of utilizations.entries()) {
        poolUtilizations.set(typeName, util.utilization);
      }
    } catch (error) {
    }
    return {
      componentTypes: componentStats.size,
      componentInstances: totalInstances,
      componentStats: Array.from(componentStats.entries()).map(([typeName, stats]) => {
        const poolSize = poolSizes.get(typeName) || 0;
        const poolUtilization = poolUtilizations.get(typeName) || 0;
        const memoryPerInstance = this.getEstimatedComponentSize(typeName, scene);
        return {
          typeName,
          instanceCount: stats.count,
          memoryPerInstance,
          totalMemory: stats.count * memoryPerInstance,
          poolSize,
          poolUtilization,
          averagePerEntity: stats.count / entityList.buffer.length
        };
      })
    };
  }
  /**
   * 获取组件类型的估算内存大小（基于预设值，不进行实际计算）
   */
  getEstimatedComponentSize(typeName, scene) {
    if (ComponentDataCollector.componentSizeCache.has(typeName)) {
      return ComponentDataCollector.componentSizeCache.get(typeName);
    }
    if (!scene)
      return 64;
    const entityList = scene.entities;
    if (!entityList?.buffer)
      return 64;
    let calculatedSize = 64;
    try {
      for (const entity of entityList.buffer) {
        if (entity.components) {
          const component = entity.components.find((c) => getComponentInstanceTypeName(c) === typeName);
          if (component) {
            calculatedSize = this.calculateQuickObjectSize(component);
            break;
          }
        }
      }
    } catch (error) {
      calculatedSize = 64;
    }
    ComponentDataCollector.componentSizeCache.set(typeName, calculatedSize);
    return calculatedSize;
  }
  calculateQuickObjectSize(obj) {
    if (!obj || typeof obj !== "object")
      return 8;
    let size = 32;
    const visited = /* @__PURE__ */ new WeakSet();
    const calculate = (item, depth = 0) => {
      if (!item || typeof item !== "object" || visited.has(item) || depth > 3) {
        return 0;
      }
      visited.add(item);
      let itemSize = 0;
      try {
        const keys = Object.keys(item);
        for (let i = 0; i < Math.min(keys.length, 20); i++) {
          const key = keys[i];
          if (key === "entity" || key === "_entity" || key === "constructor")
            continue;
          const value = item[key];
          itemSize += key.length * 2;
          if (typeof value === "string") {
            itemSize += Math.min(value.length * 2, 200);
          } else if (typeof value === "number") {
            itemSize += 8;
          } else if (typeof value === "boolean") {
            itemSize += 4;
          } else if (typeof value === "object" && value !== null) {
            itemSize += calculate(value, depth + 1);
          }
        }
      } catch (error) {
        return 32;
      }
      return itemSize;
    };
    size += calculate(obj);
    return Math.max(size, 32);
  }
  /**
   * 为内存快照功能提供的详细内存计算
   * 只在用户主动请求内存快照时调用
   * @param typeName 组件类型名称
   * @param scene 场景实例
   */
  calculateDetailedComponentMemory(typeName, scene) {
    if (!scene)
      return this.getEstimatedComponentSize(typeName, scene);
    const entityList = scene.entities;
    if (!entityList?.buffer)
      return this.getEstimatedComponentSize(typeName, scene);
    try {
      for (const entity of entityList.buffer) {
        if (entity.components) {
          const component = entity.components.find((c) => getComponentInstanceTypeName(c) === typeName);
          if (component) {
            return this.estimateObjectSize(component);
          }
        }
      }
    } catch (error) {
    }
    return this.getEstimatedComponentSize(typeName, scene);
  }
  /**
   * 估算对象内存大小（仅用于内存快照）
   * 优化版本：减少递归深度，提高性能
   */
  estimateObjectSize(obj, visited = /* @__PURE__ */ new WeakSet(), depth = 0) {
    if (obj === null || obj === void 0 || depth > 10)
      return 0;
    if (visited.has(obj))
      return 0;
    let size = 0;
    const type = typeof obj;
    switch (type) {
      case "boolean":
        size = 4;
        break;
      case "number":
        size = 8;
        break;
      case "string":
        size = 24 + Math.min(obj.length * 2, 1e3);
        break;
      case "object":
        visited.add(obj);
        if (Array.isArray(obj)) {
          size = 40 + obj.length * 8;
          const maxElements = Math.min(obj.length, 50);
          for (let i = 0; i < maxElements; i++) {
            size += this.estimateObjectSize(obj[i], visited, depth + 1);
          }
        } else {
          size = 32;
          try {
            const ownKeys = Object.getOwnPropertyNames(obj);
            const maxProps = Math.min(ownKeys.length, 30);
            for (let i = 0; i < maxProps; i++) {
              const key = ownKeys[i];
              if (key === "constructor" || key === "__proto__" || key === "entity" || key === "_entity" || key.startsWith("_cc_") || key.startsWith("__")) {
                continue;
              }
              try {
                size += 16 + key.length * 2;
                const value = obj[key];
                if (value !== void 0 && value !== null) {
                  size += this.estimateObjectSize(value, visited, depth + 1);
                }
              } catch (error) {
                continue;
              }
            }
          } catch (error) {
            size = 128;
          }
        }
        break;
      default:
        size = 8;
    }
    return Math.ceil(size / 8) * 8;
  }
  static clearCache() {
    ComponentDataCollector.componentSizeCache.clear();
  }
}
ComponentDataCollector.componentSizeCache = /* @__PURE__ */ new Map();
class SceneDataCollector {
  constructor() {
    this.sceneStartTime = Date.now();
  }
  /**
   * 收集场景数据
   * @param scene 场景实例
   */
  collectSceneData(scene) {
    if (!scene) {
      return {
        currentSceneName: "No Scene",
        isInitialized: false,
        sceneRunTime: 0,
        sceneEntityCount: 0,
        sceneSystemCount: 0,
        sceneMemory: 0,
        sceneUptime: 0
      };
    }
    const currentTime = Date.now();
    const runTime = (currentTime - this.sceneStartTime) / 1e3;
    const entityList = scene.entities;
    const entityProcessors = scene.entityProcessors;
    return {
      currentSceneName: scene.name || "Unnamed Scene",
      isInitialized: scene._didSceneBegin || false,
      sceneRunTime: runTime,
      sceneEntityCount: entityList?.buffer?.length || 0,
      sceneSystemCount: entityProcessors?.processors?.length || 0,
      sceneMemory: 0,
      // TODO: 计算实际场景内存
      sceneUptime: runTime
    };
  }
  /**
   * 设置场景开始时间
   */
  setSceneStartTime(time) {
    this.sceneStartTime = time;
  }
}
class WebSocketManager {
  constructor(url, autoReconnect = true) {
    this.isConnected = false;
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
    this.reconnectInterval = 2e3;
    this.url = url;
    this.autoReconnect = autoReconnect;
  }
  /**
   * 设置消息处理回调
   */
  setMessageHandler(handler) {
    this.messageHandler = handler;
  }
  /**
   * 连接WebSocket
   */
  connect() {
    return new Promise((resolve, reject) => {
      try {
        this.ws = new WebSocket(this.url);
        this.ws.onopen = (event) => {
          this.handleOpen(event);
          resolve();
        };
        this.ws.onclose = (event) => {
          this.handleClose(event);
        };
        this.ws.onerror = (error) => {
          this.handleError(error);
          reject(error);
        };
        this.ws.onmessage = (event) => {
          this.handleMessage(event);
        };
      } catch (error) {
        this.handleConnectionFailure(error);
        reject(error);
      }
    });
  }
  /**
   * 断开连接
   */
  disconnect() {
    if (this.ws) {
      this.autoReconnect = false;
      this.ws.close();
      this.ws = void 0;
    }
    this.isConnected = false;
  }
  /**
   * 发送数据
   */
  send(data) {
    if (!this.isConnected || !this.ws) {
      return;
    }
    try {
      const message = typeof data === "string" ? data : JSON.stringify(data);
      this.ws.send(message);
    } catch (error) {
    }
  }
  /**
   * 获取连接状态
   */
  getConnectionStatus() {
    return this.isConnected;
  }
  /**
   * 设置最大重连次数
   */
  setMaxReconnectAttempts(attempts) {
    this.maxReconnectAttempts = attempts;
  }
  /**
   * 设置重连间隔
   */
  setReconnectInterval(interval) {
    this.reconnectInterval = interval;
  }
  /**
   * 计划重连
   */
  scheduleReconnect() {
    if (this.reconnectTimer) {
      clearTimeout(this.reconnectTimer);
    }
    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
    this.reconnectAttempts++;
    this.reconnectTimer = setTimeout(() => {
      this.connect().catch((error) => {
        if (this.reconnectAttempts < this.maxReconnectAttempts) {
          this.scheduleReconnect();
        }
      });
    }, delay);
  }
  /**
   * 处理接收到的消息
   */
  handleMessage(event) {
    try {
      const message = JSON.parse(event.data);
      if (this.messageHandler) {
        this.messageHandler(message);
      }
    } catch (error) {
    }
  }
  handleOpen(event) {
    this.isConnected = true;
    this.reconnectAttempts = 0;
    if (this.onOpen) {
      this.onOpen(event);
    }
  }
  handleClose(event) {
    this.isConnected = false;
    if (this.onClose) {
      this.onClose(event);
    }
    if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
      this.scheduleReconnect();
    }
  }
  handleError(error) {
    if (this.onError) {
      this.onError(error);
    }
  }
  handleConnectionFailure(error) {
    if (this.onError) {
      this.onError(error);
    }
  }
}
class DebugManager {
  /**
   * 构造调试管理器
   * @param core Core实例
   * @param config 调试配置
   */
  constructor(core, config) {
    this.frameCounter = 0;
    this.lastSendTime = 0;
    this.isRunning = false;
    this.config = config;
    this.sceneProvider = () => core.scene || core.constructor.scene;
    this.performanceMonitorProvider = () => core._performanceMonitor;
    this.entityCollector = new EntityDataCollector();
    this.systemCollector = new SystemDataCollector();
    this.performanceCollector = new PerformanceDataCollector();
    this.componentCollector = new ComponentDataCollector();
    this.sceneCollector = new SceneDataCollector();
    this.webSocketManager = new WebSocketManager(config.websocketUrl, config.autoReconnect !== false);
    this.webSocketManager.setMessageHandler(this.handleMessage.bind(this));
    const debugFrameRate = config.debugFrameRate || 30;
    this.sendInterval = 1e3 / debugFrameRate;
    this.start();
  }
  /**
   * 启动调试管理器
   */
  start() {
    if (this.isRunning)
      return;
    this.isRunning = true;
    this.connectWebSocket();
  }
  /**
   * 停止调试管理器
   */
  stop() {
    if (!this.isRunning)
      return;
    this.isRunning = false;
    this.webSocketManager.disconnect();
  }
  /**
   * 更新配置
   */
  updateConfig(config) {
    this.config = config;
    const debugFrameRate = config.debugFrameRate || 30;
    this.sendInterval = 1e3 / debugFrameRate;
    if (this.webSocketManager && config.websocketUrl) {
      this.webSocketManager.disconnect();
      this.webSocketManager = new WebSocketManager(config.websocketUrl, config.autoReconnect !== false);
      this.webSocketManager.setMessageHandler(this.handleMessage.bind(this));
      this.connectWebSocket();
    }
  }
  /**
   * 帧更新回调
   */
  onFrameUpdate(deltaTime) {
    if (!this.isRunning || !this.config.enabled)
      return;
    this.frameCounter++;
    const currentTime = Date.now();
    if (currentTime - this.lastSendTime >= this.sendInterval) {
      this.sendDebugData();
      this.lastSendTime = currentTime;
    }
  }
  /**
   * 场景变更回调
   */
  onSceneChanged() {
    if (this.isRunning && this.config.enabled) {
      this.sendDebugData();
    }
  }
  /**
   * 处理来自调试面板的消息
   */
  handleMessage(message) {
    try {
      switch (message.type) {
        case "capture_memory_snapshot":
          this.handleMemorySnapshotRequest();
          break;
        case "config_update":
          if (message.config) {
            this.updateConfig({ ...this.config, ...message.config });
          }
          break;
        case "expand_lazy_object":
          this.handleExpandLazyObjectRequest(message);
          break;
        case "get_component_properties":
          this.handleGetComponentPropertiesRequest(message);
          break;
        case "get_raw_entity_list":
          this.handleGetRawEntityListRequest(message);
          break;
        case "get_entity_details":
          this.handleGetEntityDetailsRequest(message);
          break;
        case "ping":
          this.webSocketManager.send({
            type: "pong",
            timestamp: Date.now()
          });
          break;
        default:
          break;
      }
    } catch (error) {
      if (message.requestId) {
        this.webSocketManager.send({
          type: "error_response",
          requestId: message.requestId,
          error: error instanceof Error ? error.message : String(error)
        });
      }
    }
  }
  /**
   * 处理展开懒加载对象请求
   */
  handleExpandLazyObjectRequest(message) {
    try {
      const { entityId, componentIndex, propertyPath, requestId } = message;
      if (entityId === void 0 || componentIndex === void 0 || !propertyPath) {
        this.webSocketManager.send({
          type: "expand_lazy_object_response",
          requestId,
          error: "缺少必要参数"
        });
        return;
      }
      const expandedData = this.entityCollector.expandLazyObject(entityId, componentIndex, propertyPath);
      this.webSocketManager.send({
        type: "expand_lazy_object_response",
        requestId,
        data: expandedData
      });
    } catch (error) {
      this.webSocketManager.send({
        type: "expand_lazy_object_response",
        requestId: message.requestId,
        error: error instanceof Error ? error.message : String(error)
      });
    }
  }
  /**
   * 处理获取组件属性请求
   */
  handleGetComponentPropertiesRequest(message) {
    try {
      const { entityId, componentIndex, requestId } = message;
      if (entityId === void 0 || componentIndex === void 0) {
        this.webSocketManager.send({
          type: "get_component_properties_response",
          requestId,
          error: "缺少必要参数"
        });
        return;
      }
      const properties = this.entityCollector.getComponentProperties(entityId, componentIndex);
      this.webSocketManager.send({
        type: "get_component_properties_response",
        requestId,
        data: properties
      });
    } catch (error) {
      this.webSocketManager.send({
        type: "get_component_properties_response",
        requestId: message.requestId,
        error: error instanceof Error ? error.message : String(error)
      });
    }
  }
  /**
   * 处理获取原始实体列表请求
   */
  handleGetRawEntityListRequest(message) {
    try {
      const { requestId } = message;
      const rawEntityList = this.entityCollector.getRawEntityList();
      this.webSocketManager.send({
        type: "get_raw_entity_list_response",
        requestId,
        data: rawEntityList
      });
    } catch (error) {
      this.webSocketManager.send({
        type: "get_raw_entity_list_response",
        requestId: message.requestId,
        error: error instanceof Error ? error.message : String(error)
      });
    }
  }
  /**
   * 处理获取实体详情请求
   */
  handleGetEntityDetailsRequest(message) {
    try {
      const { entityId, requestId } = message;
      if (entityId === void 0) {
        this.webSocketManager.send({
          type: "get_entity_details_response",
          requestId,
          error: "缺少实体ID参数"
        });
        return;
      }
      const entityDetails = this.entityCollector.getEntityDetails(entityId);
      this.webSocketManager.send({
        type: "get_entity_details_response",
        requestId,
        data: entityDetails
      });
    } catch (error) {
      this.webSocketManager.send({
        type: "get_entity_details_response",
        requestId: message.requestId,
        error: error instanceof Error ? error.message : String(error)
      });
    }
  }
  /**
   * 处理内存快照请求
   */
  handleMemorySnapshotRequest() {
    try {
      const memorySnapshot = this.captureMemorySnapshot();
      this.webSocketManager.send({
        type: "memory_snapshot_response",
        data: memorySnapshot
      });
    } catch (error) {
      this.webSocketManager.send({
        type: "memory_snapshot_error",
        error: error instanceof Error ? error.message : "内存快照捕获失败"
      });
    }
  }
  /**
   * 捕获内存快照
   */
  captureMemorySnapshot() {
    const timestamp = Date.now();
    const baseMemoryInfo = this.collectBaseMemoryInfo();
    const scene = this.sceneProvider();
    const entityData = this.entityCollector.collectEntityDataWithMemory(scene);
    const componentMemoryStats = scene?.entities ? this.collectComponentMemoryStats(scene.entities) : { totalMemory: 0, componentTypes: 0, totalInstances: 0, breakdown: [] };
    const systemMemoryStats = this.collectSystemMemoryStats();
    const poolMemoryStats = this.collectPoolMemoryStats();
    const performanceStats = this.collectPerformanceStats();
    const totalEntityMemory = entityData.entitiesPerArchetype.reduce((sum, arch) => sum + arch.memory, 0);
    return {
      timestamp,
      version: "2.0",
      summary: {
        totalEntities: entityData.totalEntities,
        totalMemoryUsage: baseMemoryInfo.usedMemory,
        totalMemoryLimit: baseMemoryInfo.totalMemory,
        memoryUtilization: baseMemoryInfo.usedMemory / baseMemoryInfo.totalMemory * 100,
        gcCollections: baseMemoryInfo.gcCollections,
        entityMemory: totalEntityMemory,
        componentMemory: componentMemoryStats.totalMemory,
        systemMemory: systemMemoryStats.totalMemory,
        poolMemory: poolMemoryStats.totalMemory
      },
      baseMemory: baseMemoryInfo,
      entities: {
        totalMemory: totalEntityMemory,
        entityCount: entityData.totalEntities,
        archetypes: entityData.entitiesPerArchetype,
        largestEntities: entityData.topEntitiesByComponents
      },
      components: componentMemoryStats,
      systems: systemMemoryStats,
      pools: poolMemoryStats,
      performance: performanceStats
    };
  }
  /**
   * 收集基础内存信息
   */
  collectBaseMemoryInfo() {
    const memoryInfo = {
      totalMemory: 0,
      usedMemory: 0,
      freeMemory: 0,
      gcCollections: 0,
      heapInfo: null,
      detailedMemory: void 0
    };
    try {
      const performanceWithMemory = performance;
      if (performanceWithMemory.memory) {
        const perfMemory = performanceWithMemory.memory;
        memoryInfo.totalMemory = perfMemory.jsHeapSizeLimit || 512 * 1024 * 1024;
        memoryInfo.usedMemory = perfMemory.usedJSHeapSize || 0;
        memoryInfo.freeMemory = memoryInfo.totalMemory - memoryInfo.usedMemory;
        memoryInfo.heapInfo = {
          totalJSHeapSize: perfMemory.totalJSHeapSize || 0,
          usedJSHeapSize: perfMemory.usedJSHeapSize || 0,
          jsHeapSizeLimit: perfMemory.jsHeapSizeLimit || 0
        };
      } else {
        memoryInfo.totalMemory = 512 * 1024 * 1024;
        memoryInfo.freeMemory = 512 * 1024 * 1024;
      }
      if (performanceWithMemory.measureUserAgentSpecificMemory) {
        performanceWithMemory.measureUserAgentSpecificMemory().then((result) => {
          memoryInfo.detailedMemory = result;
        }).catch(() => {
        });
      }
    } catch (error) {
    }
    return memoryInfo;
  }
  /**
   * 收集组件内存统计（仅用于内存快照）
   */
  collectComponentMemoryStats(entityList) {
    const componentStats = /* @__PURE__ */ new Map();
    let totalComponentMemory = 0;
    const componentTypeCounts = /* @__PURE__ */ new Map();
    for (const entity of entityList.buffer) {
      if (!entity || entity.destroyed || !entity.components)
        continue;
      for (const component of entity.components) {
        const typeName = getComponentInstanceTypeName(component);
        componentTypeCounts.set(typeName, (componentTypeCounts.get(typeName) || 0) + 1);
      }
    }
    for (const [typeName, count] of componentTypeCounts.entries()) {
      const detailedMemoryPerInstance = this.componentCollector.calculateDetailedComponentMemory(typeName);
      const totalMemoryForType = detailedMemoryPerInstance * count;
      totalComponentMemory += totalMemoryForType;
      const instances = [];
      let instanceCount = 0;
      for (const entity of entityList.buffer) {
        if (!entity || entity.destroyed || !entity.components)
          continue;
        for (const component of entity.components) {
          if (getComponentInstanceTypeName(component) === typeName) {
            instances.push({
              entityId: entity.id,
              entityName: entity.name || `Entity_${entity.id}`,
              memory: detailedMemoryPerInstance
              // 使用统一的详细计算结果
            });
            instanceCount++;
            if (instanceCount >= 100)
              break;
          }
        }
        if (instanceCount >= 100)
          break;
      }
      componentStats.set(typeName, {
        count,
        totalMemory: totalMemoryForType,
        instances: instances.slice(0, 10)
        // 只保留前10个实例用于显示
      });
    }
    const componentBreakdown = Array.from(componentStats.entries()).map(([typeName, stats]) => ({
      typeName,
      instanceCount: stats.count,
      totalMemory: stats.totalMemory,
      averageMemory: stats.totalMemory / stats.count,
      percentage: totalComponentMemory > 0 ? stats.totalMemory / totalComponentMemory * 100 : 0,
      largestInstances: stats.instances.sort((a, b) => b.memory - a.memory).slice(0, 3)
    })).sort((a, b) => b.totalMemory - a.totalMemory);
    return {
      totalMemory: totalComponentMemory,
      componentTypes: componentStats.size,
      totalInstances: Array.from(componentStats.values()).reduce((sum, stats) => sum + stats.count, 0),
      breakdown: componentBreakdown
    };
  }
  collectSystemMemoryStats() {
    const scene = this.sceneProvider();
    let totalSystemMemory = 0;
    const systemBreakdown = [];
    try {
      const entityProcessors = scene?.entityProcessors;
      if (entityProcessors && entityProcessors.processors) {
        const systemTypeMemoryCache = /* @__PURE__ */ new Map();
        for (const system of entityProcessors.processors) {
          const systemTypeName = getSystemInstanceTypeName(system);
          let systemMemory;
          if (systemTypeMemoryCache.has(systemTypeName)) {
            systemMemory = systemTypeMemoryCache.get(systemTypeName);
          } else {
            systemMemory = this.calculateQuickSystemSize(system);
            systemTypeMemoryCache.set(systemTypeName, systemMemory);
          }
          totalSystemMemory += systemMemory;
          systemBreakdown.push({
            name: systemTypeName,
            memory: systemMemory,
            enabled: system.enabled !== false,
            updateOrder: system.updateOrder || 0
          });
        }
      }
    } catch (error) {
    }
    return {
      totalMemory: totalSystemMemory,
      systemCount: systemBreakdown.length,
      breakdown: systemBreakdown.sort((a, b) => b.memory - a.memory)
    };
  }
  calculateQuickSystemSize(system) {
    if (!system || typeof system !== "object")
      return 64;
    let size = 128;
    try {
      const keys = Object.keys(system);
      for (let i = 0; i < Math.min(keys.length, 15); i++) {
        const key = keys[i];
        if (key === "entities" || key === "scene" || key === "constructor")
          continue;
        const value = system[key];
        size += key.length * 2;
        if (typeof value === "string") {
          size += Math.min(value.length * 2, 100);
        } else if (typeof value === "number") {
          size += 8;
        } else if (typeof value === "boolean") {
          size += 4;
        } else if (Array.isArray(value)) {
          size += 40 + Math.min(value.length * 8, 200);
        } else if (typeof value === "object" && value !== null) {
          size += 64;
        }
      }
    } catch (error) {
      return 128;
    }
    return Math.max(size, 64);
  }
  /**
   * 收集对象池内存统计
   */
  collectPoolMemoryStats() {
    let totalPoolMemory = 0;
    const poolBreakdown = [];
    try {
      const poolManager = ComponentPoolManager.getInstance();
      const poolStats = poolManager.getPoolStats();
      for (const [typeName, stats] of poolStats.entries()) {
        const poolData = stats;
        const poolMemory = poolData.maxSize * 32;
        totalPoolMemory += poolMemory;
        poolBreakdown.push({
          typeName,
          maxSize: poolData.maxSize,
          currentSize: poolData.currentSize || 0,
          estimatedMemory: poolMemory,
          utilization: poolData.currentSize ? poolData.currentSize / poolData.maxSize * 100 : 0
        });
      }
    } catch (error) {
    }
    try {
      const poolStats = Pool.getAllPoolStats();
      for (const [typeName, stats] of Object.entries(poolStats)) {
        const poolData = stats;
        totalPoolMemory += poolData.estimatedMemoryUsage;
        poolBreakdown.push({
          typeName: `Pool_${typeName}`,
          maxSize: poolData.maxSize,
          currentSize: poolData.size,
          estimatedMemory: poolData.estimatedMemoryUsage,
          utilization: poolData.size / poolData.maxSize * 100,
          hitRate: poolData.hitRate * 100
        });
      }
    } catch (error) {
    }
    return {
      totalMemory: totalPoolMemory,
      poolCount: poolBreakdown.length,
      breakdown: poolBreakdown.sort((a, b) => b.estimatedMemory - a.estimatedMemory)
    };
  }
  /**
   * 收集性能统计信息
   */
  collectPerformanceStats() {
    try {
      const performanceMonitor = this.performanceMonitorProvider();
      if (!performanceMonitor) {
        return { enabled: false };
      }
      const stats = performanceMonitor.getAllSystemStats();
      const warnings = performanceMonitor.getPerformanceWarnings();
      return {
        enabled: performanceMonitor.enabled ?? false,
        systemCount: stats.size,
        warnings: warnings.slice(0, 10),
        // 最多10个警告
        topSystems: Array.from(stats.entries()).map((entry) => {
          const [name, stat] = entry;
          return {
            name,
            averageTime: stat.averageTime,
            maxTime: stat.maxTime,
            samples: stat.executionCount
          };
        }).sort((a, b) => b.averageTime - a.averageTime).slice(0, 5)
      };
    } catch (error) {
      return { enabled: false, error: error instanceof Error ? error.message : String(error) };
    }
  }
  /**
   * 获取调试数据
   */
  getDebugData() {
    const currentTime = Date.now();
    const scene = this.sceneProvider();
    const debugData = {
      timestamp: currentTime,
      frameworkVersion: "1.0.0",
      // 可以从package.json读取
      isRunning: this.isRunning,
      frameworkLoaded: true,
      currentScene: scene?.name || "Unknown"
    };
    if (this.config.channels.entities) {
      debugData.entities = this.entityCollector.collectEntityData(scene);
    }
    if (this.config.channels.systems) {
      const performanceMonitor = this.performanceMonitorProvider();
      debugData.systems = this.systemCollector.collectSystemData(performanceMonitor, scene);
    }
    if (this.config.channels.performance) {
      const performanceMonitor = this.performanceMonitorProvider();
      debugData.performance = this.performanceCollector.collectPerformanceData(performanceMonitor);
    }
    if (this.config.channels.components) {
      debugData.components = this.componentCollector.collectComponentData(scene);
    }
    if (this.config.channels.scenes) {
      debugData.scenes = this.sceneCollector.collectSceneData(scene);
    }
    return debugData;
  }
  /**
   * 连接WebSocket
   */
  async connectWebSocket() {
    try {
      await this.webSocketManager.connect();
    } catch (error) {
    }
  }
  /**
   * 发送调试数据
   */
  sendDebugData() {
    if (!this.webSocketManager.getConnectionStatus()) {
      return;
    }
    try {
      const debugData = this.getDebugData();
      const message = {
        type: "debug_data",
        data: debugData
      };
      this.webSocketManager.send(message);
    } catch (error) {
    }
  }
}
class Core {
  /**
   * 创建核心实例
   *
   * @param config - Core配置对象
   */
  constructor(config = {}) {
    this._globalManagers = [];
    Core._instance = this;
    this._config = {
      debug: true,
      enableEntitySystems: true,
      ...config
    };
    this._timerManager = new TimerManager();
    Core.registerGlobalManager(this._timerManager);
    this._performanceMonitor = PerformanceMonitor.instance;
    if (this._config.debug) {
      this._performanceMonitor.enable();
    }
    this._poolManager = PoolManager.getInstance();
    Core.entitySystemsEnabled = this._config.enableEntitySystems ?? true;
    this.debug = this._config.debug ?? true;
    if (this._config.debugConfig?.enabled) {
      this._debugManager = new DebugManager(this, this._config.debugConfig);
    }
    this.initialize();
  }
  /**
   * 获取核心实例
   *
   * @returns 全局核心实例
   */
  static get Instance() {
    return this._instance;
  }
  /**
   * 获取当前活动的场景（属性访问器）
   *
   * @returns 当前场景实例，如果没有则返回null
   */
  static get scene() {
    return this.getScene();
  }
  /**
   * 获取当前活动的场景（方法调用）
   *
   * @returns 当前场景实例，如果没有则返回null
   */
  static getScene() {
    if (!this._instance) {
      return null;
    }
    this._instance.ensureDefaultWorld();
    const defaultWorld = this._instance._worldManager.getWorld(this.DEFAULT_WORLD_ID);
    return defaultWorld?.getScene(this.DEFAULT_SCENE_ID) || null;
  }
  /**
   * 设置当前场景
   *
   * @param scene - 要设置的场景实例
   * @returns 设置的场景实例，便于链式调用
   */
  static setScene(scene) {
    if (!this._instance) {
      throw new Error("Core实例未创建，请先调用Core.create()");
    }
    this._instance.ensureDefaultWorld();
    const defaultWorld = this._instance._worldManager.getWorld(this.DEFAULT_WORLD_ID);
    if (defaultWorld.getScene(this.DEFAULT_SCENE_ID)) {
      defaultWorld.removeScene(this.DEFAULT_SCENE_ID);
    }
    defaultWorld.createScene(this.DEFAULT_SCENE_ID, scene);
    defaultWorld.setSceneActive(this.DEFAULT_SCENE_ID, true);
    this._instance.onSceneChanged();
    return scene;
  }
  /**
   * 创建Core实例
   *
   * 如果实例已存在，则返回现有实例。
   *
   * @param config - Core配置，也可以直接传入boolean表示debug模式（向后兼容）
   * @returns Core实例
   */
  static create(config = true) {
    if (this._instance == null) {
      const coreConfig = typeof config === "boolean" ? { debug: config, enableEntitySystems: true } : config;
      this._instance = new Core(coreConfig);
    }
    return this._instance;
  }
  /**
       * 更新游戏逻辑
       *
       * 此方法应该在游戏引擎的更新循环中调用。
       *
       * @param deltaTime - 外部引擎提供的帧时间间隔（秒）
       *
       * @example
       * ```typescript
       * // Laya引擎
       * Laya.timer.frameLoop(1, this, () => {
       *     const deltaTime = Laya.timer.delta / 1000;
       *     Core.update(deltaTime);
       * });
       *
       * // Cocos Creator
       * update(deltaTime: number) {
       *     Core.update(deltaTime);
       * }
       *
  
       * ```
       */
  static update(deltaTime) {
    if (!this._instance) {
      Core._logger.warn("Core实例未创建，请先调用Core.create()");
      return;
    }
    this._instance.updateInternal(deltaTime);
  }
  /**
   * 注册全局管理器
   *
   * 将管理器添加到全局管理器列表中，并启用它。
   *
   * @param manager - 要注册的全局管理器
   */
  static registerGlobalManager(manager) {
    this._instance._globalManagers.push(manager);
    manager.enabled = true;
  }
  /**
   * 注销全局管理器
   *
   * 从全局管理器列表中移除管理器，并禁用它。
   *
   * @param manager - 要注销的全局管理器
   */
  static unregisterGlobalManager(manager) {
    this._instance._globalManagers.splice(this._instance._globalManagers.indexOf(manager), 1);
    manager.enabled = false;
  }
  /**
   * 获取指定类型的全局管理器
   *
   * @param type - 管理器类型构造函数
   * @returns 管理器实例，如果未找到则返回null
   */
  static getGlobalManager(type) {
    for (const manager of this._instance._globalManagers) {
      if (manager instanceof type)
        return manager;
    }
    return null;
  }
  /**
   * 调度定时器
   *
   * 创建一个定时器，在指定时间后执行回调函数。
   *
   * @param timeInSeconds - 延迟时间（秒）
   * @param repeats - 是否重复执行，默认为false
   * @param context - 回调函数的上下文，默认为null
   * @param onTime - 定时器触发时的回调函数
   * @returns 创建的定时器实例
   */
  static schedule(timeInSeconds, repeats = false, context, onTime) {
    if (!onTime) {
      throw new Error("onTime callback is required");
    }
    return this._instance._timerManager.schedule(timeInSeconds, repeats, context, onTime);
  }
  /**
   * 获取ECS流式API
   *
   * @returns ECS API实例，如果未初始化则返回null
   */
  static get ecsAPI() {
    return this._instance?._ecsAPI || null;
  }
  /**
   * 启用调试功能
   *
   * @param config 调试配置
   */
  static enableDebug(config) {
    if (!this._instance) {
      Core._logger.warn("Core实例未创建，请先调用Core.create()");
      return;
    }
    if (this._instance._debugManager) {
      this._instance._debugManager.updateConfig(config);
    } else {
      this._instance._debugManager = new DebugManager(this._instance, config);
    }
    this._instance._config.debugConfig = config;
  }
  /**
   * 禁用调试功能
   */
  static disableDebug() {
    if (!this._instance)
      return;
    if (this._instance._debugManager) {
      this._instance._debugManager.stop();
      this._instance._debugManager = void 0;
    }
    if (this._instance._config.debugConfig) {
      this._instance._config.debugConfig.enabled = false;
    }
  }
  /**
   * 获取调试数据
   *
   * @returns 当前调试数据，如果调试未启用则返回null
   */
  static getDebugData() {
    if (!this._instance?._debugManager) {
      return null;
    }
    return this._instance._debugManager.getDebugData();
  }
  /**
   * 检查调试是否启用
   *
   * @returns 调试状态
   */
  static get isDebugEnabled() {
    return this._instance?._config.debugConfig?.enabled || false;
  }
  /**
   * 获取WorldManager实例
   *
   * @param config 可选的WorldManager配置，用于覆盖默认配置
   * @returns WorldManager实例，如果未初始化则自动创建
   */
  static getWorldManager(config) {
    if (!this._instance) {
      throw new Error("Core实例未创建，请先调用Core.create()");
    }
    if (!this._instance._worldManager) {
      const defaultConfig = {
        maxWorlds: 50,
        autoCleanup: true,
        cleanupInterval: 6e4,
        debug: this._instance._config.debug
      };
      this._instance._worldManager = WorldManager.getInstance({
        ...defaultConfig,
        ...config
        // 用户传入的配置会覆盖默认配置
      });
    }
    return this._instance._worldManager;
  }
  /**
   * 启用World管理
   *
   * 显式启用World功能，用于多房间/多世界架构
   *
   * @param config 可选的WorldManager配置，用于覆盖默认配置
   */
  static enableWorldManager(config) {
    return this.getWorldManager(config);
  }
  /**
   * 确保默认World存在
   *
   * 内部方法，用于懒初始化默认World
   */
  ensureDefaultWorld() {
    if (!this._worldManager) {
      this._worldManager = WorldManager.getInstance({
        maxWorlds: 1,
        // 单场景用户只需要1个World
        autoCleanup: false,
        // 单场景不需要自动清理
        cleanupInterval: 0,
        // 禁用清理定时器
        debug: this._config.debug
      });
    }
    if (!this._worldManager.getWorld(Core.DEFAULT_WORLD_ID)) {
      this._worldManager.createWorld(Core.DEFAULT_WORLD_ID, {
        name: "DefaultWorld",
        maxScenes: 1,
        autoCleanup: false
      });
      this._worldManager.setWorldActive(Core.DEFAULT_WORLD_ID, true);
    }
  }
  /**
   * 场景切换回调
   *
   * 在场景切换时调用，用于重置时间系统等。
   */
  onSceneChanged() {
    Time.sceneChanged();
    const currentScene = Core.getScene();
    if (currentScene && currentScene.querySystem && currentScene.eventSystem) {
      this._ecsAPI = createECSAPI(currentScene, currentScene.querySystem, currentScene.eventSystem);
    }
    if (this._debugManager) {
      queueMicrotask(() => {
        this._debugManager?.onSceneChanged();
      });
    }
  }
  /**
   * 初始化核心系统
   *
   * 执行核心系统的初始化逻辑。
   */
  initialize() {
  }
  /**
   * 内部更新方法
   *
   * @param deltaTime - 帧时间间隔（秒）
   */
  updateInternal(deltaTime) {
    if (Core.paused)
      return;
    const frameStartTime = this._performanceMonitor.startMonitoring("Core.update");
    Time.update(deltaTime);
    if ("updateFPS" in this._performanceMonitor && typeof this._performanceMonitor.updateFPS === "function") {
      this._performanceMonitor.updateFPS(Time.deltaTime);
    }
    const managersStartTime = this._performanceMonitor.startMonitoring("GlobalManagers.update");
    for (const globalManager of this._globalManagers) {
      if (globalManager.enabled)
        globalManager.update();
    }
    this._performanceMonitor.endMonitoring("GlobalManagers.update", managersStartTime, this._globalManagers.length);
    this._poolManager.update();
    if (this._worldManager) {
      const worldsStartTime = this._performanceMonitor.startMonitoring("Worlds.update");
      const activeWorlds = this._worldManager.getActiveWorlds();
      let totalWorldEntities = 0;
      for (const world of activeWorlds) {
        world.updateGlobalSystems();
        world.updateScenes();
        const worldStats = world.getStats();
        totalWorldEntities += worldStats.totalEntities;
      }
      this._performanceMonitor.endMonitoring("Worlds.update", worldsStartTime, totalWorldEntities);
    }
    if (this._debugManager) {
      this._debugManager.onFrameUpdate(deltaTime);
    }
    this._performanceMonitor.endMonitoring("Core.update", frameStartTime);
  }
}
Core.paused = false;
Core.DEFAULT_WORLD_ID = "__default__";
Core.DEFAULT_SCENE_ID = "__main__";
Core._logger = createLogger("Core");
class Component {
  /**
   * 创建组件实例
   *
   * 自动分配唯一ID给组件。
   */
  constructor() {
    this._enabled = true;
    this._updateOrder = 0;
    this.id = Component._idGenerator++;
  }
  /**
   * 获取组件启用状态
   *
   * 组件的实际启用状态取决于自身状态和所属实体的状态。
   *
   * @deprecated 不符合ECS架构规范，建议自己实现DisabledComponent标记组件替代
   * @returns 如果组件和所属实体都启用则返回true
   */
  get enabled() {
    return this.entity ? this.entity.enabled && this._enabled : this._enabled;
  }
  /**
   * 设置组件启用状态
   *
   * 当状态改变时会触发相应的生命周期回调。
   *
   * @deprecated 不符合ECS架构规范，建议自己实现DisabledComponent标记组件替代
   * @param value - 新的启用状态
   */
  set enabled(value) {
    if (this._enabled !== value) {
      this._enabled = value;
      if (this._enabled) {
        this.onEnabled();
      } else {
        this.onDisabled();
      }
    }
  }
  /**
   * 获取更新顺序
   *
   * @deprecated 不符合ECS架构规范，更新顺序应该由EntitySystem管理
   * @see EntitySystem
   * @returns 组件的更新顺序值
   */
  get updateOrder() {
    return this._updateOrder;
  }
  /**
   * 设置更新顺序
   *
   * @deprecated 不符合ECS架构规范，更新顺序应该由EntitySystem管理
   * @see EntitySystem
   * @param value - 新的更新顺序值
   */
  set updateOrder(value) {
    this._updateOrder = value;
  }
  /**
   * 组件添加到实体时的回调
   *
   * 当组件被添加到实体时调用，可以在此方法中进行初始化操作。
   */
  onAddedToEntity() {
  }
  /**
   * 组件从实体移除时的回调
   *
   * 当组件从实体中移除时调用，可以在此方法中进行清理操作。
   */
  onRemovedFromEntity() {
  }
  /**
   * 组件启用时的回调
   *
   * 当组件被启用时调用。
   */
  onEnabled() {
  }
  /**
   * 组件禁用时的回调
   *
   * 当组件被禁用时调用。
   */
  onDisabled() {
  }
  /**
   * 更新组件
   *
   * @deprecated 不符合ECS架构规范，建议使用EntitySystem来处理更新逻辑
   */
  update() {
  }
}
Component._idGenerator = 0;
class Matcher {
  constructor() {
    this.condition = {
      all: [],
      any: [],
      none: []
    };
  }
  /**
   * 创建匹配器，要求所有指定的组件
   * @param types 组件类型
   */
  static all(...types) {
    const matcher = new Matcher();
    return matcher.all(...types);
  }
  /**
   * 创建匹配器，要求至少一个指定的组件
   * @param types 组件类型
   */
  static any(...types) {
    const matcher = new Matcher();
    return matcher.any(...types);
  }
  /**
   * 创建匹配器，排除指定的组件
   * @param types 组件类型
   */
  static none(...types) {
    const matcher = new Matcher();
    return matcher.none(...types);
  }
  /**
   * 创建按标签查询的匙配器
   * @param tag 标签值
   */
  static byTag(tag) {
    const matcher = new Matcher();
    return matcher.withTag(tag);
  }
  /**
   * 创建按名称查询的匙配器
   * @param name 实体名称
   */
  static byName(name) {
    const matcher = new Matcher();
    return matcher.withName(name);
  }
  /**
   * 创建单组件查询的匙配器
   * @param componentType 组件类型
   */
  static byComponent(componentType) {
    const matcher = new Matcher();
    return matcher.withComponent(componentType);
  }
  /**
   * 创建复杂查询构建器
   */
  static complex() {
    return new Matcher();
  }
  /**
   * 创建空匙配器
   */
  static empty() {
    return new Matcher();
  }
  /**
   * 必须包含所有指定组件
   * @param types 组件类型
   */
  all(...types) {
    this.condition.all.push(...types);
    return this;
  }
  /**
   * 必须包含至少一个指定组件
   * @param types 组件类型
   */
  any(...types) {
    this.condition.any.push(...types);
    return this;
  }
  /**
   * 不能包含任何指定组件
   * @param types 组件类型
   */
  none(...types) {
    this.condition.none.push(...types);
    return this;
  }
  /**
   * 排除指定组件（别名方法）
   * @param types 组件类型
   */
  exclude(...types) {
    return this.none(...types);
  }
  /**
   * 至少包含其中之一（别名方法）
   * @param types 组件类型
   */
  one(...types) {
    return this.any(...types);
  }
  /**
   * 按标签查询
   * @param tag 标签值
   */
  withTag(tag) {
    this.condition.tag = tag;
    return this;
  }
  /**
   * 按名称查询
   * @param name 实体名称
   */
  withName(name) {
    this.condition.name = name;
    return this;
  }
  /**
   * 单组件查询
   * @param componentType 组件类型
   */
  withComponent(componentType) {
    this.condition.component = componentType;
    return this;
  }
  /**
   * 移除标签条件
   */
  withoutTag() {
    delete this.condition.tag;
    return this;
  }
  /**
   * 移除名称条件
   */
  withoutName() {
    delete this.condition.name;
    return this;
  }
  /**
   * 移除单组件条件
   */
  withoutComponent() {
    delete this.condition.component;
    return this;
  }
  /**
   * 获取查询条件（只读）
   */
  getCondition() {
    return {
      all: [...this.condition.all],
      any: [...this.condition.any],
      none: [...this.condition.none],
      tag: this.condition.tag,
      name: this.condition.name,
      component: this.condition.component
    };
  }
  /**
   * 检查是否为空条件
   */
  isEmpty() {
    return this.condition.all.length === 0 && this.condition.any.length === 0 && this.condition.none.length === 0 && this.condition.tag === void 0 && this.condition.name === void 0 && this.condition.component === void 0;
  }
  /**
   * 重置所有条件
   */
  reset() {
    this.condition.all.length = 0;
    this.condition.any.length = 0;
    this.condition.none.length = 0;
    delete this.condition.tag;
    delete this.condition.name;
    delete this.condition.component;
    return this;
  }
  /**
   * 克隆匹配器
   */
  clone() {
    const cloned = new Matcher();
    cloned.condition.all.push(...this.condition.all);
    cloned.condition.any.push(...this.condition.any);
    cloned.condition.none.push(...this.condition.none);
    if (this.condition.tag !== void 0) {
      cloned.condition.tag = this.condition.tag;
    }
    if (this.condition.name !== void 0) {
      cloned.condition.name = this.condition.name;
    }
    if (this.condition.component !== void 0) {
      cloned.condition.component = this.condition.component;
    }
    return cloned;
  }
  /**
   * 字符串表示
   */
  toString() {
    const parts = [];
    if (this.condition.all.length > 0) {
      parts.push(`all(${this.condition.all.map((t) => getComponentTypeName(t)).join(", ")})`);
    }
    if (this.condition.any.length > 0) {
      parts.push(`any(${this.condition.any.map((t) => getComponentTypeName(t)).join(", ")})`);
    }
    if (this.condition.none.length > 0) {
      parts.push(`none(${this.condition.none.map((t) => getComponentTypeName(t)).join(", ")})`);
    }
    if (this.condition.tag !== void 0) {
      parts.push(`tag(${this.condition.tag})`);
    }
    if (this.condition.name !== void 0) {
      parts.push(`name(${this.condition.name})`);
    }
    if (this.condition.component !== void 0) {
      parts.push(`component(${getComponentTypeName(this.condition.component)})`);
    }
    return `Matcher[${parts.join(" & ")}]`;
  }
}
class EntitySystem {
  /**
   * 获取系统处理的实体列表
   */
  get entities() {
    if (this._entityCache.frame !== null) {
      return this._entityCache.frame;
    }
    if (this._entityCache.persistent === null) {
      this._entityCache.persistent = this.queryEntities();
    }
    return this._entityCache.persistent;
  }
  /**
   * 获取系统的更新时序
   */
  get updateOrder() {
    return this._updateOrder;
  }
  set updateOrder(value) {
    this.setUpdateOrder(value);
  }
  /**
   * 获取系统的启用状态
   */
  get enabled() {
    return this._enabled;
  }
  /**
   * 设置系统的启用状态
   */
  set enabled(value) {
    this._enabled = value;
  }
  /**
   * 获取系统名称
   */
  get systemName() {
    return this._systemName;
  }
  constructor(matcher) {
    this._updateOrder = 0;
    this._enabled = true;
    this._performanceMonitor = PerformanceMonitor.instance;
    this._systemName = getSystemInstanceTypeName(this);
    this._initialized = false;
    this._matcher = matcher || Matcher.empty();
    this._eventListeners = [];
    this._scene = null;
    this._entityIdMap = null;
    this._entityIdMapVersion = -1;
    this._entityIdMapSize = 0;
    this._entityCache = {
      frame: null,
      persistent: null,
      tracked: /* @__PURE__ */ new Set(),
      invalidate() {
        this.persistent = null;
      },
      clearFrame() {
        this.frame = null;
      },
      clearAll() {
        this.frame = null;
        this.persistent = null;
        this.tracked.clear();
      }
    };
  }
  /**
   * 这个系统所属的场景
   */
  get scene() {
    return this._scene;
  }
  set scene(value) {
    this._scene = value;
  }
  /**
   * 获取实体匹配器
   */
  get matcher() {
    return this._matcher;
  }
  /**
   * 设置更新时序
   * @param order 更新时序
   */
  setUpdateOrder(order) {
    this._updateOrder = order;
    if (this.scene && this.scene.entityProcessors) {
      this.scene.entityProcessors.setDirty();
    }
  }
  /**
   * 系统初始化（框架调用）
   *
   * 在系统创建时调用。框架内部使用，用户不应直接调用。
   */
  initialize() {
    if (this._initialized) {
      return;
    }
    this._initialized = true;
    if (this.scene) {
      this._entityCache.invalidate();
      this.queryEntities();
    }
    this.onInitialize();
  }
  /**
   * 系统初始化回调
   *
   * 子类可以重写此方法进行初始化操作。
   */
  onInitialize() {
  }
  /**
   * 清除实体缓存（内部使用）
   * 当Scene中的实体发生变化时调用
   */
  clearEntityCache() {
    this._entityCache.invalidate();
  }
  /**
   * 重置系统状态
   *
   * 当系统从场景中移除时调用，重置初始化状态以便重新添加时能正确初始化。
   */
  reset() {
    this.scene = null;
    this._initialized = false;
    this._entityCache.clearAll();
    this._entityIdMap = null;
    this._entityIdMapVersion = -1;
    this._entityIdMapSize = 0;
    this.cleanupEventListeners();
    this.onDestroy();
  }
  /**
   * 查询匹配的实体
   */
  queryEntities() {
    if (!this.scene?.querySystem || !this._matcher) {
      return [];
    }
    const condition = this._matcher.getCondition();
    const querySystem = this.scene.querySystem;
    let currentEntities = [];
    if (this._matcher.isEmpty()) {
      currentEntities = querySystem.getAllEntities();
    } else if (this.isSingleCondition(condition)) {
      currentEntities = this.executeSingleConditionQuery(condition, querySystem);
    } else {
      currentEntities = this.executeComplexQuery(condition, querySystem);
    }
    this.updateEntityTracking(currentEntities);
    return currentEntities;
  }
  /**
   * 检查是否为单一条件查询
   */
  isSingleCondition(condition) {
    const flags = (condition.all.length > 0 ? 1 : 0) | (condition.any.length > 0 ? 2 : 0) | (condition.none.length > 0 ? 4 : 0) | (condition.tag !== void 0 ? 8 : 0) | (condition.name !== void 0 ? 16 : 0) | (condition.component !== void 0 ? 32 : 0);
    return flags !== 0 && (flags & flags - 1) === 0;
  }
  /**
   * 执行单一条件查询
   */
  executeSingleConditionQuery(condition, querySystem) {
    if (condition.tag !== void 0) {
      return querySystem.queryByTag(condition.tag).entities;
    }
    if (condition.name !== void 0) {
      return querySystem.queryByName(condition.name).entities;
    }
    if (condition.component !== void 0) {
      return querySystem.queryByComponent(condition.component).entities;
    }
    if (condition.all.length > 0 && condition.any.length === 0 && condition.none.length === 0) {
      return querySystem.queryAll(...condition.all).entities;
    }
    if (condition.all.length === 0 && condition.any.length > 0 && condition.none.length === 0) {
      return querySystem.queryAny(...condition.any).entities;
    }
    if (condition.all.length === 0 && condition.any.length === 0 && condition.none.length > 0) {
      return querySystem.queryNone(...condition.none).entities;
    }
    return [];
  }
  /**
   * 执行复合查询
   */
  executeComplexQueryWithIdSets(condition, querySystem) {
    let resultIds = null;
    if (condition.tag !== void 0) {
      const tagResult = querySystem.queryByTag(condition.tag);
      resultIds = this.extractEntityIds(tagResult.entities);
    }
    if (condition.name !== void 0) {
      const nameIds = this.extractEntityIds(querySystem.queryByName(condition.name).entities);
      resultIds = resultIds ? this.intersectIdSets(resultIds, nameIds) : nameIds;
    }
    if (condition.component !== void 0) {
      const componentIds = this.extractEntityIds(querySystem.queryByComponent(condition.component).entities);
      resultIds = resultIds ? this.intersectIdSets(resultIds, componentIds) : componentIds;
    }
    if (condition.all.length > 0) {
      const allIds = this.extractEntityIds(querySystem.queryAll(...condition.all).entities);
      resultIds = resultIds ? this.intersectIdSets(resultIds, allIds) : allIds;
    }
    if (condition.any.length > 0) {
      const anyIds = this.extractEntityIds(querySystem.queryAny(...condition.any).entities);
      resultIds = resultIds ? this.intersectIdSets(resultIds, anyIds) : anyIds;
    }
    if (condition.none.length > 0) {
      if (!resultIds) {
        resultIds = this.extractEntityIds(querySystem.getAllEntities());
      }
      const noneResult = querySystem.queryAny(...condition.none);
      const noneIds = this.extractEntityIds(noneResult.entities);
      resultIds = this.differenceIdSets(resultIds, noneIds);
    }
    return resultIds ? this.idSetToEntityArray(resultIds, querySystem.getAllEntities()) : [];
  }
  /**
   * 提取实体ID集合
   */
  extractEntityIds(entities) {
    const len = entities.length;
    const idSet = /* @__PURE__ */ new Set();
    for (let i = 0; i < len; i = i + 1 | 0) {
      idSet.add(entities[i].id | 0);
    }
    return idSet;
  }
  /**
   * ID集合交集运算
   */
  intersectIdSets(setA, setB) {
    let smaller, larger;
    if (setA.size <= setB.size) {
      smaller = setA;
      larger = setB;
    } else {
      smaller = setB;
      larger = setA;
    }
    const result = /* @__PURE__ */ new Set();
    for (const id of smaller) {
      if (larger.has(id)) {
        result.add(id);
      }
    }
    return result;
  }
  /**
   * ID集合差集运算
   */
  differenceIdSets(setA, setB) {
    const result = /* @__PURE__ */ new Set();
    for (const id of setA) {
      if (!setB.has(id)) {
        result.add(id);
      }
    }
    return result;
  }
  /**
   * 获取或构建实体ID映射
   */
  getEntityIdMap(allEntities) {
    const currentVersion = this.scene?.querySystem?.version ?? 0;
    if (this._entityIdMap !== null && this._entityIdMapVersion === currentVersion) {
      return this._entityIdMap;
    }
    return this.rebuildEntityIdMap(allEntities, currentVersion);
  }
  /**
   * 重建实体ID映射
   */
  rebuildEntityIdMap(allEntities, version) {
    let entityMap = this._entityIdMap;
    if (!entityMap) {
      entityMap = /* @__PURE__ */ new Map();
    } else {
      entityMap.clear();
    }
    const len = allEntities.length;
    for (let i = 0; i < len; i = i + 1 | 0) {
      const entity = allEntities[i];
      entityMap.set(entity.id | 0, entity);
    }
    this._entityIdMap = entityMap;
    this._entityIdMapVersion = version;
    this._entityIdMapSize = len;
    return entityMap;
  }
  /**
   * 从ID集合构建Entity数组
   */
  idSetToEntityArray(idSet, allEntities) {
    const entityMap = this.getEntityIdMap(allEntities);
    const size = idSet.size;
    const result = new Array(size);
    let index = 0;
    for (const id of idSet) {
      const entity = entityMap.get(id);
      if (entity !== void 0) {
        result[index] = entity;
        index = index + 1 | 0;
      }
    }
    if (index < size) {
      result.length = index;
    }
    return result;
  }
  /**
   * 执行复合查询
   *
   * 使用基于ID集合的单次扫描算法进行复杂查询
   */
  executeComplexQuery(condition, querySystem) {
    return this.executeComplexQueryWithIdSets(condition, querySystem);
  }
  /**
   * 更新系统
   */
  update() {
    if (!this._enabled || !this.onCheckProcessing()) {
      return;
    }
    const startTime = this._performanceMonitor.startMonitoring(this._systemName);
    let entityCount = 0;
    try {
      this.onBegin();
      this._entityCache.frame = this.queryEntities();
      entityCount = this._entityCache.frame.length;
      this.process(this._entityCache.frame);
    } finally {
      this._performanceMonitor.endMonitoring(this._systemName, startTime, entityCount);
    }
  }
  /**
   * 后期更新系统
   */
  lateUpdate() {
    if (!this._enabled || !this.onCheckProcessing()) {
      return;
    }
    const startTime = this._performanceMonitor.startMonitoring(`${this._systemName}_Late`);
    let entityCount = 0;
    try {
      const entities = this._entityCache.frame || [];
      entityCount = entities.length;
      this.lateProcess(entities);
      this.onEnd();
    } finally {
      this._performanceMonitor.endMonitoring(`${this._systemName}_Late`, startTime, entityCount);
      this._entityCache.clearFrame();
    }
  }
  /**
   * 在系统处理开始前调用
   *
   * 子类可以重写此方法进行预处理操作。
   */
  onBegin() {
  }
  /**
   * 处理实体列表
   *
   * 系统的核心逻辑，子类必须实现此方法来定义具体的处理逻辑。
   *
   * @param entities 要处理的实体列表
   */
  process(entities) {
  }
  /**
   * 后期处理实体列表
   *
   * 在主要处理逻辑之后执行，子类可以重写此方法。
   *
   * @param entities 要处理的实体列表
   */
  lateProcess(_entities) {
  }
  /**
   * 系统处理完毕后调用
   *
   * 子类可以重写此方法进行后处理操作。
   */
  onEnd() {
  }
  /**
   * 检查系统是否需要处理
   *
   * 在启用系统时有用，但仅偶尔需要处理。
   * 这只影响处理，不影响事件或订阅列表。
   *
   * @returns 如果系统应该处理，则为true，如果不处理则为false
   */
  onCheckProcessing() {
    return true;
  }
  /**
   * 获取系统的性能数据
   *
   * @returns 性能数据或undefined
   */
  getPerformanceData() {
    return this._performanceMonitor.getSystemData(this._systemName);
  }
  /**
   * 获取系统的性能统计
   *
   * @returns 性能统计或undefined
   */
  getPerformanceStats() {
    return this._performanceMonitor.getSystemStats(this._systemName);
  }
  /**
   * 重置系统的性能数据
   */
  resetPerformanceData() {
    this._performanceMonitor.resetSystem(this._systemName);
  }
  /**
   * 获取系统信息的字符串表示
   *
   * @returns 系统信息字符串
   */
  toString() {
    const entityCount = this.entities.length;
    const perfData = this.getPerformanceData();
    const perfInfo = perfData ? ` (${perfData.executionTime.toFixed(2)}ms)` : "";
    return `${this._systemName}[${entityCount} entities]${perfInfo}`;
  }
  /**
   * 更新实体跟踪，检查新增和移除的实体
   */
  updateEntityTracking(currentEntities) {
    const currentSet = new Set(currentEntities);
    let hasChanged = false;
    for (const entity of currentEntities) {
      if (!this._entityCache.tracked.has(entity)) {
        this._entityCache.tracked.add(entity);
        this.onAdded(entity);
        hasChanged = true;
      }
    }
    for (const entity of this._entityCache.tracked) {
      if (!currentSet.has(entity)) {
        this._entityCache.tracked.delete(entity);
        this.onRemoved(entity);
        hasChanged = true;
      }
    }
    if (hasChanged) {
      this._entityCache.invalidate();
    }
  }
  /**
   * 当实体被添加到系统时调用
   *
   * 子类可以重写此方法来处理实体添加事件。
   *
   * @param entity 被添加的实体
   */
  onAdded(entity) {
  }
  /**
   * 当实体从系统中移除时调用
   *
   * 子类可以重写此方法来处理实体移除事件。
   *
   * @param entity 被移除的实体
   */
  onRemoved(entity) {
  }
  /**
   * 添加事件监听器
   *
   * 推荐使用此方法而不是直接调用eventSystem.on()，
   * 这样可以确保系统移除时自动清理监听器，避免内存泄漏。
   *
   * @param eventType 事件类型
   * @param handler 事件处理函数
   * @param config 监听器配置
   */
  addEventListener(eventType, handler, config) {
    if (!this.scene?.eventSystem) {
      console.warn(`[${this.systemName}] Cannot add event listener: scene.eventSystem not available`);
      return;
    }
    const listenerRef = this.scene.eventSystem.on(eventType, handler, config);
    if (listenerRef) {
      this._eventListeners.push({
        eventSystem: this.scene.eventSystem,
        eventType,
        handler,
        listenerRef
      });
    }
  }
  /**
   * 移除特定的事件监听器
   *
   * @param eventType 事件类型
   * @param handler 事件处理函数
   */
  removeEventListener(eventType, handler) {
    const listenerIndex = this._eventListeners.findIndex((listener) => listener.eventType === eventType && listener.handler === handler);
    if (listenerIndex >= 0) {
      const listener = this._eventListeners[listenerIndex];
      listener.eventSystem.off(eventType, listener.listenerRef);
      this._eventListeners.splice(listenerIndex, 1);
    }
  }
  /**
   * 清理所有事件监听器
   *
   * 系统移除时自动调用，清理所有通过addEventListener添加的监听器。
   */
  cleanupEventListeners() {
    for (const listener of this._eventListeners) {
      try {
        listener.eventSystem.off(listener.eventType, listener.listenerRef);
      } catch (error) {
        console.warn(`[${this.systemName}] Failed to remove event listener for "${listener.eventType}":`, error);
      }
    }
    this._eventListeners.length = 0;
  }
  /**
   * 系统销毁时的回调
   *
   * 当系统从场景中移除时调用，子类可以重写此方法进行清理操作。
   * 注意：事件监听器会被框架自动清理，无需手动处理。
   */
  onDestroy() {
  }
}
class WorkerEntitySystem extends EntitySystem {
  constructor(matcher, config = {}) {
    super(matcher);
    this.workerPool = null;
    this.isProcessing = false;
    this.sharedBuffer = null;
    this.sharedFloatArray = null;
    this.config = {
      enableWorker: config.enableWorker ?? true,
      workerCount: config.workerCount ?? this.getOptimalWorkerCount(),
      systemConfig: config.systemConfig,
      useSharedArrayBuffer: config.useSharedArrayBuffer ?? this.isSharedArrayBufferSupported(),
      entityDataSize: config.entityDataSize ?? this.getDefaultEntityDataSize(),
      maxEntities: config.maxEntities ?? 1e4
    };
    if (this.config.enableWorker && this.isWorkerSupported()) {
      if (this.config.useSharedArrayBuffer) {
        this.initializeSharedArrayBuffer();
      }
      this.initializeWorkerPool();
    }
  }
  /**
   * 检查是否支持Worker
   */
  isWorkerSupported() {
    return typeof Worker !== "undefined" && typeof Blob !== "undefined";
  }
  /**
   * 检查是否支持SharedArrayBuffer
   */
  isSharedArrayBufferSupported() {
    return typeof SharedArrayBuffer !== "undefined" && self.crossOriginIsolated;
  }
  /**
   * 获取最优Worker数量
   */
  getOptimalWorkerCount() {
    if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
      return Math.min(navigator.hardwareConcurrency, 4);
    }
    return 2;
  }
  /**
   * 初始化SharedArrayBuffer
   */
  initializeSharedArrayBuffer() {
    try {
      if (!this.isSharedArrayBufferSupported()) {
        console.warn(`[${this.systemName}] SharedArrayBuffer not supported, falling back to single Worker mode for collision detection integrity`);
        this.config.useSharedArrayBuffer = false;
        this.config.workerCount = 1;
        return;
      }
      const bufferSize = this.config.maxEntities * this.config.entityDataSize * 4;
      this.sharedBuffer = new SharedArrayBuffer(bufferSize);
      this.sharedFloatArray = new Float32Array(this.sharedBuffer);
      console.log(`[${this.systemName}] SharedArrayBuffer initialized successfully (${bufferSize} bytes)`);
    } catch (error) {
      console.warn(`[${this.systemName}] SharedArrayBuffer init failed, falling back to single Worker mode for collision detection integrity:`, error);
      this.config.useSharedArrayBuffer = false;
      this.sharedBuffer = null;
      this.sharedFloatArray = null;
      this.config.workerCount = 1;
    }
  }
  /**
   * 初始化Worker池
   */
  initializeWorkerPool() {
    try {
      const script = this.createWorkerScript();
      this.workerPool = new WebWorkerPool(
        this.config.workerCount,
        script,
        this.sharedBuffer
        // 传递SharedArrayBuffer给Worker池
      );
    } catch (error) {
      console.error(`[${this.systemName}] Failed to initialize worker pool:`, 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;
    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) {
        if (this.config.useSharedArrayBuffer && this.sharedFloatArray && this.isSharedArrayBufferSupported()) {
          this.processWithSharedArrayBuffer(entities).finally(() => {
            this.isProcessing = false;
          });
        } else {
          if (this.config.useSharedArrayBuffer) {
            console.log(`[${this.systemName}] Falling back to traditional Worker mode for this frame`);
          }
          this.processWithWorker(entities).finally(() => {
            this.isProcessing = false;
          });
        }
      } else {
        console.log(`[${this.systemName}] Worker not available, processing synchronously`);
        this.processSynchronously(entities);
        this.isProcessing = false;
      }
    } catch (error) {
      this.isProcessing = false;
      console.error(`[${this.systemName}] Processing failed:`, error);
      throw error;
    }
  }
  /**
   * 使用SharedArrayBuffer优化的Worker处理
   */
  async processWithSharedArrayBuffer(entities) {
    if (!this.sharedFloatArray) {
      throw new Error("SharedArrayBuffer not initialized");
    }
    this.writeEntitiesToSharedBuffer(entities);
    const promises = this.createSharedArrayBufferTasks(entities.length);
    await Promise.all(promises);
    this.readResultsFromSharedBuffer(entities);
  }
  /**
   * 使用Worker并行处理
   */
  async processWithWorker(entities) {
    const entityData = [];
    for (let i = 0; i < entities.length; i++) {
      entityData[i] = this.extractEntityData(entities[i]);
    }
    const batches = this.createBatches(entityData);
    const deltaTime = Time.deltaTime;
    const promises = batches.map((batch) => this.workerPool.execute({
      entities: batch,
      deltaTime,
      systemConfig: this.config.systemConfig
    }));
    const results = await Promise.all(promises);
    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) {
    const entityData = entities.map((entity) => this.extractEntityData(entity));
    const deltaTime = Time.deltaTime;
    const results = this.workerProcess(entityData, deltaTime, this.config.systemConfig);
    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 = [];
    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任务
   */
  createSharedArrayBufferTasks(entityCount) {
    const promises = [];
    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;
      const result = this.readEntityFromBuffer(offset);
      if (result) {
        this.applyResult(entity, result);
      }
    }
  }
  /**
   * 更新Worker配置
   */
  updateConfig(newConfig) {
    const oldConfig = { ...this.config };
    Object.assign(this.config, newConfig);
    if (oldConfig.useSharedArrayBuffer !== this.config.useSharedArrayBuffer) {
      this.reinitializeWorkerSystem();
      return;
    }
    if (oldConfig.workerCount !== this.config.workerCount) {
      this.reinitializeWorkerPool();
      return;
    }
    if (!this.config.enableWorker && this.workerPool) {
      this.workerPool.destroy();
      this.workerPool = null;
    }
    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;
    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,
      isProcessing: this.isProcessing,
      sharedArrayBufferSupported: this.isSharedArrayBufferSupported(),
      sharedArrayBufferEnabled: this.config.useSharedArrayBuffer,
      currentMode
    };
  }
  /**
   * 销毁系统时清理Worker池
   */
  onDestroy() {
    super.onDestroy();
    if (this.workerPool) {
      this.workerPool.destroy();
      this.workerPool = null;
    }
  }
}
class WebWorkerPool {
  constructor(workerCount, script, sharedBuffer) {
    this.workers = [];
    this.taskQueue = [];
    this.busyWorkers = /* @__PURE__ */ new Set();
    this.taskCounter = 0;
    this.sharedBuffer = null;
    this.sharedBuffer = sharedBuffer || null;
    const blob = new Blob([script], { type: "application/javascript" });
    const scriptURL = URL.createObjectURL(blob);
    for (let i = 0; i < workerCount; i++) {
      const worker = new Worker(scriptURL);
      worker.onmessage = (e) => this.handleWorkerMessage(i, e.data);
      worker.onerror = (error) => this.handleWorkerError(i, error);
      if (sharedBuffer) {
        worker.postMessage({
          type: "init",
          sharedBuffer
        });
      }
      this.workers.push(worker);
    }
    URL.revokeObjectURL(scriptURL);
  }
  /**
   * 执行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;
    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);
        this.workers[i].postMessage({
          id: task.id,
          ...task.data
        });
        this.workers[i]._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();
  }
}
var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
var __decorateClass$3 = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = decorator(result) || result;
  return result;
};
let Position = class extends Component {
  constructor(x = 0, y = 0) {
    super();
    this.x = 0;
    this.y = 0;
    this.x = x;
    this.y = y;
  }
  set(x, y) {
    this.x = x;
    this.y = y;
  }
};
Position = __decorateClass$3([
  ECSComponent("Position")
], Position);
let Velocity = class extends Component {
  constructor(dx = 0, dy = 0) {
    super();
    this.dx = 0;
    this.dy = 0;
    this.dx = dx;
    this.dy = dy;
  }
  set(dx, dy) {
    this.dx = dx;
    this.dy = dy;
  }
  scale(factor) {
    this.dx *= factor;
    this.dy *= factor;
  }
};
Velocity = __decorateClass$3([
  ECSComponent("Velocity")
], Velocity);
let Physics = class extends Component {
  constructor(mass = 1, bounce = 0.8, friction = 0.95) {
    super();
    this.mass = 1;
    this.bounce = 0.8;
    this.friction = 0.95;
    this.mass = mass;
    this.bounce = bounce;
    this.friction = friction;
  }
};
Physics = __decorateClass$3([
  ECSComponent("Physics")
], Physics);
let Renderable = class extends Component {
  constructor(color = "#ffffff", size = 5, shape = "circle") {
    super();
    this.color = "#ffffff";
    this.size = 5;
    this.shape = "circle";
    this.color = color;
    this.size = size;
    this.shape = shape;
  }
};
Renderable = __decorateClass$3([
  ECSComponent("Renderable")
], Renderable);
let Lifetime = class extends Component {
  constructor(maxAge = 5) {
    super();
    this.maxAge = 5;
    this.currentAge = 0;
    this.maxAge = maxAge;
    this.currentAge = 0;
  }
  isDead() {
    return this.currentAge >= this.maxAge;
  }
};
Lifetime = __decorateClass$3([
  ECSComponent("Lifetime")
], Lifetime);
var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
var __decorateClass$2 = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = decorator(result) || result;
  return result;
};
let PhysicsWorkerSystem = class extends WorkerEntitySystem {
  constructor(enableWorker = true) {
    const defaultConfig = {
      gravity: 100,
      canvasWidth: 800,
      canvasHeight: 600,
      groundFriction: 0.98
    };
    const isSharedArrayBufferAvailable = typeof SharedArrayBuffer !== "undefined" && self.crossOriginIsolated;
    super(
      Matcher.empty().all(Position, Velocity, Physics),
      {
        enableWorker,
        // 当 SharedArrayBuffer 可用时使用多 Worker，否则使用单 Worker 保证碰撞检测完整性
        workerCount: isSharedArrayBufferAvailable ? navigator.hardwareConcurrency || 2 : 1,
        systemConfig: defaultConfig,
        useSharedArrayBuffer: true
        // 优先使用 SharedArrayBuffer
      }
    );
    this.physicsConfig = {
      gravity: 100,
      canvasWidth: 800,
      canvasHeight: 600,
      groundFriction: 0.98
      // 减少地面摩擦
    };
    this.startTime = 0;
  }
  extractEntityData(entity) {
    const position = entity.getComponent(Position);
    const velocity = entity.getComponent(Velocity);
    const physics = entity.getComponent(Physics);
    const renderable = entity.getComponent(Renderable);
    return {
      id: entity.id,
      x: position.x,
      y: position.y,
      dx: velocity.dx,
      dy: velocity.dy,
      mass: physics.mass,
      bounce: physics.bounce,
      friction: physics.friction,
      radius: renderable.size
    };
  }
  /**
   * Worker处理函数 - 纯函数，会被序列化到Worker中执行
   * 注意：这个函数内部不能访问外部变量，必须是纯函数
   * 非SharedArrayBuffer模式：每个Worker只能看到分配给它的实体批次
   * 这会导致跨批次的碰撞检测缺失，但单批次内的碰撞是正确的
   */
  workerProcess(entities, deltaTime, systemConfig) {
    const config = systemConfig || {
      gravity: 100,
      canvasWidth: 800,
      canvasHeight: 600,
      groundFriction: 0.98
    };
    const result = entities.map((e) => ({ ...e }));
    for (let i = 0; i < result.length; i++) {
      const entity = result[i];
      entity.dy += config.gravity * deltaTime;
      entity.x += entity.dx * deltaTime;
      entity.y += entity.dy * deltaTime;
      if (entity.x <= entity.radius) {
        entity.x = entity.radius;
        entity.dx = -entity.dx * entity.bounce;
      } else if (entity.x >= config.canvasWidth - entity.radius) {
        entity.x = config.canvasWidth - entity.radius;
        entity.dx = -entity.dx * entity.bounce;
      }
      if (entity.y <= entity.radius) {
        entity.y = entity.radius;
        entity.dy = -entity.dy * entity.bounce;
      } else if (entity.y >= config.canvasHeight - entity.radius) {
        entity.y = config.canvasHeight - entity.radius;
        entity.dy = -entity.dy * entity.bounce;
        entity.dx *= config.groundFriction;
      }
      entity.dx *= entity.friction;
      entity.dy *= entity.friction;
    }
    for (let i = 0; i < result.length; i++) {
      for (let j = i + 1; j < result.length; j++) {
        const ball1 = result[i];
        const ball2 = result[j];
        const dx = ball2.x - ball1.x;
        const dy = ball2.y - ball1.y;
        const distance = Math.sqrt(dx * dx + dy * dy);
        const minDistance = ball1.radius + ball2.radius;
        if (distance < minDistance && distance > 0) {
          const nx = dx / distance;
          const ny = dy / distance;
          const overlap = minDistance - distance;
          const separationX = nx * overlap * 0.5;
          const separationY = ny * overlap * 0.5;
          ball1.x -= separationX;
          ball1.y -= separationY;
          ball2.x += separationX;
          ball2.y += separationY;
          const relativeVelocityX = ball2.dx - ball1.dx;
          const relativeVelocityY = ball2.dy - ball1.dy;
          const velocityAlongNormal = relativeVelocityX * nx + relativeVelocityY * ny;
          if (velocityAlongNormal > 0) continue;
          const restitution = (ball1.bounce + ball2.bounce) * 0.5;
          const impulseScalar = -(1 + restitution) * velocityAlongNormal / (1 / ball1.mass + 1 / ball2.mass);
          const impulseX = impulseScalar * nx;
          const impulseY = impulseScalar * ny;
          ball1.dx -= impulseX / ball1.mass;
          ball1.dy -= impulseY / ball1.mass;
          ball2.dx += impulseX / ball2.mass;
          ball2.dy += impulseY / ball2.mass;
          const energyLoss = 0.98;
          ball1.dx *= energyLoss;
          ball1.dy *= energyLoss;
          ball2.dx *= energyLoss;
          ball2.dy *= energyLoss;
        }
      }
    }
    return result;
  }
  /**
   * 应用处理结果
   */
  applyResult(entity, result) {
    if (!entity || !entity.enabled) {
      return;
    }
    const position = entity.getComponent(Position);
    const velocity = entity.getComponent(Velocity);
    if (!position || !velocity) {
      return;
    }
    position.set(result.x, result.y);
    velocity.set(result.dx, result.dy);
  }
  /**
   * 更新物理配置
   */
  updatePhysicsConfig(newConfig) {
    Object.assign(this.physicsConfig, newConfig);
    this.updateConfig({ systemConfig: this.physicsConfig });
  }
  /**
   * 获取物理配置
   */
  getPhysicsConfig() {
    return { ...this.physicsConfig };
  }
  /**
   * 禁用 SharedArrayBuffer（用于测试降级行为）
   */
  disableSharedArrayBuffer() {
    console.log(`[${this.systemName}] Disabling SharedArrayBuffer for testing - falling back to single Worker mode`);
    this.updateConfig({
      useSharedArrayBuffer: false
    });
  }
  /**
   * 获取当前运行状态
   */
  getCurrentStatus() {
    const workerInfo = this.getWorkerInfo();
    let mode = "sync";
    if (workerInfo.enabled) {
      if (workerInfo.sharedArrayBufferEnabled && workerInfo.sharedArrayBufferSupported) {
        mode = "shared-buffer";
      } else if (workerInfo.workerCount === 1) {
        mode = "single-worker";
      } else {
        mode = "multi-worker";
      }
    }
    return {
      mode,
      sharedArrayBufferEnabled: workerInfo.sharedArrayBufferEnabled,
      workerCount: workerInfo.workerCount,
      workerEnabled: workerInfo.enabled
    };
  }
  /**
   * 性能监控
   */
  onEnd() {
    super.onEnd();
    const endTime = performance.now();
    const executionTime = endTime - this.startTime;
    window.physicsExecutionTime = executionTime;
  }
  /**
   * 获取实体数据大小
   */
  getDefaultEntityDataSize() {
    return 9;
  }
  /**
   * 将实体数据写入SharedArrayBuffer
   */
  writeEntityToBuffer(entityData, offset) {
    const sharedArray = this.sharedFloatArray;
    if (!sharedArray) return;
    const currentEntityCount = Math.floor(offset / 9) + 1;
    sharedArray[0] = currentEntityCount;
    const dataOffset = offset + 9;
    sharedArray[dataOffset + 0] = entityData.id;
    sharedArray[dataOffset + 1] = entityData.x;
    sharedArray[dataOffset + 2] = entityData.y;
    sharedArray[dataOffset + 3] = entityData.dx;
    sharedArray[dataOffset + 4] = entityData.dy;
    sharedArray[dataOffset + 5] = entityData.mass;
    sharedArray[dataOffset + 6] = entityData.bounce;
    sharedArray[dataOffset + 7] = entityData.friction;
    sharedArray[dataOffset + 8] = entityData.radius;
  }
  /**
   * 性能监控开始
   */
  onBegin() {
    super.onBegin();
    this.startTime = performance.now();
  }
  /**
   * 从SharedArrayBuffer读取实体数据
   */
  readEntityFromBuffer(offset) {
    const sharedArray = this.sharedFloatArray;
    if (!sharedArray) return null;
    const dataOffset = offset + 9;
    return {
      id: sharedArray[dataOffset + 0],
      x: sharedArray[dataOffset + 1],
      y: sharedArray[dataOffset + 2],
      dx: sharedArray[dataOffset + 3],
      dy: sharedArray[dataOffset + 4],
      mass: sharedArray[dataOffset + 5],
      bounce: sharedArray[dataOffset + 6],
      friction: sharedArray[dataOffset + 7],
      radius: sharedArray[dataOffset + 8]
    };
  }
  /**
   * SharedArrayBuffer处理函数
   */
  getSharedArrayBufferProcessFunction() {
    return function(sharedFloatArray, startIndex, endIndex, deltaTime, systemConfig) {
      const config = systemConfig || {
        gravity: 100,
        canvasWidth: 800,
        canvasHeight: 600,
        groundFriction: 0.98
      };
      const actualEntityCount = sharedFloatArray[0];
      for (let i = startIndex; i < endIndex && i < actualEntityCount; i++) {
        const offset = i * 9 + 9;
        const id = sharedFloatArray[offset + 0];
        if (id === 0) continue;
        let x = sharedFloatArray[offset + 1];
        let y = sharedFloatArray[offset + 2];
        let dx = sharedFloatArray[offset + 3];
        let dy = sharedFloatArray[offset + 4];
        const bounce = sharedFloatArray[offset + 6];
        const friction = sharedFloatArray[offset + 7];
        const radius = sharedFloatArray[offset + 8];
        dy += config.gravity * deltaTime;
        x += dx * deltaTime;
        y += dy * deltaTime;
        if (x <= radius) {
          x = radius;
          dx = -dx * bounce;
        } else if (x >= config.canvasWidth - radius) {
          x = config.canvasWidth - radius;
          dx = -dx * bounce;
        }
        if (y <= radius) {
          y = radius;
          dy = -dy * bounce;
        } else if (y >= config.canvasHeight - radius) {
          y = config.canvasHeight - radius;
          dy = -dy * bounce;
          dx *= config.groundFriction;
        }
        dx *= friction;
        dy *= friction;
        sharedFloatArray[offset + 1] = x;
        sharedFloatArray[offset + 2] = y;
        sharedFloatArray[offset + 3] = dx;
        sharedFloatArray[offset + 4] = dy;
      }
      for (let i = startIndex; i < endIndex && i < actualEntityCount; i++) {
        const offset1 = i * 9 + 9;
        const id1 = sharedFloatArray[offset1 + 0];
        if (id1 === 0) continue;
        let x1 = sharedFloatArray[offset1 + 1];
        let y1 = sharedFloatArray[offset1 + 2];
        let dx1 = sharedFloatArray[offset1 + 3];
        let dy1 = sharedFloatArray[offset1 + 4];
        const mass1 = sharedFloatArray[offset1 + 5];
        const bounce1 = sharedFloatArray[offset1 + 6];
        const radius1 = sharedFloatArray[offset1 + 8];
        for (let j = 0; j < actualEntityCount; j++) {
          if (i === j) continue;
          const offset2 = j * 9 + 9;
          const id2 = sharedFloatArray[offset2 + 0];
          if (id2 === 0) continue;
          const x2 = sharedFloatArray[offset2 + 1];
          const y2 = sharedFloatArray[offset2 + 2];
          const dx2 = sharedFloatArray[offset2 + 3];
          const dy2 = sharedFloatArray[offset2 + 4];
          const mass2 = sharedFloatArray[offset2 + 5];
          const bounce2 = sharedFloatArray[offset2 + 6];
          const radius2 = sharedFloatArray[offset2 + 8];
          if (isNaN(x2) || isNaN(y2) || isNaN(radius2) || radius2 <= 0) continue;
          const deltaX = x2 - x1;
          const deltaY = y2 - y1;
          const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
          const minDistance = radius1 + radius2;
          if (distance < minDistance && distance > 0) {
            const nx = deltaX / distance;
            const ny = deltaY / distance;
            const overlap = minDistance - distance;
            const separationX = nx * overlap * 0.5;
            const separationY = ny * overlap * 0.5;
            x1 -= separationX;
            y1 -= separationY;
            const relativeVelocityX = dx2 - dx1;
            const relativeVelocityY = dy2 - dy1;
            const velocityAlongNormal = relativeVelocityX * nx + relativeVelocityY * ny;
            if (velocityAlongNormal > 0) continue;
            const restitution = (bounce1 + bounce2) * 0.5;
            const impulseScalar = -(1 + restitution) * velocityAlongNormal / (1 / mass1 + 1 / mass2);
            const impulseX = impulseScalar * nx;
            const impulseY = impulseScalar * ny;
            dx1 -= impulseX / mass1;
            dy1 -= impulseY / mass1;
            const energyLoss = 0.98;
            dx1 *= energyLoss;
            dy1 *= energyLoss;
          }
        }
        sharedFloatArray[offset1 + 1] = x1;
        sharedFloatArray[offset1 + 2] = y1;
        sharedFloatArray[offset1 + 3] = dx1;
        sharedFloatArray[offset1 + 4] = dy1;
      }
    };
  }
};
PhysicsWorkerSystem = __decorateClass$2([
  ECSSystem("PhysicsWorkerSystem")
], PhysicsWorkerSystem);
var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
var __decorateClass$1 = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = decorator(result) || result;
  return result;
};
let RenderSystem = class extends EntitySystem {
  constructor(canvas) {
    super(Matcher.empty().all(Position, Renderable));
    this.startTime = 0;
    this.batchCount = 0;
    this.drawCallCount = 0;
    this.canvas = canvas;
    this.ctx = canvas.getContext("2d");
  }
  onBegin() {
    super.onBegin();
    this.startTime = performance.now();
    this.ctx.fillStyle = "#000000";
    this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
  }
  process(entities) {
    let lastColor = "";
    this.drawCallCount = 0;
    for (const entity of entities) {
      const position = entity.getComponent(Position);
      const renderable = entity.getComponent(Renderable);
      if (renderable.color !== lastColor) {
        this.ctx.fillStyle = renderable.color;
        lastColor = renderable.color;
      }
      if (renderable.shape === "circle") {
        this.ctx.beginPath();
        this.ctx.arc(position.x, position.y, renderable.size, 0, Math.PI * 2);
        this.ctx.fill();
        this.drawCallCount++;
      } else if (renderable.shape === "square") {
        this.ctx.fillRect(
          position.x - renderable.size / 2,
          position.y - renderable.size / 2,
          renderable.size,
          renderable.size
        );
        this.drawCallCount++;
      }
    }
    const uniqueColors = new Set(entities.map((e) => e.getComponent(Renderable).color));
    this.batchCount = uniqueColors.size;
  }
  onEnd() {
    super.onEnd();
    const endTime = performance.now();
    const executionTime = endTime - this.startTime;
    window.renderExecutionTime = executionTime;
    this.drawDebugInfo();
  }
  drawDebugInfo() {
    const entities = this.entities;
    this.ctx.fillStyle = "#00ff00";
    this.ctx.font = "14px Arial";
    this.ctx.fillText(`实体数量: ${entities.length}`, 10, 20);
    this.ctx.fillText(`渲染批次: ${this.batchCount}`, 10, 140);
    this.ctx.fillText(`绘制调用: ${this.drawCallCount}`, 10, 160);
    const workerInfo = window.workerInfo;
    if (workerInfo) {
      this.ctx.fillStyle = workerInfo.enabled ? "#00ff00" : "#ff0000";
      this.ctx.fillText(`Worker: ${workerInfo.enabled ? "启用" : "禁用"}`, 10, 40);
      if (workerInfo.enabled) {
        this.ctx.fillStyle = "#ffff00";
        const entitiesPerWorker = Math.ceil(entities.length / workerInfo.workerCount);
        this.ctx.fillText(`每个Worker实体: ${entitiesPerWorker}`, 10, 60);
        this.ctx.fillText(`Worker数量: ${workerInfo.workerCount}`, 10, 80);
      }
    }
    const physicsTime = window.physicsExecutionTime || 0;
    const renderTime = window.renderExecutionTime || 0;
    this.ctx.fillStyle = physicsTime > 16 ? "#ff0000" : physicsTime > 8 ? "#ffff00" : "#00ff00";
    this.ctx.fillText(`物理: ${physicsTime.toFixed(2)}ms`, 10, 100);
    this.ctx.fillStyle = renderTime > 16 ? "#ff0000" : renderTime > 8 ? "#ffff00" : "#00ff00";
    this.ctx.fillText(`渲染: ${renderTime.toFixed(2)}ms`, 10, 120);
  }
};
RenderSystem = __decorateClass$1([
  ECSSystem("RenderSystem")
], RenderSystem);
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = decorator(result) || result;
  return result;
};
let LifetimeSystem = class extends EntitySystem {
  constructor() {
    super(Matcher.empty().all(Lifetime));
  }
  process(entities) {
    const entitiesToRemove = [];
    for (const entity of entities) {
      const lifetime = entity.getComponent(Lifetime);
      lifetime.currentAge += Time.deltaTime;
      if (lifetime.isDead()) {
        entitiesToRemove.push(entity);
      }
    }
    for (const entity of entitiesToRemove) {
      entity.destroy();
    }
  }
};
LifetimeSystem = __decorateClass([
  ECSSystem("LifetimeSystem")
], LifetimeSystem);
class GameScene extends Scene {
  constructor(canvas) {
    super();
    this.canvas = canvas;
  }
  initialize() {
    this.name = "WorkerDemoScene";
    this.physicsSystem = new PhysicsWorkerSystem(true);
    this.renderSystem = new RenderSystem(this.canvas);
    this.lifetimeSystem = new LifetimeSystem();
    this.physicsSystem.updateOrder = 1;
    this.lifetimeSystem.updateOrder = 2;
    this.renderSystem.updateOrder = 3;
    this.addSystem(this.physicsSystem);
    this.addSystem(this.lifetimeSystem);
    this.addSystem(this.renderSystem);
  }
  onStart() {
    console.log("Worker演示场景已启动");
    this.spawnInitialEntities();
  }
  unload() {
    console.log("Worker演示场景已卸载");
  }
  /**
   * 生成初始实体
   */
  spawnInitialEntities(count = 1e3) {
    this.clearAllEntities();
    for (let i = 0; i < count; i++) {
      this.createParticle();
    }
  }
  /**
   * 创建一个粒子实体
   */
  createParticle() {
    const entity = this.createEntity(`Particle_${Date.now()}_${Math.random()}`);
    const x = Math.random() * (this.canvas.width - 20) + 10;
    const y = Math.random() * (this.canvas.height - 20) + 10;
    const dx = (Math.random() - 0.5) * 200;
    const dy = (Math.random() - 0.5) * 200;
    const mass = Math.random() * 3 + 2;
    const bounce = 0.85 + Math.random() * 0.15;
    const friction = 0.998 + Math.random() * 2e-3;
    const colors = [
      "#ff4444",
      "#44ff44",
      "#4444ff",
      "#ffff44",
      "#ff44ff",
      "#44ffff",
      "#ffffff",
      "#ff8844",
      "#88ff44",
      "#4488ff",
      "#ff4488",
      "#88ff88",
      "#8888ff",
      "#ffaa44",
      "#aaff44",
      "#44aaff",
      "#ff44aa",
      "#aa44ff",
      "#44ffaa",
      "#cccccc"
    ];
    const color = colors[Math.floor(Math.random() * colors.length)];
    const size = Math.random() * 6 + 3;
    entity.addComponent(new Position(x, y));
    entity.addComponent(new Velocity(dx, dy));
    entity.addComponent(new Physics(mass, bounce, friction));
    entity.addComponent(new Renderable(color, size, "circle"));
    entity.addComponent(new Lifetime(5 + Math.random() * 10));
  }
  /**
   * 生成粒子爆发效果
   */
  spawnParticleExplosion(centerX, centerY, count = 50) {
    for (let i = 0; i < count; i++) {
      const entity = this.createEntity(`Explosion_${Date.now()}_${i}`);
      const angle = Math.PI * 2 * i / count + (Math.random() - 0.5) * 0.5;
      const distance = Math.random() * 30;
      const x = centerX + Math.cos(angle) * distance;
      const y = centerY + Math.sin(angle) * distance;
      const speed = 100 + Math.random() * 150;
      const dx = Math.cos(angle) * speed;
      const dy = Math.sin(angle) * speed;
      const mass = 0.5 + Math.random() * 1;
      const bounce = 0.8 + Math.random() * 0.2;
      const colors = ["#ffaa00", "#ff6600", "#ff0066", "#ff3300", "#ffff00"];
      const color = colors[Math.floor(Math.random() * colors.length)];
      const size = Math.random() * 4 + 2;
      entity.addComponent(new Position(x, y));
      entity.addComponent(new Velocity(dx, dy));
      entity.addComponent(new Physics(mass, bounce, 0.999));
      entity.addComponent(new Renderable(color, size, "circle"));
      entity.addComponent(new Lifetime(2 + Math.random() * 3));
    }
  }
  /**
   * 清空所有实体
   */
  clearAllEntities() {
    const entities = [...this.entities.buffer];
    for (const entity of entities) {
      entity.destroy();
    }
  }
  /**
   * 切换Worker启用状态
   */
  toggleWorker() {
    const workerInfo = this.physicsSystem.getWorkerInfo();
    const newWorkerEnabled = !workerInfo.enabled;
    this.removeSystem(this.physicsSystem);
    this.physicsSystem = new PhysicsWorkerSystem(newWorkerEnabled);
    this.physicsSystem.updateOrder = 1;
    this.addSystem(this.physicsSystem);
    return newWorkerEnabled;
  }
  /**
   * 更新Worker配置
   */
  updateWorkerConfig(config) {
    if (config.gravity !== void 0 || config.friction !== void 0) {
      const physicsConfig = this.physicsSystem.getPhysicsConfig();
      this.physicsSystem.updatePhysicsConfig({
        gravity: config.gravity ?? physicsConfig.gravity,
        groundFriction: config.friction ?? physicsConfig.groundFriction
      });
    }
  }
  /**
   * 切换 SharedArrayBuffer 状态
   */
  toggleSharedArrayBuffer() {
    this.physicsSystem.disableSharedArrayBuffer();
  }
  /**
   * 获取物理系统状态
   */
  getPhysicsSystemStatus() {
    return this.physicsSystem.getCurrentStatus();
  }
  /**
   * 获取系统信息
   */
  getSystemInfo() {
    return {
      physics: this.physicsSystem.getWorkerInfo(),
      entityCount: this.entities.count,
      physicsConfig: this.physicsSystem.getPhysicsConfig()
    };
  }
}
class WorkerDemo {
  constructor() {
    this.isRunning = false;
    this.lastTime = 0;
    this.frameCount = 0;
    this.fpsUpdateTime = 0;
    this.currentFPS = 0;
    this.lastWorkerStatusUpdate = 0;
    this.elements = {};
    this.gameLoop = () => {
      if (!this.isRunning) return;
      const currentTime = performance.now();
      const deltaTime = (currentTime - this.lastTime) / 1e3;
      this.lastTime = currentTime;
      const frameStartTime = performance.now();
      Core.update(deltaTime);
      const frameEndTime = performance.now();
      this.updatePerformanceStats({
        fps: this.currentFPS,
        frameTime: frameEndTime - frameStartTime,
        physicsTime: window.physicsExecutionTime || 0,
        renderTime: window.renderExecutionTime || 0,
        memoryUsage: this.getMemoryUsage()
      });
      this.frameCount++;
      if (currentTime - this.fpsUpdateTime >= 1e3) {
        this.currentFPS = this.frameCount;
        this.frameCount = 0;
        this.fpsUpdateTime = currentTime;
      }
      this.updateUI();
      requestAnimationFrame(this.gameLoop);
    };
    this.canvas = document.getElementById("gameCanvas");
    if (!this.canvas) {
      throw new Error("Canvas element not found");
    }
    this.initializeUIElements();
    Core.create({
      debug: true,
      enableEntitySystems: true
    });
    this.gameScene = new GameScene(this.canvas);
    Core.setScene(this.gameScene);
    this.bindEvents();
    this.start();
  }
  initializeUIElements() {
    const elementIds = [
      "entityCount",
      "entityCountValue",
      "toggleWorker",
      "toggleSAB",
      "gravity",
      "gravityValue",
      "friction",
      "frictionValue",
      "spawnParticles",
      "clearEntities",
      "resetDemo",
      "fps",
      "entityCountStat",
      "workerStatus",
      "workerLoad",
      "physicsTime",
      "renderTime",
      "frameTime",
      "memoryUsage",
      "sabStatus"
    ];
    for (const id of elementIds) {
      const element = document.getElementById(id);
      if (element) {
        this.elements[id] = element;
      } else {
        console.warn(`Element with id '${id}' not found`);
      }
    }
  }
  bindEvents() {
    if (this.elements.entityCount && this.elements.entityCountValue) {
      const slider = this.elements.entityCount;
      slider.addEventListener("input", () => {
        this.elements.entityCountValue.textContent = slider.value;
      });
      slider.addEventListener("change", () => {
        const count = parseInt(slider.value);
        this.gameScene.spawnInitialEntities(count);
      });
    }
    if (this.elements.toggleWorker) {
      this.elements.toggleWorker.addEventListener("click", () => {
        const workerEnabled = this.gameScene.toggleWorker();
        this.elements.toggleWorker.textContent = workerEnabled ? "禁用 Worker" : "启用 Worker";
        this.updateWorkerStatus();
      });
    }
    if (this.elements.toggleSAB) {
      this.elements.toggleSAB.addEventListener("click", () => {
        this.gameScene.toggleSharedArrayBuffer();
        this.updateWorkerStatus();
      });
    }
    if (this.elements.gravity && this.elements.gravityValue) {
      const slider = this.elements.gravity;
      slider.addEventListener("input", () => {
        this.elements.gravityValue.textContent = slider.value;
      });
      slider.addEventListener("change", () => {
        const gravity = parseInt(slider.value);
        this.gameScene.updateWorkerConfig({ gravity });
      });
    }
    if (this.elements.friction && this.elements.frictionValue) {
      const slider = this.elements.friction;
      slider.addEventListener("input", () => {
        const value = parseInt(slider.value);
        this.elements.frictionValue.textContent = `${value}%`;
      });
      slider.addEventListener("change", () => {
        const friction = parseInt(slider.value) / 100;
        this.gameScene.updateWorkerConfig({ friction });
      });
    }
    if (this.elements.spawnParticles) {
      this.elements.spawnParticles.addEventListener("click", () => {
        const centerX = this.canvas.width / 2;
        const centerY = this.canvas.height / 2;
        this.gameScene.spawnParticleExplosion(centerX, centerY, 100);
      });
    }
    if (this.elements.clearEntities) {
      this.elements.clearEntities.addEventListener("click", () => {
        this.gameScene.clearAllEntities();
      });
    }
    if (this.elements.resetDemo) {
      this.elements.resetDemo.addEventListener("click", () => {
        this.resetDemo();
      });
    }
    this.canvas.addEventListener("click", (event) => {
      const rect = this.canvas.getBoundingClientRect();
      const x = event.clientX - rect.left;
      const y = event.clientY - rect.top;
      this.gameScene.spawnParticleExplosion(x, y, 30);
    });
  }
  start() {
    this.isRunning = true;
    this.lastTime = performance.now();
    this.gameLoop();
    console.log("Worker演示已启动");
  }
  updatePerformanceStats(stats) {
    if (this.elements.fps) {
      this.elements.fps.textContent = stats.fps.toString();
      this.elements.fps.className = stats.fps >= 55 ? "performance-high" : stats.fps >= 30 ? "performance-medium" : "performance-low";
    }
    if (this.elements.frameTime) {
      this.elements.frameTime.textContent = stats.frameTime.toFixed(2);
      this.elements.frameTime.className = stats.frameTime <= 16 ? "performance-high" : stats.frameTime <= 33 ? "performance-medium" : "performance-low";
    }
    if (this.elements.physicsTime) {
      this.elements.physicsTime.textContent = stats.physicsTime.toFixed(2);
      this.elements.physicsTime.className = stats.physicsTime <= 8 ? "performance-high" : stats.physicsTime <= 16 ? "performance-medium" : "performance-low";
    }
    if (this.elements.renderTime) {
      this.elements.renderTime.textContent = stats.renderTime.toFixed(2);
      this.elements.renderTime.className = stats.renderTime <= 8 ? "performance-high" : stats.renderTime <= 16 ? "performance-medium" : "performance-low";
    }
    if (this.elements.memoryUsage) {
      this.elements.memoryUsage.textContent = stats.memoryUsage.toFixed(1);
    }
  }
  updateUI() {
    const currentTime = performance.now();
    const systemInfo = this.gameScene.getSystemInfo();
    if (this.elements.entityCountStat) {
      this.elements.entityCountStat.textContent = systemInfo.entityCount.toString();
    }
    if (currentTime - this.lastWorkerStatusUpdate >= 500) {
      this.updateWorkerStatus();
      this.lastWorkerStatusUpdate = currentTime;
    }
    window.workerInfo = systemInfo.physics;
  }
  updateWorkerStatus() {
    const systemInfo = this.gameScene.getSystemInfo();
    const workerInfo = systemInfo.physics;
    const entityCount = systemInfo.entityCount;
    const status = this.gameScene.getPhysicsSystemStatus();
    if (this.elements.workerStatus) {
      if (workerInfo.enabled) {
        this.elements.workerStatus.textContent = `启用 (${workerInfo.workerCount} Workers)`;
        this.elements.workerStatus.className = "worker-enabled";
      } else {
        this.elements.workerStatus.textContent = "禁用";
        this.elements.workerStatus.className = "worker-disabled";
      }
    }
    if (this.elements.workerLoad) {
      if (workerInfo.enabled && entityCount > 0) {
        const entitiesPerWorker = Math.ceil(entityCount / workerInfo.workerCount);
        this.elements.workerLoad.textContent = `${entitiesPerWorker}/Worker (共${workerInfo.workerCount}个)`;
      } else {
        this.elements.workerLoad.textContent = "N/A";
      }
    }
    if (this.elements.sabStatus) {
      const modeNames = {
        "shared-buffer": "SharedArrayBuffer模式",
        "single-worker": "单Worker模式",
        "multi-worker": "多Worker模式",
        "sync": "同步模式"
      };
      this.elements.sabStatus.textContent = modeNames[status.mode] || status.mode;
      this.elements.sabStatus.className = status.mode === "shared-buffer" ? "worker-enabled" : "worker-disabled";
    }
    if (this.elements.toggleSAB) {
      if (status.sharedArrayBufferEnabled) {
        this.elements.toggleSAB.textContent = "禁用 SharedArrayBuffer";
      } else {
        this.elements.toggleSAB.textContent = "启用 SharedArrayBuffer";
        this.elements.toggleSAB.setAttribute("disabled", "true");
      }
    }
  }
  getMemoryUsage() {
    if ("memory" in performance) {
      const memory = performance.memory;
      return memory.usedJSHeapSize / (1024 * 1024);
    }
    return 0;
  }
  resetDemo() {
    if (this.elements.entityCount) {
      this.elements.entityCount.value = "1000";
      this.elements.entityCountValue.textContent = "1000";
    }
    if (this.elements.gravity) {
      this.elements.gravity.value = "100";
      this.elements.gravityValue.textContent = "100";
    }
    if (this.elements.friction) {
      this.elements.friction.value = "95";
      this.elements.frictionValue.textContent = "95%";
    }
    const workerInfo = this.gameScene.getSystemInfo().physics;
    if (!workerInfo.enabled) {
      this.gameScene.toggleWorker();
    }
    if (this.elements.toggleWorker) {
      this.elements.toggleWorker.textContent = "禁用 Worker";
    }
    this.gameScene.spawnInitialEntities(1e3);
    this.gameScene.updateWorkerConfig({
      gravity: 100,
      friction: 0.95
    });
    console.log("演示已重置");
  }
  stop() {
    this.isRunning = false;
  }
}
document.addEventListener("DOMContentLoaded", () => {
  try {
    new WorkerDemo();
  } catch (error) {
    console.error("启动演示失败:", error);
    document.body.innerHTML = `
            <div style="padding: 20px; color: red;">
                <h1>启动失败</h1>
                <p>错误: ${error}</p>
                <p>请确保浏览器支持Web Workers和Canvas API</p>
            </div>
        `;
  }
});