hayao 0.4.0 → 0.4.2

package/design/10-anchors/balatro.md

@@ -0,0 +1,132 @@
+---
+id: anchor-balatro
+title: Balatro
+kind: anchor
+tags: [deckbuilder, score-multiplier, joker, synergy, poker, escalation, juice]
+summary: A score-multiplier deckbuilder where poker hands feed a chips×mult engine and stacked jokers make the number explode — the fantasy is watching it go up.
+use-when: Designing a game whose payoff is a runaway score-multiplier engine and the juice of numbers detonating past a threshold.
+composes-with: [genre-deckbuilder, system-build-diversity, pattern-feedback-loops, pattern-juice-choreography]
+anchors: [anchor-balatro]
+verify-with: docs/FUN.md#11-·-roguelike-deckbuilder
+---
+
+# Balatro
+
+**What it is.** A roguelike deckbuilder built on poker. Each hand scores
+`chips × mult`; you must beat a rising blind. Between rounds you buy
+**jokers** — passive modifiers that warp the scoring — until a well-built
+engine turns a modest pair into a seven-figure detonation.
+
+**Player fantasy / why it's fun.** *Number. Goes. Up.* The pull is **the
+multiplier crossover**: for a while you scrape past blinds, then the right
+jokers click and your score leaps an order of magnitude in one hand. It's the
+deckbuilder distilled to its purest dopamine — synergy discovery plus the
+physical joy of a big number landing.
+
+## Design DNA
+
+Take the [[anchor-slay-the-spire]] draft-refine loop and **replace "survive
+combat" with "beat a score threshold."** Now the whole design points at one
+exposed number, and every card and joker is a term in its equation. The
+two-part scoring — **additive chips × multiplicative mult** — is the secret:
+mult scales multiplicatively, so builds don't climb, they *explode*. Fun is
+finding which jokers multiply each other and watching the feedback loop run
+away.
+
+The two-axis split is the load-bearing invention, and it's worth dwelling on.
+If score were a single additive number, a good build would beat a bad one by
+*some percentage* — satisfying but flat. By separating *chips* (additive,
+grows the base) from *mult* (multiplicative, grows the scaling), Balatro makes
+the two combine into a *product*, so investments in different axes multiply
+each other's value. A joker that adds mult is worth more the more chips you
+have, and vice versa — every piece raises the ceiling of every other piece.
+That's what turns "number goes up" into "number *detonates*," and it's the
+single most transplantable idea in the game.
+
+The engine is legible and the payoff is loud: you can *see* the equation
+resolve, term by term, and the juice choreographs the explosion. Legibility
+isn't a nicety here — it's how the player learns synergy. Watching each joker
+fire in sequence *teaches* you which pieces compound, so the celebration and
+the tutorial are the same animation.
+
+## Load-bearing structures
+
+| Structure | Why it works |
+|---|---|
+| **`chips × mult` two-axis scoring** | Additive base × multiplicative scaling means good builds go *superlinear* — the source of the "number explodes" feel. [[pattern-feedback-loops]]. |
+| **Jokers = stacking passive multipliers** | Persistent modifiers that combo *with each other*; the meta-game is finding multiplicative synergies. [[system-build-diversity]] / [[pattern-emergence]]. |
+| **The score threshold as the exposed goal** | One rising number to beat, one growing number you build — the entire decision surface is legible. FUN.md §17's "exposed score," applied to a deckbuilder. |
+| **Visible term-by-term resolution** | The scoring animation *shows* each card and joker firing — the juice IS the feedback, and it teaches synergy. [[pattern-juice-choreography]]. |
+| **Draft + shop between blinds** | Buy jokers / add / delete cards — draft-refine with money as the constraint. [[system-economy]] / [[system-reward-schedules]]. |
+| **Escalating blinds** | A superlinear score target forces the engine to keep growing — the rising tide of a deckbuilder. [[system-difficulty-and-dda]]. |
+| **Rare wild synergies** | A few joker combos break the game open — the discovery of a "broken" build is the peak. [[pattern-risk-reward]]. |
+
+## What to steal
+
+- **Point the whole game at one exposed, growing number**, and make every
+  piece a term in its equation. Legibility + the number-goes-up hook in one
+  move.
+- **Split scoring into additive + multiplicative axes.** Multiplicative
+  scaling is what makes builds *explode* instead of climb. This is the
+  reusable trick.
+- **Passive modifiers that multiply *each other*.** Synergy between jokers,
+  not just with cards, is where the depth and the "broken build" joy live.
+- **Resolve the score visibly, term by term.** The scoring choreography is the
+  reward — the juice *is* the feedback loop. See
+  [[pattern-juice-choreography]] and `docs/JUICE.md`.
+- **Escalate the threshold superlinearly** so the engine must keep growing
+  (and inherit the deckbuilder verify: win-rate window + draft delta).
+- **Reserve a few genuinely broken synergies.** The peak experience of the
+  genre is *discovering* a combo that breaks the math open; a handful of rare,
+  run-defining joker pairs give players a jackpot to hunt. Balance the
+  *median* build to the win-rate window, but let the tail spike.
+  [[pattern-risk-reward]].
+
+## What's just theme (drop it)
+
+- **Poker / playing cards.** Balatro's genius is that poker is *familiar
+  scaffolding*, not the point — any "form a set → score it" base works. The
+  `chips×mult` engine is the structure.
+- **The tarot/planet/spectral card taxonomy.** Flavour over a modifier system
+  — see [[system-build-diversity]].
+- **The CRT/vaporwave look.** Aesthetic; the number's *legibility* is what
+  matters, not the palette.
+- **Casino framing.** Cosmetic dressing on a score-threshold run.
+
+## Composes into
+
+- [[genre-deckbuilder]] — a score-engine variant of the draft-refine loop.
+- [[system-build-diversity]] — multiplicative-synergy joker stacking.
+- [[pattern-feedback-loops]] — the runaway multiplier is the exemplar of a
+  positive loop.
+- [[pattern-juice-choreography]] — term-by-term score resolution as feedback.
+- [[system-economy]] — the between-round shop constraint.
+
+## Twist seams
+
+- **Balatro but the multiplier is spatial** *(mechanic-swap)* — you place
+  tiles/jokers on a grid and *adjacency* multiplies; the engine becomes a
+  board you arrange. Pairs with [[anchor-loop-hero]].
+- **Balatro but you're building the *blind* for someone else** *(perspective)*
+  — asymmetric: one player tunes the score engine, the other tunes the
+  threshold. Feeds [[system-coop-and-competition]].
+- **Balatro but every joker also raises the target** *(constraint)* —
+  double-edged synergy: the pieces that grow your score also grow what you
+  must beat, forcing push-your-luck timing on when to stop building. Sharpens
+  [[pattern-risk-reward]].
+- **Balatro but the base isn't cards — it's your day** *(theme)* — the "hand"
+  is a to-do list, chips are tasks done, mult is momentum/mood, jokers are
+  habits that compound. Same `chips × mult` engine, recolored as a
+  life-optimisation toy. Theme that reinforces the mechanic rather than
+  decorating it.
+
+## See also
+
+- [[genre-deckbuilder]] · [[anchor-slay-the-spire]] ·
+  [[pattern-feedback-loops]] · [[pattern-juice-choreography]]
+- `docs/FUN.md#11-·-roguelike-deckbuilder` — win-rate window, draft delta,
+  intent honesty.
+- `docs/JUICE.md` — the score-detonation feedback contract (2-senses,
+  escalation).
+- `sandboxes/juice-lab/` — spring/pop/particle choreography for the number
+  landing.

