Cognition, Parties, and Escape Rooms

This post has three parts: eight self-tests measure the senses’ factory settings, the party table shows what can be delegated to a machine and what must stay human, and four escape-room and puzzle widgets take apart lock-key wiring, hint tiers, and pacing budgets. The three parts share one question: what does a system deliver to you, and what does it hide? The perceptual system delivers a processed summary, party games run on the information gap between people, and an escape room hands over a dependency graph on demand. Every chapter can be verified hands-on in the site’s widgets.

Eight Self-Checks on the Senses’ Factory Settings

The perceptual system never reports raw data; it only delivers a processed summary: color is a ratio among three kinds of cone cells, loudness is a logarithmic ruler, and the center of the visual field holds a hole where every sensor is missing — and you have never noticed. Every stage of that summarizing system has a quantifiable property, and the apparatus for measuring it is simpler than you would think: one color plate, one pure tone, one flash, one metronome will do.

Hands-on versions: Color Vision Test, Hearing Test, Visual Field Test, Recognition Test, Stroop Test, Keypad Trainer, Bimanual Coordination Test, Rhythm Test.

Genetics on a Color Plate

The principle of the color vision test can be stated in one sentence: disguise everything with luminance noise, and leave hue as the only clue.

The site’s Color Vision Test draws a circular plate some three hundred pixels across on a canvas: first about fourteen hundred background dots are scattered, all sampled from one base hue plus a random jitter; then the stroke positions of a hidden digit are covered with a layer of dots whose hue is offset by a fixed angle.

A normal observer pulls the digit out of the background by the hue difference, while someone with a red-green deficiency is insensitive to that hue gap, and the digit dissolves back into the background.

The most interesting design element in this apparatus is the difficulty knob.

In the source the three difficulty levels differ by a single number: the hue offset between the digit layer and the background layer (the gap) is 120°, 52°, and 22° respectively. In hard mode the two layers differ by only about twenty degrees, already close to the color discrimination limit of a typical red-green deficient observer.

Each layer also gets its own luminance jitter. Background dots draw brightness from one range, digit dots from another range that almost overlaps it.

That jitter is the soul of the Ishihara plate. If the two layers had identical luminance, an observer could fall back on “which side is brighter” to solve the puzzle; once luminance is randomised, the luminance cue drowns in noise and hue becomes the only usable clue.

A real diagnostic plate also controls the lightness and saturation distributions of its colors; a web version cannot be that strict, but the skeleton — luminance noise plus an adjustable hue gap — is the same.

Why does color deficiency strike red and green in particular? The answer is written in genetics.

Among the three human opsin genes, the blue-sensitive $S$ gene sits on chromosome 7, while the red-sensitive (L-opsin) and green-sensitive (M-opsin) genes sit side by side in the q28 region of the X chromosome.

The two sequences are highly homologous; they are themselves the product of a gene duplication tens of millions of years ago.

Homologous sequences lined up together are prone to unequal crossing over, and the result is either the loss of one gene or a “hybrid” gene whose absorption peak lands at a wrong position between red and green.

That is why red-green color blindness is the most common and blue-yellow the rarest, and also why men are far likelier to be hit than women: a man has only one X chromosome, so one bad gene shows up; a woman has two spares, and the population rate of red-green deficiency runs about 8% for men against 0.5% for women.

One detail of the scoring logic: the test screens, it does not classify. Six plates, a pool of twelve candidate digits, one point per correct plate — it can tell you “there is probably a gap on your red-green axis”, but not whether it is the missing type or the anomalous type; that takes a color vision tester measuring the full spectral response curve.

Binary Search for Hearing

The most basic question in psychophysics is: how faint a light, how quiet a sound, before you stop noticing it? That critical value is called the threshold.

The classic method for measuring a threshold is the method of limits. Sound steps down from loud to quiet, and the level at which you raise your hand and say you cannot hear it is the threshold.

But the site’s Hearing Test uses a cleverer scheme: binary search.

The apparatus has a fixed three-stage flow: 250 Hz, 1000 Hz, and 4000 Hz, tested one after another.

At each frequency a 0.5-second sine tone plays at full volume, and you have two buttons: “heard it” and “did not hear it”. Heard halves the volume; not heard jumps to the midpoint between the current level and the previous one.

What the source maintains is exactly binary search’s two pointers, lo and hi: every answer halves the interval, and after six steps the midpoint becomes that frequency’s threshold.

Since the volume parameter is a linear gain from 0 to 1, reporting converts it to decibels: $20\lg(g)$ . Full volume is 0 dB, halving the gain is $-6$ dB, so everything in the results table is negative.

The more negative the number, the more the sound had to be squashed before you could just hear it — that is, the more sensitive that ear is in that band.

“Threshold” carries a statistical meaning: it sounds like a wall, audible on this side and inaudible on the other. But real data form a gentle S-shaped psychometric function.

As sound intensity climbs from zero, the probability of reporting “heard it” creeps from 0 to 1, with no cliff in between.

The so-called threshold is merely the abscissa where that curve reaches a detection rate of 50% (or 75%). Reading the midpoint after six binary-search steps as “your hearing boundary” actually reads “between full volume and this point, detections and misses break even”.

Why is binary search legitimate here? It requires the response “heard → decrease the stimulus, not heard → increase it” to be monotone, and a psychometric function satisfies exactly that. If the response curve is not monotone (fatigue making you mash buttons later on), the search converges to a wrong equilibrium.

Every measurement that leans on the subject’s self-report carries that risk. Medicine calls measurements where “the signal depends on the reporter” subjective audiometry, and ones that bypass self-report, such as brainstem evoked potentials, objective audiometry. Same ear, two numbers.

Why these three frequencies? Start with the construction of the cochlea.

The cochlea is a coiled spiral tube, and inside it the basilar membrane is like the strings of a piano: narrow and taut at the base, resonating only to high frequencies; wide and slack at the apex, handling the low end. About fifteen thousand hair cells per ear line up along the membrane into a single frequency axis.

