minimojs 1.0.0-alpha.1 → 1.0.0-alpha.2

package/dist/input.js

@@ -0,0 +1,185 @@
+export function createInputState() {
+    return {
+        keysDown: new Set(),
+        keysPressed: new Set(),
+        pointerDown: false,
+        pointerPressed: false,
+        pointerX: 0,
+        pointerY: 0,
+        mouseDown: false,
+        mousePressed: false,
+        mouseX: 0,
+        mouseY: 0,
+        touchPointers: new Map(),
+        primaryTouchId: null,
+    };
+}
+export function bindInputEvents(canvas, input) {
+    window.addEventListener("keydown", (e) => {
+        if (!input.keysDown.has(e.key)) {
+            input.keysPressed.add(e.key);
+        }
+        input.keysDown.add(e.key);
+    });
+    window.addEventListener("keyup", (e) => {
+        input.keysDown.delete(e.key);
+    });
+    const getCanvasPoint = (clientX, clientY) => {
+        const rect = canvas.getBoundingClientRect();
+        const scaleX = canvas.width / rect.width;
+        const scaleY = canvas.height / rect.height;
+        return {
+            x: (clientX - rect.left) * scaleX,
+            y: (clientY - rect.top) * scaleY,
+        };
+    };
+    canvas.addEventListener("mousedown", (e) => {
+        const p = getCanvasPoint(e.clientX, e.clientY);
+        input.mouseX = p.x;
+        input.mouseY = p.y;
+        input.mouseDown = true;
+        input.mousePressed = true;
+        syncPrimaryPointer(input);
+    });
+    canvas.addEventListener("mouseup", () => {
+        input.mouseDown = false;
+        syncPrimaryPointer(input);
+    });
+    canvas.addEventListener("mousemove", (e) => {
+        const p = getCanvasPoint(e.clientX, e.clientY);
+        input.mouseX = p.x;
+        input.mouseY = p.y;
+        syncPrimaryPointer(input);
+    });
+    canvas.addEventListener("touchstart", (e) => {
+        for (const touch of Array.from(e.changedTouches)) {
+            const p = getCanvasPoint(touch.clientX, touch.clientY);
+            input.touchPointers.set(touch.identifier, {
+                x: p.x,
+                y: p.y,
+                pressed: true,
+            });
+            if (input.primaryTouchId === null) {
+                input.primaryTouchId = touch.identifier;
+            }
+        }
+        syncPrimaryPointer(input);
+        e.preventDefault();
+    }, { passive: false });
+    const clearTouches = (e) => {
+        for (const touch of Array.from(e.changedTouches)) {
+            input.touchPointers.delete(touch.identifier);
+            if (input.primaryTouchId === touch.identifier) {
+                input.primaryTouchId = null;
+            }
+        }
+        syncPrimaryPointer(input);
+        e.preventDefault();
+    };
+    canvas.addEventListener("touchend", clearTouches, { passive: false });
+    canvas.addEventListener("touchcancel", clearTouches, { passive: false });
+    canvas.addEventListener("touchmove", (e) => {
+        for (const touch of Array.from(e.changedTouches)) {
+            const p = getCanvasPoint(touch.clientX, touch.clientY);
+            const existing = input.touchPointers.get(touch.identifier);
+            if (existing) {
+                existing.x = p.x;
+                existing.y = p.y;
+            }
+            else {
+                input.touchPointers.set(touch.identifier, {
+                    x: p.x,
+                    y: p.y,
+                    pressed: false,
+                });
+            }
+        }
+        syncPrimaryPointer(input);
+        e.preventDefault();
+    }, { passive: false });
+}
+export function syncPrimaryPointer(input) {
+    if (input.primaryTouchId !== null) {
+        const primaryTouch = input.touchPointers.get(input.primaryTouchId);
+        if (primaryTouch) {
+            input.pointerX = primaryTouch.x;
+            input.pointerY = primaryTouch.y;
+            input.pointerDown = true;
+            input.pointerPressed = primaryTouch.pressed;
+            return;
+        }
+        input.primaryTouchId = null;
+    }
+    if (input.touchPointers.size > 0) {
+        const firstTouchEntry = input.touchPointers.entries().next().value;
+        if (firstTouchEntry) {
+            const [touchId, touch] = firstTouchEntry;
+            input.primaryTouchId = touchId;
+            input.pointerX = touch.x;
+            input.pointerY = touch.y;
+            input.pointerDown = true;
+            input.pointerPressed = touch.pressed;
+            return;
+        }
+    }
+    input.primaryTouchId = null;
+    input.pointerX = input.mouseX;
+    input.pointerY = input.mouseY;
+    input.pointerDown = input.mouseDown;
+    input.pointerPressed = input.mousePressed;
+}
+export function collectPointers(input) {
+    const pointers = [];
+    if (input.mouseDown) {
+        pointers.push({
+            id: "mouse",
+            kind: "mouse",
+            x: input.mouseX,
+            y: input.mouseY,
+            pressed: input.mousePressed,
+        });
+    }
+    for (const [id, pointer] of input.touchPointers.entries()) {
+        pointers.push({
+            id,
+            kind: "touch",
+            x: pointer.x,
+            y: pointer.y,
+            pressed: pointer.pressed,
+        });
+    }
+    return pointers;
+}
+export function isScreenPointOverSprite(x, y, sprite, radiusScale, scrollX, scrollY) {
+    const safeScale = Math.max(0, radiusScale);
+    const radius = sprite.size * safeScale;
+    const drawX = sprite.ignoreScroll ? sprite.x : sprite.x - scrollX;
+    const drawY = sprite.ignoreScroll ? sprite.y : sprite.y - scrollY;
+    const dx = x - drawX;
+    const dy = y - drawY;
+    return dx * dx + dy * dy <= radius * radius;
+}
+export function isPointerDownOverSprite(input, sprite, radiusScale, scrollX, scrollY) {
+    if (!sprite)
+        return false;
+    return collectPointers(input).some((pointer) => isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale, scrollX, scrollY));
+}
+export function isPointerPressedOverSprite(input, sprite, radiusScale, scrollX, scrollY) {
+    if (!sprite)
+        return false;
+    return collectPointers(input).some((pointer) => pointer.pressed &&
+        isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale, scrollX, scrollY));
+}
+export function getPointersOverSprite(input, sprite, radiusScale, scrollX, scrollY) {
+    if (!sprite)
+        return [];
+    return collectPointers(input).filter((pointer) => isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale, scrollX, scrollY));
+}
+export function resetTransientInput(input) {
+    input.keysPressed.clear();
+    input.mousePressed = false;
+    for (const pointer of input.touchPointers.values()) {
+        pointer.pressed = false;
+    }
+    syncPrimaryPointer(input);
+}

