@draug/engine 1.0.19 → 1.0.20

package/dist/index.d.ts

@@ -17,86 +17,53 @@ interface Logger {
     error(message: LogMessage): void;
 }
 
-interface IStorage<T extends object> {
+declare class ComponentStorage<T extends object> {
+    private bits_;
+    private data_;
+    private entityIds_;
+    private indexMap_;
+    private pool_;
+    private id_;
+    private size_;
+    private cls;
+    constructor(cap: number | undefined, factory: () => T, cls: ClassType<T>);
+    bitmap(): Bitmap;
+    get id(): number;
+    _internalSetId(id: number): number;
     add(id: number, initFn?: (obj: T) => T): T;
     remove(id: number): void;
     get(id: number): T | null;
     tryGet(id: number): T;
+    writeComponentsToBuf(ids: ReadonlyArray<number>, out: T[]): number;
     has(id: number): boolean;
     size(): number;
     forEach(cb: (id: number) => void): void;
-    bitmap(): Bitmap;
 }
 
-declare enum ComponentStorageType {
-    COMPONENT_STORAGE = 1,
-    SINGLETON_STORAGE = 2
-}
-type RegisterSingletoneComponentOptions<T extends object> = {
-    storageType: ComponentStorageType.SINGLETON_STORAGE;
-    factory: () => T;
-};
 type RegisterComponentStorageOptions<T extends object> = {
-    storageType: ComponentStorageType.COMPONENT_STORAGE;
     factory?: () => T;
 };
-type RegisterComponentOptions<T extends object> = RegisterSingletoneComponentOptions<T> | RegisterComponentStorageOptions<T>;
+type RegisterComponentOptions<T extends object> = RegisterComponentStorageOptions<T>;
 declare class ComponentAlreadyRegisteredError extends Error {
     constructor(component: ComponentType);
 }
 declare class ComponentsManager {
+    private readonly logger;
     private maxEntityCount;
     private readonly storages_;
     private currId_;
     private nextId;
-    constructor(maxEntityCount?: number);
-    register<T extends object>(component: ComponentType<T>, opts?: RegisterComponentOptions<T>): IStorage<T>;
+    constructor(logger: Logger, maxEntityCount?: number);
+    register<T extends object>(component: ComponentType<T>, opts?: RegisterComponentOptions<T>): ComponentStorage<T>;
     private createComponentStore;
-    private createSingletonStore;
-    getStorage<T extends object>(component: ComponentType<T>): IStorage<T>;
+    getStorage<T extends object>(component: ComponentType<T>): ComponentStorage<T>;
     getComponentId(ctor: ComponentType): number;
 }
 
-declare function Component(): ClassDecorator;
-
-declare class ComponentStorage<T extends object> implements IStorage<T> {
-    private bits_;
-    private data_;
-    private entityIds_;
-    private indexMap_;
-    private pool_;
-    private id_;
-    private size_;
-    private cls;
-    constructor(cap: number | undefined, factory: () => T, cls: ClassType<T>);
-    bitmap(): Bitmap;
-    get id(): number;
-    _internalSetId(id: number): number;
-    add(id: number, initFn?: (obj: T) => T): T;
-    remove(id: number): void;
-    get(id: number): T | null;
-    tryGet(id: number): T;
-    writeComponentsToBuf(ids: ReadonlyArray<number>, out: T[]): number;
-    has(id: number): boolean;
-    size(): number;
-    forEach(cb: (id: number) => void): void;
-}
-
-declare class SingletonStorage<T extends object> implements IStorage<T> {
-    private factory;
-    private value;
-    private entityId;
-    constructor(factory: () => T);
-    bitmap(): Bitmap;
-    add(id: number, initFn?: ((obj: T) => T) | undefined): T;
-    remove(id: number): void;
-    get(id: number): T | null;
-    tryGet(id: number): T;
-    has(id: number): boolean;
-    size(): number;
-    forEach(cb: (id: number) => void): void;
-    private validateId;
-}
+type ComponentOptions = {
+    name: string;
+};
+declare function Component(options: ComponentOptions): ClassDecorator;
 
 type EntityID = number;
 declare class UnregisteredComponentStorageError extends Error {
@@ -158,6 +125,14 @@ declare class EventBus {
     getBuffer<T>(key: EventKey<T>): EventBuffer<T>;
 }
 
+type ResourceMetadata = {
+    name: string;
+};
+type ResourceParams = {
+    name: string;
+};
+declare function Resource(params: ResourceParams): ClassDecorator;
+declare function getResourceMetadata(resource: Function): ResourceMetadata;
 declare class ResourcesManager {
     private readonly logger;
     private readonly items_;
@@ -205,12 +180,13 @@ declare class QueryManager {
 }
 
 type PluginID = string;
+type PluginConstructor = ClassType<PluginBase>;
 type PluginDependencies = {
     components?: ComponentType[];
     resources?: ClassType<any>[];
     systems?: ClassType<SystemBase>[];
     plugins?: Array<{
-        id: PluginID;
+        plugin: PluginConstructor;
         version?: string;
     }>;
 };
@@ -221,7 +197,7 @@ interface PluginMetadata {
     dependencies?: PluginDependencies;
 }
 declare function Plugin(metadata: PluginMetadata): ClassDecorator;
-declare function getPluginMetadata(plugin: ClassType<PluginBase>): PluginMetadata;
+declare function getPluginMetadata(plugin: PluginConstructor): PluginMetadata;
 declare function isPlugin(ctor: Function): boolean;
 declare abstract class PluginBase {
     onPluginLoad?: () => void;
@@ -229,33 +205,33 @@ declare abstract class PluginBase {
     onAfterWorldInit?: (world: World) => void;
 }
 declare class PluginError extends Error {
-    constructor(pluginId: string);
+    constructor(pluginId: PluginConstructor);
 }
 declare class ErrNotAPlugin extends Error {
     constructor(target: Function);
 }
 declare class ErrMissingPluginMetadata extends Error {
-    constructor(plugin: ClassType<PluginBase>);
+    constructor(plugin: PluginConstructor);
 }
 declare class ErrUnknownPlugin extends PluginError {
-    constructor(pluginId: string);
+    constructor(pluginId: PluginConstructor);
 }
 declare class ErrPluginNotInit extends PluginError {
-    constructor(pluginId: string);
+    constructor(pluginId: PluginConstructor);
 }
 declare class PluginsManager {
     private readonly logger;
     private plugins_;
     private isInitiated_;
     constructor(logger: Logger);
-    install<T extends ClassType<PluginBase>>(plugin: T, ...constructorProps: ConstructorParameters<T>): void;
+    install<T extends PluginConstructor>(plugin: T, ...constructorProps: ConstructorParameters<T>): void;
     build(): void;
     /**
      * @internal
      */
     __internal__onAfterWorldInit(world: World): void;
-    getPluginMetadata(pluginOrId: ClassType<PluginBase> | PluginID): PluginMetadata;
-    getPluginInstance<T extends PluginBase>(pluginOrId: ClassType<T> | PluginID): T;
+    getPluginMetadata(plugin: PluginConstructor): PluginMetadata;
+    getPluginInstance<T extends PluginBase>(plugin: ClassType<T>): T;
     private resolveId;
 }
 
@@ -312,6 +288,8 @@ declare class World {
     readonly plugins: PluginsManager;
     private readonly logger;
     private entityRefs_;
+    private updatesCount_;
+    get updatesCount(): number;
     constructor(params: WorldConstructor);
     getEntityRef(id: number): EntityRef;
     query(params: QueryParameters): number[];
@@ -364,12 +342,14 @@ type SystemMetadata = {
      */
     computeAfter?: Set<SystemCtor>;
     phase?: SystemPhase;
+    name: string;
 };
 type SystemDecoratorProps = {
     query: SystemMetadata['query'];
     requiredComponents?: ComponentType[];
     computeAfter?: SystemCtor[];
     phase?: SystemPhase;
+    name: SystemMetadata['name'];
 };
 declare function System(props: SystemDecoratorProps): ClassDecorator;
 declare function getSystemMetadata(system: SystemCtor): SystemMetadata;
@@ -513,4 +493,4 @@ declare class Engine {
     start(): void;
 }
 
-export { Asset, type AssetDisposer, type AssetID, type AssetIDGenerator, type AssetLoader, AssetState, AssetStorage, AssetsManager, type ClassType, Clock, Commands, Component, ComponentAlreadyRegisteredError, type ComponentInitFn, ComponentStorage, type ComponentType, ComponentsManager, type CreateEntityComponentEntry, DAGNode, Engine, type EngineConstructor, EntitiesManager, type EntityID, EntityMaskNotFoundError, EntityRef, ErrDAGCycleDetected, ErrMissingPluginMetadata, ErrMissingSystemMetadata, ErrNotAPlugin, ErrNotASystem, ErrPluginNotInit, ErrUnknownPlugin, EventBuffer, EventBus, type IStorage, LogLevel, type LogMessage, type Logger, Loop, ObjectPool, type PlatformLoop, Plugin, PluginBase, type PluginDependencies, PluginError, type PluginID, type PluginMetadata, PluginsManager, ResourcesManager, Runtime, SingletonStorage, type StepFunction, System, SystemBase, type SystemComputeContext, SystemError, type SystemInitContext, SystemPhase, SystemsManager, type TimeSource, UnregisteredComponentStorageError, VisitedState, World, type WorldCommand, createEventKey, entry, getPluginMetadata, getSystemMetadata, isPlugin, isSystem, topologicalSort };
+export { Asset, type AssetDisposer, type AssetID, type AssetIDGenerator, type AssetLoader, AssetState, AssetStorage, AssetsManager, type ClassType, Clock, Commands, Component, ComponentAlreadyRegisteredError, type ComponentInitFn, ComponentStorage, type ComponentType, ComponentsManager, type CreateEntityComponentEntry, DAGNode, Engine, type EngineConstructor, EntitiesManager, type EntityID, EntityMaskNotFoundError, EntityRef, ErrDAGCycleDetected, ErrMissingPluginMetadata, ErrMissingSystemMetadata, ErrNotAPlugin, ErrNotASystem, ErrPluginNotInit, ErrUnknownPlugin, EventBuffer, EventBus, LogLevel, type LogMessage, type Logger, Loop, ObjectPool, type PlatformLoop, Plugin, PluginBase, type PluginDependencies, PluginError, type PluginID, type PluginMetadata, PluginsManager, Resource, type ResourceMetadata, ResourcesManager, Runtime, type StepFunction, System, SystemBase, type SystemComputeContext, SystemError, type SystemInitContext, SystemPhase, SystemsManager, type TimeSource, UnregisteredComponentStorageError, VisitedState, World, type WorldCommand, createEventKey, entry, getPluginMetadata, getResourceMetadata, getSystemMetadata, isPlugin, isSystem, topologicalSort };

package/dist/index.js

@@ -75,7 +75,8 @@ function System(props) {
     const requiredComponents = new Set(props.requiredComponents);
     const computeAfter = new Set(props.computeAfter);
     const phase = props.phase ?? 1 /* MAIN */;
-    const metadata = { query, requiredComponents, computeAfter, phase };
+    const name = props.name ?? target.name;
+    const metadata = { query, requiredComponents, computeAfter, phase, name };
     systemTarget[SystemMetadataSymbol] = metadata;
   };
 }
@@ -121,7 +122,8 @@ var SystemsManager = class {
       this.requiredComponents_.add(c);
     for (const c of requiredComponents)
       this.requiredComponents_.add(c);
-    this.logger.debug(() => `[Systems]: "${ctor.name}" was registered`);
+    const meta = getSystemMetadata(ctor);
+    this.logger.debug(() => `[Systems]: system "${meta.name}" was registered`);
   }
   build() {
     this.buildSystemsArray();
@@ -413,55 +415,41 @@ var ComponentStorage = class {
   }
 };
 
-// src/ecs/components/singleton-storage.ts
-var SingletonStorage = class {
-  constructor(factory) {
-    this.factory = factory;
-  }
-  factory;
-  value = null;
-  entityId = null;
-  bitmap() {
-    throw new Error("Singletone component cannot has a bitmap!");
-  }
-  add(id2, initFn) {
-    if (this.value !== null)
-      throw new Error("Singleton already initiated");
-    this.entityId = id2;
-    this.value = this.factory();
-    initFn?.(this.value);
-    return this.value;
-  }
-  remove(id2) {
-    if (!this.validateId(id2))
-      return;
-    this.value = null;
-    this.entityId = null;
-  }
-  get(id2) {
-    if (!this.validateId(id2))
-      return null;
-    return this.value;
-  }
-  tryGet(id2) {
-    if (!this.validateId(id2))
-      throw new Error("[SingletoneStorage]: ID missmatch.");
-    return this.value;
-  }
-  has(id2) {
-    return this.validateId(id2);
-  }
-  size() {
-    return this.value !== null ? 1 : 0;
-  }
-  forEach(cb) {
-    if (this.entityId !== null)
-      cb(this.entityId);
+// 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}`);
   }
-  validateId(id2) {
-    return this.entityId !== null && id2 === this.entityId;
+  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 {
@@ -470,9 +458,11 @@ var ComponentAlreadyRegisteredError = class extends Error {
   }
 };
 var ComponentsManager = class {
-  constructor(maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
+  constructor(logger, maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
+    this.logger = logger;
     this.maxEntityCount = maxEntityCount;
   }
+  logger;
   maxEntityCount;
   storages_ = /* @__PURE__ */ new Map();
   currId_ = 0;
@@ -482,19 +472,10 @@ var ComponentsManager = class {
   register(component, opts) {
     if (this.storages_.has(component))
       return this.storages_.get(component);
-    let store;
-    switch (opts?.storageType) {
-      case 2 /* SINGLETON_STORAGE */:
-        store = this.createSingletonStore(opts);
-        break;
-      case 1 /* COMPONENT_STORAGE */:
-        store = this.createComponentStore(component, opts);
-        break;
-      default:
-        store = this.createComponentStore(component, opts);
-        break;
-    }
+    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) {
@@ -503,12 +484,6 @@ var ComponentsManager = class {
     store._internalSetId(this.nextId());
     return store;
   }
-  createSingletonStore(opts) {
-    if (!opts?.factory) {
-      throw new Error("For singletone storage provide factory is required!");
-    }
-    return new SingletonStorage(opts.factory);
-  }
   getStorage(component) {
     const store = this.storages_.get(component);
     if (store === void 0)
@@ -520,24 +495,30 @@ var ComponentsManager = class {
   }
 };
 
-// src/ecs/components/utils.ts
-var registry = /* @__PURE__ */ new Map();
-var id = 0;
-function Component() {
+// src/ecs/resources/resources.ts
+var ResourceMetadataSymbol = /* @__PURE__ */ Symbol("resource");
+function Resource(params) {
   return (target) => {
-    if (registry.has(target)) return;
-    registry.set(target, ++id);
+    const metadata = {
+      name: params.name
+    };
+    target[ResourceMetadataSymbol] = metadata;
   };
 }
-function getComponentId(ctor) {
-  const id2 = registry.get(ctor);
-  if (id2 === void 0) {
-    throw new Error(`Component not registered: ${ctor.name}`);
+var ErrNotResource = class extends Error {
+  constructor(ctor) {
+    super(`Class ${ctor.name} is not a Resource. Use @Resource decorator to define resources.`);
   }
-  return id2;
+};
+function getResourceMetadata(resource) {
+  if (isResource(resource)) {
+    return resource[ResourceMetadataSymbol];
+  }
+  throw new ErrNotResource(resource);
+}
+function isResource(ctor) {
+  return ResourceMetadataSymbol in ctor;
 }
-
-// src/ecs/resources/resources.ts
 var ResourcesManager = class {
   constructor(logger) {
     this.logger = logger;
@@ -546,13 +527,15 @@ var ResourcesManager = class {
   items_ = /* @__PURE__ */ new Map();
   insert(type, value) {
     this.items_.set(type, value);
-    this.logger.debug(() => `[Resources]: Inserted new Resource "${type.name}"`);
+    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 ${type.name} does not exist!`);
+      throw new Error(`Resource of class ${meta.name} does not exist!`);
     return value;
   }
   getOrInsert(type, factory) {
@@ -564,7 +547,8 @@ var ResourcesManager = class {
     return value;
   }
   remove(type) {
-    this.logger.debug(() => `[Resources]: Removed resource "${type.name}"`);
+    const meta = getResourceMetadata(type);
+    this.logger.debug(() => `[Resources]: Removed resource "${meta.name}"`);
     this.items_.delete(type);
   }
 };
@@ -598,7 +582,10 @@ var Commands = class {
       }
     };
     this.add(cmd);
-    this.logger.debug(() => `[Commands.createEntity]: Created new entity with ID ${id2}. Linked components: [${entries.map((x) => x[0].name).join(", ")}]`);
+    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;
   }
 };
@@ -798,14 +785,14 @@ var PluginsManager = class {
     if (!isPlugin(plugin))
       throw new ErrMissingPluginMetadata(plugin);
     const metadata = getPluginMetadata(plugin);
-    if (this.plugins_.has(metadata.id))
+    if (this.plugins_.has(plugin))
       return;
     const entry2 = {
       ctor: plugin,
       ctorParams: constructorProps,
       metadata
     };
-    this.plugins_.set(metadata.id, entry2);
+    this.plugins_.set(plugin, entry2);
     this.logger.debug(() => `[Plugins]: Installed plugin ${metadata.name} (${metadata.version})`);
   }
   build() {
@@ -816,15 +803,15 @@ var PluginsManager = class {
     for (const id2 of this.plugins_.keys()) {
       nodes.set(id2, new DAGNode(id2));
     }
-    for (const [id2, entry2] of this.plugins_) {
-      const node = nodes.get(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.id);
+        const depNode = nodes.get(dep.plugin);
         if (!depNode) {
-          throw new ErrMissingPluginDependency(id2, dep.id);
+          throw new ErrMissingPluginDependency(plugin, dep.plugin);
         }
-        node.vertices.push(depNode);
+        depNode.vertices.push(node);
       }
     }
     let sortedNodes;
@@ -854,20 +841,18 @@ var PluginsManager = class {
       p.instance?.onAfterWorldInit?.(world);
     }
   }
-  getPluginMetadata(pluginOrId) {
-    const id2 = this.resolveId(pluginOrId);
-    const entry2 = this.plugins_.get(id2);
-    if (!entry2) throw new ErrUnknownPlugin(id2);
+  getPluginMetadata(plugin) {
+    const entry2 = this.plugins_.get(plugin);
+    if (!entry2) throw new ErrUnknownPlugin(plugin);
     return entry2.metadata;
   }
-  getPluginInstance(pluginOrId) {
+  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 Error("Plugin instance is not initiated yet. Use PluginManager.build() before use plugins.");
+      throw new ErrPluginNotInit(plugin);
     }
-    const id2 = this.resolveId(pluginOrId);
-    const entry2 = this.plugins_.get(id2);
-    if (!entry2) throw new ErrUnknownPlugin(id2);
-    if (!entry2.instance) throw new ErrPluginNotInit(id2);
     return entry2.instance;
   }
   resolveId(pluginOrId) {
@@ -893,9 +878,13 @@ var World3 = class {
   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.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT);
+    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);
@@ -941,6 +930,7 @@ var World3 = class {
   update(clock) {
     this.systems.update(clock.getTime());
     this.commands.flush(this);
+    this.updatesCount_++;
   }
   build() {
     this.plugins.build();
@@ -1235,9 +1225,9 @@ export {
   PluginBase,
   PluginError,
   PluginsManager,
+  Resource,
   ResourcesManager,
   Runtime,
-  SingletonStorage,
   System,
   SystemBase,
   SystemError,
@@ -1249,6 +1239,7 @@ export {
   createEventKey,
   entry,
   getPluginMetadata,
+  getResourceMetadata,
   getSystemMetadata,
   isPlugin,
   isSystem,