castle-web-cli 0.4.120 → 0.4.122

package/kits/physics-2d/engine/scene.js

@@ -41,6 +41,12 @@ export class SceneRuntime {
     this.files = files ?? {};
     this.time = 0;
     this.keys = new Set();
+    // Every active pointer (finger / mouse / stylus), keyed by the browser's
+    // pointerId. A control that starts a gesture latches the id it started on
+    // and follows THAT pointer, so a second finger landing can't steal or drop
+    // an in-progress drag. `pointer` stays the primary (first-down) pointer for
+    // single-touch behaviors and for decks reading the documented API.
+    this.pointers = new Map();
     this.pointer = { x: 0, y: 0, down: false };
     this.data = { actors: [] };
     this.actors = new Map();
@@ -210,11 +216,85 @@ export class SceneRuntime {
   // input path -- the standalone ScenePlayer and the editor's play mode --
   // agree on it; behaviors read `scene.pointer` in world coordinates. Pass
   // `down` to also update the press state.
-  setPointerFromScreen(canvas, clientX, clientY, down) {
+  // `pointerId` identifies which finger/device this event came from; the
+  // browser reuses it for every event of one contact, press through release.
+  setPointerFromScreen(canvas, clientX, clientY, down, pointerId = 0) {
     const point = screenToCard(canvas, clientX, clientY);
-    this.pointer.x = point.x + (this.camera?.x ?? 0);
-    this.pointer.y = point.y + (this.camera?.y ?? 0);
-    if (down !== undefined) this.pointer.down = down;
+    const x = point.x + (this.camera?.x ?? 0);
+    const y = point.y + (this.camera?.y ?? 0);
+    let p = this.pointers.get(pointerId);
+    if (!p) {
+      // Only a press creates a pointer. A move with no press is a mouse hover,
+      // and a stray event after release must not resurrect a finished contact.
+      if (down !== true) return this.syncPrimaryPointer(x, y);
+      p = { id: pointerId, x, y, down: false, justPressed: false, claimedBy: null, claimPriority: 0 };
+      this.pointers.set(pointerId, p);
+    }
+    p.x = x;
+    p.y = y;
+    // The press edge is per-pointer, so a finger landing while another is
+    // already held still registers as a new press (a shared `down` flag would
+    // show no rising edge and the second press would be invisible).
+    if (down === true && !p.down) p.justPressed = true;
+    if (down !== undefined) p.down = down;
+    this.syncPrimaryPointer(x, y);
+  }
+
+  // Claim a pointer for one gesture, so two controls can't both act on the same
+  // finger. Returns whether `ownerId` holds it afterwards.
+  //
+  // `priority` resolves the case that actor order otherwise decides arbitrarily:
+  // a TARGETED control (a Draggable whose collider was actually pressed) must
+  // beat a GREEDY one (a Slingshot set to grab anywhere, an AnalogStick that
+  // takes any press), no matter which actor updates first. A higher priority
+  // takes the pointer from a lower one; equal or lower leaves it alone.
+  //
+  // Losing a claim is how the greedy control learns to stand down, and it costs
+  // nothing visible: on the press frame its own displacement from its origin is
+  // still zero, so it has commanded no velocity yet.
+  claimPointer(pointerId, ownerId, priority = 0) {
+    const p = this.pointers.get(pointerId);
+    if (!p) return false;
+    if (p.claimedBy == null || p.claimedBy === ownerId || priority > p.claimPriority) {
+      p.claimedBy = ownerId;
+      p.claimPriority = priority;
+    }
+    return p.claimedBy === ownerId;
+  }
+
+  // True while `ownerId` still holds this pointer. A control that latched a
+  // pointer checks this each frame so it releases when outranked. Claims need no
+  // cleanup: they live on the pointer entry, which disappears when it lifts.
+  ownsPointer(pointerId, ownerId) {
+    return this.pointers.get(pointerId)?.claimedBy === ownerId;
+  }
+
+  // Released pointers are reaped at the end of the frame rather than on the
+  // event, so a tap that begins and ends between two frames is still seen once
+  // -- and so a control latched to a pointer observes `down: false` before the
+  // entry disappears.
+  reapPointers() {
+    for (const [id, p] of this.pointers) {
+      p.justPressed = false;
+      if (!p.down) this.pointers.delete(id);
+    }
+    this.syncPrimaryPointer();
+  }
+
+  // `pointer` mirrors the primary -- the oldest pointer still held (Map keeps
+  // insertion order) -- so single-touch behaviors and decks reading the
+  // documented `scene.pointer` API behave exactly as before.
+  syncPrimaryPointer(fallbackX, fallbackY) {
+    for (const p of this.pointers.values()) {
+      if (!p.down) continue;
+      this.pointer.x = p.x;
+      this.pointer.y = p.y;
+      this.pointer.down = true;
+      return;
+    }
+    if (fallbackX !== undefined) this.pointer.x = fallbackX;
+    if (fallbackY !== undefined) this.pointer.y = fallbackY;
+    this.pointer.down = false;
   }
 
   update(dt) {
@@ -228,6 +308,8 @@ export class SceneRuntime {
     for (const system of this.systems) {
       system.afterBehaviors?.(this, dt);
     }
+    // Every behavior and system has now seen this frame's presses and releases.
+    this.reapPointers();
   }
 
   forEachBehavior(actor, callback) {

package/kits/physics-2d/engine/ui.jsx

@@ -458,6 +458,19 @@ function NumberInlineInput({ value, min, max, step, onCommit, onDone }) {
   );
 }
 
+// Snap to a multiple of `step`. `Math.round(v / step) * step` alone reintroduces
+// binary error the moment `step` isn't representable in base 2 -- 0.05 x 14 is
+// 0.7000000000000001, which then gets stored and rendered in full -- so re-round
+// to the decimal places the step itself implies.
+function snapToStep(v, step) {
+  const snapped = Math.round(v / step) * step;
+  const text = String(step);
+  const decimals = text.includes('e-')
+    ? Number(text.split('e-')[1])
+    : (text.split('.')[1] ?? '').length;
+  return Number(snapped.toFixed(Math.min(decimals, 100)));
+}
+
 export function NumberField({ label, value, onChange, min, max, step = 1, overridden, defaultValue, onReset }) {
   const current = Number.isFinite(value) ? (value ?? 0) : 0;
   // A field with BOTH a min and max is a true slider (fill + thumb), the pointer's X
@@ -481,7 +494,7 @@ export function NumberField({ label, value, onChange, min, max, step = 1, overri
     return v;
   }
   function scrubTo(v) {
-    if (step) v = Math.round(v / step) * step;
+    if (step) v = snapToStep(v, step);
     v = clampVal(v);
     if (v !== current) onChange(v);
   }

package/kits/physics-2d/main.jsx

@@ -12,13 +12,22 @@ if (!root) throw new Error('Missing root element');
 // File browsing and the code/text editor are now builtin shell panels, so the
 // kit only renders the deck (play) and its rich per-file editors (scene/pxart):
 //   (no edit / ?edit=0)        -> play the deck (playtest panel)
-//   ?file=<path>[&editor=<id>] -> a single rich editor for that file
+//   ?file=<path>[&editorModule=<path>] -> a single rich editor for that file
 const params = new URLSearchParams(window.location.search);
 function pick() {
   const initialScene = params.get('scene') ?? undefined;
   if (!isEdit()) return <PlayOnly initialScene={initialScene} />;
   const file = params.get('file');
-  if (file) return <SingleEditor path={file} editor={params.get('editor') ?? undefined} />;
+  if (file)
+    return (
+      <SingleEditor
+        path={file}
+        editor={params.get('editor') ?? undefined}
+        // Which module edits this file, resolved by the serve from whichever
+        // deck declared the type -- see `editor` in castle.json.
+        editorModule={params.get('editorModule') ?? undefined}
+      />
+    );
   return <PlayOnly initialScene={initialScene} />;
 }
 createRoot(root).render(<ErrorBoundary>{pick()}</ErrorBoundary>);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.120",
+  "version": "0.4.122",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"
@@ -37,6 +37,7 @@
     "@xterm/xterm": "^6.0.0",
     "codemirror": "^6.0.2",
     "dockview": "^4.13.1",
+    "html2canvas": "^1.4.1",
     "marked": "^18.0.5",
     "nanoid": "^5.1.7",
     "open": "^10.0.0",