The whole cochlea is a spectrum analyzer; position is frequency.

The bad news is that wear along this axis is uneven. Hair cells do not regenerate, and those in the high-frequency region carry the heaviest workload and the most fragile metabolism, so age-related hearing loss almost always collapses from the high end first.

Occupational health textbooks even have a dedicated term for it: the “4k notch” (noise notch). On the audiogram of chronic noise exposure, an isolated dip appears around 4000 Hz first.

The test puts three probes at 250, 1000, and 4000 Hz, which happen to cover both ends: the “speech backbone (250–1000 Hz contributes most to intelligibility)” and the “high-frequency outpost (4000 Hz)”. Fine at 1000 Hz but needing noticeably more volume at 4000 Hz is the typical profile of early high-frequency loss.

Decibels themselves deserve a pause.

The sound pressure a human ear can perceive spans twelve orders of magnitude, and a linear scale is unreadable. Since the auditory system’s subjective sense of intensity is roughly proportional to the logarithm, acoustics speaks uniformly in $20\lg(p/p_0)$ .

That also explains why the binary search above halves the gain (a linear domain) yet lands as even steps in decibels (a logarithmic one): each narrowing of the interval moves the reported threshold by only about 3 dB.

In psychophysical measurement, “take the logarithm of the physical quantity, search in the physical quantity” is a common pattern. Six binary steps give a precision of $1/64$ , which in decibels already exceeds what most laptop speakers can resolve.

Visual Field and Flashes

The Hole You Never Noticed

The retina is not a complete photosensitive plate. Where the optic nerve gathers and exits the eyeball there are no photoreceptors at all; the region is called the optic disc, and on the visual field it maps to a blind spot about five to seven degrees wide, some fifteen degrees outside the fovea.

It never appears in your subjective field of view because the brain fills it in from the surrounding texture. Rather than expose a hole to consciousness, it fabricates on the spot.

Most people never notice it in a lifetime; it only shows itself when you fixate on a particular spot and let a target land exactly in the hole. The target does not vanish — it merely becomes “impossible to say what color or shape it is”.

The Visual Field Test reproduces exactly this question: where in your field of view can you actually see. A red dot flashes at a random position inside a circular field for 600 ms and disappears; you click where you just saw it, and a click within 28 pixels of the true position counts as a hit.

After twelve trials a green heat map overlays the canvas. It bins hit density in polar coordinates: eight angular sectors times four concentric radius rings, thirty-two cells in total.

The polar binning is deliberate. Retinal receptor density falls off only with eccentricity (angular distance from the fovea) and is roughly symmetric in angle, so “visual field ability” is naturally a radial variable; only radius-ring statistics can reveal the gradient of “the further out, the less accurate”. A square grid would merely churn that symmetric radial gradient into noise.

One more detail in the source: the dot’s eccentricity is constrained to between 25% and 100% of the field radius. The innermost 25% is excluded because foveal resolution is dozens of times that of the periphery; dropping the dot in the fovea is a free point that measures no meaningful spatial distribution.

The 600 ms flash window is not arbitrary either.

A voluntary saccade — moving fixation from one point to another — takes about 150–200 ms from decision to landing. If the dot stayed put, you could quite legitimately “take a look”, and the test would become an eye-tracking game rather than a visual field measurement.

600 ms is far shorter than the whole chain of “spot the target — launch a saccade — refixate — report”, forcing your peripheral vision to answer alone within a single fixation, which is precisely the logic of perimetry.

Iconic Memory, Half a Second Long

The extreme version of flashing is the Recognition Test: a letter stays on screen for only 450 ms, then disappears and you pick it from four options, eight rounds in a row, with each round’s reaction time recorded to the millisecond.

The paradigm is a direct homage to one of psychology’s most famous memory experiments. Sperling’s partial report experiment of 1960: flash twelve letters for 50 ms and ask for a report — a full report yields only four or five; but if a high, middle, or low tone sounds after the flash to cue “report only this row”, the subject can report nearly that entire row.

The conclusion: for an instant after the flash, visual information exists at high fidelity in a huge buffer, iconic memory. But it decays extremely fast, nearly to zero within half a second, and only about four items are actually caught by consciousness and passed into working memory.

The site’s four-choice design sits right at that capacity. Four options is few enough to leave working memory a way out; 450 ms is longer than the tail of iconic memory but shorter than a leisurely scan, so what is measured is the ability to “catch that one glance”.

The choice of letter pool also has engineering thought in it. The twenty-four candidate letters exclude I, O, 0, and 1, the high-confusion characters. Characters with overlapping features would drift the source of errors from “memory capacity” to “feature discrimination”; with two kinds of failure mixed together, the data become uninterpretable.

That is the old rule of psychophysical experiment design: let only one variable go wrong at a time.

When Word Meaning Fights Ink Color

The Stroop Test interface is a single card. One large character in the middle of the screen: the character meaning “red” may be inked green, the one meaning “blue” may be inked red. Your task is not to read it, but to click its ink color.

Four color buttons (red, green, blue, yellow), twenty rounds, 2.5 seconds each, with a timeout counted as wrong. Accuracy refreshes live beside the score.

What actually carries information is not the accuracy but your felt sense of reaction time afterwards: incongruent trials (word meaning conflicting with ink color) are noticeably slower than congruent ones.

Published back in 1935, the effect is one of the most robust findings in cognitive psychology, and its explanation centers on an asymmetry in how automatic the two processes are.

For a proficient reader, reading a word is automatic processing: the glyph sits there and the meaning pops out on its own, without your deciding to read. Naming an ink color, by contrast, must be executed deliberately, step by step.

When the two conflict, the product of automatic processing (the meaning “red”) is not discarded; it keeps flooding the response channel, and the executive system must first spend resources pushing it down. That suppression time is the interference.

Conversely, if the task is “read the word”, the ink color barely affects you, because the weak pathway of color naming cannot squeeze into the strong pathway’s lane.

The asymmetry is one-directional, which is far deeper than the surface description “conflict slows you down”: automaticity is a one-way valve; strong processing interferes with weak processing, and almost never the reverse.

