dopaminejs 1.2.0 → 2.0.0

package/src/core/SystemRegistry.js

@@ -0,0 +1,242 @@
+/**
+ * SystemRegistry - Manages system lifecycle and dependency resolution
+ * 
+ * Systems are registered with names and can have dependencies on other systems.
+ * The registry ensures systems are updated in the correct order based on dependencies.
+ */
+export class SystemRegistry {
+    constructor(kernel) {
+        this.kernel = kernel;
+
+        // Map<systemName, { system, priority, dependencies }>
+        this._systems = new Map();
+
+        // Pre-computed update order for performance
+        this._updateOrder = [];
+        this._fixedUpdateOrder = [];
+
+        // Flag to track if order needs recomputation
+        this._needsRecompute = false;
+    }
+
+    /**
+     * 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(name, system, { priority = 0, dependencies = [] } = {}) {
+        if (this._systems.has(name)) {
+            console.warn(`[SystemRegistry] System "${name}" already registered. Replacing.`);
+            this.unregister(name);
+        }
+
+        // Validate dependencies exist
+        for (const dep of dependencies) {
+            if (!this._systems.has(dep)) {
+                console.warn(`[SystemRegistry] Dependency "${dep}" not found for system "${name}"`);
+            }
+        }
+
+        // Store system metadata
+        this._systems.set(name, {
+            system,
+            priority,
+            dependencies,
+        });
+
+        // Initialize the system
+        if (system.init) {
+            system.init(this.kernel);
+        }
+
+        // Mark for recomputation
+        this._needsRecompute = true;
+
+        // Emit event
+        this.kernel.events.emit('system_registered', { name, system });
+
+        return this;
+    }
+
+    /**
+     * Get a system by name
+     * @param {string} name - System name
+     * @returns {Object|undefined} - System instance
+     */
+    get(name) {
+        const entry = this._systems.get(name);
+        return entry ? entry.system : undefined;
+    }
+
+    /**
+     * Check if a system is registered
+     * @param {string} name - System name
+     * @returns {boolean}
+     */
+    has(name) {
+        return this._systems.has(name);
+    }
+
+    /**
+     * Unregister a system
+     * @param {string} name - System name
+     * @returns {boolean} - True if system was found and removed
+     */
+    unregister(name) {
+        const entry = this._systems.get(name);
+        if (!entry) {
+            return false;
+        }
+
+        // Call destroy if available
+        if (entry.system.destroy) {
+            entry.system.destroy();
+        }
+
+        this._systems.delete(name);
+        this._needsRecompute = true;
+
+        // Emit event
+        this.kernel.events.emit('system_unregistered', { name });
+
+        return true;
+    }
+
+    /**
+     * Update all systems (called each frame)
+     * @param {number} dt - Delta time in seconds
+     */
+    update(dt) {
+        if (this._needsRecompute) {
+            this._recomputeUpdateOrder();
+        }
+
+        // Fast iteration - no lookups, just array access
+        for (let i = 0; i < this._updateOrder.length; i++) {
+            const system = this._updateOrder[i];
+            if (system.update) {
+                system.update(dt);
+            }
+        }
+    }
+
+    /**
+     * Fixed update for physics (called at fixed timestep)
+     * @param {number} dt - Fixed delta time
+     */
+    fixedUpdate(dt) {
+        if (this._needsRecompute) {
+            this._recomputeUpdateOrder();
+        }
+
+        for (let i = 0; i < this._fixedUpdateOrder.length; i++) {
+            const system = this._fixedUpdateOrder[i];
+            if (system.fixedUpdate) {
+                system.fixedUpdate(dt);
+            }
+        }
+    }
+
+    /**
+     * Recompute the update order based on dependencies and priorities
+     * Uses topological sort for dependencies
+     * @private
+     */
+    _recomputeUpdateOrder() {
+        const systems = Array.from(this._systems.entries());
+
+        // Build dependency graph
+        const graph = new Map();
+        const inDegree = new Map();
+
+        for (const [name, entry] of systems) {
+            graph.set(name, entry.dependencies);
+            inDegree.set(name, 0);
+        }
+
+        // Calculate in-degrees
+        for (const [name, deps] of graph) {
+            for (const dep of deps) {
+                if (inDegree.has(dep)) {
+                    inDegree.set(name, inDegree.get(name) + 1);
+                }
+            }
+        }
+
+        // Topological sort (Kahn's algorithm)
+        const queue = [];
+        const sorted = [];
+
+        // Start with systems that have no dependencies
+        for (const [name, degree] of inDegree) {
+            if (degree === 0) {
+                queue.push(name);
+            }
+        }
+
+        while (queue.length > 0) {
+            // Sort queue by priority before processing
+            queue.sort((a, b) => {
+                const priorityA = this._systems.get(a).priority;
+                const priorityB = this._systems.get(b).priority;
+                return priorityB - priorityA; // Higher priority first
+            });
+
+            const name = queue.shift();
+            sorted.push(name);
+
+            // Reduce in-degree for dependent systems
+            for (const [otherName, deps] of graph) {
+                if (deps.includes(name)) {
+                    const newDegree = inDegree.get(otherName) - 1;
+                    inDegree.set(otherName, newDegree);
+                    if (newDegree === 0) {
+                        queue.push(otherName);
+                    }
+                }
+            }
+        }
+
+        // Check for circular dependencies
+        if (sorted.length !== systems.length) {
+            console.error('[SystemRegistry] Circular dependency detected in systems!');
+            // Fallback: just use priority order
+            sorted.length = 0;
+            sorted.push(...systems.map(([name]) => name).sort((a, b) => {
+                return this._systems.get(b).priority - this._systems.get(a).priority;
+            }));
+        }
+
+        // Convert to system instances
+        this._updateOrder = sorted
+            .map(name => this._systems.get(name).system)
+            .filter(system => system.update);
+
+        this._fixedUpdateOrder = sorted
+            .map(name => this._systems.get(name).system)
+            .filter(system => system.fixedUpdate);
+
+        this._needsRecompute = false;
+    }
+
+    /**
+     * Get all registered system names
+     * @returns {string[]}
+     */
+    getSystemNames() {
+        return Array.from(this._systems.keys());
+    }
+
+    /**
+     * Clear all systems
+     */
+    clear() {
+        for (const name of this._systems.keys()) {
+            this.unregister(name);
+        }
+    }
+}

