@draug/engine 1.0.10 → 1.0.12

package/README.md

@@ -245,7 +245,7 @@ In Node, `performance.now()` is available on modern versions; otherwise pass `{
 
 ### Runtime (optional)
 
-`Runtime` is a tiny wrapper: `update(dt)` forwards to `world.update(dt)`. In the Amber workspace it is usually constructed together with `@draug/assets`’s `AssetsManager` for loading textures and similar; for a headless server or a toy sim you can ignore `Runtime` and call `world.update` directly from your own driver.
+`Runtime` is a tiny wrapper: `update(dt)` forwards to `world.update(dt)`. In the Amber workspace it is usually constructed together with `AssetsManager` from this package for loading textures and similar; for a headless server or a toy sim you can ignore `Runtime` and call `world.update` directly from your own driver.
 
 ## Configuration
 
@@ -269,7 +269,7 @@ Issues and PRs are welcome in the [GitHub repository](https://github.com/yazmeya
 
 - **Author:** future_undefined — [GitHub @yazmeyaa](https://github.com/yazmeyaa) · [evgenijantonenkov456@gmail.com](mailto:evgenijantonenkov456@gmail.com)
 
-Related workspace packages: `@draug/core` (DAG sort, object pools, etc.) and `@draug/types` (shared `ClassType` helpers). Everything this library exposes to apps is listed in `src/index.ts` in the repository.
+Related workspace packages: `@draug/types` (WebSocket `RawData` helper for networking code). Everything this library exposes to apps is listed in `src/index.ts` in the repository.
 
 ## License
 

package/dist/index.cjs

@@ -20,15 +20,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Asset: () => Asset,
+  AssetState: () => AssetState,
+  AssetStorage: () => AssetStorage,
+  AssetsManager: () => AssetsManager,
   Clock: () => Clock,
   Commands: () => Commands,
   Component: () => Component,
   ComponentAlreadyRegisteredError: () => ComponentAlreadyRegisteredError,
   ComponentStorage: () => ComponentStorage,
   ComponentsManager: () => ComponentsManager,
+  DAGNode: () => DAGNode,
   EntitiesManager: () => EntitiesManager,
   EntityMaskNotFoundError: () => EntityMaskNotFoundError,
   EntityRef: () => EntityRef,
+  ErrDAGCycleDetected: () => ErrDAGCycleDetected,
   ErrMissingPluginMetadata: () => ErrMissingPluginMetadata,
   ErrMissingSystemMetadata: () => ErrMissingSystemMetadata,
   ErrNotAPlugin: () => ErrNotAPlugin,
@@ -38,6 +44,7 @@ __export(index_exports, {
   EventBuffer: () => EventBuffer,
   EventBus: () => EventBus,
   GameLoop: () => GameLoop,
+  ObjectPool: () => ObjectPool,
   Plugin: () => Plugin,
   PluginBase: () => PluginBase,
   PluginError: () => PluginError,
@@ -50,18 +57,62 @@ __export(index_exports, {
   SystemError: () => SystemError,
   SystemsManager: () => SystemsManager,
   UnregisteredComponentStorageError: () => UnregisteredComponentStorageError,
+  VisitedState: () => VisitedState,
   World: () => World3,
   createEventKey: () => createEventKey,
   entry: () => entry,
   getPluginMetadata: () => getPluginMetadata,
   getSystemMetadata: () => getSystemMetadata,
   isPlugin: () => isPlugin,
-  isSystem: () => isSystem
+  isSystem: () => isSystem,
+  topologicalSort: () => topologicalSort
 });
 module.exports = __toCommonJS(index_exports);
 
+// 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 import_core = require("@draug/core");
 var SystemError = class extends Error {
   constructor(target) {
     super(`[System Error] (System "${target.name}".`);
@@ -88,7 +139,8 @@ function System(props) {
     const query = { ...props.query };
     const requiredComponents = new Set(props.requiredComponents);
     const computeAfter = new Set(props.computeAfter);
-    const metadata = { query, requiredComponents, computeAfter };
+    const phase = props.phase ?? "main";
+    const metadata = { query, requiredComponents, computeAfter, phase };
     systemTarget[SystemMetadataSymbol] = metadata;
   };
 }
@@ -158,11 +210,26 @@ var SystemsManager = class {
     }
   }
   buildSystemsArray() {
+    const pre = [];
+    const main = [];
+    const post = [];
     const map = /* @__PURE__ */ new Map();
     for (const [ctor, system] of this.systems_.entries()) {
-      map.set(ctor, new import_core.DAGNode(system));
+      const meta = getSystemMetadata(ctor);
+      switch (meta.phase) {
+        case "pre":
+          pre.push(system);
+          break;
+        case "post":
+          post.push(system);
+          break;
+        default:
+          main.push(system);
+          map.set(ctor, new DAGNode(system));
+          break;
+      }
     }
-    for (const ctor of this.systems_.keys()) {
+    for (const ctor of map.keys()) {
       const currentNode = map.get(ctor);
       const { computeAfter } = getSystemMetadata(ctor);
       for (const depCtor of computeAfter ?? []) {
@@ -173,7 +240,11 @@ var SystemsManager = class {
         depNode.vertices.push(currentNode);
       }
     }
-    this.executionOrder_ = (0, import_core.topologicalSort)(map.values()).map((x) => x.data);
+    this.executionOrder_ = [
+      ...pre,
+      ...topologicalSort(map.values()).map((x) => x.data),
+      ...post
+    ];
   }
 };
 
@@ -274,8 +345,36 @@ var EventBus = class {
   }
 };
 
+// src/core/memory/pool.ts
+var ObjectPool = class {
+  pool_;
+  factory_;
+  cursor_;
+  constructor(factory, initialSize = 1024) {
+    this.pool_ = new Array(initialSize);
+    for (let i = 0; i < initialSize; i++) {
+      this.pool_[i] = factory();
+    }
+    this.factory_ = factory;
+    this.cursor_ = initialSize - 1;
+  }
+  acquire() {
+    if (this.cursor_ < 0) this.grow();
+    return this.pool_[this.cursor_--];
+  }
+  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
-var import_core2 = require("@draug/core");
 var import_bitmap_index = require("bitmap-index");
 var import_ts_sparse_set = require("ts-sparse-set");
 var ComponentStorage = class {
@@ -287,7 +386,7 @@ var ComponentStorage = class {
   constructor(cap = ECS_DEFAULTS.MAX_ENTITY_COUNT, factory, cls) {
     this.set_ = new import_ts_sparse_set.SparseSet(cap);
     this.bits_ = new import_bitmap_index.Bitmap(cap);
-    this.pool_ = new import_core2.ObjectPool(factory, cap);
+    this.pool_ = new ObjectPool(factory, cap);
     this.cls = cls;
   }
   bitmap() {
@@ -646,7 +745,6 @@ var QueryManager = class {
 };
 
 // src/plugin/plugin.ts
-var import_core3 = require("@draug/core");
 var PluginMetadataSymbol = /* @__PURE__ */ Symbol("plugin");
 function Plugin(metadata) {
   return (target) => {
@@ -729,7 +827,7 @@ var PluginsManager = class {
   build() {
     const nodes = /* @__PURE__ */ new Map();
     for (const id2 of this.plugins_.keys()) {
-      nodes.set(id2, new import_core3.DAGNode(id2));
+      nodes.set(id2, new DAGNode(id2));
     }
     for (const [id2, entry2] of this.plugins_) {
       const node = nodes.get(id2);
@@ -744,9 +842,9 @@ var PluginsManager = class {
     }
     let sortedNodes;
     try {
-      sortedNodes = (0, import_core3.topologicalSort)(nodes.values());
+      sortedNodes = topologicalSort(nodes.values());
     } catch (e) {
-      if (e instanceof import_core3.ErrDAGCycleDetected) {
+      if (e instanceof ErrDAGCycleDetected) {
         throw new ErrDAGCycleDetectedPlugin();
       }
       throw e;
@@ -903,17 +1001,169 @@ var Runtime = class {
     this.world.update(dt);
   }
 };
+
+// src/assets/assets.ts
+var AssetState = /* @__PURE__ */ ((AssetState2) => {
+  AssetState2[AssetState2["NOT_READY"] = 1] = "NOT_READY";
+  AssetState2[AssetState2["LOADING"] = 2] = "LOADING";
+  AssetState2[AssetState2["READY"] = 3] = "READY";
+  return AssetState2;
+})(AssetState || {});
+var Asset = class {
+  constructor(id2, url, loader, disposer) {
+    this.id = id2;
+    this.url = url;
+    this.loader = loader;
+    this.disposer = disposer;
+  }
+  id;
+  url;
+  loader;
+  disposer;
+  data_ = null;
+  state_ = 1 /* NOT_READY */;
+  loading_ = null;
+  disposed_ = false;
+  async load() {
+    if (this.state_ === 3 /* READY */)
+      return this.data_;
+    if (this.state_ === 2 /* LOADING */)
+      return this.loading_;
+    this.state_ = 2 /* LOADING */;
+    this.disposed_ = false;
+    this.loading_ = this.loader(this.url).then((data) => {
+      if (this.disposed_) return data;
+      this.data_ = data;
+      this.state_ = 3 /* READY */;
+      this.loading_ = null;
+      return data;
+    }).catch((err) => {
+      this.state_ = 1 /* NOT_READY */;
+      this.loading_ = null;
+      throw err;
+    });
+    return this.loading_;
+  }
+  reset() {
+    this.data_ = null;
+    this.loading_ = null;
+    this.state_ = 1 /* NOT_READY */;
+  }
+  async dispose() {
+    this.disposed_ = true;
+    if (this.data_)
+      await this.disposer(this.data_);
+    this.reset();
+  }
+  getData() {
+    if (this.state_ !== 3 /* READY */)
+      throw new Error("Data is not loaded yet!");
+    return this.data_;
+  }
+};
+var AssetStorage = class {
+  constructor(nextIdFn_, defaultLoader_, defaultDisposer_) {
+    this.nextIdFn_ = nextIdFn_;
+    this.defaultLoader_ = defaultLoader_;
+    this.defaultDisposer_ = defaultDisposer_;
+  }
+  nextIdFn_;
+  defaultLoader_;
+  defaultDisposer_;
+  items_ = /* @__PURE__ */ new Map();
+  newAsset(id2, url, loader, disposer) {
+    return new Asset(id2, url, loader, disposer);
+  }
+  add(url) {
+    const id2 = this.nextIdFn_();
+    const rs = this.newAsset(id2, url, this.defaultLoader_, this.defaultDisposer_);
+    this.items_.set(id2, rs);
+    return rs;
+  }
+  addCustom(url, customLoader, customDisposer) {
+    const id2 = this.nextIdFn_();
+    const rs = this.newAsset(id2, url, customLoader, customDisposer);
+    this.items_.set(id2, rs);
+    return rs;
+  }
+  get(id2) {
+    const item = this.items_.get(id2);
+    return item ?? null;
+  }
+  tryGet(id2) {
+    const item = this.items_.get(id2);
+    if (!item)
+      throw new Error(`Asset with id ${id2} in storage ${this.constructor.name} not exist`);
+    return item;
+  }
+  async remove(id2) {
+    const item = this.items_.get(id2);
+    if (!item) return;
+    await item.dispose();
+    this.items_.delete(id2);
+  }
+  async loadAll() {
+    await Promise.all(
+      Array.from(this.items_.values(), (r) => r.load())
+    );
+  }
+  async clearAll() {
+    await Promise.all(
+      Array.from(this.items_.values(), (r) => r.dispose())
+    );
+    this.items_.clear();
+  }
+};
+var NOOP_DISPOSER = async () => {
+};
+var AssetsManager = class {
+  storages_ = /* @__PURE__ */ new Map();
+  currId = 0;
+  nextIdFn = () => {
+    return ++this.currId;
+  };
+  register(res, defaultLoader, defaultDisposer = NOOP_DISPOSER) {
+    const storage = new AssetStorage(
+      this.nextIdFn,
+      defaultLoader,
+      defaultDisposer
+    );
+    this.storages_.set(res, storage);
+    return storage;
+  }
+  getStorage(res) {
+    return this.storages_.get(res) ?? null;
+  }
+  tryGetStorage(res) {
+    const s = this.storages_.get(res);
+    if (!s)
+      throw new Error(`Storage ${res.name} is not registered!`);
+    return s;
+  }
+  async loadAll() {
+    await Promise.all(Array.from(this.storages_.values(), (s) => s.loadAll()));
+  }
+  disposeAll() {
+    Array.from(this.storages_.values(), (s) => s.clearAll());
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Asset,
+  AssetState,
+  AssetStorage,
+  AssetsManager,
   Clock,
   Commands,
   Component,
   ComponentAlreadyRegisteredError,
   ComponentStorage,
   ComponentsManager,
+  DAGNode,
   EntitiesManager,
   EntityMaskNotFoundError,
   EntityRef,
+  ErrDAGCycleDetected,
   ErrMissingPluginMetadata,
   ErrMissingSystemMetadata,
   ErrNotAPlugin,
@@ -923,6 +1173,7 @@ var Runtime = class {
   EventBuffer,
   EventBus,
   GameLoop,
+  ObjectPool,
   Plugin,
   PluginBase,
   PluginError,
@@ -935,12 +1186,14 @@ var Runtime = class {
   SystemError,
   SystemsManager,
   UnregisteredComponentStorageError,
+  VisitedState,
   World,
   createEventKey,
   entry,
   getPluginMetadata,
   getSystemMetadata,
   isPlugin,
-  isSystem
+  isSystem,
+  topologicalSort
 });
 //# sourceMappingURL=index.cjs.map