@codincod/ornament 0.0.0-stage → 0.2.0

package/src/reef.ts

@@ -0,0 +1,945 @@
+/**
+ * A reef: one mound of rock, and everything that has taken a place on it.
+ *
+ * The simulation behind a reef, kept free of the DOM the way `flora.ts` is, and
+ * built on the same drawing contract: every coral on it is a handful of
+ * tapering strokes from one base, so anything that can already draw a `Twig`
+ * can draw this without being told what a reef is.
+ *
+ * ## Why a reef is not more plants
+ *
+ * `flora.ts` sows the bed: corals scattered along the sand, each standing on
+ * its own and none of them aware of the others. That is what a bed looks like,
+ * and it is not what a reef looks like. A reef is a place. It has a body of its
+ * own that stands up out of the ground, it has a top and a face and a foot, and
+ * every living thing on it is somewhere particular on that body, because where
+ * you are on a reef decides whether you can live there at all.
+ *
+ * So the mound comes first and the corals are placed against it. Each one is
+ * handed the rock and asks it what settles where anything grows: how high am I,
+ * and how hard does the water run here. A whip wants the swept crest and a
+ * leather coral wants the sheltered foot, and neither of them is put there by
+ * this file. `SORTS` says what each kind can live with, and the coral finds its
+ * own spot or does not grow.
+ *
+ * ## Health is how many kinds, not how many corals
+ *
+ * A reef covered in one coral is a reef in trouble, whatever it looks like from
+ * a distance. What a healthy one has is a great many kinds crowded together,
+ * each holding the ground it can hold, and that is also the only thing that
+ * makes a drawing of one read as alive: a hundred copies of one silhouette is
+ * wallpaper at any density. Every kind in `SORTS` gets first refusal on the
+ * rock before any kind is placed twice, and `Reef.health` is the share of them
+ * that found somewhere. Nearly every reef comes out whole. A cramped one does
+ * not, and the figure is there to say so rather than to be tuned away.
+ *
+ * ## What sits in front of the rock
+ *
+ * A mound drawn in profile has a skyline, and a coral placed on the skyline is
+ * a coral on the top. Real ones are all over the front of it as well, which in
+ * this projection means standing inside the silhouette and nearer the glass.
+ * That is `Sort.cling`: fans and whips take the face, brains and tables take
+ * the top, and the reef comes out with a front and a back rather than a fringe
+ * along one line.
+ *
+ * ## The anemone is the bed's animal, standing on rock
+ *
+ * There is one anemone in this ornament and `flora.ts` owns it. It sows its own
+ * on open sand; the reef places the same creature on the mound and hands a
+ * clownfish the address. Two drawings of one animal in one picture is the
+ * repeat this codebase argues against everywhere else, and the reader who sees
+ * both would notice they were not the same creature before working out why.
+ *
+ * What that costs here is a second way of being drawn. Coral arrives as a
+ * stencil, because a skeleton is a shape that holds. An anemone arrives as a
+ * stalk and a crown of tentacles, recut every step, because it is an animal and
+ * an animal that held still would be a dead one.
+ *
+ * ## A coral takes its size from its own distance
+ *
+ * The mound keeps its size whatever distance it stands at, because it is ground
+ * and ground does not shrink: a hill at the back of a seabed is not drawn
+ * smaller, it is drawn higher up the box and hazier, and `seabed.ts` does that
+ * already. What stands on the ground is the other thing entirely, and it has to
+ * shrink or the picture has no distance in it.
+ *
+ * So a coral is sized by the mound it grew on and then by how far back it is
+ * standing, straight through, the way `flora.ts` sizes the corals it sows on
+ * the sand. Anything softer than straight through is what put a reef at the
+ * back of the water with corals on it the size of the ones at the front, which
+ * is the one fault in a scene that everybody notices and nobody can name.
+ *
+ * ## Nothing hard ever moves
+ *
+ * Stony coral is a skeleton, so it holds whatever shape it grew into, and the
+ * step here skips it entirely. What moves is the soft half: fans, whips, soft
+ * corals and the anemones, all leaning together as the swell crosses the reef
+ * and each on its own phase, so the crest breathes rather than pulsing.
+ *
+ * Everything is seeded, so the same seed builds the same reef twice.
+ */
+
+import {
+  type Blade,
+  crown,
+  crownAt,
+  crownSwept,
+  gathered,
+  type Tentacle,
+  type Twig,
+} from "./flora.ts"
+import { makeNoise2, makeRandom, stir } from "./perlin.ts"
+import type { Point } from "./seabed.ts"
+
+export type HeadKind =
+  | "anemone"
+  | "brain"
+  | "elkhorn"
+  | "fan"
+  | "leather"
+  | "plate"
+  | "staghorn"
+  | "table"
+  | "tube"
+  | "whip"
+
+/**
+ * One thing growing on the reef, wherever it found room.
+ *
+ * The same shape of fact as a `Plant`, on purpose. A renderer strokes `twigs`
+ * at `scale` about `(x, y)`, turned by `lean` and then by `bend`, and needs to
+ * know nothing else about what it is drawing.
+ */
+export interface Head {
+  /** How far it is leaning in the swell, in radians. */
+  bend: number
+  /**
+   * Whatever else it is made of. Empty for a stencil.
+   *
+   * A `Plant`'s field, and the same idea: a renderer strokes every line a head
+   * hands it at the head's own `girth` and has no business knowing which of
+   * them is a tentacle. What has one of these is an animal rather than a
+   * skeleton, and it is drawn the way the bed's are rather than being stamped.
+   */
+  blades: Blade[]
+  /**
+   * How many times this head has been drawn again.
+   *
+   * The only thing a renderer has to watch, and `Plant.cut` for the rock. A
+   * skeleton bumps it once and never again, which is most of what grows here:
+   * the kinds with no `sway` are stone and have nothing that moves at all.
+   */
+  cut: number
+  /** 0 is as far off as this water goes, 1 is up against the glass. */
+  readonly depth: number
+  /** How thick to stroke `points` and `blades`, in the drawing's own units. */
+  readonly girth: number
+  readonly kind: HeadKind
+  /** Its own phase in the swell, so neighbours never breathe together. */
+  readonly lane: number
+  /** How far off upright it grew, in radians. Nothing on a reef is plumb. */
+  readonly lean: number
+  /** Its stalk, root to mouth, for a head that has one. Empty for a stencil. */
+  readonly points: readonly Point[]
+  /** px per unit of its drawing. */
+  readonly scale: number
+  /** How wide it stands, in px. What its neighbours were asked about. */
+  readonly span: number
+  /** Its drawing, from `SHAPES`. */
+  readonly twigs: readonly Twig[]
+  readonly x: number
+  readonly y: number
+}
+
+export interface Reef {
+  /** The rock's own skyline, left to right, for a renderer to close and fill. */
+  readonly crest: readonly Point[]
+  /** How far back the mound stands. Everything on it is at least this far. */
+  readonly depth: number
+  readonly heads: readonly Head[]
+  /** The share of the kinds there are that found somewhere to live. */
+  readonly health: number
+  /**
+   * Whether a point is over this reef, clear of the rock, and near enough to
+   * count as being on it.
+   *
+   * The question anything that lives here asks before it goes anywhere. It is
+   * the reef's to answer rather than the animal's, because the reef is the one
+   * that knows where it ends. `depth` is how far forward the asker is, and it
+   * matters for the reason `surfaceAt` gives.
+   */
+  holds(x: number, y: number, depth?: number): boolean
+  resize(width: number, height: number, floor: (x: number, depth?: number) => number): void
+  /** Where the rock reaches, left and right, in px. */
+  readonly span: readonly [number, number]
+  step(seconds: number): void
+  /**
+   * The top of the rock at x, or the ground where the reef does not reach.
+   *
+   * `depth` is how far forward the thing standing there is, and it is not a
+   * decoration: the mound has a near face that falls away towards the glass, so
+   * the rock is lower in front of the crest than at it, and anything standing
+   * further forward than the reef itself has less of it overhead. It defaults
+   * to the reef's own distance, which is the skyline `crest` is cut from.
+   */
+  surfaceAt(x: number, depth?: number): number
+  /** A long stretch of swell in one go, for a caller winding a scene forward. */
+  wind(seconds: number): void
+}
+
+export interface ReefOptions {
+  /** The ground at x, at a given distance; `seabed.floorAt`. */
+  floor: (x: number, depth?: number) => number
+  /** How many corals to try to grow, once every kind has had its one. */
+  heads?: number
+  height: number
+  seed: number
+  /**
+   * How far a head may move from its last drawing before it is drawn again, in
+   * px.
+   *
+   * `FloraOptions.tolerance` for the rock, and the same bargain. Most of what
+   * grows here is a skeleton that never moves, so most of the reef costs one
+   * comparison a step once it has been drawn once; what sways pays for the
+   * frames it is actually using. At nothing every head is recut on every step,
+   * which is how this behaved before.
+   */
+  tolerance?: number
+  width: number
+}
+
+/**
+ * What each kind of coral needs, and what it does with what it gets.
+ *
+ * The whole of the placement is in this table. There is one routine that grows
+ * a coral and it reads these numbers; a kind that wanted its own branch would
+ * be a second reef wearing the first one's interface.
+ *
+ * What decides everything is `perch` and `flow`. A reef is banded, and the
+ * bands are not a matter of taste: the crest is swept by every wave that
+ * arrives and only the strong-boned and the flexible hold there, while the foot
+ * is still and shaded and belongs to the soft and the spreading. Get those
+ * right and the reef looks studied from across a room without any one coral
+ * being worth looking at.
+ */
+interface Sort {
+  /**
+   * How far down the face it stands, as a share of the mound's rise.
+   *
+   * Taken against how much rock there is where it landed, so it comes to
+   * nothing out on the apron. Only a face can be clung to, and the ground
+   * beside a reef is not one: a sponge out there is standing on the flat, and
+   * one that had kept its share of the face would be standing in the water
+   * below the reef with nothing under it.
+   */
+  readonly cling: number
+  /** The run of water it will take, still to swept. */
+  readonly flow: readonly [number, number]
+  /** The band of rock it will take, foot to crest. */
+  readonly perch: readonly [number, number]
+  /** How much clear water it wants around it, against its own width. */
+  readonly room: number
+  /** How big it grows against what `GROWTH` allows, smallest to largest. */
+  readonly size: readonly [number, number]
+  /** How far it leans in the swell, in radians. A skeleton is 0. */
+  readonly sway: number
+  /** How many of it there are, once every kind has its one. */
+  readonly weight: number
+  /** How wide its drawing is, in its own units. */
+  readonly width: number
+}
+
+const SORTS: Readonly<Record<HeadKind, Sort>> = {
+  /** Soft, sheltered, and the only thing here anything lives inside. */
+  anemone: {
+    cling: 0.3,
+    flow: [0, 0.78],
+    perch: [0.15, 0.9],
+    room: 1.6,
+    size: [1, 1.5],
+    sway: 0.07,
+    weight: 3,
+    width: 28,
+  },
+  /** A dome that holds anywhere, and the one shape here with a body. */
+  brain: {
+    cling: 0.15,
+    flow: [0, 1],
+    perch: [0.1, 1],
+    room: 1.1,
+    size: [0.6, 1.5],
+    sway: 0,
+    weight: 5,
+    width: 30,
+  },
+  /** Broad blades into the surge, which is the one place it beats anything. */
+  elkhorn: {
+    cling: 0,
+    flow: [0.55, 1],
+    perch: [0.6, 1],
+    room: 1.4,
+    size: [0.7, 1.2],
+    sway: 0,
+    weight: 3,
+    width: 42,
+  },
+  /** A mesh held across the current, so it stands where the current runs. */
+  fan: {
+    cling: 0.55,
+    flow: [0.45, 1],
+    perch: [0.3, 0.95],
+    room: 1.3,
+    size: [0.6, 1.3],
+    sway: 0.1,
+    weight: 4,
+    width: 34,
+  },
+  /** Soft and lobed, down at the foot where nothing is pulling at it. */
+  leather: {
+    cling: 0.4,
+    flow: [0, 0.45],
+    perch: [0, 0.5],
+    room: 1.2,
+    size: [0.7, 1.2],
+    sway: 0.07,
+    weight: 3,
+    width: 26,
+  },
+  /** Spread flat to catch what light gets down there. */
+  plate: {
+    cling: 0.35,
+    flow: [0, 0.55],
+    perch: [0, 0.55],
+    room: 1.5,
+    size: [0.7, 1.3],
+    sway: 0,
+    weight: 3,
+    width: 46,
+  },
+  /** Fine branches, which snap in surge, so never at the crest. */
+  staghorn: {
+    cling: 0.1,
+    flow: [0, 0.6],
+    perch: [0.35, 0.9],
+    room: 1.3,
+    size: [0.6, 1.1],
+    sway: 0,
+    weight: 4,
+    width: 36,
+  },
+  /** A floor of its own, held up into the light at the top of the mound. */
+  table: {
+    cling: 0,
+    flow: [0.2, 0.9],
+    perch: [0.7, 1],
+    room: 1.7,
+    size: [0.7, 1.2],
+    sway: 0,
+    weight: 2,
+    width: 46,
+  },
+  /** Sponge, not coral, and it takes the shaded foot nothing else wants. */
+  tube: {
+    cling: 0.5,
+    flow: [0, 0.4],
+    perch: [0, 0.45],
+    room: 1.2,
+    size: [0.5, 0.9],
+    sway: 0.05,
+    weight: 3,
+    width: 24,
+  },
+  /** One line into the flow, and the thing on this reef that moves most. */
+  whip: {
+    cling: 0.25,
+    flow: [0.5, 1],
+    perch: [0.4, 1],
+    room: 0.9,
+    size: [0.7, 1.4],
+    sway: 0.22,
+    weight: 3,
+    width: 12,
+  },
+}
+
+/** Every kind there is, which is what `Reef.health` is measured against. */
+export const KINDS = Object.keys(SORTS) as readonly HeadKind[]
+
+/**
+ * What each kind is, as strokes from one base.
+ *
+ * `flora.ts` argues for the idiom and it holds here: round caps on tapering
+ * strokes read as a growing thing without a single closed outline being drawn,
+ * and a kind is told apart from its neighbour by how wide it gets against how
+ * tall and how thick the strokes are. Nose-up, base at the origin, in the same
+ * units the bed's corals are drawn in, so one renderer serves both.
+ */
+export const SHAPES: Readonly<Record<HeadKind, readonly Twig[]>> = {
+  /** None. It is the one animal on the rock, and an animal is not a stamp. */
+  anemone: [],
+  brain: [
+    { d: "M-13 0 C-13 -8 -8 -13 -1 -14", width: 7 },
+    { d: "M-6 0 C-7 -7 -4 -11 0 -12", width: 7 },
+    { d: "M6 0 C7 -7 5 -11 1 -13", width: 7 },
+    { d: "M13 -1 C13 -8 8 -13 1 -14", width: 7 },
+  ],
+  elkhorn: [
+    { d: "M0 0 C0 -5 -1 -9 -2 -12", width: 7 },
+    { d: "M0 0 C-1 -10 -6 -16 -14 -24", width: 6 },
+    { d: "M0 0 C1 -12 4 -20 10 -30", width: 5.5 },
+    { d: "M-8 -14 C-14 -18 -20 -20 -26 -22", width: 5 },
+    { d: "M5 -16 C11 -21 17 -23 24 -25", width: 4.5 },
+  ],
+  fan: [
+    { d: "M0 0 C0 -8 -2 -12 -3 -16", width: 3.5 },
+    { d: "M-3 -16 C-9 -20 -13 -24 -15 -30", width: 2 },
+    { d: "M-3 -16 C-6 -22 -7 -27 -8 -32", width: 2 },
+    { d: "M-3 -16 C0 -22 1 -27 1 -33", width: 2 },
+    { d: "M-3 -16 C3 -21 7 -25 10 -30", width: 2 },
+    { d: "M-3 -16 C6 -19 11 -21 15 -25", width: 2 },
+  ],
+  leather: [
+    { d: "M0 0 C-2 -6 -6 -9 -9 -15", width: 8 },
+    { d: "M0 0 C0 -7 1 -12 2 -18", width: 8 },
+    { d: "M0 0 C3 -6 7 -9 10 -14", width: 7 },
+  ],
+  plate: [
+    { d: "M0 0 C0 -2 0 -3 0 -4", width: 6 },
+    { d: "M0 0 C-6 -2 -14 -4 -22 -5", width: 5 },
+    { d: "M0 0 C6 -2 14 -4 21 -6", width: 5 },
+    { d: "M-14 -4 C-15 -7 -14 -8 -12 -10", width: 3 },
+    { d: "M15 -5 C17 -7 17 -9 16 -11", width: 3 },
+  ],
+  staghorn: [
+    { d: "M0 0 C-1 -11 -3 -20 -7 -31", width: 4 },
+    { d: "M0 0 C2 -9 5 -17 7 -28", width: 3.5 },
+    { d: "M-4 -19 C-9 -24 -13 -26 -18 -33", width: 2.4 },
+    { d: "M5 -18 C9 -24 13 -25 17 -30", width: 2.4 },
+    { d: "M-2 -8 C-7 -11 -11 -12 -15 -13", width: 2.2 },
+    { d: "M3 -10 C8 -13 11 -15 15 -17", width: 2.2 },
+  ],
+  table: [
+    { d: "M0 0 C-1 -6 -1 -10 0 -13", width: 6 },
+    { d: "M0 -13 C-8 -14 -16 -15 -23 -15", width: 4 },
+    { d: "M0 -13 C8 -14 16 -15 23 -16", width: 4 },
+    { d: "M-12 -15 C-13 -17 -13 -19 -12 -20", width: 2.4 },
+    { d: "M11 -15 C12 -17 12 -19 11 -21", width: 2.4 },
+  ],
+  tube: [
+    { d: "M-8 0 C-9 -8 -9 -14 -8 -19", width: 6 },
+    { d: "M0 0 C-1 -9 -1 -18 0 -25", width: 6.5 },
+    { d: "M8 -1 C9 -7 9 -12 8 -16", width: 5.5 },
+  ],
+  whip: [
+    { d: "M0 0 C-2 -9 -4 -16 -4 -24", width: 2.2 },
+    { d: "M0 0 C1 -12 -1 -24 2 -38", width: 2.6 },
+  ],
+}
+
+/** Where the mound sits across the box, and how much of it it may take. */
+const SEAT_LEAST = 0.26
+
+const SEAT_SPAN = 0.48
+
+const HALF_LEAST = 0.15
+
+const HALF_SPAN = 0.12
+
+/** How high it stands off the ground, as a share of the box. */
+const RISE_LEAST = 0.1
+
+const RISE_SPAN = 0.08
+
+/**
+ * How tall the mound may stand against its own width.
+ *
+ * A reef is a mound and not a tower. On a tall narrow window the height it
+ * would take from the box is more than the width there is to put it on, and
+ * what that builds is a spire with a coral balanced on the top of it.
+ */
+const TALLEST = 0.62
+
+/** How far back it stands. Never up against the glass; it is scenery. */
+const DEPTH_FAR = 0.5
+
+const DEPTH_NEAR = 0.82
+
+/**
+ * The mound's profile: how sharply its sides fall, and how flat its top is.
+ *
+ * A reef is not a hill. What it does is stand up out of the ground at a steep
+ * face and then run nearly level along the top, because the top is where it has
+ * grown up to and stopped, and a dome would say the opposite: that the middle
+ * grew fastest, which is what a pile of sand does and not what a reef does.
+ */
+const BROW = 2.6
+
+const BULGE = 0.5
+
+/** How much taller one end is than the other, so it has a windward side. */
+const LIST = 0.22
+
+/** How many lumps fit across the mound, and how much of its rise they take. */
+const LUMP_CELLS = 3.4
+
+const LUMP_SHARE = 0.24
+
+/** How many points the skyline is cut into. */
+const CREST_STEPS = 96
+
+/** How many corals to grow once every kind has had its one. */
+const HEADS = 52
+
+/**
+ * How far past the rock the reef's own rubble reaches, against its half-width.
+ *
+ * A reef does not stop where the rock stops. What surrounds one is an apron of
+ * its own broken pieces, and the things that want shelter and shade live out
+ * there rather than on the mound: it is the only ground on the whole reef that
+ * is flat, still and low. Without it every soft coral competes for the foot of
+ * the face and most of them lose, which is a reef with a bare skirt around it.
+ */
+const APRON = 1.28
+
+/**
+ * How many places a coral will try before it gives up and does not grow.
+ *
+ * It gives up rather than settling, which is the whole of why the reef comes
+ * out banded. A whip that took the first spot it was offered would end up at
+ * the foot as often as at the crest, and a reef where everything is anywhere is
+ * a reef with no bands in it, which is to say a heap.
+ */
+const TRIES = 40
+
+/** How far the reef's own water reaches past the rock, against its half-width. */
+const REACH = 0.34
+
+/** How far apart in height counts as a shelf of its own, against a width. */
+const TIER = 0.55
+
+/** How far above the crest still counts as being over the reef. */
+const HEADROOM = 0.9
+
+/** How far a coral may have grown off upright, in radians. */
+const LEAN = 0.22
+
+/**
+ * How big a coral grows against the mound it is on, in scale per px of rise.
+ *
+ * Against the mound rather than in px, because the mound is the only thing on
+ * screen a coral can be judged against. Sized absolutely, the same coral is a
+ * boulder on a narrow window and a pebble on a wide one, and the reef stops
+ * being a reef at either end: a handful of shapes filling it, or a bald rock
+ * with a rash on it.
+ */
+const GROWTH = 0.0072
+
+/**
+ * How tall an anemone's column stands, in the units the drawings are cut in.
+ *
+ * Short and stout, which is what `flora.ts` argues for at greater length: what
+ * an anemone has instead of height is a crown, and a tall one is a plant.
+ */
+const COLUMN = 16
+
+/** How thick a crown is stroked, as a share of its column. `flora.ts` again. */
+const GIRTH = 0.15
+
+/** How fast a crown works through its own feeling. */
+const CROWN_RATE = 1.1
+
+/** How fast the swell crosses the reef, and how many of it fit across. */
+const SWELL_RATE = 0.55
+
+const SWELL_CELLS = 1.8
+
+/** How much of the lean is the swell passing and how much is the head's own. */
+const SWELL_SHARE = 0.6
+
+/** Where an anemone's stalk leaves the rock, and where its crown opens. */
+const ROOT: Point = { x: 0, y: 0 }
+
+const MOUTH: Point = { x: 0, y: -COLUMN }
+
+/** How far a head moves before it is worth drawing again, in px, by default. */
+const TOLERANCE = 0.25
+
+/**
+ * How far each kind's drawing reaches from where it is rooted, in its own units.
+ *
+ * Read off the drawings rather than written down beside them. A shape nudged by
+ * eye and a number kept by hand part company on the first edit, and nothing
+ * anywhere says so; this cannot go stale because there is only the one copy.
+ *
+ * Every path in `SHAPES` is an absolute move followed by absolute curves, so
+ * the numbers in it are points. A curve stays inside the hull of its own
+ * control points, which makes the furthest of them a bound on the whole drawing
+ * rather than a sample of it, and a bound is what an estimate of movement wants
+ * to be wrong in the safe direction.
+ *
+ * An anemone has no drawing here, and its reach is asked of the crown it was
+ * dealt instead, since a crown is dealt per animal rather than per kind.
+ */
+const REACHES = ((): Readonly<Record<HeadKind, number>> => {
+  const reaches = {} as Record<HeadKind, number>
+  for (const kind of KINDS) reaches[kind] = furthest(SHAPES[kind])
+  return reaches
+})()
+
+function furthest(twigs: readonly Twig[]): number {
+  let worst = 0
+
+  for (const twig of twigs) {
+    const numbers = twig.d.match(/-?\d+(?:\.\d+)?/g) ?? []
+    for (let at = 0; at + 1 < numbers.length; at += 2) {
+      worst = Math.max(worst, Math.hypot(Number(numbers[at]), Number(numbers[at + 1])))
+    }
+  }
+
+  return worst
+}
+
+/** A floor for the box, so a sliver of a window never divides by nothing. */
+const MIN_SPAN = 1
+
+export function createReef(options: ReefOptions): Reef {
+  const noise = makeNoise2(options.seed ^ 0x2b91)
+  const gust = makeNoise2(options.seed ^ 0x5ce3)
+
+  let width = Math.max(MIN_SPAN, options.width)
+  let height = Math.max(MIN_SPAN, options.height)
+  let floor = options.floor
+  let clock = 0
+
+  let middle = width / 2
+  let half = width * HALF_LEAST
+  let rise = height * RISE_LEAST
+  let depth = DEPTH_FAR
+
+  const heads: Head[] = []
+
+  /**
+   * The tentacles each head was dealt, or nothing for anything that is a
+   * stencil.
+   *
+   * Beside the heads rather than on them, the way `flora.ts` keeps a plant's
+   * sway off the `Plant`. What a renderer wants is the crown cut at this
+   * moment, which is `Head.blades`; how it was dealt is this file's business
+   * and stays here.
+   */
+  const crowns: (readonly Tentacle[] | null)[] = []
+
+  const tolerance = Math.max(0, options.tolerance ?? TOLERANCE)
+
+  /**
+   * How far each head's drawing reaches from where it is rooted, in px.
+   *
+   * Its kind's reach at its own scale, except for an anemone, whose drawing is
+   * the column it stands on and the longest tentacle it happened to be dealt.
+   */
+  const reaches: number[] = []
+
+  /**
+   * A head as it stood when it was last drawn.
+   *
+   * The two numbers a drawing is made from and nothing else. Against the last
+   * drawing rather than the last step, because a swell that pushed a whip over
+   * and let it back has not moved it, and a sum of steps says it has.
+   */
+  const held: ({ readonly bend: number; readonly phase: number } | null)[] = []
+
+  let bounds: readonly [number, number] = [0, 0]
+  let health = 0
+
+  /**
+   * How high the rock stands at a place along it, from nothing to all of it.
+   *
+   * The one function everything about this reef is measured in. The crest is
+   * cut from it, a coral's `perch` is read off it, and a fish's ceiling is it
+   * again, so the rock cannot disagree with itself about where its own top is.
+   */
+  function climb(t: number): number {
+    if (Math.abs(t) >= 1) return 0
+    const arch = (1 - Math.abs(t) ** BROW) ** BULGE
+    const lump = 1 + noise(t * LUMP_CELLS, 0) * LUMP_SHARE
+    return Math.min(1, Math.max(0, arch * (1 + LIST * t) * lump))
+  }
+
+  /**
+   * How hard the water runs at a place along it, still to swept.
+   *
+   * Height is most of it, since the crest is what meets the water first, and
+   * the rest is which way the reef faces: one end takes the weather and the
+   * other lies behind the mound in its own shelter.
+   */
+  function swept(t: number): number {
+    return Math.min(1, climb(t) * 0.62 + ((t + 1) / 2) * 0.38)
+  }
+
+  /**
+   * How much of the rock is still overhead at a distance, all of it to none.
+   *
+   * The mound is a body rather than a wall, so its front slopes away from the
+   * crest towards the viewer, and something standing a little forward of it is
+   * standing on the part of that slope which has already come down. At the
+   * glass there is no rock left at all, which is what open water in front of a
+   * reef is.
+   */
+  const standing = (stand: number): number => {
+    if (stand <= depth) return 1
+    return 1 - Math.min(1, (stand - depth) / Math.max(1 - depth, 1e-6))
+  }
+
+  const surfaceAt = (x: number, stand: number = depth): number => {
+    const t = (x - middle) / Math.max(MIN_SPAN, half)
+    return floor(x, stand) - rise * climb(t) * standing(stand)
+  }
+
+  /**
+   * A coral, if it can find anywhere on this rock it can live.
+   *
+   * It is handed the reef and nothing else. Where it ends up is its own answer
+   * to what it is standing on and who is already standing there, which is why
+   * no caller here ever names a place.
+   */
+  function grow(kind: HeadKind, roll: () => number): Head | null {
+    const sort = SORTS[kind]
+
+    for (let tries = 0; tries < TRIES; tries++) {
+      const t = (-1 + roll() * 2) * APRON
+      const perch = climb(t)
+      const flow = swept(t)
+
+      if (perch < sort.perch[0] || perch > sort.perch[1]) continue
+      if (flow < sort.flow[0] || flow > sort.flow[1]) continue
+
+      const x = middle + t * half
+      const face = sort.cling * perch
+      const stand = depth + face * (1 - depth) * roll()
+      const grown = sort.size[0] + roll() * (sort.size[1] - sort.size[0])
+      const scale = grown * rise * GROWTH * stand
+      const span = sort.width * scale
+
+      const y = surfaceAt(x, stand)
+      if (!room(x, y, span * sort.room)) continue
+
+      const tentacles = kind === "anemone" ? crown(stir(roll() * 0xffffff), COLUMN * scale) : null
+
+      const head: Head = {
+        bend: 0,
+        blades: [],
+        cut: 0,
+        depth: stand,
+        girth: tentacles ? COLUMN * GIRTH : 0,
+        kind,
+        lane: roll() * Math.PI * 2,
+        lean: (roll() - 0.5) * LEAN * 2,
+        points: tentacles ? [ROOT, MOUTH] : [],
+        scale,
+        span,
+        twigs: gathered(SHAPES[kind]),
+        x,
+        y,
+      }
+
+      heads.push(head)
+      crowns.push(tentacles)
+      held.push(null)
+      reaches.push(
+        tentacles
+          ? COLUMN * scale * (1 + Math.max(...tentacles.map((one) => one.span)))
+          : REACHES[kind] * scale,
+      )
+      return head
+    }
+
+    return null
+  }
+
+  /**
+   * Whether a coral of that size would be standing on one already there.
+   *
+   * Height is half the question, and leaving it out was what made the first
+   * reef a row. A face has shelves up it, and a fan on one shelf is no argument
+   * against a sponge on the shelf below however nearly they share a column, so
+   * two corals only crowd each other if they are at much the same height as
+   * well as much the same place.
+   */
+  function room(x: number, y: number, want: number): boolean {
+    for (const other of heads) {
+      const near = (want + other.span) / 2
+      if (Math.abs(other.y - y) > near * TIER) continue
+      if (Math.abs(other.x - x) < near) return false
+    }
+    return true
+  }
+
+  /**
+   * The reef this seed builds, from its own generator started afresh.
+   *
+   * Its own, and restarted whenever the box changes, for the reason `relics.ts`
+   * gives: what a sea holds has to be a pure function of its seed, or a window
+   * dragged wider deals a second reef and nobody can look at the same one twice.
+   */
+  function raise(): void {
+    const roll = makeRandom(options.seed ^ 0x91af)
+
+    middle = width * (SEAT_LEAST + roll() * SEAT_SPAN)
+    half = width * (HALF_LEAST + roll() * HALF_SPAN)
+    rise = Math.min(height * (RISE_LEAST + roll() * RISE_SPAN), half * TALLEST)
+    depth = DEPTH_FAR + roll() * (DEPTH_NEAR - DEPTH_FAR)
+
+    heads.length = 0
+    crowns.length = 0
+    held.length = 0
+    reaches.length = 0
+    crest.length = 0
+    bounds = [middle - half, middle + half]
+
+    for (let step = 0; step <= CREST_STEPS; step++) {
+      const x = middle - half + ((half * 2) / CREST_STEPS) * step
+      crest.push({ x, y: surfaceAt(x) })
+    }
+
+    for (const kind of dealt(roll)) grow(kind, roll)
+
+    const rest = spread()
+    for (let made = 0; made < Math.max(0, options.heads ?? HEADS); made++) {
+      grow(rest[Math.floor(roll() * rest.length)] ?? "brain", roll)
+    }
+
+    health = new Set(heads.map((one) => one.kind)).size / KINDS.length
+  }
+
+  /**
+   * Every kind, in an order this seed made up.
+   *
+   * The first pass gives each kind of coral first refusal on a bare rock, and
+   * whoever asks first gets the best of the band they share. Asking in the
+   * order they happen to be written down means the same kind is last on every
+   * reef ever built, and the last one is the one that goes without.
+   */
+  function dealt(roll: () => number): HeadKind[] {
+    const order = [...KINDS]
+    for (let at = order.length - 1; at > 0; at--) {
+      const swap = Math.floor(roll() * (at + 1))
+      const held = order[at] as HeadKind
+      order[at] = order[swap] as HeadKind
+      order[swap] = held
+    }
+    return order
+  }
+
+  /** Every kind repeated by its weight, which is the cheapest weighting there is. */
+  function spread(): HeadKind[] {
+    const bag: HeadKind[] = []
+    for (const kind of KINDS) {
+      for (let each = 0; each < SORTS[kind].weight; each++) bag.push(kind)
+    }
+    return bag
+  }
+
+  /** How far a head is leaning at the moment, from the swell and its own phase. */
+  function lean(one: Head): number {
+    const sway = SORTS[one.kind].sway
+    if (sway === 0) return 0
+
+    const passing = gust(
+      ((one.x - middle) / Math.max(MIN_SPAN, half)) * SWELL_CELLS,
+      clock * SWELL_RATE,
+    )
+    const own = Math.sin(clock * Math.PI * 2 * SWELL_RATE + one.lane)
+    return sway * (passing * SWELL_SHARE + own * (1 - SWELL_SHARE))
+  }
+
+  /**
+   * How far a head can have moved since it was last drawn.
+   *
+   * Two things move it and both are in here, because one drawing covers the
+   * two. The whole of it turns in the swell, and the furthest part of a drawing
+   * turned about its root travels its reach for a radian of turn. An anemone's
+   * tentacles curl on their own clock besides, whether the water is doing
+   * anything or not, and `flora.ts` owns the estimate of that for the reason it
+   * owns the crown.
+   *
+   * Neither is measured off the drawing, because making one to find out is the
+   * bill this is here to avoid.
+   */
+  function wander(at: number, bend: number, phase: number): number {
+    const one = heads[at]
+    const was = held[at]
+    if (!one || !was) return Number.POSITIVE_INFINITY
+
+    return (
+      (reaches[at] ?? 0) * Math.abs(bend - was.bend) +
+      crownSwept(COLUMN * one.scale, Math.abs(phase - was.phase))
+    )
+  }
+
+  /** Draw again every head the swell has moved far enough to be worth it. */
+  function breathe(): void {
+    for (const [at, one] of heads.entries()) {
+      const tentacles = crowns[at]
+      const bend = lean(one)
+      const phase = tentacles ? clock * CROWN_RATE + one.lane : 0
+
+      if (wander(at, bend, phase) < tolerance) continue
+
+      one.bend = bend
+      if (tentacles) one.blades = crownAt(MOUTH, tentacles, COLUMN, phase)
+      one.cut++
+      held[at] = { bend, phase }
+    }
+  }
+
+  const crest: Point[] = []
+
+  raise()
+  breathe()
+
+  return {
+    crest,
+
+    get depth() {
+      return depth
+    },
+
+    heads,
+
+    get health() {
+      return health
+    },
+
+    holds(x, y, stand = depth) {
+      const reach = half * (1 + REACH)
+      if (x < middle - reach || x > middle + reach) return false
+
+      const rock = surfaceAt(x, stand)
+      return y >= rock - rise * HEADROOM && y <= rock
+    },
+
+    resize(nextWidth, nextHeight, nextFloor) {
+      width = Math.max(MIN_SPAN, nextWidth)
+      height = Math.max(MIN_SPAN, nextHeight)
+      floor = nextFloor
+      raise()
+      breathe()
+    },
+
+    get span() {
+      return bounds
+    },
+
+    step(seconds) {
+      clock += Math.min(Math.max(seconds, 0), 0.1)
+      breathe()
+    },
+
+    surfaceAt,
+
+    wind(seconds) {
+      clock += Math.max(0, seconds)
+      breathe()
+    },
+  }
+}