eb6e8a3: The page in his hand

Published from cloudronin/astara@eb6e8a38ae57ea8cfc87ca5cfaa67c067ec17d87

index.html

@@ -57,20 +57,13 @@
   #pad .walkwheel { width:176px; height:176px; }
   #pad .walkwheel::before { inset:38px; }
 
-  /* MARK, AND IT IS ON THIS SIDE ON PURPOSE.
-     Filing a page needs PAGES held and TAKE pressed, and both of those live on
-     the left wheel — one thumb cannot hold one and press the other. The right
-     thumb is already over here turning pages with the arrows, so this is where
-     the third hand would have to be.
-
-     Twelve o'clock, the same slot TAKE has on the left, because they are the
-     same kind of thing: the verb that depends on where he is standing. It is
-     there only while there is something to file. */
-  #pad #markbtn {
-    opacity:0; pointer-events:none; transition:opacity .14s linear;
-    color:rgba(255,220,180,.9); border-color:rgba(255,220,180,.55);
-  }
-  #pad #markbtn.live { opacity:1; pointer-events:auto; }
+  /* MARK WAS HERE AND IS GONE. It existed because pinning a page needed PAGES
+     held and TAKE pressed, and both of those live on the left wheel — one thumb
+     cannot hold one and press the other, so the act needed a button under the
+     other thumb. The top page of the pile is now what he is holding and TAKE
+     acts on it wherever he is standing, so there is no hold, no second button,
+     and nothing for this side to do but walk. The workaround outlived its
+     problem by one build. */
   /* Six o'clock, holding the wheel's shape open until there is a fourth thing
      to do with the right thumb. Solid and small — a dashed circle reads as
      something broken rather than something reserved. */
@@ -188,7 +181,7 @@
   </div>
   <div class="cluster right">
     <div class="wheel walkwheel">
-      <button type="button" class="n" id="markbtn" data-act="pickup" aria-label="file this page under this house">MARK</button>
+      <button type="button" class="n empty" tabindex="-1" aria-hidden="true"></button>
       <button type="button" class="w arrow" data-act="left"  aria-label="walk left">&#9664;</button>
       <button type="button" class="e arrow" data-act="right" aria-label="walk right">&#9654;</button>
       <button type="button" class="s empty" tabindex="-1" aria-hidden="true"></button>

src/checks.js

@@ -1177,6 +1177,166 @@ export function createChecks({ renderer, scene, canvas, clips = {} }) {
     drive(0.15, extra);
   }
 