The Stroop effect has a language-related corollary: for bilinguals, interference from native-language words is markedly larger than from foreign-language words, because the degree of automaticity depends on exposure to that language.

Invert that and it becomes an implicit language proficiency test. To check which language someone is more “native” in, skip the vocabulary test: lay out a pile of incongruent color words and measure reaction time.

Restricting the color words to red, green, blue, and yellow is not laziness either. These four are high-frequency, single-character, unambiguous — standard material for squeezing language differences to a minimum and isolating the conflict mechanism.

One Mind, Two Tasks

The question “how much efficiency do you lose typing while chatting” has a standard laboratory paradigm: dual tasking.

The site turns it into two widgets, one measuring serial processing, one parallel.

Keypad Trainer looks like a typing drill. The target is a random string of four to six digits, typed on the on-screen keypad, with time and wrong keys recorded, and the resulting score converted into “digits per minute”.

But read as a cognitive task, it measures the raw speed of the visual-motor conversion channel. A digit string must go through the three-stage pipeline “identify → locate on the keypad → press”, one digit at a time, and the positions of the ten keys 0 to 9 are the only free variable in that pipeline.

For the proficient, nearly all of the improvement comes from the “locate” stage turning from retrieval into reflex.

That stage has a ready-made quantitative model: Fitts’s law. The time to move a pointer to a target of width $W$ at distance $D$ is proportional to $\log_2(2D/W)$ .

The keypad’s compact three-by-four layout makes every key’s $W$ large and its $D$ small; that is the mathematical reason the numeric keypad is still standard for data entry. Layout is not a question of habit but of the coefficient in front of an exponential term.

Bimanual Coordination Test makes dual tasking literal. The canvas holds two circular targets: one follows the mouse (and drifts slowly on its own, bouncing off the walls), the other is driven by the arrow keys (6 pixels per press).

Scoring is brutal: only while both markers sit inside their own target circle at the same time does the millisecond counter run.

The design turns the cost of parallelism into a readable number. Look at either hand alone and the task is absurdly easy (the mouse chasing a slowly bouncing circle, the arrow keys chasing a still one), yet the ratio of dual-task score to total time usually slaps you in the face.

The classic explanation is the central bottleneck model. Response selection — “decision-level” processing — is single-channel; the two tasks queue there, and whichever arrives later must wait. Only peripheral stages such as perception and execution can truly run in parallel.

So the dual-task cost depends on how many stages of each task jam in the central channel. A highly automatised task (thousands of repetitions of arrow-key nudging) leaves almost no central processing behind, while stacking two novice tasks can clog the channel until the score approaches zero.

That is also why the gold standard of cognitive load measurement is the dual-task paradigm: hang a secondary task with a constant load on the primary one, and the more the secondary score drops, the more central resources the primary task is consuming.

Rhythm and Time Perception

Rhythm Test turns time perception into a single thing: dots flash on screen at a steady beat and you tap the space bar along with them.

What it measures is not whether you can keep time, but the drift of the human internal clock.

The brain has no quartz crystal; time is estimated from the frequency of neural oscillation. That oscillator has two traits: small bias but large drift — accurate within seconds, and beyond the minute it needs an external metronome to recalibrate.

The test’s flow is a series of beat intervals: first a reference beat to get the feel, then longer intervals where you judge whether two intervals are equal, and finally tapping along to a tempo that changes speed.

One interesting design hides in the source: the reference beat is not at a constant tempo; it switches between two speeds. That forces your internal clock to recalibrate instead of relying on muscle memory to bull through.

The psychophysical conclusions about time perception all find a footing here. Weber’s law holds in the time dimension too: the discrimination threshold for short intervals is about $2\text{--}5\%$ — for a 500 ms interval, the difference a person can tell is roughly 10 to 25 ms. Beyond that, you feel “these two beats are not the same speed”; within it, you feel they are steady.

That is also why tempo markings (BPM) in electronic music are usually integers. Listeners are insensitive to a ±2% tempo change, but at ±5% they clearly feel “faster” or “slower”. Producers pick 120 BPM rather than 118.7 BPM simply because the ear cannot tell the difference.

String the eight tests together and one orientation runs through the perceptual system’s design: it does not pursue precision, it pursues sufficiency. A sufficient system hides its processing below the waterline; the party games in the next chapter do the opposite, dragging the information gap between people onto the table and playing it as the game itself.

Party games are the oddest branch of the whole medium: a few role cards, a deck of fruit cards, a whiteboard — the components are nearly empty, and the game happens entirely between the players. They map naturally onto three motifs of social play: hidden identity manufactures information asymmetry, verbal probing manufactures misdirection and counter-misdirection, and pacing plus randomness manufactures blunders and laughter; and when the confrontation exits, one more class of tool quietly takes over hosting and bookkeeping.

Hands-on versions: Werewolf Moderator, Undercover Moderator, Halli Galli, Party Tracker, RPG Studio.

Werewolf

The Werewolf moderator is a rather restrained implementation. Players adjustable from 5–20, werewolves from 1 to half the table, and only three roles dealt: werewolf, Seer, villager, with exactly one Seer.

Press start and the cards are shuffled. Each player card can be opened to check a role or marked as eliminated. Two buttons, night and day, switch the phase, and the verdict is automatic: all wolves dead means the village wins, and surviving wolves numbering at least the surviving villagers means the wolves win.

Start with why this minimal setup is enough.

No Witch, no Hunter, no Guard — yet not one bone of the game-theoretic skeleton is missing. The wolves are a hidden minority, the villagers an information-disadvantaged majority, the Seer the single informed villager. Three positions and the entire structure of information asymmetry is in place.

Extra roles add hosting burden and a rules threshold, not game-theoretic dimensions. For the scenario of “running Werewolf for a table of newcomers”, the three-role setup is close to Pareto-optimal.

Numerically, the board is tight.

Take the default 8 players with 2 wolves: each night the wolves knife one villager, each day the village votes out one player.

