@msb235/blits-rapier 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -4,6 +4,29 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. The release workflow refuses a `rapier-v*` tag with no
 section here.
 
+## 0.7.1
+
+### Changed
+
+- Built and tested against engine 1.1.1.
+
+## 0.7.0
+
+### Breaking
+
+- `@msb235/blits` is a peer at `^1.1.0`, where it was `^1.0.0`. It needs that release's `mix.onSeek`
+  and `mix.call`.
+
+### Fixed
+
+- `impulse`, `drop` and `body` are calls on the mix's tape, so a `cue` or any other host call made
+  after a seek back leaves the calls ahead behind, and `tape.switchBranch` brings them back. The
+  world learns of each seek from `onSeek`, paused or not, where it guessed from frame numbers and
+  timestamps. A host making a call again once the mix has played past it again has made it twice,
+  as with a `cue`.
+- A seek forward after a seek back past memory, with a history store, replays exactly: the world
+  paged its log of pushes before stepping through it, so the stretch replayed with the wrong push.
+
 ## 0.6.0
 
 ### Breaking

package/README.md

@@ -55,11 +55,12 @@ const { position, rotation } = sim.mix.probe(box);
   the shown pose moves, so handing it back starts the simulation from there. A voice outside the
   role adds on top of wherever physics has it.
 - **`body.impulse(v)`** applies an impulse once, on the step after the mix's current time.
-  **`body.drop()`** takes the body out of the world then. Both are logged at that time, so a seek
-  back before it undoes them and playing forward through it does them again. One of these calls,
-  or `sim.body`, made after a seek lets go of the calls logged ahead of it before the seek, as a
-  call on the mix's tape starts a new future: a host that makes its calls again on the way does
-  each once.
+  **`body.drop()`** takes the body out of the world then. They and `sim.body` are calls on the
+  mix's tape (`mix.call`), so a seek back before one undoes it, and the mix makes it again as it
+  plays past, as it does a `cue`. Any host call made after a seek back, one of these or a call on
+  the mix, starts a new future without the calls that lay ahead, and `tape.switchBranch` brings
+  them back. A host that makes a call again after the mix has played past it again has made it
+  twice, as with a `cue`.
 - **`sim.world()`** is the Rapier world as the last `sync` left it, for reading: raycasts, contact
   queries, debugging draws. A change made to it directly is lost at the next seek.
 
@@ -137,14 +138,8 @@ deterministic build.
 ## Not handled
 
 - **Reads at another time.** `mix.project(t)` and `mix.trace` show a body where the world was at
-  the last `sync`, not at `t`, since the world is a voice on a subject of its own. A seek is
-  shown at once, before the next `sync`.
-- **Picking another future.** The tape's `switchBranch` brings back the mix's own calls, not
-  `impulse`, `drop` or `body` calls a later one let go of. A call on the mix itself, such as a
-  `cue`, made after a seek does not let go of those calls logged ahead.
-- **A seek forward past memory after playing on from a seek back**, with a `store`: the seek back
-  cuts the pushes paged after it from the store, so the world replays that stretch with the push
-  of the first frame it still holds. Within memory it replays exactly.
+  the last `sync` or seek, not at `t`, since the world is a voice on a subject of its own and a
+  patch reads no other subject. A seek is shown at once, before the next `sync`.
 - **Growth with a store.** Each `impulse`, `drop` and `body` call is kept for the session, since
   a seek past memory replays it and a body's description is a Rapier object, not data a store
   takes. Without a store they go once history can no longer reach them. Every body made keeps its

package/dist/physics.js

@@ -208,36 +208,35 @@ export function physics(kit, opts) {
         return holds;
     };
     let next = 0;
-    // The frame, mix time and host timestamp of the last `step`, the first frame after a seek it
-    // noticed, and the frame `live` was read in. A seek comes and goes without the driver hearing.
-    let lastSeq;
-    let lastAt = Number.NEGATIVE_INFINITY;
-    let lastTs = Number.NaN;
-    let soughtSeq = Number.NEGATIVE_INFINITY;
-    let liveSeq = Number.NaN;
     let startAt = Number.NaN;
