@esengine/ecs-framework/index.cjs.map

用于Laya、Cocos Creator等JavaScript游戏引擎的高性能ECS框架

{"version":3,"file":"index.cjs","sources":["../../../node_modules/tslib/tslib.es6.mjs","../bin/Utils/Time.js","../bin/Utils/Timers/Timer.js","../bin/Core/DI/Decorators.js","../bin/Utils/PerformanceMonitor.js","../bin/Utils/Timers/TimerManager.js","../bin/Utils/Pool/Pool.js","../bin/Utils/Pool/PoolManager.js","../bin/ECS/Decorators/TypeDecorators.js","../bin/ECS/Core/ReferenceTracker.js","../bin/Utils/Logger/Constants.js","../bin/Utils/Logger/ConsoleLogger.js","../bin/Utils/Logger/LoggerManager.js","../bin/ECS/Decorators/EntityRefDecorator.js","../bin/Utils/Debug/EntityDataCollector.js","../bin/Utils/Debug/SystemDataCollector.js","../bin/Utils/Debug/PerformanceDataCollector.js","../bin/ECS/Core/ComponentPool.js","../bin/Utils/Debug/ComponentDataCollector.js","../bin/Utils/Debug/SceneDataCollector.js","../bin/Utils/Debug/WebSocketManager.js","../bin/ECS/Utils/BigIntCompatibility.js","../bin/ECS/Core/QueryTypes.js","../bin/ECS/Core/SoAStorage.js","../bin/ECS/Core/ComponentStorage/ComponentRegistry.js","../bin/ECS/Core/ComponentStorage.js","../bin/ECS/Entity.js","../bin/ECS/Core/FluentAPI/EntityBuilder.js","../bin/ECS/Utils/EntityList.js","../bin/ECS/Utils/IdentifierPool.js","../bin/ECS/Utils/Matcher.js","../bin/ECS/Systems/EntityCache.js","../bin/ECS/Systems/EntitySystem.js","../bin/ECS/Utils/EntityProcessorList.js","../bin/ECS/Utils/Bits.js","../bin/ECS/Utils/SparseSet.js","../bin/ECS/Utils/ComponentSparseSet.js","../bin/ECS/Utils/BitMaskHashMap.js","../bin/ECS/Core/ArchetypeSystem.js","../bin/ECS/Core/ReactiveQuery.js","../bin/ECS/Core/QuerySystem.js","../bin/ECS/Core/EventSystem.js","../bin/ECS/Core/Query/TypedQuery.js","../bin/ECS/Serialization/SerializationDecorators.js","../bin/ECS/Serialization/ComponentSerializer.js","../bin/ECS/Serialization/EntitySerializer.js","../bin/Utils/BinarySerializer.js","../bin/ECS/Serialization/SceneSerializer.js","../bin/ECS/Serialization/IncrementalSerializer.js","../bin/Core/ServiceContainer.js","../bin/ECS/Scene.js","../bin/ECS/Core/FluentAPI/SceneBuilder.js","../bin/ECS/Core/FluentAPI/ComponentBuilder.js","../bin/ECS/Core/FluentAPI/EntityBatchOperator.js","../bin/ECS/Core/FluentAPI/ECSFluentAPI.js","../bin/ECS/World.js","../bin/ECS/SceneManager.js","../bin/Core/Plugin.js","../bin/Utils/Debug/DebugConfigService.js","../bin/Utils/Debug/DebugManager.js","../bin/Core/PluginManager.js","../bin/ECS/WorldManager.js","../bin/Core.js","../bin/Plugins/DebugPlugin.js","../bin/Utils/Emitter.js","../bin/ECS/Component.js","../bin/ECS/CoreEvents.js","../bin/Platform/PlatformManager.js","../bin/ECS/Systems/WorkerEntitySystem.js","../bin/ECS/Core/EventBus.js","../bin/ECS/Serialization/VersionMigration.js","../bin/ECS/TypedEntity.js","../bin/Types/TypeHelpers.js","../bin/Utils/GlobalManager.js","../bin/ECS/Systems/IntervalSystem.js","../bin/Utils/Extensions/NumberExtension.js","../bin/ECS/Systems/PassiveSystem.js","../bin/Platform/PlatformDetector.js","../bin/ECS/Systems/ProcessingSystem.js","../bin/Utils/Extensions/TypeUtils.js","../bin/Platform/index.js"],"sourcesContent":["/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n  return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nvar ownKeys = function(o) {\n  ownKeys = Object.getOwnPropertyNames || function (o) {\n    var ar = [];\n    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n    return ar;\n  };\n  return ownKeys(o);\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  var r, s = 0;\n  function next() {\n    while (r = env.stack.pop()) {\n      try {\n        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n        if (r.dispose) {\n          var result = r.dispose.call(r.value);\n          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n        }\n        else s |= 1;\n      }\n      catch (e) {\n        fail(e);\n      }\n    }\n    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n  if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n      return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n          return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n      });\n  }\n  return path;\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __esDecorate,\n  __runInitializers,\n  __propKey,\n  __setFunctionName,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n  __rewriteRelativeImportExtension,\n};\n","/**\n * 时间管理工具类\n * 提供游戏时间相关的功能，包括帧时间、总时间、时间缩放等\n */\nexport class Time {\n    /**\n     * 使用外部引擎提供的deltaTime更新时间信息\n     * @param deltaTime 外部引擎提供的帧时间间隔（秒）\n     */\n    static update(deltaTime) {\n        // 设置未缩放的帧时间\n        this.unscaledDeltaTime = deltaTime;\n        this.deltaTime = deltaTime * this.timeScale;\n        // 更新总时间\n        this.unscaledTotalTime += this.unscaledDeltaTime;\n        this.totalTime += this.deltaTime;\n        // 更新帧数\n        this.frameCount++;\n    }\n    /**\n     * 场景改变时重置时间\n     */\n    static sceneChanged() {\n        this.frameCount = 0;\n        this.totalTime = 0;\n        this.unscaledTotalTime = 0;\n        this.deltaTime = 0;\n        this.unscaledDeltaTime = 0;\n    }\n    /**\n     * 检查指定的时间间隔是否已经过去\n     * @param interval 时间间隔（秒）\n     * @param lastTime 上次检查的时间\n     * @returns 是否已经过去指定时间\n     */\n    static checkEvery(interval, lastTime) {\n        return this.totalTime - lastTime >= interval;\n    }\n}\n/**\n * 上一帧到当前帧的时间间隔（秒）\n */\nTime.deltaTime = 0;\n/**\n * 未缩放的帧时间间隔（秒）\n */\nTime.unscaledDeltaTime = 0;\n/**\n * 游戏开始以来的总时间（秒）\n */\nTime.totalTime = 0;\n/**\n * 未缩放的总时间（秒）\n */\nTime.unscaledTotalTime = 0;\n/**\n * 时间缩放比例\n */\nTime.timeScale = 1;\n/**\n * 当前帧数\n */\nTime.frameCount = 0;\n//# sourceMappingURL=Time.js.map","import { Time } from '../Time';\n/**\n * 私有类隐藏ITimer的实现\n */\nexport class Timer {\n    constructor() {\n        this._timeInSeconds = 0;\n        this._repeats = false;\n        this._isDone = false;\n        this._elapsedTime = 0;\n    }\n    getContext() {\n        return this.context;\n    }\n    /**\n     * 定时器是否已完成\n     */\n    get isDone() {\n        return this._isDone;\n    }\n    /**\n     * 定时器已运行的时间\n     */\n    get elapsedTime() {\n        return this._elapsedTime;\n    }\n    reset() {\n        this._elapsedTime = 0;\n    }\n    stop() {\n        this._isDone = true;\n    }\n    tick() {\n        // 如果stop在tick之前被调用，那么isDone将为true，我们不应该再做任何事情\n        if (!this._isDone && this._elapsedTime > this._timeInSeconds) {\n            this._elapsedTime -= this._timeInSeconds;\n            this._onTime(this);\n            if (!this._isDone && !this._repeats)\n                this._isDone = true;\n        }\n        this._elapsedTime += Time.deltaTime;\n        return this._isDone;\n    }\n    initialize(timeInsSeconds, repeats, context, onTime) {\n        this._timeInSeconds = timeInsSeconds;\n        this._repeats = repeats;\n        this.context = context;\n        this._onTime = onTime.bind(context);\n    }\n    /**\n     * 空出对象引用，以便在js需要时GC可以清理它们的引用\n     */\n    unload() {\n        this.context = null;\n        this._onTime = null;\n    }\n}\n//# sourceMappingURL=Timer.js.map","/**\n * 依赖注入装饰器\n *\n * 提供 @Injectable、@Inject 和 @Updatable 装饰器，用于标记可注入的类和依赖注入点\n */\nconst injectableMetadata = new WeakMap();\nconst injectMetadata = new WeakMap();\nconst updatableMetadata = new WeakMap();\n/**\n * @Injectable() 装饰器\n *\n * 标记类为可注入的服务，使其可以通过ServiceContainer进行依赖注入\n *\n * @example\n * ```typescript\n * @Injectable()\n * class TimeService implements IService {\n *     constructor() {}\n *     dispose() {}\n * }\n *\n * @Injectable()\n * class PhysicsSystem extends EntitySystem {\n *     constructor(\n *         @Inject(TimeService) private timeService: TimeService\n *     ) {\n *         super();\n *     }\n * }\n * ```\n */\nexport function Injectable() {\n    return function (target) {\n        const existing = injectableMetadata.get(target);\n        injectableMetadata.set(target, {\n            injectable: true,\n            dependencies: [],\n            ...(existing?.properties && { properties: existing.properties })\n        });\n    };\n}\n/**\n * @Updatable() 装饰器\n *\n * 标记服务类为可更新的，使其在每帧自动被ServiceContainer调用update方法。\n * 使用此装饰器的类必须实现IUpdatable接口（包含update方法）。\n *\n * @param priority - 更新优先级（数值越小越先执行，默认0）\n * @throws 如果类没有实现update方法，将在运行时抛出错误\n *\n * @example\n * ```typescript\n * @Injectable()\n * @Updatable()\n * class TimerManager implements IService, IUpdatable {\n *     update(deltaTime?: number) {\n *         // 每帧更新逻辑\n *     }\n *     dispose() {}\n * }\n *\n * // 指定优先级\n * @Injectable()\n * @Updatable(10)\n * class PhysicsManager implements IService, IUpdatable {\n *     update() { }\n *     dispose() {}\n * }\n * ```\n */\nexport function Updatable(priority = 0) {\n    return function (target) {\n        // 验证类原型上是否有update方法\n        const prototype = target.prototype;\n        if (!prototype || typeof prototype.update !== 'function') {\n            throw new Error(`@Updatable() decorator requires class ${target.name} to implement IUpdatable interface with update() method. ` +\n                'Please add \\'implements IUpdatable\\' and define update(deltaTime?: number): void method.');\n        }\n        // 标记为可更新\n        updatableMetadata.set(target, {\n            updatable: true,\n            priority\n        });\n    };\n}\n/**\n * @Inject() 装饰器\n *\n * 标记构造函数参数需要注入的服务类型\n *\n * @param serviceType 服务类型标识符\n */\nexport function Inject(serviceType) {\n    return function (target, _propertyKey, parameterIndex) {\n        // 获取或创建注入元数据\n        let params = injectMetadata.get(target);\n        if (!params) {\n            params = new Map();\n            injectMetadata.set(target, params);\n        }\n        // 记录参数索引和服务类型的映射\n        params.set(parameterIndex, serviceType);\n    };\n}\n/**\n * @InjectProperty() 装饰器\n *\n * 通过属性装饰器注入依赖\n *\n * 注入时机：在构造函数执行后、onInitialize() 调用前完成\n *\n * @param serviceType 服务类型\n */\nexport function InjectProperty(serviceType) {\n    return function (target, propertyKey) {\n        let metadata = injectableMetadata.get(target.constructor);\n        if (!metadata) {\n            metadata = {\n                injectable: true,\n                dependencies: []\n            };\n            injectableMetadata.set(target.constructor, metadata);\n        }\n        if (!metadata.properties) {\n            metadata.properties = new Map();\n        }\n        metadata.properties.set(propertyKey, serviceType);\n    };\n}\n/**\n * 检查类是否标记为可注入\n *\n * @param target 目标类\n * @returns 是否可注入\n */\nexport function isInjectable(target) {\n    const metadata = injectableMetadata.get(target);\n    return metadata?.injectable ?? false;\n}\n/**\n * 获取类的依赖注入元数据\n *\n * @param target 目标类\n * @returns 依赖注入元数据\n */\nexport function getInjectableMetadata(target) {\n    return injectableMetadata.get(target);\n}\n/**\n * 获取构造函数参数的注入元数据\n *\n * @param target 目标类\n * @returns 参数索引到服务类型的映射\n */\nexport function getInjectMetadata(target) {\n    return injectMetadata.get(target) || new Map();\n}\n/**\n * 创建实例并自动注入依赖\n *\n * @param constructor 构造函数\n * @param container 服务容器\n * @returns 创建的实例\n *\n * @example\n * ```typescript\n * const instance = createInstance(MySystem, container);\n * ```\n */\nexport function createInstance(constructor, container) {\n    // 获取参数注入元数据\n    const injectParams = getInjectMetadata(constructor);\n    // 解析依赖\n    const dependencies = [];\n    // 获取构造函数参数数量\n    const paramCount = constructor.length;\n    for (let i = 0; i < paramCount; i++) {\n        const serviceType = injectParams.get(i);\n        if (serviceType) {\n            // 如果有显式的@Inject标记，使用标记的类型\n            if (typeof serviceType === 'string' || typeof serviceType === 'symbol') {\n                // 字符串或Symbol类型的服务标识\n                throw new Error('String and Symbol service identifiers are not yet supported in constructor injection. ' +\n                    `Please use class types for ${constructor.name} parameter ${i}`);\n            }\n            else {\n                // 类类型\n                dependencies.push(container.resolve(serviceType));\n            }\n        }\n        else {\n            // 没有@Inject标记，传入undefined\n            dependencies.push(undefined);\n        }\n    }\n    // 创建实例\n    return new constructor(...dependencies);\n}\n/**\n * 为实例注入属性依赖\n *\n * @param instance 目标实例\n * @param container 服务容器\n */\nexport function injectProperties(instance, container) {\n    const constructor = instance.constructor;\n    const metadata = getInjectableMetadata(constructor);\n    if (!metadata?.properties || metadata.properties.size === 0) {\n        return;\n    }\n    for (const [propertyKey, serviceType] of metadata.properties) {\n        const service = container.resolve(serviceType);\n        if (service !== null) {\n            instance[propertyKey] = service;\n        }\n    }\n}\n/**\n * 检查类是否标记为可更新\n *\n * @param target 目标类\n * @returns 是否可更新\n */\nexport function isUpdatable(target) {\n    const metadata = updatableMetadata.get(target);\n    return metadata?.updatable ?? false;\n}\n/**\n * 获取类的可更新元数据\n *\n * @param target 目标类\n * @returns 可更新元数据\n */\nexport function getUpdatableMetadata(target) {\n    return updatableMetadata.get(target);\n}\n/**\n * 注册可注入的服务到容器\n *\n * 自动检测@Injectable装饰器并注册服务\n *\n * @param container 服务容器\n * @param serviceType 服务类型\n * @param singleton 是否注册为单例（默认true）\n *\n * @example\n * ```typescript\n * @Injectable()\n * class MyService implements IService {\n *     dispose() {}\n * }\n *\n * // 自动注册\n * registerInjectable(Core.services, MyService);\n * ```\n */\nexport function registerInjectable(container, serviceType, singleton = true) {\n    if (!isInjectable(serviceType)) {\n        throw new Error(`${serviceType.name} is not marked as @Injectable(). ` +\n            'Please add @Injectable() decorator to the class.');\n    }\n    // 创建工厂函数，使用createInstance自动解析依赖\n    const factory = (c) => createInstance(serviceType, c);\n    // 注册到容器\n    if (singleton) {\n        container.registerSingleton(serviceType, factory);\n    }\n    else {\n        container.registerTransient(serviceType, factory);\n    }\n}\n//# sourceMappingURL=Decorators.js.map","/**\n * 性能警告类型\n */\nexport var PerformanceWarningType;\n(function (PerformanceWarningType) {\n    PerformanceWarningType[\"HIGH_EXECUTION_TIME\"] = \"high_execution_time\";\n    PerformanceWarningType[\"HIGH_MEMORY_USAGE\"] = \"high_memory_usage\";\n    PerformanceWarningType[\"HIGH_CPU_USAGE\"] = \"high_cpu_usage\";\n    PerformanceWarningType[\"FREQUENT_GC\"] = \"frequent_gc\";\n    PerformanceWarningType[\"LOW_FPS\"] = \"low_fps\";\n    PerformanceWarningType[\"HIGH_ENTITY_COUNT\"] = \"high_entity_count\";\n})(PerformanceWarningType || (PerformanceWarningType = {}));\n/**\n * 高性能监控器\n * 用于监控ECS系统的性能表现，提供详细的分析和优化建议\n */\nexport class PerformanceMonitor {\n    constructor() {\n        this._systemData = new Map();\n        this._systemStats = new Map();\n        this._isEnabled = false;\n        this._maxRecentSamples = 60; // 保留最近60帧的数据\n    }\n    /**\n     * 启用性能监控\n     */\n    enable() {\n        this._isEnabled = true;\n    }\n    /**\n     * 禁用性能监控\n     */\n    disable() {\n        this._isEnabled = false;\n    }\n    /**\n     * 检查是否启用了性能监控\n     */\n    get isEnabled() {\n        return this._isEnabled;\n    }\n    /**\n     * 开始监控系统性能\n     * @param systemName 系统名称\n     * @returns 开始时间戳\n     */\n    startMonitoring(_systemName) {\n        if (!this._isEnabled) {\n            return 0;\n        }\n        return performance.now();\n    }\n    /**\n     * 结束监控并记录性能数据\n     * @param systemName 系统名称\n     * @param startTime 开始时间戳\n     * @param entityCount 处理的实体数量\n     */\n    endMonitoring(systemName, startTime, entityCount = 0) {\n        if (!this._isEnabled || startTime === 0) {\n            return;\n        }\n        const endTime = performance.now();\n        const executionTime = endTime - startTime;\n        const averageTimePerEntity = entityCount > 0 ? executionTime / entityCount : 0;\n        // 更新当前性能数据\n        const data = {\n            name: systemName,\n            executionTime,\n            entityCount,\n            averageTimePerEntity,\n            lastUpdateTime: endTime\n        };\n        this._systemData.set(systemName, data);\n        // 更新统计信息\n        this.updateStats(systemName, executionTime);\n    }\n    /**\n     * 更新系统统计信息\n     * @param systemName 系统名称\n     * @param executionTime 执行时间\n     */\n    updateStats(systemName, executionTime) {\n        let stats = this._systemStats.get(systemName);\n        if (!stats) {\n            stats = {\n                totalTime: 0,\n                averageTime: 0,\n                minTime: Number.MAX_VALUE,\n                maxTime: 0,\n                executionCount: 0,\n                recentTimes: [],\n                standardDeviation: 0,\n                percentile95: 0,\n                percentile99: 0\n            };\n            this._systemStats.set(systemName, stats);\n        }\n        // 更新基本统计\n        stats.totalTime += executionTime;\n        stats.executionCount++;\n        stats.averageTime = stats.totalTime / stats.executionCount;\n        stats.minTime = Math.min(stats.minTime, executionTime);\n        stats.maxTime = Math.max(stats.maxTime, executionTime);\n        // 更新最近时间列表\n        stats.recentTimes.push(executionTime);\n        if (stats.recentTimes.length > this._maxRecentSamples) {\n            stats.recentTimes.shift();\n        }\n        // 计算高级统计信息\n        this.calculateAdvancedStats(stats);\n    }\n    /**\n     * 计算高级统计信息\n     * @param stats 统计信息对象\n     */\n    calculateAdvancedStats(stats) {\n        if (stats.recentTimes.length === 0)\n            return;\n        // 计算标准差\n        const mean = stats.recentTimes.reduce((a, b) => a + b, 0) / stats.recentTimes.length;\n        const variance = stats.recentTimes.reduce((acc, time) => acc + Math.pow(time - mean, 2), 0) / stats.recentTimes.length;\n        stats.standardDeviation = Math.sqrt(variance);\n        // 计算百分位数\n        const sortedTimes = [...stats.recentTimes].sort((a, b) => a - b);\n        const len = sortedTimes.length;\n        stats.percentile95 = sortedTimes[Math.floor(len * 0.95)] || 0;\n        stats.percentile99 = sortedTimes[Math.floor(len * 0.99)] || 0;\n    }\n    /**\n     * 获取系统的当前性能数据\n     * @param systemName 系统名称\n     * @returns 性能数据或undefined\n     */\n    getSystemData(systemName) {\n        return this._systemData.get(systemName);\n    }\n    /**\n     * 获取系统的统计信息\n     * @param systemName 系统名称\n     * @returns 统计信息或undefined\n     */\n    getSystemStats(systemName) {\n        return this._systemStats.get(systemName);\n    }\n    /**\n     * 获取所有系统的性能数据\n     * @returns 所有系统的性能数据\n     */\n    getAllSystemData() {\n        return new Map(this._systemData);\n    }\n    /**\n     * 获取所有系统的统计信息\n     * @returns 所有系统的统计信息\n     */\n    getAllSystemStats() {\n        return new Map(this._systemStats);\n    }\n    /**\n     * 获取性能报告\n     * @returns 格式化的性能报告字符串\n     */\n    getPerformanceReport() {\n        if (!this._isEnabled) {\n            return 'Performance monitoring is disabled.';\n        }\n        const lines = [];\n        lines.push('=== ECS Performance Report ===');\n        lines.push('');\n        // 按平均执行时间排序\n        const sortedSystems = Array.from(this._systemStats.entries())\n            .sort((a, b) => b[1].averageTime - a[1].averageTime);\n        for (const [systemName, stats] of sortedSystems) {\n            const data = this._systemData.get(systemName);\n            lines.push(`System: ${systemName}`);\n            lines.push(`  Current: ${data?.executionTime.toFixed(2)}ms (${data?.entityCount} entities)`);\n            lines.push(`  Average: ${stats.averageTime.toFixed(2)}ms`);\n            lines.push(`  Min/Max: ${stats.minTime.toFixed(2)}ms / ${stats.maxTime.toFixed(2)}ms`);\n            lines.push(`  Total: ${stats.totalTime.toFixed(2)}ms (${stats.executionCount} calls)`);\n            if (data?.averageTimePerEntity && data.averageTimePerEntity > 0) {\n                lines.push(`  Per Entity: ${data.averageTimePerEntity.toFixed(4)}ms`);\n            }\n            lines.push('');\n        }\n        // 总体统计\n        const totalCurrentTime = Array.from(this._systemData.values())\n            .reduce((sum, data) => sum + data.executionTime, 0);\n        lines.push(`Total Frame Time: ${totalCurrentTime.toFixed(2)}ms`);\n        lines.push(`Systems Count: ${this._systemData.size}`);\n        return lines.join('\\n');\n    }\n    /**\n     * 重置所有性能数据\n     */\n    reset() {\n        this._systemData.clear();\n        this._systemStats.clear();\n    }\n    /**\n     * 重置指定系统的性能数据\n     * @param systemName 系统名称\n     */\n    resetSystem(systemName) {\n        this._systemData.delete(systemName);\n        this._systemStats.delete(systemName);\n    }\n    /**\n     * 获取性能警告\n     * @param thresholdMs 警告阈值（毫秒）\n     * @returns 超过阈值的系统列表\n     */\n    getPerformanceWarnings(thresholdMs = 16.67) {\n        const warnings = [];\n        for (const [systemName, data] of this._systemData.entries()) {\n            if (data.executionTime > thresholdMs) {\n                warnings.push(`${systemName}: ${data.executionTime.toFixed(2)}ms (>${thresholdMs}ms)`);\n            }\n        }\n        return warnings;\n    }\n    /**\n     * 设置最大保留样本数\n     * @param maxSamples 最大样本数\n     */\n    setMaxRecentSamples(maxSamples) {\n        this._maxRecentSamples = maxSamples;\n        // 裁剪现有数据\n        for (const stats of this._systemStats.values()) {\n            while (stats.recentTimes.length > maxSamples) {\n                stats.recentTimes.shift();\n            }\n        }\n    }\n    /**\n     * 释放资源\n     */\n    dispose() {\n        this._systemData.clear();\n        this._systemStats.clear();\n        this._isEnabled = false;\n    }\n}\n//# sourceMappingURL=PerformanceMonitor.js.map","import { __decorate } from \"tslib\";\nimport { Timer } from './Timer';\nimport { Updatable } from '../../Core/DI';\n/**\n * 定时器管理器\n *\n * 允许动作的延迟和重复执行\n */\nlet TimerManager = class TimerManager {\n    constructor() {\n        this._timers = [];\n    }\n    update() {\n        for (let i = this._timers.length - 1; i >= 0; i--) {\n            if (this._timers[i].tick()) {\n                this._timers[i].unload();\n                this._timers.splice(i, 1);\n            }\n        }\n    }\n    /**\n     * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作\n     * @param timeInSeconds\n     * @param repeats\n     * @param context\n     * @param onTime\n     */\n    schedule(timeInSeconds, repeats, context, onTime) {\n        const timer = new Timer();\n        timer.initialize(timeInSeconds, repeats, context, onTime);\n        this._timers.push(timer);\n        return timer;\n    }\n    /**\n     * 释放资源\n     */\n    dispose() {\n        for (const timer of this._timers) {\n            timer.unload();\n        }\n        this._timers = [];\n    }\n};\nTimerManager = __decorate([\n    Updatable()\n], TimerManager);\nexport { TimerManager };\n//# sourceMappingURL=TimerManager.js.map","/**\n * 高性能通用对象池\n * 支持任意类型的对象池化，包含详细的统计信息\n */\nexport class Pool {\n    /**\n     * 构造函数\n     * @param createFn 创建对象的函数\n     * @param maxSize 池的最大大小，默认100\n     * @param estimatedObjectSize 估算的单个对象大小（字节），默认1024\n     */\n    constructor(createFn, maxSize = 100, estimatedObjectSize = 1024) {\n        this._objects = [];\n        this._createFn = createFn;\n        this._maxSize = maxSize;\n        this._objectSize = estimatedObjectSize;\n        this._stats = {\n            size: 0,\n            maxSize,\n            totalCreated: 0,\n            totalObtained: 0,\n            totalReleased: 0,\n            hitRate: 0,\n            estimatedMemoryUsage: 0\n        };\n    }\n    /**\n     * 获取指定类型的对象池\n     * @param type 对象类型\n     * @param maxSize 池的最大大小\n     * @param estimatedObjectSize 估算的单个对象大小\n     * @returns 对象池实例\n     */\n    static getPool(type, maxSize = 100, estimatedObjectSize = 1024) {\n        let pool = this._pools.get(type);\n        if (!pool) {\n            pool = new Pool(() => new type(), maxSize, estimatedObjectSize);\n            this._pools.set(type, pool);\n        }\n        return pool;\n    }\n    /**\n     * 从池中获取对象\n     * @returns 对象实例\n     */\n    obtain() {\n        this._stats.totalObtained++;\n        if (this._objects.length > 0) {\n            const obj = this._objects.pop();\n            this._stats.size--;\n            this._updateHitRate();\n            this._updateMemoryUsage();\n            return obj;\n        }\n        // 池中没有可用对象，创建新对象\n        this._stats.totalCreated++;\n        this._updateHitRate();\n        return this._createFn();\n    }\n    /**\n     * 释放对象回池中\n     * @param obj 要释放的对象\n     */\n    release(obj) {\n        if (!obj)\n            return;\n        this._stats.totalReleased++;\n        // 如果池未满，将对象放回池中\n        if (this._stats.size < this._maxSize) {\n            // 重置对象状态\n            obj.reset();\n            this._objects.push(obj);\n            this._stats.size++;\n            this._updateMemoryUsage();\n        }\n        // 如果池已满，让对象被垃圾回收\n    }\n    /**\n     * 获取池统计信息\n     * @returns 统计信息对象\n     */\n    getStats() {\n        return { ...this._stats };\n    }\n    /**\n     * 清空池\n     */\n    clear() {\n        // 重置所有对象\n        for (const obj of this._objects) {\n            obj.reset();\n        }\n        this._objects.length = 0;\n        this._stats.size = 0;\n        this._updateMemoryUsage();\n    }\n    /**\n     * 压缩池（移除多余的对象）\n     * @param targetSize 目标大小，默认为当前大小的一半\n     */\n    compact(targetSize) {\n        const target = targetSize ?? Math.floor(this._objects.length / 2);\n        while (this._objects.length > target) {\n            const obj = this._objects.pop();\n            if (obj) {\n                obj.reset();\n                this._stats.size--;\n            }\n        }\n        this._updateMemoryUsage();\n    }\n    /**\n     * 预填充池\n     * @param count 预填充的对象数量\n     */\n    prewarm(count) {\n        const actualCount = Math.min(count, this._maxSize - this._objects.length);\n        for (let i = 0; i < actualCount; i++) {\n            const obj = this._createFn();\n            obj.reset();\n            this._objects.push(obj);\n            this._stats.totalCreated++;\n            this._stats.size++;\n        }\n        this._updateMemoryUsage();\n    }\n    /**\n     * 设置最大池大小\n     * @param maxSize 新的最大大小\n     */\n    setMaxSize(maxSize) {\n        this._maxSize = maxSize;\n        this._stats.maxSize = maxSize;\n        // 如果当前池大小超过新的最大值，进行压缩\n        if (this._objects.length > maxSize) {\n            this.compact(maxSize);\n        }\n    }\n    /**\n     * 获取池中可用对象数量\n     * @returns 可用对象数量\n     */\n    getAvailableCount() {\n        return this._objects.length;\n    }\n    /**\n     * 检查池是否为空\n     * @returns 如果池为空返回true\n     */\n    isEmpty() {\n        return this._objects.length === 0;\n    }\n    /**\n     * 检查池是否已满\n     * @returns 如果池已满返回true\n     */\n    isFull() {\n        return this._objects.length >= this._maxSize;\n    }\n    /**\n     * 获取所有已注册的池类型\n     * @returns 所有池类型的数组\n     */\n    static getAllPoolTypes() {\n        return Array.from(this._pools.keys());\n    }\n    /**\n     * 获取所有池的统计信息\n     * @returns 包含所有池统计信息的对象\n     */\n    static getAllPoolStats() {\n        const stats = {};\n        for (const [type, pool] of this._pools) {\n            const typeName = type.name || type.toString();\n            stats[typeName] = pool.getStats();\n        }\n        return stats;\n    }\n    /**\n     * 压缩所有池\n     */\n    static compactAllPools() {\n        for (const pool of this._pools.values()) {\n            pool.compact();\n        }\n    }\n    /**\n     * 清空所有池\n     */\n    static clearAllPools() {\n        for (const pool of this._pools.values()) {\n            pool.clear();\n        }\n        this._pools.clear();\n    }\n    /**\n     * 获取全局池统计信息的格式化字符串\n     * @returns 格式化的统计信息字符串\n     */\n    static getGlobalStatsString() {\n        const stats = this.getAllPoolStats();\n        const lines = ['=== Object Pool Global Statistics ===', ''];\n        if (Object.keys(stats).length === 0) {\n            lines.push('No pools registered');\n            return lines.join('\\n');\n        }\n        for (const [typeName, stat] of Object.entries(stats)) {\n            lines.push(`${typeName}:`);\n            lines.push(`  Size: ${stat.size}/${stat.maxSize}`);\n            lines.push(`  Hit Rate: ${(stat.hitRate * 100).toFixed(1)}%`);\n            lines.push(`  Total Created: ${stat.totalCreated}`);\n            lines.push(`  Total Obtained: ${stat.totalObtained}`);\n            lines.push(`  Memory: ${(stat.estimatedMemoryUsage / 1024).toFixed(1)} KB`);\n            lines.push('');\n        }\n        return lines.join('\\n');\n    }\n    /**\n     * 更新命中率\n     */\n    _updateHitRate() {\n        if (this._stats.totalObtained === 0) {\n            this._stats.hitRate = 0;\n        }\n        else {\n            const hits = this._stats.totalObtained - this._stats.totalCreated;\n            this._stats.hitRate = hits / this._stats.totalObtained;\n        }\n    }\n    /**\n     * 更新内存使用估算\n     */\n    _updateMemoryUsage() {\n        this._stats.estimatedMemoryUsage = this._stats.size * this._objectSize;\n    }\n}\nPool._pools = new Map();\n//# sourceMappingURL=Pool.js.map","import { Pool } from './Pool';\n/**\n * 池管理器\n * 统一管理所有对象池\n */\nexport class PoolManager {\n    constructor() {\n        this.pools = new Map();\n        this.autoCompactInterval = 60000; // 60秒\n        this.lastCompactTime = 0;\n        // 普通构造函数，不再使用单例模式\n    }\n    /**\n     * 注册池\n     * @param name 池名称\n     * @param pool 池实例\n     */\n    registerPool(name, pool) {\n        this.pools.set(name, pool);\n    }\n    /**\n     * 获取池\n     * @param name 池名称\n     * @returns 池实例\n     */\n    getPool(name) {\n        return this.pools.get(name) || null;\n    }\n    /**\n     * 更新池管理器（应在游戏循环中调用）\n     */\n    update() {\n        const now = Date.now();\n        if (now - this.lastCompactTime > this.autoCompactInterval) {\n            this.compactAllPools();\n            this.lastCompactTime = now;\n        }\n    }\n    /**\n     * 创建或获取标准池\n     * @param name 池名称\n     * @param createFn 创建函数\n     * @param maxSize 最大大小\n     * @param estimatedObjectSize 估算对象大小\n     * @returns 池实例\n     */\n    createPool(name, createFn, maxSize = 100, estimatedObjectSize = 1024) {\n        let pool = this.pools.get(name);\n        if (!pool) {\n            pool = new Pool(createFn, maxSize, estimatedObjectSize);\n            this.pools.set(name, pool);\n        }\n        return pool;\n    }\n    /**\n     * 移除池\n     * @param name 池名称\n     * @returns 是否成功移除\n     */\n    removePool(name) {\n        const pool = this.pools.get(name);\n        if (pool) {\n            pool.clear();\n            this.pools.delete(name);\n            return true;\n        }\n        return false;\n    }\n    /**\n     * 获取所有池名称\n     * @returns 池名称数组\n     */\n    getPoolNames() {\n        return Array.from(this.pools.keys());\n    }\n    /**\n     * 获取池数量\n     * @returns 池数量\n     */\n    getPoolCount() {\n        return this.pools.size;\n    }\n    /**\n     * 压缩所有池\n     */\n    compactAllPools() {\n        for (const pool of this.pools.values()) {\n            pool.compact();\n        }\n    }\n    /**\n     * 清空所有池\n     */\n    clearAllPools() {\n        for (const pool of this.pools.values()) {\n            pool.clear();\n        }\n    }\n    /**\n     * 获取所有池的统计信息\n     * @returns 统计信息映射\n     */\n    getAllStats() {\n        const stats = new Map();\n        for (const [name, pool] of this.pools) {\n            stats.set(name, pool.getStats());\n        }\n        return stats;\n    }\n    /**\n     * 获取总体统计信息\n     * @returns 总体统计信息\n     */\n    getGlobalStats() {\n        let totalSize = 0;\n        let totalMaxSize = 0;\n        let totalCreated = 0;\n        let totalObtained = 0;\n        let totalReleased = 0;\n        let totalMemoryUsage = 0;\n        for (const pool of this.pools.values()) {\n            const stats = pool.getStats();\n            totalSize += stats.size;\n            totalMaxSize += stats.maxSize;\n            totalCreated += stats.totalCreated;\n            totalObtained += stats.totalObtained;\n            totalReleased += stats.totalReleased;\n            totalMemoryUsage += stats.estimatedMemoryUsage;\n        }\n        const hitRate = totalObtained === 0 ? 0 : (totalObtained - totalCreated) / totalObtained;\n        return {\n            size: totalSize,\n            maxSize: totalMaxSize,\n            totalCreated,\n            totalObtained,\n            totalReleased,\n            hitRate,\n            estimatedMemoryUsage: totalMemoryUsage\n        };\n    }\n    /**\n     * 获取格式化的统计信息字符串\n     * @returns 格式化字符串\n     */\n    getStatsString() {\n        const lines = ['=== Pool Manager Statistics ===', ''];\n        if (this.pools.size === 0) {\n            lines.push('No pools r