dopaminejs 1.2.0 → 2.0.0

package/dist/dopamine.js

@@ -0,0 +1,1947 @@
+class M {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to an event
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @returns {Function} Unsubscribe function
+   */
+  on(t, e) {
+    return this.listeners.has(t) || this.listeners.set(t, /* @__PURE__ */ new Set()), this.listeners.get(t).add(e), () => this.off(t, e);
+  }
+  /**
+   * Unsubscribe from an event
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   */
+  off(t, e) {
+    this.listeners.has(t) && this.listeners.get(t).delete(e);
+  }
+  /**
+   * Emit an event
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+  emit(t, e) {
+    this.listeners.has(t) && this.listeners.get(t).forEach((s) => {
+      try {
+        s(e);
+      } catch (i) {
+        console.error(`Error in listener for event '${t}':`, i);
+      }
+    });
+  }
+  /**
+   * Clear all listeners
+   */
+  clear() {
+    this.listeners.clear();
+  }
+}
+class E extends M {
+  constructor(t, e = {}) {
+    super(), this.dataService = t, this.player = null, this.achievements = { ...this._initAchievements(), ...e.achievements || {} };
+  }
+  /**
+   * Initialize the reward system for current player
+   * @returns {Promise<Object>} Player data
+   */
+  async init() {
+    return this.player = await this.dataService.load("player", this._getDefaultPlayer()), this._updateDailyStreak(), await this.save(), this.player;
+  }
+  /**
+   * Get default player data structure
+   */
+  _getDefaultPlayer() {
+    return {
+      name: "Player",
+      xp: 0,
+      level: 1,
+      totalGamesPlayed: 0,
+      createdAt: Date.now(),
+      lastPlayedAt: Date.now(),
+      streak: {
+        current: 1,
+        longest: 1,
+        lastPlayDate: this._getTodayDateString()
+      },
+      achievements: {},
+      // achievement_id: { unlockedAt: timestamp, seen: boolean }
+      stats: {
+        // Dynamic stats object, games will add their own keys
+      }
+    };
+  }
+  /**
+   * Save player data
+   */
+  async save() {
+    this.player && (this.player.lastPlayedAt = Date.now(), await this.dataService.save("player", this.player));
+  }
+  /**
+   * Add XP and handle level ups
+   * @param {number} amount - XP to add
+   * @param {string} reason - Why XP was awarded (for notifications)
+   * @returns {Object} { leveledUp: boolean, newLevel: number, xpGained: number }
+   */
+  async addXP(t, e = "") {
+    const s = this.player.level;
+    this.player.xp += t;
+    const i = this._calculateLevel(this.player.xp), r = i > s;
+    return r && (this.player.level = i), await this.save(), this.emit("xp_gained", { amount: t, reason: e, leveledUp: r, newLevel: i }), r && this.emit("level_up", { oldLevel: s, newLevel: i }), { leveledUp: r, newLevel: i, xpGained: t };
+  }
+  /**
+   * Calculate level from XP (exponential curve)
+   */
+  _calculateLevel(t) {
+    const e = Math.floor((1 + Math.sqrt(1 + 8 * t / 50)) / 2);
+    return Math.max(1, e);
+  }
+  /**
+   * Get XP needed for next level
+   */
+  getXPForNextLevel() {
+    const t = this.player.level + 1, e = 50 * t * (t - 1), s = 50 * this.player.level * (this.player.level - 1);
+    return {
+      total: e,
+      needed: e - this.player.xp,
+      progress: (this.player.xp - s) / (e - s)
+    };
+  }
+  /**
+   * Record game result and award XP
+   * @param {string} gameName - Unique ID for the game
+   * @param {Object} result - Game-specific result data
+   */
+  async recordGame(t, e) {
+    this.player.stats[t] || (this.player.stats[t] = { totalPlays: 0, highScore: 0 });
+    const s = this.player.stats[t];
+    s.totalPlays++, this.player.totalGamesPlayed++, e.score !== void 0 && e.score > s.highScore && (s.highScore = e.score, this.emit("new_high_score", { gameName: t, score: e.score })), Object.keys(e).forEach((r) => {
+      r !== "score" && (s[r] = (s[r] || 0) + (typeof e[r] == "number" ? e[r] : 0));
+    });
+    let i = 10;
+    e.score && (i += Math.floor(e.score / 5)), i = Math.floor(i * this.getStreakMultiplier()), await this.addXP(i, `Played ${t}`), await this.checkAchievements(t, e), await this.save();
+  }
+  /**
+   * Check and unlock achievements
+   */
+  async checkAchievements(t, e) {
+    const s = [];
+    for (const [i, r] of Object.entries(this.achievements))
+      this.player.achievements[i] || r.check(this.player, t, e) && (await this.unlockAchievement(i), s.push(r));
+    return s;
+  }
+  /**
+   * Unlock an achievement
+   */
+  async unlockAchievement(t) {
+    const e = this.achievements[t];
+    return e ? (this.player.achievements[t] = {
+      unlockedAt: Date.now(),
+      seen: !1
+    }, await this.addXP(e.xp, `Achievement: ${e.name}`), this.emit("achievement_unlocked", e), await this.save(), !0) : !1;
+  }
+  /**
+   * Get all unlocked achievements
+   */
+  getUnlockedAchievements() {
+    return Object.entries(this.player.achievements).map(([t, e]) => ({
+      ...this.achievements[t],
+      id: t,
+      ...e
+    }));
+  }
+  /**
+   * Get achievements user hasn't seen the notification for yet
+   */
+  getUnseenAchievements() {
+    return this.getUnlockedAchievements().filter((t) => !t.seen);
+  }
+  /**
+   * Mark achievements as seen
+   */
+  async markAchievementsSeen(t) {
+    for (const e of t)
+      this.player.achievements[e] && (this.player.achievements[e].seen = !0);
+    await this.save();
+  }
+  /**
+   * Update daily streak
+   */
+  _updateDailyStreak() {
+    const t = this._getTodayDateString(), e = this.player.streak.lastPlayDate;
+    if (e === t)
+      return;
+    const s = this._getYesterdayDateString();
+    e === s ? (this.player.streak.current++, this.player.streak.current > this.player.streak.longest && (this.player.streak.longest = this.player.streak.current)) : this.player.streak.current = 1, this.player.streak.lastPlayDate = t;
+  }
+  /**
+   * Get streak multiplier for XP
+   */
+  getStreakMultiplier() {
+    const t = this.player.streak.current;
+    return t >= 7 ? 2 : t >= 5 ? 1.5 : t >= 3 ? 1.25 : 1;
+  }
+  /**
+   * Get today's date as YYYY-MM-DD string
+   */
+  _getTodayDateString() {
+    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  }
+  /**
+   * Get yesterday's date as YYYY-MM-DD string
+   */
+  _getYesterdayDateString() {
+    const t = /* @__PURE__ */ new Date();
+    return t.setDate(t.getDate() - 1), t.toISOString().split("T")[0];
+  }
+  /**
+   * Initialize achievement definitions
+   * Can be extended by games
+   */
+  _initAchievements() {
+    return {
+      // Universal achievements
+      first_game: {
+        name: "First Steps",
+        description: "Play your first game",
+        icon: "🎮",
+        xp: 50,
+        check: (t) => t.totalGamesPlayed >= 1
+      },
+      level_5: {
+        name: "Rising Star",
+        description: "Reach level 5",
+        icon: "⭐",
+        xp: 100,
+        check: (t) => t.level >= 5
+      },
+      level_10: {
+        name: "Expert Player",
+        description: "Reach level 10",
+        icon: "🏆",
+        xp: 250,
+        check: (t) => t.level >= 10
+      },
+      streak_3: {
+        name: "Dedicated",
+        description: "Play 3 days in a row",
+        icon: "🔥",
+        xp: 100,
+        check: (t) => t.streak.current >= 3
+      },
+      streak_7: {
+        name: "Unstoppable",
+        description: "Play 7 days in a row",
+        icon: "💥",
+        xp: 300,
+        check: (t) => t.streak.current >= 7
+      }
+    };
+  }
+}
+class P {
+  constructor(t = {}) {
+    this.storage = t.storage || window.localStorage, this.prefix = t.prefix || "dopamine_";
+  }
+  /**
+   * Save data to local storage
+   * @param {string} key 
+   * @param {any} data 
+   */
+  async save(t, e) {
+    try {
+      const s = JSON.stringify(e);
+      return this.storage.setItem(this.prefix + t, s), !0;
+    } catch (s) {
+      return console.error("Error saving data:", s), !1;
+    }
+  }
+  /**
+   * Load data from local storage
+   * @param {string} key 
+   * @param {any} defaultValue 
+   */
+  async load(t, e = null) {
+    try {
+      const s = this.storage.getItem(this.prefix + t);
+      return s ? JSON.parse(s) : e;
+    } catch (s) {
+      return console.error("Error loading data:", s), e;
+    }
+  }
+  /**
+   * Clear specific data
+   * @param {string} key 
+   */
+  async clear(t) {
+    this.storage.removeItem(this.prefix + t);
+  }
+}
+class T {
+  constructor(t) {
+    this.particleSystem = t, this.container = null, this.xpBar = null, this.levelDisplay = null, this.streakDisplay = null, this.init();
+  }
+  /**
+   * Initialize UI overlay
+   */
+  init() {
+    this.container = document.createElement("div"), this.container.id = "game-ui-overlay", this.container.innerHTML = `
+            <div class="game-ui-top-bar">
+                <div class="level-badge" id="level-badge">
+                    <span class="level-label">LVL</span>
+                    <span class="level-number" id="level-number">1</span>
+                </div>
+                
+                <div class="xp-container">
+                    <div class="xp-bar-bg">
+                        <div class="xp-bar-fill" id="xp-bar-fill" style="width: 0%"></div>
+                    </div>
+                    <div class="xp-text" id="xp-text">0 /100 XP</div>
+                </div>
+                
+                <div class="streak-badge" id="streak-badge">
+                    <span class="streak-icon">🔥</span>
+                    <span class="streak-number" id="streak-number">1</span>
+                </div>
+            </div>
+        `, document.body.appendChild(this.container), this.xpBar = document.getElementById("xp-bar-fill"), this.xpText = document.getElementById("xp-text"), this.levelDisplay = document.getElementById("level-number"), this.streakDisplay = document.getElementById("streak-number");
+  }
+  /**
+   * Update XP bar
+   */
+  updateXP(t, e, s) {
+    const i = t / s * 100;
+    this.xpBar.style.width = `${Math.min(100, i)}%`, this.xpText.textContent = `${t} / ${s} XP`, this.xpBar.style.animation = "none", setTimeout(() => {
+      this.xpBar.style.animation = "xp-pulse 0.3s ease-out";
+    }, 10);
+  }
+  /**
+   * Update level display
+   */
+  updateLevel(t) {
+    this.levelDisplay.textContent = t;
+    const e = document.getElementById("level-badge");
+    e.style.animation = "none", setTimeout(() => {
+      e.style.animation = "level-pulse 0.5s ease-out";
+    }, 10);
+  }
+  /**
+   * Update streak display
+   */
+  updateStreak(t) {
+    this.streakDisplay.textContent = t;
+    const e = document.getElementById("streak-badge");
+    t >= 7 ? e.style.background = "linear-gradient(135deg, #ff6b00 0%, #ff4400 100%)" : t >= 3 && (e.style.background = "linear-gradient(135deg, #ff8800 0%, #ff6b00 100%)");
+  }
+  /**
+   * Show achievement unlocked popup
+   */
+  showAchievement(t) {
+    const e = document.createElement("div");
+    e.className = "achievement-popup", e.innerHTML = `
+            <div class="achievement-shine"></div>
+            <div class="achievement-content">
+                <div class="achievement-icon">${t.icon}</div>
+                <div class="achievement-info">
+                    <div class="achievement-title">Achievement Unlocked!</div>
+                    <div class="achievement-name">${t.name}</div>
+                    <div class="achievement-desc">${t.description}</div>
+                    <div class="achievement-xp">+${t.xp} XP</div>
+                </div>
+            </div>
+        `, document.body.appendChild(e), setTimeout(() => {
+      const s = e.getBoundingClientRect();
+      this.particleSystem.confetti(s.left + s.width / 2, s.top + s.height / 2, 40);
+    }, 300), setTimeout(() => {
+      e.style.animation = "slideOut 0.3s ease-in forwards", setTimeout(() => e.remove(), 300);
+    }, 4e3);
+  }
+  /**
+   * Show level up screen
+   */
+  showLevelUp(t, e) {
+    const s = document.createElement("div");
+    s.className = "level-up-overlay", s.innerHTML = `
+            <div class="level-up-content">
+                <div class="level-up-title">LEVEL UP!</div>
+                <div class="level-up-number">${e}</div>
+                <div class="level-up-subtitle">Amazing progress!</div>
+            </div>
+        `, document.body.appendChild(s), setTimeout(() => {
+      for (let i = 0; i < 5; i++)
+        setTimeout(() => {
+          const r = Math.random() * window.innerWidth, n = Math.random() * window.innerHeight * 0.6;
+          this.particleSystem.confetti(r, n, 30);
+        }, i * 200);
+    }, 300), setTimeout(() => {
+      s.style.opacity = "0", setTimeout(() => s.remove(), 500);
+    }, 2500);
+  }
+  /**
+   * Show floating text (e.g., "+50 XP", "COMBO!")
+   */
+  showFloatingText(t, e, s, i = "#ffd700", r = "24px") {
+    const n = document.createElement("div");
+    n.className = "floating-text", n.textContent = t, n.style.left = e + "px", n.style.top = s + "px", n.style.color = i, n.style.fontSize = r, document.body.appendChild(n), setTimeout(() => n.remove(), 2e3);
+  }
+  /**
+   * Show combo multiplier
+   */
+  showCombo(t, e, s) {
+    this.showFloatingText(`${t}× COMBO!`, e, s, "#ff6b6b", "32px"), this.particleSystem.fire(e, s, 20);
+  }
+  /**
+   * Show "near miss"indicator
+   */
+  showNearMiss(t, e) {
+    this.showFloatingText("CLOSE CALL!", t, e, "#45b7d1", "20px"), this.particleSystem.sparkle(t, e, 15, "#45b7d1");
+  }
+  /**
+   * Show lucky moment (random multiplier)
+   */
+  showLuckyMoment(t, e, s) {
+    this.showFloatingText(`LUCKY ${t}×!`, e, s, "#ffd700", "36px"), this.particleSystem.starBurst(e, s, 12), this.particleSystem.confetti(e, s, 25);
+  }
+  /**
+   * Show generic notification
+   */
+  showNotification(t, e = "normal") {
+    const s = window.innerWidth / 2, i = window.innerHeight / 3;
+    e === "legendary" ? this.showLuckyMoment(t, s, i) : e === "rare" ? this.showCombo(t, s, i) : this.showFloatingText(t, s, i, "#fff", "24px");
+  }
+  /**
+   * Show Game Over Summary
+   */
+  showSummary(t) {
+    const e = document.createElement("div");
+    e.className = "message-box", e.style.display = "flex", e.style.position = "absolute", e.style.top = "50%", e.style.left = "50%", e.style.transform = "translate(-50%, -50%)", e.style.zIndex = "1000";
+    let s = "";
+    t.metrics && (s = Object.entries(t.metrics).map(([i, r]) => `<div style="display:flex;justify-content:space-between;width:100%"><span>${i}:</span> <strong>${r}</strong></div>`).join("")), e.innerHTML = `
+            <h1>Game Over</h1>
+            <div style="font-size: 3rem; font-weight: bold; color: #e06020; margin: 10px 0;">${t.score}</div>
+            <div style="width: 100%; margin-bottom: 20px;">
+                ${s}
+            </div>
+            <button class="btn" onclick="location.reload()">Play Again</button>
+            <button class="btn" onclick="window.location.href='index.html'" style="margin-top: 10px; background: #543847;">Exit</button>
+        `, document.body.appendChild(e);
+  }
+}
+class C {
+  constructor(t = {}) {
+    this.container = t.container ? typeof t.container == "string" ? document.querySelector(t.container) : t.container : document.body, this.canvasId = t.canvasId || "dopamine-particle-canvas", this.canvas = document.getElementById(this.canvasId), this.canvas || (this.canvas = document.createElement("canvas"), this.canvas.id = this.canvasId, this.canvas.style.pointerEvents = "none", this.canvas.style.zIndex = t.zIndex || "9999", this.container === document.body ? (this.canvas.style.position = "fixed", this.canvas.style.top = "0", this.canvas.style.left = "0") : (this.canvas.style.position = "absolute", this.canvas.style.top = "0", this.canvas.style.left = "0", window.getComputedStyle(this.container).position === "static" && (this.container.style.position = "relative")), this.container.appendChild(this.canvas)), this.ctx = this.canvas.getContext("2d"), this.particles = [], this.pool = [], this.sprites = /* @__PURE__ */ new Map(), this.customEffects = /* @__PURE__ */ new Map(), this.isAnimating = !1, this._resize(), window.ResizeObserver && this.container !== document.body ? new ResizeObserver(() => this._resize()).observe(this.container) : window.addEventListener("resize", () => this._resize());
+  }
+  _resize() {
+    this.container === document.body ? (this.canvas.width = window.innerWidth, this.canvas.height = window.innerHeight) : (this.canvas.width = this.container.clientWidth, this.canvas.height = this.container.clientHeight);
+  }
+  /**
+   * Register a custom sprite image
+   * @param {string} key 
+   * @param {string} url 
+   */
+  registerSprite(t, e) {
+    const s = new Image();
+    s.src = e, this.sprites.set(t, s);
+  }
+  /**
+   * Register a custom effect
+   * @param {string} name 
+   * @param {Function} callback - (x, y, ...args) => void
+   */
+  registerEffect(t, e) {
+    this.customEffects.set(t, e);
+  }
+  /**
+   * Play a registered effect
+   */
+  play(t, e, s, ...i) {
+    const r = this.customEffects.get(t);
+    r ? r(e, s, ...i) : console.warn(`[DopamineJS] Effect '${t}' not found.`);
+  }
+  /**
+   * Emit particles with custom config
+   * @param {Object} config 
+   */
+  emit(t) {
+    const {
+      x: e,
+      y: s,
+      count: i = 10,
+      speed: r = 5,
+      gravity: n = 0.1,
+      decay: o = 0.02,
+      life: h = 1,
+      color: c = "#ffd700",
+      sprite: d = null,
+      spread: u = Math.PI * 2,
+      angle: m = 0,
+      size: f = 5
+    } = t;
+    for (let v = 0; v < i; v++) {
+      const l = this._getParticle(), x = m + (Math.random() - 0.5) * u, w = Math.random() * r;
+      l.x = e, l.y = s, l.vx = Math.cos(x) * w, l.vy = Math.sin(x) * w, l.life = h, l.decay = o * (0.8 + Math.random() * 0.4), l.gravity = n, l.color = Array.isArray(c) ? c[Math.floor(Math.random() * c.length)] : c, l.size = f * (0.8 + Math.random() * 0.4), l.sprite = d, l.rotation = Math.random() * Math.PI * 2, l.rotationSpeed = (Math.random() - 0.5) * 0.2, this.particles.push(l);
+    }
+    this._startAnimation();
+  }
+  _getParticle() {
+    return this.pool.length > 0 ? this.pool.pop() : {};
+  }
+  _recycleParticle(t) {
+    this.pool.push(t);
+  }
+  // --- Built-in Effects ---
+  confetti(t, e, s = 50) {
+    const i = ["#ff6b6b", "#4ecdc4", "#45b7d1", "#f7dc6f", "#c06c84", "#6c5ce7"];
+    this.emit({
+      x: t,
+      y: e,
+      count: s,
+      color: i,
+      speed: 10,
+      gravity: 0.3,
+      decay: 0.015,
+      size: 8,
+      spread: Math.PI * 2
+    });
+  }
+  coinShower(t, e, s = 10) {
+    this.emit({
+      x: t,
+      y: e,
+      count: s,
+      color: "#ffd700",
+      speed: 4,
+      gravity: 0.4,
+      decay: 0.012,
+      size: 12,
+      angle: -Math.PI / 2,
+      // Upwards initially
+      spread: Math.PI / 2
+    });
+  }
+  sparkle(t, e, s = 20, i = "#ffd700") {
+    this.emit({
+      x: t,
+      y: e,
+      count: s,
+      color: i,
+      speed: 3,
+      gravity: -0.05,
+      // Float up
+      decay: 0.03,
+      size: 3
+    });
+  }
+  fire(t, e, s = 15) {
+    const i = ["#ff6b00", "#ff8800", "#ffaa00", "#ff4400"];
+    this.emit({
+      x: t,
+      y: e,
+      count: s,
+      color: i,
+      speed: 3,
+      gravity: -0.2,
+      decay: 0.04,
+      size: 5,
+      angle: -Math.PI / 2,
+      spread: Math.PI / 4
+    });
+  }
+  starBurst(t, e, s = 8) {
+    for (let i = 0; i < s; i++) {
+      const r = this._getParticle(), n = Math.PI * 2 / s * i, o = 4;
+      r.x = t, r.y = e, r.vx = Math.cos(n) * o, r.vy = Math.sin(n) * o, r.life = 1, r.decay = 0.03, r.gravity = 0, r.color = "#ffffff", r.size = 15, r.sprite = null, r.type = "star", r.rotation = n, r.rotationSpeed = 0, this.particles.push(r);
+    }
+    this._startAnimation();
+  }
+  _startAnimation() {
+    this.isAnimating || (this.isAnimating = !0, this._animate());
+  }
+  _animate() {
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    for (let t = this.particles.length - 1; t >= 0; t--) {
+      const e = this.particles[t];
+      if (e.vy += e.gravity, e.x += e.vx, e.y += e.vy, e.life -= e.decay, e.rotationSpeed && (e.rotation += e.rotationSpeed), e.life <= 0) {
+        this._recycleParticle(e), this.particles.splice(t, 1);
+        continue;
+      }
+      if (this.ctx.save(), this.ctx.globalAlpha = e.life, this.ctx.translate(e.x, e.y), this.ctx.rotate(e.rotation), e.sprite && this.sprites.has(e.sprite)) {
+        const s = this.sprites.get(e.sprite);
+        s.complete && this.ctx.drawImage(s, -e.size / 2, -e.size / 2, e.size, e.size);
+      } else e.type === "star" ? (this.ctx.fillStyle = e.color, this._drawStarPath(0, 0, 5, e.size, e.size / 2), this.ctx.fill()) : (this.ctx.fillStyle = e.color, this.ctx.beginPath(), this.ctx.arc(0, 0, e.size, 0, Math.PI * 2), this.ctx.fill());
+      this.ctx.restore();
+    }
+    this.particles.length > 0 ? requestAnimationFrame(() => this._animate()) : this.isAnimating = !1;
+  }
+  _drawStarPath(t, e, s, i, r) {
+    let n = Math.PI / 2 * 3, o = t, h = e;
+    const c = Math.PI / s;
+    this.ctx.beginPath(), this.ctx.moveTo(t, e - i);
+    for (let d = 0; d < s; d++)
+      o = t + Math.cos(n) * i, h = e + Math.sin(n) * i, this.ctx.lineTo(o, h), n += c, o = t + Math.cos(n) * r, h = e + Math.sin(n) * r, this.ctx.lineTo(o, h), n += c;
+    this.ctx.lineTo(t, e - i), this.ctx.closePath();
+  }
+  clear() {
+    this.particles.forEach((t) => this._recycleParticle(t)), this.particles = [], this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+}
+class I {
+  constructor(t = {}) {
+    this.audioContext = null, this.storageKey = t.storageKey || "dopamineSoundsMuted", this.muted = localStorage.getItem(this.storageKey) === "true", this.assets = /* @__PURE__ */ new Map(), this.customSounds = t.customSounds || {}, Object.keys(this.customSounds).length > 0 && this.preloadSounds(this.customSounds);
+  }
+  /**
+   * Initialize Audio Context (must be called after user interaction)
+   */
+  initAudio() {
+    if (!this.audioContext) {
+      const t = window.AudioContext || window.webkitAudioContext;
+      this.audioContext = new t();
+    }
+    this.audioContext.state === "suspended" && this.audioContext.resume();
+  }
+  /**
+   * Toggle mute state
+   * @returns {boolean} New mute state
+   */
+  toggleMute() {
+    return this.muted = !this.muted, localStorage.setItem(this.storageKey, this.muted), this.muted;
+  }
+  /**
+   * Register a custom sound URL
+   * @param {string} key - Unique identifier (e.g., 'jump', 'win')
+   * @param {string} url - Path to audio file
+   */
+  registerSound(t, e) {
+    this.customSounds[t] = e, this.audioContext && this.loadSound(t, e);
+  }
+  /**
+   * Preload multiple sounds
+   * @param {Object} soundMap - { key: url }
+   */
+  async preloadSounds(t) {
+    const e = Object.entries(t).map(([s, i]) => this.loadSound(s, i));
+    await Promise.allSettled(e);
+  }
+  /**
+   * Load and decode a sound file
+   */
+  async loadSound(t, e) {
+    try {
+      if (!this.audioContext)
+        return;
+      const i = await (await fetch(e)).arrayBuffer(), r = await this.audioContext.decodeAudioData(i);
+      this.assets.set(t, r);
+    } catch (s) {
+      console.warn(`[DopamineJS] Failed to load sound '${t}':`, s);
+    }
+  }
+  /**
+   * Play a sound by key (custom) or fallback to synth
+   * @param {string} key - 'jump', 'score', 'success', etc.
+   */
+  async play(t) {
+    if (this.muted) return;
+    if (this.initAudio(), this.assets.has(t)) {
+      this._playBuffer(this.assets.get(t));
+      return;
+    }
+    if (this.customSounds[t] && !this.assets.has(t) && (await this.loadSound(t, this.customSounds[t]), this.assets.has(t))) {
+      this._playBuffer(this.assets.get(t));
+      return;
+    }
+    const e = {
+      jump: () => this.playJump(!0),
+      score: () => this.playScore(!0),
+      success: () => this.playSuccess(!0),
+      click: () => this.playClick(!0),
+      error: () => this.playError(!0),
+      gameover: () => this.playGameOver(!0)
+    };
+    e[t] && e[t]();
+  }
+  _playBuffer(t) {
+    const e = this.audioContext.createBufferSource();
+    e.buffer = t, e.connect(this.audioContext.destination), e.start(0);
+  }
+  /**
+   * Play a synthesized tone
+   */
+  playTone(t, e, s = "sine", i = 0.3) {
+    if (this.muted) return;
+    this.initAudio();
+    const r = this.audioContext.createOscillator(), n = this.audioContext.createGain();
+    r.connect(n), n.connect(this.audioContext.destination), r.frequency.value = t, r.type = s, n.gain.setValueAtTime(i, this.audioContext.currentTime), n.gain.exponentialRampToValueAtTime(0.01, this.audioContext.currentTime + e), r.start(this.audioContext.currentTime), r.stop(this.audioContext.currentTime + e);
+  }
+  // --- Presets (Synth) ---
+  playJump(t = !1) {
+    if (!t && this.assets.has("jump")) return this.play("jump");
+    this.playTone(400, 0.1, "square", 0.2);
+  }
+  playScore(t = !1) {
+    if (!t && this.assets.has("score")) return this.play("score");
+    this.playTone(800, 0.15, "sine", 0.25), setTimeout(() => this.playTone(1e3, 0.15, "sine", 0.25), 50);
+  }
+  playGameOver(t = !1) {
+    if (!t && this.assets.has("gameover")) return this.play("gameover");
+    this.playTone(300, 0.2, "sawtooth", 0.3), setTimeout(() => this.playTone(200, 0.2, "sawtooth", 0.3), 100), setTimeout(() => this.playTone(150, 0.3, "sawtooth", 0.3), 200);
+  }
+  playClick(t = !1) {
+    if (!t && this.assets.has("click")) return this.play("click");
+    this.playTone(600, 0.05, "sine", 0.1);
+  }
+  playSuccess(t = !1) {
+    if (!t && this.assets.has("success")) return this.play("success");
+    this.playTone(600, 0.1, "sine", 0.2), setTimeout(() => this.playTone(800, 0.2, "sine", 0.2), 100);
+  }
+  playError(t = !1) {
+    if (!t && this.assets.has("error")) return this.play("error");
+    this.playTone(200, 0.2, "sawtooth", 0.3);
+  }
+}
+class $ {
+  constructor(t = {}) {
+    this.config = t, this.dataService = new P(t.data || {}), this.rewardSystem = new E(this.dataService, t.rewards || {}), this.soundManager = new I(t.sound || {}), this.particleSystem = new C(t.particles || {}), this.gameUI = new T(this.particleSystem), this._bindEvents();
+  }
+  async init() {
+    return await this.rewardSystem.init(), console.log("DopamineJS Initialized 🚀"), {
+      rewardSystem: this.rewardSystem,
+      gameUI: this.gameUI,
+      particleSystem: this.particleSystem,
+      soundManager: this.soundManager
+    };
+  }
+  _bindEvents() {
+    this.rewardSystem.on("xp_gained", (t) => {
+      const { total: e, needed: s } = this.rewardSystem.getXPForNextLevel();
+      this.gameUI.updateXP(this.rewardSystem.player.xp, s, e), t.xpGained > 0;
+    }), this.rewardSystem.on("level_up", (t) => {
+      this.gameUI.updateLevel(t.newLevel), this.gameUI.showLevelUp(t.oldLevel, t.newLevel);
+    }), this.rewardSystem.on("achievement_unlocked", (t) => {
+      this.gameUI.showAchievement(t);
+    }), this.rewardSystem.on("new_high_score", (t) => {
+      this.gameUI.showNotification(`New High Score: ${t.score}!`, "legendary"), this.soundManager.playSuccess();
+    });
+  }
+}
+class p {
+  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(t, e, s = 0) {
+    return this._listeners.has(t) || this._listeners.set(t, /* @__PURE__ */ new Set()), this._listeners.get(t).add({ callback: e, priority: s }), this._sortedCache.delete(t), this;
+  }
+  /**
+   * Register a one-time event listener
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @returns {EventBus} - For chaining
+   */
+  once(t, e) {
+    return this._onceListeners.has(t) || this._onceListeners.set(t, /* @__PURE__ */ new Set()), this._onceListeners.get(t).add(e), this;
+  }
+  /**
+   * Remove an event listener
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function to remove
+   * @returns {EventBus} - For chaining
+   */
+  off(t, e) {
+    const s = this._listeners.get(t);
+    if (s) {
+      for (const r of s)
+        if (r.callback === e) {
+          s.delete(r), this._sortedCache.delete(t);
+          break;
+        }
+    }
+    const i = this._onceListeners.get(t);
+    return i && i.delete(e), this;
+  }
+  /**
+   * Emit an event to all registered listeners
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+  emit(t, e) {
+    const s = this._getSortedListeners(t);
+    for (let r = 0; r < s.length; r++)
+      s[r].callback(e);
+    const i = this._onceListeners.get(t);
+    if (i && i.size > 0) {
+      for (const r of i)
+        r(e);
+      i.clear();
+    }
+  }
+  /**
+   * Get sorted listeners for an event (with caching)
+   * @private
+   */
+  _getSortedListeners(t) {
+    if (this._sortedCache.has(t))
+      return this._sortedCache.get(t);
+    const e = this._listeners.get(t);
+    if (!e || e.size === 0)
+      return [];
+    const s = Array.from(e).sort((i, r) => r.priority - i.priority);
+    return this._sortedCache.set(t, s), s;
+  }
+  /**
+   * Remove all listeners for an event, or all events if no event specified
+   * @param {string} [event] - Event name (optional)
+   */
+  clear(t) {
+    t ? (this._listeners.delete(t), this._onceListeners.delete(t), this._sortedCache.delete(t)) : (this._listeners.clear(), this._onceListeners.clear(), this._sortedCache.clear());
+  }
+  /**
+   * Check if an event has listeners
+   * @param {string} event - Event name
+   * @returns {boolean}
+   */
+  hasListeners(t) {
+    const e = this._listeners.get(t), s = this._onceListeners.get(t);
+    return e && e.size > 0 || s && s.size > 0;
+  }
+}
+p.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 O {
+  constructor(t) {
+    this.kernel = t, this._systems = /* @__PURE__ */ new Map(), this._updateOrder = [], this._fixedUpdateOrder = [], this._needsRecompute = !1;
+  }
+  /**
+   * 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(t, e, { priority: s = 0, dependencies: i = [] } = {}) {
+    this._systems.has(t) && (console.warn(`[SystemRegistry] System "${t}" already registered. Replacing.`), this.unregister(t));
+    for (const r of i)
+      this._systems.has(r) || console.warn(`[SystemRegistry] Dependency "${r}" not found for system "${t}"`);
+    return this._systems.set(t, {
+      system: e,
+      priority: s,
+      dependencies: i
+    }), e.init && e.init(this.kernel), this._needsRecompute = !0, this.kernel.events.emit("system_registered", { name: t, system: e }), this;
+  }
+  /**
+   * Get a system by name
+   * @param {string} name - System name
+   * @returns {Object|undefined} - System instance
+   */
+  get(t) {
+    const e = this._systems.get(t);
+    return e ? e.system : void 0;
+  }
+  /**
+   * Check if a system is registered
+   * @param {string} name - System name
+   * @returns {boolean}
+   */
+  has(t) {
+    return this._systems.has(t);
+  }
+  /**
+   * Unregister a system
+   * @param {string} name - System name
+   * @returns {boolean} - True if system was found and removed
+   */
+  unregister(t) {
+    const e = this._systems.get(t);
+    return e ? (e.system.destroy && e.system.destroy(), this._systems.delete(t), this._needsRecompute = !0, this.kernel.events.emit("system_unregistered", { name: t }), !0) : !1;
+  }
+  /**
+   * Update all systems (called each frame)
+   * @param {number} dt - Delta time in seconds
+   */
+  update(t) {
+    this._needsRecompute && this._recomputeUpdateOrder();
+    for (let e = 0; e < this._updateOrder.length; e++) {
+      const s = this._updateOrder[e];
+      s.update && s.update(t);
+    }
+  }
+  /**
+   * Fixed update for physics (called at fixed timestep)
+   * @param {number} dt - Fixed delta time
+   */
+  fixedUpdate(t) {
+    this._needsRecompute && this._recomputeUpdateOrder();
+    for (let e = 0; e < this._fixedUpdateOrder.length; e++) {
+      const s = this._fixedUpdateOrder[e];
+      s.fixedUpdate && s.fixedUpdate(t);
+    }
+  }
+  /**
+   * Recompute the update order based on dependencies and priorities
+   * Uses topological sort for dependencies
+   * @private
+   */
+  _recomputeUpdateOrder() {
+    const t = Array.from(this._systems.entries()), e = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+    for (const [n, o] of t)
+      e.set(n, o.dependencies), s.set(n, 0);
+    for (const [n, o] of e)
+      for (const h of o)
+        s.has(h) && 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, h) => {
+        const c = this._systems.get(o).priority;
+        return this._systems.get(h).priority - c;
+      });
+      const n = i.shift();
+      r.push(n);
+      for (const [o, h] of e)
+        if (h.includes(n)) {
+          const c = s.get(o) - 1;
+          s.set(o, c), c === 0 && i.push(o);
+        }
+    }
+    r.length !== t.length && (console.error("[SystemRegistry] Circular dependency detected in systems!"), r.length = 0, r.push(...t.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 t of this._systems.keys())
+      this.unregister(t);
+  }
+}
+class A {
+  constructor(t) {
+    this.kernel = t, this._plugins = /* @__PURE__ */ new Map(), this._loadOrder = [];
+  }
+  /**
+   * 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(t) {
+    if (!t.name)
+      throw new Error("[PluginRegistry] Plugin must have a name");
+    if (this._plugins.has(t.name))
+      return console.warn(`[PluginRegistry] Plugin "${t.name}" already registered. Skipping.`), this;
+    if (!t.init || typeof t.init != "function")
+      throw new Error(`[PluginRegistry] Plugin "${t.name}" must have an init() method`);
+    this._plugins.set(t.name, t), this._loadOrder.push(t.name);
+    try {
+      t.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
+        name: t.name,
+        version: t.version
+      }), console.log(`[PluginRegistry] Loaded plugin: ${t.name}${t.version ? ` v${t.version}` : ""}`);
+    } catch (e) {
+      throw console.error(`[PluginRegistry] Failed to initialize plugin "${t.name}":`, e), this._plugins.delete(t.name), this._loadOrder.pop(), e;
+    }
+    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(t) {
+    if (!t.name)
+      throw new Error("[PluginRegistry] Plugin must have a name");
+    if (this._plugins.has(t.name))
+      return console.warn(`[PluginRegistry] Plugin "${t.name}" already registered. Skipping.`), this;
+    if (!t.init || typeof t.init != "function")
+      throw new Error(`[PluginRegistry] Plugin "${t.name}" must have an init() method`);
+    this._plugins.set(t.name, t), this._loadOrder.push(t.name);
+    try {
+      await t.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
+        name: t.name,
+        version: t.version
+      }), console.log(`[PluginRegistry] Loaded plugin: ${t.name}${t.version ? ` v${t.version}` : ""}`);
+    } catch (e) {
+      throw console.error(`[PluginRegistry] Failed to initialize plugin "${t.name}":`, e), this._plugins.delete(t.name), this._loadOrder.pop(), e;
+    }
+    return this;
+  }
+  /**
+   * Remove a plugin
+   * @param {string} name - Plugin name
+   * @returns {boolean} - True if plugin was found and removed
+   */
+  remove(t) {
+    const e = this._plugins.get(t);
+    if (!e)
+      return !1;
+    if (e.destroy)
+      try {
+        e.destroy();
+      } catch (i) {
+        console.error(`[PluginRegistry] Error destroying plugin "${t}":`, i);
+      }
+    this._plugins.delete(t);
+    const s = this._loadOrder.indexOf(t);
+    return s > -1 && this._loadOrder.splice(s, 1), this.kernel.events.emit("plugin_unloaded", { name: t }), !0;
+  }
+  /**
+   * Get a plugin by name
+   * @param {string} name - Plugin name
+   * @returns {Object|undefined} - Plugin instance
+   */
+  get(t) {
+    return this._plugins.get(t);
+  }
+  /**
+   * Check if a plugin is registered
+   * @param {string} name - Plugin name
+   * @returns {boolean}
+   */
+  has(t) {
+    return this._plugins.has(t);
+  }
+  /**
+   * 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 t = this._loadOrder.length - 1; t >= 0; t--)
+      this.remove(this._loadOrder[t]);
+  }
+}
+class D {
+  constructor(t = {}) {
+    this.width = t.width || 800, this.height = t.height || 600, this.backgroundColor = t.backgroundColor || "#000000", this.canvas = document.createElement("canvas"), this.canvas.width = this.width, this.canvas.height = this.height, this.ctx = this.canvas.getContext("2d"), (t.parent ? typeof t.parent == "string" ? document.querySelector(t.parent) : t.parent : document.body).appendChild(this.canvas);
+  }
+  /**
+   * Clear the canvas.
+   */
+  clear() {
+    this.ctx.fillStyle = this.backgroundColor, this.ctx.fillRect(0, 0, this.width, this.height);
+  }
+  resize(t, e) {
+    this.width = t, this.height = e, this.canvas.width = t, this.canvas.height = e;
+  }
+}
+class L {
+  constructor() {
+    this.running = !1, this.lastTime = 0, this.callbacks = /* @__PURE__ */ new Set(), this._tick = this._tick.bind(this);
+  }
+  /**
+   * Add a callback to the loop.
+   * @param {Function} callback - Function to call each frame (receives dt).
+   */
+  add(t) {
+    this.callbacks.add(t);
+  }
+  /**
+   * Remove a callback from the loop.
+   * @param {Function} callback 
+   */
+  remove(t) {
+    this.callbacks.delete(t);
+  }
+  /**
+   * Start the loop.
+   */
+  start() {
+    this.running || (this.running = !0, this.lastTime = performance.now(), requestAnimationFrame(this._tick));
+  }
+  /**
+   * Stop the loop.
+   */
+  stop() {
+    this.running = !1;
+  }
+  _tick(t) {
+    if (!this.running) return;
+    const e = (t - this.lastTime) / 1e3;
+    this.lastTime = t;
+    const s = Math.min(e, 0.1);
+    for (const i of this.callbacks)
+      i(s);
+    requestAnimationFrame(this._tick);
+  }
+}
+class y {
+  constructor() {
+    this.gameObject = null, this.kernel = null;
+  }
+  /**
+   * Access systems through kernel (no more globals!)
+   */
+  get physics() {
+    var t;
+    return (t = this.kernel) == null ? void 0 : t.systems.get("physics");
+  }
+  get input() {
+    var t;
+    return (t = this.kernel) == null ? void 0 : t.systems.get("input");
+  }
+  get loader() {
+    var t;
+    return (t = this.kernel) == null ? void 0 : t.systems.get("loader");
+  }
+  get events() {
+    var t;
+    return (t = this.kernel) == null ? void 0 : t.events;
+  }
+  onAttach() {
+  }
+  onDetach() {
+  }
+  update(t) {
+  }
+  render(t) {
+  }
+}
+class B extends y {
+  constructor(t = "box", e = 50, s = 50, i = 25) {
+    super(), this.type = t, this.width = e, this.height = s, this.radius = i, this.tag = null;
+  }
+  onAttach() {
+    super.onAttach(), this.physics && this.physics.add(this);
+  }
+  onDetach() {
+    super.onDetach(), this.physics && this.physics.remove(this);
+  }
+  getBounds() {
+    const t = this.gameObject;
+    if (this.type === "box")
+      return {
+        left: t.x - this.width / 2,
+        right: t.x + this.width / 2,
+        top: t.y - this.height / 2,
+        bottom: t.y + this.height / 2
+      };
+    if (this.type === "circle")
+      return {
+        x: t.x,
+        y: t.y,
+        radius: this.radius
+      };
+  }
+}
+class _ {
+  constructor() {
+    this.colliders = [], this.kernel = null;
+  }
+  /**
+   * ISystem interface - called when registered
+   */
+  init(t) {
+    this.kernel = t;
+  }
+  /**
+   * ISystem interface - called at fixed timestep
+   */
+  fixedUpdate(t) {
+    this.step();
+  }
+  /**
+   * ISystem interface - cleanup
+   */
+  destroy() {
+    this.colliders = [];
+  }
+  add(t) {
+    this.colliders.push(t);
+  }
+  remove(t) {
+    const e = this.colliders.indexOf(t);
+    e > -1 && this.colliders.splice(e, 1);
+  }
+  /**
+   * Main Physics Step.
+   * Checks all pairs and triggers callbacks.
+   */
+  step() {
+    for (let t = 0; t < this.colliders.length; t++)
+      for (let e = t + 1; e < this.colliders.length; e++) {
+        const s = this.colliders[t], i = this.colliders[e];
+        this._intersects(s, s.getBounds(), i, i.getBounds()) && (this._notifyCollision(s.gameObject, i.gameObject), this._notifyCollision(i.gameObject, s.gameObject));
+      }
+  }
+  _notifyCollision(t, e) {
+    !t || !t.components || t.components.forEach((s) => {
+      s.onCollisionEnter && s.onCollisionEnter(e);
+    });
+  }
+  /**
+   * Check if a specific collider overlaps with anything in the target group (tag).
+   * @param {Collider} source 
+   * @param {string} targetTag 
+   */
+  checkOverlap(t, e) {
+    const s = [], i = t.getBounds();
+    for (const r of this.colliders) {
+      if (r === t || e && r.tag !== e) continue;
+      const n = r.getBounds();
+      this._intersects(t, i, r, n) && s.push(r);
+    }
+    return s;
+  }
+  _intersects(t, e, s, i) {
+    if (t.type === "box" && s.type === "box")
+      return e.left < i.right && e.right > i.left && e.top < i.bottom && e.bottom > i.top;
+    if (t.type === "circle" && s.type === "circle") {
+      const r = e.x - i.x, n = e.y - i.y;
+      return Math.sqrt(r * r + n * n) < e.radius + i.radius;
+    }
+    return !1;
+  }
+  // IPhysicsSystem interface methods (for plugin compatibility)
+  addBody(t) {
+    this.add(t);
+  }
+  removeBody(t) {
+    this.remove(t);
+  }
+  checkCollision(t, e) {
+    return this._intersects(t, t.getBounds(), e, e.getBounds());
+  }
+  raycast(t, e, s) {
+    return null;
+  }
+  setGravity(t, e) {
+  }
+}
+const G = new _();
+console.warn("[DopamineJS] GlobalPhysics is deprecated. Use kernel.physics instead.");
+class k {
+  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(t) {
+    this.kernel = t, 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(t) {
+    this.keys.set(t.key, !0);
+  }
+  _onKeyUp(t) {
+    this.keys.set(t.key, !1);
+  }
+  _onMouseMove(t) {
+    this.mouse.x = t.clientX, this.mouse.y = t.clientY;
+  }
+  _onMouseDown(t) {
+    this.mouse.buttons.set(t.button, !0);
+  }
+  _onMouseUp(t) {
+    this.mouse.buttons.set(t.button, !1);
+  }
+  isKeyDown(t) {
+    return this.keys.get(t) || !1;
+  }
+  isMouseButtonDown(t = 0) {
+    return this.mouse.buttons.get(t) || !1;
+  }
+}
+const F = new k();
+console.warn("[DopamineJS] GlobalInput is deprecated. Use kernel.input instead.");
+class S {
+  constructor() {
+    this.assets = /* @__PURE__ */ new Map(), this.kernel = null;
+  }
+  /**
+   * ISystem interface - called when registered
+   */
+  init(t) {
+    this.kernel = t;
+  }
+  /**
+   * ISystem interface - cleanup
+   */
+  destroy() {
+    this.assets.clear();
+  }
+  async loadImage(t, e) {
+    return new Promise((s, i) => {
+      const r = new Image();
+      r.onload = () => {
+        this.assets.set(t, r), s(r);
+      }, r.onerror = i, r.src = e;
+    });
+  }
+  get(t) {
+    return this.assets.get(t);
+  }
+}
+const N = new S();
+console.warn("[DopamineJS] GlobalLoader is deprecated. Use kernel.loader instead.");
+class U {
+  constructor(t = {}) {
+    this.config = t, this.events = new p(), this.systems = new O(this), this.plugins = new A(this), this._registerCoreSystems(t), this.fixedTimestep = t.fixedTimestep || 1 / 60, this._accumulator = 0, this._maxAccumulator = this.fixedTimestep * 5;
+  }
+  /**
+   * Register core engine systems
+   * These can be replaced by plugins
+   * @private
+   */
+  _registerCoreSystems(t) {
+    this.systems.register("ticker", new L(), {
+      priority: 100
+    }), this.systems.register("renderer", new D(t.renderer || {}), {
+      priority: 90
+    }), this.systems.register("input", new k(), {
+      priority: 80
+    }), this.systems.register("loader", new S(), {
+      priority: 70
+    }), this.systems.register("physics", new _(), {
+      priority: 60
+    });
+  }
+  /**
+   * Start the kernel (begins game loop)
+   */
+  start() {
+    const t = this.systems.get("ticker");
+    t && (t.add(this._update.bind(this)), t.start()), this.events.emit("kernel_started");
+  }
+  /**
+   * Stop the kernel
+   */
+  stop() {
+    const t = this.systems.get("ticker");
+    t && t.stop(), this.events.emit("kernel_stopped");
+  }
+  /**
+   * Main update loop
+   * @private
+   */
+  _update(t) {
+    for (this.events.emit(p.Events.TICK, { dt: t }), this._accumulator += t, this._accumulator > this._maxAccumulator && (this._accumulator = this._maxAccumulator); this._accumulator >= this.fixedTimestep; )
+      this.events.emit(p.Events.FIXED_UPDATE, { dt: this.fixedTimestep }), this.systems.fixedUpdate(this.fixedTimestep), this._accumulator -= this.fixedTimestep;
+    this.systems.update(t), this.events.emit(p.Events.RENDER, { dt: t });
+  }
+  /**
+   * 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(), this.plugins.clear(), this.systems.clear(), this.events.clear();
+  }
+}
+const g = {
+  /**
+   * Called when system is registered to the kernel
+   * @param {DopamineKernel} kernel - The kernel instance
+   */
+  init(a) {
+  },
+  /**
+   * Called each frame (variable timestep)
+   * @param {number} dt - Delta time in seconds
+   */
+  update(a) {
+  },
+  /**
+   * Called at fixed timestep (for physics)
+   * @param {number} dt - Fixed delta time
+   */
+  fixedUpdate(a) {
+  },
+  /**
+   * Called when system is unregistered
+   */
+  destroy() {
+  }
+};
+class K {
+  constructor() {
+    this.kernel = null;
+  }
+  init(t) {
+    this.kernel = t;
+  }
+  update(t) {
+  }
+  fixedUpdate(t) {
+  }
+  destroy() {
+  }
+}
+const X = {
+  ...g,
+  /**
+   * Add a physics body to the simulation
+   * @param {Object} body - Physics body (implementation-specific)
+   */
+  addBody(a) {
+  },
+  /**
+   * Remove a physics body from the simulation
+   * @param {Object} body - Physics body to remove
+   */
+  removeBody(a) {
+  },
+  /**
+   * Check collision between two bodies
+   * @param {Object} a - First body
+   * @param {Object} b - Second body
+   * @returns {boolean} - True if colliding
+   */
+  checkCollision(a, t) {
+  },
+  /**
+   * Perform a raycast
+   * @param {Object} origin - Ray origin {x, y}
+   * @param {Object} direction - Ray direction {x, y}
+   * @param {number} distance - Maximum ray distance
+   * @returns {Object|null} - Hit result or null
+   */
+  raycast(a, t, e) {
+  },
+  /**
+   * Set gravity for the physics world
+   * @param {number} x - Gravity X component
+   * @param {number} y - Gravity Y component
+   */
+  setGravity(a, t) {
+  },
+  /**
+   * Step the physics simulation
+   * @param {number} dt - Delta time
+   */
+  step(a) {
+  }
+}, H = {
+  ...g,
+  /**
+   * Register a sound with a key
+   * @param {string} key - Sound identifier
+   * @param {string} url - Path to audio file
+   */
+  registerSound(a, t) {
+  },
+  /**
+   * Preload multiple sounds
+   * @param {Object} soundMap - Map of key -> url
+   * @returns {Promise<void>}
+   */
+  preloadSounds(a) {
+  },
+  /**
+   * Play a sound by key
+   * @param {string} key - Sound identifier
+   * @param {Object} options - Playback options (volume, loop, etc.)
+   */
+  play(a, t) {
+  },
+  /**
+   * Play a synthesized tone
+   * @param {number} frequency - Frequency in Hz
+   * @param {number} duration - Duration in seconds
+   * @param {string} type - Waveform type ('sine', 'square', etc.)
+   * @param {number} volume - Volume (0-1)
+   */
+  playTone(a, t, e, s) {
+  },
+  /**
+   * Stop a playing sound
+   * @param {string} key - Sound identifier
+   */
+  stop(a) {
+  },
+  /**
+   * Toggle mute state
+   * @returns {boolean} - New mute state
+   */
+  toggleMute() {
+  },
+  /**
+   * Set master volume
+   * @param {number} volume - Volume (0-1)
+   */
+  setVolume(a) {
+  }
+}, q = {
+  ...g,
+  /**
+   * Register a sprite for particles
+   * @param {string} key - Sprite identifier
+   * @param {string} url - Path to image
+   */
+  registerSprite(a, t) {
+  },
+  /**
+   * Register a custom effect
+   * @param {string} name - Effect name
+   * @param {Function} callback - Effect function (x, y, ...args) => void
+   */
+  registerEffect(a, t) {
+  },
+  /**
+   * Play a registered effect
+   * @param {string} name - Effect name
+   * @param {number} x - X position
+   * @param {number} y - Y position
+   * @param {...any} args - Additional arguments
+   */
+  play(a, t, e, ...s) {
+  },
+  /**
+   * Emit particles with custom configuration
+   * @param {Object} config - Particle configuration
+   */
+  emit(a) {
+  },
+  /**
+   * Clear all particles
+   */
+  clear() {
+  },
+  // Built-in effects (optional, but recommended)
+  confetti(a, t, e) {
+  },
+  coinShower(a, t, e) {
+  },
+  sparkle(a, t, e, s) {
+  },
+  fire(a, t, e) {
+  },
+  starBurst(a, t, e) {
+  }
+};
+class J {
+  constructor() {
+    this.children = [], this.game = null;
+  }
+  /**
+   * Called when the scene is added to the Game.
+   */
+  onEnter() {
+  }
+  onExit() {
+  }
+  /**
+   * Update loop for the scene.
+   * @param {number} dt 
+   */
+  update(t) {
+    for (const e of this.children)
+      e.update && e.update(t);
+  }
+  /**
+          this.gameObjects = [];
+          this.kernel = null; // Injected by Game
+      }
+  
+      /**
+       * Add a GameObject to the scene.
+       * @param {GameObject} gameObject 
+       */
+  add(t) {
+    return t.kernel = this.kernel, this.gameObjects.push(t), t;
+  }
+  /**
+   * Remove a GameObject from the scene.
+   * @param {GameObject} gameObject 
+   */
+  remove(t) {
+    const e = this.gameObjects.indexOf(t);
+    e > -1 && this.gameObjects.splice(e, 1);
+  }
+  update(t) {
+    for (const e of this.gameObjects)
+      e.update(t);
+  }
+  render(t) {
+    for (const e of this.gameObjects)
+      e.render(t);
+  }
+}
+class R {
+  constructor(t) {
+    this.game = t, this.currentScene = null;
+  }
+  /**
+   * Switch to a new scene.
+   * @param {Scene} scene 
+   */
+  run(t) {
+    this.currentScene && this.currentScene.onExit(), this.currentScene = t, this.currentScene.game = this.game, this.game.scene = t, t.onEnter();
+  }
+}
+class W {
+  constructor(t = {}) {
+    this.config = t, this.kernel = new U(t), this.director = new R(this), this.kernel.events.on(p.Events.TICK, this._update.bind(this), 10), this.kernel.events.on(p.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(t) {
+    t.kernel = this.kernel, this.director.run(t);
+  }
+  _update({ dt: t }) {
+    this.director.currentScene && this.director.currentScene.update(t);
+  }
+  _render({ dt: t }) {
+    this.renderer.clear(), this.director.currentScene && this.director.currentScene.render(this.renderer.ctx);
+  }
+  /**
+   * Destroy the game and cleanup
+   */
+  destroy() {
+    this.kernel.destroy();
+  }
+}
+class Y {
+  constructor(t = 0, e = 0) {
+    this.x = t, this.y = e, this.rotation = 0, this.scale = { x: 1, y: 1 }, this.components = [], this.children = [], this.parent = null, this.kernel = null;
+  }
+  /**
+   * Add a child object.
+   * @param {GameObject} child 
+   */
+  addChild(t) {
+    return t.parent = this, t.kernel = this.kernel, this.children.push(t), t;
+  }
+  /**
+   * Add a component.
+   * @param {Component} component 
+   */
+  addComponent(t) {
+    return t.gameObject = this, t.kernel = this.kernel, this.components.push(t), t.onAttach(), t;
+  }
+  /**
+   * Get a component by class type.
+   * @param {class} type 
+   */
+  getComponent(t) {
+    return this.components.find((e) => e instanceof t);
+  }
+  update(t) {
+    for (const e of this.components)
+      e.update && e.update(t);
+    for (const e of this.children)
+      e.update(t);
+  }
+  render(t) {
+    t.save(), t.translate(this.x, this.y), t.rotate(this.rotation), t.scale(this.scale.x, this.scale.y);
+    for (const e of this.components)
+      e.render && e.render(t);
+    for (const e of this.children)
+      e.render(t);
+    t.restore();
+  }
+}
+class b {
+  constructor(t = 0, e = 0) {
+    this.x = t, this.y = e;
+  }
+  add(t) {
+    return this.x += t.x, this.y += t.y, this;
+  }
+  sub(t) {
+    return this.x -= t.x, this.y -= t.y, this;
+  }
+  scale(t) {
+    return this.x *= t, this.y *= t, this;
+  }
+  distance(t) {
+    const e = this.x - t.x, s = this.y - t.y;
+    return Math.sqrt(e * e + s * s);
+  }
+  normalize() {
+    const t = Math.sqrt(this.x * this.x + this.y * this.y);
+    return t > 0 && (this.x /= t, this.y /= t), this;
+  }
+  clone() {
+    return new b(this.x, this.y);
+  }
+  static distance(t, e) {
+    return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+  }
+}
+class z extends y {
+  constructor(t) {
+    super(), this.image = t, this.anchor = { x: 0.5, y: 0.5 }, this.width = t ? t.width : 0, this.height = t ? t.height : 0, this.frame = { x: 0, y: 0, w: this.width, h: this.height };
+  }
+  setFrame(t, e, s, i) {
+    this.frame = { x: t, y: e, w: s, h: i }, this.width = s, this.height = i;
+  }
+  setTexture(t) {
+    this.image = t, t && this.setFrame(0, 0, t.width, t.height);
+  }
+  render(t) {
+    if (!this.image) return;
+    const e = this.frame.w, s = this.frame.h, i = -e * this.anchor.x, r = -s * this.anchor.y;
+    t.drawImage(
+      this.image,
+      this.frame.x,
+      this.frame.y,
+      e,
+      s,
+      // Source
+      i,
+      r,
+      e,
+      s
+      // Destination
+    );
+  }
+}
+class V extends y {
+  constructor() {
+    super(), this.animations = {}, this.currentAnim = null, this.timer = 0, this.currentFrameIndex = 0, this.sprite = null;
+  }
+  onAttach() {
+    this.sprite = this.gameObject.getComponent(z), this.sprite || console.warn("Animator attached to GameObject without a Sprite component.");
+  }
+  addAnimation(t, e, s = 10, i = !0) {
+    this.animations[t] = { frames: e, fps: s, loop: i };
+  }
+  play(t) {
+    this.currentAnim && this.currentAnim.name === t || this.animations[t] && (this.currentAnim = { name: t, ...this.animations[t] }, this.currentFrameIndex = 0, this.timer = 0, this._updateFrame());
+  }
+  update(t) {
+    if (!this.currentAnim || !this.sprite) return;
+    this.timer += t;
+    const e = 1 / this.currentAnim.fps;
+    this.timer >= e && (this.timer -= e, 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 t = this.currentAnim.frames[this.currentFrameIndex];
+    this.sprite.setFrame(t.x, t.y, t.w, t.h);
+  }
+}
+class Q {
+  static createGround(t, e, s = "#333") {
+    const i = document.createElement("canvas");
+    i.width = t, i.height = e;
+    const r = i.getContext("2d");
+    r.fillStyle = s, r.fillRect(0, 0, t, e);
+    for (let n = 0; n < 1e3; n++) {
+      r.fillStyle = Math.random() > 0.5 ? "#444" : "#222";
+      const o = Math.random() * 4 + 2;
+      r.fillRect(Math.random() * t, Math.random() * e, o, o);
+    }
+    r.strokeStyle = "rgba(255,255,255,0.05)", r.lineWidth = 2, r.beginPath();
+    for (let n = 0; n <= t; n += 64)
+      r.moveTo(n, 0), r.lineTo(n, e);
+    for (let n = 0; n <= e; n += 64)
+      r.moveTo(0, n), r.lineTo(t, n);
+    return r.stroke(), i;
+  }
+  static createCharacterSheet(t, e) {
+    const r = document.createElement("canvas");
+    r.width = 64 * 4, r.height = 64;
+    const n = r.getContext("2d");
+    for (let o = 0; o < 4; o++) {
+      const h = o * 64, c = 0, d = h + 64 / 2, u = c + 64 / 2, m = o % 2 === 0 ? 0 : -2, f = o === 1 ? 5 : o === 3 ? -5 : 0;
+      n.fillStyle = t, n.beginPath(), n.arc(d, u + m, 20, 0, Math.PI * 2), n.fill(), n.fillStyle = e, n.beginPath(), n.arc(d - 15, u + m + f, 8, 0, Math.PI * 2), n.arc(d + 15, u + m - f, 8, 0, Math.PI * 2), n.fill(), n.fillStyle = j(t), n.beginPath(), n.arc(d, u + m, 15, 0, Math.PI * 2), n.fill(), e === "#333" && (n.fillStyle = "#000", n.fillRect(d + 10, u + m - 5, 25, 6));
+    }
+    return r;
+  }
+}
+function j(a, t) {
+  return a;
+}
+class Z extends y {
+  constructor(t) {
+    super(), this.system = t;
+  }
+  /**
+   * Trigger an effect at the GameObject's current position.
+   * @param {string} effectName - 'confetti', 'fire', 'sparkle', etc.
+   * @param {object} options - override options
+   */
+  play(t, e = {}) {
+    const s = this.gameObject.x, i = this.gameObject.y;
+    switch (t) {
+      case "confetti":
+        this.system.confetti(s, i, e.count);
+        break;
+      case "fire":
+        this.system.fire(s, i, e.count);
+        break;
+      case "sparkle":
+        this.system.sparkle(s, i, e.count, e.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,
+          ...e
+        });
+    }
+  }
+}
+class tt extends y {
+  constructor() {
+    super(), this.intensity = 0, this.duration = 0, this.timer = 0, this.originalPos = { x: 0, y: 0 }, this.isShaking = !1;
+  }
+  shake(t = 5, e = 0.2) {
+    this.intensity = t, this.duration = e, this.timer = 0, this.isShaking = !0, this.timer === 0 && (this.originalPos.x = this.gameObject.x, this.originalPos.y = this.gameObject.y);
+  }
+  update(t) {
+    if (!this.isShaking) return;
+    if (this.timer += t, this.timer >= this.duration) {
+      this.isShaking = !1, this.gameObject.x = this.originalPos.x, this.gameObject.y = this.originalPos.y;
+      return;
+    }
+    const e = (Math.random() - 0.5) * 2 * this.intensity, s = (Math.random() - 0.5) * 2 * this.intensity;
+    this.gameObject.x = this.originalPos.x + e, this.gameObject.y = this.originalPos.y + s;
+  }
+}
+export {
+  V as Animator,
+  B as Collider,
+  y as Component,
+  P as DataService,
+  R as Director,
+  U as DopamineKernel,
+  p as EventBus,
+  W as Game,
+  Y as GameObject,
+  T as GameUI,
+  F as GlobalInput,
+  N as GlobalLoader,
+  G as GlobalPhysics,
+  H as IAudioSystem,
+  q as IParticleSystem,
+  X as IPhysicsSystem,
+  g as ISystem,
+  k as Input,
+  S as Loader,
+  Z as ParticleEmitter,
+  C as ParticleSystem,
+  _ as Physics,
+  A as PluginRegistry,
+  D as Renderer,
+  E as RewardSystem,
+  J as Scene,
+  tt as ScreenShake,
+  I as SoundManager,
+  z as Sprite,
+  K as System,
+  O as SystemRegistry,
+  Q as TextureGenerator,
+  L as Ticker,
+  b as Vector2,
+  $ as default
+};