dopaminejs 1.1.0 → 2.0.0

package/src/dopamine/index.js

@@ -0,0 +1,62 @@
+import { RewardSystem } from './core/RewardSystem.js';
+import { DataService } from './core/DataService.js';
+import { GameUI } from './ui/GameUI.js';
+import { ParticleSystem } from './effects/ParticleSystem.js';
+import { SoundManager } from './audio/SoundManager.js';
+import './ui/dopamine.css';
+
+export { RewardSystem, DataService, GameUI, ParticleSystem, SoundManager };
+
+export default class Dopamine {
+    constructor(config = {}) {
+        this.config = config;
+
+        // Initialize subsystems with config
+        this.dataService = new DataService(config.data || {});
+        this.rewardSystem = new RewardSystem(this.dataService, config.rewards || {});
+        this.soundManager = new SoundManager(config.sound || {});
+        this.particleSystem = new ParticleSystem(config.particles || {});
+        this.gameUI = new GameUI(this.particleSystem);
+
+        // Bind UI to RewardSystem events
+        this._bindEvents();
+    }
+
+    async init() {
+        await this.rewardSystem.init();
+        console.log('DopamineJS Initialized 🚀');
+        return {
+            rewardSystem: this.rewardSystem,
+            gameUI: this.gameUI,
+            particleSystem: this.particleSystem,
+            soundManager: this.soundManager
+        };
+    }
+
+    _bindEvents() {
+        this.rewardSystem.on('xp_gained', (data) => {
+            const { total, needed } = this.rewardSystem.getXPForNextLevel();
+            this.gameUI.updateXP(this.rewardSystem.player.xp, needed, total);
+
+            if (data.xpGained > 0) {
+                // Show floating text for XP gain
+                // We might need a way to know WHERE to show this, or just show it in a standard place
+                // For now, let's just update the bar
+            }
+        });
+
+        this.rewardSystem.on('level_up', (data) => {
+            this.gameUI.updateLevel(data.newLevel);
+            this.gameUI.showLevelUp(data.oldLevel, data.newLevel);
+        });
+
+        this.rewardSystem.on('achievement_unlocked', (achievement) => {
+            this.gameUI.showAchievement(achievement);
+        });
+
+        this.rewardSystem.on('new_high_score', (data) => {
+            this.gameUI.showNotification(`New High Score: ${data.score}!`, 'legendary');
+            this.soundManager.playSuccess();
+        });
+    }
+}

package/src/dopamine/utils/TextureGenerator.js

@@ -0,0 +1,90 @@
+/**
+ * Generates procedural textures for prototyping.
+ */
+export class TextureGenerator {
+    static createGround(width, height, color = '#333') {
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+
+        ctx.fillStyle = color;
+        ctx.fillRect(0, 0, width, height);
+
+        // Noise / Grit
+        for (let i = 0; i < 1000; i++) {
+            ctx.fillStyle = Math.random() > 0.5 ? '#444' : '#222';
+            const size = Math.random() * 4 + 2;
+            ctx.fillRect(Math.random() * width, Math.random() * height, size, size);
+        }
+
+        // Grid lines overlay (faint)
+        ctx.strokeStyle = 'rgba(255,255,255,0.05)';
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        for (let i = 0; i <= width; i += 64) {
+            ctx.moveTo(i, 0); ctx.lineTo(i, height);
+        }
+        for (let i = 0; i <= height; i += 64) {
+            ctx.moveTo(0, i); ctx.lineTo(width, i);
+        }
+        ctx.stroke();
+
+        return canvas;
+    }
+
+    static createCharacterSheet(colorBody, colorDetail) {
+        // Create a 4-frame walk cycle strip (Vertical or Horizontal)
+        // Let's do Horizontal: 64x64 frames, 4 frames -> 256x64 image
+        const cellW = 64;
+        const cellH = 64;
+        const canvas = document.createElement('canvas');
+        canvas.width = cellW * 4;
+        canvas.height = cellH;
+        const ctx = canvas.getContext('2d');
+
+        for (let i = 0; i < 4; i++) {
+            const x = i * cellW;
+            const y = 0;
+            const cx = x + cellW / 2;
+            const cy = y + cellH / 2;
+
+            // -- Frame Animation Variances --
+            // Bobbing effect
+            const bob = (i % 2 === 0) ? 0 : -2;
+            // Leg swing (simulated by shape change or just simple offset)
+            const legOffset = (i === 1) ? 5 : (i === 3 ? -5 : 0);
+
+            // Body
+            ctx.fillStyle = colorBody;
+            ctx.beginPath();
+            ctx.arc(cx, cy + bob, 20, 0, Math.PI * 2);
+            ctx.fill();
+
+            // Shoulders/Hands (Top Down)
+            ctx.fillStyle = colorDetail;
+            ctx.beginPath();
+            ctx.arc(cx - 15, cy + bob + legOffset, 8, 0, Math.PI * 2); // Left hand
+            ctx.arc(cx + 15, cy + bob - legOffset, 8, 0, Math.PI * 2); // Right hand
+            ctx.fill();
+
+            // Head/Helmet
+            ctx.fillStyle = adjustColor(colorBody, -20);
+            ctx.beginPath();
+            ctx.arc(cx, cy + bob, 15, 0, Math.PI * 2);
+            ctx.fill();
+
+            // Gun (if soldier)
+            if (colorDetail === '#333') { // Hacky check
+                ctx.fillStyle = '#000';
+                ctx.fillRect(cx + 10, cy + bob - 5, 25, 6);
+            }
+        }
+
+        return canvas;
+    }
+}
+
+function adjustColor(color, amount) {
+    return color; // Placeholder for color darkening logic
+}

