268252f: Wrong doors wake the owner, and a note on the tree says the rule

manifest.json

@@ -315,6 +315,16 @@
         "_letter": "What he was told, in the only voice this game has: palace paper. It may name the errand, the road and the levy, because a palace order would name the levy and nobody will know what that means until village one shows them. It may not say a word about her, about the drained, or about what the levy is. THE SEAL IS THE TITLE CARD -- Astara, once, on the paper, and nowhere else in the game. The newline is load-bearing: wrap() splits on it first, so the seal keeps its own line the way every signature does. 140 characters, against 67 to 149 across the other nine strings.",
         "fragment": null,
         "_fragment": "None, and there never will be. Nobody in this village was holding the Crown's order."
+      },
+      {
+        "house": "the tree",
+        "origin": "tree",
+        "_origin": "NOT A HOUSE, like the palace. The scene finds it by this field, and drawLetterHouse draws a tree at the foot of its page.",
+        "_points": "AT THE RULE, AND NEVER AT AN ANSWER. It says the drained cannot speak, that some carry something, and that it goes home. Not which ones, not which home, and nothing about him or who wrote it. A rebel's hand, read in the torchlight like everything else.",
+        "letter": "They cannot speak.\nWhat they carried is all that is left of them.\nIf you find it, take it home.",
+        "_letter": "Three lines, and read on the road, so it is page two after his orders: the palace's instruction and the rebels', which contradict each other. Nothing has to say so.",
+        "fragment": null,
+        "_fragment": "None. It is not anybody's."
       }
     ]
   },
@@ -1049,6 +1059,51 @@
       ],
       "silhouette": "auto"
     },