package/design/10-anchors/celeste.md

@@ -0,0 +1,136 @@
+---
+id: anchor-celeste
+title: Celeste
+kind: anchor
+tags: [platformer, precision, grace, assist-mode, mastery, humane, momentum]
+summary: Precision platformer where brutal difficulty and total forgiveness coexist — grace is a system, assist mode makes the mountain optional not easy.
+use-when: Designing a movement-first game where deaths must feel fair and the difficulty needs a humane floor.
+composes-with: [genre-precision-platformer, system-grace, system-mastery-curve, system-accessibility]
+anchors: [anchor-celeste]
+verify-with: docs/FUN.md#2-·-precision-platformer-celeste-like
+---
+
+# Celeste
+
+**What it is.** A hard-as-nails precision platformer built on three verbs —
+**jump, dash, climb** — where every death is instant to retry and clearly your
+fault, and an **assist mode** lets any player tune the physics until the
+mountain is climbable.
+
+**Player fantasy / why it's fun.** *I am getting better at this, and the game
+knows it.* The pull is the **micro-mastery loop**: a screen looks impossible,
+you die twenty times, and then your hands learn it and it flows. Death costs
+nothing but the last two seconds, so frustration never compounds.
+
+## Design DNA
+
+A platformer is a **trust contract**: inputs must land, and deaths must read
+as yours. Celeste pays the contract in full, then adds a second, radical move
+— it makes the *whole difficulty curve* a slider the player owns. Mastery and
+mercy are not opposites here; the **grace systems that make hard fair** are
+the same ones that make assist mode humane rather than cheap.
+
+The core is small on purpose. One screen = one idea. The dash is a single
+recharging resource that turns the whole moveset combinatorial: jump, dash,
+and climb are only three verbs, but *where and when* you spend the dash — off
+a wall, at an apex, into a corner — is a hundred distinct lines. Difficulty
+comes from **arranging one screen's obstacles around one movement idea**, not
+from adding mechanics. The player's growth is physical: the hands learn the
+rhythm the eyes already understood, and the game is careful never to punish a
+read it didn't teach.
+
+The deepest structural bet is that **being forgiving and being hard are
+orthogonal.** Coyote time doesn't make Celeste easier; it removes the *unfair*
+deaths so the *fair* ones can be brutal. Assist mode extends the same logic to
+the whole curve — the mountain stays hard-by-default, but its difficulty is a
+dial, not a wall.
+
+## Load-bearing structures
+
+| Structure | Why it works |
+|---|---|
+| **Single-screen units** | Each room is one puzzle-of-movement; death rewinds only that screen. Failure is cheap, so difficulty can be brutal. |
+| **Instant, momentum-preserving retry** | No load, no menu, no lost run. The player stays in flow; retrying *is* the practice. See [[system-grace]] / [[system-save-and-checkpoint]]. |
+| **The dash as a recharging combinatorial verb** | One resource (dash, refreshed on ground/crystal) multiplies three verbs into hundreds of lines. Depth from few pieces — [[pattern-emergence]]. |
+| **Grace canon under the hood** | Coyote time, jump buffer, corner correction, variable height. Invisible when working; the reason "unfair" deaths vanish. FUN.md law 5. |
+| **Assist mode as first-class** | Game speed, infinite stamina, invincibility, dash count — all tunable, framed as *your climb, your terms*, never a lesser mode. [[system-accessibility]]. |
+| **Difficulty as respect** | B-sides and berries are optional peaks for the hungry; the main path stays completable. Two audiences, one mountain. [[system-difficulty-and-dda]]. |
+| **Narrative rhymes the mechanic** | The climb is the story; the fall-and-retry is anxiety made playable. Theme *serves* the loop instead of decorating it. |
+
+## What to steal
+
+- **The single-screen retry unit.** Cheap death is the license for hard
+  content. Bound failure to the smallest sensible chunk and make retry instant
+  — the retry *is* the practice, so the loop teaches while it punishes.
+- **One recharging resource that reshapes the moveset.** Dash, hook,
+  double-jump — give the player a verb-multiplier they manage in the air. One
+  resource shared across three verbs beats six independent abilities: it
+  forces a decision every jump.
+- **The full grace canon, tuned in frames, not vibes** — coyote, buffer,
+  corner-correct, variable height, apex gravity, lift momentum. This is a
+  build primitive, not polish: see [[system-grace]] and
+  [[genre-precision-platformer]]. Grace state must persist past the state that
+  changed it (a coyote jump fires after you've left the ledge).
+- **Assist mode as a slider, not an easy button.** Expose the physics knobs —
+  game speed, stamina, dash count, invincibility — and frame them as *your
+  terms*, never a lesser mode. The floor is opt-in, not imposed. See
+  [[system-accessibility]].
+- **Separate "forgiving" from "hard."** Design the difficulty and the mercy
+  independently: brutal obstacle placement *plus* a full grace canon, not
+  softened obstacles. This is the move that lets one game serve both
+  audiences.
+- **Derive gap widths from the movement envelope**, never eyeball them (FUN.md
+  law 3). Compute `jumpDistance`/`dashJumpDistance` from the actual config and
+  place every gap inside it with human slack — frame-perfect spacing is a bug,
+  not a challenge.
+
+## What's just theme (drop it)
+
+- **The mountain / mental-health allegory.** Powerful, but it's a coat of
+  paint over the loop — a heist tower or a data-spire climbs identically.
+- **Pixel art and the specific character.** Aesthetic, not structure.
+- **Strawberries as literal fruit.** The *optional-peak collectible* is
+  structural; the fruit is flavour — see [[system-collectibles]].
+- **The specific two-hour narrative arc.** The retry loop is fun in a single
+  30-second screen with zero story.
+
+## Composes into
+
+- [[genre-precision-platformer]] — this is its canonical anchor; the
+  movement-trust contract lives there.
+- [[system-grace]] — Celeste is the reference implementation of
+  grace-as-system.
+- [[system-accessibility]] — assist mode is the exemplar of humane, opt-in
+  difficulty.
+- [[system-mastery-curve]] — the "die-till-your-hands-learn-it" micro-loop.
+- [[system-save-and-checkpoint]] — instant retry is a checkpoint-design
+  choice.
+
+## Twist seams
+
+- **Celeste but the dash is a shared resource with a companion**
+  *(mechanic-swap)* — coyote and buffer now mediate a coop hand-off; one
+  player's dash refresh gates the other's jump, turning solo mastery into
+  interdependence. Feeds [[system-coop-and-competition]].
+- **Celeste but momentum is the only score** *(constraint)* — no deaths, just
+  a speed meter that bleeds when you stop or touch a wall; the assist knobs
+  become a difficulty *dial for style*, not survival, and the single-screen
+  unit becomes a chained flow-run. Pairs with [[pattern-mastery-and-flow]].
+- **Celeste but tonally cozy** *(tonal)* — same grace canon, but the
+  "mountain" is a garden you tend upward; failure is a gentle reset, not
+  anxiety, and the collectible peaks become seasonal blooms. Bends the
+  register without touching the verbs. Pairs with [[genre-farming-sim]].
+- **Celeste but the screen rewrites itself as you climb** *(structure)* — each
+  retry reshuffles the obstacle layout within the movement envelope, so
+  mastery is of the *system*, not a memorised line. Pulls in
+  [[system-procgen-design]] and shifts the fun from execution-of-a-known-line
+  to adaptation.
+
+## See also
+
+- [[genre-precision-platformer]] · [[system-grace]] · [[system-accessibility]]
+- `examples/updrift/` — the golden platformer reference; grace canon wired
+  end-to-end.
+- `docs/FUN.md#2-·-precision-platformer-celeste-like` — the movement-trust
+  verify pattern.
+- `docs/JUICE.md` — feel gates for landing, dash, and death choreography.

package/design/10-anchors/civilization.md

@@ -0,0 +1,101 @@
+---
+id: anchor-civilization
+title: Civilization
+kind: anchor
+tags: [4x, turn-based, strategy, snowball, comeback, tech-tree, one-more-turn]
+summary: The 4X "one more turn" engine — many shallow-per-turn systems layered into a deep whole, with victory paths and a snowball you must brake for comebacks.
+use-when: The intent is a layered turn-based strategy game where compounding decisions and multiple win paths drive "just one more turn."
+composes-with: [genre-rts, system-tech-tree, system-economy, pattern-feedback-loops, system-session-structure]
+anchors: []
+verify-with: docs/FUN.md#9-rts-lite
+---
+
+# Civilization
+
+**What it is.** A turn-based 4X (eXplore, eXpand, eXploit, eXterminate) where you
+grow a civilisation across millennia. No single system is deep per turn; the depth
+is **layering** — economy, tech, culture, diplomacy, military all tick together,
+and each turn's small choices *compound*. Multiple **victory paths** (conquest,
+science, culture…) mean many strategies win. The famous symptom is "**one more
+turn**": the next decision always dangles.
+
+**Player fantasy.** Author of history. You steer a people from a single settler to
+a space-faring empire, and every era you unlock a new *layer* of play. The pull is
+the compounding — a good decision twenty turns ago is still paying off — and the
+horizon always holding one more reachable milestone.
+
+## Design DNA
+
+The engine is **layered compounding on a turn clock**. Each system is simple in
+isolation; interacting, they generate deep decisions and long-horizon plans. A
+turn's reward is *always* incremental and *always* sets up the next — the
+"one-more-turn" hook is a deliberate [[pattern-pacing-and-tension]] design: never
+end a turn without dangling an imminent payoff. The central risk is the
+**snowball**: 4X economies runaway ([[pattern-feedback-loops]]), so a leader
+accelerates away and the game dies at turn 100 of 300. Civ's answer is
+**comeback/catch-up brakes** — tech diffusion, war weariness, per-city upkeep — so
+a lead is real but not sealed.
+
+## Load-bearing structures
+
+| Structure | Why it works |
+|---|---|
+| **Layered systems** | Economy/tech/culture/military each shallow per turn; interacting, they yield deep plans. Depth from breadth, not one hard system. → [[pattern-emergence]]. |
+| **Multiple victory paths** | Science/culture/domination each win; players pick a lane, and the AI must contest all of them. → [[system-build-diversity]]. |
+| **Tech tree across eras** | Research gates whole new layers of play; each era is a legible power/options spike. → [[system-tech-tree]]. |
+| **"One more turn" hook** | Every turn ends with an imminent payoff dangling — a growth finishing next turn, a wonder two off. → [[pattern-pacing-and-tension]]. |
+| **Snowball with brakes** | Runaway economy (positive loop) is deliberately countered (diffusion, upkeep, war weariness) to keep games contestable. → [[pattern-feedback-loops]]. |
+| **Perfect-information turns** | Turn-based and pure-state; the whole game replays deterministically and clones for AI scoring. (FUN.md law 7). |
+
+## What to steal
+
+- **Layering over depth**: many *simple* interacting systems out-produce one
+  complex system for emergent decisions — and each is separately verifiable.
+- The **"one more turn" pacing rule**: never let a turn end without an imminent,
+  visible payoff. This is the retention engine. → [[pattern-pacing-and-tension]].
+- **Multiple win paths** as replayability *and* as a balance test: the AI must
+  contest each lane, so no single strategy dominates. → [[system-build-diversity]].
+- **Snowball brakes**: pair every runaway positive loop with an explicit
+  catch-up mechanic, or the game decides itself early. → [[pattern-feedback-loops]].
+
+## What's just theme (drop it)
+
+- The **real-world history** — leaders, wonders, and civs are flavour on a
+  layered-4X spine; a fantasy, sci-fi, or abstract skin plays identically.
+- **The exact five victory types** — the principle is "≥2 viable lanes," not the
+  specific set. → [[world-theme-vectors]].
+- **Hex map / literal units** — one presentation of "regions you develop"; a
+  node-graph or card layout carries the same layering.
+- **Scale (millennia, huge maps)** — the loop works at any scale; a single-session
+  micro-4X keeps the DNA. → [[system-session-structure]].
+
+## Composes into
+
+- [[genre-rts]] — the turn-based strategy neighbour (shared macro/economy DNA;
+  Civ trades real-time mass for layered turns).
+- [[system-tech-tree]] — era research as the layer-unlock spine.
+- [[system-economy]] — the compounding faucets/sinks that fund every lane.
+- [[pattern-feedback-loops]] — the snowball and its required comeback brakes.
+- [[pattern-pacing-and-tension]] — "one more turn" as an explicit pacing design.
+
+## Twist seams
+
+- **Civ but one session, one sitting** *(structure / constraint)* — a micro-4X
+  that resolves in 30 minutes; layering without the epic length. Pairs with
+  [[system-session-structure]].
+- **Civ but you're one citizen** *(perspective)* — history from the ground: the
+  empire is the *environment*, you a person living through its eras. Pairs with
+  [[anchor-stardew-valley]].
+- **Civ but the map is a deck** *(mechanic-swap)* — replace the hex world with a
+  drafted card layout of provinces; layering survives the medium swap. Pairs with
+  [[genre-deckbuilder]].
+- **Civ but comeback-only** *(constraint)* — always play the underdog; the twist is
+  a snowball you fight *against*, inverting the fantasy. Pairs with
+  [[pattern-feedback-loops]].
+
+## See also
+
+- [`docs/FUN.md#9-rts-lite`](../../docs/FUN.md) — strategy is the balance test; the
+  intended line must beat the null line; pure-state turns clone for AI scoring.
+- [[system-tech-tree]] · [[anchor-age-of-empires]] (real-time cousin) ·
+  [[pattern-feedback-loops]].

