dopaminejs 1.0.0

package/README.md

@@ -0,0 +1,84 @@
+# DopamineJS 🧠✨
+
+A lightweight, modular JavaScript library for adding "juice", rewards, and satisfying feedback to your HTML5 games.
+
+## Features
+
+-   **Reward System**: XP, Levels, Achievements, and Daily Streaks.
+-   **Game UI**: Beautiful, animated overlays for level-ups, notifications, and HUDs.
+-   **Particle Effects**: Confetti, sparkles, fire, and coin showers.
+-   **Sound Manager**: Synthesized retro sound effects (no external assets needed).
+-   **Data Persistence**: Automatic local storage management.
+
+## Installation
+
+### Via npm (Coming Soon)
+```bash
+npm install dopaminejs
+```
+
+### Direct Include
+Include the built script and CSS in your HTML:
+```html
+<link rel="stylesheet" href="dist/dopamine.css">
+<script src="dist/dopamine.js"></script>
+```
+
+## Quick Start
+
+```javascript
+import Dopamine from 'dopaminejs';
+
+// Initialize
+const game = new Dopamine();
+await game.init();
+
+// Access modules
+const { rewardSystem, particleSystem, soundManager, gameUI } = game;
+
+// 1. Award XP
+await rewardSystem.addXP(100, 'Enemy Defeated');
+
+// 2. Show Visual Feedback
+particleSystem.confetti(window.innerWidth / 2, window.innerHeight / 2);
+
+// 3. Play Sound
+soundManager.playSuccess();
+
+// 4. Show Notification
+gameUI.showNotification('Level Up!', 'legendary');
+```
+
+## Modules
+
+### RewardSystem
+Manages player progression.
+-   `addXP(amount, reason)`
+-   `recordGame(gameId, result)`
+-   `unlockAchievement(id)`
+
+### ParticleSystem
+Visual effects on a dedicated canvas layer.
+-   `confetti(x, y)`
+-   `sparkle(x, y)`
+-   `fire(x, y)`
+-   `coinShower(x, y)`
+
+### SoundManager
+Synthesized audio effects.
+-   `playJump()`
+-   `playScore()`
+-   `playGameOver()`
+-   `toggleMute()`
+
+### GameUI
+Overlay system for feedback.
+-   `showNotification(msg, type)`
+-   `showLevelUp(oldLvl, newLvl)`
+-   `showSummary(data)`
+
+## License
+MIT
+
+## Support
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/T6T01CQT4R)

package/dist/dopamine.mjs

