@draug/engine 1.0.21 → 1.0.23

package/dist/chunk-SWTBVK53.js

@@ -0,0 +1,1256 @@
+var __defProp = Object.defineProperty;
+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 = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/ecs/components/utils.ts
+var registry = /* @__PURE__ */ new Map();
+var id = 0;
+var ComponentMetadataSymbol = /* @__PURE__ */ Symbol("component");
+function Component(options) {
+  return (target) => {
+    const metadata = {
+      name: options.name,
+      id: ++id
+    };
+    registry.set(target, metadata.id);
+    target[ComponentMetadataSymbol] = metadata;
+  };
+}
+function getComponentId(ctor) {
+  const id2 = registry.get(ctor);
+  if (id2 === void 0) {
+    throw new Error(`Component not registered: ${ctor.name}`);
+  }
+  return id2;
+}
+var ErrNotComponent = class extends Error {
+  constructor(ctor) {
+    super(`Class ${ctor.name} is not a Component. Use @Component decorator to define components.`);
+  }
+};
+function getComponentMetadata(component) {
+  if (isComponent(component)) {
+    return component[ComponentMetadataSymbol];
+  }
+  throw new ErrNotComponent(component);
+}
+function isComponent(ctor) {
+  return ComponentMetadataSymbol in ctor;
+}
+
+// src/core/graph/dag.ts
+var VisitedState = /* @__PURE__ */ ((VisitedState2) => {
+  VisitedState2[VisitedState2["Unvisited"] = 0] = "Unvisited";
+  VisitedState2[VisitedState2["Visiting"] = 1] = "Visiting";
+  VisitedState2[VisitedState2["Visited"] = 2] = "Visited";
+  return VisitedState2;
+})(VisitedState || {});
+var DAGNode = class {
+  data;
+  vertices = [];
+  constructor(data, vertices) {
+    this.data = data;
+    if (vertices)
+      this.vertices = vertices;
+  }
+};
+var ErrDAGCycleDetected = class extends Error {
+  constructor() {
+    super(`Cycle detected!`);
+  }
+};
+function topologicalSort(nodes) {
+  const visited = /* @__PURE__ */ new Map();
+  const result = [];
+  const dfs = (node) => {
+    const state = visited.get(node) ?? 0 /* Unvisited */;
+    if (state === 2 /* Visited */) return;
+    if (state === 1 /* Visiting */) {
+      throw new ErrDAGCycleDetected();
+    }
+    visited.set(node, 1 /* Visiting */);
+    for (const child of node.vertices) {
+      dfs(child);
+    }
+    visited.set(node, 2 /* Visited */);
+    result.push(node);
+  };
+  for (const node of nodes) {
+    dfs(node);
+  }
+  return result.reverse();
+}
+
+// src/ecs/system.ts
+var SystemError = class extends Error {
+  constructor(target) {
+    super(`[System Error] (System "${target.name}".`);
+  }
+};
+var ErrNotASystem = class extends Error {
+  constructor(target) {
+    super(`Provided class "${target.name}" is not a System! Extend your class from SystemBase.`);
+  }
+};
+var ErrMissingSystemMetadata = class extends SystemError {
+  constructor(target) {
+    super(target);
+    this.message = `${this.message}: Missing system metadata! Define system class with @System decorator.`;
+  }
+};
+var SystemPhase = /* @__PURE__ */ ((SystemPhase2) => {
+  SystemPhase2[SystemPhase2["PRE"] = 0] = "PRE";
+  SystemPhase2[SystemPhase2["MAIN"] = 1] = "MAIN";
+  SystemPhase2[SystemPhase2["POST"] = 2] = "POST";
+  return SystemPhase2;
+})(SystemPhase || {});
+var SystemMetadataSymbol = /* @__PURE__ */ Symbol("system");
+function System(props) {
+  return (target) => {
+    const systemTarget = target;
+    if ("__proto__" in systemTarget && systemTarget.__proto__ !== SystemBase) {
+      throw new ErrNotASystem(target);
+    }
+    const query = { ...props.query };
+    const requiredComponents = new Set(props.requiredComponents);
+    const computeAfter = new Set(props.computeAfter);
+    const phase = props.phase ?? 1 /* MAIN */;
+    const name = props.name ?? target.name;
+    const metadata = { query, requiredComponents, computeAfter, phase, name };
+    systemTarget[SystemMetadataSymbol] = metadata;
+  };
+}
+function getSystemMetadata(system) {
+  if (hasMetadata(system)) {
+    return system[SystemMetadataSymbol];
+  }
+  throw new ErrMissingSystemMetadata(system);
+}
+function hasMetadata(ctor) {
+  return SystemMetadataSymbol in ctor;
+}
+function isSystem(ctor) {
+  return hasMetadata(ctor);
+}
+var SystemBase = class {
+};
+var SystemsManager = class {
+  constructor(world, logger) {
+    this.world = world;
+    this.logger = logger;
+  }
+  world;
+  logger;
+  systems_ = /* @__PURE__ */ new Map();
+  executionOrder_ = [];
+  requiredComponents_ = /* @__PURE__ */ new Set();
+  dirty_ = true;
+  getRequiredComponents() {
+    return this.requiredComponents_;
+  }
+  register(sys) {
+    const ctor = sys.constructor;
+    if (this.systems_.has(ctor)) throw new Error("Duplicate system");
+    const { query, requiredComponents } = getSystemMetadata(ctor);
+    this.systems_.set(ctor, sys);
+    const q = query;
+    for (const c of q.include ?? [])
+      this.requiredComponents_.add(c);
+    for (const c of q.exclude ?? [])
+      this.requiredComponents_.add(c);
+    for (const c of q.anyOf ?? [])
+      this.requiredComponents_.add(c);
+    for (const c of requiredComponents)
+      this.requiredComponents_.add(c);
+    const meta = getSystemMetadata(ctor);
+    this.logger.debug(() => `[Systems]: system "${meta.name}" was registered`);
+  }
+  build() {
+    this.buildSystemsArray();
+    for (const sys of this.systems_.values()) {
+      sys.onInit?.({ world: this.world, logger: this.logger });
+    }
+    this.logger.debug(() => `Built ${this.systems_.size} systems`);
+    this.dirty_ = false;
+  }
+  rebuild() {
+    this.build();
+  }
+  get(ctor) {
+    const s = this.systems_.get(ctor);
+    if (!s)
+      throw new Error("System not registered");
+    return s;
+  }
+  update(time) {
+    if (this.dirty_)
+      this.rebuild();
+    this.world.events.swapAll();
+    for (const s of this.executionOrder_) {
+      const { query } = getSystemMetadata(s.constructor);
+      const entities = this.world.query(query);
+      s.compute({
+        world: this.world,
+        entities,
+        time,
+        logger: this.logger
+      });
+    }
+  }
+  buildSystemsArray() {
+    const pre = [];
+    const main = [];
+    const post = [];
+    const map = /* @__PURE__ */ new Map();
+    for (const [ctor, system] of this.systems_.entries()) {
+      const meta = getSystemMetadata(ctor);
+      switch (meta.phase) {
+        case 0 /* PRE */:
+          pre.push(system);
+          break;
+        case 1 /* MAIN */:
+          post.push(system);
+          break;
+        default:
+          main.push(system);
+          map.set(ctor, new DAGNode(system));
+          break;
+      }
+    }
+    for (const ctor of map.keys()) {
+      const currentNode = map.get(ctor);
+      const { computeAfter } = getSystemMetadata(ctor);
+      for (const depCtor of computeAfter ?? []) {
+        const depNode = map.get(depCtor);
+        if (!depNode) {
+          throw new Error(`Dependency ${depCtor.name} not registered`);
+        }
+        depNode.vertices.push(currentNode);
+      }
+    }
+    this.executionOrder_ = [
+      ...pre,
+      ...topologicalSort(map.values()).map((x) => x.data),
+      ...post
+    ];
+  }
+};
+
+// src/ecs/constant.ts
+var ECS_DEFAULTS = {
+  MAX_ENTITY_COUNT: Math.pow(2, 12)
+};
+
+// src/ecs/events-buffer.ts
+var EventBuffer = class {
+  readBuf = [];
+  writeBuf = [];
+  write(event) {
+    this.writeBuf.push(event);
+  }
+  /**
+   * Advances the buffer to the next frame.
+   *
+   * Performs a double-buffer flip:
+   * - Promotes all events written during the previous frame (`writeBuf`)
+   *   to be readable in the current frame (`readBuf`).
+   * - Reuses the previous `readBuf` as the new `writeBuf` and clears it
+   *   to collect events for the next frame.
+   *
+   * After calling this method:
+   * - `get()` will return a stable snapshot of events produced in the previous frame.
+   * - `add()` will write into an empty buffer for the current frame.
+   *
+   * Guarantees:
+   * - No events written during the current frame are visible until the next `swap()`.
+   * - Readers observe a consistent, immutable snapshot within a frame.
+   *
+   * Expected to be called exactly once per frame, before system execution.
+  */
+  swap() {
+    const tmp = this.readBuf;
+    this.readBuf = this.writeBuf;
+    this.writeBuf = tmp;
+    this.writeBuf.length = 0;
+  }
+  read() {
+    return this.readBuf;
+  }
+  size() {
+    return this.readBuf.length;
+  }
+};
+function createEventKey(description) {
+  return Symbol(description);
+}
+var EventBus = class {
+  storage = /* @__PURE__ */ new Map();
+  swapAll() {
+    this.storage.forEach((s) => s.swap());
+  }
+  getBuffer(key) {
+    let buf = this.storage.get(key);
+    if (!buf) {
+      buf = new EventBuffer();
+      this.storage.set(key, buf);
+    }
+    return buf;
+  }
+};
+
+// src/ecs/resources/resources.ts
+var ResourceMetadataSymbol = /* @__PURE__ */ Symbol("resource");
+function Resource(params) {
+  return (target) => {
+    const metadata = {
+      name: params.name
+    };
+    target[ResourceMetadataSymbol] = metadata;
+  };
+}
+var ErrNotResource = class extends Error {
+  constructor(ctor) {
+    super(`Class ${ctor.name} is not a Resource. Use @Resource decorator to define resources.`);
+  }
+};
+function getResourceMetadata(resource) {
+  if (isResource(resource)) {
+    return resource[ResourceMetadataSymbol];
+  }
+  throw new ErrNotResource(resource);
+}
+function isResource(ctor) {
+  return ResourceMetadataSymbol in ctor;
+}
+var ResourcesManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  items_ = /* @__PURE__ */ new Map();
+  insert(type, value) {
+    this.items_.set(type, value);
+    const metadata = getResourceMetadata(type);
+    this.logger.debug(() => `[Resources]: Inserted new Resource "${metadata.name}"`);
+    return value;
+  }
+  get(type) {
+    const value = this.items_.get(type);
+    const meta = getResourceMetadata(type);
+    if (!value)
+      throw new Error(`Resource of class ${meta.name} does not exist!`);
+    return value;
+  }
+  getOrInsert(type, factory) {
+    let value = this.items_.get(type) ?? null;
+    if (value === null) {
+      value = factory();
+      this.insert(type, value);
+    }
+    return value;
+  }
+  remove(type) {
+    const meta = getResourceMetadata(type);
+    this.logger.debug(() => `[Resources]: Removed resource "${meta.name}"`);
+    this.items_.delete(type);
+  }
+};
+
+// src/ecs/command.ts
+function entry(component, init = () => {
+}) {
+  return [component, init];
+}
+var Commands = class {
+  constructor(world, logger) {
+    this.world = world;
+    this.logger = logger;
+  }
+  world;
+  logger;
+  commandsQueue_ = [];
+  add(cmd) {
+    this.commandsQueue_.push(cmd);
+  }
+  flush(world) {
+    for (const cmd of this.commandsQueue_)
+      cmd(world);
+    this.commandsQueue_.length = 0;
+  }
+  createEntity(...entries) {
+    const id2 = this.world.entities.create();
+    const cmd = (world) => {
+      for (const [cls, initFn] of entries) {
+        world.addComponent(id2, cls, initFn);
+      }
+    };
+    this.add(cmd);
+    this.logger.debug(() => {
+      const components = entries.map((x) => getComponentMetadata(x[0]).name).join(", ");
+      return `[Commands.createEntity]: Created new entity with ID ${id2}. Linked components: [${components}]`;
+    });
+    return id2;
+  }
+};
+
+// src/ecs/query.ts
+import { Bitmap } from "bitmap-index";
+var QueryManager = class {
+  constructor(world) {
+    this.world = world;
+  }
+  world;
+  cache = /* @__PURE__ */ new Map();
+  get(params) {
+    const key = this.getKey(params);
+    let entry2 = this.cache.get(key);
+    if (!entry2) {
+      entry2 = {
+        params,
+        bitmap: this.compute(params),
+        dirty: false,
+        deps: this.collectDeps(params)
+      };
+      this.cache.set(key, entry2);
+    }
+    if (entry2.dirty) {
+      entry2.bitmap = this.compute(entry2.params);
+      entry2.dirty = false;
+    }
+    let targetBitmap = entry2.bitmap;
+    if (params.excludeEntitiesIds?.length) {
+      targetBitmap = entry2.bitmap.clone();
+      const excludeBm = new Bitmap();
+      for (const id2 of params.excludeEntitiesIds) {
+        excludeBm.set(id2);
+      }
+      targetBitmap.andNot(excludeBm);
+    }
+    if (params.filter) {
+      const result = [];
+      targetBitmap.range((id2) => {
+        if (params.filter(id2)) result.push(id2);
+      });
+      return result;
+    }
+    return this.extractIds(targetBitmap);
+  }
+  invalidate(component) {
+    for (const entry2 of this.cache.values()) {
+      if (entry2.deps.has(component)) {
+        entry2.dirty = true;
+      }
+    }
+  }
+  getKey(q) {
+    return [
+      this.ids(q.include),
+      this.ids(q.exclude),
+      this.ids(q.anyOf)
+    ].join("|");
+  }
+  ids(arr) {
+    if (!arr || arr.length === 0) return "";
+    return arr.map((c) => this.world.components.getComponentId(c)).sort((a, b) => a - b).join(",");
+  }
+  collectDeps(q) {
+    const set = /* @__PURE__ */ new Set();
+    q.include?.forEach((c) => set.add(c));
+    q.exclude?.forEach((c) => set.add(c));
+    q.anyOf?.forEach((c) => set.add(c));
+    return set;
+  }
+  compute(params) {
+    let result = this.combineBitmaps(params.include, "and");
+    const any = this.combineBitmaps(params.anyOf, "or");
+    if (any) {
+      result = result ? result.and(any) : any;
+    }
+    if (!result) {
+      return new Bitmap();
+    }
+    this.applyExclusions(result, params.exclude);
+    return result;
+  }
+  combineBitmaps(components, op) {
+    if (!components?.length) return null;
+    let result = null;
+    let hasAtLeastOneValid = false;
+    for (const c of components) {
+      const bm = this.world.components.getStorage(c)?.bitmap();
+      if (!bm) {
+        if (op === "and") {
+          return new Bitmap();
+        }
+        continue;
+      }
+      hasAtLeastOneValid = true;
+      if (!result) {
+        result = bm.clone();
+      } else {
+        op === "and" ? result.and(bm) : result.or(bm);
+      }
+    }
+    if (op === "or" && !hasAtLeastOneValid) {
+      return new Bitmap();
+    }
+    return result;
+  }
+  applyExclusions(target, excludeComponents) {
+    if (excludeComponents?.length) {
+      for (const c of excludeComponents) {
+        const bm = this.world.components.getStorage(c)?.bitmap();
+        if (bm) target.andNot(bm);
+      }
+    }
+  }
+  extractIds(bitmap) {
+    const result = [];
+    bitmap.range((id2) => {
+      result.push(id2);
+    });
+    return result;
+  }
+};
+
+// src/ecs/plugin/plugin.ts
+var PluginMetadataSymbol = /* @__PURE__ */ Symbol("plugin");
+function Plugin(metadata) {
+  return (target) => {
+    if ("__proto__" in target && target.__proto__ !== PluginBase)
+      throw new ErrNotAPlugin(target);
+    target[PluginMetadataSymbol] = metadata;
+  };
+}
+function getPluginMetadata(plugin) {
+  if (hasMetadata2(plugin)) {
+    return plugin[PluginMetadataSymbol];
+  }
+  throw new ErrMissingPluginMetadata(plugin);
+}
+function hasMetadata2(ctor) {
+  return PluginMetadataSymbol in ctor;
+}
+function isPlugin(ctor) {
+  return hasMetadata2(ctor);
+}
+var PluginBase = class {
+  onPluginLoad;
+  onPluginUnload;
+  onAfterWorldInit;
+};
+var PluginError = class extends Error {
+  constructor(pluginId) {
+    super(`Plugin error! Plugin [${pluginId}]`);
+  }
+};
+var ErrNotAPlugin = class extends Error {
+  constructor(target) {
+    super(`Provided class ${target.name} is not a Plugin! Every plugin must extends of PluginBase class.`);
+  }
+};
+var ErrMissingPluginMetadata = class extends Error {
+  constructor(plugin) {
+    super(`Provided class ${plugin.name}: Missing plugin metadata! Define plugin class with @Plugin decorator.`);
+  }
+};
+var ErrUnknownPlugin = class extends PluginError {
+  constructor(pluginId) {
+    super(pluginId);
+    this.message = `${super.message}: Plugin not found in manager.`;
+  }
+};
+var ErrPluginNotInit = class extends PluginError {
+  constructor(pluginId) {
+    super(pluginId);
+    this.message = `${super.message}: Plugin not initiated yet. You must use PluginsManager.build() before getting instance.`;
+  }
+};
+var ErrMissingPluginDependency = class extends PluginError {
+  constructor(pluginId, missingDepId) {
+    super(pluginId);
+    this.message = `${super.message}: Missing required dependency [${missingDepId}]. Install it first.`;
+  }
+};
+var ErrDAGCycleDetectedPlugin = class extends Error {
+  constructor() {
+    super(`Cycle detected in plugin dependencies!`);
+  }
+};
+var PluginsManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  plugins_ = /* @__PURE__ */ new Map();
+  isInitiated_ = false;
+  install(plugin, ...constructorProps) {
+    if (!isPlugin(plugin))
+      throw new ErrMissingPluginMetadata(plugin);
+    const metadata = getPluginMetadata(plugin);
+    if (this.plugins_.has(plugin))
+      return;
+    const entry2 = {
+      ctor: plugin,
+      ctorParams: constructorProps,
+      metadata
+    };
+    this.plugins_.set(plugin, entry2);
+    this.logger.debug(() => `[Plugins]: Installed plugin ${metadata.name} (${metadata.version})`);
+  }
+  build() {
+    if (this.plugins_.size === 0) {
+      return;
+    }
+    const nodes = /* @__PURE__ */ new Map();
+    for (const id2 of this.plugins_.keys()) {
+      nodes.set(id2, new DAGNode(id2));
+    }
+    for (const [plugin, entry2] of this.plugins_) {
+      const node = nodes.get(plugin);
+      const depPlugins = entry2.metadata.dependencies?.plugins ?? [];
+      for (const dep of depPlugins) {
+        const depNode = nodes.get(dep.plugin);
+        if (!depNode) {
+          throw new ErrMissingPluginDependency(plugin, dep.plugin);
+        }
+        depNode.vertices.push(node);
+      }
+    }
+    let sortedNodes;
+    try {
+      sortedNodes = topologicalSort(nodes.values());
+    } catch (e) {
+      if (e instanceof ErrDAGCycleDetected) {
+        throw new ErrDAGCycleDetectedPlugin();
+      }
+      throw e;
+    }
+    for (const node of sortedNodes) {
+      const entry2 = this.plugins_.get(node.data);
+      const { ctor, ctorParams } = entry2;
+      const instance = new ctor(...ctorParams);
+      entry2.instance = instance;
+      instance.onPluginLoad?.();
+    }
+    this.isInitiated_ = true;
+    this.logger.debug(() => `[Plugins]: Plugins built successfully!`);
+  }
+  /**
+   * @internal
+   */
+  __internal__onAfterWorldInit(world) {
+    for (const p of this.plugins_.values()) {
+      p.instance?.onAfterWorldInit?.(world);
+    }
+  }
+  getPluginMetadata(plugin) {
+    const entry2 = this.plugins_.get(plugin);
+    if (!entry2) throw new ErrUnknownPlugin(plugin);
+    return entry2.metadata;
+  }
+  getPluginInstance(plugin) {
+    const entry2 = this.plugins_.get(plugin);
+    if (!entry2) throw new ErrUnknownPlugin(plugin);
+    if (!entry2.instance) throw new ErrPluginNotInit(plugin);
+    if (!this.isInitiated_) {
+      throw new ErrPluginNotInit(plugin);
+    }
+    return entry2.instance;
+  }
+};
+
+// src/ecs/world.ts
+var World2 = class {
+  entities;
+  components;
+  systems;
+  events;
+  resources;
+  commands;
+  queries;
+  plugins;
+  logger;
+  entityRefs_ = /* @__PURE__ */ new Map();
+  updatesCount_ = 0;
+  get updatesCount() {
+    return this.updatesCount_;
+  }
+  constructor(params) {
+    this.entities = new EntitiesManager(params.logger);
+    this.components = new ComponentsManager(params.logger, params.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT);
+    this.systems = new SystemsManager(this, params.logger);
+    this.events = new EventBus();
+    this.resources = new ResourcesManager(params.logger);
+    this.commands = new Commands(this, params.logger);
+    this.queries = new QueryManager(this);
+    this.plugins = new PluginsManager(params.logger);
+    this.logger = params.logger;
+  }
+  getEntityRef(id2) {
+    let ref = this.entityRefs_.get(id2);
+    if (!ref) {
+      ref = new EntityRef(this, id2);
+      this.entityRefs_.set(id2, ref);
+    }
+    return ref;
+  }
+  query(params) {
+    return this.queries.get(params);
+  }
+  removeComponent(entity, component) {
+    const id2 = typeof entity === "number" ? entity : entity.id;
+    const storage = this.components.getStorage(component);
+    storage.remove(id2);
+    this.queries.invalidate(component);
+  }
+  addComponent(entity, component, initFn) {
+    const storage = this.components.getStorage(component);
+    let id2;
+    if (typeof entity === "number") {
+      id2 = entity;
+    } else {
+      id2 = entity.id;
+    }
+    const c = storage.add(id2, (o) => {
+      if (initFn) {
+        initFn(o);
+      }
+      return o;
+    });
+    this.queries.invalidate(component);
+    return c;
+  }
+  update(clock) {
+    this.systems.update(clock.getTime());
+    this.commands.flush(this);
+    this.updatesCount_++;
+  }
+  build() {
+    this.plugins.build();
+    this.logger.debug(() => "World was built successfully");
+  }
+};
+
+// src/ecs/entity.ts
+var UnregisteredComponentStorageError = class extends Error {
+  constructor(component) {
+    const meta = getComponentMetadata(component);
+    super(`Cannot get storage for component ${meta.name}. Seems like it's not registered in world.`);
+  }
+};
+var EntityMaskNotFoundError = class extends Error {
+  constructor(id2) {
+    super(`Cannot find bitmask for entity [${id2}]. Seems like it's not registered in the EntityManager.`);
+  }
+};
+var EntitiesManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  id_ = 0;
+  nextId() {
+    return ++this.id_;
+  }
+  create() {
+    const id2 = this.nextId();
+    this.logger.debug(() => `[Entities]: Created new entity with ID ${id2}`);
+    return id2;
+  }
+};
+var EntityRef = class {
+  constructor(world, id2) {
+    this.world = world;
+    this.id = id2;
+  }
+  world;
+  id;
+  with(...components) {
+    return components.map((c) => {
+      const s = this.world.components.getStorage(c);
+      return s.tryGet(this.id);
+    });
+  }
+};
+
+// src/core/memory/pool.ts
+var ObjectPool = class {
+  pool_;
+  factory_;
+  cursor_;
+  constructor(factory, initialSize = 0) {
+    this.pool_ = new Array(initialSize);
+    this.factory_ = factory;
+    this.cursor_ = initialSize - 1;
+  }
+  acquire() {
+    if (this.cursor_ >= 0) {
+      return this.pool_[this.cursor_--];
+    }
+    return this.factory_();
+  }
+  release(obj) {
+    this.pool_[++this.cursor_] = obj;
+  }
+  grow() {
+    const oldSize = this.pool_.length;
+    const newSize = oldSize * 2;
+    for (let i = oldSize; i < newSize; i++) this.pool_[i] = this.factory_();
+    this.cursor_ = newSize - 1;
+    this.pool_.length = newSize;
+  }
+};
+
+// src/ecs/components/component-storage.ts
+import { Bitmap as Bitmap2 } from "bitmap-index";
+var ComponentStorage = class {
+  bits_;
+  data_ = [];
+  entityIds_ = [];
+  indexMap_ = /* @__PURE__ */ new Map();
+  pool_;
+  id_ = 0;
+  size_ = 0;
+  cls;
+  constructor(cap = ECS_DEFAULTS.MAX_ENTITY_COUNT, factory, cls) {
+    this.bits_ = new Bitmap2(cap);
+    this.pool_ = new ObjectPool(factory, 0);
+    this.cls = cls;
+  }
+  bitmap() {
+    return this.bits_;
+  }
+  get id() {
+    return this.id_;
+  }
+  _internalSetId(id2) {
+    return this.id_ = id2;
+  }
+  add(id2, initFn) {
+    if (this.indexMap_.has(id2)) {
+      throw new Error(`[ComponentStorage "${this.cls.name}"]: Entity ${id2} already has this component`);
+    }
+    const obj = this.pool_.acquire();
+    initFn?.(obj);
+    const index = this.data_.length;
+    this.data_.push(obj);
+    this.entityIds_.push(id2);
+    this.indexMap_.set(id2, index);
+    this.bits_.set(id2);
+    this.size_++;
+    return obj;
+  }
+  remove(id2) {
+    const index = this.indexMap_.get(id2);
+    if (index === void 0) return;
+    this.bits_.remove(id2);
+    const lastIndex = this.data_.length - 1;
+    const lastEntityId = this.entityIds_[lastIndex];
+    const removedObj = this.data_[index];
+    if (index !== lastIndex) {
+      this.data_[index] = this.data_[lastIndex];
+      this.entityIds_[index] = lastEntityId;
+      this.indexMap_.set(lastEntityId, index);
+    }
+    this.data_.pop();
+    this.entityIds_.pop();
+    this.indexMap_.delete(id2);
+    this.pool_.release(removedObj);
+    this.size_--;
+  }
+  get(id2) {
+    const index = this.indexMap_.get(id2);
+    return index !== void 0 ? this.data_[index] : null;
+  }
+  tryGet(id2) {
+    const index = this.indexMap_.get(id2);
+    if (index === void 0)
+      throw new Error(`[ComponentStorage "${this.cls.name}"]: Requesting non-existing item with ID ${id2}.`);
+    return this.data_[index];
+  }
+  writeComponentsToBuf(ids, out) {
+    let len = 0;
+    for (const id2 of ids) {
+      const index = this.indexMap_.get(id2);
+      if (index !== void 0) out[len++] = this.data_[index];
+    }
+    return len;
+  }
+  has(id2) {
+    return this.bits_.contains(id2);
+  }
+  size() {
+    return this.size_;
+  }
+  forEach(cb) {
+    for (const id2 of this.entityIds_) {
+      cb(id2);
+    }
+  }
+};
+
+// src/ecs/components/manager.ts
+var ComponentAlreadyRegisteredError = class extends Error {
+  constructor(component) {
+    super(`Component ${component.name} already registered!`);
+  }
+};
+var ComponentsManager = class {
+  constructor(logger, maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
+    this.logger = logger;
+    this.maxEntityCount = maxEntityCount;
+  }
+  logger;
+  maxEntityCount;
+  storages_ = /* @__PURE__ */ new Map();
+  currId_ = 0;
+  nextId() {
+    return ++this.currId_;
+  }
+  register(component, opts) {
+    if (this.storages_.has(component))
+      return this.storages_.get(component);
+    const store = this.createComponentStore(component, opts);
+    this.storages_.set(component, store);
+    const meta = getComponentMetadata(component);
+    this.logger.debug(() => `[Components]: Registered component "${meta.name}"`);
+    return store;
+  }
+  createComponentStore(component, opts) {
+    const factory = opts?.factory ?? ((...args) => new component(...args));
+    const store = new ComponentStorage(this.maxEntityCount, factory, component);
+    store._internalSetId(this.nextId());
+    return store;
+  }
+  getStorage(component) {
+    const store = this.storages_.get(component);
+    if (store === void 0)
+      throw new UnregisteredComponentStorageError(component);
+    return store;
+  }
+  getComponentId(ctor) {
+    return getComponentId(ctor);
+  }
+};
+
+// src/std/math/vector.ts
+var Vector2 = class _Vector2 {
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+  x;
+  y;
+  toVec3(z = 0) {
+    return new Vector3(this.x, this.y, z);
+  }
+  toVec4(z = 0, w = 0) {
+    return new Vector4(this.x, this.y, z, w);
+  }
+  clone() {
+    return new _Vector2(this.x, this.y);
+  }
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+  equals(v) {
+    return this.x === v.x && this.y === v.y;
+  }
+  add(other) {
+    this.x += other.x;
+    this.y += other.y;
+    return this;
+  }
+  sub(other) {
+    this.x -= other.x;
+    this.y -= other.y;
+    return this;
+  }
+  mulScalar(s) {
+    this.x *= s;
+    this.y *= s;
+    return this;
+  }
+  divScalar(s) {
+    if (s === 0) {
+      this.x = 0;
+      this.y = 0;
+      return this;
+    }
+    this.x /= s;
+    this.y /= s;
+    return this;
+  }
+  negate() {
+    this.x *= -1;
+    this.y *= -1;
+    return this;
+  }
+  length() {
+    return Math.sqrt(this.x ** 2 + this.y ** 2);
+  }
+  normalize() {
+    const m = this.length();
+    if (m !== 0) {
+      this.x = this.x / m;
+      this.y = this.y / m;
+    }
+    return this;
+  }
+  normalized() {
+    return this.clone().normalize();
+  }
+};
+var Vector3 = class _Vector3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  x;
+  y;
+  z;
+  toVec2() {
+    return new Vector2(this.x, this.y);
+  }
+  toVec4(w = 0) {
+    return new Vector4(this.x, this.y, this.z, w);
+  }
+  clone() {
+    return new _Vector3(this.x, this.y, this.z);
+  }
+  set(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    return this;
+  }
+  equals(v) {
+    return this.x === v.x && this.y === v.y && this.z === v.z;
+  }
+  add(other) {
+    this.x += other.x;
+    this.y += other.y;
+    this.z += other.z;
+    return this;
+  }
+  sub(other) {
+    this.x -= other.x;
+    this.y -= other.y;
+    this.z -= other.z;
+    return this;
+  }
+  mulScalar(s) {
+    this.x *= s;
+    this.y *= s;
+    this.z *= s;
+    return this;
+  }
+  divScalar(s) {
+    if (s === 0) {
+      this.x = 0;
+      this.y = 0;
+      this.z = 0;
+      return this;
+    }
+    this.x /= s;
+    this.y /= s;
+    this.z /= s;
+    return this;
+  }
+  negate() {
+    this.x *= -1;
+    this.y *= -1;
+    this.z *= -1;
+    return this;
+  }
+  length() {
+    return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
+  }
+  normalize() {
+    const m = this.length();
+    if (m !== 0) {
+      this.x = this.x / m;
+      this.y = this.y / m;
+      this.z = this.z / m;
+    }
+    return this;
+  }
+  normalized() {
+    return this.clone().normalize();
+  }
+};
+var Vector4 = class _Vector4 {
+  constructor(x = 0, y = 0, z = 0, w = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  x;
+  y;
+  z;
+  w;
+  toVec2() {
+    return new Vector2(this.x, this.y);
+  }
+  toVec3() {
+    return new Vector3(this.x, this.y, this.z);
+  }
+  clone() {
+    return new _Vector4(this.x, this.y, this.z, this.w);
+  }
+  set(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+    return this;
+  }
+  equals(v) {
+    return this.x === v.x && this.y === v.y && this.z === v.z && this.w === v.w;
+  }
+  add(other) {
+    this.x += other.x;
+    this.y += other.y;
+    this.z += other.z;
+    this.w += other.w;
+    return this;
+  }
+  sub(other) {
+    this.x -= other.x;
+    this.y -= other.y;
+    this.z -= other.z;
+    this.w -= other.w;
+    return this;
+  }
+  mulScalar(s) {
+    this.x *= s;
+    this.y *= s;
+    this.z *= s;
+    this.w *= s;
+    return this;
+  }
+  divScalar(s) {
+    if (s === 0) {
+      this.x = 0;
+      this.y = 0;
+      this.z = 0;
+      this.w = 0;
+      return this;
+    }
+    this.x /= s;
+    this.y /= s;
+    this.z /= s;
+    this.w /= s;
+    return this;
+  }
+  negate() {
+    this.x *= -1;
+    this.y *= -1;
+    this.z *= -1;
+    this.w *= -1;
+    return this;
+  }
+  length() {
+    return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2 + this.w ** 2);
+  }
+  normalize() {
+    const m = this.length();
+    if (m !== 0) {
+      this.x = this.x / m;
+      this.y = this.y / m;
+      this.z = this.z / m;
+      this.w = this.w / m;
+    }
+    return this;
+  }
+  normalized() {
+    return this.clone().normalize();
+  }
+};
+
+// src/std/components/transform.ts
+var Transform = class {
+  constructor(position = new Vector3(), rotation = new Vector3(), scale = new Vector3(1, 1, 1)) {
+    this.position = position;
+    this.rotation = rotation;
+    this.scale = scale;
+  }
+  position;
+  rotation;
+  scale;
+};
+Transform = __decorateClass([
+  Component({ name: "Transform_stdlib" })
+], Transform);
+
+// src/std/components/velocity.ts
+var Velocity = class {
+  constructor(linear = new Vector3()) {
+    this.linear = linear;
+  }
+  linear;
+};
+Velocity = __decorateClass([
+  Component({ name: "Velocity_stdlib" })
+], Velocity);
+
+export {
+  __decorateClass,
+  VisitedState,
+  DAGNode,
+  ErrDAGCycleDetected,
+  topologicalSort,
+  SystemError,
+  ErrNotASystem,
+  ErrMissingSystemMetadata,
+  SystemPhase,
+  System,
+  getSystemMetadata,
+  isSystem,
+  SystemBase,
+  SystemsManager,
+  Component,
+  UnregisteredComponentStorageError,
+  EntityMaskNotFoundError,
+  EntitiesManager,
+  EntityRef,
+  ECS_DEFAULTS,
+  EventBuffer,
+  createEventKey,
+  EventBus,
+  ObjectPool,
+  ComponentStorage,
+  ComponentAlreadyRegisteredError,
+  ComponentsManager,
+  Resource,
+  getResourceMetadata,
+  ResourcesManager,
+  entry,
+  Commands,
+  Plugin,
+  getPluginMetadata,
+  isPlugin,
+  PluginBase,
+  PluginError,
+  ErrNotAPlugin,
+  ErrMissingPluginMetadata,
+  ErrUnknownPlugin,
+  ErrPluginNotInit,
+  PluginsManager,
+  World2 as World,
+  Transform,
+  Velocity
+};
+//# sourceMappingURL=chunk-SWTBVK53.js.map