@codincod/ornament 0.0.0-stage → 0.2.0

package/src/flora.ts

@@ -0,0 +1,1955 @@
+/**
+ * What grows on the bottom: kelp, grass and coral.
+ *
+ * Rooted life, kept free of the DOM the way the rest of the ornament is. It
+ * needs a floor to be rooted to, which the caller supplies as a function rather
+ * than a number, because a seabed is not level and a plant hovering a pixel
+ * above the sand is a plant nobody believes.
+ *
+ * A plant asks that function for the ground at its own distance, which is the
+ * whole of how a bed acquires depth: the near ones stand on the sand at the
+ * front, the far ones are up the slope behind it, and nothing is arranged
+ * along a line. See `FloraOptions.floor`.
+ *
+ * ## Why the plants read as water and the fish do not
+ *
+ * A fish is going somewhere, so it tells you what it wants and not much about
+ * where it is. A plant is not going anywhere, so everything it does is the
+ * water doing it. That makes the bed the single most legible statement of
+ * current in the whole scene, and it is why these read the same Perlin field
+ * the shoal reads: when the water leans one way, the kelp along that stretch
+ * leans with it and so do the fish passing through, and the three agreeing is
+ * what makes it a sea rather than three animations sharing a rectangle.
+ *
+ * ## How a strand bends
+ *
+ * `amp * sin(phase + t * 2.4) * t`, taken from the site's own `Marks.strand/3`
+ * and kept identical so a strand in a porthole and a strand on a desktop are
+ * the same plant. The `* t` is the whole trick: at the root `t` is zero and the
+ * sine cannot move it, so the base is planted and only the tip travels. Drop it
+ * and the plant slides along the seabed like weed on a windscreen.
+ *
+ * Blades grow at whatever angle the strand happens to have where they are, so a
+ * blade never crosses the strand it grows from. That is also the site's rule
+ * and it is worth keeping for the same reason: a crossing blade is the one
+ * thing that makes a drawn plant look like two drawn plants.
+ *
+ * ## One weed is not a bed
+ *
+ * There are thousands of seaweeds and this bed knew kelp: a stipe with leaves
+ * lying back along it, sown over and over. What the eye reads then is one plant
+ * at a range of sizes, and no amount of grading those sizes makes it a bed.
+ *
+ * So a weed is a row of a table. A frill is the kelp that was here already. A
+ * strap is a short thick stipe carrying leaves as long as the whole plant,
+ * which is most of what a laminaria is from below. A wrack divides as it
+ * climbs, so what it draws is a branch rather than a mast. A sea lettuce is a
+ * low ruffle standing off a stub, and it is the only one of them whose outline
+ * has any width to it.
+ *
+ * ## Grass comes in clumps
+ *
+ * One blade of grass is a hair, and a floor sown with single hairs is a floor
+ * that has been swept rather than one anything grows on. Grass grows from a
+ * root in a handful of blades of unequal height leaning out of the same spot,
+ * so that is what one plant here is: a strand and its mates, splayed a little,
+ * each its own height and none of them on the same clock. The clump leans as
+ * one because it reads one field at one place, which is what tells you the
+ * blades belong to each other rather than happening to stand together.
+ *
+ * ## And clumps come in meadows
+ *
+ * Clumps scattered evenly across the box are a lawn somebody seeded by hand.
+ * Seagrass spreads from where it already is, so a bed seen from inside it is a
+ * few dense patches, a thinning at their edges, and bare sand between them. The
+ * beds are placed first and the clumps are placed in them, near the middle more
+ * often than at the edge. A few land nowhere near one, because an edge every
+ * blade respects is an edge, and a meadow has none.
+ *
+ * ## Coral does not sway
+ *
+ * It is a skeleton. A coral bending in the current would be a coral made of
+ * rubber, and the stiffness is useful in its own right: with everything else in
+ * the scene moving, the one thing holding still is what the movement is
+ * measured against.
+ *
+ * ## A plant recuts itself when it has moved enough to be worth it
+ *
+ * A bed is the most expensive layer in the ornament, and nearly all of that
+ * cost is cutting strands. Almost every plant changes shape on almost every
+ * frame, so asking whether one moved saves nothing; asking whether it moved
+ * enough to see saves most of the bed, because a plant swaying gently travels a
+ * fraction of a pixel between frames and a renderer that redrew it for that
+ * spent the frame on a picture nobody could tell from the last one.
+ *
+ * So a plant holds its last drawing until it has wandered `tolerance` away from
+ * it, and `cut` is how a renderer knows. The judgement costs three subtractions
+ * and no geometry at all: where the tip of a strand sits is a closed form of
+ * the amplitude and the phase, which is what `stir` is. That also takes the
+ * work out of the simulation, since cutting the strand was the simulation's own
+ * bill; the two were one thing wearing two names.
+ *
+ * `docs/decisions/0027-let-an-element-decide-when-its-drawing-is-stale.md` is
+ * the argument, and `flora.test.ts` holds `stir` to never under-reporting what
+ * a plant actually did.
+ *
+ * ## Two of these are animals
+ *
+ * An anemone is a column with a crown on it, and everything about it that
+ * moves moves on its own. Kelp leans because the water leans; a tentacle feels
+ * around whether the water is doing anything or not. That is the difference
+ * between a plant and an animal down here, and it is why a crown is walked out
+ * of the mouth a step at a time rather than cut from a root: what a tentacle
+ * does is curl, and a curl is a heading that keeps turning.
+ *
+ * An anemone also does the one thing a rooted animal can do about anything: it
+ * pulls in. Nothing tells it to. The water is the register of what is in it,
+ * and a crown reads that register and decides for itself, which is why `about`
+ * is an option here rather than a call somebody makes. What it minds is not
+ * what a fish minds: a shark going by at a distance is no business of an
+ * anemone's, and something large nearly touching it is all of its business. It
+ * pays no attention at all to whether the thing hunts, which every other animal
+ * here weighs: what is about to be on top of a crown is about to be on top of
+ * it either way, and nothing that eats an anemone was ever going to be outrun.
+ *
+ * A sea fan is the other end of it. It is a skeleton like coral, so it holds
+ * its shape, and it stands across the current rather than along it because
+ * that is how it eats. It gives a little, which is what says it is not a stone.
+ *
+ * The crown earns its place at the back of the picture more than at the front,
+ * and it is placed with a lean that way. Everything else rooted down there is a
+ * line, and a line a few px long in the murk is a hair the haze takes first. A
+ * crown has a body: the tentacles overlap into a mass with an outline, and a
+ * mass survives being drawn small and faint where a hair does not. It is the
+ * boulder's argument, one layer up.
+ */
+
+import { abreast, type Presence } from "./biome.ts"
+import { makeNoise2, makeRandom, type Noise2 } from "./perlin.ts"
+import type { Point } from "./seabed.ts"
+
+export type PlantKind = "anemone" | "coral" | "fan" | "grass" | "kelp"
+
+/**
+ * Coral, as a fan of tapering strokes from one base.
+ *
+ * The site's `Marks.coral/1`, brought across whole. Round caps do the work:
+ * strokes of falling width, splayed, read as a branch without a single curve
+ * being drawn twice.
+ */
+export interface Twig {
+  readonly d: string
+  readonly width: number
+}
+
+/**
+ * The same drawing with its strokes gathered by how thick they are.
+ *
+ * A drawing here is a handful of tapering strokes and a renderer strokes each
+ * of them, so a coral of five strokes is five paths, and a bed of corals is
+ * more paths than the rest of the scene put together. Strokes of one width are
+ * one path as far as a renderer is concerned: several subpaths in one `d`,
+ * stroked once, drawn identically. A boulder is four strokes of one width and
+ * comes out of this as one.
+ *
+ * Held on to, because a handful of these tables serve every coral, every reef
+ * head and every sprig on a wall, and the gathering is the same each time.
+ */
+const gatherings: { drawn: readonly Twig[]; gathered: readonly Twig[] }[] = []
+
+export function gathered(twigs: readonly Twig[]): readonly Twig[] {
+  for (const held of gatherings) {
+    if (held.drawn === twigs) return held.gathered
+  }
+
+  const made: { d: string; width: number }[] = []
+  for (const twig of twigs) {
+    const same = made.find((one) => one.width === twig.width)
+    if (same) same.d += ` ${twig.d}`
+    else made.push({ d: twig.d, width: twig.width })
+  }
+
+  gatherings.push({ drawn: twigs, gathered: made })
+  return made
+}
+
+export const CORAL: readonly Twig[] = [
+  { d: "M0 0 C-2 -14 -10 -18 -16 -26", width: 5 },
+  { d: "M0 0 C0 -16 2 -24 0 -34", width: 6 },
+  { d: "M0 0 C2 -12 10 -16 18 -22", width: 4.5 },
+  { d: "M-8 -14 C-12 -20 -16 -22 -22 -24", width: 3 },
+  { d: "M8 -12 C12 -18 18 -20 24 -20", width: 3 },
+]
+
+/**
+ * The rest of the reef: a bush, a staghorn and a boulder.
+ *
+ * One coral drawn over and over is a wallpaper repeat, and a seabed made of it
+ * is a seabed the eye finishes reading in a second. These are the same idiom as
+ * the site's above, tapering strokes from one base, and they differ in the two
+ * things that actually change what a growing thing looks like: how wide it gets
+ * against how tall, and how thick the strokes are.
+ *
+ * The boulder is the important one. Everything else rooted down there is a line
+ * of some sort, so a bed of them is a bed of hairs however many are sown; the
+ * one shape with a body is what the rest gets to stand against.
+ */
+const BUSH: readonly Twig[] = [
+  { d: "M0 0 C-4 -8 -14 -10 -24 -12", width: 4 },
+  { d: "M0 0 C-2 -10 -6 -15 -10 -22", width: 4.5 },
+  { d: "M0 0 C1 -9 3 -14 4 -20", width: 5 },
+  { d: "M0 0 C4 -8 12 -11 22 -14", width: 4 },
+  { d: "M-12 -9 C-16 -14 -18 -16 -20 -22", width: 2.5 },
+  { d: "M10 -10 C14 -14 18 -15 22 -20", width: 2.5 },
+]
+
+const STAGHORN: readonly Twig[] = [
+  { d: "M0 0 C0 -12 -2 -22 -6 -34", width: 5.5 },
+  { d: "M0 0 C3 -10 6 -18 8 -30", width: 4.5 },
+  { d: "M-3 -20 C-8 -26 -12 -28 -16 -36", width: 3 },
+  { d: "M6 -20 C10 -26 14 -27 18 -32", width: 3 },
+  { d: "M0 -6 C-6 -10 -10 -12 -14 -14", width: 2.5 },
+]
+
+const BOULDER: readonly Twig[] = [
+  { d: "M0 0 C-9 -4 -13 -9 -12 -15", width: 7 },
+  { d: "M0 0 C-4 -6 -5 -12 -4 -18", width: 7 },
+  { d: "M0 0 C3 -6 5 -12 5 -17", width: 7 },
+  { d: "M0 0 C9 -4 13 -9 11 -15", width: 7 },
+]
+
+/**
+ * Which coral a plant might be, and how often.
+ *
+ * Weighted by repetition, which is the cheapest weighting there is and reads at
+ * a glance. Boulders are common because they are what the bed is short of;
+ * staghorns are rare because a tall coral in a stand of kelp is one more
+ * vertical line in a picture already full of them.
+ */
+const REEF: readonly (readonly Twig[])[] = [BOULDER, BOULDER, BUSH, BUSH, CORAL, STAGHORN]
+
+/**
+ * One blade, as the line it hangs along rather than its endpoints.
+ *
+ * A blade was two points and a straight line between them, and a plant made of
+ * those is a fir tree: every blade the same length, leaving at the same angle,
+ * evenly spaced up a trunk. Kelp does not do that. A blade leaves the stipe,
+ * bows out into the water and then falls back along it, so what it draws is a
+ * long soft curve lying nearly parallel to the plant, and the eye reads a
+ * bundle of those as something being held up by water.
+ */
+export type Blade = readonly Point[]
+
+export interface Plant {
+  /**
+   * Blades, as they were at the last cut. Empty for coral.
+   *
+   * Leaves off the stipe for kelp; the rest of the clump for grass. One field
+   * rather than two, because a renderer's job is to stroke every line the plant
+   * hands it at the plant's own weight, and it has no business knowing which of
+   * them is a leaf and which is another blade of grass.
+   */
+  blades: Blade[]
+  /**
+   * How many times this plant has recut itself.
+   *
+   * The only thing a renderer has to watch. While it holds, `points` and
+   * `blades` are the arrays they already were, so a renderer keeping its own
+   * drawing of this plant keeps a drawing that is still true and does no work.
+   * A plant that has never bent bumps it once and then never again, which is
+   * every coral in the bed.
+   */
+  cut: number
+  /** 0 is as far off as this water goes, 1 is up against the glass. */
+  readonly depth: number
+  /** How thick to draw the strand, in px. */
+  readonly girth: number
+  readonly kind: PlantKind
+  /** The strand from root to tip, as it was at the last cut. Empty for coral. */
+  points: Point[]
+  /** What to scale the coral drawing by. Meaningless for the others. */
+  readonly scale: number
+  /** Which coral this one is. Empty for anything that sways. */
+  readonly twigs: readonly Twig[]
+  /** Where it is rooted. */
+  readonly x: number
+  readonly y: number
+}
+
+export interface Flora {
+  /**
+   * What a plant is made of, for a renderer that would rather bend it itself.
+   *
+   * The bed hands over points because that is what a renderer needs and the
+   * arithmetic behind them is nobody else's business. It is a bad bargain for
+   * one kind of caller: a renderer that draws on a graphics card would rather
+   * take the shape once and bend it there, and to do that it has to know what
+   * the shape is a function of. `Frame` is that, and `Sway` is the two numbers
+   * a frame is evaluated at; see `swaying`.
+   */
+  madeOf(at: number): Frame | null
+  readonly plants: readonly Plant[]
+  resize(width: number, height: number, floor: (x: number, depth?: number) => number): void
+  step(seconds: number): void
+  /** Where each plant's sway has got to, in step with `plants`. */
+  readonly swinging: readonly Swing[]
+  /**
+   * A long stretch of time in one go, for a caller winding a scene forward.
+   *
+   * Exact, not an approximation of one. A plant has no memory: where it is
+   * standing at a moment is a sine of the clock and a field read at its own
+   * place, so an hour of swaying is an hour added to the clock and one recut.
+   * `step` cannot do this because it clamps, which is what protects a scene
+   * from a stalled frame, and it is also what makes winding one cost a step per
+   * fiftieth of a second of it.
+   *
+   * It is worth having because the bed is the most expensive layer in the whole
+   * ornament by a distance: a wind that recut two hundred plants at every
+   * intermediate moment spent three quarters of its time drawing pictures of
+   * the past that nobody was ever going to see.
+   */
+  wind(seconds: number): void
+}
+
+export interface FloraOptions {
+  /**
+   * What else is in the water, asked for once a step.
+   *
+   * Left out, nothing is, and every crown in the bed stands open. Which is the
+   * state a sea with nothing large in it is in anyway.
+   */
+  about?: () => readonly Presence[]
+  anemones?: number
+  /**
+   * A patch of sand nothing may root in, asked once a plant.
+   *
+   * Left out, nothing is bare and the bed grows everywhere it can reach. It is
+   * here for `eels.ts`, whose whole animal is a stretch of open sand: a colony
+   * works its holes over continuously, and a garden eel bed in the wild is a
+   * clearing with weed around the edge of it rather than weed with eels in it.
+   *
+   * A predicate rather than a rectangle, because whatever knows a patch is bare
+   * knows why, and a shape handed over here would be that reason copied.
+   */
+  bare?: (x: number, depth: number) => boolean
+  corals?: number
+  /**
+   * Which kinds the bed should keep a cut drawing of. All of them by default.
+   *
+   * For a caller that would rather bend a plant itself: hand it `["anemone"]`
+   * and the bed still sways, still says where every plant's sway has got to,
+   * and stops drawing the four kinds that are a `Frame` and a swing. It is a
+   * statement about what the caller is going to read rather than about what the
+   * water is doing, which is why it is here and not a tolerance: a plant nobody
+   * is going to look at the points of should not be spending anything on them.
+   *
+   * A crown is the one that has to stay, because a crown is walked rather than
+   * cut and there is no frame that stands in for it.
+   */
+  cutting?: readonly PlantKind[]
+  fans?: number
+  /**
+   * The ground at x, at a given distance; `seabed.floorAt`.
+   *
+   * Both arguments matter here. A bed where every plant is rooted on the line
+   * at the front of the picture is a bed with one plant repeated at a hundred
+   * sizes, and no amount of grading those sizes puts distance back into it: the
+   * eye reads the row of roots, not the heights. A plant asks for the ground at
+   * its own depth, so the roots climb the slope and the bed acquires the one
+   * thing a rank of them never has.
+   */
+  floor: (x: number, depth?: number) => number
+  grasses?: number
+  height: number
+  kelps?: number
+  seed: number
+  /**
+   * How far a plant may wander from its last drawing before it recuts, in px.
+   *
+   * The bed's whole price, in one number. At nothing, every plant recuts on
+   * every step and the bed costs what it always did. At a quarter of a pixel
+   * roughly a fifth of them do, and what the eye is given up is a sway that
+   * arrives in quarter-pixel steps rather than continuously, on a line drawn at
+   * a third of the ink of the copy in front of it.
+   *
+   * It is a tolerance and not a frame rate: a plant the current is throwing
+   * about crosses it every step and keeps every one of its frames, and a plant
+   * in the still water at the back of the picture goes minutes without needing
+   * one. So a calm bed is nearly free and a stirred one costs what it is worth,
+   * which is the right way round and is not something a lower step rate can do.
+   */
+  tolerance?: number
+  width: number
+}
+
+/** How many features of the current fit across the box. The shoal's own. */
+const FIELD_CELLS = 3.6
+
+/** How many places a plant will try before it gives up on being planted. */
+const BARE_TRIES = 6
+
+/** How fast the field slides, so a bed never settles into one shape. */
+const DRIFT = 0.06
+
+/** How tall kelp and grass stand, as shares of the box's height. */
+const KELP_LEAST = 0.22
+
+const KELP_SPAN = 0.3
+
+const GRASS_LEAST = 0.05
+
+const GRASS_SPAN = 0.085
+
+/**
+ * How many blades stand in one clump of grass, and how far they splay.
+ *
+ * The splay is an angle off upright, in radians, and it is small on purpose. A
+ * clump that fans wide is a palm; grass leaves the ground very nearly vertical
+ * and only opens out towards the tips, which the sway already does for it.
+ *
+ * The shortest blade in a clump is `GRASS_RUNT` of the tallest. Even heights
+ * are the thing that gives a drawn plant away fastest, faster than an even
+ * spacing does.
+ */
+/**
+ * How much grass a full clump wants, in px, and the fewest blades it is still a
+ * clump with.
+ *
+ * The crown's argument again. A clump reads as one plant opening out, and the
+ * blade that says so is the one leaning furthest; the ones between it and the
+ * middle are what make it thick. At the back of the bed there is no room
+ * between them to be thick in.
+ */
+const TUFT_CROWDED = 46
+
+const TUFT_FEWEST = 2
+
+const TUFT_LEAST = 3
+
+const TUFT_MOST = 7
+
+const TUFT_SPLAY = 0.34
+
+const TUFT_ROOT = 0.16
+
+const GRASS_RUNT = 0.5
+
+/** How thick their strands are drawn, in px. */
+const KELP_GIRTH = 5.2
+
+const GRASS_GIRTH = 2
+
+/** How finely a strand is cut. Enough that the bend has no corners in it. */
+const KELP_STEPS = 12
+
+const GRASS_STEPS = 6
+
+/**
+ * How far a tip travels, as a share of the plant's own height.
+ *
+ * Kelp leans a long way and grass barely does, which is the difference between
+ * something with a metre of leverage and something with a hand's width of it.
+ * Both are measured against their own height rather than in pixels, so a tall
+ * plant and a short one in the same current agree about which way the water is
+ * going and disagree about how much it matters.
+ */
+const KELP_LEAN = 0.34
+
+const GRASS_LEAN = 0.14
+
+/** How fast a plant works through its own sway, slowest to fastest. */
+const SWAY_SLOWEST = 0.22
+
+const SWAY_FASTEST = 0.44
+
+/**
+ * How much of the lean is the shared current, and how much is the plant's own.
+ *
+ * Mostly shared, because a bed where every plant swings on its own clock is a
+ * bed in no current at all: what the eye reads then is a row of metronomes. The
+ * share that is its own is what stops them moving as one object.
+ */
+const CURRENT_SHARE = 0.68
+
+/**
+ * Which weed a plant is, as the handful of numbers that tell one from another.
+ *
+ * What separates two seaweeds in silhouette is small: how long a leaf is
+ * against the plant carrying it, how much of that length is spent trailing
+ * back down the strand rather than standing off it, where up the strand the
+ * leaves start, and whether the strand divides on the way up. The rest of the
+ * plant is the same plant.
+ *
+ * `span`, `trail` and `flare` are the three that carry it, and they are where
+ * kelp used to keep its only shape. A leaf leaving along the normal stands out
+ * like a thorn, and a plant covered in short thorns reads as something dead in
+ * winter. So the two directions run on different clocks along the leaf: the
+ * sideways part is all at the root and gone by the tip, the trailing part
+ * builds the whole way, and between them the leaf bows out and comes back.
+ * `flare` only has to be enough to keep a leaf off the strand it grows from,
+ * and every bit past that is a thorn again, which is why the one weed here
+ * that flares hard has almost no trail to lie along.
+ */
+interface Weed {
+  /** How many leaves come off the strand. */
+  readonly blades: number
+  /** How far a leaf bows off the strand before it falls back along it. */
+  readonly flare: number
+  /** Where up the strand it divides, if it divides at all. */
+  readonly forks: readonly number[]
+  /** How thick its strand is drawn, against kelp's own. */
+  readonly girth: number
+  /** Where up the strand the lowest leaf sits. */
+  readonly seat: number
+  /** How long a leaf is against the plant's height. */
+  readonly span: number
+  /** How tall it stands, against kelp's own height. */
+  readonly stature: number
+  /** How much shorter the topmost leaf is than the lowest. */
+  readonly taper: number
+  /** How much of a leaf's length is spent going back down the strand. */
+  readonly trail: number
+}
+
+/** The kelp that was here before there was a table: a mast of long soft leaves,
+ *  every one of them lying back along it. */
+const FRILL: Weed = {
+  blades: 7,
+  flare: 0.3,
+  forks: [],
+  girth: 1,
+  seat: 0.14,
+  span: 0.44,
+  stature: 1,
+  taper: 0.45,
+  trail: 0.95,
+}
+
+/** A strap: a short thick stipe under leaves as long as the plant, which is
+ *  most of what a laminaria is from below. */
+const STRAP: Weed = {
+  blades: 4,
+  flare: 0.42,
+  forks: [],
+  girth: 1.35,
+  seat: 0.55,
+  span: 0.95,
+  stature: 0.74,
+  taper: 0.08,
+  trail: 0.8,
+}
+
+/** A wrack: it divides as it climbs, so its outline is a branch, and what it
+ *  carries along the branches are stubs rather than leaves. */
+const WRACK: Weed = {
+  blades: 24,
+  flare: 0.28,
+  forks: [0.3, 0.48, 0.66],
+  girth: 0.8,
+  seat: 0.2,
+  span: 0.34,
+  stature: 0.78,
+  taper: 0.3,
+  trail: 0.85,
+}
+
+/** Sea lettuce: a low ruffle standing off a stub, and the only weed here whose
+ *  outline has any width to it. */
+const LETTUCE: Weed = {
+  blades: 15,
+  flare: 0.95,
+  forks: [],
+  girth: 0.62,
+  seat: 0.06,
+  span: 0.33,
+  stature: 0.44,
+  taper: 0.05,
+  trail: 0.2,
+}
+
+/**
+ * Which weed a plant might be, and how often.
+ *
+ * Weighted by repetition, the way the reef above is. The frill comes up most
+ * because it is the tall thing in the bed, and a bed with nothing tall in it is
+ * a lawn.
+ */
+const WEEDS: readonly Weed[] = [FRILL, FRILL, LETTUCE, STRAP, WRACK]
+
+/**
+ * How much weed a full set of leaves wants, in px, and the fewest it is a weed
+ * with.
+ *
+ * The crown's argument on the tallest thing in the bed, which is why the number
+ * is the largest of them. A wrack carries two dozen stubs along its branches
+ * and stands anywhere from a knuckle to half the box; at the short end those
+ * stubs are closer together than the strand they are on is thick.
+ */
+const LEAF_CROWDED = 210
+
+const LEAF_FEWEST = 3
+
+/** How finely a leaf is cut. Enough that the bow in it has no corner. */
+const BLADE_STEPS = 5
+
+/**
+ * How much of a line one segment is worth, in px, and the fewest any line is
+ * ever cut into.
+ *
+ * Every count in this file says how finely something is cut and none of them
+ * said how big the something was drawn. A plant in the murk is a few px tall
+ * and was carrying the same twelve-point strand and the same five-point leaves
+ * as one at the glass, which is a point every fraction of a pixel: work done,
+ * published and tessellated for a bend nothing can resolve.
+ *
+ * Depth never changes for anything rooted, so the count is dealt when the thing
+ * is sown and then left alone. That is the whole reason to do it this way: a
+ * count that changed while somebody was watching would pop, and one dealt at
+ * sowing cannot.
+ *
+ * The number is the chord: a segment this long on a bend as slack as a plant's
+ * stands about a quarter of a px off the curve it is standing in for, which is
+ * the same quarter px the bed already accepts before it redraws at all. The
+ * table's own count stays the ceiling, so nothing is ever cut finer than it was.
+ */
+const STEP_SPAN = 8
+
+const FEWEST_STEPS = 2
+
+/** How finely a line that long is worth cutting, against the most it may have. */
+function cuts(most: number, drawn: number): number {
+  return Math.max(FEWEST_STEPS, Math.min(most, Math.round(drawn / STEP_SPAN)))
+}
+
+/**
+ * How many of something a drawing that big is worth.
+ *
+ * `roomy` is how much room the full count wants, in px, and `fewest` is where
+ * the thing stops being itself. A crown had this argument first and made it
+ * alone; it is the same argument for a fan's ribs and a clump's blades, so it
+ * is written once and the three of them pass their own numbers to it.
+ */
+function crowded(most: number, fewest: number, drawn: number, roomy: number): number {
+  const room = Math.min(1, Math.max(0, drawn / roomy))
+  return Math.max(Math.min(most, fewest), Math.round(most * room))
+}
+
+/**
+ * What a fork takes of the strand left above it, and how far off it leans.
+ *
+ * Well short of all of it, and well short of a right angle. A fork carrying the
+ * whole of the remaining height is a plant with two tips at the same place,
+ * which reads as one strand drawn twice; a fork leaving sideways is a
+ * crossroads.
+ */
+const FORK_REACH = 0.58
+
+const FORK_SPLAY = 0.5
+
+/** The ends of a coral's scale. */
+const CORAL_SMALLEST = 0.9
+
+const CORAL_LARGEST = 2.4
+
+/**
+ * How tall an anemone stands, as a share of the box, and how thick its column
+ * is against that.
+ *
+ * Short and stout. What an anemone has instead of height is a crown, and a tall
+ * one is a plant with a bad haircut. The column is measured as a share of its
+ * own height rather than in px because what says column is that it is stout,
+ * and something stout that got small stayed stout.
+ */
+const ANEMONE_LEAST = 0.03
+
+const ANEMONE_SPAN = 0.028
+
+const ANEMONE_GIRTH = 0.15
+
+/** How far a column gives to the water, and how finely it is cut. It is a
+ *  foot: it holds on, and what moves up there is the crown. */
+const ANEMONE_LEAN = 0.08
+
+const ANEMONE_STEPS = 3
+
+/**
+ * How many tentacles a crown carries, and how far the outermost opens from
+ * upright, in radians.
+ *
+ * Enough of them that they overlap, which is the whole of why an anemone is
+ * worth having at the back of the picture: the mass has an outline and a hair
+ * does not. Opened to about a right angle at the edge, so the crown is a bowl
+ * rather than a brush.
+ */
+const CROWN_LEAST = 12
+
+const CROWN_MOST = 20
+
+const CROWN_OPEN = 0.92
+
+/**
+ * How much further a tentacle turns along its own length, how long it is
+ * against the column, and how far it feels around as it goes.
+ *
+ * The wave is scaled by how far along the tentacle it is, for the reason a
+ * strand's bend is: what a tentacle is attached to holds still, and only the
+ * tip is free. The curl is the shape and the wave is the life, and the wave is
+ * the smaller of the two by a distance.
+ */
+const CROWN_CURL = 0.36
+
+const CROWN_REACH = 0.95
+
+const CROWN_WAVE = 0.22
+
+const CROWN_WAVES = 2.2
+
+const CROWN_STEPS = 5
+
+/**
+ * How much column a crown wants, in px, before it is dealt every tentacle it
+ * could have, and the fewest it is ever dealt.
+ *
+ * A crown reads because its tentacles overlap into a mass. The count that does
+ * that at the size the bed grows them is a smudge at the size something else
+ * might: a head on a reef is a fraction of an anemone on open sand, and the
+ * same handful of lines crossing in that space is a thumbprint. So the count
+ * comes down with the drawing, and the floor is where it stops being a crown
+ * and starts being a tuft.
+ */
+const CROWN_CROWDED = 30
+
+const CROWN_FEWEST = 6
+
+/**
+ * How much bigger than its own crown a thing has to be before an anemone minds
+ * it, and how near it has to come, as a share of its own size.
+ *
+ * Far nearer than a fish minds anything. A clownfish watches the water because
+ * it can leave; a crown has nowhere to be but where it is, so the only thing
+ * worth spending a retraction on is something about to be on top of it. Minded
+ * from further off, a bed of them would shut every time anything crossed the
+ * picture, and a shut anemone is a stalk.
+ */
+const CROWN_MINDS = 2.4
+
+const CROWN_NOTICE = 0.9
+
+/**
+ * How much of itself a frightened crown pulls in, how far the column squats
+ * under it, and how long it takes to open again.
+ *
+ * Slow. A pull is fast because it has to be and the opening is not, which is
+ * most of what makes it read as an animal rather than a switch. Not the whole
+ * of the tentacle either: an anemone closed to nothing is a stalk, and the
+ * shape that says frightened is a crown half its own width with its column
+ * hunched under it.
+ */
+const CROWN_PULL = 0.62
+
+const COLUMN_SQUAT = 0.22
+
+const PULL_FADE = 6
+
+/** How tall a sea fan stands, as a share of the box, and how thick its stem is
+ *  against that. Broad rather than tall: it is a net held up in the current. */
+const FAN_LEAST = 0.055
+
+const FAN_SPAN = 0.05
+
+const FAN_GIRTH = 0.07
+
+/**
+ * How much of a fan's height is the stem the ribs leave from.
+ *
+ * A third, and it matters. Cut at full height it is a fan with a flagpole
+ * through it: a bare mast standing well above the last rib, which no gorgonian
+ * has and which the eye reads before it reads the fan.
+ */
+const FAN_STEM = 0.34
+
+/**
+ * How far a fan gives to the current, how finely it is cut, and what share of
+ * the bend its ribs take.
+ *
+ * Barely, and the barely is the point. A gorgonian is a skeleton, so it holds
+ * its shape the way coral does; give it kelp's lean and it is made of rubber,
+ * and give it none at all and it is a stone with a pattern on it.
+ */
+const FAN_LEAN = 0.06
+
+const FAN_STEPS = 4
+
+const RIB_GIVE = 0.5
+
+/** How many ribs leave the stem, how far the lowest opens from upright, and
+ *  where up the stem the first of them leaves. */
+const RIB_LEAST = 6
+
+const RIB_MOST = 10
+
+/**
+ * How much fan a full set of ribs wants, in px, and the fewest it is a fan
+ * with.
+ *
+ * The crown's argument, on the plant it applies to hardest. A gorgonian is
+ * mostly rib, and the bed grows them at about two dozen px tall: eight ribs
+ * with a twig off each is sixteen lines crossing a space a thumbnail would
+ * cover, and what comes out is a blot rather than a lattice. Three ribs is
+ * where the splay stops reading.
+ */
+const RIB_CROWDED = 44
+
+const RIB_FEWEST = 3
+
+/** How much rib a twig off the middle of it wants, in px. Under this the twig
+ *  lands inside the line it left, and is a point of ink nobody can resolve. */
+const RIB_TWIGGED = 14
+
+const RIB_OPEN = 1.25
+
+const RIB_SEAT = 0.12
+
+/** How long a rib is against the stem, what a twig off one takes of that, and
+ *  how much further out the twig leans. */
+const RIB_REACH = 0.95
+
+const RIB_TWIG = 0.38
+
+const RIB_SPLAY = 1.35
+
+/**
+ * How much width one bed of grass gets, how far a clump strays inside it, how
+ * far it strays in distance, and how often one lands nowhere near a bed.
+ *
+ * The width is in px so that a wide screen gets more beds rather than wider
+ * ones, which is the difference between a coast with meadows along it and one
+ * meadow stretched to fit. The stray is what keeps a bed from having an edge.
+ */
+const MEADOW_EVERY = 620
+
+const MEADOW_SPREAD = 0.13
+
+const MEADOW_DEEP = 0.16
+
+const MEADOW_STRAY = 0.14
+
+/**
+ * How far back rooted things stand, from the murk to the front of the picture.
+ *
+ * The near end used to stop short of the front on the argument that the bed is
+ * behind the water rather than in front of it. That was true of a bed drawn as
+ * one line, where the nearest plant and the furthest stood on the same edge and
+ * the only thing distance did was thin them. A plant now stands on the ground
+ * at its own distance, so the near end has to reach the sand at the front: stop
+ * short of it and the whole foreground is bare ground with the whole bed
+ * hanging above it.
+ *
+ * The far end reaches most of the way back for the same reason read the other
+ * way round. Stop it short and the hills at the back are bare rock with a lawn
+ * in front of them, and the two read as separate pictures: what ties a distance
+ * to a foreground is one kind of thing appearing at every station between them.
+ * What a plant that far back is drawn at is `PLANT_SHRINK`, which is the answer
+ * to the version of this that was tried first and did not work: reaching back
+ * with the size scaled by the distance outright put a hair on the far ground
+ * and the haze had it before anybody did.
+ */
+const DEPTH_FAR = 0.12
+
+const DEPTH_NEAR = 1
+
+/**
+ * How much of a plant's drawn size is how far off it is.
+ *
+ * Not the whole of it, for the reason `seabed.ts` gives about a stone: scaled
+ * by distance outright, a plant on the far hills is a hair a couple of px wide,
+ * the haze has most of that, and what the eye reads up there is bare ground
+ * with a lawn in front of it. A share leaves distance most of its work and
+ * leaves the crest something a reader can name as a plant.
+ */
+const PLANT_SHRINK = 0.78
+
+/** How much of its size a plant that far off keeps. */
+const shrunk = (depth: number): number => 1 - PLANT_SHRINK + PLANT_SHRINK * depth
+
+/**
+ * How hard a crown leans towards the back of the water when it is placed.
+ *
+ * An anemone is the one rooted thing here with a body, and a body is worth most
+ * where a line has stopped reading. Placed evenly, most of them are spent at
+ * the front of the picture, where there was already plenty to look at, and the
+ * far hills stay what they were. It is a lean rather than a rule: a crown in
+ * the foreground is the only one anybody will ever see the tentacles of.
+ */
+const CROWN_BACK = 1.7
+
+const MIN_SPAN = 1
+
+/**
+ * How far each kind gives to the water, gathered so a plant can be looked up by
+ * what it is.
+ *
+ * The two skeletons are down at the bottom of it for a reason of their own. A
+ * fan and a column are stiff, and the little they are given is not a lean: it
+ * is the whole of what says they are alive rather than carved.
+ */
+const LEANS: Readonly<Record<PlantKind, number>> = {
+  anemone: ANEMONE_LEAN,
+  coral: 0,
+  fan: FAN_LEAN,
+  grass: GRASS_LEAN,
+  kelp: KELP_LEAN,
+}
+
+/**
+ * How much of a plant's height its own strand carries.
+ *
+ * All of it, except for the fan, whose height is mostly its ribs; see
+ * `FAN_STEM`. A coral has no strand at all and the number is never read.
+ */
+const STEMS: Readonly<Record<PlantKind, number>> = {
+  anemone: 1,
+  coral: 0,
+  fan: FAN_STEM,
+  grass: 1,
+  kelp: 1,
+}
+
+/**
+ * How far a plant wanders before it is worth recutting, in px, by default.
+ *
+ * A quarter of a pixel, which is where the arithmetic and the eye currently
+ * agree on a stroke drawn at a third of the copy's ink. Everything above it is
+ * a bed the eye reads as continuous; below it the saving falls away and above
+ * it the plants that sway hardest begin to step. A caller with a denser bed, a
+ * sharper screen or a slower machine passes its own.
+ */
+const TOLERANCE = 0.25
+
+/**
+ * How much further than its strand's tip the rest of a plant can travel.
+ *
+ * The judgement is made on the strand, because the strand is the one line whose
+ * movement is a closed form of the numbers the sway holds. Everything else a
+ * plant is made of rides on it: a leaf hangs off a limb, a rib is cut from the
+ * stem, a tentacle is walked out of the mouth. Each of those swings wider than
+ * the point it hangs from, by however much its own drawing reaches, so the
+ * estimate is scaled by that and `flora.test.ts` holds these numbers to it.
+ *
+ * They come out the same for everything that bends, which is worth stating
+ * because it was not arrived at by assuming it: a leaf, a rib and a mate all
+ * reach about as far off their strand as each other, and the bed was measured
+ * before these were written down. Coral never moves, so the scale it would need
+ * is the one number here that cannot be wrong.
+ */
+const SWING: Readonly<Record<PlantKind, number>> = {
+  anemone: 2,
+  coral: 0,
+  fan: 2,
+  grass: 2,
+  kelp: 2,
+}
+
+/**
+ * How far the furthest thing on a plant travels on its own clock, as a share of
+ * the plant's span, per radian of that clock.
+ *
+ * Nothing rooted has any of this and one animal has all of it. A stem, a rib
+ * and a leaf move because the water moved them, so their whole travel is in the
+ * amplitude and `SWING` weighs it. A tentacle curls whether the water is doing
+ * anything or not, which is the difference between a plant and an animal down
+ * there and is stated at greater length above. So a crown in still water swings
+ * its own reach through its own beat while the estimate that only knows about
+ * amplitude reads nothing at all, and a bed of anemones holds drawings that are
+ * a long way stale.
+ */
+const SWEEP: Readonly<Record<PlantKind, number>> = {
+  anemone: 0.25,
+  coral: 0,
+  fan: 0,
+  grass: 0,
+  kelp: 0,
+}
+
+/** How finely each kind's strand is cut. Enough that its bend has no corners. */
+const STEPS: Readonly<Record<PlantKind, number>> = {
+  anemone: ANEMONE_STEPS,
+  coral: 0,
+  fan: FAN_STEPS,
+  grass: GRASS_STEPS,
+  kelp: KELP_STEPS,
+}
+
+/**
+ * How thick to draw a plant's strand, in px.
+ *
+ * Two rules, because two different things are being measured. Kelp and grass
+ * are a width in px thinned by how far off they are, which is a stem seen at a
+ * distance. A column and a stem are a share of their own height, because what
+ * makes either read is that it is stout beside what it carries.
+ */
+function girthOf(kind: PlantKind, weed: Weed | null, span: number, depth: number): number {
+  if (kind === "anemone") return span * ANEMONE_GIRTH
+  if (kind === "fan") return span * FAN_GIRTH
+  if (kind === "kelp") return KELP_GIRTH * (weed?.girth ?? 1) * shrunk(depth)
+  return GRASS_GIRTH * shrunk(depth)
+}
+
+/**
+ * One tentacle, as a heading that keeps turning.
+ *
+ * A curl cannot be cut the way a strand is. A strand is a line from a root to a
+ * tip with a bend put through it, and a curl has no tip to aim at: it is a
+ * direction that keeps going round. So this walks it a step at a time, turning
+ * further out as it goes and feeling around as it turns. The feeling is scaled
+ * by how far along the tentacle the step is, for the reason the strand's bend
+ * is: the base is attached to something and the tip is not.
+ */
+function feeler(
+  x: number,
+  y: number,
+  span: number,
+  open: number,
+  phase: number,
+  steps: number,
+): Point[] {
+  const points: Point[] = [{ x, y }]
+  const pace = span / steps
+
+  let atX = x
+  let atY = y
+  for (let step = 1; step <= steps; step++) {
+    const u = step / steps
+    const heading = open * (1 + CROWN_CURL * u) + Math.sin(phase + u * CROWN_WAVES) * CROWN_WAVE * u
+
+    atX += pace * Math.sin(heading)
+    atY -= pace * Math.cos(heading)
+    points.push({ x: atX, y: atY })
+  }
+  return points
+}
+
+/**
+ * One tentacle of a crown: how long, how far out, and its own clock.
+ *
+ * Lengths are shares of the column rather than px, which is what lets one crown
+ * be dealt once and cut at whatever size the thing drawing it works in.
+ */
+export interface Tentacle {
+  /** How much faster or slower than its crown this one works through its own
+   *  feeling, so no two are ever at the same point of the same curl. */
+  readonly beat: number
+  readonly own: number
+  /** Where across the mouth it leaves, as a share of the column's height. */
+  readonly shift: number
+  /** How far it opens from upright, in radians. */
+  readonly slant: number
+  /** How long it is, as a share of the column's height. */
+  readonly span: number
+  /**
+   * How finely it is cut, dealt with the crown rather than taken from the span
+   * it is drawn at.
+   *
+   * `crownAt` is cut at 1 by a caller that is about to scale the drawing and at
+   * a real height by one that is not, so the span it is handed says nothing
+   * about how big anybody will see this. What does is the size the crown was
+   * dealt for, which is the size it was grown at and never changes.
+   */
+  readonly steps: number
+}
+
+/**
+ * Deal a crown: the tentacles one anemone has, spread evenly across its mouth.
+ *
+ * Evenly, where a clump of grass is splayed at random, because a crown is a
+ * ring of them and a gap in a ring is a gap. What is left to the dice is how
+ * long each one is and where in its own feeling it happens to be, which is
+ * enough that no two agree about anything.
+ *
+ * `drawn` is how many px of column the animal is going to be drawn at, and the
+ * only thing it decides is how many tentacles there are; see `CROWN_CROWDED`.
+ *
+ * Dealt once and cut every step, which is the split `crownAt` is the other half
+ * of. Nothing here reads a clock, so an animal dealt this way is the same
+ * animal however long a scene has been running.
+ */
+export function crown(seed: number, drawn: number): Tentacle[] {
+  const random = makeRandom(seed)
+  const most = CROWN_LEAST + Math.floor(random() * (CROWN_MOST - CROWN_LEAST + 1))
+  const count = crowded(most, CROWN_FEWEST, drawn, CROWN_CROWDED)
+
+  const tentacles: Tentacle[] = []
+  for (let made = 0; made < count; made++) {
+    const across = count < 2 ? 0 : (made / (count - 1)) * 2 - 1
+
+    const span = CROWN_REACH * (0.75 + random() * 0.55)
+
+    tentacles.push({
+      beat: 0.7 + random() * 0.7,
+      own: random() * Math.PI * 2,
+      shift: across * ANEMONE_GIRTH * 0.5,
+      slant: across * CROWN_OPEN * (0.72 + random() * 0.56),
+      span,
+      steps: cuts(CROWN_STEPS, span * drawn),
+    })
+  }
+  return tentacles
+}
+
+/**
+ * How far a crown's furthest tip travels while its own clock turns.
+ *
+ * `span` is the column's height in whatever the caller draws in, and `turned`
+ * is how far the clock has come round since, in radians, so what comes back is
+ * a distance in the caller's own units.
+ *
+ * Exported because a crown is not only the bed's. `reef.ts` grows its anemones
+ * out of `crown` and `crownAt`, which means it has the same question to answer
+ * about whether one has moved far enough to be worth drawing again, and an
+ * estimate written down twice is an estimate that agrees with itself only until
+ * somebody edits one of them.
+ *
+ * It is `SWEEP`'s own number rather than a copy of it, for that reason.
+ */
+export function crownSwept(span: number, turned: number): number {
+  return span * SWEEP.anemone * turned
+}
+
+/**
+ * A crown at a moment, walked out of a mouth you give it.
+ *
+ * `span` is the column's height in whatever the caller draws in, so a crown
+ * dealt once can be cut at 1 for a drawing that is about to be scaled and at
+ * its real height for one that is not. `phase` is the animal's own clock, and
+ * it is an argument rather than something this owns, so a scene can be wound
+ * forward to a moment rather than stepped through every moment before it.
+ */
+export function crownAt(
+  mouth: Point,
+  tentacles: readonly Tentacle[],
+  span: number,
+  phase: number,
+): Blade[] {
+  return tentacles.map((one) =>
+    feeler(
+      mouth.x + one.shift * span,
+      mouth.y,
+      one.span * span,
+      one.slant,
+      phase * one.beat + one.own,
+      one.steps,
+    ),
+  )
+}
+
+/** Where something is going to stand: somewhere across the box, at a distance. */
+interface Spot {
+  readonly depth: number
+  readonly x: number
+}
+
+/**
+ * The water as it stood when a plant was last cut.
+ *
+ * Everything a drawing was made from and nothing else, so how far the plant has
+ * wandered since is arithmetic on four numbers. Against the last cut rather
+ * than the last step, because a sum of per-step movements drifts upward on a
+ * plant that is swaying back and forth and would recut one that had returned to
+ * where it started.
+ */
+interface Drawn {
+  readonly amp: number
+  readonly fright: number
+  readonly own: number
+  /** How tall the column stood, which only a crown pulling itself in changes. */
+  readonly stem: number
+}
+
+interface Sway {
+  /** How pulled in it is, 0 open and 1 shut. Nothing but a crown is ever
+   *  anything but 0. */
+  readonly fright: number
+  readonly lean: number
+  /**
+   * Whatever else the plant is made of: the rest of a clump of grass, the
+   * tentacles of a crown, the ribs of a fan. Empty for kelp, whose leaves are
+   * cut off its strand where they sit rather than placed around it.
+   */
+  readonly mates: readonly Mate[]
+  readonly own: number
+  readonly rate: number
+  readonly steps: number
+  /** The crown, dealt once. Empty for anything that is not an anemone. */
+  readonly tentacles: readonly Tentacle[]
+  /** Which weed it is. Null for anything that is not one. */
+  readonly weed: Weed | null
+}
+
+/**
+ * One line of a plant, and where it leaves whatever it grows from.
+ *
+ * Everything a plant is made of past its leaves is one of these, which is the
+ * point of writing it down: a fork off a kelp, a blade of a clump, a rib of a
+ * fan and a twig off a rib were four pieces of arithmetic saying the same
+ * thing, and they are now one.
+ *
+ * `beat` and `own` are how its clock runs against the plant's, a multiplier and
+ * an offset, and `give` is what share of the plant's amplitude reaches it. A
+ * fan's ribs are stiff because their give is a half; a fork high up a wrack
+ * moves less than the strand under it for the same reason and by its own share.
+ */
+export interface Limb {
+  readonly beat: number
+  readonly give: number
+  readonly own: number
+  /** Where up the limb it leaves, 0 at that limb's root and 1 at its tip. */
+  readonly seat: number
+  /** How far along the ground it is rooted, for a limb that leaves no limb. */
+  readonly shift: number
+  readonly slant: number
+  readonly span: number
+  /** Which limb it leaves, or -1 for the ground. */
+  readonly stem: number
+  readonly steps: number
+}
+
+/**
+ * One leaf, as the shape it is in the frame of the limb it grows on.
+ *
+ * `x` is how far back down the limb the point is and `y` how far out across it,
+ * both in px, so the drawing is finished the moment the plant is sown and all
+ * that is ever done with it again is stand it up wherever the limb has got to.
+ */
+export interface Leaf {
+  readonly limb: number
+  readonly seat: number
+  readonly shape: readonly Point[]
+}
+
+/** What a plant is made of: its limbs, in the order they are drawn. */
+export interface Frame {
+  readonly leaves: readonly Leaf[]
+  readonly limbs: readonly Limb[]
+}
+
+/**
+ * Where the water has a plant's sway got to.
+ *
+ * The whole of what a `Frame` has to be evaluated at, which is the point of it
+ * being two numbers: a renderer that has taken the shape once takes this a
+ * frame, and a bed of six hundred plants is under five kilobytes of it.
+ */
+export interface Swing {
+  readonly amp: number
+  readonly own: number
+}
+
+/**
+ * One more blade in a clump: where it sits, how tall, and which way it leans.
+ *
+ * `slant` is a fixed tilt off upright and `own` its own place in the sway, so
+ * two blades of one clump are never at the same point of the same swing. They
+ * share the clump's amplitude, which is what keeps them a clump.
+ */
+interface Mate {
+  /** How much faster or slower than its clump this blade works through the
+   *  sway, so a clump drifts out of step with itself instead of pulsing. */
+  readonly beat: number
+  readonly own: number
+  /** Where up the strand it leaves, 0 at the root and 1 at the tip. A fan's
+   *  ribs climb its stem; everything else leaves from one place. */
+  readonly seat: number
+  readonly shift: number
+  readonly slant: number
+  readonly span: number
+}
+
+export function createFlora(options: FloraOptions): Flora {
+  const noise = makeNoise2(options.seed ^ 0x4f10)
+  const random = makeRandom(options.seed ^ 0x6b3c)
+
+  let width = Math.max(MIN_SPAN, options.width)
+  let height = Math.max(MIN_SPAN, options.height)
+  let floor = options.floor
+  let drift = 0
+
+  const plants: Plant[] = []
+  const sways: Sway[] = []
+
+  const tolerance = Math.max(0, options.tolerance ?? TOLERANCE)
+
+  /** Which kinds are drawn here rather than left to whoever asked. */
+  const cutting = new Set<PlantKind>(
+    options.cutting ?? ["anemone", "coral", "fan", "grass", "kelp"],
+  )
+
+  /** What each plant was cut from, or null while it has never been cut. */
+  const drawn: (Drawn | null)[] = []
+
+  /** What each plant is made of, worked out the first time it is drawn. */
+  const frames: (Frame | null)[] = []
+
+  /** Where each plant's sway has got to, kept rather than made every step. */
+  const swinging: { amp: number; own: number }[] = []
+
+  /** The beds the grass grows in, dealt again whenever the box changes. */
+  const beds: Spot[] = []
+
+  /** How tall each strand stands. Off the Plant, because a renderer wants the
+   *  points rather than the number they were cut from. */
+  const heights = new Map<number, number>()
+
+  function plant(kind: PlantKind): void {
+    let { depth, x } = where(kind)
+
+    // Asked again rather than pushed aside, since a plant moved off a clearing
+    // lands on its edge and a bed with a rim of weed around a bald spot is more
+    // obviously arranged than one with a gap in it. A handful of tries, because
+    // a clearing is a patch and not most of the floor.
+    for (let again = 0; again < BARE_TRIES && options.bare?.(x, depth); again++) {
+      const spot = where(kind)
+      depth = spot.depth
+      x = spot.x
+    }
+    if (options.bare?.(x, depth)) return
+
+    if (kind === "coral") {
+      plants.push({
+        blades: [],
+        cut: 0,
+        depth,
+        girth: 0,
+        kind,
+        points: [],
+        scale: (CORAL_SMALLEST + random() * (CORAL_LARGEST - CORAL_SMALLEST)) * shrunk(depth),
+        twigs: gathered(REEF[Math.floor(random() * REEF.length)] ?? CORAL),
+        x,
+        y: floor(x, depth),
+      })
+      sways.push({
+        fright: 0,
+        lean: 0,
+        mates: [],
+        own: random() * Math.PI * 2,
+        rate: 0,
+        steps: 0,
+        tentacles: [],
+        weed: null,
+      })
+      drawn.push(null)
+      return
+    }
+
+    const weed = kind === "kelp" ? (WEEDS[Math.floor(random() * WEEDS.length)] ?? FRILL) : null
+    const span = height * stature(kind, weed) * shrunk(depth)
+
+    plants.push({
+      blades: [],
+      cut: 0,
+      depth,
+      girth: girthOf(kind, weed, span, depth),
+      kind,
+      points: [],
+      scale: 1,
+      twigs: [],
+      x,
+      y: floor(x, depth),
+    })
+
+    sways.push({
+      fright: 0,
+      lean: span * LEANS[kind],
+      mates: crop(kind, span),
+      own: random() * Math.PI * 2,
+      rate: SWAY_SLOWEST + random() * (SWAY_FASTEST - SWAY_SLOWEST),
+      steps: cuts(STEPS[kind], span * STEMS[kind]),
+      tentacles: kind === "anemone" ? crown((random() * 0xffff) | 0, span) : [],
+      weed,
+    })
+
+    drawn.push(null)
+    heights.set(plants.length - 1, span)
+  }
+
+  /** How tall one stands, as a share of the box's height. */
+  function stature(kind: PlantKind, weed: Weed | null): number {
+    if (kind === "anemone") return ANEMONE_LEAST + random() * ANEMONE_SPAN
+    if (kind === "fan") return FAN_LEAST + random() * FAN_SPAN
+    if (kind === "kelp") return (KELP_LEAST + random() * KELP_SPAN) * (weed?.stature ?? 1)
+    return GRASS_LEAST + random() * GRASS_SPAN
+  }
+
+  /** Whatever else the plant is made of, placed once and cut every step. */
+  function crop(kind: PlantKind, span: number): Mate[] {
+    if (kind === "fan") return ribs(span)
+    if (kind === "grass") return clump(span)
+    return []
+  }
+
+  /** Where one of these goes: its bed if it has one, the back of the water if
+   *  it is worth most there, and anywhere at all otherwise. */
+  function where(kind: PlantKind): Spot {
+    if (kind === "anemone") {
+      return {
+        depth: DEPTH_FAR + random() ** CROWN_BACK * (DEPTH_NEAR - DEPTH_FAR),
+        x: random() * width,
+      }
+    }
+    return kind === "grass" ? sprig() : anywhere()
+  }
+
+  /** Somewhere across the box, at any distance the bed reaches. */
+  function anywhere(): Spot {
+    return { depth: DEPTH_FAR + random() * (DEPTH_NEAR - DEPTH_FAR), x: random() * width }
+  }
+
+  /**
+   * Where one clump of grass lands.
+   *
+   * In a bed, nearer its middle than its edge, which is what two draws added
+   * together buy for nothing. A few land nowhere near one, so that no bed has an
+   * edge the eye can find.
+   */
+  function sprig(): Spot {
+    const bed = beds[Math.floor(random() * beds.length)]
+    if (!bed || random() < MEADOW_STRAY) return anywhere()
+
+    const depth = bed.depth + (random() + random() - 1) * MEADOW_DEEP
+
+    return {
+      depth: Math.min(DEPTH_NEAR, Math.max(DEPTH_FAR, depth)),
+      x: bed.x + (random() + random() - 1) * MEADOW_SPREAD * width,
+    }
+  }
+
+  /**
+   * The blades standing around one root, the tallest of which is drawn already.
+   *
+   * They lean away from the middle rather than at random, because a clump is
+   * one plant opening out and not a handful of separate ones that happen to
+   * have landed together.
+   */
+  function clump(span: number): Mate[] {
+    const mates: Mate[] = []
+    const most = TUFT_LEAST + Math.floor(random() * (TUFT_MOST - TUFT_LEAST + 1))
+    const count = crowded(most, TUFT_FEWEST, span, TUFT_CROWDED)
+
+    for (let made = 0; made < count; made++) {
+      const side = made % 2 === 0 ? 1 : -1
+      const out = (Math.floor(made / 2) + 1) / Math.ceil(count / 2)
+
+      mates.push({
+        beat: 0.82 + random() * 0.4,
+        own: random() * Math.PI * 2,
+        seat: 0,
+        shift: side * out * span * TUFT_ROOT * (0.4 + random() * 0.6),
+        slant: side * out * TUFT_SPLAY * (0.5 + random() * 0.5),
+        span: span * (GRASS_RUNT + random() * (1 - GRASS_RUNT)),
+      })
+    }
+    return mates
+  }
+
+  /**
+   * The ribs of a fan, longest and widest at the foot.
+   *
+   * A gorgonian is broad where it leaves the ground and comes to nothing at the
+   * top, so a rib that leaves low is long and opens near flat, and one that
+   * leaves high is short and nearly upright. Cut the other way round it is a
+   * tree, which is a fine shape and is not this one.
+   */
+  function ribs(span: number): Mate[] {
+    const mates: Mate[] = []
+    const most = RIB_LEAST + Math.floor(random() * (RIB_MOST - RIB_LEAST + 1))
+    const count = crowded(most, RIB_FEWEST, span, RIB_CROWDED)
+
+    for (let made = 0; made < count; made++) {
+      const side = made % 2 === 0 ? 1 : -1
+      const up = (Math.floor(made / 2) + 1) / Math.ceil(count / 2)
+
+      mates.push({
+        beat: 0.9 + random() * 0.25,
+        own: random() * Math.PI * 2,
+        seat: Math.min(1, RIB_SEAT + up * (1 - RIB_SEAT) * (0.75 + random() * 0.35)),
+        shift: 0,
+        slant: side * RIB_OPEN * (1 - up * 0.55),
+        span: span * RIB_REACH * (1 - up * 0.18),
+      })
+    }
+    return mates
+  }
+
+  function sow(): void {
+    plants.length = 0
+    sways.length = 0
+    beds.length = 0
+    drawn.length = 0
+    frames.length = 0
+    swinging.length = 0
+    heights.clear()
+
+    for (let made = 0; made < Math.max(1, Math.round(width / MEADOW_EVERY)); made++) {
+      beds.push(anywhere())
+    }
+
+    for (let made = 0; made < Math.max(0, options.anemones ?? 0); made++) plant("anemone")
+    for (let made = 0; made < Math.max(0, options.corals ?? 0); made++) plant("coral")
+    for (let made = 0; made < Math.max(0, options.fans ?? 0); made++) plant("fan")
+    for (let made = 0; made < Math.max(0, options.grasses ?? 0); made++) plant("grass")
+    for (let made = 0; made < Math.max(0, options.kelps ?? 0); made++) plant("kelp")
+  }
+
+  /**
+   * Recut one strand where the water currently has it.
+   *
+   * The bend is the site's, and the amplitude is this file's own business: a
+   * share of it comes off the shared field at the plant's own position, so a
+   * stretch of bed leans together, and the rest is the plant's own slow swing.
+   */
+  function bend(at: number, field: Noise2): void {
+    const one = plants[at]
+    const sway = sways[at]
+    const span = heights.get(at)
+    if (!one || !sway || span == null || one.kind === "coral") return
+
+    const current = field((one.x / width) * FIELD_CELLS + drift, drift)
+    const own = Math.sin(sway.own)
+    const amp = sway.lean * (current * CURRENT_SHARE + own * (1 - CURRENT_SHARE))
+
+    // Written down whether or not the plant is worth cutting again, because a
+    // renderer bending the shape itself wants where the water is now and has no
+    // use at all for how far it has come since the last drawing.
+    const swing = swinging[at]
+    if (swing) {
+      swing.amp = amp
+      swing.own = sway.own
+    } else {
+      swinging[at] = { amp, own: sway.own }
+    }
+
+    if (!cutting.has(one.kind)) return
+
+    // A frightened crown hunches: the column squats and the tentacles come in.
+    // Both off the one number, because they are one movement.
+    const shy = one.kind === "anemone" ? 1 - sway.fright * COLUMN_SQUAT : 1
+    const stem = span * STEMS[one.kind] * shy
+    const was = drawn[at]
+    if (was && stir(one.kind, span, was, amp, sway.fright, sway.own, stem) < tolerance) return
+
+    drawn[at] = { amp, fright: sway.fright, own: sway.own, stem }
+    one.cut++
+
+    if (one.kind === "anemone") {
+      // A crown is walked rather than cut, so it is the one thing here that is
+      // not a shape the water bends: it is a heading that keeps turning, and
+      // where it has turned to is the clock itself. The column is a strand like
+      // any other, and the crown leaves from wherever the water has left its
+      // mouth. That is the whole of what the two have to say to each other: the
+      // crown is not reading the current, it is riding on something that did.
+      const points = strand(one.x, one.y, stem, sway.own, amp, 0, sway.steps)
+      const mouth = points[points.length - 1]
+      const out = span * (1 - sway.fright * CROWN_PULL)
+
+      one.points = points
+      one.blades = mouth ? crownAt(mouth, sway.tentacles, out, sway.own) : []
+      return
+    }
+
+    cutFrom(one, framed(at), amp, sway.own)
+  }
+
+  /**
+   * What a plant is made of, worked out once and kept.
+   *
+   * Everything here was already fixed when the plant was sown: where a fork
+   * leaves, how many leaves a weed that tall carries, how far out a rib opens,
+   * how long a leaf is and what shape. None of it is anything the water has a
+   * say in. It was being worked out again on every plant on every frame it
+   * moved, which is most of what a bed cost to draw.
+   *
+   * Splitting it out buys a second thing, and the second thing is the larger.
+   * A plant that can say what it is made of can be handed to a renderer that
+   * bends it somewhere else: the shape goes over once and the water sends two
+   * numbers a frame after that. A plant that can only hand over the points it
+   * happens to be at this instant has to hand them all over again every time
+   * it moves.
+   */
+  function framed(at: number): Frame {
+    const held = frames[at]
+    if (held) return held
+
+    const made = grown(at)
+    frames[at] = made
+    return made
+  }
+
+  /** Where up a line something leaves it, as one of the points it was cut at. */
+  const seated = (seat: number, steps: number): number =>
+    Math.min(steps, Math.max(0, Math.round(seat * steps))) / steps
+
+  /**
+   * The lines a plant is made of, and the leaves hanging off them.
+   *
+   * A limb knows the limb it leaves and where up it, so the whole plant is a
+   * short tree and cutting it is one pass down the list. The order the limbs
+   * are written in is the order they are drawn in, because it is also the order
+   * they were in when this was three branches of one function.
+   */
+  function grown(at: number): Frame {
+    const one = plants[at]
+    const sway = sways[at]
+    const span = heights.get(at)
+    if (!one || !sway || span == null) return { leaves: [], limbs: [] }
+
+    const limbs: Limb[] = [
+      {
+        beat: 1,
+        give: 1,
+        own: 0,
+        seat: 0,
+        shift: 0,
+        slant: 0,
+        span: span * STEMS[one.kind],
+        stem: -1,
+        steps: sway.steps,
+      },
+    ]
+
+    if (one.kind === "grass") {
+      for (const mate of sway.mates) {
+        limbs.push({
+          beat: mate.beat,
+          give: 1,
+          own: mate.own,
+          seat: 0,
+          shift: mate.shift,
+          slant: mate.slant,
+          span: mate.span,
+          stem: -1,
+          steps: cuts(sway.steps, mate.span),
+        })
+      }
+      return { leaves: [], limbs }
+    }
+
+    if (one.kind === "fan") {
+      for (const mate of sway.mates) {
+        const rib = limbs.length
+        const steps = cuts(FAN_STEPS, mate.span)
+
+        limbs.push({
+          beat: mate.beat,
+          give: RIB_GIVE,
+          own: mate.own,
+          seat: seated(mate.seat, sway.steps),
+          shift: 0,
+          slant: mate.slant,
+          span: mate.span,
+          stem: 0,
+          steps,
+        })
+
+        if (mate.span < RIB_TWIGGED) continue
+
+        limbs.push({
+          beat: 1,
+          give: RIB_GIVE,
+          own: mate.own,
+          seat: Math.floor((steps + 1) / 2) / steps,
+          shift: 0,
+          slant: mate.slant * RIB_SPLAY,
+          span: mate.span * RIB_TWIG,
+          stem: rib,
+          steps: 2,
+        })
+      }
+      return { leaves: [], limbs }
+    }
+
+    const weed = sway.weed ?? FRILL
+
+    weed.forks.forEach((up, made) => {
+      limbs.push({
+        beat: 1,
+        give: 1 - up,
+        own: up * Math.PI,
+        seat: seated(up, sway.steps),
+        shift: 0,
+        slant: (made % 2 === 0 ? 1 : -1) * FORK_SPLAY,
+        span: span * (1 - up) * FORK_REACH,
+        stem: 0,
+        steps: Math.max(FEWEST_STEPS, Math.round(sway.steps * (1 - up))),
+      })
+    })
+
+    return { leaves: leafage(weed, limbs, span), limbs }
+  }
+
+  /**
+   * Where the leaves sit on a plant's limbs, and the shape each of them is.
+   *
+   * The shape is written down in the frame of the limb it grows on: how far
+   * back down the limb, and how far out across it. What that saves is the whole
+   * of a leaf's arithmetic, since a leaf is the same drawing whatever the water
+   * is doing and only the frame it hangs in moves.
+   *
+   * A leaf's length is taken off the limb's own reach rather than off the
+   * length the limb happens to be bent to. It is the argument the leaf count
+   * already makes: a drawing dealt when the plant was sown must not gain and
+   * lose anything as the plant sways.
+   */
+  function leafage(weed: Weed, limbs: readonly Limb[], span: number): Leaf[] {
+    const leaves: Leaf[] = []
+    const leafy = crowded(weed.blades, LEAF_FEWEST, span, LEAF_CROWDED)
+    const each = Math.max(1, Math.round(leafy / limbs.length))
+    const bends = cuts(BLADE_STEPS, span * weed.span)
+
+    limbs.forEach((limb, on) => {
+      for (let made = 0; made < each; made++) {
+        const seat = weed.seat + (made / each) * (1 - weed.seat)
+        const side = made % 2 === 0 ? 1 : -1
+
+        // Shorter the higher up it sits, which is what a plant that has been
+        // growing from the bottom for a season looks like.
+        const long = limb.span * weed.span * (1 - weed.taper * seat)
+
+        const shape: Point[] = []
+        for (let step = 0; step <= bends; step++) {
+          const u = step / bends
+          const out = Math.sin(u * Math.PI * 0.62) * (1 - u * 0.72) * weed.flare
+          shape.push({ x: u * weed.trail * long, y: out * long * side })
+        }
+
+        leaves.push({ limb: on, seat: seated(seat, limb.steps), shape })
+      }
+    })
+
+    return leaves
+  }
+
+  /**
+   * Cut a plant where the water has it: every limb, and then every leaf.
+   *
+   * One pass, because a limb never leaves a limb written after it. What a leaf
+   * needs is the two points its own limb was cut at where it sits, since down
+   * the limb and out across it are both read off the line as drawn: that is the
+   * whole of why a leaf never crosses what it grows from, however far the plant
+   * is leaning.
+   */
+  function cutFrom(one: Plant, frame: Frame, amp: number, own: number): void {
+    const lines: Point[][] = []
+
+    for (const limb of frame.limbs) {
+      const root =
+        limb.stem < 0 ? { x: one.x + limb.shift, y: one.y } : at(lines[limb.stem], limb.seat)
+
+      lines.push(
+        strand(
+          root.x,
+          root.y,
+          limb.span,
+          own * limb.beat + limb.own,
+          amp * limb.give,
+          limb.slant,
+          limb.steps,
+        ),
+      )
+    }
+
+    const blades: Blade[] = lines.slice(1)
+
+    for (const leaf of frame.leaves) {
+      const line = lines[leaf.limb]
+      if (!line) continue
+
+      const up = Math.round(leaf.seat * (line.length - 1))
+      const on = line[Math.min(line.length - 1, up)]
+      const under = line[Math.max(0, up - 1)]
+      if (!on || !under) continue
+
+      const runX = on.x - under.x
+      const runY = on.y - under.y
+      const run = Math.hypot(runX, runY) || 1
+
+      const trailX = -runX / run
+      const trailY = -runY / run
+      const blade: Point[] = []
+      for (const step of leaf.shape) {
+        blade.push({
+          x: on.x + trailX * step.x + trailY * step.y,
+          y: on.y + trailY * step.x - trailX * step.y,
+        })
+      }
+      blades.push(blade)
+    }
+
+    one.points = lines[0] ?? []
+    one.blades = blades
+  }
+
+  /** The point a line was cut at, this far up it. */
+  function at(line: Point[] | undefined, seat: number): Point {
+    if (!line || line.length === 0) return { x: 0, y: 0 }
+    const up = Math.round(seat * (line.length - 1))
+    return line[Math.min(line.length - 1, Math.max(0, up))] ?? { x: 0, y: 0 }
+  }
+
+  /**
+   * One line from a root, bent by the water and tilted off upright.
+   *
+   * The bend is the site's `Marks.strand/3`: the `* t` is what plants the base
+   * and lets only the tip travel. The slant is this file's own, and it is a
+   * whole rotation rather than a nudge to the top, so a blade leaning out of a
+   * clump leaves the ground already leaning instead of curving away halfway up.
+   */
+  function strand(
+    x: number,
+    y: number,
+    span: number,
+    phase: number,
+    amp: number,
+    slant: number,
+    steps: number,
+  ): Point[] {
+    const lean = Math.sin(slant)
+    const rise = Math.cos(slant)
+
+    const points: Point[] = []
+    for (let step = 0; step <= steps; step++) {
+      const t = step / steps
+      points.push({
+        x: x + span * t * lean + amp * Math.sin(phase + t * 2.4) * t,
+        y: y - span * t * rise,
+      })
+    }
+    return points
+  }
+
+  /**
+   * How pulled in this crown should be, given what is in the water.
+   *
+   * Bigger than it is and nearly on top of it; see `CROWN_MINDS`. Nothing here
+   * is told anything: the bed reads the register once a step and every crown in
+   * it makes up its own mind, which is why two anemones a hand apart do not
+   * shut together.
+   */
+  function scared(one: Plant, span: number, water: readonly Presence[]): number {
+    let worst = 0
+
+    for (const thing of water) {
+      if (thing.size < span * CROWN_MINDS) continue
+
+      const reach = thing.size * CROWN_NOTICE
+      const away = Math.hypot(one.x - thing.x, one.y - thing.y)
+      if (away >= reach) continue
+
+      // Weighed by how nearly abreast the two are, because a screen has two
+      // distances and this water has three: something crossing at the glass is
+      // not on top of a crown rooted in the murk, however neatly they line up.
+      worst = Math.max(worst, (1 - away / reach) * abreast(one.depth, thing.depth))
+    }
+
+    return worst
+  }
+
+  /** Put every clock forward, which is all a stretch of time does to a bed. */
+  function carry(seconds: number, water: readonly Presence[]): void {
+    drift += DRIFT * seconds
+
+    for (let at = 0; at < sways.length; at++) {
+      const sway = sways[at]
+      const one = plants[at]
+      if (!sway || !one) continue
+
+      const shy = one.kind === "anemone" ? scared(one, heights.get(at) ?? 0, water) : 0
+      const fright = Math.max(0, Math.max(sway.fright - seconds / PULL_FADE, shy))
+
+      // Reassigning through the array keeps `Sway` readable as a record.
+      if (sway.rate > 0 || fright !== sway.fright) {
+        sways[at] = { ...sway, fright, own: sway.own + sway.rate * seconds }
+      }
+    }
+  }
+
+  /**
+   * How far a point on a plant can have travelled since it was last cut.
+   *
+   * A bound, and the whole worth of it is that it costs four subtractions where
+   * finding out for certain costs the cut. The tip of a strand sits at
+   * `amp * sin(phase + 2.4)`, so a change in the amplitude moves it by no more
+   * than that change, and a change in the phase by no more than the amplitude
+   * times the angle turned. Every point below the tip moves less, because the
+   * `* t` that plants the root shortens all of it.
+   *
+   * The column's height is the third term and a crown's grip on its own
+   * tentacles is the fourth, since those are the other two numbers a drawing is
+   * made from. `SWING` carries whatever the plant has hung off its strand and
+   * `SWEEP` carries whatever moves without the water moving it.
+   *
+   * It runs high rather than low, deliberately. Over-reporting spends a cut
+   * that was not needed and under-reporting leaves a stale drawing on the
+   * screen, and only one of those is visible.
+   */
+  function stir(
+    kind: PlantKind,
+    span: number,
+    was: Drawn,
+    amp: number,
+    fright: number,
+    own: number,
+    stem: number,
+  ): number {
+    const reach = Math.max(Math.abs(amp), Math.abs(was.amp))
+    const turned = Math.abs(own - was.own)
+
+    return (
+      (Math.abs(amp - was.amp) + reach * turned) * SWING[kind] +
+      span * SWEEP[kind] * turned +
+      Math.abs(stem - was.stem) +
+      Math.abs(fright - was.fright) * span * CROWN_PULL
+    )
+  }
+
+  /** Recut every plant the water has moved far enough to be worth recutting. */
+  function recut(): void {
+    for (let at = 0; at < plants.length; at++) bend(at, noise)
+  }
+
+  function advance(seconds: number): void {
+    carry(Math.min(Math.max(seconds, 0), 0.1), options.about?.() ?? [])
+    recut()
+  }
+
+  sow()
+  advance(0)
+
+  return {
+    madeOf(at) {
+      const one = plants[at]
+      if (!one || one.kind === "coral" || one.kind === "anemone") return null
+      return framed(at)
+    },
+
+    plants,
+
+    resize(nextWidth, nextHeight, nextFloor) {
+      width = Math.max(MIN_SPAN, nextWidth)
+      height = Math.max(MIN_SPAN, nextHeight)
+      floor = nextFloor
+      sow()
+      advance(0)
+    },
+
+    step: advance,
+
+    swinging,
+
+    wind(seconds) {
+      // Wound through empty water, whatever is in it now. A wind is how a scene
+      // opens somewhere other than its starting line, and nothing was in the
+      // water while nobody was watching it.
+      carry(Math.max(seconds, 0), [])
+      recut()
+    },
+  }
+}