+    "road_tree": {
+      "_what": "THE TREE WITH THE NOTE ON IT. On the road, at his own scale, two-thirds of the way to the village: after the first drained, before the first house. A rebel nailed the rule to it. Placeholder, generated by tools/gen_placeholders.js.",
+      "path": "assets/tree/",
+      "file": "lit_{nn}.svg",
+      "frames": 1,
+      "fps": 1,
+      "native": [
+        420,
+        1180
+      ],
+      "pivot": [
+        210,
+        1180
+      ],
+      "nailAt": [
+        [
+          185,
+          984,
+          56,
+          76
+        ]
+      ],
+      "_nailAt": "On the trunk wherever the trunk went, at a house nail's height above the ground, so the torch finds it from where a player already stands to read a door. The generator prints it.",
+      "silhouette": "auto"
+    },
+    "origin_tree": {
+      "_what": "WHERE THE NOTE CAME FROM, drawn at the foot of its page the way the order's page carries the palace. A lone tree.",
+      "path": "assets/origin_tree/",
+      "file": "lit_{nn}.svg",
+      "frames": 1,
+      "fps": 1,
+      "native": [
+        960,
+        900
+      ],
+      "pivot": [
+        480,
+        900
+      ],
+      "_pivot": "Same canvas and pivot as houses, so drawLetterHouse scales it with the same k.",
+      "bleedEdges": [
+        "bottom"
+      ],
+      "silhouette": "auto"
+    },
     "kept": {
       "_note": "FIVE TORN PAGES, AND THEY ARE ALL THE SAME SHAPE. A tool silhouette carries one bit and one bit only supports matching; a line of text carries a relationship, which is what inference needs. So what differs between the five is the scribble, which sits inside the contour and which the silhouette pass discards. A player who could tell them apart by their tear would have the answer without reading a word.",
       "path": "assets/kept/",
@@ -1070,7 +1125,7 @@
       "_note": "FIVE WHOLE PAGES, and they are the same shape as each other for exactly the reason the torn ones are. Same contour as `kept` with the tear replaced by a straight edge and the same scribble seed, so a fragment reads as a piece off one of these. The sheet carries the shape and the band carries the words; neither does the other's job, and no player ever identifies a house by the outline of its paper.",
       "path": "assets/letter/",
       "file": "lit_{nn}.svg",
-      "frames": 6,
+      "frames": 7,
       "fps": 1,
       "variants": true,
       "native": [
@@ -1082,7 +1137,7 @@
         48
       ],
       "silhouette": "auto",
-      "_frames": "Five village papers and one palace one. The sixth is the order, and it is cleaner and squarer than the others because the palace does not write on scraps."
+      "_frames": "Five village papers, one palace one and one scrap. The sixth is the order, cleaner and squarer because the palace does not write on scraps. The seventh is the note off the tree, torn and in a hand that is not the village's. Every frame stays inside the same ink box: the box is the union of all of them, and one that reached further would shrink every letter on every nail and every page."
     },
     "key": {
       "_note": "ONE KEY, AND EVERY HOUSE HAS THE SAME ONE. Every household in a walled village holds a key to the gate; that is how village gates work. It is not evidence: it never enters the sheaf, it cannot be read, and there is nothing at all to work out about it. All the deduction in this level is in the paper. Visible from the moment a door is lit and not takeable until somebody comes home and opens it — you can see it the whole time and not have it.",

src/audio.js

@@ -450,7 +450,8 @@ export function createAudio() {
      * what a swing looks like; the clip's name is the whole contract, so a new
      * loop is a new entry here and nothing else.
      */
-    drainedVoice: (kind, v = AUDIO.DRAINED_VOICE) => {
+    drainedVoice: (kind, level = 1, pan = 0) => {
+      const v = AUDIO.DRAINED_VOICE * level;
       const pick = { loop_swing: ['drainedSwing', drainedSwing],
         loop_haul: ['drainedHaul', drainedHaul],
         loop_bear: ['drainedBear', drainedBear],
@@ -462,7 +463,7 @@ export function createAudio() {
       // The recording if it has decoded, the generated one if it has not --
       // the same fallback the boots and the thunder have, and for the same
       // reason: a recording cannot be fetched before the first gesture.
-      if (!playSlice(pick[0], v)) pick[1](c, master, c.currentTime, noise, v);
+      if (!playSlice(pick[0], v, pan)) pick[1](c, master, c.currentTime, noise, v);
     },
     /**
      * A key off its hook. Its own sound, because it is its own act.
@@ -514,11 +515,11 @@ export function createAudio() {
       }
       burst(c, out, c.currentTime, noise, { freq: 650, q: 0.9, gain: v * 0.5, attack: 0.3, decay: 0.3, sweepTo: 1500 });
     },
-    drainedWake: (v = AUDIO.WAKE) => {
+    drainedWake: (level = 1, pan = 0) => {
       if (!enabled) return;
       const c = ensure();
       if (!c || c.state !== 'running') return;
-      playSlice('wake', v);
+      playSlice('wake', AUDIO.WAKE * level, pan);
     },
     /** The village, under everything. 0..1, set every frame by the scene. */
     villageBed: (level) => setLoop('villageBed', level * AUDIO.VILLAGE),

src/checks.js

@@ -1583,17 +1583,31 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     const carriers = armed();
     const owner = carriers.find((d) => d.kept === 0);      // the forge's
 
-    // 1. THE WRONG FRAME DOES NOTHING. The page is on the wall, right or
-    //    wrong, and the body stays exactly where it fell.
+    // 1. THE WRONG FRAME WAKES THEM. This was "the wrong frame does nothing",
+    //    and that is exactly what made the walk home an answer key: pin, see
+    //    who walks, try the next door, never read a word. Now a stranger's
+    //    house wakes the owner and it comes for him. The page stays on the
+    //    wall, and nothing opens or settles.
     atDoor(1, 0);
     tap({ sheaf: true });
-    drive(3);
+    const seen = [owner.state];
+    for (let i = 0; i < 60 * 3; i++) {
+      scene.update(1 / 60, NONE);
+      if (seen[seen.length - 1] !== owner.state) seen.push(owner.state);
+    }
     const wrong = {
       onTheWall: s.houses[1].filed === 0,
-      bodyStaysDown: owner.state === 'DOWNED',
+      rose: seen.includes('RISING'),
+      cameForHim: owner.state === 'RUSH' && !owner.homing,
+      states: seen.join(' > '),
       nothingOpened: s.houses.every((h) => !h.open),
       nothingSettled: s.houses.every((h) => !h.settled),
     };
+    // Put it back down before it reaches him. What follows is about the walk
+    // home, not a fight; wrongDoorWakes owns the fight.
+    owner.hits = 99;
+    owner.takeHit(owner.x - 1);
+    drive(1.0);
 
     // 2. AND IT COMES BACK OUT. Brute force is allowed: four fragments, five
     //    frames, and nothing stops a player working through them.
@@ -1605,7 +1619,11 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     };
 
     // 3. THE RIGHT FRAME AND HE GETS UP. Nothing is said, here or anywhere.
+    //    From wherever it went down last — which, after step 1, is not where
+    //    it spawned.
     atDoor(0, 0);
+    const from = owner.x;
+    const pinnedAt = s.clock;
     tap({ sheaf: true });
     const filed = {
       onTheWall: s.houses[0].filed === 0,
@@ -1625,12 +1643,15 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     // 5. IT ARRIVES, AND ONLY ITS OWN DOOR OPENS.
     let ticks = 0;
     while (owner.state !== 'HOME' && ticks < 60 * 200) { scene.update(1 / 60, NONE); ticks++; }
-    const walked = Math.abs(s.houses[0].x - owner.spawnX);
+    const walked = Math.abs(s.houses[0].x - from);
     const arrived = {
       home: owner.state === 'HOME',
       atTheDoor: Math.round(owner.x) === s.houses[0].x,
       doorsOpen: s.houses.filter((h) => h.open).length,
-      seconds: +(ticks / 60).toFixed(1),
+      // From the pin, not from here: steps 4's second and a half is part of
+      // the walk, and counting from after it hid behind the old error in
+      // where the walk started.
+      seconds: +(s.clock - pinnedAt).toFixed(1),
       px: Math.round(walked),
       // Derived from HOME_SPEED rather than written down, plus the rise.
       expected: +(walked / TUNING.HOME_SPEED + TUNING.RISE_MS / 1000).toFixed(1),
@@ -1645,7 +1666,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
 
     return {
       name: 'walks home',
-      pass: wrong.onTheWall && wrong.bodyStaysDown && wrong.nothingOpened &&
+      pass: wrong.onTheWall && wrong.rose && wrong.cameForHim && wrong.nothingOpened &&
             wrong.nothingSettled &&
             pulledBack.frameEmpty && pulledBack.stillInTheSheaf &&
             filed.onTheWall && filed.settled && filed.gotUp &&
@@ -1654,7 +1675,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
             arrived.home && arrived.atTheDoor && arrived.doorsOpen === 1 &&
             Math.abs(arrived.seconds - arrived.expected) < 1.5 &&
             frozen.ignoredTheSword && frozen.didNotMove && frozen.stillHome,
-      theWrongFrameDoesNothing: wrong,
+      theWrongFrameWakesThem: wrong,
       andItComesBackOut: pulledBack,
       theRightFrameSendsThemHome: filed,
       andThenTheFrameIsFinishedWith: settled,
@@ -2043,9 +2064,12 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     at(0); mark();
     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,
-    //    and it has to look exactly like four filed and one not done yet.
+    // 7. NO VERDICT, EVER. The world answers every filing now — a person
+    //    walking home, or a person coming for you — and that is all it does.
+    //    Nothing in the state says right or wrong: no tick, no score, no
+    //    `correct` or `wrong` field anywhere. An empty plot is not flagged.
+    //    Four filed and one empty is the finding, and it has to look exactly
+    //    like four filed and one not done yet.
     const noVerdict = !('correct' in s.houses[0]) && !('wrong' in s.houses[0]) &&
       s.houses.every((h) => h.filed == null || typeof h.filed === 'number');
 
@@ -2456,10 +2480,10 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     const highest = rows.length ? Math.min(...rows.map((r) => r.phoneTop)) : 0;
     return {
       name: 'band fits',
-      // TEN, EXACTLY. Nine village strings and his orders. An exact equality
-      // rather than a floor, so adding a string and not looking at it fails
-      // here rather than on somebody's phone.
-      pass: rows.length === 10 && worst <= BAND.MAX_LINES && highest >= BAND.TOP_FLOOR,
+      // ELEVEN, EXACTLY. Nine village strings, his orders, and the note on the
+      // tree. An exact equality rather than a floor, so adding a string and not
+      // looking at it fails here rather than on somebody's phone.
+      pass: rows.length === 11 && worst <= BAND.MAX_LINES && highest >= BAND.TOP_FLOOR,
       strings: rows.length, longest: worst, allowed: BAND.MAX_LINES,
       // How far up the scene the tallest band climbs on the narrowest display,
       // and how far up it is allowed to. Bigger number is lower on screen.
@@ -2620,6 +2644,241 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     };
   }
 
+  // --- wrong doors ----------------------------------------------------------------
+  //
+  // Played through, the level was finished without reading a word: pin a page,
+  // see who walks, try the next door. The walk home was an answer key. So a
+  // stranger's house now wakes the owner, and it comes for him — guessing is
+  // still allowed, and it costs blood. See docs/specs/astara-wrong-door-addendum.md.
+
+  /** States a body passes through over the next few seconds, in order. */
+  const statesOver = (d, secs) => {
+    const seen = [d.state];
+    for (let i = 0; i < Math.round(secs * 60); i++) {
+      scene.update(1 / 60, NONE);
+      if (seen[seen.length - 1] !== d.state) seen.push(d.state);
+    }
+    return seen;
+  };
+  /** Put a body down on the spot. The fixture armed() already uses. */
+  const putDown = (d) => { d.hits = 99; d.takeHit(d.x - 1); drive(1.0); };
+
+  /**
+   * A WRONG DOOR WAKES THEM.
+   *
+   * Every carrier, the gatekeeper included: pinned on a door that is not
+   * theirs, the owner rises and comes — RISING, then RUSH, never homing — and
+   * the page stays on the wrong wall. Knocked down, it can be woken again by
+   * the next wrong pin, as often as he makes one. Pinned right, it goes home.
+   *
+   * AND THE BEAT THE RULES MAKE WITHOUT ANYONE DESIGNING IT. `sendHome` from
+   * RUSH goes straight to HOMING, so the way to stop someone coming for you is
+   * to put their words where they belong. A woken body chasing him from beyond
+   * its own door: he pins it right, and it walks up to its door, stops short of
+   * him, turns its back and never touches him. Asserted, because it falls out
+   * of two methods sitting side by side and nothing else protects it.
+   */
+  function wrongDoorWakes() {
+    const rows = [];
+    for (const c of armed()) {
+      const k = c.kept;
+      // A door that is not theirs AND not finished with. A door filed right is
+      // locked, and the rows before this one have filed theirs right.
+      const w = s.houses.map((_, i) => (k + 1 + i) % s.houses.length)
+        .find((i) => i !== k && !s.houses[i].settled);
+      atDoor(w, k);
+      tap({ sheaf: true });
+      const first = statesOver(c, 2.5);
+      const woke = first.includes('RISING') && c.state === 'RUSH' && !c.homing && c.revealed;
+      const leftUp = s.houses[w].filed === k;
+      putDown(c);
+      const downed = c.state === 'DOWNED';
+      const stillUp = s.houses[w].filed === k;
+      atDoor(w, k);
+      tap({ sheaf: true });                              // take it back down...
+      const retrieved = s.houses[w].filed == null;
+      atDoor(w, k);
+      tap({ sheaf: true });                              // ...and pin it wrong again
+      const again = statesOver(c, 2.5);
+      const wokeAgain = again.includes('RISING') && c.state === 'RUSH' && !c.homing;
+      putDown(c);
+      atDoor(w, k);
+      tap({ sheaf: true });                              // off the wrong wall
+      atDoor(k, k);
+      tap({ sheaf: true });                              // onto its own
+      const home = c.homing && (c.state === 'RISING' || c.state === 'HOMING') &&
+        c.homeX === s.houses[k].x;
+      rows.push({ kept: k, wrongDoor: w, woke, pageStaysUp: leftUp && stillUp, downed,
+        retrieved, wokeAgain, goesHomeWhenRight: home, states: first.join(' > ') });
+    }
+
+    // The beat. A carrier that fell beyond its own door, from where he pins,
+    // and a wrong door on his side of it — so it chases him past nothing, and
+    // its own door is between them when he puts the page up.
+    const beat = (() => {
+      for (const seed of [7, 11, 23, 41, 97, 131]) {
+        for (const c of armed(seed).filter((d) => !d.post)) {
+          const k = c.kept;
+          const door = s.houses[k].x;
+          if (!(c.x > door + 300)) continue;
+          const w = s.houses.findIndex((h, i) => i !== k && h.x < door - 300);
+          if (w < 0) continue;
+          atDoor(w, k);
+          tap({ sheaf: true });                          // wrong: it wakes
+          atDoor(w, k);
+          tap({ sheaf: true });                          // straight back down
+          // He goes to its door and waits; it comes for him, still beyond it.
+          s.prince.x = s.prince.prevX = door - 300;
+          s.prince.facing = 1;
+          s.camera.reset(s.prince.x);
+          let t = 0;
+          while (!(c.state === 'RUSH' && c.x - s.prince.x < W / 2) && t < 60 * 60) {
+            scene.update(1 / 60, NONE);
+            t++;
+          }
+          const closing = c.state === 'RUSH' && c.x - s.prince.x < W / 2 && c.x > door;
+          const cameAtHim = c.facing === -1;
+          const hits0 = s.prince.hits;
+          atDoor(k, k);
+          tap({ sheaf: true });                          // right: it stops coming
+          const stopped = c.state === 'HOMING' && c.homing && c.homeX === door;
+          let u = 0, hurt = false, nearest = Infinity;
+          while (c.state !== 'HOME' && u < 60 * 60) {
+            scene.update(1 / 60, NONE);
+            u++;
+            if (s.prince.hits > hits0) hurt = true;
+            nearest = Math.min(nearest, Math.abs(c.x - s.prince.x));
+          }
+          return {
+            seed, kept: k, secondsToClose: +(t / 60).toFixed(1), closing, cameAtHim, stopped,
+            atItsDoor: c.state === 'HOME' && Math.round(c.x) === door,
+            turnedItsBack: c.facing === Math.sign(c.x - s.prince.x),
+            neverTouchedHim: !hurt, closestItCame: Math.round(nearest),
+          };
+        }
+      }
+      return null;
+    })();
+    scene.reset();
+    return {
+      name: 'a wrong door wakes them',
+      pass: rows.length === 4 &&
+            rows.every((r) => r.woke && r.pageStaysUp && r.downed && r.retrieved &&
+              r.wokeAgain && r.goesHomeWhenRight) &&
+            !!beat && beat.closing && beat.cameAtHim && beat.stopped && beat.atItsDoor &&
+            beat.turnedItsBack && beat.neverTouchedHim,
+      rows, theBeat: beat,
+    };
+  }
+
+  /**
+   * THE GATEKEEPER WAKES AT HIS POST.
+   *
+   * He is the first page most players pin, and pinned wrong he comes for them
+   * with the spear — the hardest fight in the level, and the first time a
+   * player learns that where things go matters. But he does not leave the
+   * gate: pinned from the far end of the village he wakes and waits there,
+   * and at the gate he braces, thrusts and shoves, exactly as before.
+   */
+  function gatekeeperWakesAtHisPost() {
+    armed();
+    const gk = gatekeeper();
+    const post = gk.x;
+    atDoor(0, gk.kept);                                  // the forge: the far end
+    tap({ sheaf: true });
+    const seen = statesOver(gk, 3);
+    const woke = seen.includes('RISING') && gk.state === 'RUSH' && gk.revealed && !gk.homing;
+    const stayedWhileHeWasAway = gk.x === post;
+    s.prince.x = s.prince.prevX = s.gateStopX;
+    s.prince.facing = 1;
+    s.camera.reset(s.prince.x);
+    const hits0 = s.prince.hits;
+    const phases = new Set();
+    let shoved = false, moved = false;
+    for (let i = 0; i < 60 * 4; i++) {
+      const before = s.prince.x;
+      scene.update(1 / 60, NONE);
+      phases.add(gk.phase);
+      if (s.prince.x < before - 60) shoved = true;
+      if (gk.x !== post) moved = true;
+    }
+    const hitsTaken = s.prince.hits - hits0;
+    scene.reset();
+    return {
+      name: 'the gatekeeper wakes at his post',
+      pass: woke && stayedWhileHeWasAway && !moved && phases.size >= 3 && shoved,
+      woke, states: seen.join(' > '), stayedWhileHeWasAway, movedAtTheGate: moved,
+      phasesSeen: [...phases].sort(), shovedHim: shoved, hitsItCostHim: hitsTaken,
+    };
+  }
+
+  /**
+   * THE TREE TEACHES THE RULE, AND NOTHING ELSE.
+   *
+   * A note nailed to a tree on the road: they cannot speak, what they carried
+   * is all that is left of them, take it home. It stands past the first
+   * drained, so "they" has somebody to mean, and before the village, so it is
+   * read before the first fight — and far enough from every drained that
+   * lighting it wakes nobody.
+   *
+   * Light it and the band reads it. Take it and it is page two, the rebels'
+   * instruction after the palace's, carrying a tree at its foot. The nail it
+   * leaves is bare and asks for nothing: holding a page there, nothing is
+   * offered. A restart puts the note back.
+   */
+  function theTreeTeaches() {
+    scene.reset();
+    const t = s.tree;
+    if (!t) return { name: 'the tree teaches', pass: false, why: 'there is no tree' };
+    const note = s.letters.byHouse[t.index]?.letter ?? null;
+    const road = s.drained.filter((d) => !s.village.includes(d));
+    const first = Math.min(...road.map((d) => d.x));
+    const clearOfAll = Math.min(...road.map((d) => Math.abs(d.x - t.x)));
+    const placed = t.x > first + TUNING.TREE_CLEAR && t.x < BOWL.X0 &&
+      clearOfAll >= TUNING.TREE_CLEAR;
+
+    // Up to it in the dark: nothing read yet.
+    s.prince.x = s.prince.prevX = t.x - 300;
+    s.prince.facing = 1;
+    s.camera.reset(s.prince.x);
+    drive(0.5);
+    const unreadInTheDark = !t.letterSeen && s.band?.text !== note;
+
+    // Lit: the band reads it, and nobody wakes.
+    drive(1.4, { torch: true });
+    const reads = t.letterSeen && s.band?.text === note && s.canTakeLetter;
+    const nobodyWoke = s.drained.every((d) => !d.revealed);
+
+    // Taken: page two, the tree's, after his orders.
+    const before = s.sheaf.pages.length;
+    tap();
+    const p = s.sheaf.pages[1];
+    const pageTwo = before === 1 && s.sheaf.pages.length === 2 && p?.kind === 'letter' &&
+      p.house === t.index && s.textFor(p) === note && s.sheaf.pages[0].house !== t.index;
+    const origin = s.letters.byHouse[p?.house]?.origin;
+    const bare = t.letterTaken && !s.canTakeLetter;
+
+    // Nothing goes back on it: holding a page there, nothing is offered.
+    s.prince.inventory.push({ kept: 0, answers: null, seen: true });
+    s.sheaf.pages.push({ kind: 'fragment', kept: 0 });
+    s.sheaf.index = s.sheaf.pages.length - 1;
+    drive(0.5, { torch: true });
+    drive(0.3);
+    const nothingGoesBack = !s.canPin && !s.canMark && !s.canTakeLetter;
+
+    scene.reset();
+    const backOnItsNail = !t.letterTaken && !t.letterSeen;
+    return {
+      name: 'the tree teaches',
+      pass: !!note && placed && unreadInTheDark && reads && nobodyWoke && pageTwo &&
+            origin === 'tree' && bare && nothingGoesBack && backOnItsNail,
+      at: t.x, pastTheFirstDrained: t.x - first, clearOfEveryDrained: clearOfAll,
+      clearFloor: TUNING.TREE_CLEAR, beforeTheVillage: t.x < BOWL.X0,
+      unreadInTheDark, readsUnderTheTorch: reads, nobodyWoke,
+      pageTwo, originOnThePage: origin, bareNailAfter: bare, nothingGoesBack, backOnItsNail,
+    };
+  }
+
   // --- the two lanes ------------------------------------------------------------
   //
   // Every player who saw a Drained on his road fought it: no side scroller lets
@@ -3014,7 +3273,8 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       nothingOutOfReach(), healthCosts(), theGate(),
       orderIsPageOne(), openingHolds(),
       nobodyBlocksTheRoad(), gatekeeperIsOnTheRoad(), stepDownTelegraphs(),
-      watchesYouPass(), laneReads(), theGlanceStillWorks()];
+      watchesYouPass(), laneReads(), theGlanceStillWorks(),
+      wrongDoorWakes(), gatekeeperWakesAtHisPost(), theTreeTeaches()];
     return { pass: out.every((r) => r.pass), results: out };
   }
 
@@ -3048,6 +3308,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     orderIsPageOne, openingHolds,
     nobodyBlocksTheRoad, gatekeeperIsOnTheRoad, stepDownTelegraphs,
     watchesYouPass, laneReads, theGlanceStillWorks,
+    wrongDoorWakes, gatekeeperWakesAtHisPost, theTreeTeaches,
     all, frameAt, frameAtX };
 
   return Object.fromEntries(Object.entries(api).map(([k, fn]) => [k, silent(fn)]));

src/drained.js

@@ -16,6 +16,8 @@
 //   STAGGER  knocked back, cannot act.
 //   DOWNED   lies where it fell. Cannot be revealed. Cannot rush.
 //   RISING   getting up. Can be knocked back down, for ever.
+//            A body woken by a WRONG pin rises into RUSH too, and comes for him
+//            from wherever it fell — off screen included. See wake().
 //   HOMING   walking back to its own door, because somebody gave it its name.
 //            Harmless, never hurries, and the only thing in this game that
 //            goes somewhere on purpose.
@@ -223,6 +225,11 @@ export function createDrained(clips, spawnX0, dir, keptIndex = 0, opts = {}) {
     // rush, and it is the one flag in here that the player's own act sets.
     homing: false,
     homeX: null,
+    // WOKEN BY A WRONG PIN. Someone put its last words on a stranger's house,
+    // and it is coming for him — from wherever it fell, so this is also what
+    // keeps it out of the distance cull and moving while he cannot see it.
+    // Cleared the moment it goes down again or is sent home.
+    woken: false,
   };
 
   /**
@@ -294,6 +301,8 @@ export function createDrained(clips, spawnX0, dir, keptIndex = 0, opts = {}) {
     // moves it, so a state that is not these two is simply on the road.
     d.lane = (next === WANDER || next === STEP_DOWN) && !post ? 1 : 0;
     if (next !== WANDER) d.watching = false;
+    // Only rising, rushing and reeling are part of coming for him.
+    if (next !== RISING && next !== RUSH && next !== STAGGER) d.woken = false;
     players[next].reset();
     applyPose();
   }
@@ -336,6 +345,7 @@ export function createDrained(clips, spawnX0, dir, keptIndex = 0, opts = {}) {
     d.knockVel = 0;
     d.homing = false;
     d.homeX = null;
+    d.woken = false;
     d.watching = false;
     d.stir = 0;
     // THE GATEKEEPER'S CYCLE, and it was surviving a reset.
@@ -368,9 +378,37 @@ export function createDrained(clips, spawnX0, dir, keptIndex = 0, opts = {}) {
     if (d.state === HOMING || d.state === HOME) return;
     d.homeX = x;
     d.homing = true;
+    d.woken = false;
     enter(d.state === DOWNED ? RISING : HOMING);
   };
 
+  /**
+   * Somebody put this one's words on the WRONG wall, so it gets up and comes
+   * for him. The same rise as going home; RISING already forks on `homing`,
+   * so this is that flag held false and the rise started.
+   *
+   * A NORMAL REVEALED DRAINED from here: RUSH, three hits to put down. It is
+   * already on the road where it fell, so there is no step down. `revealed`
+   * is set because the gatekeeper — and anything downed without a look — was
+   * never revealed, and the guard pose and the fight count read that flag.
+   *
+   * Returns whether it actually woke. One already up is left as it is: it is
+   * coming anyway. One going home, or home, was filed right and is finished.
+   */
+  d.wake = () => {
+    if (d.state === HOMING || d.state === HOME) return false;
+    d.homing = false;
+    d.homeX = null;
+    d.revealed = true;
+    if (d.state === DOWNED) {
+      enter(RISING);
+      d.woken = true;
+      return true;
+    }
+    if (d.state === RISING) { d.woken = true; return true; }
+    return false;
+  };
+
   /** A connected sword hit. Returns true if it did anything at all. */
   d.takeHit = (fromX) => {
     // Hitting a DOWNED one does nothing. No knockback, no reaction, no counter.
@@ -553,7 +591,10 @@ export function createDrained(clips, spawnX0, dir, keptIndex = 0, opts = {}) {
       case RUSH: {
         const toward = Math.sign(ctx.princeX - d.x) || -1;
         d.facing = toward;
-        if (!ctx.inFrame) break;
+        // Off screen it waits — unless a wrong pin woke it, in which case it is
+        // coming for him and does not need to see him to do it. The gatekeeper
+        // waits either way: he is angry at the gate, not chasing anyone.
+        if (!ctx.inFrame && (!d.woken || postClip)) break;
         if (postClip) {
           // HE DOES NOT CLOSE THE DISTANCE. Sixty years after anyone relieved
           // him, he is still keeping people away from a gate — so he stands

src/render.js

@@ -260,6 +260,37 @@ export function createRenderer(ctx) {
     }
   }
 
+  /**
+   * The tree with the note on it. On the road at his own scale, so it draws
+   * with the houses: black in the dark pass, its bark in the lit one.
+   *
+   * THE NOTE, BOTH WAYS. In the dark the scrap shows pale — paper catching
+   * what light there is, so a lone tree says "something is pinned here" the
+   * way a house's lit doorway does. Under the torch it is the letter on its
+   * nail, drawn by drawNail like every other; once taken, a bare nail and a
+   * paler patch, and — `quiet` — nothing asking to be filled.
+   */
+  function drawTree(c, s, camX, mode) {
+    const t = s.tree;
+    const clip = s.treeClip;
+    if (!t || !clip) return;
+    const sx = Math.round(t.x - camX);
+    if (sx < -clip.width || sx > W + clip.width) return;
+    const x = sx - clip.pivotX;
+    const y = GROUND_Y - clip.pivotY;
+    c.drawImage(clip.frames[0][mode === 'lit' ? 'lit' : 'dark'], x, y);
+    if (mode === 'lit') {
+      drawNail(c, s, clip, t, x, y, s.clock ?? 0, true);
+    } else if (!t.letterTaken && s.treeNoteDark) {
+      const art = s.letterArt;
+      const b = nailBox(clip, t, x, y, art);
+      if (b) {
+        c.drawImage(s.treeNoteDark, b.px - b.ink.x * b.k, b.py - b.ink.y * b.k,
+          art.width * b.k, art.height * b.k);
+      }
+    }
+  }
+
   /**
    * One Drained, in whichever lane it is standing in.
    *
@@ -924,11 +955,13 @@ export function createRenderer(ctx) {
   function drawLetterHouse(c, s, sheet, x0, y0, pg) {
     if (!pg || pg.kind !== 'letter') return;
     const house = s.houses?.[pg.house];
-    // WHERE IT CAME FROM. Five of the six letters come from a house in this
-    // village and show it. The sixth came from the palace, which is not a
-    // building here and has no entry in `houses` -- so no house means the
-    // palace, and that fallback IS the rule rather than a guard around one.
-    const hc = house ? s.houseClip : s.palaceClip;
+    // WHERE IT CAME FROM. Five of the letters come from a house in this village
+    // and show it. The order came from the palace and the note from a tree on
+    // the road, and neither has an entry in `houses` — so their own `origin`
+    // says which, and no house and no origin still means the palace.
+    const origin = house ? null : s.letters?.byHouse?.[pg.house]?.origin;
+    const hc = house ? s.houseClip
+      : origin === 'tree' ? (s.treeIconClip ?? s.palaceClip) : s.palaceClip;
     if (!hc) return;
     const frame = house ? house.variant : 0;
     const bx = x0 + sheet.width / 2;
@@ -1147,7 +1180,7 @@ export function createRenderer(ctx) {
    * LIT PASS ONLY, so all three live and die with the torch like everything
    * else in a doorway.
    */
-  function drawNail(c, s, clip, house, x, y, clock) {
+  function drawNail(c, s, clip, house, x, y, clock, quiet = false) {
     if (!clip.nailAt) return;
 
     // 1. THE LETTER, while it is still hanging there.
@@ -1193,7 +1226,10 @@ export function createRenderer(ctx) {
     // question, which is the same reason four empty sockets on the gate have
     // never needed explaining — and it is why the loom house goes on asking
     // for the whole level, with nobody left to answer it.
-    if (house.filed == null) {
+    //
+    // NOT ON THE TREE (`quiet`). Nothing ever goes back on it, so its empty
+    // patch must not ask for anything: a bare nail and a paler mark, no more.
+    if (house.filed == null && !quiet) {
       const pulse = 1 - TORCH.KEPT_PULSE_DEPTH *
         (0.5 - 0.5 * Math.cos(clock * Math.PI * 2 * TORCH.KEPT_PULSE_HZ));
       const cx = px0 + nw / 2;
@@ -1255,7 +1291,7 @@ export function createRenderer(ctx) {
     // AND IT IS NOT A VERDICT. It appears for the wrong page just as readily,
     // because it is a preview of an act and not an opinion about it.
     if (house.filed == null) {
-      if (!s.canPin || s.markHouse !== house.index) return;
+      if (quiet || !s.canPin || s.markHouse !== house.index) return;
       const held = s.handPage;
       const ghostArt = held?.kind === 'fragment' ? s.kept : null;
       const gf = ghostArt?.frames[held.kept];
@@ -1606,6 +1642,7 @@ export function createRenderer(ctx) {
     drawGround(ctx, s.ground, 'dark', 0, W, camX);
     drawBolt(ctx, s);
     drawVillage(ctx, s, camX, 'dark');
+    drawTree(ctx, s, camX, 'dark');
     drawFlash(ctx, s.flash ?? 0);
     drawAllDrained(ctx, s, 'dark', camX, alpha);
     drawClip(ctx, s.prince.clip, s.prince.frame, 'dark', px, GROUND_Y + limpDip, camX, face, s.prince.eyeDim);
@@ -1648,6 +1685,7 @@ export function createRenderer(ctx) {
         // And here the doors open. This is the one thing in the level the
         // torch reveals that is not a person.
         drawVillage(octx, s, camX, 'lit');
+        drawTree(octx, s, camX, 'lit');
         // He is never lit by his own torch, so he goes in with his DARK art —
         // the same trick the far layers use.
         // The Drained are the thing the torch is for.

src/scene_level.js

@@ -151,6 +151,9 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
   // sky behind the action. A silhouette only shows up against light, so this is
   // the one thing Blade Warrior does that costs nothing — the fight belongs
   // under the bright patch. See background.skyOpenAt for what "open" counts.
+  // THE TREE GOES DOWN FIRST, the way the doors do, and the three road drained
+  // go in what is left. See TREE_CLEAR.
+  const TREE_X = Math.round(TUNING.LEVEL_LENGTH_PX * TUNING.TREE_AT);
   {
     const L = TUNING.LEVEL_LENGTH_PX;
     const n = TUNING.ROAD_ENCOUNTERS;
@@ -169,6 +172,8 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
         // is 680 across — so one raise woke both, on the stretch that is
         // supposed to be teaching him what raising it costs.
         if (drained.some((o) => Math.abs(o.x - cand) < TORCH.RADIUS * 2)) continue;
+        // And never within the torch's reach of the note on the tree.
+        if (Math.abs(cand - TREE_X) < TUNING.TREE_CLEAR) continue;
         // Gentle pull to the middle of the window so ties do not drift to an end.
         const score = background.skyOpenAt(cand, W) - Math.abs(cand - centre) * 0.6;
         if (score > best) { best = score; bestX = Math.round(cand); }
@@ -386,6 +391,33 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
   const socketArt = clips.key
     ? (await tintFrames(clips.key, PALETTE.WATCHERS, 'dark'))[0] : null;
 
+  // --- the tree on the road ------------------------------------------------
+  // A rebel nailed the rule to it: they cannot speak, what they carried is all
+  // that is left of them, take it home. Never an answer — not which ones, not
+  // which home. It is a letter like the houses' in every way the code cares
+  // about: light it, read it in the band, take it, and it is a page. It just
+  // is not a door, so nothing is ever pinned back to it.
+  const treeClip = clips.road_tree ?? null;
+  const TREE_NOTE = letters?.byHouse?.findIndex((h) => h.origin === 'tree') ?? -1;
+  const TREE = treeClip && TREE_NOTE >= 0
+    ? { kind: 'tree', x: TREE_X, index: TREE_NOTE, variant: 0,
+      seen: false, letterSeen: false, letterTaken: false, filed: null }
+    : null;
+  /** The middle of the nail on the tree, as a world point. Off the clip's pixels. */
+  const treePoint = () => {
+    const r = treeClip?.nailAt?.[0];
+    if (!TREE || !r) return null;
+    return [TREE.x - treeClip.pivotX + r[0] + r[2] / 2,
+      GROUND_Y - treeClip.pivotY + r[1] + r[3] / 2];
+  };
+  // PALE IN THE DARK. A house letter has a lit doorway beside it to draw the
+  // eye; a note on a lone tree has nothing, and would be walked past. So the
+  // scrap shows as paper catching what light there is — enough to say
+  // "something is pinned here", never enough to read. Above the no-mud floor.
+  const NOTE_IN_THE_DARK = '#9a9484';     // lum 148
+  const treeNoteDark = TREE && clips.letter
+    ? (await tintFrames(clips.letter, NOTE_IN_THE_DARK, 'dark'))[TREE_NOTE] ?? null : null;
+
   // --- the twelve --------------------------------------------------------
   // Twelve shapes you can swing at, against the background watchers you cannot.
   // Two populations doing different jobs: the watchers make it feel like a
@@ -880,6 +912,7 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     seed: SEED,
     houses: HOUSES, houseTint: PALETTE.WATCHERS,
     houseClip, palaceClip, houseArt, doorPoint, keyPoint, letterPoint,
+    tree: TREE, treeClip, treeIconClip: clips.origin_tree ?? null, treeNoteDark, treePoint,
     village, gateX: GATE_X, gateStopX: GATE_STOP_X,
     villageGap: VILLAGE_GAP, bowlX0: BOWL.X0,
     flame: { clip: clips.fire, player: createPlayer(clips.fire), frame: 0 },
@@ -912,6 +945,7 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       h.letterSeen = false; h.letterTaken = false;
       h.open = false; h.settled = false; h.keyTaken = false;
     }
+    if (TREE) { TREE.seen = false; TREE.letterSeen = false; TREE.letterTaken = false; }
     prevPickup = false;
     prince.attacking = false;
     prince.attackTime = 0;
@@ -1132,7 +1166,10 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       // — filing correctly from the far side of the village put a body on its
       // knees for ever. The flag covers the whole journey; it is cleared when
       // the door opens, and the cull takes over again.
-      if (!d.homing && Math.abs(d.x - prince.x) > W * 1.4) continue;
+      //
+      // AND ONE WOKEN BY A WRONG PIN, for the same reason: it is on its way to
+      // him, and a body skipped here would sit in the street half risen.
+      if (!d.homing && !d.woken && Math.abs(d.x - prince.x) > W * 1.4) continue;
       // On screen together? The camera follows the prince, so this is the same
       // question as "can it see him".
       const sx = d.x - camera.x;
@@ -1185,8 +1222,19 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       // They are BODY sounds and never tool sounds, and audio.js says at
       // length why: a hammer-on-anvil clang would send every player to the
       // swinging shape, and the forge's fragment is deliberately on a hauler.
-      if (ctx.inFrame && d.frame !== wasFrame &&
-          d.clip?.soundFrames?.includes(d.frame)) audio?.drainedVoice?.(d.clip.name);
+      //
+      // AND ONE COMING FOR HIM IS HEARD COMING. Woken by a wrong pin it rushes
+      // from wherever it fell, so its breathing plays off screen too: faint far
+      // off, louder as it closes, on the side it is on. The walk home's drag
+      // does the same, off the same numbers.
+      if (d.frame !== wasFrame && d.clip?.soundFrames?.includes(d.frame) &&
+          (ctx.inFrame || (d.woken && d.state === RUSH))) {
+        const off = d.x - prince.x;
+        const near = Math.max(0, 1 - Math.max(0, Math.abs(off) - W / 2) / Math.max(1, AUDIO.HOME_FOOT_REACH));
+        audio?.drainedVoice?.(d.clip.name,
+          ctx.inFrame ? 1 : AUDIO.HOME_FOOT_FAR + (1 - AUDIO.HOME_FOOT_FAR) * near,
+          Math.max(-0.85, Math.min(0.85, off / 1400)));
+      }
       // THE INSTANT IT NOTICES HIM. `revealed` latches and never unlatches, so
       // this fires once per shape per run — about twelve times, and every one
       // of them is a fight he chose by deciding to see.
@@ -1300,6 +1348,11 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
         h.letterSeen = true;
       }
     }
+    // THE NOTE ON THE TREE. No door to light first: the paper is all there is.
+    if (TREE && !TREE.letterTaken) {
+      const p = treePoint();
+      if (p && torch.covers(p[0], p[1])) { TREE.seen = true; TREE.letterSeen = true; }
+    }
 
     // TAKING IT DOES NOT NEED THE TORCH STILL UP. Seeing latches; taking is a
     // separate act, exactly as it is for a page on the ground, which he can
@@ -1314,6 +1367,12 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       const p = letterPoint(h);
       if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) { litLetter = h; break; }
     }
+    // And the tree's, on the same terms. From here the band and E do not know
+    // the difference: it reads as a letter and files as one, with its own page.
+    if (!litLetter && TREE && !TREE.letterTaken && TREE.letterSeen) {
+      const p = treePoint();
+      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) litLetter = TREE;
+    }
 
     // AND THE KEY, WHICH NEEDS THE DOOR OPEN AND NOT THE TORCH UP.
     //
@@ -1525,6 +1584,24 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
             flash.ms = 0;
             flash.thundered = false;
           }
+        } else {
+          // AND IF IT WAS NOT, THEY OBJECT. Played through, the level was
+          // finished without reading a word: pin, see who walks, try the next
+          // door. The walk home confirmed every guess instantly and for free,
+          // which made it an answer key. Now a stranger's house wakes the
+          // owner, and it comes for him. Guessing is still allowed; it costs.
+          //
+          // The page stays on the wrong wall. Putting it down does not take it
+          // back — he does that, with E, as always.
+          const owner = drained.find((d) => d.kept === holding && d.keptTaken);
+          if (owner && owner.wake()) {
+            // HEARD AT FULL STRENGTH, WHEREVER IT IS. On the side it is on, but
+            // never quieter for being far: a faint gasp from across the village
+            // and a rush thirty seconds later are two things nobody connects.
+            // The breathing as it comes can fall away with distance. The
+            // moment it wakes cannot.
+            audio?.drainedWake?.(1, Math.max(-0.85, Math.min(0.85, (owner.x - prince.x) / 1400)));
+          }
         }
       }
     }

src/tuning.js

@@ -533,6 +533,15 @@ export const TUNING = {
   // they land every 0.9 of a screen, which is the same crowding the village
   // was failing on, in the place that is supposed to be the quiet part.
   ROAD_ENCOUNTERS: 3,
+  // THE TREE WITH THE NOTE ON IT, as a share of the road. Two-thirds: past
+  // the first drained, so "they" has somebody to mean, and before the first
+  // house, so it is read before the first fight.
+  TREE_AT: 0.66,
+  // AND NOBODY STANDS NEAR IT. Placed first, the way the doors are, and every
+  // road drained kept this far off. Not a guess: he reads it from about 300px
+  // away, and the torch lights a figure up to 339 ahead of him and 214 behind —
+  // so lighting the note can never wake anybody, from either side.
+  TREE_CLEAR: 700,
 
   // THE VILLAGE. The road ends and the bowl begins. This replaces the ending
   // that used to be here — thirty-four watchers stepping onto the path until he