package/src/index.js

@@ -1,62 +1,34 @@
-import { RewardSystem } from './core/RewardSystem.js';
-import { DataService } from './core/DataService.js';
-import { GameUI } from './ui/GameUI.js';
-import { ParticleSystem } from './effects/ParticleSystem.js';
-import { SoundManager } from './audio/SoundManager.js';
-import './ui/dopamine.css';
-
-export { RewardSystem, DataService, GameUI, ParticleSystem, SoundManager };
-
-export default class Dopamine {
-    constructor(config = {}) {
-        this.config = config;
-
-        // Initialize subsystems with config
-        this.dataService = new DataService(config.data || {});
-        this.rewardSystem = new RewardSystem(this.dataService, config.rewards || {});
-        this.soundManager = new SoundManager(config.sound || {});
-        this.particleSystem = new ParticleSystem(config.particles || {});
-        this.gameUI = new GameUI(this.particleSystem);
-
-        // Bind UI to RewardSystem events
-        this._bindEvents();
-    }
-
-    async init() {
-        await this.rewardSystem.init();
-        console.log('DopamineJS Initialized 🚀');
-        return {
-            rewardSystem: this.rewardSystem,
-            gameUI: this.gameUI,
-            particleSystem: this.particleSystem,
-            soundManager: this.soundManager
-        };
-    }
-
-    _bindEvents() {
-        this.rewardSystem.on('xp_gained', (data) => {
-            const { total, needed } = this.rewardSystem.getXPForNextLevel();
-            this.gameUI.updateXP(this.rewardSystem.player.xp, needed, total);
-
-            if (data.xpGained > 0) {
-                // Show floating text for XP gain
-                // We might need a way to know WHERE to show this, or just show it in a standard place
-                // For now, let's just update the bar
-            }
-        });
-
-        this.rewardSystem.on('level_up', (data) => {
-            this.gameUI.updateLevel(data.newLevel);
-            this.gameUI.showLevelUp(data.oldLevel, data.newLevel);
-        });
-
-        this.rewardSystem.on('achievement_unlocked', (achievement) => {
-            this.gameUI.showAchievement(achievement);
-        });
-
-        this.rewardSystem.on('new_high_score', (data) => {
-            this.gameUI.showNotification(`New High Score: ${data.score}!`, 'legendary');
-            this.soundManager.playSuccess();
-        });
-    }
-}
+import Dopamine from './dopamine/index.js';
+
+// Re-export legacy systems
+export * from './dopamine/index.js';
+
+// Export New Kernel Architecture (Phase 0)
+export { DopamineKernel } from './core/DopamineKernel.js';
+export { EventBus } from './core/EventBus.js';
+export { SystemRegistry } from './core/SystemRegistry.js';
+export { PluginRegistry } from './core/PluginRegistry.js';
+
+// Export System Interfaces
+export * from './interfaces/index.js';
+
+// Export New Engine Core
+export { Game } from './core/Game.js';
+export { Scene } from './core/Scene.js';
+export { GameObject } from './core/GameObject.js';
+export { Component } from './core/Component.js';
+export { Renderer } from './renderer/Renderer.js';
+export { Ticker } from './systems/Ticker.js';
+export { Loader, GlobalLoader } from './systems/Loader.js';
+export { Input, GlobalInput } from './systems/Input.js';
+export { Director } from './systems/Director.js';
+export { Physics, GlobalPhysics } from './systems/Physics.js';
+export { Vector2 } from './core/Vector2.js';
+export { Collider } from './core/Collider.js';
+export { Sprite } from './core/Sprite.js';
+export { Animator } from './core/Animator.js';
+export { TextureGenerator } from './dopamine/utils/TextureGenerator.js';
+export { ParticleEmitter, ScreenShake } from './dopamine/components/index.js';
+
+// Export default for backward compatibility
+export default Dopamine;