package/design/10-anchors/dead-cells.md

@@ -0,0 +1,125 @@
+---
+id: anchor-dead-cells
+title: Dead Cells
+kind: anchor
+tags: [metroidvania, roguelite, permanence, run-based, combat, unlock-pool, biome-branch]
+summary: Metroidvania fused with roguelite — runs are impermanent, but permanent unlocks fold discoveries into the pool, so the world persists even when the run doesn't.
+use-when: Designing a run-based action game that still wants a growing, permanent sense of world and mastery across deaths.
+composes-with: [genre-metroidvania, genre-roguelike, system-meta-progression, system-combat-model]
+anchors: [anchor-dead-cells]
+verify-with: docs/FUN.md#3-·-metroidvania
+---
+
+# Dead Cells
+
+**What it is.** A fast, weighty 2D action game where each run threads a
+randomised sequence of biomes toward a boss — you die and lose the run, but
+the *permanent* layer (unlocked weapons, blueprints, shortcuts, mutations)
+grows every time.
+
+**Player fantasy / why it's fun.** *The run is temporary; my mastery and my
+arsenal are forever.* The pull is **permanence over impermanence**: roguelites
+reset you, Dead Cells lets you *keep the map of possibility*. Combat is the
+tight loop; the expanding unlock pool is the reason a loss still feels like a
+step forward.
+
+## Design DNA
+
+Take the **metroidvania's locked-door promise** and the **roguelite's fresh
+run** and reconcile them: the *layout* resets, but *access* accretes.
+Permanent ability-gates (the metroidvania spine) unlock new biome branches; a
+**blueprint pool** folds every rare drop you carry to the end into all future
+runs. So the world map is roguelike (never the same twice) while the *world of
+options* is metroidvania (only ever grows).
+
+The reconciliation is the whole insight: these two genres seem opposed — one
+is about *permanence and mastery of a fixed space*, the other about
+*impermanence and fresh variance* — and Dead Cells resolves the tension by
+splitting *what resets* from *what accretes*. Geometry is disposable;
+capability is forever. A losing run still expands the pool of what *can* drop,
+so the sense of loss is real but never total. That single split is more
+portable than any specific mechanic in the game.
+
+Combat is the second engine: fluid, roll-cancellable, weapon-defined,
+punishing but readable. It's what makes the moment-to-moment worth the
+disposable runs — a great feel is the price of admission for a structure this
+loss-heavy.
+
+## Load-bearing structures
+
+| Structure | Why it works |
+|---|---|
+| **Impermanent run, permanent pool** | Layout resets each run; the *set of things that can appear* only grows. A loss still advances the account. [[system-meta-progression]]. |
+| **Permanent ability-gates unlock branches** | Metroidvania traversal powers (vine, teleport) are meta-unlocks that open new biome *routes* — the roguelite map has a metroidvania skeleton. [[genre-metroidvania]]. |
+| **Blueprint economy** | Rare recipes drop mid-run but only *bank* if you survive the exit — carry-it-out risk gates the pool's growth. [[pattern-risk-reward]]. |
+| **Roll-cancellable weighty combat** | Every attack commits, but the roll's i-frames let skilled play cancel — the skill ceiling is timing, not spam. [[system-combat-model]] + [[system-grace]]. |
+| **Branching biome routes with tradeoffs** | Choose the harder path for better loot / a timed-door bonus — spatial [[pattern-risk-reward]] baked into the map. |
+| **Mutations = per-run build** | Run-scoped modifiers layered on permanent gear give each descent an identity. [[system-build-diversity]]. |
+| **Scaling-stat commitment (colours)** | Investing in one damage stat scales your matching gear — soft build-locking that makes drafts matter. |
+
+## What to steal
+
+- **Separate what resets from what accretes.** The layout can be fully
+  roguelike while the *pool of possibilities* is strictly monotonic. This is
+  the whole trick — a loss must grow the account.
+- **Meta-unlock traversal powers that open new routes**, not just stat boosts
+  — the metroidvania gate as a roguelite reward.
+- **Carry-it-to-the-exit banking.** Make pool-growth resources survive only if
+  you do — risk that gates permanence.
+- **Roll-cancel combat:** committed attacks + a graceful escape verb. Weight
+  and readability without stiffness. Wire via [[system-grace]].
+- **Branching routes with explicit risk/reward** (harder biome = better loot,
+  timed doors that reward speed). Spatial risk/reward baked into the map means
+  the choice happens *before* the fight, not just during it.
+- **Soft build-locking via a scaling stat.** Let investing in one damage
+  colour scale the matching gear, so drafts commit the player to an identity
+  without hard class walls — a lighter [[system-build-diversity]] lever than
+  fixed classes.
+
+## What's just theme (drop it)
+
+- **The prisoner-island / headless-body fiction.** Minimal and cosmetic; the
+  loop needs no story.
+- **The specific biomes.** *Branch-with-tradeoff* is structural; "Toxic Sewers
+  vs Promenade" is flavour.
+- **Cells-as-currency naming.** A meta-currency by any name; see
+  [[system-economy]].
+- **The exact weapon list.** Weapon *archetypes* (fast/heavy/ranged/trap) are
+  structural; the specific gear is content — [[system-build-diversity]].
+
+## Composes into
+
+- [[genre-metroidvania]] — supplies the gate-and-branch spine.
+- [[genre-roguelike]] — supplies the fresh-run layout.
+- [[system-meta-progression]] — the accreting blueprint pool is the exemplar
+  of "loss still advances."
+- [[system-combat-model]] — roll-cancel weighty combat.
+- [[system-build-diversity]] — mutations + stat-scaling commitment.
+
+## Twist seams
+
+- **Dead Cells but the *world* is permanent and only *you* reset**
+  *(structure)* — invert it: the map persists metroidvania-style, and
+  roguelite variance lives in your loadout. Now it's Metroid with disposable
+  builds.
+- **Dead Cells but banking is social** *(mechanic-swap)* — blueprints you
+  carry out drop into a *shared* pool other runs (or players) inherit;
+  permanence becomes communal. Feeds [[system-coop-and-competition]].
+- **Dead Cells but pacifist** *(constraint / tonal)* — the roll-cancel verb
+  becomes evasion-only; biomes are navigated, not cleared; the pool grows with
+  *routes discovered*, not weapons. Bends combat out entirely and pulls toward
+  [[genre-exploration]].
+- **Dead Cells but the biomes are a deck you draft the run's route from**
+  *(mechanic-swap)* — instead of walking a randomised map, you play
+  biome-cards to *assemble* the descent; the accreting pool becomes a growing
+  card collection. Pulls in [[genre-deckbuilder]] over the traversal.
+
+## See also
+
+- [[genre-metroidvania]] · [[genre-roguelike]] · [[system-meta-progression]] ·
+  [[system-combat-model]]
+- `docs/FUN.md#3-·-metroidvania` — negative gate proofs (ungated maneuver must
+  fail).
+- `examples/kintsugi/` — the metroidvania reference: gate-and-branch world
+  graph.
+- `sandboxes/procgen-lab/` — seeded biome-branch generation.