@@ -0,0 +1,627 @@
+class v {
+  constructor() {
+    this.storage = window.localStorage;
+  }
+  /**
+   * Save data to local storage
+   * @param {string} key 
+   * @param {any} data 
+   */
+  async save(e, t) {
+    try {
+      const i = JSON.stringify(t);
+      return this.storage.setItem(e, i), !0;
+    } catch (i) {
+      return console.error("Error saving data:", i), !1;
+    }
+  }
+  /**
+   * Load data from local storage
+   * @param {string} key 
+   * @param {any} defaultValue 
+   */
+  async load(e, t = null) {
+    try {
+      const i = this.storage.getItem(e);
+      return i ? JSON.parse(i) : t;
+    } catch (i) {
+      return console.error("Error loading data:", i), t;
+    }
+  }
+  /**
+   * Clear specific data
+   * @param {string} key 
+   */
+  async clear(e) {
+    this.storage.removeItem(e);
+  }
+}
+const m = new v();
+class u {
+  constructor() {
+    this.player = null, this.achievements = this._initAchievements(), this.listeners = [];
+  }
+  /**
+   * Initialize the reward system for current player
+   * @returns {Promise<Object>} Player data
+   */
+  async init() {
+    return this.player = await m.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 m.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(e, t = "") {
+    const i = this.player.level;
+    this.player.xp += e;
+    const s = this._calculateLevel(this.player.xp), a = s > i;
+    return a && (this.player.level = s), await this.save(), this._emit("xp_gained", { amount: e, reason: t, leveledUp: a, newLevel: s }), a && this._emit("level_up", { oldLevel: i, newLevel: s }), { leveledUp: a, newLevel: s, xpGained: e };
+  }
+  /**
+   * Calculate level from XP (exponential curve)
+   */
+  _calculateLevel(e) {
+    const t = Math.floor((1 + Math.sqrt(1 + 8 * e / 50)) / 2);
+    return Math.max(1, t);
+  }
+  /**
+   * Get XP needed for next level
+   */
+  getXPForNextLevel() {
+    const e = this.player.level + 1, t = 50 * e * (e - 1), i = 50 * this.player.level * (this.player.level - 1);
+    return {
+      total: t,
+      needed: t - this.player.xp,
+      progress: (this.player.xp - i) / (t - i)
+    };
+  }
+  /**
+   * Record game result and award XP
+   * @param {string} gameName - Unique ID for the game
+   * @param {Object} result - Game-specific result data
+   */
+  async recordGame(e, t) {
+    this.player.stats[e] || (this.player.stats[e] = { totalPlays: 0, highScore: 0 });
+    const i = this.player.stats[e];
+    i.totalPlays++, this.player.totalGamesPlayed++, t.score !== void 0 && t.score > i.highScore && (i.highScore = t.score, this._emit("new_high_score", { gameName: e, score: t.score })), Object.keys(t).forEach((a) => {
+      a !== "score" && (i[a] = (i[a] || 0) + (typeof t[a] == "number" ? t[a] : 0));
+    });
+    let s = 10;
+    t.score && (s += Math.floor(t.score / 5)), s = Math.floor(s * this.getStreakMultiplier()), await this.addXP(s, `Played ${e}`), await this.checkAchievements(e, t), await this.save();
+  }
+  /**
+   * Check and unlock achievements
+   */
+  async checkAchievements(e, t) {
+    const i = [];
+    for (const [s, a] of Object.entries(this.achievements))
+      this.player.achievements[s] || a.check(this.player, e, t) && (await this.unlockAchievement(s), i.push(a));
+    return i;
+  }
+  /**
+   * Unlock an achievement
+   */
+  async unlockAchievement(e) {
+    const t = this.achievements[e];
+    return t ? (this.player.achievements[e] = {
+      unlockedAt: Date.now(),
+      seen: !1
+    }, await this.addXP(t.xp, `Achievement: ${t.name}`), this._emit("achievement_unlocked", t), await this.save(), !0) : !1;
+  }
+  /**
+   * Get all unlocked achievements
+   */
+  getUnlockedAchievements() {
+    return Object.entries(this.player.achievements).map(([e, t]) => ({
+      ...this.achievements[e],
+      id: e,
+      ...t
+    }));
+  }
+  /**
+   * Get achievements user hasn't seen the notification for yet
+   */
+  getUnseenAchievements() {
+    return this.getUnlockedAchievements().filter((e) => !e.seen);
+  }
+  /**
+   * Mark achievements as seen
+   */
+  async markAchievementsSeen(e) {
+    for (const t of e)
+      this.player.achievements[t] && (this.player.achievements[t].seen = !0);
+    await this.save();
+  }
+  /**
+   * Update daily streak
+   */
+  _updateDailyStreak() {
+    const e = this._getTodayDateString(), t = this.player.streak.lastPlayDate;
+    if (t === e)
+      return;
+    const i = this._getYesterdayDateString();
+    t === i ? (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 = e;
+  }
+  /**
+   * Get streak multiplier for XP
+   */
+  getStreakMultiplier() {
+    const e = this.player.streak.current;
+    return e >= 7 ? 2 : e >= 5 ? 1.5 : e >= 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 e = /* @__PURE__ */ new Date();
+    return e.setDate(e.getDate() - 1), e.toISOString().split("T")[0];
+  }
+  /**
+   * Event system for UI updates
+   */
+  on(e, t) {
+    this.listeners.push({ event: e, callback: t });
+  }
+  _emit(e, t) {
+    this.listeners.filter((i) => i.event === e).forEach((i) => i.callback(t));
+  }
+  /**
+   * 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: (e) => e.totalGamesPlayed >= 1
+      },
+      level_5: {
+        name: "Rising Star",
+        description: "Reach level 5",
+        icon: "⭐",
+        xp: 100,
+        check: (e) => e.level >= 5
+      },
+      level_10: {
+        name: "Expert Player",
+        description: "Reach level 10",
+        icon: "🏆",
+        xp: 250,
+        check: (e) => e.level >= 10
+      },
+      streak_3: {
+        name: "Dedicated",
+        description: "Play 3 days in a row",
+        icon: "🔥",
+        xp: 100,
+        check: (e) => e.streak.current >= 3
+      },
+      streak_7: {
+        name: "Unstoppable",
+        description: "Play 7 days in a row",
+        icon: "💥",
+        xp: 300,
+        check: (e) => e.streak.current >= 7
+      }
+    };
+  }
+  /**
+   * Register custom achievements
+   * @param {Object} achievements 
+   */
+  registerAchievements(e) {
+    this.achievements = { ...this.achievements, ...e };
+  }
+}
+const y = new u();
+class f {
+  constructor(e = "dopamine-particle-canvas") {
+    this.canvasId = e, this.canvas = document.getElementById(e), this.canvas || (this.canvas = document.createElement("canvas"), this.canvas.id = e, this.canvas.style.position = "fixed", this.canvas.style.top = "0", this.canvas.style.left = "0", this.canvas.style.width = "100%", this.canvas.style.height = "100%", this.canvas.style.pointerEvents = "none", this.canvas.style.zIndex = "9999", document.body.appendChild(this.canvas)), this.ctx = this.canvas.getContext("2d"), this.particles = [], this.isAnimating = !1, this._resize(), window.addEventListener("resize", () => this._resize());
+  }
+  _resize() {
+    this.canvas.width = window.innerWidth, this.canvas.height = window.innerHeight;
+  }
+  /**
+   * Confetti explosion (for achievements, level ups)
+   */
+  confetti(e, t, i = 50) {
+    const s = ["#ff6b6b", "#4ecdc4", "#45b7d1", "#f7dc6f", "#c06c84", "#6c5ce7"];
+    for (let a = 0; a < i; a++)
+      this.particles.push({
+        x: e,
+        y: t,
+        vx: (Math.random() - 0.5) * 10,
+        vy: (Math.random() - 0.5) * 10 - 5,
+        rotation: Math.random() * Math.PI * 2,
+        rotationSpeed: (Math.random() - 0.5) * 0.2,
+        color: s[Math.floor(Math.random() * s.length)],
+        size: Math.random() * 8 + 4,
+        life: 1,
+        decay: 0.015 + Math.random() * 0.01,
+        gravity: 0.3,
+        type: "confetti"
+      });
+    this._startAnimation();
+  }
+  /**
+   * Sparkle effect (for score milestones, combos)
+   */
+  sparkle(e, t, i = 20, s = "#ffd700") {
+    for (let a = 0; a < i; a++) {
+      const n = Math.PI * 2 / i * a, o = 2 + Math.random() * 3;
+      this.particles.push({
+        x: e,
+        y: t,
+        vx: Math.cos(n) * o,
+        vy: Math.sin(n) * o,
+        color: s,
+        size: Math.random() * 4 + 2,
+        life: 1,
+        decay: 0.02,
+        gravity: -0.1,
+        // Slight upward drift
+        type: "spark"
+      });
+    }
+    this._startAnimation();
+  }
+  /**
+   * Coin shower (for collecting coins)
+   */
+  coinShower(e, t, i = 10) {
+    for (let s = 0; s < i; s++)
+      this.particles.push({
+        x: e + (Math.random() - 0.5) * 100,
+        y: t - Math.random() * 50,
+        vx: (Math.random() - 0.5) * 3,
+        vy: Math.random() * -2 - 3,
+        color: "#ffd700",
+        size: 12,
+        life: 1,
+        decay: 0.012,
+        gravity: 0.4,
+        type: "coin"
+      });
+    this._startAnimation();
+  }
+  /**
+   * Fire particles (for streaks, combos)
+   */
+  fire(e, t, i = 15) {
+    const s = ["#ff6b00", "#ff8800", "#ffaa00", "#ff4400"];
+    for (let a = 0; a < i; a++)
+      this.particles.push({
+        x: e + (Math.random() - 0.5) * 20,
+        y: t,
+        vx: (Math.random() - 0.5) * 2,
+        vy: -Math.random() * 3 - 2,
+        color: s[Math.floor(Math.random() * s.length)],
+        size: Math.random() * 6 + 3,
+        life: 1,
+        decay: 0.025,
+        gravity: -0.2,
+        // Upward
+        type: "fire"
+      });
+    this._startAnimation();
+  }
+  /**
+   * Star burst (for "perfect" moments)
+   */
+  starBurst(e, t, i = 8) {
+    for (let s = 0; s < i; s++) {
+      const a = Math.PI * 2 / i * s, n = 4;
+      this.particles.push({
+        x: e,
+        y: t,
+        vx: Math.cos(a) * n,
+        vy: Math.sin(a) * n,
+        rotation: a,
+        color: "#ffffff",
+        size: 15,
+        life: 1,
+        decay: 0.03,
+        gravity: 0,
+        type: "star"
+      });
+    }
+    this._startAnimation();
+  }
+  _startAnimation() {
+    this.isAnimating || (this.isAnimating = !0, this._animate());
+  }
+  _animate() {
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    for (let e = this.particles.length - 1; e >= 0; e--) {
+      const t = this.particles[e];
+      if (t.vy += t.gravity, t.x += t.vx, t.y += t.vy, t.life -= t.decay, t.rotationSpeed && (t.rotation += t.rotationSpeed), t.life <= 0) {
+        this.particles.splice(e, 1);
+        continue;
+      }
+      this.ctx.save(), this.ctx.globalAlpha = t.life, this.ctx.fillStyle = t.color, t.type === "confetti" ? (this.ctx.translate(t.x, t.y), this.ctx.rotate(t.rotation), this.ctx.fillRect(-t.size / 2, -t.size / 2, t.size, t.size / 2)) : t.type === "coin" ? (this.ctx.beginPath(), this.ctx.arc(t.x, t.y, t.size, 0, Math.PI * 2), this.ctx.fill(), this.ctx.fillStyle = "#ffee88", this.ctx.beginPath(), this.ctx.arc(t.x - t.size / 3, t.y - t.size / 3, t.size / 3, 0, Math.PI * 2), this.ctx.fill()) : t.type === "star" ? this._drawStar(t.x, t.y, 5, t.size, t.size / 2, t.rotation) : (this.ctx.beginPath(), this.ctx.arc(t.x, t.y, t.size, 0, Math.PI * 2), this.ctx.fill()), this.ctx.restore();
+    }
+    this.particles.length > 0 ? requestAnimationFrame(() => this._animate()) : this.isAnimating = !1;
+  }
+  _drawStar(e, t, i, s, a, n) {
+    let o = Math.PI / 2 * 3 + n;
+    const d = Math.PI / i;
+    this.ctx.beginPath(), this.ctx.moveTo(e, t - s);
+    for (let p = 0; p < i; p++) {
+      let c = e + Math.cos(o) * s, h = t + Math.sin(o) * s;
+      this.ctx.lineTo(c, h), o += d, c = e + Math.cos(o) * a, h = t + Math.sin(o) * a, this.ctx.lineTo(c, h), o += d;
+    }
+    this.ctx.lineTo(e, t - s), this.ctx.closePath(), this.ctx.fill();
+  }
+  /**
+   * Clear all particles
+   */
+  clear() {
+    this.particles = [], this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+}
+const l = new f();
+class g {
+  constructor() {
+    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(e, t, i) {
+    const s = e / i * 100;
+    this.xpBar.style.width = `${Math.min(100, s)}%`, this.xpText.textContent = `${e} / ${i} XP`, this.xpBar.style.animation = "none", setTimeout(() => {
+      this.xpBar.style.animation = "xp-pulse 0.3s ease-out";
+    }, 10);
+  }
+  /**
+   * Update level display
+   */
+  updateLevel(e) {
+    this.levelDisplay.textContent = e;
+    const t = document.getElementById("level-badge");
+    t.style.animation = "none", setTimeout(() => {
+      t.style.animation = "level-pulse 0.5s ease-out";
+    }, 10);
+  }
+  /**
+   * Update streak display
+   */
+  updateStreak(e) {
+    this.streakDisplay.textContent = e;
+    const t = document.getElementById("streak-badge");
+    e >= 7 ? t.style.background = "linear-gradient(135deg, #ff6b00 0%, #ff4400 100%)" : e >= 3 && (t.style.background = "linear-gradient(135deg, #ff8800 0%, #ff6b00 100%)");
+  }
+  /**
+   * Show achievement unlocked popup
+   */
+  showAchievement(e) {
+    const t = document.createElement("div");
+    t.className = "achievement-popup", t.innerHTML = `
+            <div class="achievement-shine"></div>
+            <div class="achievement-content">
+                <div class="achievement-icon">${e.icon}</div>
+                <div class="achievement-info">
+                    <div class="achievement-title">Achievement Unlocked!</div>
+                    <div class="achievement-name">${e.name}</div>
+                    <div class="achievement-desc">${e.description}</div>
+                    <div class="achievement-xp">+${e.xp} XP</div>
+                </div>
+            </div>
+        `, document.body.appendChild(t), setTimeout(() => {
+      const i = t.getBoundingClientRect();
+      l.confetti(i.left + i.width / 2, i.top + i.height / 2, 40);
+    }, 300), setTimeout(() => {
+      t.style.animation = "slideOut 0.3s ease-in forwards", setTimeout(() => t.remove(), 300);
+    }, 4e3);
+  }
+  /**
+   * Show level up screen
+   */
+  showLevelUp(e, t) {
+    const i = document.createElement("div");
+    i.className = "level-up-overlay", i.innerHTML = `
+            <div class="level-up-content">
+                <div class="level-up-title">LEVEL UP!</div>
+                <div class="level-up-number">${t}</div>
+                <div class="level-up-subtitle">Amazing progress!</div>
+            </div>
+        `, document.body.appendChild(i), setTimeout(() => {
+      for (let s = 0; s < 5; s++)
+        setTimeout(() => {
+          const a = Math.random() * window.innerWidth, n = Math.random() * window.innerHeight * 0.6;
+          l.confetti(a, n, 30);
+        }, s * 200);
+    }, 300), setTimeout(() => {
+      i.style.opacity = "0", setTimeout(() => i.remove(), 500);
+    }, 2500);
+  }
+  /**
+   * Show floating text (e.g., "+50 XP", "COMBO!")
+   */
+  showFloatingText(e, t, i, s = "#ffd700", a = "24px") {
+    const n = document.createElement("div");
+    n.className = "floating-text", n.textContent = e, n.style.left = t + "px", n.style.top = i + "px", n.style.color = s, n.style.fontSize = a, document.body.appendChild(n), setTimeout(() => n.remove(), 2e3);
+  }
+  /**
+   * Show combo multiplier
+   */
+  showCombo(e, t, i) {
+    this.showFloatingText(`${e}× COMBO!`, t, i, "#ff6b6b", "32px"), l.fire(t, i, 20);
+  }
+  /**
+   * Show "near miss"indicator
+   */
+  showNearMiss(e, t) {
+    this.showFloatingText("CLOSE CALL!", e, t, "#45b7d1", "20px"), l.sparkle(e, t, 15, "#45b7d1");
+  }
+  /**
+   * Show lucky moment (random multiplier)
+   */
+  showLuckyMoment(e, t, i) {
+    this.showFloatingText(`LUCKY ${e}×!`, t, i, "#ffd700", "36px"), l.starBurst(t, i, 12), l.confetti(t, i, 25);
+  }
+  /**
+   * Show generic notification
+   */
+  showNotification(e, t = "normal") {
+    const i = window.innerWidth / 2, s = window.innerHeight / 3;
+    t === "legendary" ? this.showLuckyMoment(e, i, s) : t === "rare" ? this.showCombo(e, i, s) : this.showFloatingText(e, i, s, "#fff", "24px");
+  }
+  /**
+   * Show Game Over Summary
+   */
+  showSummary(e) {
+    const t = document.createElement("div");
+    t.className = "message-box", t.style.display = "flex", t.style.position = "absolute", t.style.top = "50%", t.style.left = "50%", t.style.transform = "translate(-50%, -50%)", t.style.zIndex = "1000";
+    let i = "";
+    e.metrics && (i = Object.entries(e.metrics).map(([s, a]) => `<div style="display:flex;justify-content:space-between;width:100%"><span>${s}:</span> <strong>${a}</strong></div>`).join("")), t.innerHTML = `
+            <h1>Game Over</h1>
+            <div style="font-size: 3rem; font-weight: bold; color: #e06020; margin: 10px 0;">${e.score}</div>
+            <div style="width: 100%; margin-bottom: 20px;">
+                ${i}
+            </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(t);
+  }
+}
+const x = new g();
+class w {
+  constructor() {
+    this.audioContext = null, this.muted = localStorage.getItem("dopamineSoundsMuted") === "true";
+  }
+  /**
+   * Initialize Audio Context (must be called after user interaction)
+   */
+  initAudio() {
+    this.audioContext || (this.audioContext = new (window.AudioContext || window.webkitAudioContext)());
+  }
+  /**
+   * Toggle mute state
+   * @returns {boolean} New mute state
+   */
+  toggleMute() {
+    return this.muted = !this.muted, localStorage.setItem("dopamineSoundsMuted", this.muted), this.muted;
+  }
+  /**
+   * Play a synthesized tone
+   * @param {number} frequency 
+   * @param {number} duration 
+   * @param {string} type - 'sine', 'square', 'sawtooth', 'triangle'
+   * @param {number} volume 
+   */
+  playTone(e, t, i = "sine", s = 0.3) {
+    if (this.muted) return;
+    this.initAudio();
+    const a = this.audioContext.createOscillator(), n = this.audioContext.createGain();
+    a.connect(n), n.connect(this.audioContext.destination), a.frequency.value = e, a.type = i, n.gain.setValueAtTime(s, this.audioContext.currentTime), n.gain.exponentialRampToValueAtTime(0.01, this.audioContext.currentTime + t), a.start(this.audioContext.currentTime), a.stop(this.audioContext.currentTime + t);
+  }
+  // --- Presets ---
+  playJump() {
+    this.playTone(400, 0.1, "square", 0.2);
+  }
+  playScore() {
+    this.playTone(800, 0.15, "sine", 0.25), setTimeout(() => this.playTone(1e3, 0.15, "sine", 0.25), 50);
+  }
+  playGameOver() {
+    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() {
+    this.playTone(600, 0.05, "sine", 0.1);
+  }
+  playSuccess() {
+    this.playTone(600, 0.1, "sine", 0.2), setTimeout(() => this.playTone(800, 0.2, "sine", 0.2), 100);
+  }
+  playError() {
+    this.playTone(200, 0.2, "sawtooth", 0.3);
+  }
+}
+const b = new w();
+class M {
+  constructor(e = {}) {
+    this.config = e;
+  }
+  async init() {
+    return await y.init(), console.log("DopamineJS Initialized 🚀"), {
+      rewardSystem: y,
+      gameUI: x,
+      particleSystem: l,
+      soundManager: b
+    };
+  }
+}
+export {
+  m as dataService,
+  M as default,
+  x as gameUI,
+  l as particleSystem,
+  y as rewardSystem,
+  b as soundManager
+};