Health and level restart: six hits, no bar, death takes the map with it

manifest.json

@@ -72,6 +72,14 @@
       "handPivot": [166, 58],
       "silhouette": "auto"
     },
+    "prince_hurt": {
+      "_note": "THERE IS NO HEALTH BAR. He holds his side, leans away from it and his head comes down, and that is how much is left. The only new drawing health needed — the limp is the run frames on an uneven cadence, and the slowed swing is a number.",
+      "path": "assets/prince/hurt/", "file": "lit_{nn}.svg",
+      "frames": 4, "fps": 2, "variants": true,
+      "_frames_note": "Two stages of two. Frames 0-1 are hurt, 2-3 are spent, and the scene picks the pair off how much is left — two frames alone read as 'he is hurt' and said nothing about how close he was.",
+      "native": [220, 340], "pivot": [110, 340],
+      "silhouette": "auto"
+    },
     "prince_map": {
       "_note": "The torch pose with the other hand out in front. Holding the map raises the torch — one button, one cost. The SHEET is a separate clip anchored at mapPivot, the same way the flame is anchored at handPivot, because that is what lets the sheet be lit while he stays a silhouette inside his own torchlight.",
       "path": "assets/prince/map/", "file": "lit_{nn}.svg",

src/checks.js

@@ -821,15 +821,106 @@ export function createChecks({ renderer, scene, canvas }) {
     };
   }
 
+  /**
+   * A FIGHT NOW COSTS SOMETHING.
+   *
+   * Village one played like a beat 'em up because beating up every Drained cost
+   * nothing: three hits, no health, no death. The optimal play was to hit
+   * everything and the game agreed. At zero risk there is no search at all,
+   * just a sweep — and a sweep cannot be tedious, because it is not looking for
+   * anything.
+   *
+   * What this asserts is the shape of the cost, not that it is fun:
+   *
+   *   - A man standing in the dark doing nothing is still harmless. The level's
+   *     whole argument is that nothing is hostile until it is looked at, and
+   *     health must not quietly take that away.
+   *   - Six catches, not five and not seven, and the sixth restarts the LEVEL.
+   *   - The restart takes the findings with it. A checkpoint that keeps the map
+   *     is too forgiving to change how anybody plays.
+   *   - Grace: one contact costs one hit, not one per frame of touching.
+   *   - It shows on his body — the swing slows and the stance changes — and
+   *     nowhere else. There is no bar.
+   */
+  function healthCosts() {
+    scene.reset();
+    const v = s.drained[0];
+
+    // 1. unlit, and standing right on top of it
+    s.prince.x = s.prince.prevX = v.x - 40;
+    s.camera.reset(s.prince.x);
+    drive(2);
+    const harmless = s.prince.hits === 0 && v.state === 'WANDER';
+
+    // 2. GRACE: one contact is one hit, not one per frame of touching.
+    //
+    // `v.takeHit` hurts the DRAINED — it is what wakes this one up. What hurts
+    // the prince is being in contact with it once it is rushing.
+    v.takeHit(s.prince.x);
+    let n = 0;
+    while (s.prince.hits === 0 && n < 60 * 8) { scene.update(1 / 60, { ...NONE }); n++; }
+    const first = s.prince.hits;
+    // Then pinned against it, well inside the grace window.
+    const held = Math.round((TUNING.HURT_GRACE_MS / 1000) * 60 * 0.6);
+    for (let i = 0; i < held; i++) {
+      s.prince.x = s.prince.prevX = v.x - 30;
+      scene.update(1 / 60, { ...NONE });
+    }
+    const oneContact = first === 1 && s.prince.hits === 1;
+
+    // 3. it shows on him
+    const fresh = TUNING.SWING_SLOW[0];
+    const worn = TUNING.SWING_SLOW[TUNING.SWING_SLOW.length - 1];
+    s.prince.hits = TUNING.LIMP_FROM;
+    s.prince.x = s.prince.prevX = BOWL.X0 + 200;
+    drive(0.5);
+    const stance = s.prince.clip?.name === 'prince_hurt';
+
+    // 4. six, and the level starts again with the findings gone
+    scene.reset();
+    s.houses[0].seen = true;
+    s.prince.inventory.push({ kept: 0, identity: 'a blacksmith', seen: true });
+    s.prince.x = s.prince.prevX = v.x - 30;
+    s.camera.reset(s.prince.x);
+    let caught = 0;
+    for (let k = 0; k < 14 && s.run.deaths === 0; k++) {
+      s.prince.x = s.prince.prevX = v.x - 30;
+      s.camera.reset(s.prince.x);
+      drive(1.5, { torch: true });
+      drive(2.2);
+      caught = Math.max(caught, s.prince.hits);
+    }
+    const died = {
+      tookSix: caught === TUNING.PRINCE_HITS,
+      deaths: s.run.deaths,
+      backToTheStart: s.prince.x < 1000,
+      lostTheMap: !s.houses[0].seen && s.prince.inventory.length === 0,
+      hitsReset: s.prince.hits === 0,
+    };
+
+    return {
+      name: 'health costs',
+      pass: harmless && oneContact && stance && worn > fresh * 1.5 &&
+            died.tookSix && died.deaths === 1 && died.backToTheStart &&
+            died.lostTheMap && died.hitsReset,
+      unlitIsStillHarmless: harmless,
+      graceHoldsForOneHit: oneContact,
+      holdsHisSide: stance,
+      swingSlowsBy: +(worn / fresh).toFixed(2),
+      died,
+    };
+  }
+
   function all() {
     const out = [figureContrast(), watcherContrast(), brightMass(), skyWeave(),
       bowlLayout(), bodiesPersist(), wholeLevelWalkable(), stillUntilLit(),
-      doorsRead(), mapRecords(), populationReads(), nothingOutOfReach(), theGate()];
+      doorsRead(), mapRecords(), populationReads(), nothingOutOfReach(),
+      healthCosts(), theGate()];
     return { pass: out.every((r) => r.pass), results: out };
   }
 
   return { figureContrast, watcherContrast, brightMass, skyWeave,
     bowlLayout, bodiesPersist, wholeLevelWalkable, stillUntilLit, doorsRead,
-    mapRecords, populationReads, nothingOutOfReach, theGate,
+    mapRecords, populationReads, nothingOutOfReach, healthCosts, theGate,
     all, frameAt, frameAtX };
 }