package/design/10-anchors/factorio.md

@@ -0,0 +1,100 @@
+---
+id: anchor-factorio
+title: Factorio
+kind: anchor
+tags: [automation, logistics, factory, throughput, optimization, scaling, engineering]
+summary: Automation/logistics sim where the factory itself is the toy — you build the machine that builds, and the fun is untangling throughput bottlenecks that scale forever.
+use-when: The intent is a systems/optimization game about building processes rather than acting them out; the player designs, the machine executes.
+composes-with: [genre-incremental, system-resource-loops, system-crafting, system-tech-tree, system-emergent-systems]
+anchors: []
+verify-with: docs/FUN.md#14-incrementalidle
+---
+
+# Factorio
+
+**What it is.** A game about building the machine that plays the game. You
+hand-craft the first few items, then **automate** their production, then automate
+the automation — until you're not moving resources, you're *designing the system
+that moves them*. The factory is the toy; the fun is diagnosing and fixing
+**bottlenecks** in a process you built.
+
+**Player fantasy.** The engineer's high: a mess of belts becomes a legible,
+humming machine because *you* untangled it. Every problem is one you created by
+succeeding — demand outgrew supply — and every fix is a small act of design you
+get to admire running on its own.
+
+## Design DNA
+
+The core verb isn't *do*, it's **automate** — replace your own labour with a
+standing process, then find the constraint the new scale exposed. Factorio is an
+**incremental** at heart ([[genre-incremental]]) but you build the production
+curve by hand instead of buying it. The loop is self-fueling: solving one
+bottleneck raises throughput until a *downstream* stage becomes the new
+bottleneck. The factory is a second-order machine — you don't place outcomes, you
+place rules, and the outcomes **emerge** ([[pattern-emergence]]).
+
+## Load-bearing structures
+
+| Structure | Why it works |
+|---|---|
+| **Automate-your-own-labour** | The verb is building a process, not performing it; mastery is designing systems, not reflexes. |
+| **Throughput bottlenecks** | Every solved constraint reveals the next one downstream — an endless, self-generated problem queue. → [[system-resource-loops]]. |
+| **Deep crafting chains** | Ore→plate→gear→belt→machine; each tier consumes the last, so scaling one forces scaling all. → [[system-crafting]]. |
+| **Ratios & balancing** | The optimisation meat: N miners feed M smelters feed K assemblers. Legible math with infinite depth. |
+| **Tech tree funded by production** | Research consumes your output, so teching *is* a sink that pressures throughput. → [[system-tech-tree]]. |
+| **Spatial logistics** | Belts/pipes make routing a physical, visible puzzle — the factory's shape *is* its performance. |
+| **Emergent complexity from few parts** | A handful of primitives (belt, inserter, assembler) compose into unbounded designs. → [[pattern-emergence]]. |
+
+## What to steal
+
+- The **automate-then-optimise loop**: give the player a verb, then let them
+  *replace themselves* at it. The game becomes about designing, not grinding.
+- **Self-generated bottlenecks**: never hand the player a task list; let success
+  create the next problem. The best difficulty curve is one the player builds.
+- **Legible ratios**: expose the math (this feeds that at rate R) so optimisation
+  is *knowable*, not guesswork. Mastery = reading the machine.
+- **Deep chains as pacing**: each crafting tier is a natural session/era boundary,
+  the way [[genre-incremental]] uses eras — no unlock deserts (FUN.md §14).
+
+## What's just theme (drop it)
+
+- The **alien-planet/pollution fiction** — flavour. The loop is medium-agnostic:
+  a kitchen, a bank, a bloodstream, a bureaucracy all work.
+- **Combat / biters** — a pressure valve bolted on; many great automation games
+  ship without it. Cut it until the factory is fun alone.
+- **3D/real-time-continuous** — belts can tick discretely. The sim is pure state
+  over throughput; the presentation is [[pattern-juice-choreography]] on top.
+- **Literal belts** — spatial routing is one expression of "connect producers to
+  consumers." Graph/abstract layouts carry the same puzzle.
+
+## Composes into
+
+- [[genre-incremental]] — the parent loop (production curve, no deserts), except
+  the player *builds* the curve.
+- [[system-resource-loops]] — the gather→convert→spend chains and their
+  bottlenecks are the whole game.
+- [[system-crafting]] — recipe chains with combinatorial depth.
+- [[system-tech-tree]] — research as the throughput sink that keeps you scaling.
+- [[pattern-emergence]] — few primitives, unbounded designs; the second-order toy.
+
+## Twist seams
+
+- **Factorio but on a run timer** *(structure)* — roguelite: each run is a fresh
+  map and a scoring throughput target; blueprints are your meta-progression.
+  Pairs with [[system-meta-progression]].
+- **Factorio but you route grief, not iron** *(theme + tonal)* — an emotional or
+  bureaucratic "factory" where the resource is something human; the bend
+  recolours every belt. See [[process-the-twist]].
+- **Factorio but one screen, one machine** *(constraint)* — no sprawl; optimise a
+  single fixed footprint, puzzle-tight. Pairs with [[genre-grid-puzzle]].
+- **Factorio but two players share one factory** *(perspective)* — coop where the
+  bottleneck is *communication* about who owns which subsystem. Pairs with
+  [[genre-coop-chaos]].
+
+## See also
+
+- [`docs/FUN.md#14-incrementalidle`](../../docs/FUN.md) — payback ratios flat
+  across tiers; UI intent is an action; no unlock deserts; balance-sim the arc.
+- [`sandboxes/procgen-lab`](../../sandboxes/procgen-lab) — resource-field
+  generation for map variety.
+- [[genre-incremental]] · [[system-resource-loops]] · [[system-crafting]].