+  /**
+   * THE TOP PAGE IS WHAT IS IN HIS HAND, and it stays there when the pile
+   * goes away.
+   *
+   * The sheaf is for CHOOSING. Letting go of Q is putting the rest of the
+   * papers back in your coat, not putting down the one you picked.
+   */
+  function topPageIsTheHand() {
+    armed();
+    const held = () => s.handPage;
+
+    // Page to a fragment and let go.
+    s.sheaf.index = s.sheaf.pages.findIndex((p) => p.kind === 'fragment');
+    drive(0.6, { sheaf: true });
+    const upIsFragment = held()?.kind === 'fragment';
+    drive(0.6);                                   // Q released
+    const stillFragment = held()?.kind === 'fragment' && !s.sheaf.up;
+
+    // A letter is a different shape in the hand, and it can be on top too —
+    // but one has to be in the pile first, and armed() only takes fragments.
+    s.prince.x = s.prince.prevX = s.houses[2].x - 300;
+    s.prince.facing = 1;
+    s.camera.reset(s.prince.x);
+    drive(1.4, { torch: true });
+    drive(0.2, { pickup: true });
+    drive(0.15);
+    const li = s.sheaf.pages.findIndex((p) => p.kind === 'letter');
+    s.sheaf.index = li;
+    drive(0.6);
+    const letterOnTop = held()?.kind === 'letter';
+
+    // AND TAKING SOMETHING PUTS IT ON TOP, which is the whole tutorial: knock
+    // one down, take the scrap, walk to the door, press E. No Q anywhere.
+    const c = s.drained.find((d) => d.kept != null && !d.keptTaken)
+      ?? s.drained.find((d) => d.kept != null);
+    const before = s.sheaf.pages.length;
+    s.prince.x = s.prince.prevX = s.houses[0].x - 900;
+    s.camera.reset(s.prince.x);
+    s.sheaf.pages.push({ kind: 'fragment', kept: 3 });
+    s.sheaf.index = s.sheaf.pages.length - 1;
+    drive(0.3);
+    const takingPutsItOnTop = s.sheaf.pages.length === before + 1 &&
+      held()?.kept === 3;
+
+    // An empty pile is an empty hand.
+    s.sheaf.pages.length = 0;
+    s.sheaf.index = 0;
+    drive(0.3);
+    const emptyIsEmpty = held() == null;
+
+    return {
+      name: 'the top page is the hand',
+      pass: upIsFragment && stillFragment && letterOnTop &&
+            takingPutsItOnTop && emptyIsEmpty && c != null,
+      aFragmentSurvivesTheReleaseOfQ: stillFragment,
+      aLetterCanBeOnTopToo: letterOnTop,
+      takingPutsItOnTop, andNothingHeldWithAnEmptyPile: emptyIsEmpty,
+    };
+  }
+
+  /**
+   * WHAT `E` DOES AT A DOOR, every row of it, and Q makes no difference to any
+   * of them.
+   *
+   * One button, no modes. It is take-or-leave-the-thing-in-front-of-you, which
+   * is what E has meant everywhere else in this game since the first object on
+   * the ground.
+   */
+  function eAtTheDoor() {
+    const rows = [];
+    const put = (k) => {
+      s.sheaf.index = k === null
+        ? s.sheaf.pages.findIndex((p) => p.kind === 'letter')
+        : s.sheaf.pages.findIndex((p) => p.kind === 'fragment' && p.kept === k);
+    };
+    const stand = (i, withQ) => {
+      s.prince.x = s.prince.prevX = s.houses[i].x - 300;
+      s.prince.facing = 1;
+      s.camera.reset(s.prince.x);
+      drive(0.6, withQ ? { sheaf: true } : {});
+    };
+
+    for (const withQ of [false, true]) {
+      armed();
+      const extra = withQ ? { sheaf: true } : {};
+      const press = () => { drive(0.2, { ...extra, pickup: true }); drive(0.15, extra); };
+      // THE BAKEHOUSE, AND THE TWO FRAGMENTS ARE THE FORGE'S AND THE WELL
+      // HOUSE'S. Both are wrong here, on purpose.
+      //
+      // The first pass at this used fragment 1 as "a different fragment" at
+      // house 1 — which is the bakehouse's OWN fragment, so it was correct,
+      // its owner walked home, the patch settled, and every row after it
+      // measured the lock refusing rather than the thing it meant to measure.
+      // The check was wrong and the game was right.
+      const H = 1;
+      const A = 0, B = 2;
+      const h = s.houses[H];
+
+      // 1. A letter on the nail, anything on top -> takes the letter.
+      put(0); stand(H, withQ);
+      // the door has to have been looked at at least once for anything to be
+      // offered, which is the latch, not a mode
+      drive(1.4, { torch: true });
+      stand(H, withQ);
+      press();
+      const tookLetter = h.letterTaken && h.filed == null;
+
+      // 2. A bare patch, a fragment on top -> pins it.
+      put(A); stand(H, withQ); press();
+      const pinned = h.filed === A;
+
+      // 3. A fragment in the patch, a DIFFERENT fragment on top -> swap.
+      put(B); stand(H, withQ); press();
+      const swapped = h.filed === B;
+
+      // 4. A fragment in the patch, the SAME one on top -> takes it back.
+      put(B); stand(H, withQ); press();
+      const tookBackSame = h.filed == null;
+
+      // 5. A fragment in the patch, NOT a fragment on top -> takes it back.
+      put(A); stand(H, withQ); press();          // pin one again
+      put(null); stand(H, withQ); press();       // a letter on top
+      const tookBackWithLetter = h.filed == null;
+
+      // 6. A bare patch, not a fragment on top -> nothing.
+      put(null); stand(H, withQ);
+      const offeredWithLetter = s.canMark;
+      press();
+      const bareAndLetterDoesNothing = h.filed == null && !offeredWithLetter;
+
+      // 7. A settled patch -> nothing. The lock stands.
+      const F = 0;
+      const forge = s.houses[F];
+      put(0); stand(F, withQ);
+      drive(1.4, { torch: true });
+      stand(F, withQ); press();                  // letter off
+      put(0); stand(F, withQ); press();          // the forge's own, so it settles
+      const settled = forge.settled && forge.filed === 0;
+      put(B); stand(F, withQ); press();          // try to swap it
+      const lockHeld = forge.filed === 0 && settled;
+
+      rows.push({ withQ, tookLetter, pinned, swapped, tookBackSame,
+        tookBackWithLetter, bareAndLetterDoesNothing, lockHeld });
+    }
+    scene.reset();
+    const ok = rows.every((r) => Object.entries(r)
+      .every(([k, v]) => k === 'withQ' || v === true));
+    // AND Q CHANGES NOTHING. Every row, both ways, identical.
+    const sameEitherWay = JSON.stringify({ ...rows[0], withQ: 0 }) ===
+      JSON.stringify({ ...rows[1], withQ: 0 });
+
+    return {
+      name: 'E at the door',
+      pass: ok && sameEitherWay,
+      everyRowHolds: ok,
+      andTheSheafMakesNoDifference: sameEitherWay,
+      rows,
+    };
+  }
+
   function walksHome() {
     const carriers = armed();
     const owner = carriers.find((d) => d.kept === 0);      // the forge's
@@ -1607,16 +1767,39 @@ export function createChecks({ renderer, scene, canvas, clips = {} }) {
     mark();
     const needsADoor = filed().join(',') === before;
 
-    // 6. AND NOT WITH THE SHEAF DOWN, and not from the map page. Both would be
-    //    filing something he is not holding.
-    at(0);
-    drive(0.3, { pickup: true });                       // sheaf down
-    const needsTheSheaf = filed().join(',') === before;
+    // 6. AND IT DOES NOT NEED THE SHEAF UP. THIS CLAIM IS INVERTED.
+    //
+    //    It used to assert the opposite — that pinning with the sheaf down did
+    //    nothing — and that rule was played and it did not survive contact.
+    //    Three conditions and a mode: hold Q, page to the fragment, press E at
+    //    a door. Nobody does that with paper.
+    //
+    //    The top page of the pile is what he is holding, and E acts on what he
+    //    is holding. So the same press with the sheaf DOWN has to do the same
+    //    thing the press with it up did, and this asserts exactly that.
+    s.prince.x = s.prince.prevX = s.houses[0].x - 1500;
+    s.sheaf.index = fragA;
+    drive(0.4);                                         // sheaf down, walking about
+    const onTopWithItDown = s.page()?.kept === 2 && !s.sheaf.up;
+    s.prince.x = s.prince.prevX = s.houses[0].x - 300;
+    s.prince.facing = 1;
+    s.camera.reset(s.prince.x);
+    drive(0.5);                                         // NO sheaf, NO torch
+    const offeredWithItDown = s.canPin;
+    tap();                                              // plain E
+    const pinnedWithItDown = s.houses[0].filed === 2;
+    // And taking it back down is the same press again.
+    tap();
+    const takenBackWithItDown = s.houses[0].filed == null;
+    const noSheafNeeded = onTopWithItDown && offeredWithItDown &&
+      pinnedWithItDown && takenBackWithItDown;
+    // Put the world back where claim 7 expects it.
+    const before2 = filed().join(',');
     // A LETTER IS NOT A CLAIM. Only a torn page off a body can be filed — the
     // letter is what the house already says about itself.
     s.sheaf.index = s.sheaf.pages.findIndex((p) => p.kind === 'letter');
     at(0); mark();
-    const mapCannotBeFiled = s.sheaf.index < 0 || filed().join(',') === before;
+    const mapCannotBeFiled = s.sheaf.index < 0 || filed().join(',') === before2;
 
     // 7. NO FEEDBACK, EVER. Nothing in the state says right or wrong, and an
     //    empty plot is not flagged. Four filed and one empty is the finding,
@@ -1634,17 +1817,20 @@ export function createChecks({ renderer, scene, canvas, clips = {} }) {
 
     return {
       name: 'marking is a claim',
-      pass: nothingAutoFiles && needsTheLetterOff &&
+      pass: nothingAutoFiles && needsTheLetterOff && noSheafNeeded &&
             afterFirst[0] === 2 && afterReplace[0] === 3 &&
             afterMove[0] == null && afterMove[1] === 3 && onlyOnce &&
-            needsADoor && needsTheSheaf && mapCannotBeFiled && noVerdict &&
+            needsADoor && mapCannotBeFiled && noVerdict &&
             frozenAtTheGate,
       nothingFilesItself: nothingAutoFiles,
       andThereIsNoSlotUntilTheLetterIsOff: needsTheLetterOff,
       theSamePressTakesTheLetterInstead: tookTheLetterInstead,
       afterFirst, afterReplace, afterMove,
       oneFragmentOneHouse: onlyOnce,
-      needsALitDoor: needsADoor, needsTheSheafUp: needsTheSheaf,
+      needsALitDoor: needsADoor,
+      andDoesNotNeedTheSheafUp: noSheafNeeded,
+      withTheSheafDown: { onTop: onTopWithItDown, offered: offeredWithItDown,
+        pinned: pinnedWithItDown, takenBack: takenBackWithItDown },
       aLetterCannotBeFiled: mapCannotBeFiled,
       noRightOrWrongAnywhere: noVerdict,
       frozenAtTheGate,
@@ -1811,15 +1997,38 @@ export function createChecks({ renderer, scene, canvas, clips = {} }) {
       return frame();
     });
 
+    // 4. AND ON TOUCH THERE IS ONE CONTEXTUAL BUTTON, NOT TWO.
+    //
+    //    MARK lived on the right wheel because pinning a page needed PAGES
+    //    held and TAKE pressed and one thumb cannot do both. The top page is
+    //    now what he is holding and TAKE acts on it, so the second button is
+    //    deleted. Asserted rather than trusted, because a stray button in the
+    //    markup is invisible on a desktop and is the whole control scheme on
+    //    a phone.
+    const pad = document.getElementById('pad');
+    const acts = pad
+      ? [...pad.querySelectorAll('button[data-act]')].map((b) => b.dataset.act)
+      : [];
+    const touch = {
+      noMarkButton: !document.getElementById('markbtn'),
+      // Exactly one thing on the pad fires the contextual verb.
+      onePickupButton: acts.filter((a) => a === 'pickup').length === 1,
+      // And nothing is labelled with the verb that no longer exists.
+      nothingSaysMark: !pad || !/\bMARK\b/.test(pad.textContent),
+      acts,
+    };
+
     return {
       name: 'the keys are shown',
       pass: withoutTheReadout > 1500 && withTheReadout > 1500 &&
-            whileReading < withoutTheReadout * 0.25,
+            whileReading < withoutTheReadout * 0.25 &&
+            touch.noMarkButton && touch.onePickupButton && touch.nothingSaysMark,
       inkWithTheReadoutOff: withoutTheReadout,
       inkWithItOn: withTheReadout,
       inkWhileReadingALetter: whileReading,
       survivesDebugBeingOff: withoutTheReadout > 1500,
       getsOutOfTheWayOfAPage: whileReading < withoutTheReadout * 0.25,
+      andOneContextualButtonOnTouch: touch,
     };
   }
 
@@ -2022,6 +2231,7 @@ export function createChecks({ renderer, scene, canvas, clips = {} }) {
       doorsRead(), pagesCost(), sheafPages(), markingIsAClaim(),
       theRoomAsks(), aGlanceIsFree(), theLightGoesOut(), theKeysAreShown(), bandFits(),
       dealObeysRules(), swingerIsBait(),
+      topPageIsTheHand(), eAtTheDoor(),
       walksHome(), keyBehindTheDoor(), residueStaysLocked(),
       nothingOutOfReach(), healthCosts(), theGate()];
     return { pass: out.every((r) => r.pass), results: out };
@@ -2030,6 +2240,7 @@ export function createChecks({ renderer, scene, canvas, clips = {} }) {
   return { figureContrast, watcherContrast, brightMass, skyWeave,
     bowlLayout, bodiesPersist, wholeLevelWalkable, stillUntilLit, doorsRead,
     pagesCost, sheafPages, markingIsAClaim, theRoomAsks, aGlanceIsFree, theLightGoesOut, theKeysAreShown, bandFits, dealObeysRules, swingerIsBait,
+    topPageIsTheHand, eAtTheDoor,
     walksHome, keyBehindTheDoor, residueStaysLocked,
     nothingOutOfReach, healthCosts, theGate,
     all, frameAt, frameAtX };

src/input.js

@@ -158,31 +158,24 @@ export function createInput(target, { onReset } = {}) {
   }
 
   /**
-   * Lights TAKE only when there is something to do with it, and says which.
+   * Lights TAKE only when there is something to do with it.
    *
-   * It is one button doing two jobs — take the thing at his feet, or file the
-   * page in his hand under the door he is standing at. A phone has no readout
-   * worth reading, so the button itself has to carry the difference.
+   * ONE BUTTON, ONE SLOT, NO LABEL CHANGE. It used to be two: TAKE on the left
+   * wheel and a second MARK button over by the walk arrows, because pinning a
+   * page needed PAGES held and TAKE pressed and one thumb cannot do both.
+   *
+   * The top page of the pile is now what he is holding, so TAKE acts on it
+   * wherever he stands and the second button is deleted. Whether this press
+   * takes a letter, pins a page, takes one back down, takes a key or picks
+   * something off the ground is decided by where he is standing — which is
+   * what TAKE has meant everywhere else in this game since the first object.
    */
   const takeBtn = pad?.querySelector('.wheel [data-act="pickup"]');
-  // The second one, over by the walk arrows. Filing needs PAGES held and TAKE
-  // pressed and both of those are on the left wheel, which is one thumb's worth
-  // of buttons asking for two thumbs. This is the one the right thumb can reach
-  // without letting go of anything.
-  const markBtn = pad?.querySelector('#markbtn');
   let takeLive = false;
-  const setTakeAvailable = (yes, label = 'TAKE') => {
-    const marking = label === 'MARK';
-    if (markBtn) markBtn.classList.toggle('live', yes && marking);
-    if (!takeBtn) return;
-    // ONE OF THEM AT A TIME. The wheel's button never changes what it says —
-    // it is TAKE, and it goes dark while there is a MARK offered on the other
-    // side. A dim MARK here and a bright MARK there is two buttons asking to
-    // be pressed for one act.
-    const wheelLive = yes && !marking;
-    if (wheelLive === takeLive) return;
-    takeLive = wheelLive;
-    takeBtn.classList.toggle('live', wheelLive);
+  const setTakeAvailable = (yes) => {
+    if (!takeBtn || yes === takeLive) return;
+    takeLive = yes;
+    takeBtn.classList.toggle('live', yes);
   };
 
   target.addEventListener('pointerdown', onPointerDown);

src/main.js

@@ -109,7 +109,7 @@ const loop = createLoop({
       // decides. This used to re-run the ground scan itself, which was two
       // places that had to agree about what is within reach.
       input.setTakeAvailable?.(st.canMark || st.canTakeLetter || st.canTakeKey ||
-        st.canPlaceKey || st.canTake, st.canMark ? 'MARK' : 'TAKE');
+        st.canPlaceKey || st.canTake);
     }
   },
   render: (alpha) => {

src/render.js

@@ -365,6 +365,68 @@ export function createRenderer(ctx) {
    * No error state, no completion state, and an empty slot is never flagged.
    * The empty slot is the finding.
    */
+  /**
+   * THE PAGE IN HIS HAND, and it is the whole affordance.
+   *
+   * The top of the pile is what he is holding, and E at a door acts on it. A
+   * player who cannot see what they are holding has to raise the sheaf to find
+   * out, which is the mode this change exists to delete — so he holds it where
+   * you can see it, and the SHAPE says what E will do:
+   *
+   *   a torn page   a fragment. E at a bare patch pins it
+   *   a whole page  a letter. E at a patch takes back whatever is in it
+   *   nothing       nothing to pin
+   *
+   * BOTH PASSES, AND ALWAYS THE DARK ART. He is drawn as a silhouette even
+   * inside his own torchlight — a man cannot light himself — and a page in his
+   * hand is part of him. It reads for the same reason a carrier's fragment
+   * reads: the hand is at the edge of his outline, so the page breaks it.
+   *
+   * IT RIDES mapPivot, which is already measured on her standing drawing and
+   * is already the hand the sheaf is held in. Nothing new to place: when the
+   * sheaf goes up, the sheet covers this exact spot, which is why this hides.
+   *
+   * AND ONLY ON THE STANDING POSE. Her run frames carry no hand anchor, so he
+   * is empty-handed while moving and holding it the moment he stops — which is
+   * the moment it matters and the only moment E does anything.
+   */
+  function drawHeldPage(c, s, px, camX, face) {
+    if (s.sheaf?.up) return;
+    const pg = s.handPage;
+    if (!pg) return;
+    const pose = s.prince.clip;
+    if (!pose?.mapPivot) return;
+    const art = pg.kind === 'fragment' ? s.kept : pg.kind === 'letter' ? s.letterArt : null;
+    if (!art) return;
+    const idx = pg.kind === 'fragment' ? pg.kept : pg.house;
+    const frame = art.frames[idx];
+    if (!frame) return;
+
+    const ink = art.ink ?? { x: 0, y: 0, w: art.width, h: art.height };
+    // ONE SCALE FOR BOTH, AND THAT IS THE WHOLE DIFFERENCE BETWEEN THEM.
+    //
+    // Scaling each to the same height came out at 827 pixels of page for a
+    // fragment and 756 for a letter, differing by 139 — the tear, and nothing
+    // else. Which is measuring a 2.6px scribble at arm's length.
+    //
+    // The art already knows: the whole page's ink is 54 tall and a piece torn
+    // off it is 46. Fixing the scale to the page's own units keeps that, so a
+    // fragment is visibly the smaller thing. Divided by the LETTER's ink, so
+    // the full page is the one that comes out at the size that was chosen.
+    //
+    // Small either way. It is a page held down by the side, not one being read.
+    const k = 40 / ((s.letterArt?.ink?.h) || ink.h);
+    const w = ink.w * k;
+    const h = ink.h * k;
+    const ox = (pose.mapPivot[0] - pose.pivotX) * face;
+    const oy = pose.mapPivot[1] - pose.pivotY;
+    const sx = Math.round(px - camX + ox);
+    const sy = Math.round(GROUND_Y + oy);
+    const left = face >= 0 ? sx - w * 0.2 : sx - w * 0.8;
+    c.drawImage(frame.dark, left - ink.x * k, sy - h * 0.5 - ink.y * k,
+      art.width * k, art.height * k);
+  }
+
   function drawSheet(c, s, mode, px, camX, face) {
     const sheet = s.sheetClip;
     const pose = s.prince.clip;
@@ -993,6 +1055,7 @@ export function createRenderer(ctx) {
       drawKept(ctx, s.kept, d, 'dark', dx2, camX, s.clock);
     }
     drawClip(ctx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y + limpDip, camX, face, s.prince.eyeDim);
+    drawHeldPage(ctx, s, px, camX, face);
     drawSheet(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);
@@ -1040,6 +1103,7 @@ export function createRenderer(ctx) {
           drawKept(octx, s.kept, d, 'lit', dx2, camX, s.clock);
         }
         drawClip(octx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y + limpDip, camX, face, s.prince.eyeDim);
+        drawHeldPage(octx, s, px, 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.
         drawSheet(octx, s, 'lit', px, camX, face);
@@ -1178,11 +1242,12 @@ export function createRenderer(ctx) {
           (s.prince.inventory.length
             ? s.prince.inventory.map((it) => (it.seen ? it.answers : '?')).join(', ')
             : '—') +
-          (s.canMark ? '   [E] MARK'
-            : s.canTakeLetter ? '   [E] take the letter'
-              : s.canPlaceKey ? `   [E] put a key in  (${s.prince.keys} in hand)`
-                : s.canTakeKey ? '   [E] take the key'
-                  : nearKept ? '   [E] take' : '') +
+          (s.canPin ? '   [E] PIN IT HERE'
+            : s.canMark ? '   [E] take it back down'
+              : s.canTakeLetter ? '   [E] take the letter'
+                : s.canPlaceKey ? `   [E] put a key in  (${s.prince.keys} in hand)`
+                  : s.canTakeKey ? '   [E] take the key'
+                    : nearKept ? '   [E] take' : '') +
           // ONLY WHEN IT IS NOT WORKING. Spelled out because a phone has no
           // console and no backtick key — "running / playback" and still silent
           // on an iPhone means the ringer switch, not the game. Once it is

src/scene_level.js

@@ -1049,12 +1049,15 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     // Lighting one is the only thing that says who lived here. It latches, the
     // same way seeing an object on the ground latches, and for the same reason:
     // he looked, and looking is not something he can un-do.
-    let lit = null;
+    // IT LATCHES AND NOTHING READS IT THIS FRAME ANY MORE. There used to be a
+    // `lit` house here, meaning "the torch is on this door right now", and it
+    // was what marking tested. Marking now tests a LATCH plus a distance, the
+    // same deal the letter and the key already had — so all this loop does is
+    // remember that he looked.
     let litLetter = null;
     for (const h of HOUSES) {
       const [dx, dy] = doorPoint(h);
       if (!torch.covers(dx, dy)) continue;
-      lit = h;
       h.seen = true;
       // And the letter on its wall. Same latch as an object on the ground: he
       // looked, and looking is not something he can un-do.
@@ -1163,7 +1166,38 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     const wantsPickup = pickupHeld && !prevPickup;
     prevPickup = pickupHeld;
     input.pickup = false;
-    const markingPage = sheaf.up && torch.raise > 0.9 ? page() : null;
+    // --- what is in his hand ------------------------------------------------
+    //
+    // THE TOP PAGE OF THE PILE IS WHAT HE IS HOLDING, and the pile does not
+    // have to be up for him to be holding it.
+    //
+    // It used to. Pinning a fragment meant holding Q, paging to it, and
+    // pressing E at a door — three conditions and a mode, and it was played and
+    // nobody did it. Nobody does that with paper either: you take the page you
+    // want, put the rest away, walk over, and pin it.
+    //
+    // So the sheaf is for CHOOSING and E is for DOING, and E never asks about
+    // the sheaf. Q still raises the torch, still stops him, still shows the
+    // band and pages with the arrows. It has just stopped being a prerequisite.
+    const handPage = page();
+    state.handPage = handPage;
+
+    // THE DOOR HE IS AT, AND IT IS LATCHED RATHER THAN LIT.
+    //
+    // `lit` above is whether the torch is ON a door this frame, and that was
+    // the marking test — which worked only because holding the sheaf forced the
+    // torch up. With the sheaf out of it, the torch is down and `lit` is null,
+    // so the old test could never fire again.
+    //
+    // The letter and the key already solved this: seeing latches, and taking is
+    // a separate act that only needs him to still be standing there. The patch
+    // is the third thing on that wall and it gets the same deal.
+    let nearDoor = null;
+    for (const h of HOUSES) {
+      if (!h.seen) continue;
+      const p = letterPoint(h);
+      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) { nearDoor = h; break; }
+    }
     // AND NOT BEFORE THE LETTER IS OFF THE NAIL.
     //
     // There is one spot beside each door and the letter is on it. Take the
@@ -1179,40 +1213,60 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     //
     // AND NOT AT A DOOR THAT IS FINISHED WITH. Someone walked home to it; the
     // patch has the only thing it was ever going to hold.
-    const canMark = !gate.through && !!lit && !lit.settled && lit.letterTaken &&
-      markingPage?.kind === 'fragment' && pageSeen(markingPage);
-    state.canMark = canMark;
+    //
+    // AND NOT AT A DOOR THAT IS FINISHED WITH. Someone walked home to it; the
+    // patch has the only thing it was ever going to hold.
+    const patchTakes = !!nearDoor && !gate.through && !nearDoor.settled &&
+      nearDoor.letterTaken;
+    const holding = handPage?.kind === 'fragment' ? handPage.kept : null;
+
+    // PIN, or TAKE BACK, and which one is decided by what is already there.
+    //
+    // THE SAME PAGE THAT IS ALREADY PINNED TAKES IT BACK. The table this comes
+    // from does not have a row for it — it has "a different fragment evicts and
+    // pins" and "not a fragment takes it back" — and holding the page that is
+    // already on the wall is neither. Evicting it and pinning it again is a
+    // press that does nothing, so it is the other one: he is holding the thing
+    // in front of him, and E takes it down.
+    const canRetrieve = patchTakes && nearDoor.filed != null &&
+      (holding === null || holding === nearDoor.filed);
+    const canPin = patchTakes && holding !== null && holding !== nearDoor.filed;
+    const canMark = canPin || canRetrieve;
+
+    // LETTER FIRST, THEN THE PATCH, THEN THE KEY. An unread door hands over the
+    // reading before it will accept a claim about it, and the thing that opens
+    // a gate comes last. Evidence before conclusions before rewards, which is
+    // the order this whole game is arguing for.
+    state.canTakeLetter = !!litLetter;
+    state.canMark = !litLetter && canMark;
+    state.canPin = !litLetter && canPin;
     // WHICH house it would go under. The sheet draws that house's plot beside
-    // the page when this is set, so the paper itself says "this one, here" —
-    // which is the only thing in the build that tells a player marking exists.
-    state.markHouse = canMark ? lit.index : null;
-    state.canTakeLetter = !canMark && !!litLetter;
-    // LETTER FIRST, THEN KEY. At an open door with the letter still on the
-    // wall both are offered by the same button, so they queue: press once for
-    // the reading, again for the key. Evidence before the thing that opens a
-    // gate, which is the order this whole game is arguing for.
-    state.canTakeKey = !canMark && !litLetter && !!litKey;
+    // the page when this is set, so the paper itself says "this one, here".
+    state.markHouse = state.canPin ? nearDoor.index : null;
+    state.canTakeKey = !litLetter && !canMark && !!litKey;
     // AND PUTTING ONE IN. He stops 380px short of the leaf and can never get
     // closer, so the reach is the door's, not the ground's.
     state.canPlaceKey = !canMark && prince.keys > 0 && !gate.through &&
       gate.placed < TUNING.GATE_WANTS &&
       Math.abs(prince.x - GATE_X) <= TUNING.DOOR_REACH;
-    if (wantsPickup && canMark) {
-      if (lit.filed === markingPage.kept) {
-        // TAKE IT BACK OUT. He is standing at the door holding the page that
-        // is already in the frame, so the only thing left to do with it is
-        // change his mind. It never left the sheaf — the frame holds a claim,
-        // not the paper — so there is nothing to give back.
-        lit.filed = null;
+    if (wantsPickup && state.canMark && !prince.attacking) {
+      if (canRetrieve) {
+        // TAKE IT BACK DOWN. Either he is holding the page that is already
+        // pinned here, or he is holding nothing that could go in — and in both
+        // cases the only thing on that wall he can act on is what is on it.
+        //
+        // It never left the sheaf. The patch holds a CLAIM, not the paper, so
+        // there is nothing to hand back.
+        nearDoor.filed = null;
         audio?.mark?.();
       } else {
-        // MOVE, THEN REPLACE. Filing a fragment somewhere else takes it off
-        // wherever it was, and filing a different one here pushes the old one
-        // out. Two fragments can never sit under one house and one fragment can
-        // never sit under two, and neither rule needs a message: it is what
+        // MOVE, THEN REPLACE. Pinning a fragment somewhere else takes it off
+        // wherever it was, and pinning a different one here pushes the old one
+        // out. Two fragments can never sit in one patch and one fragment can
+        // never sit in two, and neither rule needs a message: it is what
         // putting a piece of paper down on a table already does.
-        for (const h of HOUSES) if (h.filed === markingPage.kept) h.filed = null;
-        lit.filed = markingPage.kept;
+        for (const h of HOUSES) if (h.filed === holding) h.filed = null;
+        nearDoor.filed = holding;
         audio?.mark?.();
 
         // AND IF IT WAS THEIRS, THEY GO HOME.
@@ -1222,11 +1276,11 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
         // there is nowhere for it to drift to.
         //
         // NOTHING IS SAID. No tick, no sound of being right, no change to the
-        // frame. Somewhere out in the village a body gets up, and the only way
+        // patch. Somewhere out in the village a body gets up, and the only way
         // to find out is that it walks up the street.
-        if (lit.index === markingPage.kept) {
-          const owner = drained.find((d) => d.kept === markingPage.kept && d.keptTaken);
-          if (owner) { lit.settled = true; owner.sendHome(lit.x); }
+        if (nearDoor.index === holding) {
+          const owner = drained.find((d) => d.kept === holding && d.keptTaken);
+          if (owner) { nearDoor.settled = true; owner.sendHome(nearDoor.x); }
         }
       }
     }
@@ -1252,7 +1306,7 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     // fragment, and this needs a letter still lying in a lit room. Ahead of the
     // object at his feet because he is looking into the room, and because the
     // clear pocket round every door keeps drops out of this spot anyway.
-    if (wantsPickup && !canMark && litLetter && !prince.attacking) {
+    if (wantsPickup && state.canTakeLetter && !prince.attacking) {
       litLetter.letterTaken = true;
       filePage({ kind: 'letter', house: litLetter.index });
       audio?.mark?.();
@@ -1270,7 +1324,7 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       litKey.keyTaken = true;
       prince.keys++;
       audio?.mark?.();
-    } else if (wantsPickup && !canMark && nearest && !prince.attacking) {
+    } else if (wantsPickup && !state.canMark && nearest && !prince.attacking) {
       nearest.keptTaken = true;
       run.taken++;
       prince.inventory.push({