1 files changed, 14 insertions, 18 deletions
diff --git a/tools/feed-wheel-reverse-test.js b/tools/feed-wheel-reverse-test.js
index 8a00b11..1f133ff 100644
--- a/tools/feed-wheel-reverse-test.js
+++ b/tools/feed-wheel-reverse-test.js
@@ -46,24 +46,20 @@ for (const dir of [1, -1]) {
   assert((f.y - reversed) * dir < 0, 'next frame continues in the new direction');
   assert(Math.abs(f.y - reversed) < 20, 'new velocity is not applied to the old frame delay');
   settle(f);
-  // The turn back is a hunt: a quarter of a notch's travel, not a flight the other way.
+  // The turn back is a plain notch from rest: its full travel, no flight the other way.
   const back = (before - f.y) * dir;
-  assert(back > 65 && back < 90, 'a reverse notch against a coast is a short step: ' + back);
-  // Each notch on grows the step back towards a full one; the sixth is a plain notch again.
-  const steps = [];
-  for (let i = 0; i < 5; i++) { f.advance(200); const y = f.y; f.wheel(-dir); settle(f); steps.push((y - f.y) * dir); }
-  assert(steps.every((s, i) => i === 0 || s > steps[i - 1] * 1.08), 'hunting steps grow notch by notch: ' + steps.map(Math.round));
-  assert(steps[0] > 95 && steps[0] < 125 && steps[3] > 240 && steps[3] < 285 && steps[4] > 280 && steps[4] < 330, 'from about a third of a notch to a full one: ' + steps.map(Math.round));
-  { f.advance(200); const y = f.y; f.wheel(-dir); settle(f); const s = (y - f.y) * dir; assert(s > 280 && s < 330, 'a few flicks on, the wheel flies again: ' + s); }
-  // A turn back while hunting starts the small steps over.
-  f.wheel(-dir); f.advance(17); f.frame(); f.advance(17); f.frame();
-  { const y = f.y; f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > 65 && s < 90, 'a reversal while hunting is a short step again: ' + s); }
-  { f.advance(300); const y = f.y; f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > 95 && s < 120, 'and the next grows from there: ' + s); }
-  // A pause ends the hunt: the next notch is the plain push from rest.
-  { f.advance(2200); const y = f.y; f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > 280 && s < 330, 'after a pause a notch is a full push: ' + s); }
-  // A turn back against a coast that only just died hunts too.
-  { f.wheel(dir); settle(f); f.advance(200); const y = f.y; f.wheel(-dir); settle(f); const s = (y - f.y) * dir; assert(s > 65 && s < 90, 'reversing right after the coast dies is a short step: ' + s); }
-  // ...but a notch from rest the other way, well after, is a full one.
+  assert(back > 280 && back < 330, 'a reverse notch against a coast travels one notch: ' + back);
+  // For a moment after a reversal notches don't wind the speed up: a
+  // reversal and a quick second notch travel about two notches, not a flight.
+  let calm;
+  { f.wheel(-dir); f.advance(17); f.frame(); f.wheel(-dir); f.advance(120); f.frame(); // coasting again, the other way
+    const y = f.y; f.wheel(dir); f.advance(60); f.frame(); f.wheel(dir); settle(f); calm = (f.y - y) * dir;
+    assert(calm > 540 && calm < 700, 'a reversal and a quick second notch: about two notches of travel: ' + calm); }
+  // From rest, well after, the wind-up is back: the same two quick notches go further.
+  { f.advance(2500); const y = f.y; f.wheel(dir); f.advance(60); f.frame(); f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > calm + 40, 'two quick notches with the wind-up go further: ' + s + ' vs ' + calm); }
+  // From rest a notch either way is a full push.
   { f.advance(2500); const y = f.y; f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > 280 && s < 330, 'from rest a notch either way is a full push: ' + s); }
+  // A turn back against a coast that only just died is a reversal too (caught, no wind-up).
+  { f.wheel(dir); settle(f, 40); f.advance(100); const y = f.y; f.wheel(-dir); f.advance(60); f.frame(); f.wheel(-dir); settle(f); const s = (y - f.y) * dir; assert(s > 520 && s < 700, 'reversing right after the coast dies: no wind-up: ' + s); }
 }
-console.log('✓ immediate reversal both ways, stale frame timestamps, busy frame recovery, precision hunt after a reversal (short steps that grow, restart on another turn back, end on a pause)');
+console.log('✓ immediate reversal both ways, stale frame timestamps, busy frame recovery, a reversal is a plain notch with no wind-up for a moment');