Run two lines. If every day vote hits a wolf: after night one it is 2 wolves and 5 villagers, the day removes 1 wolf; after night two it is 1 wolf and 4 villagers, one more wolf out, village wins.

If the day votes wrong twice: after two night knifes and two wrong votes the board is 2 wolves and 2 villagers, the condition $w \ge g$ holds, and the wolves win.

Put the two side by side and you can count it: the village can afford exactly one wrong vote in total.

That number explains all the pressure in Werewolf’s daytime speeches. Every vote is a Bayesian update with a one-mistake margin, and speech, expression and logic all nudge the decimal point of the posterior on “who is a wolf”.

The Seer’s value sits exactly there. One check a night turns “whom do we vote for” from a probability question into a certainty, which is insurance on the village’s single wrong vote.

The wolves’ counter is perfectly symmetric: knife the exposed Seer, or fake-claim Seer to manufacture a second information source. Leave the village unsure which ledger to trust and wrong votes grow by themselves.

The night and day buttons deserve a second look too. The whole information rhythm of Werewolf hides in that switch.

Night is the production line of private information. Wolves confer, the Seer checks, and what comes out belongs only to a corner of the table.

Day is the public market for private information. Speech and votes push private information onto the public ledger, forgeries smuggled in among it.

The widget makes this clock very permissive. It blocks nothing; you can still check role cards during the day. The reason is that a moderator tool serves the table in the room: the buttons only give everyone a shared time coordinate, a reminder of which world is speaking now.

The adjustable cap of 20 players has its own logic. Werewolf’s difficulty grows superlinearly with headcount: more people means more speech rounds, each round’s information increment diluted, and the cost of telling a fake claim from a real one soaring. Capping at 20 while defaulting to 8 puts newcomer games and big productions on the same panel.

Two source details say a lot about the product philosophy of a moderator tool.

One: the wolf count caps at half the players. But filling an even game all the way to half satisfies $w \ge g$ at the opening, and the verdict declares a wolf win outright. Playable configurations are in effect clamped by the rules themselves to “strictly less than half”; the loose cap just refuses to decide for the player.

Two: the eliminate button is a toggle. Misclick, click again, revived.

The tool does not adjudicate, does not hurry, does not hold grudges. It takes over only the two things machines are good at: the randomness of dealing (a shuffle must be unpredictable; that is the physical basis of information asymmetry) and the precision of judging (comparing headcounts, where a machine does not misspeak). Everything else stays with the humans.

The fake claim deserves its own section, because it is the purest signaling game at the table.

The real Seer reports a check; the fake-claiming wolf reports a check too. The village faces two information sources with one prior in hand: whose language sounds more like a Seer.

The matrix is almost symmetric. The real claimant fears suspicion, the fake fears exposure. Both sides’ optimal speech converges on the same confident register, so the register itself loses its information content. What remains is external evidence: whether the checked targets’ fates line up, whether later checks are self-consistent, whether a dead player’s role contradicts the check record.

Why does the moderator deal cards but never record speech? Once the tool stores evidence on people’s behalf, the fake claim’s room to live compresses and the game converges toward verification play. The deliberate blank in the speech phase is exactly the ecological niche left for deception.

This is the design floor of an information-asymmetry game: a tool can remove the execution error from randomness, but not randomness itself, and certainly not verify a lie for you.

Undercover

The Undercover moderator is mechanically simpler. 3–12 players sit in a circle, one random player gets the odd word out, everyone takes turns describing their word, votes eliminate suspects, and the answer is revealed when two players remain.

The whole trick rests on two things: the word pair and the descriptions.

Word pairs are semantic engineering.

The site ships 15 pairs. At a glance they were tossed in at random; look closer and there is a clear axis.

Cat and tiger are the same kind at different ranks, police officer and security guard the same domain at different posts, doctor and nurse the same workplace at different divisions of labor, train and subway the same vehicle in different scenes.

Ink and soy sauce are the most vicious: nearly the same color, no relation whatsoever in use. Piano and organ plant the mine right in the names.

The 15 pairs also read as three more gradients. Milk tea and coffee sit on the near-synonym axis, umbrella and tent on the function axis (both shelters), candle and oil lamp on the era axis (both light sources).

Different axis types expose differently in the description round. Near-synonym pairs get split by fine-grained description, function pairs are separated by usage scene, and era pairs additionally test the player’s store of general knowledge.

A good pair obeys one law of contradiction: close enough that the undercover can describe it, far enough that one slip fails to reconcile the accounts.

Too far apart (cat and truck) and the undercover is exposed in round one. Too close (sand and cement) and no description separates them, so voting degenerates into a coin flip.

The “semantic distance” window is astonishingly narrow. Fifteen pairs are fifteen manual calibrations of where that window sits. The quality of the word list sets the game’s ceiling; the mechanics themselves are the easy part.

The description round is a textbook signaling game.

The civilians’ optimal strategy is a discriminating description: a proposition true of the civilian word and false of the undercover word. For the pair (apple, pear), say “you don’t peel it”.

But that immediately raises the leakage problem. Describe too discriminately and you broadcast the civilian word’s key attribute to the undercover, who can align next round.

So the actual equilibrium is everyone speaking half-true vagueness, the release rate of information deliberately throttled. The Undercover speech round is not about finding the undercover; it is about controlling the flow rate of information.

The voting odds are easy arithmetic too. Default 5 players with 1 undercover; if every round eliminated purely at random, the village must miss three rounds running for the undercover to reach the reveal, at probability $\frac{4}{5}\times\frac{3}{4}\times\frac{2}{3}=\frac{2}{5}$ .

The random baseline hands the undercover a forty percent survival rate. Which explains why every sentence in the description round really does move the odds: the entire job of speech is to pull the vote up or down from that 0.4 baseline.

The interactions fit the offline pass-the-device scene as well.

Cards are face down by default; tap to peek at your word, tap again to hide it, elimination is allowed only while the card is face down, and the game reveals every role when two players remain.

