@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/core/ServiceLocator.js

@@ -1,71 +1,67 @@
-'use strict';
-
-/* ────────────────────────────────────────────────────────────────
-   ServiceLocator — Dependency injection container
-──────────────────────────────────────────────────────────────── */
-class ServiceLocator {
-    constructor() {
-        this.services = new Map();
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _ServiceLocator = class _ServiceLocator {
+  constructor() {
+    this.services = /* @__PURE__ */ new Map();
+  }
+  static get instance() {
+    if (!_ServiceLocator._instance) {
+      _ServiceLocator._instance = new _ServiceLocator();
     }
-    static get instance() {
-        if (!ServiceLocator._instance) {
-            ServiceLocator._instance = new ServiceLocator();
-        }
-        return ServiceLocator._instance;
+    return _ServiceLocator._instance;
+  }
+  /** Register a service by key. */
+  register(key, service) {
+    this.services.set(key, service);
+  }
+  /** Retrieve a service by key. Throws if not registered. */
+  get(key) {
+    const svc = this.services.get(key);
+    if (svc === void 0) {
+      throw new Error(`[ServiceLocator] Service "${key}" not registered.`);
     }
-    /** Register a service by key. */
-    register(key, service) {
-        this.services.set(key, service);
-    }
-    /** Retrieve a service by key. Throws if not registered. */
-    get(key) {
-        const svc = this.services.get(key);
-        if (svc === undefined) {
-            throw new Error(`[ServiceLocator] Service "${key}" not registered.`);
-        }
-        return svc;
-    }
-    /** Retrieve a service, or undefined if not registered. */
-    tryGet(key) {
-        return this.services.get(key);
-    }
-    /** Check if a service is registered. */
-    has(key) {
-        return this.services.has(key);
-    }
-    /** Remove a service. */
-    unregister(key) {
-        return this.services.delete(key);
-    }
-    /** Remove all services. */
-    clear() {
-        this.services.clear();
-    }
-    /** Reset static singleton (for testing). */
-    static reset() {
-        ServiceLocator._instance?.clear();
-        ServiceLocator._instance = null;
-    }
-}
-ServiceLocator._instance = null;
-/* ── Convenience service keys ─────────────────────────────────── */
+    return svc;
+  }
+  /** Retrieve a service, or undefined if not registered. */
+  tryGet(key) {
+    return this.services.get(key);
+  }
+  /** Check if a service is registered. */
+  has(key) {
+    return this.services.has(key);
+  }
+  /** Remove a service. */
+  unregister(key) {
+    return this.services.delete(key);
+  }
+  /** Remove all services. */
+  clear() {
+    this.services.clear();
+  }
+  /** Reset static singleton (for testing). */
+  static reset() {
+    _ServiceLocator._instance?.clear();
+    _ServiceLocator._instance = null;
+  }
+};
+_ServiceLocator._instance = null;
+let ServiceLocator = _ServiceLocator;
 const SERVICE_KEYS = {
-    CONFIG: 'GameConfig',
-    CLOCK: 'GameClock',
-    LOOP: 'GameLoop',
-    EVENTS: 'EventBus',
-    EVENT_BUS: 'EventBus',
-    INPUT: 'InputManager',
-    AUDIO: 'AudioManager',
-    RENDERER: 'Renderer2D',
-    CAMERA: 'Camera2D',
-    PHYSICS: 'PhysicsEngine',
-    SCENES: 'SceneManager',
-    SCENE_MANAGER: 'SceneManager',
-    PLAYERS: 'PlayerManager',
-    PLAYER_MANAGER: 'PlayerManager',
-    WORLD: 'World',
+  CONFIG: "GameConfig",
+  CLOCK: "GameClock",
+  LOOP: "GameLoop",
+  EVENTS: "EventBus",
+  EVENT_BUS: "EventBus",
+  INPUT: "InputManager",
+  AUDIO: "AudioManager",
+  RENDERER: "Renderer2D",
+  CAMERA: "Camera2D",
+  PHYSICS: "PhysicsEngine",
+  SCENES: "SceneManager",
+  SCENE_MANAGER: "SceneManager",
+  PLAYERS: "PlayerManager",
+  PLAYER_MANAGER: "PlayerManager",
+  WORLD: "World"
 };
-
 exports.SERVICE_KEYS = SERVICE_KEYS;
 exports.ServiceLocator = ServiceLocator;

package/dist/cjs/core/Validation.js

@@ -1,111 +1,101 @@
-'use strict';
-
-/* ────────────────────────────────────────────────────────────────
-   Validation — Boundary validation utilities for public APIs
-──────────────────────────────────────────────────────────────── */
-/* ── Range validation ─────────────────────────────────────────── */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
+  return Math.max(min, Math.min(max, value));
 }
 function clampPositive(value) {
-    return Math.max(0, value);
+  return Math.max(0, value);
 }
 function assertFinite(value, name) {
-    if (!Number.isFinite(value)) {
-        throw new RangeError(`[Validation] ${name} must be a finite number, got ${value}`);
-    }
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`[Validation] ${name} must be a finite number, got ${value}`);
+  }
 }
 function assertPositive(value, name) {
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new RangeError(`[Validation] ${name} must be a positive number, got ${value}`);
-    }
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`[Validation] ${name} must be a positive number, got ${value}`);
+  }
 }
 function assertNonNegative(value, name) {
-    if (!Number.isFinite(value) || value < 0) {
-        throw new RangeError(`[Validation] ${name} must be a non-negative number, got ${value}`);
-    }
+  if (!Number.isFinite(value) || value < 0) {
+    throw new RangeError(`[Validation] ${name} must be a non-negative number, got ${value}`);
+  }
 }
 function assertInRange(value, min, max, name) {
-    if (!Number.isFinite(value) || value < min || value > max) {
-        throw new RangeError(`[Validation] ${name} must be between ${min} and ${max}, got ${value}`);
-    }
+  if (!Number.isFinite(value) || value < min || value > max) {
+    throw new RangeError(`[Validation] ${name} must be between ${min} and ${max}, got ${value}`);
+  }
 }