package/dist/internal-types.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// Internal types (stripped from .d.ts via @internal + stripInternal)
+// ---------------------------------------------------------------------------
+export {};

package/dist/minimo.d.ts

@@ -155,6 +155,32 @@ export declare class Sprite {
      */
     constructor(sprite: string, x?: number, y?: number);
 }
+/**
+ * Snapshot of an active pointer tracked by the engine.
+ *
+ * Coordinates are in canvas/screen space, matching {@link Game.pointerX} and
+ * {@link Game.pointerY}. For world-space comparisons, use helpers such as
+ * {@link Game.isPointerDownOverSprite} or {@link Game.getPointersOverSprite}.
+ */
+export interface PointerInfo {
+    /**
+     * Unique pointer id.
+     * - Mouse always uses `"mouse"`.
+     * - Touch pointers use the browser touch identifier.
+     */
+    id: "mouse" | number;
+    /** Pointer source kind. */
+    kind: "mouse" | "touch";
+    /** Current X position in canvas/screen space, in pixels. */
+    x: number;
+    /** Current Y position in canvas/screen space, in pixels. */
+    y: number;
+    /**
+     * `true` only on the frame this pointer started pressing.
+     * For held pointers after the first frame, this becomes `false`.
+     */
+    pressed: boolean;
+}
 /**
  * # MinimoJS v1 — AI Agent Integration Guide
  *
@@ -685,6 +711,103 @@ export declare class Game {
      * ```
      */
     isPointerPressed(): boolean;
+    /**
+     * 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 circular area centered on the sprite. The radius
+     * is `sprite.size * radiusScale`. World-space sprites are tested against the
+     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
+     * screen space.
+     *
+     * 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.size` to define the hit radius.
+     *   Default: `0.5`.
+     * @returns `true` if any currently held pointer overlaps the sprite hit area.
+     *
+     * @example
+     * ```ts
+     * if (game.isPointerDownOverSprite(leftButton, 0.72)) {
+     *   player.x -= 200 * dt;
+     * }
+     * ```
+     */
+    isPointerDownOverSprite(sprite: Sprite | null | undefined, radiusScale?: number): 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 circular area centered on the sprite. The radius
+     * is `sprite.size * radiusScale`. World-space sprites are tested against the
+     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
+     * screen space.
+     *
+     * 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.size` to define the hit radius.
+     *   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)) {
+     *   startGame();
+     * }
+     * ```
+     */
+    isPointerPressedOverSprite(sprite: Sprite | null | undefined, radiusScale?: number): boolean;
+    /**
+     * Returns a read-only snapshot of all currently active pointers.
+     *
+     * Mouse appears in the list only while the mouse button is held down. Touches
+     * appear while they remain active on the canvas. Coordinates are returned in
+     * canvas/screen space.
+     *
+     * Use this for advanced multitouch controls such as joysticks, drag handles,
+     * or gesture-like gameplay logic.
+     *
+     * @returns A read-only array of active pointer snapshots.
+     *
+     * @example
+     * ```ts
+     * const pointers = game.getPointers();
+     * if (pointers.length > 0) {
+     *   const first = pointers[0];
+     *   game.text(`Pointer: ${first.x}, ${first.y}`, 10, 10);
+     * }
+     * ```
+     */
+    getPointers(): readonly PointerInfo[];
+    /**
+     * Returns a read-only snapshot of all active pointers currently overlapping
+     * the target sprite.
+     *
+     * Pointer hit testing uses a circular area centered on the sprite. The radius
+     * is `sprite.size * radiusScale`. World-space sprites are tested against the
+     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
+     * screen space.
+     *
+     * 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.size` to define the hit radius.
+     *   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);
+     * if (touches.length > 0) {
+     *   const p = touches[0];
+     *   const dx = p.x - joystickBase.x;
+     * }
+     * ```
+     */
+    getPointersOverSprite(sprite: Sprite | null | undefined, radiusScale?: number): readonly PointerInfo[];
     /**
      * Returns `true` when the current device appears to be mobile/touch-first.
      *