Like the Werewolf moderator, it automates everything automatable (drawing the pair, assigning roles, the reveal) and leaves the unautomatable (describing, misleading, persuading) exactly where it was, with the humans.

The undercover’s strategy chain is worth listing once.

Early on, ride the civilians’ phrasing with generic descriptions. The closer the pair, the easier the ride; vacuous lines like “it’s an everyday thing” carry the highest safety factor.

Mid game, watch who gets suspected repeatedly and steer votes elsewhere.

Late game, as the survivor count approaches the reveal line, the goal flips to squeezing into the final pair, because two survivors trigger the reveal and reaching the endgame counts as a win in house scoring. What to do then is not to keep hiding but to stop making mistakes.

The civilians’ counters are layered too. First probe reactions with repeated votes (someone named in two rounds moves up the priority list), then reconcile with description replay: put one player’s two rounds side by side and even the closest pair leaks in the details.

All of these strategies rest on three mechanical preconditions: descriptions are public, words are private, votes are common knowledge. Remove any one and the signaling game falls apart. Which, turned around, explains why this game’s variants (blind word draws, secret ballots) always change exactly one of the three.

Halli Galli

Halli Galli is the only game in the set of five that tests the hand.

The site implementation: four fruits, 10 cards each, 40 cards in total, each printed with a number from 1–5 (two of each number per fruit); after the shuffle you and the computer get 20 each.

Tap “flip” and you play a card; the computer follows instantly with one of its own. The instant any fruit’s face-up total equals exactly 5, the bell rings, and you have 1.3 seconds to hit it and sweep the table. Miss the window and the computer takes the pile.

The four fruit totals live permanently at the top of the screen as badges. Tracking them is the entire difficulty of the game.

First, how it manufactures mistakes.

Human simple reaction time is about 0.2 seconds, but that is reaction to one clear, single signal. Here the signal is four counters accumulating in parallel, and any card can push one of them to 5.

In substance this is a four-channel Go/No-Go task: the vast majority of cards are No-Go (hold still), a few are Go (act now).

The cognitive load multiplies reaction time several times over, and the 1.3-second window sits right at “enough when alert, just short when distracted”.

Nastier still are two structural pits.

The total never comes back. Between two bell rings each fruit’s table total only grows; flip a 4 onto a 3 and it jumps to 7, and the 5 is missed forever, until someone sweeps the table and the count restarts. The regret of a missed window induces the next premature strike.

When the card just before a total reaching 5 appears, the player enters an anticipatory state, and anticipatory reactions are the breeding ground of premature ringing.

Interestingly, the source removes premature ringing physically: while the bell has not rung, the ring button is disabled. The original board game’s classic blunder of slapping the bell at the wrong moment and paying cards is designed out. In the site version only one mistake survives, timing out, and the penalty shrinks from “pay cards to your opponent” to “your opponent takes the table for free”.

As for the computer opponent: it has no intelligence.

It never judges on its own, never blunders, and scores entirely off your timeouts. It is implemented as a 1.3-second hourglass bolted to an automatic card follower.

The design is refreshingly honest. The fun of a reaction game was never in the opponent’s strength but in your own nervous system’s live performance. The computer’s job is to be a precise timer, executing the fact that you were slow without any feeling about it.

Hick’s law gives the difficulty a quantitative footnote: $RT = a + b\log_2(n+1)$ . As the choice channels go from 1 to 4, reaction time climbs logarithmically rather than linearly.

But Halli Galli’s cruelty lies beyond the channel count. Four counters share one table, and attention must be allocated dynamically across four permanent badges. Each flip rewrites only one counter, but which one to watch next second keeps changing hands as the board moves.

The deck also hides an invisible protagonist: the 5 cards.

If a fruit’s table total is still 0, a 5 rings the bell outright. If the total is already 1–4, the same card sends that fruit straight past the point. Whether one card is opportunity or trap depends entirely on the table state it walks into.

And sweeping the table zeroes all four counters at once, pulling all four lanes back to the start line. So “when does the bell ring” is not only a reaction question but a pacing one: ring early and take a small table, ring late and possibly miss it entirely, and the whole game rolls inside that trade-off.

The deck itself is deliberate. Each fruit runs 1–5 twice, 30 points per fruit, 3 points per card on average across the 40, so the table total climbs at a steady rate and “exactly 5” is a moving target. The shuffle guarantees that every approach to 5 takes a different path, which guarantees that mistakes cannot be immunized by muscle memory.

Scoring settles the cards swept across the whole game. Two piles of 20 run down in step, and what is finally compared is who blundered less. A reaction game compresses luck into the instant of the deal and leaves the rest to the nerves.

Tabletop tools

The other two of the five are not competitive games at all.

The party tracker is a tabletop RPG panel. Enter name, class, hit points, maximum, and armor — five fields — to build a small party; each member has three states, normal, downed, dead; the health bar changes color with the state (green, yellow, red); hit points are nudged with ±1 buttons. The cleric in the preset party starts out downed.

The quest board is a quest-tracking whiteboard. Title, three difficulty tiers (easy / normal / hard), a reward, and three states (not started / in progress / complete) advanced by button, with three count badges hanging at the top. The preset quests run from razing a goblin camp all the way to challenging the dragon.

Embedded below is the D&D character sheet, another member of the same tabletop toolchain: pick a race and a class, and a portable ability card is generated on the spot.

Put these two widgets into the context of “party games” and a commonly ignored design dimension lights up: where the randomness sits.

Werewolf puts randomness at the start (shuffled dealing), Halli Galli in the card order, Undercover in the word pair and the role draw. Randomness built into the action layer exists so the weak still have a shot at a hand: a newcomer can dodge knives with seat position in Werewolf, can catch a friendly card order in Halli Galli. A random stream that keeps re-dealing is precisely the technical implementation of “sustaining entertainment rather than competition”.

The tabletop tools walk the opposite road: they externalize randomness entirely.

Humans roll the dice, humans adjudicate the outcome, and the panel does one thing only, bookkeeping. The party tracker has no win condition, the quest board no score and no countdown. They are the only two of the five with no winning or losing.