-    const sought = () => lastSeq !== undefined && history?.tape !== undefined && (m.seq > lastSeq + 1 || m.now < lastAt);
-    /** Reads the world at the time sought after seeks since the last step, with no sync since. */
-    const fresh = () => {
-        if (lastSeq === undefined ||
-            history?.tape === undefined ||
-            liveSeq === m.seq ||
-            m.timestamp !== lastTs)
-            return;
+    // Where the mix stood before the coming frame, whose pushes stand for the stretch from there.
+    let from = Number.NEGATIVE_INFINITY;
+    // Sought since the world was last read, so the next read steps it to the time sought.
+    let stale = false;
+    m.onSeek((s) => {
+        // What was logged after the frame kept is from a future the tape makes again.
+        if (s.back)
+            for (let i = log.length - 1; i >= 0; i--)
+                if (log[i].seq > s.frame)
+                    log.splice(i, 1);
+        from = s.at;
+        holding = {};
+        held.clear();
+        stale = true;
+    });
+    const read = () => {
+        stale = false;
         m.probe(WORLD);
         live = seen;
-        liveSeq = m.seq;
     };
-    /** Logs a call, letting go of the calls logged ahead of it before a seek, as the mix's tape does. */
-    const call = (entry) => {
-        if (sought())
-            soughtSeq = lastSeq + 1;
-        const from = entry.at - stepMs / 2;
-        for (let i = log.length - 1; i >= 0 && log[i].at >= from; i--)
-            if (log[i].seq < soughtSeq)
-                log.splice(i, 1);
-        insert(log, entry);
+    const fresh = () => {
+        if (stale)
+            read();
     };
+    // Apart from `body`, so the closures a body keeps do not hold its description once the tape lets go.
+    const adding = (key, desc, colliders) => (at, seq) => ({ at, seq, key, kind: 'add', desc, colliders });
+    /** Logs a call on the mix's tape, so the mix makes it again wherever it makes the host's again. */
+    const call = (label, entry) => m.call(label, () => insert(log, entry(now(), m.seq)));
     const step = () => {
         // Cued before the mix has a time, the world would catch up from mix time 0 on its first step.
         if (!started) {
@@ -266,24 +265,17 @@ export function physics(kit, opts) {
             startAt = at;
         // This frame stands for the frames logged after where the mix stood before it, up to its own
         // time. Those ahead stay for a seek forward, which replays them as the mix's tape does its calls.
-        let before = lastAt;
-        if (sought()) {
-            before = m.project({ frame: seq - 1 }).timestamp;
-            soughtSeq = lastSeq + 1;
-            holding = {};
-            held.clear();
-        }
         let end = pushLog.length;
         while (end > 0 && pushLog[end - 1].at > at)
             end--;
         let start = end;
         while (start > 0 &&
-            (pushLog[start - 1].at > before || pushLog[start - 1].at === at))
+            (pushLog[start - 1].at > from || pushLog[start - 1].at === at))
             start--;
         pushLog.splice(start, end - start, { at, seq, pushes, holds: holding, goals });
-        lastSeq = seq;
-        lastAt = at;
-        lastTs = m.timestamp;
+        from = at;
+        // Stepped before older frames are paged, since a world behind after a seek steps through them.
+        read();
         let old = 0;
         while (old < pushLog.length - 1 && pushLog[old + 1].at < at - keep)
             old++;
@@ -297,9 +289,6 @@ export function physics(kit, opts) {
                 seq,
                 data: { pushes, holds, goals },
             })));
-        m.probe(WORLD);
-        live = seen;
-        liveSeq = seq;
         // Without a store, calls older than any copy a replay starts from are in every copy already,
         // once history no longer reaches the world's first step, which a fresh world replays from.
         const reach = Math.min(at, live?.t ?? at) - keep - stepMs;
@@ -317,7 +306,7 @@ export function physics(kit, opts) {
         role: ROLE,
         body(desc, ...colliders) {
             const key = next++;
-            call({ at: now(), seq: m.seq, key, kind: 'add', desc, colliders });
+            call('add body', adding(key, desc, colliders));
             const controls = {};
             keys.set(controls, `controls ${key}`);
             const own = (spec, subject) => {
@@ -339,8 +328,11 @@ export function physics(kit, opts) {
                     driven.add(body);
                     return own(spec, controls);
                 },
-                impulse: (v) => call({ at: now(), seq: m.seq, key, kind: 'impulse', v: [...v] }),
-                drop: () => call({ at: now(), seq: m.seq, key, kind: 'drop' }),
+                impulse: (v) => {
+                    const copied = [...v];
+                    call('impulse', (at, seq) => ({ at, seq, key, kind: 'impulse', v: copied }));
+                },
+                drop: () => call('drop body', (at, seq) => ({ at, seq, key, kind: 'drop' })),
             };
             keys.set(body, `body ${key}`);
             body.simulated = m.cue({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits-rapier",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Pairs Rapier rigid-body physics with a blits mix: voices push bodies, and each body's simulated pose blends with authored motion",
   "keywords": [
     "physics",
@@ -38,14 +38,14 @@
     "prepack": "rm -rf dist && npm run build"
   },
   "peerDependencies": {
-    "@msb235/blits": "^1.0.0",
+    "@msb235/blits": "^1.1.0",
     "@dimforge/rapier2d-compat": ">=0.21.0 <1.0.0",
     "@dimforge/rapier3d-compat": ">=0.21.0 <1.0.0"
   },
   "devDependencies": {
     "@dimforge/rapier2d-compat": "0.21.0",
     "@dimforge/rapier3d-compat": "0.21.0",
-    "@msb235/blits": "1.0.0"
+    "@msb235/blits": "1.1.1"
   },
   "peerDependenciesMeta": {
     "@dimforge/rapier2d-compat": {