src/drained.js

@@ -257,8 +257,10 @@ export function createDrained(clips, spawnX, dir, keptIndex = 0, opts = {}) {
   };
 
   /**
-   * Shoved off as he gets back up. Staggers it without counting a hit, so it
-   * cannot simply walk back into him during the moment he needs to stand.
+   * Shoved off without counting a hit. Written for the old get-up-where-you-
+   * fell recovery, which death replaced with a level restart. Kept because it
+   * is the only way to move one of these without hurting it, and the ending
+   * will want that.
    */
   d.shoveOff = (fromX, push) => {
     if (!post) d.x += Math.sign(d.x - fromX || 1) * push;

src/render.js

@@ -115,7 +115,7 @@ export function createRenderer(ctx) {
   // drew the Drained backwards every time it moved. The manifest says which way
   // each clip was authored.
   //
-  // ART_HANDOFF.md used to promise nothing was mirrored in code. That stopped
+  // docs/ART_HANDOFF.md used to promise nothing was mirrored in code. That stopped
   // being true the moment the prince got a facing and could be attacked from
   // either side. The pivot stays on the anchor through the flip.
   function drawClip(c, clip, index, mode, worldX, worldY, camX = 0, facing = 1) {
@@ -535,6 +535,13 @@ export function createRenderer(ctx) {
     const handY = lerp(s.torch.prevHandY, s.torch.handY, alpha);
     const face = s.prince.facing;
     const torchUp = !s.prince.hasSword;
+    // The weight going out of the bad leg. Half a limp is the rhythm, which the
+    // scene does by hurrying one half of the cycle; the other half is this —
+    // he drops a few px while that foot is down.
+    const hurt = Math.max(0, s.prince.hits - TUNING.LIMP_FROM);
+    const limpDip = (hurt > 0 && s.prince.moving &&
+      s.prince.frame >= s.prince.clip.count / 2)
+      ? Math.min(TUNING.LIMP_DIP_PX, TUNING.LIMP_DIP_PX * (hurt / 3)) : 0;
 
     ctx.setTransform(1, 0, 0, 1, 0, 0);
 
@@ -561,7 +568,7 @@ export function createRenderer(ctx) {
       drawClip(ctx, d.clip, d.frame, 'dark', dx2, GROUND_Y, camX, d.facing);
       drawKept(ctx, s.kept, d, 'dark', dx2, camX, s.clock);
     }
-    drawClip(ctx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y, camX, face);
+    drawClip(ctx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y + limpDip, camX, face);
     drawMap(ctx, s, 'dark', px, camX, face);
     if (torchUp) drawClip(ctx, s.flame.clip, s.flame.frame, 'dark', handX, handY, camX, face);
     stats.bgDrawn += s.background.drawNear(ctx, camX, W, H, 'dark', px);
@@ -608,7 +615,7 @@ export function createRenderer(ctx) {
           drawClip(octx, d.clip, d.frame, 'lit', dx2, GROUND_Y, camX, d.facing);
           drawKept(octx, s.kept, d, 'lit', dx2, camX, s.clock);
         }
-        drawClip(octx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y, camX, face);
+        drawClip(octx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y + limpDip, camX, face);
         // He is never lit by his own torch. The SHEET is — it is the one thing
         // he carries that the light is for.
         drawMap(octx, s, 'lit', px, camX, face);
@@ -695,6 +702,14 @@ export function createRenderer(ctx) {
           `   village ${TUNING.BOWL_W} (${(TUNING.BOWL_W / W).toFixed(1)} screens, ` +
           `${(TUNING.BOWL_W / TUNING.WALK_SPEED).toFixed(0)}s across)` +
           `   shapes ${standing}/${s.village ? s.village.length : 0} standing, ${s.villageGap ?? 0}px apart`,
+        // NO HEALTH BAR ON SCREEN. This line is for judging the build, not for
+        // playing it — the player is meant to read it off how he is standing.
+        `hits ${s.prince.hits}/${TUNING.PRINCE_HITS}` +
+          (s.prince.hits >= TUNING.LIMP_FROM ? '  limping' : '') +
+          `   swing x${TUNING.SWING_SLOW[Math.min(s.prince.hits, TUNING.SWING_SLOW.length - 1)].toFixed(2)}` +
+          (s.run ? `   run ${s.run.seconds.toFixed(0)}s  fights ${s.run.fights}` +
+            `  took ${s.run.taken}  hit ${s.run.hitsTaken}  deaths ${s.run.deaths}` +
+            `   WATCHING ${s.run.watching.toFixed(1)}s` : ''),
         `gate ${s.gate ? `${s.gate.filled}/${TUNING.GATE_WANTS}` : '—'}` +
           (s.gate?.open >= 1 ? '  OPEN' : '  shut') +
           (s.gate?.through ? '  — through' : '') +

src/scene_level.js

@@ -26,6 +26,7 @@ export async function createLevelScene(clips, { audio = null } = {}) {
   const torchClip = clips.prince_torch;
   const guardClip = clips.prince_guard;
   const mapClip = clips.prince_map;
+  const hurtClip = clips.prince_hurt;
   const sheetClip = clips.map_sheet;
 
   // The hand the torch is held in, published by the manifest in sprite
@@ -66,6 +67,9 @@ export async function createLevelScene(clips, { audio = null } = {}) {
     torchPlayer: createPlayer(torchClip),
     guard: createPlayer(guardClip),
     mapPlayer: mapClip ? createPlayer(mapClip) : null,
+    hurtPlayer: hurtClip ? createPlayer(hurtClip) : null,
+    // Hits TAKEN, not left. There is no bar; it is read off his body.
+    hits: 0,
     attacking: false,
     attackTime: 0,
     attackConnected: false,
@@ -385,9 +389,40 @@ export async function createLevelScene(clips, { audio = null } = {}) {
 
   // The loss beat. No text, no shake, no sting — the light going out is the
   // whole thing.
+  // The DEATH beat now, not the loss beat. Being caught costs a hit; the sixth
+  // one is this, and it restarts the level.
   const loss = { active: false, timer: 0, torchWasUp: false, x: 0, y: 0, vx: 0, r: 0, by: null };
   let grace = 0;
 
+  /**
+   * Caught. Knocked back, a moment to get clear, and one less.
+   *
+   * WANDER contact is still harmless — the whole level argues that nothing is
+   * hostile until it is looked at, and a man standing in the dark doing nothing
+   * has to stay a man standing in the dark doing nothing.
+   */
+  function takeHit(fromX, knock) {
+    if (grace > 0 || loss.active) return;
+    prince.hits++;
+    run.hitsTaken++;
+    prince.x += (Math.sign(prince.x - fromX) || -1) * knock;
+    prince.prevX = prince.x;
+    prince.attacking = false;
+    grace = TUNING.HURT_GRACE_MS;
+    audio?.hit();
+    if (prince.hits < TUNING.PRINCE_HITS) return;
+    // The sixth. The light goes out and the level starts again.
+    loss.active = true;
+    loss.timer = 0;
+    prince.down.reset();
+    loss.torchWasUp = torch.raise > 0.01;
+    loss.x = torch.handX;
+    loss.y = torch.handY;
+    loss.vx = prince.facing * 120;
+    loss.r = torch.radius;
+    audio?.bodyFall();
+  }
+
   // THE MAP. Not a screen — a sheet he holds up in his own torchlight. It
   // records and it never reasons: it knows what he has looked at and nothing
   // else, and the player never does a moment's bookkeeping.
@@ -398,6 +433,20 @@ export async function createLevelScene(clips, { audio = null } = {}) {
   // He has to look. That is the level.
   const gate = { filled: 0, open: 0, through: false };
 
+  /**
+   * WHAT THIS BUILD IS FOR, counted.
+   *
+   * The question health is being added to answer is one thing: does he start
+   * standing still and looking at something before walking up to it? So the
+   * run keeps score of the only number that answers it — seconds spent with
+   * the torch up, standing still, with nothing hostile near enough to reach
+   * him. Watching from safety.
+   *
+   * Everything else here is context for that one figure.
+   */
+  const run = { seconds: 0, fights: 0, hitsTaken: 0, deaths: 0, watching: 0, taken: 0 };
+  const WATCH_CLEAR_PX = 600;
+
   const map = {
     up: false,
     // How long the sheet has been held at full raise. Reading it is looking, so
@@ -412,7 +461,7 @@ export async function createLevelScene(clips, { audio = null } = {}) {
     audio,
     ground: clips.ground,
     kept: clips.kept,
-    map, sheetClip, mapClip,
+    map, sheetClip, mapClip, hurtClip, run,
     houses: HOUSES, houseTint: PALETTE.WATCHERS,
     houseClip, houseArt, doorPoint,
     village, gateX: GATE_X, gateStopX: GATE_STOP_X,
@@ -428,6 +477,7 @@ export async function createLevelScene(clips, { audio = null } = {}) {
     prince.facing = 1;
     prince.hasSword = true;
     prince.moving = false;
+    prince.hits = 0;
     prince.run.reset();
     prince.idle.reset();
     torch.reset();
@@ -447,6 +497,9 @@ export async function createLevelScene(clips, { audio = null } = {}) {
     gate.open = 0;
     gate.through = false;
     state.fade = 0;
+    // Deaths survive a restart. Everything else about the run does not — that
+    // is what "the findings are at stake" means.
+    run.seconds = 0; run.fights = 0; run.hitsTaken = 0; run.watching = 0; run.taken = 0;
     lastRunFrame = -1;
     prince.inventory.length = 0;
     drained.forEach((d) => d.reset());
@@ -478,19 +531,13 @@ export async function createLevelScene(clips, { audio = null } = {}) {
         torch.cy = loss.y;
         torch.radius = loss.r;
       }
-      if (loss.timer >= TUNING.LOSS_HOLD_MS + 900) {
-        // He gets up where he fell. The level is not restarted — the world
-        // remembers, which means the thing that got him is still right there.
-        // So it is pushed clear and he has a moment before contact counts
-        // again, otherwise it kills him on the frame he stands up.
-        loss.active = false;
-        loss.timer = 0;
-        prince.down.reset();
-        grace = TUNING.RECOVER_GRACE_MS;
-        if (loss.by) loss.by.shoveOff(prince.x, TUNING.RECOVER_PUSH_PX);
-        torch.reset();
-        prince.attacking = false;
-      }
+      // THE LEVEL RESTARTS. He does not get up where he fell any more.
+      //
+      // The spec's checkpoint at the mouth keeps the map, and a checkpoint that
+      // keeps the findings is too forgiving to change how anybody plays. The
+      // findings have to be at stake or the fights are not a cost.
+      state.fade = Math.min(1, (loss.timer - TUNING.LOSS_HOLD_MS) / TUNING.DEATH_FADE_MS);
+      if (loss.timer >= TUNING.LOSS_HOLD_MS + TUNING.DEATH_FADE_MS) { run.deaths++; reset(); }
       return;
     }
 
@@ -537,7 +584,10 @@ export async function createLevelScene(clips, { audio = null } = {}) {
       }
     }
     if (prince.attacking) {
-      prince.attackTime += dt;
+      // THE SWING SLOWS. A cost he feels in the one thing he was using to make
+      // the cost not matter.
+      const slow = TUNING.SWING_SLOW[Math.min(prince.hits, TUNING.SWING_SLOW.length - 1)];
+      prince.attackTime += dt / slow;
       const ms = prince.attackTime * 1000;
       const active = ms >= TUNING.ATTACK_WINDUP_MS &&
                      ms < TUNING.ATTACK_WINDUP_MS + TUNING.ATTACK_ACTIVE_MS;
@@ -573,25 +623,16 @@ export async function createLevelScene(clips, { audio = null } = {}) {
       // Contact with a WANDER one is not a loss. He walks into someone standing
       // in the dark and nothing happens at all, which is worse.
       if (kind === 'shove' && grace <= 0) {
-        // Knocked back out of his reach. He loses ground, not the run — and a
-        // moment's grace, or the same thrust shoves him again next frame.
-        prince.x = d.x + Math.sign(prince.x - d.x || -1) * (TUNING.POST_REACH + TUNING.POST_SHOVE_PX);
-        prince.prevX = prince.x;
-        grace = TUNING.RECOVER_GRACE_MS * 0.5;
-        prince.attacking = false;
-        audio?.bodyFall();
+        // He loses ground AND one of his six. He was the only thing in the
+        // village that could not hurt you, which made the hard fight free.
+        loss.by = d;
+        const back = d.x + Math.sign(prince.x - d.x || -1) * (TUNING.POST_REACH + TUNING.POST_SHOVE_PX);
+        takeHit(d.x, 0);
+        if (!loss.active) { prince.x = back; prince.prevX = back; }
       }
       if (kind === 'fatal' && !loss.active) {
-        loss.active = true;
-        loss.timer = 0;
         loss.by = d;
-        audio?.bodyFall();
-        prince.down.reset();
-        loss.torchWasUp = torch.raise > 0.01;
-        loss.x = torch.handX;
-        loss.y = torch.handY;
-        loss.vx = prince.facing * 120;
-        loss.r = torch.radius;
+        takeHit(d.x, TUNING.HURT_KNOCK_PX);
       }
     }
 
@@ -643,11 +684,21 @@ export async function createLevelScene(clips, { audio = null } = {}) {
     }
     if (wantsPickup && nearest && !prince.attacking) {
       nearest.keptTaken = true;
+      run.taken++;
       prince.inventory.push({
         kept: nearest.kept, identity: nearest.identity, seen: nearest.keptSeen,
       });
     }
 
+    // --- the score ----------------------------------------------------------
+    run.seconds += dt;
+    run.fights = drained.filter((d) => d.revealed).length;
+    if (torch.raise > 0.9 && !prince.moving) {
+      const near = drained.some((d) => d.state !== DOWNED &&
+        Math.abs(d.x - prince.x) < WATCH_CLEAR_PX);
+      if (!near) run.watching += dt;
+    }
+
     // --- the gate -----------------------------------------------------------
     // It counts what he is CARRYING and has looked at, and it counts live: put
     // one down and a mark goes out again. The map keeps score and the score is
@@ -680,7 +731,21 @@ export async function createLevelScene(clips, { audio = null } = {}) {
       state.flame.frame = state.flame.player.index;
     } else if (prince.moving) {
       const rate = runClip.groundSpeed ? TUNING.WALK_SPEED / runClip.groundSpeed : 1;
-      prince.run.advance(dt * rate);
+      // THE LIMP, AND IT IS HER OWN RUN FRAMES.
+      //
+      // A limp is an asymmetric rhythm, not a different drawing: the good foot
+      // carries longer and the bad one is hurried off. So the cycle is slowed
+      // through its second half and rushed through the first, by an amount that
+      // grows with the hits he has taken. Nothing was redrawn for it, and it
+      // reads because it is what a limp actually is.
+      const hurt = Math.max(0, prince.hits - TUNING.LIMP_FROM);
+      if (hurt > 0) {
+        const half = prince.run.index >= runClip.count / 2;
+        const hitch = 1 - Math.min(0.8, TUNING.LIMP_HITCH * (hurt / 3)) * (half ? 1 : -0.5);
+        prince.run.advance(dt * rate / hitch);
+      } else {
+        prince.run.advance(dt * rate);
+      }
       prince.clip = runClip;
       prince.frame = prince.run.index;
       // A footstep when the boot ARRIVES, not on a timer. runClip.footFrames is
@@ -689,6 +754,17 @@ export async function createLevelScene(clips, { audio = null } = {}) {
         if (runClip.footFrames?.includes(prince.frame)) audio?.footstep();
         lastRunFrame = prince.frame;
       }
+    } else if (prince.hits >= TUNING.LIMP_FROM && hurtClip) {
+      // Standing still with something left in him, he holds his side. This is
+      // the whole health readout: no bar, no number, just how he is standing.
+      //
+      // Two stages. Which pair of frames he is in is how close he is — the
+      // first is hurt, the second is spent, and the switch is at the halfway
+      // point of what he can take.
+      prince.hurtPlayer.advance(dt);
+      const spent = prince.hits >= Math.ceil(TUNING.PRINCE_HITS / 2) + 1;
+      prince.clip = hurtClip;
+      prince.frame = (spent ? 2 : 0) + (prince.hurtPlayer.index % 2);
     } else if (drained.some((d) => d.revealed && d.state !== DOWNED && Math.abs(d.x - prince.x) < W)) {
       // Once one has been seen and is coming, he stands ready.
       prince.guard.advance(dt);

src/silhouette.js

@@ -19,7 +19,7 @@
 // sealing: 2.43x, and it reads correctly — body solid, fingers separate, boots
 // intact.
 //
-// See FINDINGS.md for the full write-up.
+// See docs/FINDINGS.md for the full write-up.
 
 const INF = 1 << 28;
 

src/tuning.js

@@ -257,17 +257,49 @@ export const TUNING = {
   ATTACK_ACTIVE_MS: 80,
   ATTACK_RECOVERY_MS: 220,
 
+  // --- HEALTH, and the reason it is here ------------------------------------
+  //
+  // Village one played like a beat 'em up, and it played that way because
+  // beating up every Drained cost nothing: three hits, no health, no death. So
+  // the optimal play was to hit everything, and the game agreed.
+  //
+  // The spec's reasoning for leaving health out was wrong, and its author said
+  // so: the question was whether the SEARCH is tedious, and tedium measures
+  // fine at zero risk — but at zero risk there is no search at all, just a
+  // sweep. A sweep cannot be tedious because it is not looking for anything.
+  //
+  // SIX, not three. Three plus a ten-screen restart means one mistake costs
+  // fifteen minutes and people reload the page instead of playing on. Six makes
+  // a death a run of bad decisions rather than one bad moment.
+  //
+  // It does not come back. Six is six for the whole run, and a restart is the
+  // only thing that resets it.
+  PRINCE_HITS: 6,
+  HURT_GRACE_MS: 900,       // caught once, then a moment to get clear
+  HURT_KNOCK_PX: 260,
+
+  // NO HEALTH BAR. It is read off his body, the same rule as everything else:
+  // he limps, he holds his side, and the swing slows.
+  //
+  // The limp is HER run frames on an uneven cadence with a dip on the bad side,
+  // not a new drawing. A limp is an asymmetric rhythm, so this is the truer
+  // version as well as the cheaper one.
+  LIMP_FROM: 2,             // hits taken before the walk goes uneven
+  LIMP_HITCH: 0.42,         // how much slower the bad foot's half of the cycle is
+  LIMP_DIP_PX: 7,
+  // The swing slows as he goes, by hits taken. A cost he can feel in the one
+  // thing he was using to make the cost not matter.
+  SWING_SLOW: [1, 1, 1.1, 1.24, 1.42, 1.66],
+
   LOSS_HOLD_MS: 800,
+  // Death restarts the LEVEL. The spec's checkpoint at the mouth keeps the map,
+  // and a checkpoint that keeps the findings is too forgiving to change how
+  // anybody plays. The findings have to be at stake.
+  DEATH_FADE_MS: 1600,
 
-  // Getting up after a loss. He comes back where he fell and the world
-  // remembers — bodies still down, revealed ones still revealed. The thing that
-  // got him is still standing there, so he needs a moment or it simply kills
-  // him again on the frame he stands up.
-  RECOVER_GRACE_MS: 1200,
-  // 190 left a 98px gap against a 110px contact reach, so it grabbed him again
-  // the instant the grace ran out. It also kept walking in during the grace,
-  // which is why it is staggered as well as pushed.
-  RECOVER_PUSH_PX: 420,
+  // RECOVER_GRACE_MS and RECOVER_PUSH_PX lived here and are gone. They were for
+  // getting up where he fell, which is not what happens any more: being caught
+  // costs one of six, and the sixth restarts the level. See PRINCE_HITS.
 
   // How close he has to be to take the object off the ground. The drop sits
   // 225px out from the body, and he stops about 170px short of it when he
@@ -408,7 +440,7 @@ export const TONE = {
 
 // --- the depth experiment ---------------------------------------------------
 // ALL OFF BY DEFAULT. Nothing here is a feature yet; see the spec and the table
-// in FINDINGS.md. Toggled from the address bar, and X cycles them one at a time
+// in docs/FINDINGS.md. Toggled from the address bar, and X cycles them one at a time
 // because judging these by eye needs fast A/B and typing five URLs is not fast.
 export const DEPTH = {
   OCC: 1,          // near-layer density multiplier. 1 leaves it alone