The reason is that a tabletop session’s entertainment core is narrative continuity, not settlement fairness. The panel’s value is saving the host one misrecorded hit point or one lost quest card; the drama at the table is still made by people.

Both panels’ details deserve a read from the angle of host burden.

Hit points on ±1 buttons rather than free input presses the cost of a change to the floor. Combat at a tabletop session runs on a clock measured in seconds, and the host’s attention has to stay on the table.

The health bar’s color coding (normal green, downed yellow, dead red) borrows the traffic light: one glance says who is in trouble, no number reading required.

And the downed cleric in the preset party is a silent demonstration of use: the state field exists for exactly that moment.

The quest board’s three difficulty tiers and three states are equally minimal-complete design. Difficulty is enough to hang a priority on, states are enough to run a workflow, and one more of either would be a burden.

More interesting is that they share a tech stack with the competitive widgets while serving the opposite division of labor.

Halli Galli gives the machine what machines compute fast (counting) and leaves humans what humans are good at (reaction). The tabletop panels take on what humans compute slowly (a state ledger across five or six variables at once) and hand back what humans are good at (narrative and adjudication).

Two scenarios, opposite directions of division, one principle: the machine keeps the books, the human makes the calls.

This is also where the two senses of “party” part ways. One is the competitive game at a gathering, randomness bound to laughter. The other is the tabletop session around the table, where randomness is only the dice of the story.

The limits of automated judging

Look back over the five and one engineering principle runs through them: what can be verified goes to the machine, what cannot stays with humans.

Dealing and shuffling (must be unpredictable) — machine. Counting and timing (must be exact) — machine. State and verdict (must not misspeak) — machine. Describing, persuading, voting, performing — human. The four fruit totals in Halli Galli are a domain where machines crush humans, so the widget turns them into permanent badges and saves the player the most exhausting bookkeeping, while leaving the 1.3-second decision to the player.

Not one item on the list says “must be fair”. The night knife in Werewolf can be senseless, the word pair in Undercover can be biased, the bell window is only 1.3 seconds. A party game does not need fairness; it needs unpredictability and consistency for everyone: randomness consistent for everyone is what makes a shared joke, judging consistent for everyone is what makes a shared win, and the cheapest way to implement consistency is to hand it to a machine.

Conversely, the persuasion of the description round, the game theory of the voting round, the heartbeat of a fake claim — the machine takes over none of it, not because it cannot be simulated technically but because simulating it dissolves the game. A party game’s opponent has to be a real person, because the means of production here is the information gap and the trust gap between real people.

The limit of automated judging is, in the end, the limit of social play: a machine can manage randomness, record state, and enforce rules; what it cannot do is fool your friends for you, or decide for you whom to believe.

Party games draw their boundary at what may be delegated to a machine; escape-room and puzzle levels work another boundary — the dependency graph in the author’s head, and the pace at which it is disclosed.

Locks, Keys, and Pacing Budgets

Escape-room games wrap a shell of spatial narrative around solving puzzles: the puzzle is still the same puzzle, but what the player faces is no longer a question card — it is a locked door, with a key behind it, the key somewhere else, and somewhere else another lock. The whole craft of level design hides inside that tongue twister: how locks and keys are wired, in what order clues are revealed, and how someone who is stuck gets quietly nudged.

Hands-on versions: Escape Room, Escape Adventure, Drop Water, Jenga.

Locks and Keys

Abstract an escape room away and what remains is a directed graph.

The nodes are locks, meaning any state that blocks progress. A door, a safe, a vent cover that needs a tool to pry open.

Edges run from a key to the lock it opens. A key here can be an item or a piece of information.

What you actually draw on paper when designing a room is not the floor plan but this dependency graph. It has only two hard constraints.

No broken chains: every lock’s key must be reachable from the initial state.

No self-locking cycles: a lock’s key must not be walled off behind that same lock.

A level that violates the first is unsolvable; one that violates the second deadlocks. Either way the player never reaches a state at all and simply quits.

By the nature of the key, locks divide once more into two classes, and the design feel is entirely different.

An information lock has for a key a conclusion that can be re-derived at any moment. All three locks in Escape Room are of this kind. In the study, “the years on the paintings in reverse order are the safe code”; in the corridor, “the key the same color as the wallpaper”; in the vault, “the next term of the sequence” (the three rooms are named exactly study, corridor, vault).

The clue panel is always on screen, so the answer can be recomputed at any time. Information locks therefore cannot dead-end topologically. The worst case is a player who misread the clue, not a world that has turned unsolvable.

Item locks are different. The key is an object occupying a position in space; you have to walk to it, pick it up, carry it. Reachability becomes an extra constraint, and the dependency graph extends off the paper into the scene.

The winning chain in Escape Adventure is a textbook-long item-lock chain. A key lies under the rug in room one, and only after picking it up does the door to room two open. Room two holds a note and a safe; enter the four-digit code (hard-coded as 7391 in the source) to open the safe and take the crowbar. The vent in room three has to be pried open with that crowbar, and you crawl out through the hole.

Every edge holds the chain together. The only decorative edge is the note: viewable, pickable, taking part in no unlock — a pure atmosphere prop.

But there is one genuine topological hazard on this chain, worth pulling out on its own.

Getting from room two to room three has no gate at all, and rooms only move forward, never back. If the player skips the safe and clicks “next room”, they stand at the vent and get one line: “You need a crowbar to pry the vent open.”

But the safe is by then permanently behind them, the crowbar can never be obtained again, and the only way out is to start over.

The dependency graph itself has no cycle and no broken chain; the problem is that one-way progress makes “the key is behind you” a reachable state.

The standard fix in commercial escape games is to add a backtracking edge to the door (allow regret), or to bind admission to the final area directly to the ultimate key. At the source level the fix is one line of validation: check for the crowbar before entering room three.

This counterexample is exactly why dependency-graph analysis pays. A cycle or a broken chain that is obvious on paper, hidden across three rooms, becomes “you find out you are finished halfway through”.

