minimojs 1.0.0-alpha.7 → 1.0.0-alpha.8

package/dist/internal/InputSystem.js

@@ -117,30 +117,30 @@ export class InputSystem {
     isPointerPressed() {
         return this._pointerPressed;
     }
-    isPointerDownOverSprite(sprite, radiusScale = 0.5) {
+    isPointerDownOverSprite(sprite) {
         if (!sprite)
             return false;
         if (this._mouseDown &&
-            this.isScreenPointOverSprite(this._mouseX, this._mouseY, sprite, radiusScale)) {
+            this.isScreenPointOverSprite(this._mouseX, this._mouseY, sprite)) {
             return true;
         }
         for (const pointer of this._touchPointers.values()) {
-            if (this.isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale)) {
+            if (this.isScreenPointOverSprite(pointer.x, pointer.y, sprite)) {
                 return true;
             }
         }
         return false;
     }
-    isPointerPressedOverSprite(sprite, radiusScale = 0.5) {
+    isPointerPressedOverSprite(sprite) {
         if (!sprite)
             return false;
         if (this._mousePressed &&
-            this.isScreenPointOverSprite(this._mouseX, this._mouseY, sprite, radiusScale)) {
+            this.isScreenPointOverSprite(this._mouseX, this._mouseY, sprite)) {
             return true;
         }
         for (const pointer of this._touchPointers.values()) {
             if (pointer.pressed &&
-                this.isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale)) {
+                this.isScreenPointOverSprite(pointer.x, pointer.y, sprite)) {
                 return true;
             }
         }
@@ -149,10 +149,10 @@ export class InputSystem {
     getPointers() {
         return this.collectPointers();
     }
-    getPointersOverSprite(sprite, radiusScale = 0.5) {
+    getPointersOverSprite(sprite) {
         if (!sprite)
             return [];
-        return this.collectPointers().filter((pointer) => this.isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale));
+        return this.collectPointers().filter((pointer) => this.isScreenPointOverSprite(pointer.x, pointer.y, sprite));
     }
     isMobileDevice() {
         if (typeof navigator === "undefined")
@@ -185,10 +185,9 @@ export class InputSystem {
             y: (clientY - rect.top) * scaleY,
         };
     }
-    isScreenPointOverSprite(x, y, sprite, radiusScale) {
-        const safeScale = Math.max(0, radiusScale);
-        const halfWidth = (sprite.displayWidth * safeScale) / 2;
-        const halfHeight = (sprite.displayHeight * safeScale) / 2;
+    isScreenPointOverSprite(x, y, sprite) {
+        const halfWidth = sprite.displayWidth / 2;
+        const halfHeight = sprite.displayHeight / 2;
         const drawX = sprite.ignoreScroll ? sprite.renderX : sprite.renderX - this.game.scrollX;
         const drawY = sprite.ignoreScroll ? sprite.renderY : sprite.renderY - this.game.scrollY;
         return Math.abs(x - drawX) <= halfWidth && Math.abs(y - drawY) <= halfHeight;

package/dist/minimo.d.ts

@@ -1153,52 +1153,50 @@ export declare class Game {
      * Returns `true` while any active pointer is held down over the target sprite.
      * Works with both mouse input and multiple simultaneous touches.
      *
-     * Pointer hit testing uses a square area centered on the sprite. The square
-     * half-size is `sprite.displaySize * radiusScale` (default `0.5`, which matches
-     * the sprite's displayed size). World-space sprites are tested against the
-     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
-     * screen space.
+     * Pointer hit testing uses the sprite's exact displayed rectangular bounds.
+     * World-space sprites are tested against the current camera scroll. HUD
+     * sprites with `ignoreScroll = true` are tested in screen space. For
+     * anchored {@link TextSprite} instances, the engine first resolves
+     * `anchorX` / `anchorY` into the final rendered center, then tests against
+     * that rectangle.
      *
      * Use this for continuous virtual buttons such as touch movement controls.
      *
      * @param sprite - Target sprite to test. If `null` / `undefined`, returns `false`.
-     * @param radiusScale - Multiplier applied to `sprite.displaySize` to define the square half-size.
-     *   Default: `0.5`.
      * @returns `true` if any currently held pointer overlaps the sprite hit area.
      *
      * @example
      * ```ts
-     * if (game.isPointerDownOverSprite(leftButton, 0.72)) {
+     * if (game.isPointerDownOverSprite(leftButton)) {
      *   player.x -= 200 * dt;
      * }
      * ```
      */
-    isPointerDownOverSprite(sprite: BaseSprite | null | undefined, radiusScale?: number): boolean;
+    isPointerDownOverSprite(sprite: BaseSprite | null | undefined): boolean;
     /**
      * Returns `true` only on the frame any pointer first pressed over the target
      * sprite. Works with both mouse input and multiple simultaneous touches.
      *
-     * Pointer hit testing uses a square area centered on the sprite. The square
-     * half-size is `sprite.displaySize * radiusScale` (default `0.5`, which matches
-     * the sprite's displayed size). World-space sprites are tested against the
-     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
-     * screen space.
+     * Pointer hit testing uses the sprite's exact displayed rectangular bounds.
+     * World-space sprites are tested against the current camera scroll. HUD
+     * sprites with `ignoreScroll = true` are tested in screen space. For
+     * anchored {@link TextSprite} instances, the engine first resolves
+     * `anchorX` / `anchorY` into the final rendered center, then tests against
+     * that rectangle.
      *
      * Use this for one-shot virtual buttons such as menu taps.
      *
      * @param sprite - Target sprite to test. If `null` / `undefined`, returns `false`.
-     * @param radiusScale - Multiplier applied to `sprite.displaySize` to define the square half-size.
-     *   Default: `0.5`.
      * @returns `true` if any pointer began pressing this frame over the sprite hit area.
      *
      * @example
      * ```ts
-     * if (game.isPointerPressedOverSprite(startButton, 0.8)) {
+     * if (game.isPointerPressedOverSprite(startButton)) {
      *   startGame();
      * }
      * ```
      */
-    isPointerPressedOverSprite(sprite: BaseSprite | null | undefined, radiusScale?: number): boolean;
+    isPointerPressedOverSprite(sprite: BaseSprite | null | undefined): boolean;
     /**
      * Returns a read-only snapshot of all currently active pointers.
      *
@@ -1225,30 +1223,29 @@ export declare class Game {
      * Returns a read-only snapshot of all active pointers currently overlapping
      * the target sprite.
      *
-     * Pointer hit testing uses a square area centered on the sprite. The square
-     * half-size is `sprite.displaySize * radiusScale` (default `0.5`, which matches
-     * the sprite's displayed size). World-space sprites are tested against the
-     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
-     * screen space.
+     * Pointer hit testing uses the sprite's exact displayed rectangular bounds.
+     * World-space sprites are tested against the current camera scroll. HUD
+     * sprites with `ignoreScroll = true` are tested in screen space. For
+     * anchored {@link TextSprite} instances, the engine first resolves
+     * `anchorX` / `anchorY` into the final rendered center, then tests against
+     * that rectangle.
      *
      * Use this when you need more than a boolean result, such as reading the exact
      * pointer position over a virtual joystick or draggable control.
      *
      * @param sprite - Target sprite to test. If `null` / `undefined`, returns an empty array.
-     * @param radiusScale - Multiplier applied to `sprite.displaySize` to define the square half-size.
-     *   Default: `0.5`.
      * @returns A read-only array of active pointer snapshots currently over the sprite.
      *
      * @example
      * ```ts
-     * const touches = game.getPointersOverSprite(joystickBase, 1.0);
+     * const touches = game.getPointersOverSprite(joystickBase);
      * if (touches.length > 0) {
      *   const p = touches[0];
      *   const dx = p.x - joystickBase.x;
      * }
      * ```
      */
-    getPointersOverSprite(sprite: BaseSprite | null | undefined, radiusScale?: number): readonly PointerInfo[];
+    getPointersOverSprite(sprite: BaseSprite | null | undefined): readonly PointerInfo[];
     /**
      * Returns `true` when the current device appears to be mobile/touch-first.
      *
@@ -1681,7 +1678,9 @@ export declare class Game {
      *
      * Call this before {@link Game.start}, typically right after constructing the
      * game or inside {@link Game.onPreload}. MinimoJS waits for every registered
-     * font via `document.fonts.load(...)` before rendering anything.
+     * font via `document.fonts.load(...)` before rendering anything. Host
+     * environments may also pre-register fonts by setting
+     * `globalThis.__MINIMO_WEB_FONT_REQUIREMENTS__` before your game code runs.
      *
      * The font itself must still be declared by your page (for example with a
      * `<link rel="stylesheet">` in `index.html`). MinimoJS only waits for it.

package/dist/minimo.js

@@ -734,6 +734,7 @@ export class Game {
      */
     constructor(width = 800, height = 600) {
         /** @internal */ this._requiredFonts = new Map();
+        /** @internal */ this._hasAppliedGlobalFontRequirements = false;
         /** @internal */ this._isRegisteringPreloadAssets = false;
         /** @internal */ this._hasCompletedPreload = false;
         /** @internal */ this._preloadPromise = null;
@@ -858,6 +859,7 @@ export class Game {
         this.requireFont('"Press Start 2P"', {
             sampleText: "Loading... SCORE LIVES GAME OVER YOU WIN",
         });
+        this.applyGlobalFontRequirements();
     }
     // -------------------------------------------------------------------------
     // Canvas dimensions (read-only)
@@ -1236,55 +1238,53 @@ export class Game {
      * Returns `true` while any active pointer is held down over the target sprite.
      * Works with both mouse input and multiple simultaneous touches.
      *
-     * Pointer hit testing uses a square area centered on the sprite. The square
-     * half-size is `sprite.displaySize * radiusScale` (default `0.5`, which matches
-     * the sprite's displayed size). World-space sprites are tested against the
-     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
-     * screen space.
+     * Pointer hit testing uses the sprite's exact displayed rectangular bounds.
+     * World-space sprites are tested against the current camera scroll. HUD
+     * sprites with `ignoreScroll = true` are tested in screen space. For
+     * anchored {@link TextSprite} instances, the engine first resolves
+     * `anchorX` / `anchorY` into the final rendered center, then tests against
+     * that rectangle.
      *
      * Use this for continuous virtual buttons such as touch movement controls.
      *
      * @param sprite - Target sprite to test. If `null` / `undefined`, returns `false`.
-     * @param radiusScale - Multiplier applied to `sprite.displaySize` to define the square half-size.
-     *   Default: `0.5`.
      * @returns `true` if any currently held pointer overlaps the sprite hit area.
      *
      * @example
      * ```ts
-     * if (game.isPointerDownOverSprite(leftButton, 0.72)) {
+     * if (game.isPointerDownOverSprite(leftButton)) {
      *   player.x -= 200 * dt;
      * }
      * ```
      */
-    isPointerDownOverSprite(sprite, radiusScale = 0.5) {
-        return this._inputSystem.isPointerDownOverSprite(sprite, radiusScale);
+    isPointerDownOverSprite(sprite) {
+        return this._inputSystem.isPointerDownOverSprite(sprite);
     }
     /**
      * Returns `true` only on the frame any pointer first pressed over the target
      * sprite. Works with both mouse input and multiple simultaneous touches.
      *
-     * Pointer hit testing uses a square area centered on the sprite. The square
-     * half-size is `sprite.displaySize * radiusScale` (default `0.5`, which matches
-     * the sprite's displayed size). World-space sprites are tested against the
-     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
-     * screen space.
+     * Pointer hit testing uses the sprite's exact displayed rectangular bounds.
+     * World-space sprites are tested against the current camera scroll. HUD
+     * sprites with `ignoreScroll = true` are tested in screen space. For
+     * anchored {@link TextSprite} instances, the engine first resolves
+     * `anchorX` / `anchorY` into the final rendered center, then tests against
+     * that rectangle.
      *
      * Use this for one-shot virtual buttons such as menu taps.
      *
      * @param sprite - Target sprite to test. If `null` / `undefined`, returns `false`.
-     * @param radiusScale - Multiplier applied to `sprite.displaySize` to define the square half-size.
-     *   Default: `0.5`.
      * @returns `true` if any pointer began pressing this frame over the sprite hit area.
      *
      * @example
      * ```ts
-     * if (game.isPointerPressedOverSprite(startButton, 0.8)) {
+     * if (game.isPointerPressedOverSprite(startButton)) {
      *   startGame();
      * }
      * ```
      */
-    isPointerPressedOverSprite(sprite, radiusScale = 0.5) {
-        return this._inputSystem.isPointerPressedOverSprite(sprite, radiusScale);
+    isPointerPressedOverSprite(sprite) {
+        return this._inputSystem.isPointerPressedOverSprite(sprite);
     }
     /**
      * Returns a read-only snapshot of all currently active pointers.
@@ -1314,31 +1314,30 @@ export class Game {
      * Returns a read-only snapshot of all active pointers currently overlapping
      * the target sprite.
      *
-     * Pointer hit testing uses a square area centered on the sprite. The square
-     * half-size is `sprite.displaySize * radiusScale` (default `0.5`, which matches
-     * the sprite's displayed size). World-space sprites are tested against the
-     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
-     * screen space.
+     * Pointer hit testing uses the sprite's exact displayed rectangular bounds.
+     * World-space sprites are tested against the current camera scroll. HUD
+     * sprites with `ignoreScroll = true` are tested in screen space. For
+     * anchored {@link TextSprite} instances, the engine first resolves
+     * `anchorX` / `anchorY` into the final rendered center, then tests against
+     * that rectangle.
      *
      * Use this when you need more than a boolean result, such as reading the exact
      * pointer position over a virtual joystick or draggable control.
      *
      * @param sprite - Target sprite to test. If `null` / `undefined`, returns an empty array.
-     * @param radiusScale - Multiplier applied to `sprite.displaySize` to define the square half-size.
-     *   Default: `0.5`.
      * @returns A read-only array of active pointer snapshots currently over the sprite.
      *
      * @example
      * ```ts
-     * const touches = game.getPointersOverSprite(joystickBase, 1.0);
+     * const touches = game.getPointersOverSprite(joystickBase);
      * if (touches.length > 0) {
      *   const p = touches[0];
      *   const dx = p.x - joystickBase.x;
      * }
      * ```
      */
-    getPointersOverSprite(sprite, radiusScale = 0.5) {
-        return this._inputSystem.getPointersOverSprite(sprite, radiusScale);
+    getPointersOverSprite(sprite) {
+        return this._inputSystem.getPointersOverSprite(sprite);
     }
     /**
      * Returns `true` when the current device appears to be mobile/touch-first.
@@ -1838,7 +1837,9 @@ export class Game {
      *
      * Call this before {@link Game.start}, typically right after constructing the
      * game or inside {@link Game.onPreload}. MinimoJS waits for every registered
-     * font via `document.fonts.load(...)` before rendering anything.
+     * font via `document.fonts.load(...)` before rendering anything. Host
+     * environments may also pre-register fonts by setting
+     * `globalThis.__MINIMO_WEB_FONT_REQUIREMENTS__` before your game code runs.
      *
      * The font itself must still be declared by your page (for example with a
      * `<link rel="stylesheet">` in `index.html`). MinimoJS only waits for it.
@@ -1974,6 +1975,7 @@ export class Game {
      * ```
      */
     start() {
+        this.applyGlobalFontRequirements();
         if (this._hasCompletedPreload) {
             this._loopSystem.start();
             return;
@@ -2076,6 +2078,47 @@ export class Game {
         fontLoads.push(fontSet.ready);
         return Promise.all(fontLoads).then(() => undefined);
     }
+    /** @internal */
+    applyGlobalFontRequirements() {
+        if (this._hasAppliedGlobalFontRequirements) {
+            return;
+        }
+        this._hasAppliedGlobalFontRequirements = true;
+        const root = globalThis;
+        const requirements = root.__MINIMO_WEB_FONT_REQUIREMENTS__;
+        if (!Array.isArray(requirements)) {
+            return;
+        }
+        for (const entry of requirements) {
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const requirement = entry;
+            const family = typeof requirement.family === "string" ? requirement.family.trim() : "";
+            if (!family) {
+                continue;
+            }
+            const sampleText = typeof requirement.sample_text === "string"
+                ? requirement.sample_text
+                : typeof requirement.sampleText === "string"
+                    ? requirement.sampleText
+                    : "";
+            this.requireFont(`"${family}"`, {
+                weight: typeof requirement.weight === "string" && requirement.weight.trim()
+                    ? requirement.weight.trim()
+                    : undefined,
+                style: requirement.style === "normal" ||
+                    requirement.style === "italic" ||
+                    requirement.style === "oblique"
+                    ? requirement.style
+                    : undefined,
+                size: typeof requirement.size === "number" && Number.isFinite(requirement.size)
+                    ? requirement.size
+                    : undefined,
+                sampleText,
+            });
+        }
+    }
     /** @internal */ _render() {
         this._renderSystem.render({
             canvas: this._canvas,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimojs",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.8",
   "description": "MinimoJS v1 — ultra-minimal, flat, deterministic 2D web game engine. Emoji-only sprites, rAF loop, TypeScript-first, LLM-friendly.",
   "type": "module",
   "main": "dist/minimo.js",