package/src/interfaces/IAudioSystem.js

@@ -0,0 +1,58 @@
+import { ISystem } from './ISystem.js';
+
+/**
+ * IAudioSystem - Interface for audio implementations
+ * 
+ * Allows different audio engines (Web Audio, Howler.js, etc.) to be swapped
+ */
+export const IAudioSystem = {
+    ...ISystem,
+
+    /**
+     * Register a sound with a key
+     * @param {string} key - Sound identifier
+     * @param {string} url - Path to audio file
+     */
+    registerSound(key, url) { },
+
+    /**
+     * Preload multiple sounds
+     * @param {Object} soundMap - Map of key -> url
+     * @returns {Promise<void>}
+     */
+    preloadSounds(soundMap) { },
+
+    /**
+     * Play a sound by key
+     * @param {string} key - Sound identifier
+     * @param {Object} options - Playback options (volume, loop, etc.)
+     */
+    play(key, options) { },
+
+    /**
+     * 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(frequency, duration, type, volume) { },
+
+    /**
+     * Stop a playing sound
+     * @param {string} key - Sound identifier
+     */
+    stop(key) { },
+
+    /**
+     * Toggle mute state
+     * @returns {boolean} - New mute state
+     */
+    toggleMute() { },
+
+    /**
+     * Set master volume
+     * @param {number} volume - Volume (0-1)
+     */
+    setVolume(volume) { },
+};

package/src/interfaces/IParticleSystem.js

@@ -0,0 +1,51 @@
+import { ISystem } from './ISystem.js';
+
+/**
+ * IParticleSystem - Interface for particle system implementations
+ * 
+ * Allows different renderers (Canvas, WebGL, custom) to be swapped
+ */
+export const IParticleSystem = {
+    ...ISystem,
+
+    /**
+     * Register a sprite for particles
+     * @param {string} key - Sprite identifier
+     * @param {string} url - Path to image
+     */
+    registerSprite(key, url) { },
+
+    /**
+     * Register a custom effect
+     * @param {string} name - Effect name
+     * @param {Function} callback - Effect function (x, y, ...args) => void
+     */
+    registerEffect(name, callback) { },
+
+    /**
+     * 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(name, x, y, ...args) { },
+
+    /**
+     * Emit particles with custom configuration
+     * @param {Object} config - Particle configuration
+     */
+    emit(config) { },
+
+    /**
+     * Clear all particles
+     */
+    clear() { },
+
+    // Built-in effects (optional, but recommended)
+    confetti(x, y, count) { },
+    coinShower(x, y, count) { },
+    sparkle(x, y, count, color) { },
+    fire(x, y, count) { },
+    starBurst(x, y, count) { },
+};

package/src/interfaces/IPhysicsSystem.js

@@ -0,0 +1,52 @@
+import { ISystem } from './ISystem.js';
+
+/**
+ * IPhysicsSystem - Interface for physics implementations
+ * 
+ * Allows different physics engines (custom, Matter.js, Box2D) to be swapped
+ */
+export const IPhysicsSystem = {
+    ...ISystem,
+
+    /**
+     * Add a physics body to the simulation
+     * @param {Object} body - Physics body (implementation-specific)
+     */
+    addBody(body) { },
+
+    /**
+     * Remove a physics body from the simulation
+     * @param {Object} body - Physics body to remove
+     */
+    removeBody(body) { },
+
+    /**
+     * Check collision between two bodies
+     * @param {Object} a - First body
+     * @param {Object} b - Second body
+     * @returns {boolean} - True if colliding
+     */
+    checkCollision(a, b) { },
+
+    /**
+     * 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(origin, direction, distance) { },
+
+    /**
+     * Set gravity for the physics world
+     * @param {number} x - Gravity X component
+     * @param {number} y - Gravity Y component
+     */
+    setGravity(x, y) { },
+
+    /**
+     * Step the physics simulation
+     * @param {number} dt - Delta time
+     */
+    step(dt) { },
+};

package/src/interfaces/ISystem.js

@@ -0,0 +1,48 @@
+/**
+ * ISystem - Base interface for all systems
+ * 
+ * All systems should implement this interface.
+ * Methods are optional - only implement what you need.
+ */
+export const ISystem = {
+    /**
+     * Called when system is registered to the kernel
+     * @param {DopamineKernel} kernel - The kernel instance
+     */
+    init(kernel) { },
+
+    /**
+     * Called each frame (variable timestep)
+     * @param {number} dt - Delta time in seconds
+     */
+    update(dt) { },
+
+    /**
+     * Called at fixed timestep (for physics)
+     * @param {number} dt - Fixed delta time
+     */
+    fixedUpdate(dt) { },
+
+    /**
+     * Called when system is unregistered
+     */
+    destroy() { },
+};
+
+/**
+ * Base System class that implements ISystem
+ * Systems can extend this for convenience
+ */
+export class System {
+    constructor() {
+        this.kernel = null;
+    }
+
+    init(kernel) {
+        this.kernel = kernel;
+    }
+
+    update(dt) { }
+    fixedUpdate(dt) { }
+    destroy() { }
+}