Randomized Parameters and Fixed Scripts

In the same genre, two widgets offer opposite answers to replayability.

Escape Room belongs to the randomized-parameter camp. Every run re-draws the puzzle surface in all three rooms. Painting years are uniform from 100 to 999, 900 possibilities. Wallpaper color is one of three. The sequence puzzle takes a first term from 2 to 9 and a common difference from 2 to 5 — 8 and 4 variants, 32 together.

Multiply the three and a run has $900\times3\times32=86400$ surface combinations.

But notice what the randomization touches and what it leaves alone. The order of the three rooms, the three puzzle types, the linear progression — none of it moves. What is random is the parameters, not the structure.

By the second run the player notices they are not playing a new level, just a new exam number on the same paper.

That is a design trade-off. Structural randomization (rearranging the dependency graph, roguelike style) very easily produces broken chains and deadlocks; the two hard constraints from the previous section are precisely what is hardest to guarantee automatically. Parameter-level randomization is safe by construction, because the dependency graph never moves.

The hidden cost of parameterization lies elsewhere: clues have to be generated along with the parameters. All three clue strings in the source are templates with placeholders. “The painting reads {year}”, “the wallpaper is {color}”, “find the next number in the sequence: {seq}”. Every random parameter needs a sentence that lets it prove itself; miss one and that puzzle becomes a case with no head.

Parameterization has a few corners that are easy to miss.

Year reversal works on strings: 120 reversed is 021, not 21. So the answer comparison is string equality, and the input placeholder is the three-digit 000. A leading-zero detail, backed by the discipline that every instance in the parameter space must be decidable.

The sequence’s parameter range is worth a glance as well. First term 2–9, common difference 2–5, deliberately narrow so that mental arithmetic past the fourth term stays in syllabus. Randomization must not touch the difficulty budget; what replayability buys is novelty, not difficulty drift.

While we are here, run a birthday-paradox calculation. Eighty-six thousand combinations sounds like a lot, but around three hundred runs you hit your first repeated paper. The parameter space grows like a square root, and long-line replay built on it is always finite.

Escape Adventure stands at the other end: the fixed-script camp.

The code is hard-coded, item positions are fixed, the path is unique, and replay value drops to zero the moment you finish once.

What it buys in exchange is worth just as much. A hand-built script can be tuned node by node. Where each item sits, what each line of copy says, which tier a hint reaches — all of it is custom-made for that single path.

The random camp sells the hundredth run, the fixed camp sells the first. At two or three minutes a run, the two are almost a division of labor between “make them play more” and “make them understand”.

Trace the fixed-script idea upward and it is the same design philosophy as the “rule economics” of pencil puzzles. Puzzles trade scarce rules for a unique solution; escape rooms trade lock wiring for pacing, and both demand that the author hold the whole graph in view.

I wrote about this lineage before in Six Pencil Puzzles and Their Rule Skeletons; the two read well side by side.

Hints and Failure Text

Being stuck is not a malfunction; it is the dependency graph not yet finished in the player’s head.

A hint system is, in essence, disclosing that graph from the author’s head on demand. By granularity there are three tiers.

Direction level: “there is something in this room you have not examined”.

Location level: “look at the rug”.

Action level: “lift the rug and take the key”.

The hint button in Escape Adventure gives the last tier. It hands out one action-level line for the current room: room one gets “Hint: lift the rug and take the key.”, room two gets “Hint: read the note, then use the safe code.”, room three gets “Hint: pry the vent open with the crowbar and escape.”

Object, action, one step, and the player is never stuck again.

The cost sits right there. Action-level hints skip every rung of reasoning; three rooms, three presses, and the game has played itself for you.

Commercial titles therefore price hints as a rule: timed penalties, use caps, hint points. The widget chose unlimited free supply.

At its size that choice is reasonable. The reasoning chain is three steps total, the player’s motive to press for a hint is weak to begin with, and a pricing system would be a liability. Drop the same policy into a thirty-step chain and you have dismantled the game.

Cheaper than a hint button is the failure text.

The two refusals in Escape Adventure — “You need a key to open the next door.” and “You need a crowbar to pry the vent open.” — are not a vague “no” but a precise report of the missing dependency edge. What is missing, and where the missing thing is used, in one sentence.

What the player reads out of a failure is the shape of the graph.

Compare Escape Room, where a wrong answer earns only “Not quite.” But its locks are all information locks, the clue panel is always up, and re-reading the clue is the hint, so the minimal refusal holds.

The comparison yields a rule of thumb: how much detail a failure text carries should follow the type of lock. An item lock’s failure must report what is missing; an information lock’s failure only needs to send you back for another look.

There is one more disclosure channel in the widget that is easy to overlook: the log.

Every look, pickup, and use in Escape Adventure is appended to the log area and kept as it scrolls. It is external memory (what have I examined, what am I carrying) and post-mortem material at once. Scroll back when stuck and the clue you need is usually already in there.

Log-style disclosure has a hidden benefit too: the whole transition history sits on screen, which makes it a visible save file by nature.

Jenga

Physical mini-games swap in a different grammar for level design: no locks, only a risk curve that keeps tightening.

The Jenga tower is 12 layers of 3 blocks each, 36 blocks. The goal is to draw until only 3 remain — 33 successful pulls.

Collapse has two rules, one deterministic and one probabilistic.

The deterministic one governs structure: empty a layer while blocks remain above it, and the tower falls.

The probabilistic one governs wear: every pull rolls an invisible die, and the collapse chance is 5% plus 2% times the number of weak layers. A weak layer is one below the pull position holding at most 1 block.

Start with the tension curve the probability rule produces. Each layer you cripple makes every later pull cost 2% more. Hollow out the lower deck on purpose and the theoretical ceiling is $0.05+0.02\times11=27\%$ — nearly a third of pulls send the tower to heaven.

The risk is not a fixed lottery distribution; it is set by where you have already pulled. The danger is something the player accumulates.

The difference between a tension curve and a random curve: the former comes with a bill, and the bill has your name on it.