-/* ── String validation ────────────────────────────────────────── */
 function assertNonEmpty(value, name) {
-    if (!value || value.trim().length === 0) {
-        throw new TypeError(`[Validation] ${name} must be a non-empty string`);
-    }
+  if (!value || value.trim().length === 0) {
+    throw new TypeError(`[Validation] ${name} must be a non-empty string`);
+  }
 }
-/* ── Canvas validation ────────────────────────────────────────── */
-function assertCanvasElement(el, name = 'canvas') {
-    if (!el || typeof el.getContext !== 'function') {
-        throw new TypeError(`[Validation] ${name} must be a valid HTMLCanvasElement`);
-    }
+function assertCanvasElement(el, name = "canvas") {
+  if (!el || typeof el.getContext !== "function") {
+    throw new TypeError(`[Validation] ${name} must be a valid HTMLCanvasElement`);
+  }
 }
 function validateGameSettings(settings) {
-    const result = { valid: true, warnings: [], errors: [] };
-    if (settings.width !== undefined) {
-        if (settings.width < 64 || settings.width > 7680) {
-            result.errors.push(`width ${settings.width} out of range [64, 7680]`);
-            result.valid = false;
-        }
-        else if (settings.width < 320) {
-            result.warnings.push(`width ${settings.width} is very small, consider 320+`);
-        }
+  const result = { valid: true, warnings: [], errors: [] };
+  if (settings.width !== void 0) {
+    if (settings.width < 64 || settings.width > 7680) {
+      result.errors.push(`width ${settings.width} out of range [64, 7680]`);
+      result.valid = false;
+    } else if (settings.width < 320) {
+      result.warnings.push(`width ${settings.width} is very small, consider 320+`);
     }
-    if (settings.height !== undefined) {
-        if (settings.height < 64 || settings.height > 4320) {
-            result.errors.push(`height ${settings.height} out of range [64, 4320]`);
-            result.valid = false;
-        }
-        else if (settings.height < 240) {
-            result.warnings.push(`height ${settings.height} is very small, consider 240+`);
-        }
+  }
+  if (settings.height !== void 0) {
+    if (settings.height < 64 || settings.height > 4320) {
+      result.errors.push(`height ${settings.height} out of range [64, 4320]`);
+      result.valid = false;
+    } else if (settings.height < 240) {
+      result.warnings.push(`height ${settings.height} is very small, consider 240+`);
     }
-    if (settings.targetFps !== undefined) {
-        if (settings.targetFps < 1 || settings.targetFps > 300) {
-            result.errors.push(`targetFps ${settings.targetFps} out of range [1, 300]`);
-            result.valid = false;
-        }
-        else if (settings.targetFps > 120) {
-            result.warnings.push(`targetFps ${settings.targetFps} is high, most displays are 60-120 Hz`);
-        }
+  }
+  if (settings.targetFps !== void 0) {
+    if (settings.targetFps < 1 || settings.targetFps > 300) {
+      result.errors.push(`targetFps ${settings.targetFps} out of range [1, 300]`);
+      result.valid = false;
+    } else if (settings.targetFps > 120) {
+      result.warnings.push(`targetFps ${settings.targetFps} is high, most displays are 60-120 Hz`);
     }
-    if (settings.maxPlayers !== undefined) {
-        if (settings.maxPlayers < 1 || settings.maxPlayers > 12) {
-            result.errors.push(`maxPlayers ${settings.maxPlayers} out of range [1, 12]`);
-            result.valid = false;
-        }
+  }
+  if (settings.maxPlayers !== void 0) {
+    if (settings.maxPlayers < 1 || settings.maxPlayers > 12) {
+      result.errors.push(`maxPlayers ${settings.maxPlayers} out of range [1, 12]`);
+      result.valid = false;
     }
-    return result;
+  }
+  return result;
 }
-/* ── Physics validation ───────────────────────────────────────── */
 function validatePhysicsSettings(settings) {
-    const result = { valid: true, warnings: [], errors: [] };
-    if (settings.fixedTimestep !== undefined) {
-        if (settings.fixedTimestep < 0.001 || settings.fixedTimestep > 0.1) {
-            result.errors.push(`fixedTimestep ${settings.fixedTimestep} out of range [0.001, 0.1]`);
-            result.valid = false;
-        }
-        else if (settings.fixedTimestep > 1 / 30) {
-            result.warnings.push(`fixedTimestep ${settings.fixedTimestep}s is large, physics accuracy may suffer`);
-        }
+  const result = { valid: true, warnings: [], errors: [] };
+  if (settings.fixedTimestep !== void 0) {
+    if (settings.fixedTimestep < 1e-3 || settings.fixedTimestep > 0.1) {
+      result.errors.push(`fixedTimestep ${settings.fixedTimestep} out of range [0.001, 0.1]`);
+      result.valid = false;
+    } else if (settings.fixedTimestep > 1 / 30) {
+      result.warnings.push(
+        `fixedTimestep ${settings.fixedTimestep}s is large, physics accuracy may suffer`
+      );
     }
-    if (settings.velocityIterations !== undefined) {
-        if (settings.velocityIterations < 1 || settings.velocityIterations > 100) {
-            result.errors.push(`velocityIterations ${settings.velocityIterations} out of range [1, 100]`);
-            result.valid = false;
-        }
+  }
+  if (settings.velocityIterations !== void 0) {
+    if (settings.velocityIterations < 1 || settings.velocityIterations > 100) {
+      result.errors.push(`velocityIterations ${settings.velocityIterations} out of range [1, 100]`);
+      result.valid = false;
     }
-    if (settings.positionIterations !== undefined) {
-        if (settings.positionIterations < 1 || settings.positionIterations > 100) {
-            result.errors.push(`positionIterations ${settings.positionIterations} out of range [1, 100]`);
-            result.valid = false;
-        }
+  }
+  if (settings.positionIterations !== void 0) {
+    if (settings.positionIterations < 1 || settings.positionIterations > 100) {
+      result.errors.push(`positionIterations ${settings.positionIterations} out of range [1, 100]`);
+      result.valid = false;
     }
-    return result;
+  }
+  return result;
 }
-
 exports.assertCanvasElement = assertCanvasElement;
 exports.assertFinite = assertFinite;
 exports.assertInRange = assertInRange;

package/dist/cjs/core/math.js

@@ -1,115 +1,111 @@
-'use strict';
-
-/* ────────────────────────────────────────────────────────────────
-   Vec2 — 2D vector math utilities (pure functions)
-──────────────────────────────────────────────────────────────── */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const v2 = {
-    create(x = 0, y = 0) {
-        return { x, y };
-    },
-    zero() {
-        return { x: 0, y: 0 };
-    },
-    one() {
-        return { x: 1, y: 1 };
-    },
-    clone(a) {
-        return { x: a.x, y: a.y };
-    },
-    add(a, b) {
-        return { x: a.x + b.x, y: a.y + b.y };
-    },
-    sub(a, b) {
-        return { x: a.x - b.x, y: a.y - b.y };
-    },
-    mul(a, s) {
-        return { x: a.x * s, y: a.y * s };
-    },
-    div(a, s) {
-        return { x: a.x / s, y: a.y / s };
-    },
-    dot(a, b) {
-        return a.x * b.x + a.y * b.y;
-    },
-    cross(a, b) {
-        return a.x * b.y - a.y * b.x;
-    },
-    len(a) {
-        return Math.sqrt(a.x * a.x + a.y * a.y);
-    },
-    lenSq(a) {
-        return a.x * a.x + a.y * a.y;
-    },
-    normalize(a) {
-        const l = v2.len(a);
-        return l > 0 ? { x: a.x / l, y: a.y / l } : { x: 0, y: 0 };
-    },
-    dist(a, b) {
-        const dx = a.x - b.x;
-        const dy = a.y - b.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    },
-    distSq(a, b) {
-        const dx = a.x - b.x;
-        const dy = a.y - b.y;
-        return dx * dx + dy * dy;
-    },
-    lerp(a, b, t) {
-        return {
-            x: a.x + (b.x - a.x) * t,
-            y: a.y + (b.y - a.y) * t,
-        };
-    },
-    rotate(a, angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        return {
-            x: a.x * c - a.y * s,
-            y: a.x * s + a.y * c,
-        };
-    },
-    angle(a) {
-        return Math.atan2(a.y, a.x);
-    },
-    angleBetween(a, b) {
-        return Math.atan2(b.y - a.y, b.x - a.x);
-    },
-    negate(a) {
-        return { x: -a.x, y: -a.y };
-    },
-    perpCW(a) {
-        return { x: a.y, y: -a.x };
-    },
-    perpCCW(a) {
-        return { x: -a.y, y: a.x };
-    },
-    reflect(a, normal) {
-        const d = 2 * v2.dot(a, normal);
-        return { x: a.x - d * normal.x, y: a.y - d * normal.y };
-    },
-    equals(a, b, epsilon = 1e-6) {
-        return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon;
-    },
-    min(a, b) {
-        return { x: Math.min(a.x, b.x), y: Math.min(a.y, b.y) };
-    },
-    max(a, b) {
-        return { x: Math.max(a.x, b.x), y: Math.max(a.y, b.y) };
-    },
-    clamp(v, min, max) {
-        return {
-            x: Math.max(min.x, Math.min(max.x, v.x)),
-            y: Math.max(min.y, Math.min(max.y, v.y)),
-        };
-    },
-    fromAngle(angle, length = 1) {
-        return { x: Math.cos(angle) * length, y: Math.sin(angle) * length };
-    },
-    random(minLen = 0, maxLen = 1) {
-        const angle = Math.random() * Math.PI * 2;
-        const length = minLen + Math.random() * (maxLen - minLen);
-        return v2.fromAngle(angle, length);
-    },
+  create(x = 0, y = 0) {
+    return { x, y };
+  },
+  zero() {
+    return { x: 0, y: 0 };
+  },
+  one() {
+    return { x: 1, y: 1 };
+  },
+  clone(a) {
+    return { x: a.x, y: a.y };
+  },
+  add(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y };
+  },
+  sub(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y };
+  },
+  mul(a, s) {
+    return { x: a.x * s, y: a.y * s };
+  },
+  div(a, s) {
+    return { x: a.x / s, y: a.y / s };
+  },
+  dot(a, b) {
+    return a.x * b.x + a.y * b.y;
+  },
+  cross(a, b) {
+    return a.x * b.y - a.y * b.x;
+  },
+  len(a) {
+    return Math.sqrt(a.x * a.x + a.y * a.y);
+  },
+  lenSq(a) {
+    return a.x * a.x + a.y * a.y;
+  },
+  normalize(a) {
+    const l = v2.len(a);
+    return l > 0 ? { x: a.x / l, y: a.y / l } : { x: 0, y: 0 };
+  },
+  dist(a, b) {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  },
+  distSq(a, b) {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    return dx * dx + dy * dy;
+  },
+  lerp(a, b, t) {
+    return {
+      x: a.x + (b.x - a.x) * t,
+      y: a.y + (b.y - a.y) * t
+    };
+  },
+  rotate(a, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return {
+      x: a.x * c - a.y * s,
+      y: a.x * s + a.y * c
+    };
+  },
+  angle(a) {
+    return Math.atan2(a.y, a.x);
+  },
+  angleBetween(a, b) {
+    return Math.atan2(b.y - a.y, b.x - a.x);
+  },
+  negate(a) {
+    return { x: -a.x, y: -a.y };
+  },
+  perpCW(a) {
+    return { x: a.y, y: -a.x };
+  },
+  perpCCW(a) {
+    return { x: -a.y, y: a.x };
+  },
+  reflect(a, normal) {
+    const d = 2 * v2.dot(a, normal);
+    return { x: a.x - d * normal.x, y: a.y - d * normal.y };
+  },
+  equals(a, b, epsilon = 1e-6) {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon;
+  },
+  min(a, b) {
+    return { x: Math.min(a.x, b.x), y: Math.min(a.y, b.y) };
+  },
+  max(a, b) {
+    return { x: Math.max(a.x, b.x), y: Math.max(a.y, b.y) };
+  },
+  clamp(v, min, max) {
+    return {
+      x: Math.max(min.x, Math.min(max.x, v.x)),
+      y: Math.max(min.y, Math.min(max.y, v.y))
+    };
+  },
+  fromAngle(angle, length = 1) {
+    return { x: Math.cos(angle) * length, y: Math.sin(angle) * length };
+  },
+  random(minLen = 0, maxLen = 1) {
+    const angle = Math.random() * Math.PI * 2;
+    const length = minLen + Math.random() * (maxLen - minLen);
+    return v2.fromAngle(angle, length);
+  }
 };
-
 exports.v2 = v2;