package/src/core/Vector2.js

@@ -0,0 +1,50 @@
+/**
+ * 2D Vector class for position, velocity, and physics calculations.
+ */
+export class Vector2 {
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        return this;
+    }
+
+    sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        return this;
+    }
+
+    scale(s) {
+        this.x *= s;
+        this.y *= s;
+        return this;
+    }
+
+    distance(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    normalize() {
+        const len = Math.sqrt(this.x * this.x + this.y * this.y);
+        if (len > 0) {
+            this.x /= len;
+            this.y /= len;
+        }
+        return this;
+    }
+
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+
+    static distance(a, b) {
+        return Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
+    }
+}

package/src/{audio → dopamine/audio}/SoundManager.js

@@ -11,7 +11,6 @@ export class SoundManager {
 
         // Asset management
         this.assets = new Map(); // key -> AudioBuffer
-        this.soundPack = config.soundPack || 'synth'; // 'synth' or custom
         this.customSounds = config.customSounds || {}; // key -> url
 
         // Preload custom sounds if provided
@@ -111,9 +110,8 @@ export class SoundManager {
         }
 
         // 3. Fallback to synth based on key name
-        // Map common keys to synth methods
         const synthMap = {
-            'jump': () => this.playJump(true), // true = force synth
+            'jump': () => this.playJump(true),
             'score': () => this.playScore(true),
             'success': () => this.playSuccess(true),
             'click': () => this.playClick(true),

package/src/dopamine/components/ParticleEmitter.js

@@ -0,0 +1,50 @@
+import { Component } from '../../core/Component.js';
+
+/**
+ * Wraps the Dopamine ParticleSystem for a GameObject.
+ * Allows easy "Emit at my position" logic.
+ */
+export class ParticleEmitter extends Component {
+    constructor(particleSystem) {
+        super();
+        this.system = particleSystem;
+    }
+
+    /**
+     * Trigger an effect at the GameObject's current position.
+     * @param {string} effectName - 'confetti', 'fire', 'sparkle', etc.
+     * @param {object} options - override options
+     */
+    play(effectName, options = {}) {
+        const x = this.gameObject.x;
+        const y = this.gameObject.y;
+
+        switch (effectName) {
+            case 'confetti':
+                this.system.confetti(x, y, options.count);
+                break;
+            case 'fire':
+                this.system.fire(x, y, options.count);
+                break;
+            case 'sparkle':
+                this.system.sparkle(x, y, options.count, options.color);
+                break;
+            case 'blood': // Custom shortcut for our game
+                this.system.emit({
+                    x, y,
+                    count: 10,
+                    color: ['#8a0303', '#ff0000'],
+                    speed: 4,
+                    gravity: 0.1,
+                    decay: 0.05
+                });
+                break;
+            default:
+                // Direct emit fallback
+                this.system.emit({
+                    x, y,
+                    ...options
+                });
+        }
+    }
+}

package/src/dopamine/components/ScreenShake.js

@@ -0,0 +1,49 @@
+import { Component } from '../../core/Component.js';
+
+/**
+ * Adds screen shake capability.
+ * Usually attached to the Camera or the Root Scene object.
+ */
+export class ScreenShake extends Component {
+    constructor() {
+        super();
+        this.intensity = 0;
+        this.duration = 0;
+        this.timer = 0;
+        this.originalPos = { x: 0, y: 0 };
+        this.isShaking = false;
+    }
+
+    shake(intensity = 5, duration = 0.2) {
+        this.intensity = intensity;
+        this.duration = duration;
+        this.timer = 0;
+        this.isShaking = true;
+
+        // Save original if not already shaking
+        if (this.timer === 0) {
+            this.originalPos.x = this.gameObject.x;
+            this.originalPos.y = this.gameObject.y;
+        }
+    }
+
+    update(dt) {
+        if (!this.isShaking) return;
+
+        this.timer += dt;
+
+        if (this.timer >= this.duration) {
+            this.isShaking = false;
+            this.gameObject.x = this.originalPos.x;
+            this.gameObject.y = this.originalPos.y;
+            return;
+        }
+
+        // Random offset
+        const offsetX = (Math.random() - 0.5) * 2 * this.intensity;
+        const offsetY = (Math.random() - 0.5) * 2 * this.intensity;
+
+        this.gameObject.x = this.originalPos.x + offsetX;
+        this.gameObject.y = this.originalPos.y + offsetY;
+    }
+}

package/src/dopamine/components/index.js

@@ -0,0 +1,4 @@
+import Dopamine from '../index.js';
+
+export { ParticleEmitter } from './ParticleEmitter.js';
+export { ScreenShake } from './ScreenShake.js';