But the source actually buries a structurally safe route in it.

The deterministic rule looks only upward. Above the top layer there is never anything, so it can be emptied freely. Empty a layer and the layer beneath it has nothing above it either. Clear from the top down and deterministic collapse never triggers.

And weak layers only count downward. Going top-down, everything below is at full strength of three, the weak-layer count is identically zero, and every pull’s collapse rate is identically 5%.

So a run on the optimal route is 33 independent trials: survival $0.95^{33}\approx18\%$ .

Run the expectation too. A constant 5% hazard means the tower falls around pull 20 on average, while clearing the game means surviving 33. Even on the optimal route, winning is a low-probability event.

This is not a numerical mistake. Physical Jenga is a game you lose more often than win; the 5% base rate carries that “it falls sooner or later” table feel straight into the parameters.

The interface has two counters: pulls made and blocks left. No health bar, no probability readout; 5% and 2% are buried in the code. The player can only infer the rules from the feel of “pull low and it falls faster”.

The convention in physical games is to let the math hide behind the feel. Get the feel right and the math gets played out on its own.

There is a temporal structure to this probability rule worth noting. The hazard does not rise with time; it rises only with space.

And the tower’s scars are all in plain sight. A pulled block leaves a gray slot in place, so which layers are crippled and how many weak layers have piled up below can be counted at a glance.

Lazy play (going for the handiest bottom two layers first) lifts every later pull to 9%, and the tower falls around pull eleven. Disciplined top-down play holds at 5% throughout.

One tower, and the risk curve differs by player. Level design leaves the freedom of how to pull to the player, and leaves the resulting bill to the player as well.

Drop Water

The Drop Water board is a 5×5 grid, and each cell holds 0 to 3 drops.

Click any cell to add a drop; a cell that reaches 4 drops detonates at once. The cell resets to zero and spits one drop up, down, left, and right, and a splash can push another cell past its threshold; the chain is settled by a loop in the source that repeats until no cell on the board is critical.

The instructions are one sentence: “Click any cell to add a drop. A cell that reaches 4 drops explodes and splashes one drop to each neighbor. Clear the board to win.”

But a conservation ledger is buried in that rule, and you have to balance it before you can win.

A burst’s income and outgo depend on where it happens.

An interior cell bursts: −4 locally, +4 to four neighbors, not a drop of total water lost.

An edge cell has only three neighbors, for a net outflow of 1 drop.

A corner has only two neighbors, for a net outflow of 2.

In other words the board’s boundary is the only drain in the whole system. Translated, the victory condition “clear the board” means: make every drop leave through a boundary burst.

Each cell’s reading is a pressure gauge, and 4 is the redline. However high the global water level, it is not directly fatal; what is fatal is a high level all pent up inside.

Drop Water’s water pressure is not a metaphor but a physical quantity you can account for cell by cell.

The three preset levels hold 20, 17, and 30 drops in total, all of which must drain through the 16 outer edge and corner cells.

The threshold of 4 is not arbitrary either. An interior cell has exactly 4 neighbors, so a burst pushes one drop out along each edge. Threshold equals degree: not a drop more, not a drop less, dealt evenly to the four neighbors.

Edges and corners have degrees of only 3 and 2, while the threshold stays 4. The shortfall is exactly the leakage: the closer a cell is to the border, the more it loses per burst.

The whole economy of the rule is hidden in that degree difference.

The second layer of structure is the order-independence of the chain. Mathematically the board is an abelian sandpile. For the same set of clicks, no matter in what order they are performed and in what order the chain settles, the final stable state is unique.

That property turns solving into a clean problem. Choose a multiset of which cells and how many times each, and let necessity do the rest.

The step counter at the top therefore has an exact meaning: it counts how far you are from the minimum click set.

The three preset puzzles also demonstrate two opposite rhythms.

Two corner cells in level two come with 4 drops already in them, in a critical state (drawn with a warning outline), and any click at all detonates them and sets off a board-wide chain. A puzzle that peaks at the opening: the first move is the biggest event.

The other two are the opposite, building pressure cell by cell from zero.

The source also has a fuse: the settling loop carries a 2000-iteration cap. A sandpile on a finite board with boundary drainage is theoretically bound to stabilize, so the cap is purely defensive programming. A good level mechanic converges on its own; the code only guards against the day it does not.

The Pacing Band

Between “stuck for ten minutes” and “bored for thirty seconds” there is only one narrow band: the interval between two progress events.

Too long an interval and the player leaves in frustration. Too short and progress devalues into a ledger, and nobody’s heart races at the tenth automatic reward.

All the pacing design in escape rooms and puzzle levels is budgeting that interval.

The four widgets’ time scales can be laid side by side.

Escape Room has three locks a run, no penalty for a wrong answer, instant judgment, and a run of about two minutes, so the interval between progress events is compressed to the tens of seconds.

Escape Adventure needs around ten interactions a run, so the interval is longer, but every step carries a scene interaction, and it is airtight.

Jenga cuts two minutes into 33 heartbeats, each pull separated by one piece of suspense: will it fall this time.

Drop Water cuts a few minutes into a number of bets: will this one blow the board apart.

The common premise is immediate feedback. A wrong answer lights up on the spot, a chain settles in the same frame, a falling tower pops up at once. The sense of time inside the band rests on immediate feedback, and any late feedback anywhere widens it until the game is unplayable.

The band’s two walls each have their own defense.

The left wall (being stuck) is defended by the hint system. Action-level hints, failure text that reports what is missing, the always-on clue panel — all pressure valves.

The right wall (boredom) is defended by randomization. Re-drawing the parameters keeps the second run’s surface from repeating.

The costs of the two directions are finally booked to the same account. The more you disclose, the less there is to reason about. The more you randomize, the less hand control the author has.

Level design, in the end, is pricing being stuck. Free hints and dependency edges written into failure text push the price below the floor at which the player is willing to keep going. Parameterization, preset levels, and a rising risk curve keep manufacturing reasons to go again.

Thanks for reading! Follow me if you'd like~