@draug/engine 1.0.16 → 1.0.18

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;
@@ -90,7 +104,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 +157,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 +172,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,16 +242,25 @@ 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;
 }
 
+type WorldConstructor = {
+    maxEntityCount?: number;
+    logger: Logger;
+};
 declare class World {
     readonly entities: EntitiesManager;
     readonly components: ComponentsManager;
@@ -242,8 +270,9 @@ declare class World {
     readonly commands: Commands;
     readonly queries: QueryManager;
     readonly plugins: PluginsManager;
+    private readonly logger;
     private entityRefs_;
-    constructor(maxEntityCount?: number);
+    constructor(params: WorldConstructor);
     getEntityRef(id: number): EntityRef;
     query(params: QueryParameters): number[];
     removeComponent<T extends object>(ref: EntityRef, component: ComponentType<T>): void;
@@ -311,11 +340,17 @@ type SystemCtor<T extends SystemBase = SystemBase> = ClassType<T>;
  */
 type SystemComputeContext = {
     /** Entity IDs from the query for this {@link SystemBase.compute} invocation. */
-    entities: number[];
+    readonly entities: number[];
     /** ECS world instance. */
-    world: World;
+    readonly world: World;
     /** Delta time (seconds or your engine's convention) since the previous update. */
-    dt: number;
+    readonly dt: number;
+    /** Logger instance for debugging and diagnostics. */
+    readonly logger: Logger;
+};
+type SystemInitContext = {
+    world: World;
+    logger: Logger;
 };
 /**
  * Base class for ECS systems executed by {@link SystemsManager}.
@@ -329,15 +364,16 @@ declare abstract class SystemBase {
      * Logic for one systems pass: run for all entities in {@link SystemComputeContext.entities}.
      */
     abstract compute(ctx: SystemComputeContext): void;
-    onInit?(world: World): void;
+    onInit?(ctx: SystemInitContext): void;
 }
 declare class SystemsManager {
     private readonly world;
+    private readonly logger;
     private systems_;
     private executionOrder_;
     private requiredComponents_;
     private dirty_;
-    constructor(world: World);
+    constructor(world: World, logger: Logger);
     getRequiredComponents(): ComponentType[];
     register<T extends SystemBase>(sys: T): void;
     build(): void;
@@ -364,20 +400,19 @@ declare class Clock {
 type StepFunction = (dt: number, world: World) => void;
 type PlatformLoop = (callback: () => void) => void;
 declare class Loop {
-    private readonly world;
     private readonly clock;
     private readonly stepFn;
     private readonly platformLoop;
     private running;
-    constructor(world: World, clock: Clock, stepFn: StepFunction, platformLoop: PlatformLoop);
-    start(): void;
+    constructor(clock: Clock, stepFn: StepFunction, platformLoop: PlatformLoop);
+    start(world: World): void;
     stop(): void;
 }
 
 declare class Runtime {
     private readonly loop;
     constructor(loop: Loop);
-    run(): void;
+    run(world: World): void;
 }
 
 declare enum VisitedState {
@@ -457,14 +492,16 @@ declare class AssetsManager {
 
 type EngineConstructor = {
     loop: Loop;
+    logger?: Logger;
 };
 declare class Engine {
     readonly runtime: Runtime;
-    readonly world: World;
     readonly assets: AssetsManager;
+    readonly world: World;
+    readonly logger: Logger;
     constructor(params: EngineConstructor);
     init(): void;
     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, Loop, ObjectPool, Plugin, PluginBase, type PluginDependencies, PluginError, type PluginID, type PluginMetadata, PluginsManager, ResourcesManager, Runtime, SingletonStorage, type StepFunction, System, SystemBase, type SystemComputeContext, SystemError, 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, 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 };

package/dist/index.js

@@ -94,10 +94,12 @@ function isSystem(ctor) {
 var SystemBase = class {
 };
 var SystemsManager = class {
-  constructor(world) {
+  constructor(world, logger) {
     this.world = world;
+    this.logger = logger;
   }
   world;
+  logger;
   systems_ = /* @__PURE__ */ new Map();
   executionOrder_ = [];
   requiredComponents_ = /* @__PURE__ */ new Set();
@@ -119,11 +121,15 @@ 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.buildSystemsArray();
-    for (const sys of this.systems_.values())
-      sys.onInit?.(this.world);
+    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();
@@ -141,7 +147,12 @@ var SystemsManager = class {
     for (const s of this.executionOrder_) {
       const { query } = getSystemMetadata(s.constructor);
       const entities = this.world.query(query);
-      s.compute({ entities, world: this.world, dt });
+      s.compute({
+        world: this.world,
+        entities,
+        dt,
+        logger: this.logger
+      });
     }
   }
   buildSystemsArray() {
@@ -195,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 {
@@ -504,9 +521,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) {
@@ -519,11 +541,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);
   }
 };
@@ -534,10 +557,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);
@@ -555,6 +580,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;
   }
 };
@@ -744,6 +770,10 @@ var ErrDAGCycleDetectedPlugin = class extends Error {
   }
 };
 var PluginsManager = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
   plugins_ = /* @__PURE__ */ new Map();
   isInitiated_ = false;
   install(plugin, ...constructorProps) {
@@ -758,6 +788,7 @@ var PluginsManager = class {
       metadata
     };
     this.plugins_.set(metadata.id, entry2);
+    this.logger.debug(() => `[Plugins]: Installed plugin ${metadata.name} (${metadata.version})`);
   }
   build() {
     const nodes = /* @__PURE__ */ new Map();
@@ -792,7 +823,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);
@@ -827,17 +862,26 @@ var PluginsManager = class {
 
 // src/ecs/world.ts
 var World3 = class {
-  entities = new EntitiesManager();
-  components = new ComponentsManager();
-  systems = new SystemsManager(this);
-  events = new EventBus();
-  resources = new ResourcesManager();
-  commands = new Commands(this);
-  queries = new QueryManager(this);
-  plugins = new PluginsManager();
+  entities;
+  components;
+  systems;
+  events;
+  resources;
+  commands;
+  queries;
+  plugins;
+  logger;
   entityRefs_ = /* @__PURE__ */ new Map();
-  constructor(maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
-    this.components = new ComponentsManager(maxEntityCount);
+  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.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);
@@ -879,6 +923,18 @@ var World3 = class {
   }
   build() {
     this.plugins.build();
+    this.logger.debug(() => "World was built successfully");
+  }
+};
+
+// src/runtime/runtime.ts
+var Runtime = class {
+  constructor(loop) {
+    this.loop = loop;
+  }
+  loop;
+  run(world) {
+    this.loop.start(world);
   }
 };
 
@@ -909,23 +965,21 @@ var Clock = class {
 
 // src/runtime/loop.ts
 var Loop = class {
-  constructor(world, clock, stepFn, platformLoop) {
-    this.world = world;
+  constructor(clock, stepFn, platformLoop) {
     this.clock = clock;
     this.stepFn = stepFn;
     this.platformLoop = platformLoop;
   }
-  world;
   clock;
   stepFn;
   platformLoop;
   running = false;
-  start() {
+  start(world) {
     this.running = true;
     const loop = () => {
       if (!this.running) return;
       this.clock.tick();
-      this.stepFn(this.clock.dt, this.world);
+      this.stepFn(this.clock.dt, world);
       this.platformLoop(loop);
     };
     this.platformLoop(loop);
@@ -935,17 +989,6 @@ var Loop = class {
   }
 };
 
-// src/runtime/runtime.ts
-var Runtime = class {
-  constructor(loop) {
-    this.loop = loop;
-  }
-  loop;
-  run() {
-    this.loop.start();
-  }
-};
-
 // src/assets/assets.ts
 var AssetState = /* @__PURE__ */ ((AssetState2) => {
   AssetState2[AssetState2["NOT_READY"] = 1] = "NOT_READY";
@@ -1092,21 +1135,43 @@ var AssetsManager = class {
   }
 };
 
+// src/logger/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 1] = "Info";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var NoopLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+
 // src/engine.ts
 var Engine = class {
   runtime;
+  assets = new AssetsManager();
   world;
-  assets;
+  logger;
   constructor(params) {
-    this.world = new World3();
     this.runtime = new Runtime(params.loop);
-    this.assets = new AssetsManager();
+    this.logger = params.logger ?? new NoopLogger();
+    this.world = new World3({
+      logger: this.logger
+    });
   }
   init() {
     this.world.build();
   }
   start() {
-    this.runtime.run();
+    this.runtime.run(this.world);
   }
 };
 export {
@@ -1134,6 +1199,7 @@ export {
   ErrUnknownPlugin,
   EventBuffer,
   EventBus,
+  LogLevel,
   Loop,
   ObjectPool,
   Plugin,