dopaminejs 2.1.0 → 2.3.0

package/dist/engine.js

@@ -0,0 +1,1158 @@
+class a {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map(), this._onceListeners = /* @__PURE__ */ new Map(), this._sortedCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register an event listener
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @param {number} priority - Higher priority = called first (default: 0)
+   * @returns {EventBus} - For chaining
+   */
+  on(e, t, s = 0) {
+    return this._listeners.has(e) || this._listeners.set(e, /* @__PURE__ */ new Set()), this._listeners.get(e).add({ callback: t, priority: s }), this._sortedCache.delete(e), this;
+  }
+  /**
+   * Register a one-time event listener
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @returns {EventBus} - For chaining
+   */
+  once(e, t) {
+    return this._onceListeners.has(e) || this._onceListeners.set(e, /* @__PURE__ */ new Set()), this._onceListeners.get(e).add(t), this;
+  }
+  /**
+   * Remove an event listener
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function to remove
+   * @returns {EventBus} - For chaining
+   */
+  off(e, t) {
+    const s = this._listeners.get(e);
+    if (s)
+      for (const r of [...s])
+        r.callback === t && (s.delete(r), this._sortedCache.delete(e));
+    const i = this._onceListeners.get(e);
+    return i && i.delete(t), this;
+  }
+  /**
+   * Emit an event to all registered listeners
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+  emit(e, t) {
+    const s = this._getSortedListeners(e);
+    for (let r = 0; r < s.length; r++)
+      this._invoke(s[r].callback, t, e);
+    const i = this._onceListeners.get(e);
+    if (i && i.size > 0) {
+      const r = [...i];
+      i.clear();
+      for (const n of r)
+        this._invoke(n, t, e);
+    }
+  }
+  /**
+   * Call one listener without letting it abort the dispatch.
+   *
+   * A throwing listener used to take out every lower-priority listener for
+   * that event, which on 'tick' means the game silently stops updating.
+   *
+   * @private
+   */
+  _invoke(e, t, s) {
+    try {
+      e(t);
+    } catch (i) {
+      console.error(`[DopamineJS] Listener for "${s}" threw:`, i);
+    }
+  }
+  /**
+   * Get sorted listeners for an event (with caching)
+   * @private
+   */
+  _getSortedListeners(e) {
+    if (this._sortedCache.has(e))
+      return this._sortedCache.get(e);
+    const t = this._listeners.get(e);
+    if (!t || t.size === 0)
+      return [];
+    const s = Array.from(t).sort((i, r) => r.priority - i.priority);
+    return this._sortedCache.set(e, s), s;
+  }
+  /**
+   * Remove all listeners for an event, or all events if no event specified
+   * @param {string} [event] - Event name (optional)
+   */
+  clear(e) {
+    e ? (this._listeners.delete(e), this._onceListeners.delete(e), this._sortedCache.delete(e)) : (this._listeners.clear(), this._onceListeners.clear(), this._sortedCache.clear());
+  }
+  /**
+   * Check if an event has listeners
+   * @param {string} event - Event name
+   * @returns {boolean}
+   */
+  hasListeners(e) {
+    const t = this._listeners.get(e), s = this._onceListeners.get(e);
+    return !!t?.size || !!s?.size;
+  }
+}
+a.Events = {
+  // Core game loop events
+  TICK: "tick",
+  FIXED_UPDATE: "fixed_update",
+  RENDER: "render",
+  // Physics events
+  COLLISION_ENTER: "collision_enter",
+  COLLISION_EXIT: "collision_exit",
+  // Dopamine events (from RewardSystem)
+  XP_GAINED: "xp_gained",
+  LEVEL_UP: "level_up",
+  ACHIEVEMENT_UNLOCKED: "achievement_unlocked",
+  NEW_HIGH_SCORE: "new_high_score",
+  STREAK_UPDATED: "streak_updated",
+  // System lifecycle events
+  SYSTEM_REGISTERED: "system_registered",
+  SYSTEM_UNREGISTERED: "system_unregistered",
+  PLUGIN_LOADED: "plugin_loaded",
+  PLUGIN_UNLOADED: "plugin_unloaded"
+};
+class g {
+  constructor(e) {
+    this.kernel = e, this._systems = /* @__PURE__ */ new Map(), this._updateOrder = [], this._fixedUpdateOrder = [], this._needsRecompute = !1, this._failed = /* @__PURE__ */ new WeakSet();
+  }
+  /**
+   * Run one system's update without letting a throw stop the others.
+   * @private
+   */
+  _run(e, t, s) {
+    try {
+      e[t](s);
+    } catch (i) {
+      this._failed.has(e) || (this._failed.add(e), console.error(`[SystemRegistry] System ${t}() threw:`, i));
+    }
+  }
+  /**
+   * Register a system
+   * @param {string} name - Unique system name
+   * @param {Object} system - System instance (must implement ISystem interface)
+   * @param {Object} options - Configuration options
+   * @param {number} options.priority - Update priority (higher = earlier, default: 0)
+   * @param {string[]} options.dependencies - System names this depends on
+   * @returns {SystemRegistry} - For chaining
+   */
+  register(e, t, { priority: s = 0, dependencies: i = [] } = {}) {
+    this._systems.has(e) && (console.warn(`[SystemRegistry] System "${e}" already registered. Replacing.`), this.unregister(e));
+    for (const r of i)
+      this._systems.has(r) || console.warn(`[SystemRegistry] Dependency "${r}" not found for system "${e}"`);
+    return this._systems.set(e, {
+      system: t,
+      priority: s,
+      dependencies: i
+    }), t.init && t.init(this.kernel), this._needsRecompute = !0, this.kernel.events.emit("system_registered", { name: e, system: t }), this;
+  }
+  /**
+   * Get a system by name
+   * @param {string} name - System name
+   * @returns {Object|undefined} - System instance
+   */
+  get(e) {
+    const t = this._systems.get(e);
+    return t ? t.system : void 0;
+  }
+  /**
+   * Check if a system is registered
+   * @param {string} name - System name
+   * @returns {boolean}
+   */
+  has(e) {
+    return this._systems.has(e);
+  }
+  /**
+   * Unregister a system
+   * @param {string} name - System name
+   * @returns {boolean} - True if system was found and removed
+   */
+  unregister(e) {
+    const t = this._systems.get(e);
+    if (!t)
+      return !1;
+    try {
+      t.system.destroy && t.system.destroy();
+    } finally {
+      this._systems.delete(e), this._needsRecompute = !0, this.kernel.events.emit("system_unregistered", { name: e });
+    }
+    return !0;
+  }
+  /**
+   * Update all systems (called each frame)
+   * @param {number} dt - Delta time in seconds
+   */
+  update(e) {
+    this._needsRecompute && this._recomputeUpdateOrder();
+    for (let t = 0; t < this._updateOrder.length; t++) {
+      const s = this._updateOrder[t];
+      s.update && this._run(s, "update", e);
+    }
+  }
+  /**
+   * Fixed update for physics (called at fixed timestep)
+   * @param {number} dt - Fixed delta time
+   */
+  fixedUpdate(e) {
+    this._needsRecompute && this._recomputeUpdateOrder();
+    for (let t = 0; t < this._fixedUpdateOrder.length; t++) {
+      const s = this._fixedUpdateOrder[t];
+      s.fixedUpdate && this._run(s, "fixedUpdate", e);
+    }
+  }
+  /**
+   * Recompute the update order based on dependencies and priorities
+   * Uses topological sort for dependencies
+   * @private
+   */
+  _recomputeUpdateOrder() {
+    const e = Array.from(this._systems.entries()), t = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+    for (const [n, o] of e)
+      t.set(n, o.dependencies), s.set(n, 0);
+    for (const [n, o] of t)
+      for (const c of o)
+        s.has(c) && s.set(n, s.get(n) + 1);
+    const i = [], r = [];
+    for (const [n, o] of s)
+      o === 0 && i.push(n);
+    for (; i.length > 0; ) {
+      i.sort((o, c) => {
+        const d = this._systems.get(o).priority;
+        return this._systems.get(c).priority - d;
+      });
+      const n = i.shift();
+      r.push(n);
+      for (const [o, c] of t)
+        if (c.includes(n)) {
+          const d = s.get(o) - 1;
+          s.set(o, d), d === 0 && i.push(o);
+        }
+    }
+    r.length !== e.length && (console.error("[SystemRegistry] Circular dependency detected in systems!"), r.length = 0, r.push(...e.map(([n]) => n).sort((n, o) => this._systems.get(o).priority - this._systems.get(n).priority))), this._updateOrder = r.map((n) => this._systems.get(n).system).filter((n) => n.update), this._fixedUpdateOrder = r.map((n) => this._systems.get(n).system).filter((n) => n.fixedUpdate), this._needsRecompute = !1;
+  }
+  /**
+   * Get all registered system names
+   * @returns {string[]}
+   */
+  getSystemNames() {
+    return Array.from(this._systems.keys());
+  }
+  /**
+   * Clear all systems
+   */
+  clear() {
+    for (const e of this._systems.keys())
+      this.unregister(e);
+  }
+}
+class p {
+  constructor(e) {
+    this.kernel = e, this._plugins = /* @__PURE__ */ new Map(), this._loadOrder = [], this._inFlight = /* @__PURE__ */ new Set();
+  }
+  /**
+   * @private
+   */
+  _systemsSince(e) {
+    return this.kernel.systems.getSystemNames().filter((t) => !e.has(t));
+  }
+  /**
+   * Mark systems as belonging to a plugin that loaded.
+   * @private
+   */
+  _claim(e) {
+    for (const t of this._inFlight)
+      for (const s of e)
+        t.foreign.add(s);
+  }
+  /**
+   * Remove the systems a failed plugin registered. They would keep updating
+   * with nothing left to remove them.
+   * @private
+   */
+  _rollback(e) {
+    for (const t of e)
+      try {
+        this.kernel.systems.unregister(t);
+      } catch (s) {
+        console.error(`[PluginRegistry] Error removing system "${t}":`, s);
+      }
+  }
+  /**
+   * Forget a plugin whose init failed.
+   *
+   * Removed by name: with two async inits in flight, the failed plugin is
+   * not necessarily the last entry.
+   * @private
+   */
+  _forget(e) {
+    this._plugins.delete(e);
+    const t = this._loadOrder.indexOf(e);
+    t > -1 && this._loadOrder.splice(t, 1);
+  }
+  /**
+   * Register and initialize a plugin
+   * 
+   * Plugin interface:
+   * {
+   *   name: string,
+   *   version?: string,
+   *   init(kernel): void,
+   *   destroy?(): void
+   * }
+   * 
+   * @param {Object} plugin - Plugin instance
+   * @returns {PluginRegistry} - For chaining
+   */
+  use(e) {
+    if (!e.name)
+      throw new Error("[PluginRegistry] Plugin must have a name");
+    if (this._plugins.has(e.name))
+      return console.warn(`[PluginRegistry] Plugin "${e.name}" already registered. Skipping.`), this;
+    if (!e.init || typeof e.init != "function")
+      throw new Error(`[PluginRegistry] Plugin "${e.name}" must have an init() method`);
+    this._plugins.set(e.name, e), this._loadOrder.push(e.name);
+    const t = new Set(this.kernel.systems.getSystemNames());
+    try {
+      e.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
+        name: e.name,
+        version: e.version
+      }), this._claim(this._systemsSince(t));
+    } catch (s) {
+      throw console.error(`[PluginRegistry] Failed to initialize plugin "${e.name}":`, s), this._forget(e.name), this._rollback(this._systemsSince(t)), s;
+    }
+    return this;
+  }
+  /**
+   * Register and initialize a plugin asynchronously
+   * Useful for plugins that need to load external resources
+   * 
+   * @param {Object} plugin - Plugin instance with async init
+   * @returns {Promise<PluginRegistry>} - For chaining
+   */
+  async useAsync(e) {
+    if (!e.name)
+      throw new Error("[PluginRegistry] Plugin must have a name");
+    if (this._plugins.has(e.name))
+      return console.warn(`[PluginRegistry] Plugin "${e.name}" already registered. Skipping.`), this;
+    if (!e.init || typeof e.init != "function")
+      throw new Error(`[PluginRegistry] Plugin "${e.name}" must have an init() method`);
+    this._plugins.set(e.name, e), this._loadOrder.push(e.name);
+    const t = {
+      before: new Set(this.kernel.systems.getSystemNames()),
+      foreign: /* @__PURE__ */ new Set()
+    }, s = () => this._systemsSince(t.before).filter((i) => !t.foreign.has(i));
+    this._inFlight.add(t);
+    try {
+      await e.init(this.kernel), this._inFlight.delete(t), this._claim(s()), this.kernel.events.emit("plugin_loaded", {
+        name: e.name,
+        version: e.version
+      });
+    } catch (i) {
+      console.error(`[PluginRegistry] Failed to initialize plugin "${e.name}":`, i), this._inFlight.delete(t), this._forget(e.name);
+      const r = s();
+      throw this._inFlight.size === 0 ? this._rollback(r) : r.length > 0 && console.warn(`[PluginRegistry] Left systems in place after "${e.name}" failed: ${r.join(", ")}`), i;
+    }
+    return this;
+  }
+  /**
+   * Remove a plugin
+   * @param {string} name - Plugin name
+   * @returns {boolean} - True if plugin was found and removed
+   */
+  remove(e) {
+    const t = this._plugins.get(e);
+    if (!t)
+      return !1;
+    if (t.destroy)
+      try {
+        t.destroy();
+      } catch (i) {
+        console.error(`[PluginRegistry] Error destroying plugin "${e}":`, i);
+      }
+    this._plugins.delete(e);
+    const s = this._loadOrder.indexOf(e);
+    return s > -1 && this._loadOrder.splice(s, 1), this.kernel.events.emit("plugin_unloaded", { name: e }), !0;
+  }
+  /**
+   * Get a plugin by name
+   * @param {string} name - Plugin name
+   * @returns {Object|undefined} - Plugin instance
+   */
+  get(e) {
+    return this._plugins.get(e);
+  }
+  /**
+   * Check if a plugin is registered
+   * @param {string} name - Plugin name
+   * @returns {boolean}
+   */
+  has(e) {
+    return this._plugins.has(e);
+  }
+  /**
+   * Get all registered plugin names
+   * @returns {string[]}
+   */
+  getPluginNames() {
+    return Array.from(this._plugins.keys());
+  }
+  /**
+   * Get plugin load order
+   * @returns {string[]}
+   */
+  getLoadOrder() {
+    return [...this._loadOrder];
+  }
+  /**
+   * Clear all plugins (in reverse load order)
+   */
+  clear() {
+    for (let e = this._loadOrder.length - 1; e >= 0; e--)
+      this.remove(this._loadOrder[e]);
+  }
+}
+class k {
+  constructor(e = {}) {
+    this.width = e.width || 800, this.height = e.height || 600, this.backgroundColor = e.backgroundColor || "#000000", e.canvas ? (this.canvas = e.canvas, this.canvas.width = this.width, this.canvas.height = this.height) : (this.canvas = document.createElement("canvas"), this.canvas.width = this.width, this.canvas.height = this.height, (e.parent ? typeof e.parent == "string" ? document.querySelector(e.parent) : e.parent : document.body).appendChild(this.canvas)), this.ctx = this.canvas.getContext("2d");
+  }
+  /**
+   * Clear the canvas.
+   */
+  clear() {
+    this.ctx.fillStyle = this.backgroundColor, this.ctx.fillRect(0, 0, this.width, this.height);
+  }
+  resize(e, t) {
+    this.width = e, this.height = t, this.canvas.width = e, this.canvas.height = t;
+  }
+}
+class w {
+  constructor() {
+    this.running = !1, this.lastTime = 0, this.callbacks = /* @__PURE__ */ new Set(), this._frameHandle = null, this._tick = this._tick.bind(this), this._failed = /* @__PURE__ */ new WeakSet();
+  }
+  /**
+   * Add a callback to the loop.
+   * @param {Function} callback - Function to call each frame (receives dt).
+   */
+  add(e) {
+    this.callbacks.add(e);
+  }
+  /**
+   * Remove a callback from the loop.
+   * @param {Function} callback 
+   */
+  remove(e) {
+    this.callbacks.delete(e);
+  }
+  /**
+   * Start the loop.
+   */
+  start() {
+    this.running || (this.running = !0, this.lastTime = performance.now(), this._frameHandle !== null && cancelAnimationFrame(this._frameHandle), this._frameHandle = requestAnimationFrame(this._tick));
+  }
+  /**
+   * Stop the loop.
+   */
+  stop() {
+    this.running = !1, this._frameHandle !== null && (cancelAnimationFrame(this._frameHandle), this._frameHandle = null);
+  }
+  _tick(e) {
+    if (this._frameHandle = null, !this.running) return;
+    const t = (e - this.lastTime) / 1e3;
+    this.lastTime = e;
+    const s = Math.max(0, Math.min(t, 0.1));
+    for (const i of [...this.callbacks])
+      try {
+        i(s);
+      } catch (r) {
+        this._failed.has(i) || (this._failed.add(i), console.error("[Ticker] Callback threw:", r));
+      }
+    this.running && (this._frameHandle = requestAnimationFrame(this._tick));
+  }
+}
+function u(h, e) {
+  let t = !1;
+  return new Proxy(h, {
+    get(s, i, r) {
+      t || (t = !0, console.warn(e));
+      const n = Reflect.get(s, i, r);
+      return typeof n == "function" ? n.bind(s) : n;
+    },
+    set(s, i, r) {
+      return t || (t = !0, console.warn(e)), Reflect.set(s, i, r);
+    }
+  });
+}
+class l {
+  constructor() {
+    this.gameObject = null, this.kernel = null;
+  }
+  /**
+   * Access systems through kernel (no more globals!)
+   */
+  get physics() {
+    return this.kernel?.systems.get("physics");
+  }
+  get input() {
+    return this.kernel?.systems.get("input");
+  }
+  get loader() {
+    return this.kernel?.systems.get("loader");
+  }
+  get events() {
+    return this.kernel?.events;
+  }
+  onAttach() {
+  }
+  onDetach() {
+  }
+  update(e) {
+  }
+  render(e) {
+  }
+}
+class b extends l {
+  constructor(e = "box", t = 50, s = 50, i = 25) {
+    super(), this.type = e, this.width = t, this.height = s, this.radius = i, this.tag = null;
+  }
+  get kernel() {
+    return this._kernel ?? null;
+  }
+  /**
+   * The kernel can arrive after onAttach(), when the collider was added to
+   * an object before that object joined a scene. Registering only in
+   * onAttach() left such colliders out of physics for good.
+   */
+  set kernel(e) {
+    e !== this._kernel && (this._unregister(), this._kernel = e, this._register());
+  }
+  onAttach() {
+    super.onAttach(), this._attached = !0, this._register();
+  }
+  onDetach() {
+    super.onDetach(), this._attached = !1, this._unregister();
+  }
+  /**
+   * @private
+   */
+  _register() {
+    if (this._physics || !this._attached) return;
+    const e = this.physics;
+    e && (e.add(this), this._physics = e);
+  }
+  /**
+   * @private
+   */
+  _unregister() {
+    this._physics && (this._physics.remove(this), this._physics = null);
+  }
+  getBounds() {
+    const e = this.gameObject;
+    if (this.type === "box")
+      return {
+        left: e.x - this.width / 2,
+        right: e.x + this.width / 2,
+        top: e.y - this.height / 2,
+        bottom: e.y + this.height / 2
+      };
+    if (this.type === "circle")
+      return {
+        x: e.x,
+        y: e.y,
+        radius: this.radius
+      };
+  }
+}
+class m {
+  constructor() {
+    this.colliders = [], this.kernel = null;
+  }
+  /**
+   * ISystem interface - called when registered
+   */
+  init(e) {
+    this.kernel = e;
+  }
+  /**
+   * ISystem interface - called at fixed timestep
+   */
+  fixedUpdate(e) {
+    this.step();
+  }
+  /**
+   * ISystem interface - cleanup
+   */
+  destroy() {
+    this.colliders = [];
+  }
+  add(e) {
+    this.colliders.push(e);
+  }
+  remove(e) {
+    const t = this.colliders.indexOf(e);
+    t > -1 && this.colliders.splice(t, 1);
+  }
+  /**
+   * Main Physics Step.
+   * Checks all pairs and triggers callbacks.
+   */
+  step() {
+    for (let e = 0; e < this.colliders.length; e++)
+      for (let t = e + 1; t < this.colliders.length; t++) {
+        const s = this.colliders[e], i = this.colliders[t];
+        this._intersects(s, s.getBounds(), i, i.getBounds()) && (this._notifyCollision(s.gameObject, i.gameObject), this._notifyCollision(i.gameObject, s.gameObject));
+      }
+  }
+  _notifyCollision(e, t) {
+    !e || !e.components || e.components.forEach((s) => {
+      s.onCollisionEnter && s.onCollisionEnter(t);
+    });
+  }
+  /**
+   * Check if a specific collider overlaps with anything in the target group (tag).
+   * @param {Collider} source 
+   * @param {string} targetTag 
+   */
+  checkOverlap(e, t) {
+    const s = [], i = e.getBounds();
+    for (const r of this.colliders) {
+      if (r === e || t && r.tag !== t) continue;
+      const n = r.getBounds();
+      this._intersects(e, i, r, n) && s.push(r);
+    }
+    return s;
+  }
+  _intersects(e, t, s, i) {
+    if (e.type === "box" && s.type === "box")
+      return t.left < i.right && t.right > i.left && t.top < i.bottom && t.bottom > i.top;
+    if (e.type === "circle" && s.type === "circle") {
+      const r = t.x - i.x, n = t.y - i.y;
+      return Math.sqrt(r * r + n * n) < t.radius + i.radius;
+    }
+    return !1;
+  }
+  // IPhysicsSystem interface methods (for plugin compatibility)
+  addBody(e) {
+    this.add(e);
+  }
+  removeBody(e) {
+    this.remove(e);
+  }
+  checkCollision(e, t) {
+    return this._intersects(e, e.getBounds(), t, t.getBounds());
+  }
+  raycast(e, t, s) {
+    return null;
+  }
+  setGravity(e, t) {
+  }
+}
+const O = u(
+  new m(),
+  "[DopamineJS] GlobalPhysics is deprecated. Use kernel.physics instead."
+);
+class f {
+  constructor() {
+    this.keys = /* @__PURE__ */ new Map(), this.mouse = { x: 0, y: 0, buttons: /* @__PURE__ */ new Map() }, this.kernel = null, this._onKeyDown = this._onKeyDown.bind(this), this._onKeyUp = this._onKeyUp.bind(this), this._onMouseMove = this._onMouseMove.bind(this), this._onMouseDown = this._onMouseDown.bind(this), this._onMouseUp = this._onMouseUp.bind(this);
+  }
+  /**
+   * ISystem interface - called when registered
+   */
+  init(e) {
+    this.kernel = e, window.addEventListener("keydown", this._onKeyDown), window.addEventListener("keyup", this._onKeyUp), window.addEventListener("mousemove", this._onMouseMove), window.addEventListener("mousedown", this._onMouseDown), window.addEventListener("mouseup", this._onMouseUp);
+  }
+  /**
+   * ISystem interface - cleanup
+   */
+  destroy() {
+    window.removeEventListener("keydown", this._onKeyDown), window.removeEventListener("keyup", this._onKeyUp), window.removeEventListener("mousemove", this._onMouseMove), window.removeEventListener("mousedown", this._onMouseDown), window.removeEventListener("mouseup", this._onMouseUp);
+  }
+  _onKeyDown(e) {
+    this.keys.set(e.key, !0);
+  }
+  _onKeyUp(e) {
+    this.keys.set(e.key, !1);
+  }
+  _onMouseMove(e) {
+    this.mouse.x = e.clientX, this.mouse.y = e.clientY;
+  }
+  _onMouseDown(e) {
+    this.mouse.buttons.set(e.button, !0);
+  }
+  _onMouseUp(e) {
+    this.mouse.buttons.set(e.button, !1);
+  }
+  isKeyDown(e) {
+    return this.keys.get(e) || !1;
+  }
+  isMouseButtonDown(e = 0) {
+    return this.mouse.buttons.get(e) || !1;
+  }
+}
+const M = u(
+  new f(),
+  "[DopamineJS] GlobalInput is deprecated. Use kernel.input instead."
+);
+class y {
+  constructor() {
+    this.assets = /* @__PURE__ */ new Map(), this.kernel = null;
+  }
+  /**
+   * ISystem interface - called when registered
+   */
+  init(e) {
+    this.kernel = e;
+  }
+  /**
+   * ISystem interface - cleanup
+   */
+  destroy() {
+    this.assets.clear();
+  }
+  async loadImage(e, t) {
+    return new Promise((s, i) => {
+      const r = new Image();
+      r.onload = () => {
+        this.assets.set(e, r), s(r);
+      }, r.onerror = i, r.src = t;
+    });
+  }
+  get(e) {
+    return this.assets.get(e);
+  }
+}
+const C = u(
+  new y(),
+  "[DopamineJS] GlobalLoader is deprecated. Use kernel.loader instead."
+);
+class x {
+  constructor(e = {}) {
+    this.config = e, this._boundUpdate = this._update.bind(this), this.events = new a(), this.systems = new g(this), this.plugins = new p(this), this._registerCoreSystems(e), this.fixedTimestep = e.fixedTimestep || 1 / 60, this._accumulator = 0, this._maxAccumulator = this.fixedTimestep * 5;
+  }
+  /**
+   * Register core engine systems
+   * These can be replaced by plugins
+   * @private
+   */
+  _registerCoreSystems(e) {
+    this.systems.register("ticker", new w(), {
+      priority: 100
+    });
+    const t = {
+      width: e.width,
+      height: e.height,
+      backgroundColor: e.backgroundColor,
+      canvas: e.canvas,
+      ...e.renderer
+    };
+    this.systems.register("renderer", new k(t), {
+      priority: 90
+    }), this.systems.register("input", new f(), {
+      priority: 80
+    }), this.systems.register("loader", new y(), {
+      priority: 70
+    }), this.systems.register("physics", new m(), {
+      priority: 60
+    });
+  }
+  /**
+   * Start the kernel (begins game loop)
+   */
+  start() {
+    const e = this.systems.get("ticker");
+    e && (e.add(this._boundUpdate), e.start()), this.events.emit("kernel_started");
+  }
+  /**
+   * Stop the kernel
+   */
+  stop() {
+    const e = this.systems.get("ticker");
+    e && e.stop(), this.events.emit("kernel_stopped");
+  }
+  /**
+   * Main update loop
+   * @private
+   */
+  _update(e) {
+    for (this.events.emit(a.Events.TICK, { dt: e }), this._accumulator += e, this._accumulator > this._maxAccumulator && (this._accumulator = this._maxAccumulator); this._accumulator >= this.fixedTimestep; )
+      this.events.emit(a.Events.FIXED_UPDATE, { dt: this.fixedTimestep }), this.systems.fixedUpdate(this.fixedTimestep), this._accumulator -= this.fixedTimestep;
+    this.systems.update(e), this.events.emit(a.Events.RENDER, { dt: e });
+  }
+  /**
+   * Shorthand accessors for common systems (backward compatibility)
+   */
+  get physics() {
+    return this.systems.get("physics");
+  }
+  get input() {
+    return this.systems.get("input");
+  }
+  get loader() {
+    return this.systems.get("loader");
+  }
+  get renderer() {
+    return this.systems.get("renderer");
+  }
+  get ticker() {
+    return this.systems.get("ticker");
+  }
+  /**
+   * Destroy the kernel and cleanup all systems
+   */
+  destroy() {
+    this.stop();
+    const e = this.systems.get("ticker");
+    e && e.remove(this._boundUpdate), this.plugins.clear(), this.systems.clear(), this.events.clear();
+  }
+}
+class D {
+  constructor() {
+    this.gameObjects = [], this._kernel = null;
+  }
+  get kernel() {
+    return this._kernel;
+  }
+  /**
+   * Objects added before the scene had a kernel receive it here. Scenes are
+   * often built in a constructor, before Game.setScene() injects the kernel.
+   * The Director sets it to null on exit, which takes colliders out of
+   * physics until the scene runs again.
+   */
+  set kernel(e) {
+    this._kernel = e;
+    for (const t of this.gameObjects)
+      t.kernel = e;
+  }
+  /**
+   * Called when the scene is added to the Game.
+   */
+  onEnter() {
+  }
+  /**
+   * Called when the scene is removed from the Game.
+   */
+  onExit() {
+  }
+  /**
+   * Add a GameObject to the scene.
+   * @param {GameObject} gameObject 
+   */
+  add(e) {
+    return this.kernel && (e.kernel = this.kernel), e._detached && (e._detached = !1, this._eachComponent(e, (t) => t.onAttach())), this.gameObjects.push(e), e;
+  }
+  /**
+   * Remove a GameObject from the scene.
+   * @param {GameObject} gameObject 
+   */
+  remove(e) {
+    const t = this.gameObjects.indexOf(e);
+    t > -1 && (this.gameObjects.splice(t, 1), e._detached = !0, this._eachComponent(e, (s) => s.onDetach()));
+  }
+  /**
+   * Visit the components of an object and of all its children.
+   * @private
+   */
+  _eachComponent(e, t) {
+    for (const s of [...e.components])
+      t(s);
+    for (const s of e.children)
+      this._eachComponent(s, t);
+  }
+  /**
+   * Update loop for the scene.
+   * @param {number} dt 
+   */
+  update(e) {
+    for (const t of [...this.gameObjects])
+      t._detached || t.update(e);
+  }
+  /**
+   * Render loop for the scene.
+   * @param {CanvasRenderingContext2D} ctx 
+   */
+  render(e) {
+    for (const t of [...this.gameObjects])
+      t._detached || t.render(e);
+  }
+}
+class v {
+  constructor(e) {
+    this.game = e, this.currentScene = null;
+  }
+  /**
+   * Switch to a new scene.
+   * @param {Scene} scene 
+   */
+  run(e) {
+    this.currentScene && (this.currentScene.onExit(), this.currentScene.kernel = null), this.currentScene = e, this.currentScene.game = this.game, this.game?.kernel && (e.kernel = this.game.kernel), this.game.scene = e, e.onEnter();
+  }
+}
+class L {
+  constructor(e = {}) {
+    this.config = e, this.kernel = new x(e), this.director = new v(this), this.kernel.systems.register("director", this.director), this.kernel.events.on(a.Events.TICK, this._update.bind(this), 10), this.kernel.events.on(a.Events.RENDER, this._render.bind(this), 10);
+  }
+  /**
+   * Backward compatibility accessors
+   */
+  get renderer() {
+    return this.kernel.renderer;
+  }
+  get ticker() {
+    return this.kernel.ticker;
+  }
+  get physics() {
+    return this.kernel.physics;
+  }
+  get input() {
+    return this.kernel.input;
+  }
+  /**
+   * Start the game loop.
+   */
+  start() {
+    this.kernel.start();
+  }
+  /**
+   * Stop the game loop.
+   */
+  stop() {
+    this.kernel.stop();
+  }
+  /**
+   * Switch to a new scene.
+   * @param {Scene} newScene 
+   */
+  setScene(e) {
+    e.kernel = this.kernel, this.director.run(e);
+  }
+  _update({ dt: e }) {
+    this.director.currentScene && this.director.currentScene.update(e);
+  }
+  _render({ dt: e }) {
+    this.renderer.clear(), this.director.currentScene && this.director.currentScene.render(this.renderer.ctx);
+  }
+  /**
+   * Destroy the game and cleanup
+   */
+  destroy() {
+    this.kernel.destroy();
+  }
+}
+class R {
+  constructor(e = 0, t = 0) {
+    this.x = e, this.y = t, this.rotation = 0, this.scale = { x: 1, y: 1 }, this.components = [], this.children = [], this.parent = null, this._kernel = null;
+  }
+  get kernel() {
+    return this._kernel;
+  }
+  set kernel(e) {
+    this._kernel = e;
+    for (const t of this.components)
+      t.kernel = e;
+    for (const t of this.children)
+      t.kernel = e;
+  }
+  /**
+   * Add a child object.
+   * @param {GameObject} child 
+   */
+  addChild(e) {
+    return e.parent = this, e.kernel = this.kernel, this.children.push(e), e;
+  }
+  /**
+   * Add a component.
+   * @param {Component} component 
+   */
+  addComponent(e) {
+    return e.gameObject = this, e.kernel = this.kernel, this.components.push(e), e.onAttach(), e;
+  }
+  /**
+   * Get a component by class type.
+   * @param {class} type 
+   */
+  getComponent(e) {
+    return this.components.find((t) => t instanceof e);
+  }
+  update(e) {
+    for (const t of this.components)
+      t.update && t.update(e);
+    for (const t of this.children)
+      t.update(e);
+  }
+  render(e) {
+    e.save(), e.translate(this.x, this.y), e.rotate(this.rotation), e.scale(this.scale.x, this.scale.y);
+    for (const t of this.components)
+      t.render && t.render(e);
+    for (const t of this.children)
+      t.render(e);
+    e.restore();
+  }
+}
+class _ {
+  constructor(e = 0, t = 0) {
+    this.x = e, this.y = t;
+  }
+  add(e) {
+    return this.x += e.x, this.y += e.y, this;
+  }
+  sub(e) {
+    return this.x -= e.x, this.y -= e.y, this;
+  }
+  scale(e) {
+    return this.x *= e, this.y *= e, this;
+  }
+  distance(e) {
+    const t = this.x - e.x, s = this.y - e.y;
+    return Math.sqrt(t * t + s * s);
+  }
+  normalize() {
+    const e = Math.sqrt(this.x * this.x + this.y * this.y);
+    return e > 0 && (this.x /= e, this.y /= e), this;
+  }
+  clone() {
+    return new _(this.x, this.y);
+  }
+  static distance(e, t) {
+    return Math.sqrt(Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2));
+  }
+}
+class E extends l {
+  constructor(e) {
+    super(), this.image = e, this.anchor = { x: 0.5, y: 0.5 }, this.width = e ? e.width : 0, this.height = e ? e.height : 0, this.frame = { x: 0, y: 0, w: this.width, h: this.height };
+  }
+  setFrame(e, t, s, i) {
+    this.frame = { x: e, y: t, w: s, h: i }, this.width = s, this.height = i;
+  }
+  setTexture(e) {
+    this.image = e, e && this.setFrame(0, 0, e.width, e.height);
+  }
+  render(e) {
+    if (!this.image) return;
+    const t = this.frame.w, s = this.frame.h, i = -t * this.anchor.x, r = -s * this.anchor.y;
+    e.drawImage(
+      this.image,
+      this.frame.x,
+      this.frame.y,
+      t,
+      s,
+      // Source
+      i,
+      r,
+      t,
+      s
+      // Destination
+    );
+  }
+}
+class P extends l {
+  constructor() {
+    super(), this.animations = {}, this.currentAnim = null, this.timer = 0, this.currentFrameIndex = 0, this.sprite = null;
+  }
+  onAttach() {
+    this.sprite = this.gameObject.getComponent(E), this.sprite || console.warn("Animator attached to GameObject without a Sprite component.");
+  }
+  addAnimation(e, t, s = 10, i = !0) {
+    this.animations[e] = { frames: t, fps: s, loop: i };
+  }
+  play(e) {
+    this.currentAnim && this.currentAnim.name === e || this.animations[e] && (this.currentAnim = { name: e, ...this.animations[e] }, this.currentFrameIndex = 0, this.timer = 0, this._updateFrame());
+  }
+  update(e) {
+    if (!this.currentAnim || !this.sprite) return;
+    this.timer += e;
+    const t = 1 / this.currentAnim.fps;
+    this.timer >= t && (this.timer -= t, this.currentFrameIndex++, this.currentFrameIndex >= this.currentAnim.frames.length && (this.currentAnim.loop ? this.currentFrameIndex = 0 : this.currentFrameIndex = this.currentAnim.frames.length - 1), this._updateFrame());
+  }
+  _updateFrame() {
+    const e = this.currentAnim.frames[this.currentFrameIndex];
+    this.sprite.setFrame(e.x, e.y, e.w, e.h);
+  }
+}
+class U extends l {
+  constructor(e) {
+    super(), this.system = e;
+  }
+  /**
+   * Trigger an effect at the GameObject's current position.
+   * @param {string} effectName - 'confetti', 'fire', 'sparkle', etc.
+   * @param {object} options - override options
+   */
+  play(e, t = {}) {
+    const s = this.gameObject.x, i = this.gameObject.y;
+    switch (e) {
+      case "confetti":
+        this.system.confetti(s, i, t.count);
+        break;
+      case "fire":
+        this.system.fire(s, i, t.count);
+        break;
+      case "sparkle":
+        this.system.sparkle(s, i, t.count, t.color);
+        break;
+      case "blood":
+        this.system.emit({
+          x: s,
+          y: i,
+          count: 10,
+          color: ["#8a0303", "#ff0000"],
+          speed: 4,
+          gravity: 0.1,
+          decay: 0.05
+        });
+        break;
+      default:
+        this.system.emit({
+          x: s,
+          y: i,
+          ...t
+        });
+    }
+  }
+}
+class A extends l {
+  constructor() {
+    super(), this.intensity = 0, this.duration = 0, this.timer = 0, this.originalPos = { x: 0, y: 0 }, this.isShaking = !1;
+  }
+  shake(e = 5, t = 0.2) {
+    this.isShaking || (this.originalPos.x = this.gameObject.x, this.originalPos.y = this.gameObject.y), this.intensity = e, this.duration = t, this.timer = 0, this.isShaking = !0;
+  }
+  update(e) {
+    if (!this.isShaking) return;
+    if (this.timer += e, this.timer >= this.duration) {
+      this.isShaking = !1, this.gameObject.x = this.originalPos.x, this.gameObject.y = this.originalPos.y;
+      return;
+    }
+    const t = (Math.random() - 0.5) * 2 * this.intensity, s = (Math.random() - 0.5) * 2 * this.intensity;
+    this.gameObject.x = this.originalPos.x + t, this.gameObject.y = this.originalPos.y + s;
+  }
+}
+export {
+  P as Animator,
+  b as Collider,
+  l as Component,
+  v as Director,
+  x as DopamineKernel,
+  a as EventBus,
+  L as Game,
+  R as GameObject,
+  M as GlobalInput,
+  C as GlobalLoader,
+  O as GlobalPhysics,
+  f as Input,
+  y as Loader,
+  U as ParticleEmitter,
+  m as Physics,
+  p as PluginRegistry,
+  k as Renderer,
+  D as Scene,
+  A as ScreenShake,
+  E as Sprite,
+  g as SystemRegistry,
+  w as Ticker,
+  _ as Vector2
+};