@draug/engine 1.0.20 → 1.0.23

package/dist/index.js

@@ -1,942 +1,52 @@
-// 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 Array.from(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/entity.ts
-var UnregisteredComponentStorageError = class extends Error {
-  constructor(component) {
-    super(`Cannot get storage for component ${component.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/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/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 } 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 Bitmap(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/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/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/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 as Bitmap2 } 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 Bitmap2();
-      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 Bitmap2();
-    }
-    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 Bitmap2();
-        }
-        continue;
-      }
-      hasAtLeastOneValid = true;
-      if (!result) {
-        result = bm.clone();
-      } else {
-        op === "and" ? result.and(bm) : result.or(bm);
-      }
-    }
-    if (op === "or" && !hasAtLeastOneValid) {
-      return new Bitmap2();
-    }
-    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;
-  }
-  resolveId(pluginOrId) {
-    if (typeof pluginOrId === "string") {
-      return pluginOrId;
-    }
-    if (!isPlugin(pluginOrId)) {
-      throw new ErrMissingPluginMetadata(pluginOrId);
-    }
-    return getPluginMetadata(pluginOrId).id;
-  }
-};
-
-// src/ecs/world.ts
-var World3 = 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");
-  }
-};
+import {
+  MovementSystem
+} from "./chunk-BYP45ZLQ.js";
+import {
+  Commands,
+  Component,
+  ComponentAlreadyRegisteredError,
+  ComponentStorage,
+  ComponentsManager,
+  DAGNode,
+  ECS_DEFAULTS,
+  EntitiesManager,
+  EntityMaskNotFoundError,
+  EntityRef,
+  ErrDAGCycleDetected,
+  ErrMissingPluginMetadata,
+  ErrMissingSystemMetadata,
+  ErrNotAPlugin,
+  ErrNotASystem,
+  ErrPluginNotInit,
+  ErrUnknownPlugin,
+  EventBuffer,
+  EventBus,
+  ObjectPool,
+  Plugin,
+  PluginBase,
+  PluginError,
+  PluginsManager,
+  Resource,
+  ResourcesManager,
+  System,
+  SystemBase,
+  SystemError,
+  SystemPhase,
+  SystemsManager,
+  Transform,
+  UnregisteredComponentStorageError,
+  Velocity,
+  VisitedState,
+  World,
+  createEventKey,
+  entry,
+  getPluginMetadata,
+  getResourceMetadata,
+  getSystemMetadata,
+  isPlugin,
+  isSystem,
+  topologicalSort
+} from "./chunk-SWTBVK53.js";
 
 // src/runtime/runtime.ts
 var Runtime = class {
@@ -1015,8 +125,8 @@ var AssetState = /* @__PURE__ */ ((AssetState2) => {
   return AssetState2;
 })(AssetState || {});
 var Asset = class {
-  constructor(id2, url, loader, disposer) {
-    this.id = id2;
+  constructor(id, url, loader, disposer) {
+    this.id = id;
     this.url = url;
     this.loader = loader;
     this.disposer = disposer;
@@ -1076,36 +186,36 @@ var AssetStorage = class {
   defaultLoader_;
   defaultDisposer_;
   items_ = /* @__PURE__ */ new Map();
-  newAsset(id2, url, loader, disposer) {
-    return new Asset(id2, url, loader, disposer);
+  newAsset(id, url, loader, disposer) {
+    return new Asset(id, url, loader, disposer);
   }
   add(url) {
-    const id2 = this.nextIdFn_();
-    const rs = this.newAsset(id2, url, this.defaultLoader_, this.defaultDisposer_);
-    this.items_.set(id2, rs);
+    const id = this.nextIdFn_();
+    const rs = this.newAsset(id, url, this.defaultLoader_, this.defaultDisposer_);
+    this.items_.set(id, rs);
     return rs;
   }
   addCustom(url, customLoader, customDisposer) {
-    const id2 = this.nextIdFn_();
-    const rs = this.newAsset(id2, url, customLoader, customDisposer);
-    this.items_.set(id2, rs);
+    const id = this.nextIdFn_();
+    const rs = this.newAsset(id, url, customLoader, customDisposer);
+    this.items_.set(id, rs);
     return rs;
   }
-  get(id2) {
-    const item = this.items_.get(id2);
+  get(id) {
+    const item = this.items_.get(id);
     return item ?? null;
   }
-  tryGet(id2) {
-    const item = this.items_.get(id2);
+  tryGet(id) {
+    const item = this.items_.get(id);
     if (!item)
-      throw new Error(`Asset with id ${id2} in storage ${this.constructor.name} not exist`);
+      throw new Error(`Asset with id ${id} in storage ${this.constructor.name} not exist`);
     return item;
   }
-  async remove(id2) {
-    const item = this.items_.get(id2);
+  async remove(id) {
+    const item = this.items_.get(id);
     if (!item) return;
     await item.dispose();
-    this.items_.delete(id2);
+    this.items_.delete(id);
   }
   async loadAll() {
     await Promise.all(
@@ -1172,6 +282,13 @@ var NoopLogger = class {
   }
 };
 
+// src/std/utils.ts
+function injectStd(world) {
+  world.components.register(Transform);
+  world.components.register(Velocity);
+  world.systems.register(new MovementSystem());
+}
+
 // src/engine.ts
 var Engine = class {
   runtime;
@@ -1181,10 +298,14 @@ var Engine = class {
   constructor(params) {
     this.runtime = new Runtime(params.loop);
     this.logger = params.logger ?? new NoopLogger();
-    this.world = new World3({
+    this.world = new World({
       logger: this.logger,
       maxEntityCount: params.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT
     });
+    injectStd(this.world);
+  }
+  getTick() {
+    return this.world.updatesCount;
   }
   init() {
     this.world.build();
@@ -1235,7 +356,7 @@ export {
   SystemsManager,
   UnregisteredComponentStorageError,
   VisitedState,
-  World3 as World,
+  World,
   createEventKey,
   entry,
   getPluginMetadata,