package/src/interfaces/index.js

@@ -0,0 +1,7 @@
+/**
+ * Export all system interfaces
+ */
+export { ISystem, System } from './ISystem.js';
+export { IPhysicsSystem } from './IPhysicsSystem.js';
+export { IAudioSystem } from './IAudioSystem.js';
+export { IParticleSystem } from './IParticleSystem.js';

package/src/renderer/Renderer.js

@@ -0,0 +1,37 @@
+/**
+ * Handles the Canvas and Context for rendering.
+ */
+export class Renderer {
+    constructor(options = {}) {
+        this.width = options.width || 800;
+        this.height = options.height || 600;
+        this.backgroundColor = options.backgroundColor || '#000000';
+
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.width;
+        this.canvas.height = this.height;
+        this.ctx = this.canvas.getContext('2d');
+
+        // Append to body or specified container
+        const parent = options.parent ?
+            (typeof options.parent === 'string' ? document.querySelector(options.parent) : options.parent)
+            : document.body;
+
+        parent.appendChild(this.canvas);
+    }
+
+    /**
+     * Clear the canvas.
+     */
+    clear() {
+        this.ctx.fillStyle = this.backgroundColor;
+        this.ctx.fillRect(0, 0, this.width, this.height);
+    }
+
+    resize(width, height) {
+        this.width = width;
+        this.height = height;
+        this.canvas.width = width;
+        this.canvas.height = height;
+    }
+}

package/src/systems/Director.js

@@ -0,0 +1,27 @@
+/**
+ * Manages Scene transitions and state.
+ */
+export class Director {
+    constructor(game) {
+        this.game = game;
+        this.currentScene = null;
+    }
+
+    /**
+     * Switch to a new scene.
+     * @param {Scene} scene 
+     */
+    run(scene) {
+        if (this.currentScene) {
+            this.currentScene.onExit();
+        }
+
+        this.currentScene = scene;
+        this.currentScene.game = this.game;
+
+        // Let the game know (if game engine needs to reference it directly)
+        this.game.scene = scene;
+
+        scene.onEnter();
+    }
+}

package/src/systems/Input.js

@@ -0,0 +1,77 @@
+/**
+ * Input System
+ * Tracks keyboard and mouse input.
+ */
+export class Input {
+    constructor() {
+        this.keys = new Map();
+        this.mouse = { x: 0, y: 0, buttons: new Map() };
+        this.kernel = null;
+
+        // Bind event listeners
+        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(kernel) {
+        this.kernel = kernel;
+
+        // Attach event listeners
+        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, true);
+    }
+
+    _onKeyUp(e) {
+        this.keys.set(e.key, false);
+    }
+
+    _onMouseMove(e) {
+        this.mouse.x = e.clientX;
+        this.mouse.y = e.clientY;
+    }
+
+    _onMouseDown(e) {
+        this.mouse.buttons.set(e.button, true);
+    }
+
+    _onMouseUp(e) {
+        this.mouse.buttons.set(e.button, false);
+    }
+
+    isKeyDown(key) {
+        return this.keys.get(key) || false;
+    }
+
+    isMouseButtonDown(button = 0) {
+        return this.mouse.buttons.get(button) || false;
+    }
+}
+
+// DEPRECATED: Keep for backward compatibility
+export const GlobalInput = new Input();
+// Note: GlobalInput won't have listeners attached unless init() is called
+console.warn('[DopamineJS] GlobalInput is deprecated. Use kernel.input instead.');

package/src/systems/Loader.js

@@ -0,0 +1,44 @@
+/**
+ * Asset Loader
+ * Loads and caches images, audio, etc.
+ */
+export class Loader {
+    constructor() {
+        this.assets = new Map();
+        this.kernel = null;
+    }
+
+    /**
+     * ISystem interface - called when registered
+     */
+    init(kernel) {
+        this.kernel = kernel;
+    }
+
+    /**
+     * ISystem interface - cleanup
+     */
+    destroy() {
+        this.assets.clear();
+    }
+
+    async loadImage(key, url) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                this.assets.set(key, img);
+                resolve(img);
+            };
+            img.onerror = reject;
+            img.src = url;
+        });
+    }
+
+    get(key) {
+        return this.assets.get(key);
+    }
+}
+
+// DEPRECATED: Keep for backward compatibility
+export const GlobalLoader = new Loader();
+console.warn('[DopamineJS] GlobalLoader is deprecated. Use kernel.loader instead.');