@codincod/ornament 0.0.0-stage → 0.2.0

package/src/jellies.ts

@@ -0,0 +1,1794 @@
+/**
+ * The jellyfish, of which there are eight and no two of them swim alike.
+ *
+ * A drifting animal is the hardest thing in this water to get right, because
+ * the wrong version of it is so cheap: a dome, a few streamers, a sine wave on
+ * the vertical, and the eye files it under decoration within a second. What
+ * makes a real one worth watching is that it is barely in charge of where it
+ * goes. It holds itself the right way up, it pushes when it wants to be
+ * higher, and the rest of its afternoon belongs to the water.
+ *
+ * So the model here is the animal's, and the horizontal is the current's. A
+ * bell points at the sky, a contraction drives it along the axis it is
+ * pointing, and how deep it ends up is settled by how often it bothers. Let
+ * that run and the sawtooth comes out on its own: a climb on every pulse, a
+ * slow sink between them, and a whole animal's day of holding one depth
+ * without anything ever setting a depth.
+ *
+ * ## Eight of them, and the differences are not decoration
+ *
+ * `Drive` is the argument for the file. Three of these animals do not pulse at
+ * all and two of them are not jellyfish, which is the sort of fact that reads
+ * as pedantry until you watch the water: a comb jelly gliding past a pulsing
+ * moon jelly is the clearest statement of scale and difference the scene can
+ * make with two small shapes.
+ *
+ *   * **Moon** (*Aurelia aurita*), the saucer with four horseshoes in it. Its
+ *     bell is a spring: the contraction throws a starting vortex off the rim
+ *     and the elastic refill catches it, so one beat gives two pushes and the
+ *     second is free. Gemmell and others measured it in PNAS in 2013 and
+ *     called it passive energy recapture, and it is `Habit.recapture`.
+ *   * **Barrel** (*Rhizostoma pulmo*), a bell to 90 cm with no marginal
+ *     tentacles whatever and eight fused oral arms hanging under it. The
+ *     strongest swimmer of the pulsers here and the steadiest.
+ *   * **Lion's mane** (*Cyanea capillata*), the largest of them, its tentacles
+ *     in eight clusters and the whole mass reported past 30 m in the north
+ *     Atlantic. Slow, cold, and drawn as hair rather than as a body; see the
+ *     note on `veil` below.
+ *   * **Box** (*Chironex fleckeri*), the one with eyes. Twenty-four of them in
+ *     four rhopalia, a tentacle bundle off each of the four pedalia, and a
+ *     documented habit of steering round an obstacle instead of into it. It is
+ *     the only animal in this file handed `about`, and that is the reason.
+ *   * **Crown** (the coronates, *Atolla* and *Periphylla*), a deep red disc
+ *     with a groove cut round it and one trailing tentacle far longer than the
+ *     rest. Attacked, an *Atolla* runs a wave of blue light round its margin
+ *     and keeps running it: the burglar alarm, meant to call in something
+ *     bigger than whatever has hold of it. `Answer` is where that lives.
+ *   * **Man o' war** (*Physalia physalis*), which is not one animal and cannot
+ *     swim. A colony under a gas float, sailing at an angle to the wind, with
+ *     left-handed and right-handed forms that leave on opposite tacks. It
+ *     never pulses and it never leaves the surface.
+ *   * **Comb** (*Mnemiopsis leidyi*), a ctenophore, so not a jellyfish and not
+ *     even close: no stinging cells, eight rows of fused cilia beating in a
+ *     travelling wave, and two oral lobes held open like a scoop. It swims
+ *     mouth first, which is the detail worth drawing, because everything else
+ *     in this water leads with the end that is not its mouth.
+ *   * **Mauve stinger** (*Pelagia noctiluca*), a bell the size of a fist
+ *     covered in warts, with only eight marginal tentacles and four oral arms,
+ *     all of them long. It has no seabed stage at all, which is why it arrives
+ *     in the millions or not at all, and its warts sting, which is why a
+ *     swimmer can be stung by a part of it that is not a tentacle.
+ *
+ * ## What a startle is worth to something with no brain
+ *
+ * Almost nothing it does with its body. A hull going over empties a reef and a
+ * moon jelly does not notice, because there is nothing in a moon jelly that
+ * could. Only the box jelly moves, and only because it can see; the comb jelly
+ * and the man o' war gather themselves in and stop. That is the whole of
+ * `Answer`.
+ *
+ * What three of them do instead is make light. Around half the medusae in the
+ * sea are bioluminescent, which is more of them than anybody guesses, and none
+ * of it is left on: touched, then fading over seconds. `Light` is
+ * a column of its own for that reason, since a crown jelly answers with light
+ * and nothing else while a comb jelly does both at once. Three displays, and
+ * they are not the same display at three strengths: a wave that runs round a
+ * margin, a wash over a whole animal, and eight rows lit end to end.
+ *
+ * It is worth nothing in daylight, and that is not a defect to be tuned out.
+ * A flash is measured against the water around it, so these are a night thing,
+ * and the one light in this file that runs the other way is the comb jelly's
+ * diffraction, which needs a sun to take apart and dies in the dark. Both are
+ * the renderer's to weigh; see `combRows` and `washOf`.
+ *
+ * ## Hair is not a body
+ *
+ * `visitors.ts` reached this first and the reasoning carries over whole: a fine
+ * mass scatters light instead of stopping it, so a lion's mane drawn at the
+ * weight of its own bell is a solid animal wearing a solid skirt. What hangs
+ * under these is handed over separately and `VEIL_INK` in `visitors.ts` is the
+ * share it is drawn at.
+ */
+
+import { abreast, type Biome, type Presence } from "./biome.ts"
+import { mixOf } from "./census.ts"
+import { makeNoise2, makeRandom } from "./perlin.ts"
+import type { Point } from "./seabed.ts"
+import { felt, type Startle } from "./shoal.ts"
+import { drawnAt } from "./sizes.ts"
+
+export type JellyKind =
+  | "barrel"
+  | "box"
+  | "comb"
+  | "crown"
+  | "mane"
+  | "manowar"
+  | "moon"
+  | "stinger"
+
+/**
+ * How a thing gets about.
+ *
+ * The three ways anything in this file moves, and they are three different
+ * animals rather than three settings.
+ *
+ *   * `pulse` squeezes a bell and coasts. Nothing happens between the beats,
+ *     and the gap is most of the cycle.
+ *   * `cilia` never stops. Eight rows of hairs beating in a travelling wave
+ *     give a push that has no peak in it, so a ctenophore glides where a
+ *     jellyfish lurches.
+ *   * `sail` has no engine at all. A float on the surface goes where the wind
+ *     puts it and heels over on the way.
+ */
+export type Drive = "cilia" | "pulse" | "sail"
+
+/**
+ * What one does with its body when something goes over.
+ *
+ * `none` is the common answer and the honest one. The other two belong to the
+ * animals here with the equipment to give another. What a jellyfish does with
+ * light is a separate question and a separate column; see `Light`.
+ */
+export type Answer = "bolt" | "furl" | "none"
+
+/**
+ * What one does with light when something takes hold of it.
+ *
+ * Around half of the medusae in the sea make their own, which is more of them
+ * than most people would guess and is why this is a column rather than a
+ * special case. None of it is on all the time. Bioluminescence costs the
+ * animal something and it is spent when there is something to spend it on:
+ * every display here is fired by contact and fades over seconds.
+ *
+ *   * `wave` runs round the margin, turn after turn. A crown jelly's.
+ *   * `wash` lights the whole animal at once, bell, arms and tentacles. The
+ *     mauve stinger is named for it: *noctiluca* is the night light of the sea.
+ *   * `rows` lights the eight rows a comb jelly already has, which is the
+ *     detail worth having, because those rows are lit twice by two different
+ *     things. See `combRows`.
+ *
+ * It is blue in the sea, near 470 nm, since blue is what gets furthest through
+ * water. This scene has no blue in it, so every renderer here draws it in the
+ * moon's colour and nothing else in the water glows at all.
+ */
+export type Light = "none" | "rows" | "wash" | "wave"
+
+export interface Jelly {
+  /** Where it is in its own cycle, 0 to 1. A sail has one and ignores it. */
+  beat: number
+  /** 0 is as far off as this water goes, 1 is up against the glass. */
+  readonly depth: number
+  /** A mirror, 1 or -1. For a man o' war it is which tack it sails on. */
+  readonly facing: number
+  /**
+   * How brightly it is lighting itself, 0 dark and 1 full.
+   *
+   * Light the animal made, and nothing else. It is 0 until something touches
+   * it and 0 again a few seconds later, and for the four kinds that cannot
+   * make any it is 0 for their whole lives. What a comb jelly's rows scatter
+   * out of the water's own light is not this and is not read off it.
+   */
+  glow: number
+  readonly kind: JellyKind
+  /** Bell across in px, distance already taken out of it. */
+  readonly size: number
+  /**
+   * How gathered it is, 0 open and 1 shut.
+   *
+   * The number the drawing and the travel are both read off, which is the rule
+   * `Squid.squeeze` keeps and for the same reason. What it means depends on
+   * what has one: a bell contracting, oral lobes drawn in, or a
+   * float letting its crest down.
+   */
+  squeeze: number
+  /** How far the apex leans off straight up, in radians. */
+  tilt: number
+  /**
+   * How far the light has run, in radians.
+   *
+   * Round the margin for a crown jelly, whose alarm is a wave that keeps going
+   * round; down the rows for a comb jelly, whose cilia beat in sequence from
+   * the far end towards the mouth. Nothing else uses it.
+   */
+  wave: number
+  x: number
+  y: number
+}
+
+export interface Jellies {
+  readonly jellies: readonly Jelly[]
+  resize(width: number, height: number, count?: number): void
+  /**
+   * Advance by `seconds`. `startle` is whatever the water is being told to do,
+   * which three of the seven kinds can answer and four cannot.
+   */
+  step(seconds: number, startle?: Startle | null): void
+}
+
+export interface JelliesOptions {
+  count: number
+  /**
+   * Where the ground is, so that nothing settles into it.
+   *
+   * A box jelly hunts along the bottom and a lion's mane sinks whenever it
+   * stops pulsing, so both of them arrive at the sand sooner or later. Without
+   * this they arrive at the bottom of the box, which in a scene with hills in
+   * it is a bell buried up to its margin.
+   *
+   * Asked at the animal's own distance, since the ground has one. A bell that
+   * took the near sand for its floor would sink through the hill it is drifting
+   * over and come to rest among the roots of plants standing in front of it.
+   */
+  floor?: (x: number, depth?: number) => number
+  height: number
+  /** Which kinds may turn up. The whole table, unless a caller narrows it. */
+  kinds?: readonly JellyKind[]
+  seed: number
+  /**
+   * The water these are in, so that whatever swims past can see them.
+   *
+   * Entered rather than announced, the way `visitors.ts` enters a shark: what
+   * a lion's mane looks like to a small fish is a fact about the lion's mane.
+   * It is read as well as written, by the box jelly, which has the eyes to
+   * read it with. Left out, these drift a water nothing is watching, and
+   * nothing is watching them back.
+   */
+  water?: Biome
+  width: number
+}
+
+/**
+ * What one kind is, where it lives, and how it gets about.
+ *
+ * A row an animal, and the row is the whole difference between them: nothing
+ * in `step` branches on a kind except the three drives, so a jellyfish that
+ * needed a branch of its own would be a second simulation wearing this one's
+ * interface. The two would part company the first time either was tuned.
+ *
+ * The bells are real animals measured across, in metres, at the distance these
+ * all drift past at; `sizes.ts` turns the pair into a share of the box. A moon
+ * jelly runs to 40 cm, a barrel to 90, a north Atlantic lion's mane past a
+ * metre and a half, a box jelly's cube to 30 cm, and a comb jelly is the size
+ * of a plum. A man o' war is measured along its float rather than across a
+ * bell, since it has no bell.
+ *
+ * How common each is against the others is not a column here. It is the same
+ * question as how common a jellyfish is against a fish, so `census.ts` answers
+ * both, and a bloom is a day on which the water is nearly all of one of them.
+ *
+ * `beats` is contractions a second at rest, and the numbers are the published
+ * ones held to this water's own pace: an adult *Aurelia* runs near one a
+ * second, a barrel jelly slower, a lion's mane slower again, and a box jelly
+ * fast enough to run a fish down. `sink` is what happens the rest of the time,
+ * so a kind that pulses rarely had better be near neutral or it spends its day
+ * on the floor.
+ */
+interface Habit {
+  answer: Answer
+  /** How far the oral arms hang, in bell widths. */
+  armFall: number
+  /** How many hang under it. */
+  arms: number
+  /** Contractions a second while it is holding its depth. */
+  beats: number
+  /** How many bunches the marginal tentacles are gathered into. */
+  bunches: number
+  drive: Drive
+  /** How far back it lives: 0 the murk, 1 the glass. */
+  farLeast: number
+  farSpan: number
+  /** How far the marginal tentacles trail, in bell widths. */
+  hairFall: number
+  /** How many there are of them. */
+  hairs: number
+  /** What it does with light, which for half of them is nothing. */
+  light: Light
+  /** How much it looks like it stings, to anything that can see it. */
+  menace: number
+  /** What share of the cycle the contraction itself takes. */
+  push: number
+  /** What share of a pulse's push arrives on the refill instead. */
+  recapture: number
+  /** How far it leans off upright as it goes, in radians. */
+  roll: number
+  /** Where in the column it holds: 0 the surface, 1 the floor. */
+  seatLeast: number
+  seatSpan: number
+  /** Whether it can make out what is in the water with it. One of them can. */
+  sees: boolean
+  /** How fast it falls with nothing driving it, in bell widths a second. */
+  sink: number
+  /** How much way one pulse adds, in bell widths a second. */
+  thrust: number
+  /** How far the one long tentacle goes, in bell widths. Nothing, mostly. */
+  trail: number
+  /** How big it is across, in metres. */
+  wideLeast: number
+  wideSpan: number
+}
+
+const HABITS: Readonly<Record<JellyKind, Habit>> = {
+  barrel: {
+    answer: "none",
+    armFall: 0.85,
+    arms: 8,
+    beats: 0.55,
+    bunches: 1,
+    drive: "pulse",
+    farLeast: 0.32,
+    farSpan: 0.46,
+    hairFall: 0,
+    hairs: 0,
+    light: "none",
+    menace: 0.1,
+    push: 0.32,
+    recapture: 0.1,
+    roll: 0.1,
+    seatLeast: 0.3,
+    seatSpan: 0.34,
+    sees: false,
+    sink: 0.3,
+    thrust: 0.62,
+    trail: 0,
+    wideLeast: 0.4,
+    wideSpan: 0.5,
+  },
+  box: {
+    answer: "bolt",
+    armFall: 0,
+    arms: 0,
+    beats: 1.4,
+    bunches: 4,
+    drive: "pulse",
+    farLeast: 0.4,
+    farSpan: 0.4,
+    hairFall: 3.2,
+    hairs: 16,
+    light: "none",
+    menace: 0.55,
+    push: 0.3,
+    recapture: 0,
+    roll: 0.5,
+    seatLeast: 0.48,
+    seatSpan: 0.26,
+    sees: true,
+    sink: 0.22,
+    thrust: 0.95,
+    trail: 0,
+    wideLeast: 0.14,
+    wideSpan: 0.16,
+  },
+  comb: {
+    answer: "furl",
+    armFall: 0,
+    arms: 0,
+    beats: 3.2,
+    bunches: 1,
+    drive: "cilia",
+    farLeast: 0.5,
+    farSpan: 0.44,
+    hairFall: 0,
+    hairs: 0,
+    light: "rows",
+    menace: 0,
+    push: 0.5,
+    recapture: 0,
+    roll: 0.22,
+    seatLeast: 0.24,
+    seatSpan: 0.46,
+    sees: false,
+    sink: 0.05,
+    thrust: 0.34,
+    trail: 0,
+    wideLeast: 0.06,
+    wideSpan: 0.06,
+  },
+  crown: {
+    answer: "none",
+    armFall: 0,
+    arms: 0,
+    beats: 0.5,
+    bunches: 1,
+    drive: "pulse",
+    farLeast: 0.1,
+    farSpan: 0.3,
+    hairFall: 0.5,
+    hairs: 20,
+    light: "wave",
+    menace: 0.15,
+    push: 0.34,
+    recapture: 0.05,
+    roll: 0.12,
+    seatLeast: 0.54,
+    seatSpan: 0.2,
+    sees: false,
+    sink: 0.3,
+    thrust: 0.5,
+    trail: 3.4,
+    wideLeast: 0.09,
+    wideSpan: 0.09,
+  },
+  mane: {
+    answer: "none",
+    armFall: 1.05,
+    arms: 4,
+    beats: 0.34,
+    bunches: 8,
+    drive: "pulse",
+    farLeast: 0.18,
+    farSpan: 0.42,
+    hairFall: 2.6,
+    hairs: 44,
+    light: "none",
+    menace: 0.4,
+    push: 0.36,
+    recapture: 0.12,
+    roll: 0.09,
+    seatLeast: 0.38,
+    seatSpan: 0.32,
+    sees: false,
+    sink: 0.14,
+    thrust: 0.5,
+    trail: 0,
+    wideLeast: 0.7,
+    wideSpan: 0.8,
+  },
+  manowar: {
+    answer: "furl",
+    armFall: 0.7,
+    arms: 5,
+    beats: 0.12,
+    bunches: 1,
+    drive: "sail",
+    farLeast: 0.55,
+    farSpan: 0.35,
+    hairFall: 0.9,
+    hairs: 7,
+    light: "none",
+    menace: 0.5,
+    push: 0.5,
+    recapture: 0,
+    roll: 0.18,
+    seatLeast: 0.03,
+    seatSpan: 0.02,
+    sees: false,
+    sink: 0,
+    thrust: 0,
+    trail: 5.5,
+    wideLeast: 0.1,
+    wideSpan: 0.18,
+  },
+  moon: {
+    answer: "none",
+    armFall: 0.5,
+    arms: 4,
+    beats: 0.9,
+    bunches: 1,
+    drive: "pulse",
+    farLeast: 0.28,
+    farSpan: 0.56,
+    hairFall: 0.16,
+    hairs: 40,
+    light: "none",
+    menace: 0.05,
+    push: 0.3,
+    recapture: 0.36,
+    roll: 0.08,
+    seatLeast: 0.26,
+    seatSpan: 0.38,
+    sees: false,
+    sink: 0.28,
+    thrust: 0.5,
+    trail: 0,
+    wideLeast: 0.2,
+    wideSpan: 0.2,
+  },
+  stinger: {
+    answer: "none",
+    armFall: 1.5,
+    arms: 4,
+    beats: 0.7,
+    bunches: 1,
+    drive: "pulse",
+    farLeast: 0.34,
+    farSpan: 0.5,
+    hairFall: 2.2,
+    hairs: 8,
+    light: "wash",
+    menace: 0.45,
+    push: 0.31,
+    recapture: 0.18,
+    roll: 0.11,
+    seatLeast: 0.14,
+    seatSpan: 0.34,
+    sees: false,
+    sink: 0.29,
+    thrust: 0.55,
+    trail: 0,
+    wideLeast: 0.06,
+    wideSpan: 0.06,
+  },
+}
+
+export const KINDS: readonly JellyKind[] = Object.keys(HABITS) as JellyKind[]
+
+/**
+ * How each of them gets about, and what each does when something goes over.
+ *
+ * The two columns of `HABITS` anybody outside this file has a use for. A
+ * renderer needs the first, since a float with a sail on it is not a bell and
+ * is not drawn like one; a test needs the second, to hold the three that
+ * answer against the four that cannot.
+ */
+export const DRIVES: Readonly<Record<JellyKind, Drive>> = Object.fromEntries(
+  KINDS.map((kind) => [kind, HABITS[kind].drive]),
+) as Record<JellyKind, Drive>
+
+export const ANSWERS: Readonly<Record<JellyKind, Answer>> = Object.fromEntries(
+  KINDS.map((kind) => [kind, HABITS[kind].answer]),
+) as Record<JellyKind, Answer>
+
+export const LIGHTS: Readonly<Record<JellyKind, Light>> = Object.fromEntries(
+  KINDS.map((kind) => [kind, HABITS[kind].light]),
+) as Record<JellyKind, Light>
+
+/**
+ * How far off these drift past, in metres.
+ *
+ * Nearer than the sharks and the turtles, which cross at `SWIMMING_OFF`. A
+ * jellyfish is something you find yourself already among, so it is drawn at
+ * the distance of a thing you would rather not touch.
+ */
+export const DRIFTING_OFF = 5
+
+/** How much of the drawn size is distance. A far one is smaller as well as fainter. */
+const DEPTH_SIZE = 0.55
+
+/**
+ * How fast one loses way, per second.
+ *
+ * High, because a bell is a bluff body and a pulse is spent almost as soon as
+ * it is made. It is what makes the sawtooth: without it a moon jelly's beats
+ * would add up and it would leave the top of the picture inside a minute.
+ */
+const DRAG = 2.4
+
+/** What share of the cycle the refill push occupies, after the contraction. */
+const RECOVER = 0.34
+
+/**
+ * The lowest and highest the pulse rate is ever driven to, against its own.
+ *
+ * The floor is not zero. A jellyfish that had risen above where it wanted to
+ * be and stopped altogether would be a dead one, and the picture reads that
+ * immediately: everything else in the water is moving.
+ */
+const RATE_LEAST = 0.22
+const RATE_MOST = 1.9
+
+/** How hard being off its depth drives the pulse. */
+const URGE = 0.8
+
+/** How far off its seat one has to be for that to be the whole of its mind. */
+const BAND = 0.13
+
+/** The water everything here is carried by, in px a second, and how it turns over. */
+const CURRENT = 15
+const CURRENT_LIFT = 4
+const CURRENT_GRAIN = 1 / 620
+const CURRENT_CREEP = 0.014
+
+/** How fast a lean is taken up, per second. */
+const TURN = 1.1
+
+/** How far a bolt lifts the pulse rate, and the push with it. */
+const BOLT_RATE = 1.6
+const BOLT_PUSH = 1.2
+
+/** How long an alarm takes to run out, in seconds. */
+const ALARM_HOLD = 4.5
+
+/** How fast the crown jelly's light goes round its own margin, in turns a second. */
+const FLASH_SPIN = 1.4
+
+/** How far a comb jelly turns over to go down, at the bottom of its band. */
+const DIVE = 1.2
+
+/** How far a man o' war's crest goes over as it wets it. */
+const WET = 0.3
+
+/** How far a man o' war's tack takes it off the water it is sitting on. */
+const TACK = 0.45
+
+/** How far outside the box one drifts before it is made again, in bell widths. */
+const MARGIN = 1.6
+
+/** How near a moon jelly is born to the last one, in bell widths. A smack. */
+const SMACK = 5
+
+/** How far the top of the water is from the top of the box, as a share of it. */
+const SKY = 0.02
+
+/**
+ * How far a bell is held off the ground, in bell widths, before what hangs
+ * under it is counted.
+ *
+ * The oral arms are counted, because they are the body and a body laid over the
+ * sand reads as an animal in the sand. The marginal hair is not: it is slack
+ * and it streams, and a lion's mane sweeping the bottom with it is what one
+ * looks like.
+ */
+const BELL_CLEAR = 0.35
+
+const MIN_SPAN = 1
+
+/**
+ * A jellyfish with the parts of it a renderer has no use for.
+ *
+ * Its way through the water and how frightened it is. Neither belongs on
+ * `Jelly`: what is drawn is a shape at a place, and a drawing that took a
+ * velocity would be a drawing deciding how the animal moves.
+ */
+interface Held extends Jelly {
+  alarm: number
+  /** Where in the column it means to be, in px down the box. */
+  seat: number
+  /** Which way it turns over to descend, and which tack it sails on. */
+  side: number
+  vx: number
+  vy: number
+  /** Where the box jelly is going, in px. Nothing else has anywhere to be. */
+  wantX: number
+  wantY: number
+}
+
+/**
+ * How hard the bell is squeezed at this point of the cycle, 0 open and 1 shut.
+ *
+ * The contraction is quick and the refill is not, which is the shape of the
+ * whole animal's rhythm: about a third of the cycle is the push and the rest
+ * is the bell letting itself back out. Drawn as a rise on a sine's shoulder
+ * and a longer fall on a cosine's, so neither end has a corner in it.
+ */
+export function squeezeAt(kind: JellyKind, beat: number): number {
+  const habit = HABITS[kind]
+  const at = beat - Math.floor(beat)
+  if (at < habit.push) return Math.sin((at / habit.push) * (Math.PI / 2))
+
+  const back = (at - habit.push) / Math.max(1e-6, 1 - habit.push)
+  return (1 + Math.cos(back * Math.PI)) / 2
+}
+
+/**
+ * What the bell is pushing with at this point of the cycle.
+ *
+ * Weighted so that one whole cycle of it comes to 1, whatever the shape: a
+ * caller multiplies by `Habit.thrust` and gets bell widths a second added per
+ * pulse, which is a number that can be argued about.
+ *
+ * The second lobe is the moon jelly's. A contraction throws a ring of water
+ * off the rim and the bell's own elasticity brings it back in against that
+ * ring, so the refill pushes as well, at rather less than the contraction did
+ * and for nothing. `Habit.recapture` is the share, and a kind that has none
+ * has a flat second half of the cycle.
+ */
+export function thrustAt(kind: JellyKind, beat: number): number {
+  const habit = HABITS[kind]
+  const at = beat - Math.floor(beat)
+  if (at < habit.push) {
+    const along = at / habit.push
+    return (1 - habit.recapture) * (Math.PI / (2 * habit.push)) * Math.sin(along * Math.PI)
+  }
+
+  const after = (at - habit.push) / RECOVER
+  if (after >= 1 || habit.recapture <= 0) return 0
+  return habit.recapture * (Math.PI / (2 * RECOVER)) * Math.sin(after * Math.PI)
+}
+
+export function createJellies(options: JelliesOptions): Jellies {
+  const random = makeRandom(options.seed ^ 0x5e11)
+  const flow = makeNoise2(options.seed ^ 0x1f0a)
+  const kinds = options.kinds && options.kinds.length > 0 ? options.kinds : KINDS
+
+  let width = Math.max(MIN_SPAN, options.width)
+  let height = Math.max(MIN_SPAN, options.height)
+  let clock = 0
+
+  const held: Held[] = []
+  const gathered: Presence[] = []
+
+  /** How common each of them is in this water today; see `census.ts`. */
+  const shares = mixOf(kinds, options.seed)
+
+  /** Which kind this one is, drawn on the day's own shares. */
+  function draw(): JellyKind {
+    let total = 0
+    for (const kind of kinds) total += shares[kind]
+
+    let ticket = random() * total
+    for (const kind of kinds) {
+      ticket -= shares[kind]
+      if (ticket <= 0) return kind
+    }
+    return kinds[kinds.length - 1] ?? "moon"
+  }
+
+  /**
+   * Make one, either scattered through the water or walked in from a side.
+   *
+   * `from` is which side it enters by, or nothing for the first filling of the
+   * box. Nothing appears in the middle of the picture after that, which is the
+   * promise every animal in this scene keeps.
+   */
+  function born(from?: number): Held {
+    const kind = draw()
+    const habit = HABITS[kind]
+    const depth = habit.farLeast + random() * habit.farSpan
+    const across = habit.wideLeast + random() * habit.wideSpan
+    const size = drawnAt(across, DRIFTING_OFF) * width * (1 - DEPTH_SIZE + DEPTH_SIZE * depth)
+    const seat = height * (SKY + (habit.seatLeast + random() * habit.seatSpan) * (1 - SKY))
+
+    const x = from == null ? random() * width : from < 0 ? -size * MARGIN : width + size * MARGIN
+
+    // The ground is a ceiling on how deep a band can be. A crown jelly lives
+    // in the bottom third of the column and a hill in the bottom third is
+    // still a hill, so where it means to be is wherever the sand allows.
+    const bed = (options.floor?.(x, depth) ?? height) - size * clearOf(habit)
+    const seated = Math.min(seat, bed)
+
+    const one: Held = {
+      alarm: 0,
+      beat: random(),
+      depth,
+      facing: random() < 0.5 ? -1 : 1,
+      glow: 0,
+      kind,
+      seat: seated,
+      side: random() < 0.5 ? -1 : 1,
+      size,
+      squeeze: 0,
+      tilt: 0,
+      vx: 0,
+      vy: 0,
+      wantX: 0,
+      wantY: 0,
+      wave: random() * Math.PI * 2,
+      x,
+      y: clamp(seated + (random() - 0.5) * height * BAND, height * SKY + size * 0.6, bed),
+    }
+
+    one.squeeze = habit.drive === "pulse" ? squeezeAt(kind, one.beat) : 0
+    aim(one)
+
+    // A smack. Moon jellies are found in company rather than one at a time,
+    // and the water they came in on is the reason, so a new one takes the
+    // height of whichever is already about instead of picking its own.
+    if (kind === "moon") {
+      for (const other of held) {
+        if (other.kind !== "moon") continue
+        one.y = other.y + (random() - 0.5) * SMACK * one.size
+        one.seat = other.seat
+        break
+      }
+    }
+
+    return one
+  }
+
+  /** Somewhere for the one animal here with eyes to be going. */
+  function aim(one: Held): void {
+    one.wantX = random() * width
+    one.wantY = one.seat + (random() - 0.5) * height * BAND * 2
+  }
+
+  for (let made = 0; made < Math.max(0, options.count); made++) held.push(born())
+
+  options.water?.enter(() => {
+    gathered.length = 0
+    for (const one of held) {
+      const habit = HABITS[one.kind]
+      if (habit.menace <= 0) continue
+
+      // Measured across whatever it can reach with, which for a lion's mane is
+      // most of a picture and for a box jelly is several times its own bell.
+      // What a fish has to keep clear of is the hair.
+      gathered.push({
+        depth: one.depth,
+        menace: habit.menace,
+        size: one.size * (1 + Math.max(habit.hairFall, habit.trail) * 0.6),
+        x: one.x,
+        y: one.y,
+      })
+    }
+    return gathered
+  })
+
+  /** The water's own movement where this animal is, in px a second. */
+  function carry(one: Held): { x: number; y: number } {
+    const u = one.x * CURRENT_GRAIN
+    const v = one.y * CURRENT_GRAIN + clock * CURRENT_CREEP
+    return {
+      x: flow(u, v) * CURRENT * (0.4 + 0.6 * one.depth),
+      y: flow(u + 31.7, v - 12.3) * CURRENT_LIFT,
+    }
+  }
+
+  /** How far off its depth it is: 1 far below where it wants to be, -1 above. */
+  function urgeOf(one: Held): number {
+    return clamp((one.y - one.seat) / Math.max(1, height * BAND), -1, 1)
+  }
+
+  /**
+   * Where the box jelly means to point.
+   *
+   * Towards wherever it is going, and away from anything large it can make out
+   * on the way. *Chironex* has twenty-four eyes and a published habit of
+   * steering round a piling instead of into it, and this is the whole of what
+   * that is worth in a picture: a swerve nobody asked for, at a moment nothing
+   * else in the water reacted to.
+   */
+  function steer(one: Held): number {
+    let toX = one.wantX - one.x
+    let toY = one.wantY - one.y
+
+    for (const seen of options.water?.about() ?? []) {
+      const gap = Math.hypot(seen.x - one.x, seen.y - one.y)
+      const notice = seen.size * 1.4 + one.size
+      if (gap >= notice || gap <= 0.001) continue
+
+      const shove = (1 - gap / notice) * abreast(one.depth, seen.depth) * notice
+      toX -= ((seen.x - one.x) / gap) * shove
+      toY -= ((seen.y - one.y) / gap) * shove
+    }
+
+    return Math.atan2(toX, -toY)
+  }
+
+  /**
+   * Whether something is actually on this animal, 0 clear and 1 square on it.
+   *
+   * Touch, and touch is not sight. `Habit.sees` is a fact about eyes and it
+   * gates steering, since deciding to go round something means making it out
+   * at a distance. Knowing that a thing has hold of you needs no eyes at all:
+   * a jellyfish is a nerve net and being struck is exactly what a nerve net
+   * is for. So every kind that can make light reads the water for contact,
+   * and the four with none never ask.
+   *
+   * This is what actually fires the displays. A hull going over is minutes
+   * apart and a shark is rarer than that, and a light that only ever answered
+   * those would be a light nobody ever saw. What sets a real one off is a fish
+   * blundering into it, which happens all afternoon.
+   */
+  function touched(one: Held): number {
+    let worst = 0
+
+    for (const seen of options.water?.about() ?? []) {
+      const gap = Math.hypot(seen.x - one.x, seen.y - one.y)
+      const reach = (seen.size + one.size) * 0.5
+      if (gap >= reach || gap <= 0.001) continue
+
+      worst = Math.max(worst, (1 - gap / reach) * abreast(one.depth, seen.depth))
+    }
+
+    return worst
+  }
+
+  function pulse(one: Held, habit: Habit, dt: number, bolt: number): void {
+    const rate =
+      habit.beats * clamp(1 + urgeOf(one) * URGE, RATE_LEAST, RATE_MOST) * (1 + bolt * BOLT_RATE)
+
+    one.beat = (one.beat + rate * dt) % 1
+    one.squeeze = squeezeAt(one.kind, one.beat)
+
+    // Rate times the curve, because the curve is weighted per pulse and a
+    // faster animal is having more of them. A box jelly running from something
+    // gets its speed from beating oftener as much as from beating harder.
+    const kick = thrustAt(one.kind, one.beat) * habit.thrust * rate * (1 + bolt * BOLT_PUSH)
+    drive(one, dt, kick, (1 - one.squeeze) * habit.sink)
+  }
+
+  /**
+   * Eight rows of cilia, beating in sequence from the far end towards the
+   * mouth, which never stop and have no peak in them.
+   *
+   * So the push is flat and the animal glides. Everything a ctenophore does
+   * about its depth it does by turning over, since it has no way of pushing
+   * harder: `DIVE` is how far it is willing to go, and a comb jelly holding
+   * station at the top of its band is drawn most of the way upside down.
+   */
+  function cilia(one: Held, habit: Habit, dt: number, furl: number): void {
+    one.beat = (one.beat + habit.beats * dt) % 1
+    one.wave = (one.wave + habit.beats * Math.PI * 2 * dt) % (Math.PI * 2)
+    one.squeeze = furl
+
+    const working = 1 - furl
+    drive(one, dt, habit.thrust * DRAG * working, habit.sink)
+  }
+
+  /**
+   * A float on the surface, which is where it stays.
+   *
+   * *Physalia* cannot swim and does not try. What it has is a crest it holds
+   * up into the wind, and a handedness: the left-sailing and right-sailing
+   * forms leave on opposite tacks, at about 45 degrees off the wind's own
+   * line. A picture with one horizontal axis in it cannot show an angle, so
+   * what the tack comes to here is a float outrunning or lagging the water it
+   * is sitting on, which is what you would see from a beach anyway.
+   *
+   * Disturbed, it lets the crest down and rolls the float under to wet it,
+   * which is `furl` and is the nearest thing to a reflex a colony has.
+   */
+  function sail(one: Held, habit: Habit, dt: number, furl: number): void {
+    one.beat = (one.beat + habit.beats * dt) % 1
+
+    const wet = (1 - Math.cos(one.beat * Math.PI * 2)) / 2
+    one.squeeze = Math.max(furl, WET * wet)
+
+    const wind = carry(one)
+    one.vx = wind.x * TACK * one.side * (1 - one.squeeze * 0.5)
+    one.vy = 0
+    one.y = one.seat + Math.sin(one.beat * Math.PI * 2) * one.size * 0.04
+    one.tilt = swing(one.tilt, habit.roll * one.side * (0.4 + wet), TURN * dt)
+    one.x += (one.vx + wind.x) * dt
+  }
+
+  /** Way on, way off, and what the water does to it while it has neither. */
+  function drive(one: Held, dt: number, kick: number, fall: number): void {
+    const ax = Math.sin(one.tilt) * kick * one.size
+    const ay = -Math.cos(one.tilt) * kick * one.size
+
+    one.vx += (ax - one.vx * DRAG) * dt
+    one.vy += (ay + fall * one.size * DRAG - one.vy * DRAG) * dt
+
+    const water = carry(one)
+    one.x += (one.vx + water.x) * dt
+    one.y += (one.vy + water.y) * dt
+  }
+
+  /** A lazy lean, its own for each animal, going nowhere. */
+  function lean(one: Held, habit: Habit): number {
+    return habit.roll * flow(one.x * CURRENT_GRAIN * 0.5, clock * 0.05 + one.seat * 0.01)
+  }
+
+  return {
+    jellies: held,
+
+    resize(nextWidth, nextHeight, count) {
+      const scaleX = Math.max(MIN_SPAN, nextWidth) / width
+      const scaleY = Math.max(MIN_SPAN, nextHeight) / height
+      width = Math.max(MIN_SPAN, nextWidth)
+      height = Math.max(MIN_SPAN, nextHeight)
+
+      for (const one of held) {
+        one.x *= scaleX
+        one.y *= scaleY
+        one.seat *= scaleY
+        one.wantX *= scaleX
+        one.wantY *= scaleY
+      }
+
+      if (count == null) return
+      while (held.length > count) held.pop()
+      while (held.length < count) held.push(born(random() < 0.5 ? -1 : 1))
+    },
+
+    step(seconds, startle) {
+      const dt = clamp(seconds, 0, 0.1)
+      clock += dt
+
+      for (let at = 0; at < held.length; at++) {
+        const one = held[at]
+        if (!one) continue
+        const habit = HABITS[one.kind]
+
+        // What a startle is worth to this animal, which for four of the seven
+        // is nothing at all. Nothing is checking whether the thing that went
+        // over was frightening: a moon jelly has no equipment to check with.
+        if (startle && (habit.answer !== "none" || habit.light !== "none")) {
+          const gap = Math.hypot(startle.x - one.x, startle.y - one.y)
+          if (gap < startle.reach) {
+            const near = (1 - gap / startle.reach) * startle.force * felt(one.depth, startle)
+            one.alarm = Math.max(one.alarm, clamp(near, 0, 1))
+          }
+        }
+        // And whatever is on top of it this moment, which is the other half of
+        // being disturbed and the half that happens often.
+        if (habit.light !== "none") one.alarm = Math.max(one.alarm, touched(one))
+
+        one.alarm = Math.max(0, one.alarm - dt / ALARM_HOLD)
+
+        const bolt = habit.answer === "bolt" ? one.alarm : 0
+        const furl = habit.answer === "furl" ? one.alarm : 0
+
+        // Light the animal made, which every kind that can make any makes the
+        // same way: touched, then fading over seconds. A crown jelly's runs
+        // round its own margin and keeps running, on the theory that whatever
+        // turns up to look will be interested in the thing that has hold of
+        // it. That is the only display here with a direction to it.
+        if (habit.light !== "none") {
+          one.glow = one.alarm
+          if (habit.light === "wave" && one.alarm > 0) {
+            one.wave = (one.wave + FLASH_SPIN * Math.PI * 2 * dt) % (Math.PI * 2)
+          }
+        }
+
+        if (habit.drive === "sail") {
+          sail(one, habit, dt, furl)
+        } else if (habit.drive === "cilia") {
+          const want = one.side * (1 - urgeOf(one)) * DIVE + lean(one, habit)
+          one.tilt = swing(one.tilt, want, TURN * dt)
+          cilia(one, habit, dt, furl)
+        } else {
+          const want = habit.sees ? steer(one) : lean(one, habit)
+          one.tilt = swing(one.tilt, want, TURN * dt)
+          pulse(one, habit, dt, bolt)
+        }
+
+        // Somewhere new to be, once it has arrived. Only the box jelly is ever
+        // going anywhere, and this is how often it changes its mind.
+        if (habit.sees && Math.hypot(one.wantX - one.x, one.wantY - one.y) < one.size) aim(one)
+
+        // The top of the water and the ground are both walls, and a bell that
+        // met either would be a bell sliding along a line. What it gets is a
+        // shove back into the water, which reads as an animal that thought
+        // better of it.
+        const roof = height * SKY + (habit.drive === "sail" ? 0 : one.size * 0.6)
+        if (one.y < roof) {
+          one.y = roof
+          one.vy = Math.max(one.vy, 0)
+        }
+        const bed = (options.floor?.(one.x, one.depth) ?? height) - one.size * clearOf(habit)
+        if (one.y > bed) {
+          one.y = bed
+          one.vy = Math.min(one.vy, 0)
+        }
+
+        const gone = one.size * MARGIN
+        if (one.x < -gone) held[at] = born(1)
+        if (one.x > width + gone) held[at] = born(-1)
+      }
+    },
+  }
+}
+
+const clamp = (value: number, low: number, high: number): number =>
+  Math.min(Math.max(value, low), high)
+
+/** How far this kind holds its rim off the ground, in bell widths. */
+const clearOf = (habit: Habit): number => BELL_CLEAR + habit.armFall
+
+const ease = (from: number, to: number, rate: number): number =>
+  from + (to - from) * Math.min(1, Math.max(0, rate))
+
+/**
+ * The same, taken the short way round a circle.
+ *
+ * `Math.atan2` answers +π on one side of straight down and -π on the other, so
+ * a bell that means to go down sits on a seam. Eased along the number line, a
+ * hair of sideways drift across that seam sends the animal the whole way round
+ * the compass and back, which reads as a jellyfish spinning on the spot. Taken
+ * the short way, the same seam is a wobble. The answer is kept inside one
+ * turn, because a wallpaper runs for days and a winding angle loses its
+ * precision on the way to the card.
+ */
+const swing = (from: number, to: number, rate: number): number => {
+  const gone = ease(from, from + Math.atan2(Math.sin(to - from), Math.cos(to - from)), rate)
+  return Math.atan2(Math.sin(gone), Math.cos(gone))
+}
+
+/**
+ * The drawings, all of them in a bell one unit across.
+ *
+ * The rim sits on the origin, the apex is above it and everything that hangs
+ * hangs below, so a renderer scales by `Jelly.size`, mirrors by `Jelly.facing`
+ * and turns by `Jelly.tilt`, exactly as it does a fish. A jelly at rest is
+ * pointing at the sky, which is the one posture every animal here shares.
+ *
+ * The comb jelly is drawn in the same frame and comes out looking upside down,
+ * because it is. A ctenophore swims mouth first, so the end that leads is the
+ * end with the lobes on it, and putting the mouth where every other animal
+ * here keeps its apex is the drawing telling the truth about it.
+ */
+
+/**
+ * How many drawings one contraction is cut into.
+ *
+ * A bell squeezes continuously and a renderer keeps the paths it has walked,
+ * so a path that never repeats is a cache with a leak in it. The same bargain
+ * `fish_shape.ts` makes with a tail beat: enough steps that nobody counts
+ * them, few enough that the whole vocabulary of the water fits in a map.
+ */
+export const BELL_STEPS = 24
+
+/** What a fine mass and a thick one are drawn as lines at, in bell widths. */
+export const HAIR_GIRTH: Readonly<Record<JellyKind, number>> = {
+  barrel: 0.02,
+  box: 0.016,
+  comb: 0.012,
+  crown: 0.014,
+  mane: 0.009,
+  manowar: 0.012,
+  moon: 0.008,
+  stinger: 0.011,
+}
+
+export const ARM_GIRTH: Readonly<Record<JellyKind, number>> = {
+  barrel: 0.075,
+  box: 0.03,
+  comb: 0.03,
+  crown: 0.03,
+  mane: 0.055,
+  manowar: 0.04,
+  moon: 0.03,
+  stinger: 0.045,
+}
+
+const fixed = (value: number): string => (Math.abs(value) < 0.0005 ? 0 : value).toFixed(3)
+
+/**
+ * A run of points as a curve that goes through all of them.
+ *
+ * Catmull-Rom, written out as cubics, because a bell is a shape somebody has
+ * to be able to argue about and an argument about a bell is an argument about
+ * where its shoulder is. Sampling the shape and smoothing it afterwards keeps
+ * the numbers in the file the ones a reader can check.
+ */
+function smooth(points: readonly Point[], shut: boolean): string {
+  if (points.length < 2) return ""
+
+  const at = (i: number): Point => {
+    const seat = shut
+      ? (i + points.length) % points.length
+      : Math.min(points.length - 1, Math.max(0, i))
+    return points[seat] ?? { x: 0, y: 0 }
+  }
+
+  const head = at(0)
+  const parts = [`M${fixed(head.x)} ${fixed(head.y)}`]
+  const last = shut ? points.length : points.length - 1
+
+  for (let i = 0; i < last; i++) {
+    const back = at(i - 1)
+    const from = at(i)
+    const to = at(i + 1)
+    const on = at(i + 2)
+    parts.push(
+      `C${fixed(from.x + (to.x - back.x) / 6)} ${fixed(from.y + (to.y - back.y) / 6)}` +
+        ` ${fixed(to.x - (on.x - from.x) / 6)} ${fixed(to.y - (on.y - from.y) / 6)}` +
+        ` ${fixed(to.x)} ${fixed(to.y)}`,
+    )
+  }
+
+  return shut ? `${parts.join(" ")} Z` : parts.join(" ")
+}
+
+/**
+ * The shape of one bell, as numbers rather than as a path.
+ *
+ * `shoulder` is what tells the seven apart before anything else does. Below
+ * one the dome is drawn out to a point and reads as a helmet; at four the
+ * sides go straight up and the top goes flat, which is a box jelly and is why
+ * a box jelly is recognisable at forty pixels.
+ */
+interface Dome {
+  /** How deep the near rim bows below the far one, in bell widths. */
+  bow: number
+  /** How deep each scallop of the margin cuts, in bell widths. */
+  cut: number
+  /**
+   * How far below the origin everything that hangs is rooted, in bell widths.
+   *
+   * The margin, for anything with a bell, which is where the origin already
+   * is. A man o' war has no margin: what hangs off it hangs off the underside
+   * of a float, and rooted at the origin it would come out of the middle of
+   * the bag.
+   */
+  hang: number
+  /** How many scallops show across the front of the margin. None is smooth. */
+  lobes: number
+  /** How square the shoulder is: under 1 pointed, 1 round, over 1 boxy. */
+  shoulder: number
+  /** How tall it stands, in bell widths, and how much taller it squeezes. */
+  tall: number
+  tallGain: number
+  /**
+   * How far the bumps on the dome stand off it, and how many show.
+   *
+   * One animal here has any. A mauve stinger's bell is covered in warts, and
+   * they are not decoration: each one is a packed cluster of stinging cells,
+   * which is why the animal can sting you with a part of itself that is not a
+   * tentacle. It is also the whole of how you tell one from a moon jelly at a
+   * distance, since neither of them is much bigger than a fist.
+   */
+  wart: number
+  warts: number
+  /** How wide it is when open, and how much of that a contraction takes. */
+  wide: number
+  wideLoss: number
+}
+
+const DOMES: Readonly<Record<JellyKind, Dome>> = {
+  barrel: {
+    bow: 0.13,
+    cut: 0.02,
+    hang: 0,
+    lobes: 8,
+    shoulder: 1.15,
+    tall: 0.5,
+    tallGain: 0.14,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0.2,
+  },
+  box: {
+    bow: 0.06,
+    cut: 0,
+    hang: 0,
+    lobes: 0,
+    shoulder: 3.4,
+    tall: 0.92,
+    tallGain: 0.12,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0.2,
+  },
+  comb: {
+    bow: 0,
+    cut: 0,
+    hang: 0,
+    lobes: 0,
+    shoulder: 1,
+    tall: 0,
+    tallGain: 0,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0.14,
+  },
+  crown: {
+    bow: 0.05,
+    cut: 0.05,
+    hang: 0,
+    lobes: 6,
+    shoulder: 1.6,
+    tall: 0.3,
+    tallGain: 0.1,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0.16,
+  },
+  mane: {
+    bow: 0.11,
+    cut: 0.07,
+    hang: 0,
+    lobes: 4,
+    shoulder: 0.85,
+    tall: 0.34,
+    tallGain: 0.12,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0.18,
+  },
+  manowar: {
+    bow: 0,
+    cut: 0,
+    hang: 0.12,
+    lobes: 0,
+    shoulder: 1,
+    tall: 0,
+    tallGain: 0,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0,
+  },
+  moon: {
+    bow: 0.1,
+    cut: 0.015,
+    hang: 0,
+    lobes: 5,
+    shoulder: 0.95,
+    tall: 0.28,
+    tallGain: 0.14,
+    wart: 0,
+    warts: 0,
+    wide: 1,
+    wideLoss: 0.22,
+  },
+  stinger: {
+    bow: 0.12,
+    cut: 0.02,
+    hang: 0,
+    lobes: 5,
+    shoulder: 1.3,
+    tall: 0.46,
+    tallGain: 0.14,
+    wart: 0.04,
+    warts: 6,
+    wide: 1,
+    wideLoss: 0.2,
+  },
+}
+
+/**
+ * How many samples the top of a bell is worth, and how many its margin.
+ *
+ * The margin is counted off its own scallops, because a rim sampled at fewer
+ * points than it has lobes is a rim with a beat frequency in it: eight
+ * scallops read off sixteen samples come out as four, and the animal is drawn
+ * with the wrong number of parts.
+ */
+const OVER = 20
+const UNDER = 14
+const PER_LOBE = 4
+const PER_WART = 5
+
+/**
+ * A bell, squeezed by however much it is squeezed.
+ *
+ * A contraction takes width out and puts height in, because that is where the
+ * water went and it is the whole of what a pulse looks like from the side. The
+ * margin bows towards the reader, so the rim reads as a circle seen at an
+ * angle instead of a line ruled under a dome.
+ */
+function domePath(kind: JellyKind, squeeze: number): string {
+  const shape = DOMES[kind]
+  const wide = (shape.wide * (1 - shape.wideLoss * squeeze)) / 2
+  const tall = shape.tall + shape.tallGain * squeeze
+  const points: Point[] = []
+
+  const over = Math.max(OVER, shape.warts * PER_WART)
+  for (let i = 0; i <= over; i++) {
+    const turn = Math.PI - (i / over) * Math.PI
+    // The warts ride on the dome rather than being stuck to it, so they stand
+    // off along the outward normal and go flat where the dome turns under at
+    // the sides. A bump added straight up would put a row of teeth on the top
+    // and leave the shoulders smooth, which is the wrong animal.
+    const bump =
+      shape.warts > 0 ? shape.wart * Math.max(0, Math.sin((i / over) * Math.PI * shape.warts)) : 0
+
+    points.push({
+      x: wide * Math.cos(turn) * (1 + bump),
+      y: -tall * Math.sin(turn) ** (1 / shape.shoulder) - bump * Math.sin(turn) * tall * 0.5,
+    })
+  }
+
+  // The margin, coming back the other way. The scallops are cut into it rather
+  // than hung off it, so a lion's mane comes apart into eight lobes and a moon
+  // jelly's rim is merely not straight.
+  const under = Math.max(UNDER, shape.lobes * PER_LOBE)
+  for (let i = 1; i < under; i++) {
+    const along = 1 - i / under
+    const across = (along - 0.5) * 2
+    const scallop = shape.lobes > 0 ? Math.abs(Math.sin(along * Math.PI * shape.lobes)) : 0
+    points.push({
+      x: wide * across,
+      y: (shape.bow + shape.cut * scallop) * (1 - across * across) * (1 + squeeze * 0.3),
+    })
+  }
+
+  return smooth(points, true)
+}
+
+/**
+ * A comb jelly, which is a bag with a slit in it and two lobes either side.
+ *
+ * Drawn mouth up, since that is the end it leads with. The lobes close over
+ * the mouth when it is disturbed and that is the whole of `squeeze` for this
+ * animal: there is no bell here to contract.
+ */
+function combBody(squeeze: number): string {
+  const open = 1 - squeeze
+  const wide = 0.5 * (1 - 0.2 * squeeze)
+  const gape = 0.34 * open
+
+  const points: Point[] = [
+    { x: -gape, y: -0.62 },
+    { x: -wide, y: -0.26 },
+    { x: -wide * 0.94, y: 0.16 },
+    { x: -wide * 0.4, y: 0.62 },
+    { x: 0, y: 0.78 },
+    { x: wide * 0.4, y: 0.62 },
+    { x: wide * 0.94, y: 0.16 },
+    { x: wide, y: -0.26 },
+    { x: gape, y: -0.62 },
+    // The mouth itself, a notch between the two lobes rather than a gap
+    // between two shapes: the lobes are folds of one animal.
+    { x: gape * 0.3, y: -0.3 + 0.1 * squeeze },
+    { x: -gape * 0.3, y: -0.3 + 0.1 * squeeze },
+  ]
+
+  return smooth(points, true)
+}
+
+/**
+ * A man o' war's float, seen from the side with its crest up.
+ *
+ * The float is a gas bag the animal secretes and cannot refill quickly, and
+ * the crest along the top of it is the sail. Disturbed, or merely drying out,
+ * it lets the crest over and rolls the whole float under to wet it, which is
+ * `squeeze` here and is the only movement the colony has.
+ */
+function manowarFloat(squeeze: number): string {
+  const lift = 1 - squeeze * 0.85
+  const points: Point[] = [
+    // The bag first: long, low, and lifted clear of the water at both ends.
+    { x: -0.5, y: 0.02 },
+    { x: -0.4, y: -0.05 },
+    { x: -0.26, y: -0.08 },
+    // Then the crest, which is a fin and not a bulge. Its base is a third of
+    // the bag's length and it stands half of it high, so what a wind pushes on
+    // is plainly a sail. Widen the base and the whole animal reads as a
+    // mushroom, which is how the first draft of this drawing read.
+    { x: -0.14, y: -0.22 * lift },
+    { x: -0.02, y: -0.42 * lift },
+    { x: 0.02, y: -0.44 * lift },
+    { x: 0.14, y: -0.27 * lift },
+    { x: 0.2, y: -0.1 },
+    { x: 0.36, y: -0.07 },
+    { x: 0.5, y: 0.03 },
+    // And back along the underside, which is where everything hangs from.
+    { x: 0.4, y: 0.1 },
+    { x: 0.12, y: 0.15 },
+    { x: -0.18, y: 0.14 },
+    { x: -0.4, y: 0.08 },
+  ]
+
+  return smooth(points, true)
+}
+
+/** The bells, one a kind, kept by the step they were cut at. */
+const cut = new Map<string, string>()
+
+/**
+ * What this animal looks like now.
+ *
+ * Snapped to a step of the contraction, so the same drawing comes back as the
+ * same string and a renderer's own cache of walked paths stays the size of the
+ * vocabulary instead of the size of the afternoon.
+ */
+export function bell(kind: JellyKind, squeeze: number): string {
+  const step = Math.round(Math.min(Math.max(squeeze, 0), 1) * BELL_STEPS)
+  const key = `${kind}${step}`
+  const had = cut.get(key)
+  if (had) return had
+
+  const at = step / BELL_STEPS
+  const made =
+    kind === "comb" ? combBody(at) : kind === "manowar" ? manowarFloat(at) : domePath(kind, at)
+
+  cut.set(key, made)
+  return made
+}
+
+/**
+ * The four horseshoes on a moon jelly, which is how anybody tells one.
+ *
+ * Gonads, seen through the bell, and the reason *Aurelia* is the jellyfish
+ * everybody can name. Four of them, set at the corners of a square, so from
+ * the side the near pair sits low and the far pair rides high and small. They
+ * are handed over as lines and drawn at a share of the bell's own weight, so
+ * they read as the bell being see-through and not as marks painted on it.
+ */
+export function moonMarks(squeeze: number): Point[][] {
+  const wide = (1 - DOMES.moon.wideLoss * squeeze) / 2
+  const seat = -DOMES.moon.tall * (0.3 + 0.1 * squeeze)
+  const marks: Point[][] = []
+
+  for (let made = 0; made < 4; made++) {
+    const round = (made / 4) * Math.PI * 2 + Math.PI / 4
+    const spot = { x: Math.cos(round) * wide * 0.52, y: seat + Math.sin(round) * 0.1 }
+    // Smaller at the back of the bell, because the back of the bell is further
+    // away. It is the whole of the perspective this drawing has and it is
+    // enough: without it the four marks are a row of beads.
+    const size = wide * 0.2 * (1 - Math.sin(round) * 0.3)
+    const shoe: Point[] = []
+
+    for (let i = 0; i <= 10; i++) {
+      const turn = Math.PI * 0.22 + (i / 10) * Math.PI * 1.56
+      shoe.push({ x: spot.x + size * Math.cos(turn), y: spot.y + size * Math.sin(turn) * 0.72 })
+    }
+    marks.push(shoe)
+  }
+
+  return marks
+}
+
+/**
+ * A number between 0 and 1 that is the same every time it is asked for.
+ *
+ * The tentacles need to differ from one another and a scene has to open the
+ * same way twice, so nothing here draws a random number: a strand's length and
+ * its phase are a function of which strand it is. The constants are the usual
+ * hash and mean nothing.
+ */
+function jitter(at: number, salt: number): number {
+  const spun = Math.sin(at * 12.9898 + salt * 78.233) * 43758.5453
+  return spun - Math.floor(spun)
+}
+
+/** How many pieces a strand and an arm are cut into. */
+const STRAND = 8
+const ARM = 7
+
+/**
+ * How much margin one strand is worth, in px, and the shortest one worth
+ * drawing at all.
+ *
+ * A moon jelly carries hundreds of marginal tentacles and they are each about
+ * a centimetre. Drawn at the count and drawn honestly they are forty lines
+ * inside a fringe eleven pixels deep, which costs a renderer forty strokes and
+ * buys the reader a smudge. So the drawing knows how big it is: the fringe
+ * thins as the animal recedes and goes altogether when there is nothing left
+ * of it, and the bunches survive, because how many clusters a lion's mane has
+ * is part of what it is.
+ */
+const PITCH = 5
+const WORTH = 3
+
+/**
+ * Everything fine that hangs off the margin.
+ *
+ * One rule for all of them and a table of numbers to argue about, which is the
+ * same bargain `HABITS` makes with swimming. What separates a moon jelly's
+ * fringe from a lion's mane is `hairs`, `hairFall` and `bunches`: forty
+ * stubs evenly round the rim against thirty-two in eight clusters falling two
+ * and a half bell widths.
+ *
+ * They gather as the bell contracts and splay again as it fills, which is not
+ * a flourish. It is the only part of the animal that shows the water it is
+ * pushing against, and it is the same argument `squidArms` makes.
+ */
+export function hairOf(one: Jelly): Point[][] {
+  const habit = HABITS[one.kind]
+  const shape = DOMES[one.kind]
+  const strands: Point[][] = []
+  const wide = (shape.wide * (1 - shape.wideLoss * one.squeeze)) / 2
+  const splay = 0.28 * (1 - one.squeeze)
+  const room = Math.max(habit.bunches, Math.round(one.size / PITCH))
+  const per = Math.max(
+    1,
+    Math.min(Math.round(habit.hairs / habit.bunches), Math.round(room / habit.bunches)),
+  )
+  const shown = habit.hairFall * one.size < WORTH ? 0 : Math.min(habit.hairs, per * habit.bunches)
+
+  for (let made = 0; made < shown; made++) {
+    const bunch = Math.floor(made / per)
+    const inside = per > 1 ? ((made % per) / (per - 1) - 0.5) * 0.9 : 0
+    const across =
+      habit.bunches > 1
+        ? ((bunch + 0.5) / habit.bunches - 0.5) * 2 + inside * (0.55 / habit.bunches)
+        : shown > 1
+          ? (made / (shown - 1) - 0.5) * 2
+          : 0
+
+    strands.push(
+      strand(
+        wide * across,
+        shape.hang + (shape.bow + shape.cut) * (1 - across * across),
+        habit.hairFall * (0.62 + 0.38 * jitter(made, 1)),
+        across * splay,
+        one,
+        made,
+      ),
+    )
+  }
+
+  // The long one. A crown jelly trails a single tentacle several times its own
+  // width and fishes with it; a man o' war trails one that averages ten metres
+  // under a float the size of a hand. Both are the animal, so both are drawn,
+  // and neither is a mistake in the numbers.
+  if (habit.trail > 0) {
+    strands.push(strand(wide * 0.1, shape.hang + shape.bow * 0.6, habit.trail, 0.06, one, 97))
+  }
+
+  return strands
+}
+
+/**
+ * One strand, falling from where it is rooted.
+ *
+ * Its wave runs down its own length and it runs slower the further down it
+ * goes, which is what makes a length of hair in water look heavy. Straight
+ * while the bell is squeezed, since a strand behind something that has just
+ * pushed is a strand being pulled.
+ */
+function strand(
+  rootX: number,
+  rootY: number,
+  fall: number,
+  out: number,
+  one: Jelly,
+  at: number,
+): Point[] {
+  const points: Point[] = []
+  const phase = jitter(at, 2) * Math.PI * 2 + one.beat * Math.PI * 2
+  const wave = (1 - one.squeeze * 0.8) * 0.05 * (0.6 + jitter(at, 3))
+
+  for (let step = 0; step <= STRAND; step++) {
+    const along = step / STRAND
+    points.push({
+      x: rootX + out * along * fall + Math.sin(phase + along * 3.4) * wave * along * fall,
+      y: rootY + along * fall * (0.9 + 0.1 * one.squeeze),
+    })
+  }
+
+  return points
+}
+
+/**
+ * The oral arms, which are the thick things and not the stinging ones.
+ *
+ * A barrel jelly has eight and nothing else, no marginal tentacles at all, and
+ * is the animal you can pick out of a bloom by that alone. A moon jelly has
+ * four short frilled ones round its mouth. A lion's mane's hang in folded
+ * curtains behind the hair. The box jelly and the crown have none worth
+ * drawing, so they get none.
+ */
+export function armsOf(one: Jelly): Point[][] {
+  const habit = HABITS[one.kind]
+  if (habit.arms <= 0) return []
+
+  const shape = DOMES[one.kind]
+  const wide = (shape.wide * (1 - shape.wideLoss * one.squeeze)) / 2
+  const arms: Point[][] = []
+
+  for (let made = 0; made < habit.arms; made++) {
+    const across = habit.arms > 1 ? (made / (habit.arms - 1) - 0.5) * 2 : 0
+    const root = across * wide * 0.3
+    const phase = jitter(made, 4) * Math.PI * 2 + one.beat * Math.PI * 2
+    const frill = 0.07 * (0.5 + jitter(made, 5)) * (1 - one.squeeze * 0.6)
+    // No two the same length. A bunch of arms all ending on one line is a
+    // fringe on a lampshade, and it is the single thing that gave the first
+    // draft of these away as drawn instead of grown.
+    const fall = habit.armFall * (0.66 + 0.34 * jitter(made, 6))
+    const points: Point[] = []
+
+    for (let step = 0; step <= ARM; step++) {
+      const along = step / ARM
+      // Out and then down, so an arm leaves the mouth sideways and gathers
+      // under the bell instead of dropping out of it like a rope. The tip
+      // comes back in, which is what stops a bunch of them reading as pipes.
+      points.push({
+        x:
+          root +
+          across * wide * 0.62 * Math.sqrt(along) * (1 - along * along * 0.55) +
+          Math.sin(phase + along * 4.2) * frill * along,
+        y: shape.hang + shape.bow * 0.5 + along * fall * (0.88 + 0.12 * one.squeeze),
+      })
+    }
+    arms.push(points)
+  }
+
+  return arms
+}
+
+/** How many rows a comb jelly shows the reader, out of the eight it has. */
+const ROWS = 4
+
+/** How many pieces one row is cut into, and how far the wave lags down it. */
+const BEADS = 7
+const LAG = 2.2
+
+/**
+ * The comb rows, and where the light running along them has got to.
+ *
+ * Eight rows of fused cilia, beating in sequence from the aboral end towards
+ * the mouth, each row a fraction behind the one before it. What runs along
+ * them is not light the animal made: the rows work as a diffraction grating,
+ * so what the reader sees is the water's own light taken apart. That is why a
+ * ctenophore in a beam looks like it is wired up and a ctenophore in the dark
+ * does not.
+ *
+ * So this is the borrowed light, and it needs a sun to borrow from. The comb
+ * jelly's own light is `Jelly.glow`, it comes on when something jostles the
+ * animal, it runs along these same eight rows, and it needs the dark. The two
+ * are drawn on one set of lines from two different sources, and telling them
+ * apart is the whole reason this animal is worth having in the water.
+ *
+ * The wave dies as the lobes come in, since a row that has stopped beating has
+ * stopped diffracting. The lines are handed over anyway: that is the moment
+ * the animal is flashing.
+ *
+ * Half the rows face away and are not drawn. Each piece carries its own share
+ * of the wave, because the wave is the point and a row drawn at one weight is
+ * a stripe.
+ */
+export function combRows(one: Jelly): { glow: number; points: Point[] }[] {
+  if (one.kind !== "comb") return []
+
+  const lit: { glow: number; points: Point[] }[] = []
+  const beating = 1 - one.squeeze
+
+  for (let row = 0; row < ROWS; row++) {
+    const across = (row / (ROWS - 1) - 0.5) * 2
+    const seat = across * 0.34 * (1 - 0.2 * one.squeeze)
+    // The rows near the edge of the body are seen almost end on, so they are
+    // shorter on the screen and dimmer. Nothing about the animal changed.
+    const edge = 1 - Math.abs(across) * 0.45
+
+    for (let bead = 0; bead < BEADS; bead++) {
+      const from = bead / BEADS
+      const to = (bead + 1) / BEADS
+      const along = (from + to) / 2
+      const swell = Math.sin(one.wave - along * LAG + row * 0.5)
+      lit.push({
+        glow: beating * edge * (0.25 + 0.75 * Math.max(0, swell)),
+        points: [
+          { x: seat * bodyAt(from), y: 0.7 - from * 1.24 },
+          { x: seat * bodyAt(to), y: 0.7 - to * 1.24 },
+        ],
+      })
+    }
+  }
+
+  return lit
+}
+
+/** How wide the body is at a point along a row, the aboral end at 0. */
+function bodyAt(along: number): number {
+  return Math.sin(Math.min(1, along * 0.82 + 0.18) * Math.PI) ** 0.6
+}
+
+/** How many waves of the alarm are running round the margin at once. */
+const ALARMS = 3
+
+/**
+ * The crown jelly's alarm: light running round its own margin.
+ *
+ * *Atolla wyvillei* held by something fires a wave of blue round the rim and
+ * keeps firing it, turn after turn, for several seconds. It is not a warning
+ * to whatever has hold of it. It is an advertisement, meant to bring in
+ * something big enough to eat the thing that is eating it, and it works: a
+ * lure built to imitate it is what put a live giant squid on camera in 2012.
+ *
+ * The far half of the margin is seen through the animal, so it is dimmer. That
+ * is what turns a row of lights into a wheel.
+ */
+export function sparks(one: Jelly): { glow: number; x: number; y: number }[] {
+  if (one.glow <= 0.01 || HABITS[one.kind].light !== "wave") return []
+
+  const shape = DOMES[one.kind]
+  const wide = (shape.wide * (1 - shape.wideLoss * one.squeeze)) / 2
+  const lit: { glow: number; x: number; y: number }[] = []
+
+  for (let made = 0; made < ALARMS; made++) {
+    const round = one.wave + (made / ALARMS) * Math.PI * 2
+    const front = Math.sin(round)
+    lit.push({
+      glow: one.glow * (0.35 + (0.65 * (front + 1)) / 2),
+      x: Math.cos(round) * wide,
+      y: shape.bow * (1 + front * 0.4),
+    })
+  }
+
+  return lit
+}
+
+/**
+ * The whole animal alight, which is the commonest display in the sea.
+ *
+ * A mauve stinger touched in the dark lights bell, arms and tentacles at once
+ * and goes on doing it wherever it was touched; *Pelagia noctiluca* is the
+ * night light of the sea and was named that centuries before anybody knew what
+ * the light was for. There is no shape to it and no direction, so what goes
+ * over the wire is a middle and a reach.
+ *
+ * The reach covers the tentacles as well as the bell, because they light too,
+ * and a glow stopping at the margin would draw a lamp with a jellyfish hanging
+ * under it.
+ */
+export function washOf(one: Jelly): { glow: number; reach: number } | null {
+  const habit = HABITS[one.kind]
+  if (habit.light !== "wash" || one.glow <= 0.01) return null
+
+  return {
+    glow: one.glow,
+    reach: one.size * (0.5 + Math.max(habit.hairFall, habit.armFall) * 0.45),
+  }
+}