minimojs 1.0.0-alpha.25 → 1.0.0-alpha.27

package/dist/internal/InputSystem.js

@@ -29,6 +29,16 @@ export class InputSystem {
         this._touchPointers = new Map();
         /** @internal */
         this._primaryTouchId = null;
+        /**
+         * The primary touch after it lifted, kept until the mouse or a new touch
+         * takes over, so the pointer stays where the finger left the screen instead
+         * of jumping to the mouse's last position.
+         *
+         * @internal
+         */
+        this._releasedTouch = null;
+        /** @internal True on the frame the primary touch ended in a `touchcancel`. */
+        this._pointerCancelled = false;
     }
     get pointerX() {
         return this._pointerX;
@@ -52,16 +62,19 @@ export class InputSystem {
             this._mouseY = p.y;
             this._mouseDown = true;
             this._mousePressed = true;
+            this._releasedTouch = null;
             this.syncPrimaryPointer();
         });
         this.canvas.addEventListener("mouseup", () => {
             this._mouseDown = false;
+            this._releasedTouch = null;
             this.syncPrimaryPointer();
         });
         this.canvas.addEventListener("mousemove", (e) => {
             const p = this.getCanvasPoint(e.clientX, e.clientY);
             this._mouseX = p.x;
             this._mouseY = p.y;
+            this._releasedTouch = null;
             this.syncPrimaryPointer();
         });
         this.canvas.addEventListener("touchstart", (e) => {
@@ -76,27 +89,17 @@ export class InputSystem {
                     this._primaryTouchId = touch.identifier;
                 }
             }
+            this._releasedTouch = null;
+            this._pointerCancelled = false;
             this.syncPrimaryPointer();
             e.preventDefault();
         }, { passive: false });
         this.canvas.addEventListener("touchend", (e) => {
-            for (const touch of Array.from(e.changedTouches)) {
-                this._touchPointers.delete(touch.identifier);
-                if (this._primaryTouchId === touch.identifier) {
-                    this._primaryTouchId = null;
-                }
-            }
-            this.syncPrimaryPointer();
+            this.endTouches(e, false);
             e.preventDefault();
         }, { passive: false });
         this.canvas.addEventListener("touchcancel", (e) => {
-            for (const touch of Array.from(e.changedTouches)) {
-                this._touchPointers.delete(touch.identifier);
-                if (this._primaryTouchId === touch.identifier) {
-                    this._primaryTouchId = null;
-                }
-            }
-            this.syncPrimaryPointer();
+            this.endTouches(e, true);
             e.preventDefault();
         }, { passive: false });
         this.canvas.addEventListener("touchmove", (e) => {
@@ -131,6 +134,9 @@ export class InputSystem {
     isPointerPressed() {
         return this._pointerPressed;
     }
+    isPointerCancelled() {
+        return this._pointerCancelled;
+    }
     isPointerDownOverSprite(sprite) {
         if (!sprite)
             return false;
@@ -185,11 +191,38 @@ export class InputSystem {
         for (const pointer of this._touchPointers.values()) {
             pointer.pressed = false;
         }
+        if (this._releasedTouch)
+            this._releasedTouch.pressed = false;
+        this._pointerCancelled = false;
         this.syncPrimaryPointer();
     }
     resetPressedState() {
         this.clearFramePressedState();
     }
+    /**
+     * Removes the touches an event ended. When the primary one lifts, it is kept
+     * as the released touch at the point it lifted, carrying its frame-press flag
+     * so a tap that starts and ends between two frames still reads as pressed.
+     *
+     * @internal
+     */
+    endTouches(e, cancelled) {
+        for (const touch of Array.from(e.changedTouches)) {
+            const pointer = this._touchPointers.get(touch.identifier);
+            this._touchPointers.delete(touch.identifier);
+            if (this._primaryTouchId !== touch.identifier || !pointer)
+                continue;
+            this._primaryTouchId = null;
+            if (!cancelled) {
+                const p = this.getCanvasPoint(touch.clientX, touch.clientY);
+                pointer.x = p.x;
+                pointer.y = p.y;
+            }
+            this._releasedTouch = pointer;
+            this._pointerCancelled = cancelled;
+        }
+        this.syncPrimaryPointer();
+    }
     /** @internal */
     getCanvasPoint(clientX, clientY) {
         const rect = this.canvas.getBoundingClientRect();
@@ -257,9 +290,10 @@ export class InputSystem {
             }
         }
         this._primaryTouchId = null;
-        this._pointerX = this._mouseX;
-        this._pointerY = this._mouseY;
+        const released = this._releasedTouch;
+        this._pointerX = released ? released.x : this._mouseX;
+        this._pointerY = released ? released.y : this._mouseY;
         this._pointerDown = this._mouseDown;
-        this._pointerPressed = this._mousePressed;
+        this._pointerPressed = this._mousePressed || (released?.pressed ?? false);
     }
 }

package/dist/minimo-cards.d.ts

@@ -242,6 +242,10 @@ export declare class CardPile {
  *
  * Call {@link update} once per frame.
  *
+ * Piles and cards live in world space and scroll with the game. The table
+ * reads the pointer itself and adds `game.scrollX` and `game.scrollY`, so a
+ * scrolled board needs no conversion from the game.
+ *
  * @example
  * ```ts
  * const table = new CardTable(game, {

package/dist/minimo-cards.js

@@ -187,6 +187,10 @@ let nextTableId = 1;
  *
  * Call {@link update} once per frame.
  *
+ * Piles and cards live in world space and scroll with the game. The table
+ * reads the pointer itself and adds `game.scrollX` and `game.scrollY`, so a
+ * scrolled board needs no conversion from the game.
+ *
  * @example
  * ```ts
  * const table = new CardTable(game, {
@@ -638,12 +642,15 @@ export class CardTable {
             this.cancelDrag();
             return;
         }
+        // The pointer is in screen space and the piles and cards are in world space.
         const x = game.pointerX;
         const y = game.pointerY;
+        const worldX = x + game.scrollX;
+        const worldY = y + game.scrollY;
         if (game.isPointerPressed()) {
             this.cancelDrag();
-            const hit = this.hitTest(x, y);
-            this._press = hit ? { x, y, card: hit.card, pile: hit.pile, dragTried: false } : null;
+            const hit = this.hitTest(worldX, worldY);
+            this._press = hit ? { x, y, worldX, worldY, card: hit.card, pile: hit.pile, dragTried: false } : null;
             return;
         }
         const press = this._press;
@@ -654,11 +661,14 @@ export class CardTable {
                 this.startDrag(press);
             }
             if (this._drag)
-                this.followPointer(x, y);
+                this.followPointer(worldX, worldY);
             return;
         }
         this._press = null;
-        if (this._drag)
+        // A cancelled touch was interrupted, not released: return the cards, tap nothing.
+        if (game.isPointerCancelled())
+            this.cancelDrag();
+        else if (this._drag)
             this.finishDrag();
         else if (Math.hypot(x - press.x, y - press.y) < this.dragThreshold)
             this.onTap?.(press.card, press.pile);
@@ -715,8 +725,8 @@ export class CardTable {
             view.moving = false;
             view.waitMs = 0;
             view.dragging = true;
-            view.grabX = press.x - view.sprite.x;
-            view.grabY = press.y - view.sprite.y;
+            view.grabX = press.worldX - view.sprite.x;
+            view.grabY = press.worldY - view.sprite.y;
             view.sprite.layer = this.layer + 1000 + i * 0.01;
             this.applyScale(view);
         });

package/dist/minimo.js

@@ -1816,6 +1816,15 @@ export class Game {
     isPointerPressed() {
         return this._inputSystem.isPointerPressed();
     }
+    /**
+     * True on the frame the primary touch ended in a `touchcancel` rather than
+     * lifting, so a module can drop the gesture instead of reading it as a tap.
+     *
+     * @internal
+     */
+    isPointerCancelled() {
+        return this._inputSystem.isPointerCancelled();
+    }
     /**
      * Returns `true` while any active pointer is held down over the target sprite.
      * Works with both mouse input and multiple simultaneous touches.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimojs",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.27",
   "description": "MinimoJS v1 — ultra-minimal, flat, deterministic 2D web game engine. Image-first sprites with emoji as a zero-asset alternative, rAF loop, TypeScript-first, LLM-friendly.",
   "type": "module",
   "main": "dist/minimo.js",