@draug/engine 1.0.17 → 1.0.19

package/dist/index.d.ts

@@ -3,6 +3,20 @@ import { Bitmap } from 'bitmap-index';
 type ClassType<T> = new (...args: any[]) => T;
 type ComponentType<T extends object = object> = ClassType<T>;
 
+declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3
+}
+type LogMessage = () => string;
+interface Logger {
+    debug(message: LogMessage): void;
+    info(message: LogMessage): void;
+    warn(message: LogMessage): void;
+    error(message: LogMessage): void;
+}
+
 interface IStorage<T extends object> {
     add(id: number, initFn?: (obj: T) => T): T;
     remove(id: number): void;
@@ -47,9 +61,12 @@ declare function Component(): ClassDecorator;
 
 declare class ComponentStorage<T extends object> implements IStorage<T> {
     private bits_;
-    private set_;
+    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;
@@ -61,7 +78,6 @@ declare class ComponentStorage<T extends object> implements IStorage<T> {
     tryGet(id: number): T;
     writeComponentsToBuf(ids: ReadonlyArray<number>, out: T[]): number;
     has(id: number): boolean;
-    entityIds(): number[];
     size(): number;
     forEach(cb: (id: number) => void): void;
 }
@@ -90,7 +106,9 @@ declare class EntityMaskNotFoundError extends Error {
     constructor(id: EntityID);
 }
 declare class EntitiesManager {
+    private readonly logger;
     private id_;
+    constructor(logger: Logger);
     private nextId;
     create(): EntityID;
 }
@@ -141,7 +159,9 @@ declare class EventBus {
 }
 
 declare class ResourcesManager {
+    private readonly logger;
     private readonly items_;
+    constructor(logger: Logger);
     insert<T extends object>(type: ClassType<T>, value: T): T;
     get<T extends object>(type: ClassType<T>): T;
     getOrInsert<T extends object>(type: ClassType<T>, factory: () => T): T;
@@ -154,8 +174,9 @@ type CreateEntityComponentEntry<T extends ComponentType = ComponentType> = T ext
 declare function entry<T extends ComponentType>(component: T, init?: ComponentInitFn<T>): CreateEntityComponentEntry;
 declare class Commands {
     private readonly world;
+    private readonly logger;
     private readonly commandsQueue_;
-    constructor(world: World);
+    constructor(world: World, logger: Logger);
     add(cmd: WorldCommand): void;
     flush(world: World): void;
     createEntity(...entries: CreateEntityComponentEntry[]): number;
@@ -223,28 +244,57 @@ declare class ErrPluginNotInit extends PluginError {
     constructor(pluginId: string);
 }
 declare class PluginsManager {
+    private readonly logger;
     private plugins_;
     private isInitiated_;
+    constructor(logger: Logger);
     install<T extends ClassType<PluginBase>>(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;
     private resolveId;
 }
 
-declare enum LogLevel {
-    Debug = 0,
-    Info = 1,
-    Warn = 2,
-    Error = 3
+interface TimeSource {
+    now(): number;
 }
-type LogMessage = () => string;
-interface Logger {
-    debug(message: LogMessage): void;
-    info(message: LogMessage): void;
-    warn(message: LogMessage): void;
-    error(message: LogMessage): void;
+declare class Clock {
+    private readonly timeSource_;
+    private lastTimeMs_;
+    private ellapsedTime_;
+    private delta_;
+    private readonly time_;
+    constructor(timeSource_: TimeSource);
+    get deltaMs(): number;
+    get ellapsedTime(): number;
+    tick(): void;
+    getTime(): Readonly<Time>;
+}
+type Time = {
+    delta: number;
+    elapsed: number;
+};
+
+type StepFunction = (dt: number, world: World) => void;
+type PlatformLoop = (callback: () => void) => void;
+declare class Loop {
+    private readonly clock;
+    private readonly stepFn;
+    private readonly platformLoop;
+    private running;
+    constructor(clock: Clock, stepFn: StepFunction, platformLoop: PlatformLoop);
+    start(world: World): void;
+    stop(): void;
+}
+
+declare class Runtime {
+    private readonly loop;
+    constructor(loop: Loop);
+    run(world: World): void;
 }
 
 type WorldConstructor = {
@@ -260,6 +310,7 @@ declare class World {
     readonly commands: Commands;
     readonly queries: QueryManager;
     readonly plugins: PluginsManager;
+    private readonly logger;
     private entityRefs_;
     constructor(params: WorldConstructor);
     getEntityRef(id: number): EntityRef;
@@ -268,7 +319,7 @@ declare class World {
     removeComponent<T extends object>(entity: EntityID, component: ComponentType<T>): void;
     addComponent<T extends object>(id: EntityID, component: ClassType<T>, initFn?: (obj: T) => void): T;
     addComponent<T extends object>(id: EntityRef, component: ClassType<T>, initFn?: (obj: T) => void): T;
-    update(dt: number): void;
+    update(clock: Clock): void;
     build(): void;
 }
 
@@ -333,7 +384,7 @@ type SystemComputeContext = {
     /** ECS world instance. */
     readonly world: World;
     /** Delta time (seconds or your engine's convention) since the previous update. */
-    readonly dt: number;
+    readonly time: Time;
     /** Logger instance for debugging and diagnostics. */
     readonly logger: Logger;
 };
@@ -368,42 +419,10 @@ declare class SystemsManager {
     build(): void;
     private rebuild;
     get<T extends SystemBase>(ctor: SystemCtor<T>): T;
-    update(dt: number): void;
+    update(time: Time): void;
     private buildSystemsArray;
 }
 
-interface TimeSource {
-    now(): number;
-}
-declare class Clock {
-    private readonly timeSource_;
-    private lastTimeMs_;
-    private elapsedTime_;
-    private dt_;
-    constructor(timeSource_: TimeSource);
-    get dt(): number;
-    get ellapsedTime(): number;
-    tick(): void;
-}
-
-type StepFunction = (dt: number, world: World) => void;
-type PlatformLoop = (callback: () => void) => void;
-declare class Loop {
-    private readonly clock;
-    private readonly stepFn;
-    private readonly platformLoop;
-    private running;
-    constructor(clock: Clock, stepFn: StepFunction, platformLoop: PlatformLoop);
-    start(world: World): void;
-    stop(): void;
-}
-
-declare class Runtime {
-    private readonly loop;
-    constructor(loop: Loop);
-    run(world: World): void;
-}
-
 declare enum VisitedState {
     Unvisited = 0,
     Visiting = 1,
@@ -482,6 +501,7 @@ declare class AssetsManager {
 type EngineConstructor = {
     loop: Loop;
     logger?: Logger;
+    maxEntityCount?: number;
 };
 declare class Engine {
     readonly runtime: Runtime;

package/dist/index.js

@@ -121,13 +121,14 @@ var SystemsManager = class {
       this.requiredComponents_.add(c);
     for (const c of requiredComponents)
       this.requiredComponents_.add(c);
+    this.logger.debug(() => `[Systems]: "${ctor.name}" was registered`);
   }
   build() {
-    this.logger.info(() => "Building systems...");
     this.buildSystemsArray();
-    for (const sys of this.systems_.values())
+    for (const sys of this.systems_.values()) {
       sys.onInit?.({ world: this.world, logger: this.logger });
-    this.logger.info(() => "Systems sucessfully was built!");
+    }
+    this.logger.debug(() => `Built ${this.systems_.size} systems`);
     this.dirty_ = false;
   }
   rebuild() {
@@ -139,7 +140,7 @@ var SystemsManager = class {
       throw new Error("System not registered");
     return s;
   }
-  update(dt) {
+  update(time) {
     if (this.dirty_)
       this.rebuild();
     this.world.events.swapAll();
@@ -149,7 +150,7 @@ var SystemsManager = class {
       s.compute({
         world: this.world,
         entities,
-        dt,
+        time,
         logger: this.logger
       });
     }
@@ -205,12 +206,18 @@ var EntityMaskNotFoundError = class extends Error {
   }
 };
 var EntitiesManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
   id_ = 0;
   nextId() {
     return ++this.id_;
   }
   create() {
-    return this.nextId();
+    const id2 = this.nextId();
+    this.logger.debug(() => `[Entities]: Created new entity with ID ${id2}`);
+    return id2;
   }
 };
 var EntityRef = class {
@@ -230,7 +237,7 @@ var EntityRef = class {
 
 // src/ecs/constant.ts
 var ECS_DEFAULTS = {
-  MAX_ENTITY_COUNT: Math.pow(2, 16)
+  MAX_ENTITY_COUNT: Math.pow(2, 12)
 };
 
 // src/ecs/events-buffer.ts
@@ -295,17 +302,16 @@ var ObjectPool = class {
   pool_;
   factory_;
   cursor_;
-  constructor(factory, initialSize = 1024) {
+  constructor(factory, initialSize = 0) {
     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_--];
+    if (this.cursor_ >= 0) {
+      return this.pool_[this.cursor_--];
+    }
+    return this.factory_();
   }
   release(obj) {
     this.pool_[++this.cursor_] = obj;
@@ -321,17 +327,18 @@ var ObjectPool = class {
 
 // src/ecs/components/component-storage.ts
 import { Bitmap } from "bitmap-index";
-import { SparseSet } from "ts-sparse-set";
 var ComponentStorage = class {
   bits_;
-  set_;
+  data_ = [];
+  entityIds_ = [];
+  indexMap_ = /* @__PURE__ */ new Map();
   pool_;
   id_ = 0;
+  size_ = 0;
   cls;
   constructor(cap = ECS_DEFAULTS.MAX_ENTITY_COUNT, factory, cls) {
-    this.set_ = new SparseSet(cap);
     this.bits_ = new Bitmap(cap);
-    this.pool_ = new ObjectPool(factory, cap);
+    this.pool_ = new ObjectPool(factory, 0);
     this.cls = cls;
   }
   bitmap() {
@@ -344,47 +351,65 @@ var ComponentStorage = class {
     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 value = this.set_.add(id2, obj);
+    const index = this.data_.length;
+    this.data_.push(obj);
+    this.entityIds_.push(id2);
+    this.indexMap_.set(id2, index);
     this.bits_.set(id2);
-    return value;
+    this.size_++;
+    return obj;
   }
   remove(id2) {
-    const obj = this.set_.get(id2);
-    if (!obj) return;
+    const index = this.indexMap_.get(id2);
+    if (index === void 0) return;
     this.bits_.remove(id2);
-    this.pool_.release(obj);
-    this.set_.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) {
-    return this.set_.get(id2);
+    const index = this.indexMap_.get(id2);
+    return index !== void 0 ? this.data_[index] : null;
   }
   tryGet(id2) {
-    const x = this.set_.get(id2);
-    if (!x)
+    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 x;
+    return this.data_[index];
   }
   writeComponentsToBuf(ids, out) {
     let len = 0;
     for (const id2 of ids) {
-      const obj = this.set_.get(id2);
-      if (obj !== null) out[len++] = obj;
+      const index = this.indexMap_.get(id2);
+      if (index !== void 0) out[len++] = this.data_[index];
     }
     return len;
   }
   has(id2) {
     return this.bits_.contains(id2);
   }
-  entityIds() {
-    return Array.from(this.bits_);
-  }
   size() {
-    return this.bits_.count();
+    return this.size_;
   }
   forEach(cb) {
-    this.bits_.range((x) => cb(x));
+    for (const id2 of this.entityIds_) {
+      cb(id2);
+    }
   }
 };
 
@@ -514,9 +539,14 @@ function getComponentId(ctor) {
 
 // src/ecs/resources/resources.ts
 var ResourcesManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
   items_ = /* @__PURE__ */ new Map();
   insert(type, value) {
     this.items_.set(type, value);
+    this.logger.debug(() => `[Resources]: Inserted new Resource "${type.name}"`);
     return value;
   }
   get(type) {
@@ -529,11 +559,12 @@ var ResourcesManager = class {
     let value = this.items_.get(type) ?? null;
     if (value === null) {
       value = factory();
-      this.items_.set(type, value);
+      this.insert(type, value);
     }
     return value;
   }
   remove(type) {
+    this.logger.debug(() => `[Resources]: Removed resource "${type.name}"`);
     this.items_.delete(type);
   }
 };
@@ -544,10 +575,12 @@ function entry(component, init = () => {
   return [component, init];
 }
 var Commands = class {
-  constructor(world) {
+  constructor(world, logger) {
     this.world = world;
+    this.logger = logger;
   }
   world;
+  logger;
   commandsQueue_ = [];
   add(cmd) {
     this.commandsQueue_.push(cmd);
@@ -565,6 +598,7 @@ 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(", ")}]`);
     return id2;
   }
 };
@@ -754,6 +788,10 @@ var ErrDAGCycleDetectedPlugin = class extends Error {
   }
 };
 var PluginsManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
   plugins_ = /* @__PURE__ */ new Map();
   isInitiated_ = false;
   install(plugin, ...constructorProps) {
@@ -768,8 +806,12 @@ var PluginsManager = class {
       metadata
     };
     this.plugins_.set(metadata.id, 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));
@@ -802,7 +844,11 @@ var PluginsManager = class {
       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);
@@ -845,16 +891,18 @@ var World3 = class {
   commands;
   queries;
   plugins;
+  logger;
   entityRefs_ = /* @__PURE__ */ new Map();
   constructor(params) {
+    this.entities = new EntitiesManager(params.logger);
     this.components = new ComponentsManager(params.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT);
     this.systems = new SystemsManager(this, params.logger);
-    this.entities = new EntitiesManager();
     this.events = new EventBus();
-    this.resources = new ResourcesManager();
-    this.commands = new Commands(this);
+    this.resources = new ResourcesManager(params.logger);
+    this.commands = new Commands(this, params.logger);
     this.queries = new QueryManager(this);
-    this.plugins = new PluginsManager();
+    this.plugins = new PluginsManager(params.logger);
+    this.logger = params.logger;
   }
   getEntityRef(id2) {
     let ref = this.entityRefs_.get(id2);
@@ -890,12 +938,13 @@ var World3 = class {
     this.queries.invalidate(component);
     return c;
   }
-  update(dt) {
-    this.systems.update(dt);
+  update(clock) {
+    this.systems.update(clock.getTime());
     this.commands.flush(this);
   }
   build() {
     this.plugins.build();
+    this.logger.debug(() => "World was built successfully");
   }
 };
 
@@ -918,21 +967,28 @@ var Clock = class {
   }
   timeSource_;
   lastTimeMs_;
-  elapsedTime_ = 0;
-  dt_ = 0;
-  get dt() {
-    return this.dt_;
+  ellapsedTime_ = 0;
+  delta_ = 0;
+  time_ = {
+    delta: 0,
+    elapsed: 0
+  };
+  get deltaMs() {
+    return this.delta_;
   }
   get ellapsedTime() {
-    return this.elapsedTime_;
+    return this.ellapsedTime_;
   }
   tick() {
     const now = this.timeSource_.now();
-    const dt = now - this.lastTimeMs_;
-    this.dt_ = dt;
-    this.elapsedTime_ += dt;
+    const dt = Math.min(now - this.lastTimeMs_, 100);
+    this.delta_ = this.time_.delta = dt / 1e3;
+    this.ellapsedTime_ = this.time_.elapsed += dt / 1e3;
     this.lastTimeMs_ = now;
   }
+  getTime() {
+    return this.time_;
+  }
 };
 
 // src/runtime/loop.ts
@@ -951,7 +1007,7 @@ var Loop = class {
     const loop = () => {
       if (!this.running) return;
       this.clock.tick();
-      this.stepFn(this.clock.dt, world);
+      this.stepFn(this.clock.deltaMs, world);
       this.platformLoop(loop);
     };
     this.platformLoop(loop);
@@ -1136,7 +1192,8 @@ var Engine = class {
     this.runtime = new Runtime(params.loop);
     this.logger = params.logger ?? new NoopLogger();
     this.world = new World3({
-      logger: this.logger
+      logger: this.logger,
+      maxEntityCount: params.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT
     });
   }
   init() {