@yagejs/debug 0.1.0

package/dist/index.cjs

@@ -0,0 +1,655 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DebugPlugin: () => DebugPlugin,
+  DebugRegistryImpl: () => DebugRegistryImpl,
+  StatsStore: () => StatsStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/DebugPlugin.ts
+var import_core3 = require("@yagejs/core");
+
+// src/types.ts
+var import_core = require("@yagejs/core");
+var DebugRegistryKey = new import_core.ServiceKey("debugRegistry");
+
+// src/DebugPlugin.ts
+var import_renderer = require("@yagejs/renderer");
+
+// src/DebugClock.ts
+var DebugClock = class {
+  constructor(gameLoop, stopTicker, startTicker, render) {
+    this.gameLoop = gameLoop;
+    this.stopTicker = stopTicker;
+    this.startTicker = startTicker;
+    this.render = render;
+  }
+  gameLoop;
+  stopTicker;
+  startTicker;
+  render;
+  static {
+    __name(this, "DebugClock");
+  }
+  _isManual = false;
+  get isManual() {
+    return this._isManual;
+  }
+  startAuto() {
+    if (!this._isManual) return;
+    this.startTicker();
+    this._isManual = false;
+  }
+  stopAuto() {
+    if (this._isManual) return;
+    this.stopTicker();
+    this._isManual = true;
+  }
+  step(dtMs) {
+    if (!this._isManual) {
+      throw new Error(
+        "Manual clock is not active. Call clock.stopAuto() first."
+      );
+    }
+    const dt = dtMs ?? this.gameLoop.fixedTimestep;
+    this.gameLoop.tick(dt);
+    this.render();
+  }
+  stepFrames(count, dtMs) {
+    if (!Number.isInteger(count) || count < 0) {
+      throw new Error(
+        "stepFrames(count) requires a non-negative integer count."
+      );
+    }
+    for (let i = 0; i < count; i++) {
+      this.step(dtMs);
+    }
+  }
+  /** Enter or exit manual mode. Used by DebugPlugin for config-driven init. */
+  setManual(enabled) {
+    if (enabled === this._isManual) return;
+    if (enabled) {
+      this.stopTicker();
+    } else {
+      this.startTicker();
+    }
+    this._isManual = enabled;
+  }
+};
+
+// src/DebugRegistryImpl.ts
+var DebugRegistryImpl = class {
+  static {
+    __name(this, "DebugRegistryImpl");
+  }
+  contributors = /* @__PURE__ */ new Map();
+  enabled = false;
+  flags = /* @__PURE__ */ new Map();
+  register(contributor) {
+    if (this.contributors.has(contributor.name)) return;
+    this.contributors.set(contributor.name, contributor);
+    for (const flag of contributor.flags) {
+      this.flags.set(`${contributor.name}.${flag}`, true);
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isFlagEnabled(contributorName, flag) {
+    return this.flags.get(`${contributorName}.${flag}`) ?? true;
+  }
+  toggle() {
+    this.enabled = !this.enabled;
+  }
+  toggleFlag(contributorName, flag) {
+    const key = `${contributorName}.${flag}`;
+    this.flags.set(key, !(this.flags.get(key) ?? true));
+  }
+  setFlag(contributorName, flag, value) {
+    this.flags.set(`${contributorName}.${flag}`, value);
+  }
+};
+
+// src/StatsStore.ts
+var WINDOW_SIZE = 120;
+var StatsStore = class {
+  static {
+    __name(this, "StatsStore");
+  }
+  rings = /* @__PURE__ */ new Map();
+  push(key, value) {
+    let ring = this.rings.get(key);
+    if (!ring) {
+      ring = { data: new Float64Array(WINDOW_SIZE), count: 0, index: 0 };
+      this.rings.set(key, ring);
+    }
+    ring.data[ring.index] = value;
+    ring.index = (ring.index + 1) % WINDOW_SIZE;
+    if (ring.count < WINDOW_SIZE) ring.count++;
+  }
+  average(key) {
+    const ring = this.rings.get(key);
+    if (!ring || ring.count === 0) return 0;
+    const { data, count } = ring;
+    let sum = 0;
+    for (let i = 0; i < count; i++) sum += data[i] ?? 0;
+    return sum / count;
+  }
+  latest(key) {
+    const ring = this.rings.get(key);
+    if (!ring || ring.count === 0) return 0;
+    return ring.data[(ring.index - 1 + WINDOW_SIZE) % WINDOW_SIZE] ?? 0;
+  }
+  min(key) {
+    const ring = this.rings.get(key);
+    if (!ring || ring.count === 0) return 0;
+    const { data, count } = ring;
+    let m = Infinity;
+    for (let i = 0; i < count; i++) {
+      const v = data[i] ?? 0;
+      if (v < m) m = v;
+    }
+    return m;
+  }
+  max(key) {
+    const ring = this.rings.get(key);
+    if (!ring || ring.count === 0) return 0;
+    const { data, count } = ring;
+    let m = -Infinity;
+    for (let i = 0; i < count; i++) {
+      const v = data[i] ?? 0;
+      if (v > m) m = v;
+    }
+    return m;
+  }
+};
+
+// src/GraphicsPool.ts
+var import_pixi = require("pixi.js");
+var GraphicsPool = class {
+  static {
+    __name(this, "GraphicsPool");
+  }
+  pool = null;
+  index = 0;
+  container;
+  maxSize;
+  constructor(container, maxSize = 256) {
+    this.container = container;
+    this.maxSize = maxSize;
+  }
+  /** Lazily create Graphics objects on first use (ensures PixiJS is fully ready). */
+  ensure() {
+    if (this.pool) return this.pool;
+    this.pool = [];
+    for (let i = 0; i < this.maxSize; i++) {
+      const g = new import_pixi.Graphics();
+      g.visible = false;
+      g.eventMode = "none";
+      this.container.addChild(g);
+      this.pool.push(g);
+    }
+    return this.pool;
+  }
+  /** Return the next available Graphics, or undefined if the pool is exhausted. */
+  acquire() {
+    const pool = this.ensure();
+    if (this.index >= pool.length) return void 0;
+    const g = pool[this.index];
+    g.visible = true;
+    this.index++;
+    return g;
+  }
+  /** Clear and hide all previously acquired graphics, reset index. */
+  resetFrame() {
+    if (!this.pool) return;
+    for (let i = 0; i < this.index; i++) {
+      const g = this.pool[i];
+      g.clear();
+      g.visible = false;
+      g.position.set(0, 0);
+      g.rotation = 0;
+      g.scale.set(1, 1);
+    }
+    this.index = 0;
+  }
+  destroy() {
+    if (!this.pool) return;
+    for (const g of this.pool) {
+      g.destroy();
+    }
+    this.pool.length = 0;
+  }
+};
+
+// src/TextPool.ts
+var import_pixi2 = require("pixi.js");
+var LINE_HEIGHT = 16;
+var FONT_SIZE = 14;
+var PADDING = 4;
+var TextPool = class {
+  static {
+    __name(this, "TextPool");
+  }
+  pool = null;
+  index = 0;
+  container;
+  maxLines;
+  constructor(container, maxLines = 32) {
+    this.container = container;
+    this.maxLines = maxLines;
+  }
+  /** Lazily create Text objects on first use (ensures PixiJS is fully ready). */
+  ensure() {
+    if (this.pool) return this.pool;
+    this.pool = [];
+    for (let i = 0; i < this.maxLines; i++) {
+      const t = new import_pixi2.Text({
+        text: "",
+        style: {
+          fontFamily: "monospace",
+          fontSize: FONT_SIZE,
+          fill: 16777215
+        }
+      });
+      t.visible = false;
+      t.eventMode = "none";
+      this.container.addChild(t);
+      this.pool.push(t);
+    }
+    return this.pool;
+  }
+  /** Show a text line at the next available slot. */
+  addLine(text) {
+    const pool = this.ensure();
+    if (this.index >= pool.length) return;
+    const t = pool[this.index];
+    t.text = text;
+    t.visible = true;
+    t.position.set(PADDING, PADDING + this.index * LINE_HEIGHT);
+    this.index++;
+  }
+  /** Hide all lines and reset for the next frame. */
+  resetFrame() {
+    if (!this.pool) return;
+    for (let i = 0; i < this.index; i++) {
+      this.pool[i].visible = false;
+    }
+    this.index = 0;
+  }
+  destroy() {
+    if (!this.pool) return;
+    for (const t of this.pool) {
+      t.destroy();
+    }
+    this.pool.length = 0;
+  }
+};
+
+// src/WorldDebugApiImpl.ts
+var WorldDebugApiImpl = class {
+  constructor(pool, registry, _camera) {
+    this.pool = pool;
+    this.registry = registry;
+    this._camera = _camera;
+  }
+  pool;
+  registry;
+  _camera;
+  static {
+    __name(this, "WorldDebugApiImpl");
+  }
+  _contributorName = "";
+  /** Set the current contributor name (called before each contributor's drawWorld). */
+  setContributor(name) {
+    this._contributorName = name;
+  }
+  acquireGraphics() {
+    return this.pool.acquire();
+  }
+  isFlagEnabled(flag) {
+    return this.registry.isFlagEnabled(this._contributorName, flag);
+  }
+  get cameraZoom() {
+    return this._camera.zoom;
+  }
+};
+
+// src/HudDebugApiImpl.ts
+var HudDebugApiImpl = class {
+  constructor(textPool, registry, screenWidth, screenHeight) {
+    this.textPool = textPool;
+    this.registry = registry;
+    this.screenWidth = screenWidth;
+    this.screenHeight = screenHeight;
+  }
+  textPool;
+  registry;
+  screenWidth;
+  screenHeight;
+  static {
+    __name(this, "HudDebugApiImpl");
+  }
+  _contributorName = "";
+  /** Set the current contributor name (called before each contributor's drawHud). */
+  setContributor(name) {
+    this._contributorName = name;
+  }
+  addLine(text) {
+    this.textPool.addLine(text);
+  }
+  isFlagEnabled(flag) {
+    return this.registry.isFlagEnabled(this._contributorName, flag);
+  }
+};
+
+// src/DebugRenderSystem.ts
+var import_core2 = require("@yagejs/core");
+var DebugRenderSystem = class extends import_core2.System {
+  constructor(registry, graphicsPool, textPool, worldApi, hudApi, stats, worldContainer, hudContainer) {
+    super();
+    this.registry = registry;
+    this.graphicsPool = graphicsPool;
+    this.textPool = textPool;
+    this.worldApi = worldApi;
+    this.hudApi = hudApi;
+    this.stats = stats;
+    this.worldContainer = worldContainer;
+    this.hudContainer = hudContainer;
+  }
+  registry;
+  graphicsPool;
+  textPool;
+  worldApi;
+  hudApi;
+  stats;
+  worldContainer;
+  hudContainer;
+  static {
+    __name(this, "DebugRenderSystem");
+  }
+  phase = import_core2.Phase.Render;
+  priority = 9999;
+  update(dt) {
+    if (!this.registry.enabled) {
+      this.worldContainer.visible = false;
+      this.hudContainer.visible = false;
+      return;
+    }
+    this.worldContainer.visible = true;
+    this.hudContainer.visible = true;
+    this.graphicsPool.resetFrame();
+    this.textPool.resetFrame();
+    for (const [name, contributor] of this.registry.contributors) {
+      contributor.sample?.(this.stats, dt);
+      if (contributor.drawWorld) {
+        this.worldApi.setContributor(name);
+        contributor.drawWorld(this.worldApi);
+      }
+      if (contributor.drawHud) {
+        this.hudApi.setContributor(name);
+        contributor.drawHud(this.hudApi);
+      }
+    }
+  }
+};
+
+// src/contributors/FpsContributor.ts
+var FpsContributor = class {
+  static {
+    __name(this, "FpsContributor");
+  }
+  name = "fps";
+  flags = [];
+  stats = null;
+  sample(stats, dt) {
+    this.stats = stats;
+    if (dt > 0) stats.push("fps", 1e3 / dt);
+  }
+  drawHud(api) {
+    const avg = this.stats?.average("fps") ?? 0;
+    api.addLine(`FPS: ${Math.round(avg)}`);
+  }
+};
+
+// src/contributors/EntityCountContributor.ts
+var EntityCountContributor = class {
+  constructor(inspector) {
+    this.inspector = inspector;
+  }
+  inspector;
+  static {
+    __name(this, "EntityCountContributor");
+  }
+  name = "entities";
+  flags = [];
+  drawHud(api) {
+    const count = this.inspector.snapshot().entityCount;
+    api.addLine(`Entities: ${count}`);
+  }
+};
+
+// src/contributors/SystemTimingContributor.ts
+var SystemTimingContributor = class {
+  constructor(timings) {
+    this.timings = timings;
+  }
+  timings;
+  static {
+    __name(this, "SystemTimingContributor");
+  }
+  name = "timing";
+  flags = ["breakdown"];
+  stats = null;
+  sample(stats) {
+    this.stats = stats;
+    for (const [name, ms] of this.timings) {
+      stats.push(`system.${name}`, ms);
+    }
+  }
+  drawHud(api) {
+    if (!this.stats) return;
+    let total = 0;
+    const entries = [];
+    for (const name of this.timings.keys()) {
+      const avg = this.stats.average(`system.${name}`);
+      total += avg;
+      entries.push([name, avg]);
+    }
+    api.addLine(`Systems: ${total.toFixed(2)}ms`);
+    if (api.isFlagEnabled("breakdown")) {
+      entries.sort((a, b) => b[1] - a[1]);
+      for (const [name, avg] of entries) {
+        api.addLine(`  ${name}: ${avg.toFixed(2)}ms`);
+      }
+    }
+  }
+};
+
+// src/DebugPlugin.ts
+var DebugPlugin = class {
+  static {
+    __name(this, "DebugPlugin");
+  }
+  name = "debug";
+  version = "2.0.0";
+  dependencies = ["renderer"];
+  config;
+  registry;
+  stats;
+  graphicsPool;
+  textPool;
+  worldContainer;
+  hudContainer;
+  worldApi;
+  hudApi;
+  systemTimings = /* @__PURE__ */ new Map();
+  originalUpdates = /* @__PURE__ */ new Map();
+  keyListener = null;
+  context;
+  renderer;
+  clock = null;
+  constructor(config) {
+    this.config = config ?? {};
+  }
+  install(context) {
+    this.context = context;
+    this.renderer = context.resolve(import_renderer.RendererKey);
+    const camera = context.resolve(import_renderer.CameraKey);
+    const worldLayers = context.resolve(import_renderer.RenderLayerManagerKey);
+    const debugLayer = worldLayers.getOrCreate("debug", 999999);
+    this.worldContainer = debugLayer.container;
+    this.worldContainer.eventMode = "none";
+    const hudLayers = this.renderer.createScreenContainer("debug-hud");
+    this.hudContainer = hudLayers.defaultLayer.container;
+    this.hudContainer.eventMode = "none";
+    this.graphicsPool = new GraphicsPool(
+      this.worldContainer,
+      this.config.maxGraphics
+    );
+    this.textPool = new TextPool(this.hudContainer, this.config.maxHudLines);
+    this.registry = new DebugRegistryImpl();
+    this.registry.enabled = this.config.startEnabled ?? false;
+    if (this.config.flags) {
+      for (const [key, value] of Object.entries(this.config.flags)) {
+        const dot = key.indexOf(".");
+        if (dot > 0) {
+          this.registry.setFlag(key.slice(0, dot), key.slice(dot + 1), value);
+        }
+      }
+    }
+    this.stats = new StatsStore();
+    this.worldApi = new WorldDebugApiImpl(
+      this.graphicsPool,
+      this.registry,
+      camera
+    );
+    this.hudApi = new HudDebugApiImpl(
+      this.textPool,
+      this.registry,
+      camera.viewportWidth,
+      camera.viewportHeight
+    );
+    context.register(DebugRegistryKey, this.registry);
+  }
+  registerSystems(scheduler) {
+    scheduler.add(
+      new DebugRenderSystem(
+        this.registry,
+        this.graphicsPool,
+        this.textPool,
+        this.worldApi,
+        this.hudApi,
+        this.stats,
+        this.worldContainer,
+        this.hudContainer
+      )
+    );
+  }
+  onStart() {
+    const toggleKey = this.config.toggleKey ?? "Backquote";
+    const stepKey = this.config.stepKey ?? "Period";
+    this.keyListener = (e) => {
+      if (e.code === toggleKey) {
+        this.registry.toggle();
+        return;
+      }
+      if (e.code === stepKey && this.clock?.isManual) {
+        e.preventDefault();
+        this.clock.step();
+      }
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("keydown", this.keyListener);
+    }
+    const scheduler = this.context.resolve(import_core3.SystemSchedulerKey);
+    for (const system of scheduler.getAllSystems()) {
+      if (system instanceof DebugRenderSystem) continue;
+      const name = system.constructor.name;
+      const original = system.update.bind(system);
+      this.originalUpdates.set(system, original);
+      system.update = (dt) => {
+        const t0 = performance.now();
+        original(dt);
+        this.systemTimings.set(name, performance.now() - t0);
+      };
+    }
+    const inspector = this.context.resolve(import_core3.InspectorKey);
+    this.registry.register(new FpsContributor());
+    this.registry.register(new EntityCountContributor(inspector));
+    this.registry.register(new SystemTimingContributor(this.systemTimings));
+    const gameLoop = this.context.resolve(import_core3.GameLoopKey);
+    const app = this.renderer.application;
+    this.clock = new DebugClock(
+      gameLoop,
+      () => app.stop(),
+      () => app.start(),
+      () => app.render()
+    );
+    if (this.config.manualClock) {
+      this.clock.setManual(true);
+    }
+    this.attachToGlobal(this.clock);
+  }
+  onDestroy() {
+    for (const [system, original] of this.originalUpdates) {
+      system.update = original;
+    }
+    this.originalUpdates.clear();
+    if (this.keyListener) {
+      if (typeof window !== "undefined") {
+        window.removeEventListener("keydown", this.keyListener);
+      }
+      this.keyListener = null;
+    }
+    this.detachFromGlobal();
+    this.clock = null;
+    for (const contributor of this.registry.contributors.values()) {
+      contributor.dispose?.();
+    }
+    this.registry.contributors.clear();
+    this.graphicsPool.destroy();
+    this.textPool.destroy();
+    this.renderer.destroyScreenContainer("debug-hud");
+  }
+  attachToGlobal(clock) {
+    const g = globalThis["__yage__"];
+    if (g && typeof g === "object") {
+      g["clock"] = clock;
+    }
+  }
+  detachFromGlobal() {
+    const g = globalThis["__yage__"];
+    if (g && typeof g === "object" && g["clock"] === this.clock) {
+      delete g["clock"];
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DebugPlugin,
+  DebugRegistryImpl,
+  StatsStore
+});
+//# sourceMappingURL=index.cjs.map