@codincod/ornament 0.0.0-stage → 0.1.0

package/src/walkers.ts

@@ -0,0 +1,861 @@
+/**
+ * What walks on the bottom: crabs and starfish.
+ *
+ * The bed grows things and now it has animals living on it, kept free of the
+ * DOM the way the rest of the ornament is. A plant is rooted and everything it
+ * does is the water doing it; these two are the other case. They are on the
+ * ground, they go where they decide to go, and the current has no say in
+ * either.
+ *
+ * ## Why they are not in `flora.ts`
+ *
+ * A thing that walks is not a thing that is rooted, and the two want opposite
+ * machinery. A plant is a strand recut from a field every step and it never
+ * moves, so nothing about it accumulates. A walker has a position it carries
+ * from one step to the next, which is a different kind of object however
+ * similar the drawings come out.
+ *
+ * ## Why the bottom needed them
+ *
+ * Everything else down there is scenery. Kelp leans, coral holds still, and a
+ * bed of both is a place with nothing living in it, which the eye reads as a
+ * diagram of a seabed. One animal going about its business at the bottom of the
+ * picture is what makes the rest of it a floor rather than a pattern, and it
+ * costs a handful of lines.
+ *
+ * ## A crab
+ *
+ * It goes sideways, which is the whole of what says crab before anything else
+ * about the drawing does. Most of its day it is not going anywhere: it stands,
+ * it works at the sand, and then it crosses a stretch quickly and stops again.
+ * That is the shape a small animal on an open floor actually has, and it is
+ * also what makes the crossings worth watching.
+ *
+ * The gait runs off distance rather than off the clock. A leg cycle driven by
+ * time carries on swinging while the animal stands still, which reads as a
+ * crab running on the spot; driven by how far it has gone, the legs stop when
+ * it stops and hurry when it hurries, for free.
+ *
+ * ## A starfish
+ *
+ * It creeps. The number is not a compromise: a starfish moves about as fast as
+ * a minute hand, so what it has instead of a gait is its arms, which reach and
+ * shorten on their own clocks. Over a sitting it will have gone somewhere, and
+ * nobody will have seen it go.
+ *
+ * It is drawn squashed, because it is lying on the ground rather than standing
+ * on it. The ground climbs the picture as it goes back, so the sand is seen
+ * from a shallow angle above, and a star lying flat on it is a star seen from
+ * that angle. Drawn round it would be a starfish stuck to the glass.
+ *
+ * ## Nobody tells a crab anything
+ *
+ * There is no conductor down here. The water is the place everything is in and
+ * the register of what is in it, and an animal reads that register and decides
+ * for itself; nothing is fired at it. So a crab is handed `about`, a way of
+ * asking what else is out there, and what it does with the answer is its own
+ * business. Hand it nothing and it goes about its day.
+ *
+ * What it does is freeze. A crab on open sand cannot outrun anything worth
+ * running from, so its first answer is to stop being a moving thing, and its
+ * second, when whatever it is gets close enough, is to bolt for the edge of the
+ * picture. That order matters: a crab that bolted at the first shadow would be
+ * a crab that has never met one.
+ *
+ * The two answers are to different questions, which is why the water reports
+ * size and menace separately. Anything big enough and near enough will stop a
+ * crab dead, turtle or shark, because a thing that has not seen you is a thing
+ * you keep it that way. What decides whether it then runs is whether the thing
+ * looks like it hunts. Something enormous and harmless directly overhead will
+ * still move it, because a crab under a turtle is a crab about to be stood on.
+ *
+ * A starfish does nothing at all, which is not an omission. Its answer to a
+ * predator takes hours, and an animal reacting on a timescale nobody is
+ * watching is an animal that does not react.
+ *
+ * ## The drawings
+ *
+ * The same contract the octopus keeps, so a renderer that can draw one can draw
+ * these: a path in a drawing one unit wide sitting on the origin, plus lines in
+ * that same drawing, and `size` is what a unit is worth in px. The origin is
+ * the sand under the animal, which is what lets a renderer put it at `x`, `y`
+ * and be done.
+ */
+
+import { abreast, type Presence } from "./biome.ts"
+import { makeRandom } from "./perlin.ts"
+import type { Point } from "./seabed.ts"
+import { BED_OFF, drawnAt } from "./sizes.ts"
+
+export type WalkerKind = "crab" | "starfish"
+
+export interface Walker {
+  /**
+   * The body, as a path in a drawing one unit wide sitting on the origin.
+   *
+   * Recut every step. A carapace has no shape to change, so what moves it is
+   * the bob; a starfish is all body, so its arms are the only thing it has.
+   */
+  body: string
+  /**
+   * How many times this walker has redrawn itself.
+   *
+   * The only thing a renderer has to watch. While it holds, `body`, `legs`,
+   * `x`, `y` and `facing` are what they already were, so a renderer keeping its
+   * own drawing keeps one that is still true and does no work. A crab spends
+   * most of its day standing, so most of them hold most of the time.
+   */
+  cut: number
+  /** 0 is as far off as this water goes, 1 is up against the glass. */
+  readonly depth: number
+  /** Which way it is going. A crab leads with a side; a starfish has no front
+   *  at all and keeps this only to say which way it is creeping. */
+  facing: number
+  readonly kind: WalkerKind
+  /** The legs and the claws, in the same drawing. Empty for a starfish. */
+  legs: Point[][]
+  /** px per unit of the drawing. */
+  readonly size: number
+  x: number
+  y: number
+}
+
+export interface Walkers {
+  /**
+   * A box of a new size, and the ground that came with it.
+   *
+   * The height is taken and not read. Nothing here ever leaves the ground, so
+   * the only thing a taller box changes is where the ground is, and that
+   * arrives as `floor`. It is in the signature because every other layer's
+   * resize has that shape and a renderer resizes all of them in a row.
+   */
+  resize(width: number, height: number, floor: (x: number, depth?: number) => number): void
+  step(seconds: number): void
+  readonly walkers: readonly Walker[]
+}
+
+export interface WalkersOptions {
+  /**
+   * What else is in the water, asked for once a step.
+   *
+   * Left out, nothing is: a floor with no register to read is a floor whose
+   * animals have nothing to be frightened of, which is the state a scene with
+   * no shark in it is in anyway.
+   */
+  about?: () => readonly Presence[]
+  crabs?: number
+  /** The ground at x, at a given distance; `seabed.floorAt`. An animal that
+   *  asked for the sand at the front while standing at the back would be an
+   *  animal buried up to its shell in the hillside. */
+  floor: (x: number, depth?: number) => number
+  seed: number
+  starfish?: number
+  /**
+   * How far a walker may travel from its last drawing before it redraws, in px.
+   *
+   * `FloraOptions.tolerance` for animals that walk, and the same bargain. A
+   * crab standing still is free, one crossing a stretch costs what it always
+   * did, and in between the drawing arrives in steps of this size. At nothing
+   * every walker redraws on every step, which is how it behaved before.
+   */
+  tolerance?: number
+  width: number
+}
+
+/**
+ * The ends of a crab's shell across, and of a starfish's span tip to tip, in
+ * metres.
+ *
+ * Real animals off the sand, turned into a share of the box by `sizes.ts` at
+ * the distance the floor lies at. Written in px they were a fraction of what
+ * they should have been, and the fault could not be seen from inside this file:
+ * nine px is a defensible crab right up until a fish the length of your hand
+ * swims over it at six times its size. The two of them are near enough one
+ * another in the water, so they are near enough one another here.
+ *
+ * The shell rather than the animal, because the shell is what a drawing here is
+ * a unit of. A crab reaches about twice this once its legs and its claws are
+ * out, which is where the animal a reader actually sees comes from.
+ */
+const CRAB_SMALLEST = 0.06
+
+const CRAB_LARGEST = 0.14
+
+const STARFISH_SMALLEST = 0.18
+
+const STARFISH_LARGEST = 0.34
+
+/**
+ * How much of a walker's drawn size is its distance.
+ *
+ * The share the rest of the scene uses. Scaled by depth outright, the far end
+ * of the range is a tenth of the near end, and a tenth of a crab is a speck;
+ * what distance is for down here is weight rather than size.
+ */
+const DEPTH_SIZE = 0.55
+
+/**
+ * How far back they go.
+ *
+ * As far as the bed grows, and that is the point of them. The far ground is the
+ * part of the picture that reads as bare, and a plant does not fix it: that far
+ * back a plant is a few px of a faint line, which the haze takes first. What
+ * fixes bare ground is something with a body. A shell and a star are both a
+ * shape with an outline, and an outline survives being drawn small and faint.
+ */
+const DEPTH_FAR = 0.12
+
+const DEPTH_NEAR = 1
+
+/**
+ * How hard a starfish leans towards the back of the water when it is placed.
+ *
+ * A crab is mostly legs, which is to say mostly lines, and it belongs wherever
+ * it happens to be. A starfish is a disc, and a disc is worth most where a line
+ * has stopped reading. It is a lean rather than a rule, since one at the front
+ * is the only one anybody sees the arms of.
+ */
+const STAR_BACK = 1.7
+
+/** How far past the side one goes before it comes back on the other. */
+const MARGIN = 1.4
+
+/** How fast a crab crosses, in its own widths a second, and how much faster or
+ *  slower than that one of them is. */
+const SCUTTLE = 2.6
+
+const HASTE = 0.45
+
+/**
+ * How long a crab stands and how long it goes, in seconds, and how often a stop
+ * turns it round.
+ *
+ * Standing takes most of it. An animal that crossed the picture continuously
+ * would be a shuttle, and the stopping is what makes a crossing something that
+ * happened rather than something that is always happening.
+ */
+const STAND_LEAST = 3.5
+
+const STAND_SPAN = 9
+
+const GO_LEAST = 0.8
+
+const GO_SPAN = 2.6
+
+const TURN_ODDS = 0.45
+
+/**
+ * How much bigger than a crab a thing has to be before it is minded, how far
+ * off it is minded from as a share of its own size, and how fast the fright
+ * fades once it has gone.
+ *
+ * The first two are the rule `nemos.ts` uses, because it is the right rule and
+ * two animals in one water should be frightened of the same things. Something
+ * a crab's own size is another crab.
+ */
+const MINDS = 1.6
+
+const NOTICE = 3.2
+
+const FRIGHT_FADE = 3.5
+
+/**
+ * How much of a bolt something with no menace about it can still provoke.
+ *
+ * A quarter. `nemos.ts` weighs its fright the same way and for the same reason:
+ * a shape that has never eaten anybody is not nothing when it is on top of you,
+ * and a sea where a turtle and a shark were the same event is a sea where
+ * nothing that happens means anything.
+ */
+const BULK = 0.25
+
+/**
+ * How frightened a crab has to be before it stops, and before it runs.
+ *
+ * A long way apart. Freezing is the whole of what a small animal on open ground
+ * has, and the bolt is what is left when freezing has plainly not worked.
+ */
+const FREEZE_AT = 0.05
+
+const BOLT_AT = 0.55
+
+/**
+ * How near a thing has to be, whatever it looks like, before a crab gets out
+ * from under it.
+ *
+ * Nearly touching, and it is the only reading here that ignores menace
+ * entirely. A crab under a turtle is a crab about to be stood on, and nothing
+ * about the turtle's intentions makes that better.
+ */
+const SQUASH_AT = 0.88
+
+/** How much faster than a walk a bolt is. */
+const BOLT = 3.4
+
+/** How fast a starfish creeps, in its own spans a second, and how far off that
+ *  one of them is. A minute hand, and the arithmetic is the same. */
+const CREEP = 0.008
+
+const DAWDLE = 0.6
+
+/** How long a starfish holds a direction, in seconds. Nothing about this animal
+ *  is in a hurry, and a starfish that changed its mind often would be a leaf. */
+const HOLD_LEAST = 40
+
+const HOLD_SPAN = 90
+
+/** How high the shell rides above the sand, and how far it bobs as the legs
+ *  work. A shell that rode on the ground would be a stone with legs. */
+const RIDE = 0.24
+
+const BOB = 0.035
+
+/** How many legs a side carries, how far one strides, and how far it lifts. */
+const LEGS = 4
+
+/** What the far side's legs keep of the near side's reach, and how far up the
+ *  picture its feet stand. The ground behind something is drawn higher than the
+ *  ground it is standing on, and a foot that ignored that is a foot in a hole. */
+const AWAY = 0.66
+
+const BEHIND = 0.05
+
+const STRIDE = 0.1
+
+const LIFT = 0.06
+
+/** How far a crab's gait comes round for one width travelled. Two cycles, so a
+ *  leg is not covering half the animal's own width in a stride. */
+const GAIT = Math.PI * 4
+
+/** How many arms a starfish has, how far the web between them comes in, and how
+ *  finely the outline is cut. */
+/** How far a walker travels before it is worth redrawing, in px, by default. */
+const TOLERANCE = 0.25
+
+/**
+ * How far a crab's foot travels for a radian of its gait, in the drawing.
+ *
+ * Read off `crabLegs` rather than guessed at. A foot sits at `swing * STRIDE`
+ * across and `-max(0, swing) * LIFT` up, and a sine cannot change faster than
+ * its own angle, so no part of a leg outruns this. It is the whole of what
+ * changes when a crab works its legs without going anywhere.
+ */
+const GAIT_REACH = Math.hypot(STRIDE, LIFT)
+
+/**
+ * How much of an arm's length is the reach that makes it creep, halved.
+ *
+ * A starfish is drawn one unit across, so an arm tip sits about half a unit out
+ * and travels about half of whatever its length does. Its length is
+ * `odd * (1 + sin(clock) * ARM_REACH)`, and each arm keeps its own clock, so
+ * what a starfish is capable of in a second is the fastest of them.
+ */
+const ARM_TIP = 0.5
+
+const ARMS = 5
+
+const WEB = 0.44
+
+const RIM = 44
+
+/** How much of its span an arm may be short or long of the rest, and how far it
+ *  reaches and pulls back as it goes. No two arms of one animal agree. */
+const ODD_ARM = 0.22
+
+const ARM_REACH = 0.12
+
+/** How fast an arm works through its own reach, slowest to fastest. */
+const ARM_SLOWEST = 0.12
+
+const ARM_FASTEST = 0.34
+
+/**
+ * How much a starfish is squashed, lying on the sand.
+ *
+ * Nearly half. It is the one drawing here that is being seen from above rather
+ * than from the side, and the ground it is lying on is a slope going away from
+ * the reader; this is that slope's share of it. Drawn round it is a starfish
+ * stuck to the inside of the glass.
+ */
+const FLATTEN = 0.46
+
+const MIN_SPAN = 1
+
+/**
+ * What a crab has made of the water this moment: how alarming the worst thing
+ * in it is, how much of that is something that hunts, and where it was.
+ */
+interface Seen {
+  chased: number
+  from: number
+  near: number
+}
+
+/**
+ * The walker as it stood when it was last drawn.
+ *
+ * Everything the drawing was made from, so how far it has wandered since is
+ * arithmetic on it. Against the last drawing rather than the last step, since a
+ * crab that shuffled and came back has not moved.
+ */
+interface Drawn {
+  readonly facing: number
+  /** Seconds since the drawing was made, which is all a starfish needs. */
+  since: number
+  readonly stride: number
+  readonly x: number
+  readonly y: number
+}
+
+/** What one walker is doing, alongside the animal itself. */
+interface Doing {
+  /** Where each arm is in its own reach. Empty for a crab. */
+  readonly arms: number[]
+  /** How far through the current bout it is, in seconds. */
+  at: number
+  /** How much of the fright is something that looks like it hunts. */
+  chased: number
+  /** How far this one's fastest arm carries its tip in a second, in the
+   *  drawing. Nought for a crab, which has no arms and a gait instead. */
+  readonly creep: number
+  /** How frightened it is, 0 easy and 1 with the thing on top of it. */
+  fright: number
+  /** Whether it is going anywhere at the moment. */
+  going: boolean
+  /** How long and how odd each arm is. Empty for a crab. */
+  readonly odd: readonly number[]
+  /** How fast it goes when it is going, in px a second. */
+  readonly pace: number
+  /** How far each arm gets through its reach in a second. Empty for a crab. */
+  readonly rates: readonly number[]
+  /** How long this bout runs, in seconds. */
+  span: number
+  /** How far through the gait it is, in radians. */
+  stride: number
+}
+
+/**
+ * A crab's shell, in a drawing one unit wide sitting on the origin.
+ *
+ * Wider than it is tall, which is the half of a crab that is not its legs. The
+ * `bob` lifts it as the legs work, and it is small enough that nobody will name
+ * it: what it is for is that the shell and the legs are one animal rather than
+ * a drawing with lines under it.
+ */
+export function crabShell(bob: number): string {
+  const at = (-RIDE - 0.22 + Math.sin(bob) * BOB).toFixed(3)
+  const up = (-RIDE - 0.46 + Math.sin(bob) * BOB).toFixed(3)
+  const low = (-RIDE + 0.02 + Math.sin(bob) * BOB).toFixed(3)
+
+  return [
+    `M-0.5 ${at}`,
+    `Q-0.48 ${up} 0 ${up}`,
+    `Q0.48 ${up} 0.5 ${at}`,
+    `Q0.46 ${low} 0 ${low}`,
+    `Q-0.46 ${low} -0.5 ${at}`,
+    "Z",
+  ].join(" ")
+}
+
+/** The shell with the bob out of it, for anything wanting a still one. */
+export const CRAB_SHELL = crabShell(0)
+
+/** How a crab is standing: which way it leads, and where it is in its gait. */
+export interface CrabPose {
+  readonly facing: number
+  readonly stride: number
+}
+
+/**
+ * The legs and the claws, in the same drawing as the shell.
+ *
+ * A leg is a hip, a knee above the shell and a foot on the sand, which is the
+ * arch that says crab rather than insect. They work in two groups, so half the
+ * animal is planted whenever the other half is swinging, and the swing is a
+ * step forward and a lift rather than a wave: a foot that rose without going
+ * anywhere is a crab treading water.
+ *
+ * The claws lead, because a crab goes sideways and holds them in front of the
+ * side it is going to. They are the one part of it drawn to be recognised at
+ * this size.
+ */
+export function crabLegs(pose: CrabPose): Point[][] {
+  const legs: Point[][] = []
+
+  for (let side = -1; side <= 1; side += 2) {
+    // The four on the far side of the animal, drawn shorter and standing
+    // closer in. There is no second weight to draw them at, so what says they
+    // are behind the shell is that they are foreshortened, which is what the
+    // far side of a standing thing actually does. Which side that is only
+    // changes at a stop, for the reason the octopus turns at a stop.
+    const away = side === -pose.facing ? AWAY : 1
+
+    for (let at = 0; at < LEGS; at++) {
+      const hip = { x: side * (0.44 - at * 0.05), y: -RIDE - 0.34 + at * 0.08 }
+      const seat = (0.5 + at * 0.13) * away
+
+      // Half of them a stride behind the other half. Every leg swinging at once
+      // is a crab hopping, and every leg planted at once is a crab sliding.
+      const swing = Math.sin(pose.stride + (at % 2 === 0 ? 0 : Math.PI) + (side < 0 ? Math.PI : 0))
+      const foot = {
+        x: side * seat + swing * STRIDE * pose.facing,
+        y: -Math.max(0, swing) * LIFT * away - (away < 1 ? BEHIND : 0),
+      }
+
+      legs.push([
+        hip,
+        { x: (hip.x + foot.x) / 2 + side * 0.07, y: (-RIDE - 0.36 - at * 0.02) * away },
+        foot,
+      ])
+    }
+  }
+
+  // Out in front of the side it is going to, and folded rather than straight: a
+  // claw held out at arm's length is a crab surrendering.
+  for (const up of [0, 1]) {
+    const lead = pose.facing
+    const rise = -RIDE - 0.1 - up * 0.13
+
+    legs.push([
+      { x: lead * 0.36, y: rise },
+      { x: lead * (0.74 + up * 0.05), y: rise + 0.04 },
+      { x: lead * (1.02 + up * 0.06), y: rise - 0.06 },
+      { x: lead * (0.88 + up * 0.05), y: rise - 0.2 },
+    ])
+  }
+
+  return legs
+}
+
+/**
+ * A starfish, as one closed outline in a drawing one unit across.
+ *
+ * Arms rather than points. A starfish drawn with a straight edge from tip to
+ * tip is a sheriff's badge, and what a real one has is a thick arm coming out
+ * of a disc and a deep round web between it and the next. `WEB` is where that
+ * web comes in to, and the whole difference between the two drawings is that
+ * number.
+ *
+ * `reach` is each arm's own length, which is where every one of these stops
+ * being a stamp of the same shape: an animal whose arms all agreed would be a
+ * cut-out, and a real one has one arm short from an argument it lost.
+ */
+export function starfishBody(reach: readonly number[]): string {
+  const arms = Math.max(1, reach.length)
+
+  // Seated on the longest arm it currently has, so it sits on the sand rather
+  // than through it, the way every other drawing here does. The seat shifts as
+  // the arms work, which is a settling nobody will name and is cheaper than
+  // deciding what the ground in front of it would have hidden.
+  const seat = Math.max(...reach) * 0.5 * FLATTEN
+
+  const path: string[] = []
+  for (let at = 0; at <= RIM; at++) {
+    const turn = (at / RIM) * Math.PI * 2
+    const lobe = (1 + Math.cos(turn * arms)) / 2
+    const arm = reach[Math.round((turn * arms) / (Math.PI * 2)) % arms] ?? 1
+    const out = (WEB + (1 - WEB) * lobe ** 0.7) * arm * 0.5
+
+    const x = (Math.sin(turn) * out).toFixed(3)
+    const y = (-seat - Math.cos(turn) * out * FLATTEN).toFixed(3)
+    path.push(`${at === 0 ? "M" : "L"}${x} ${y}`)
+  }
+
+  path.push("Z")
+  return path.join(" ")
+}
+
+export function createWalkers(options: WalkersOptions): Walkers {
+  const random = makeRandom(options.seed ^ 0x3c4a)
+
+  let width = Math.max(MIN_SPAN, options.width)
+  let floor = options.floor
+
+  const walkers: Walker[] = []
+  const doings: Doing[] = []
+
+  const tolerance = Math.max(0, options.tolerance ?? TOLERANCE)
+
+  /** What each walker was drawn from, or null while it never has been. */
+  const held: (Drawn | null)[] = []
+
+  function born(kind: WalkerKind): void {
+    const crab = kind === "crab"
+    const back = crab ? random() : random() ** STAR_BACK
+    const depth = DEPTH_FAR + back * (DEPTH_NEAR - DEPTH_FAR)
+    const across = crab
+      ? CRAB_SMALLEST + random() * (CRAB_LARGEST - CRAB_SMALLEST)
+      : STARFISH_SMALLEST + random() * (STARFISH_LARGEST - STARFISH_SMALLEST)
+    const span = drawnAt(across, BED_OFF) * width
+    const size = span * (1 - DEPTH_SIZE + DEPTH_SIZE * depth)
+    const x = random() * width
+
+    const odd: number[] = []
+    const arms: number[] = []
+    const rates: number[] = []
+    if (!crab) {
+      for (let at = 0; at < ARMS; at++) {
+        odd.push(1 - ODD_ARM + random() * ODD_ARM * 2)
+        arms.push(random() * Math.PI * 2)
+        rates.push(ARM_SLOWEST + random() * (ARM_FASTEST - ARM_SLOWEST))
+      }
+    }
+
+    // Part way through whatever it is doing already. A floor where every animal
+    // set off on the same frame is a floor that was switched on.
+    const going = crab ? random() < 0.3 : true
+    const run = crab ? bout(going) : HOLD_LEAST + random() * HOLD_SPAN
+
+    let quickest = 0
+    for (let at = 0; at < odd.length; at++) {
+      quickest = Math.max(quickest, (odd[at] ?? 0) * (rates[at] ?? 0) * ARM_REACH * ARM_TIP)
+    }
+
+    doings.push({
+      arms,
+      at: random() * run,
+      chased: 0,
+      creep: quickest,
+      fright: 0,
+      going,
+      odd,
+      pace: crab
+        ? size * SCUTTLE * (1 - HASTE + random() * HASTE * 2)
+        : size * CREEP * (1 - DAWDLE + random() * DAWDLE * 2),
+      rates,
+      span: run,
+      stride: random() * Math.PI * 2,
+    })
+
+    walkers.push({
+      body: "",
+      cut: 0,
+      depth,
+      facing: random() < 0.5 ? -1 : 1,
+      kind,
+      legs: [],
+      size,
+      x,
+      y: floor(x, depth),
+    })
+
+    held.push(null)
+  }
+
+  /** How long a crab stands, or how long it goes. */
+  function bout(going: boolean): number {
+    return going ? GO_LEAST + random() * GO_SPAN : STAND_LEAST + random() * STAND_SPAN
+  }
+
+  /**
+   * One animal, a moment on.
+   *
+   * A crab's gait is wound by the ground it covered rather than by the time
+   * that passed, so its legs stop when it does. That is one line and it is the
+   * difference between an animal walking and a sprite playing an animation.
+   */
+  /**
+   * How frightened this one is by what is in the water, right now.
+   *
+   * Bigger than it is, and near enough, where near is measured against the
+   * size of the thing rather than in px: a shark is a shark from further off
+   * than a bream is. `nemos.ts` minds the water by the same rule, which is
+   * what keeps two animals in one sea frightened of the same things.
+   */
+  function minded(one: Walker, water: readonly Presence[]): Seen {
+    const seen: Seen = { chased: 0, from: one.x, near: 0 }
+
+    for (const thing of water) {
+      if (thing.size < one.size * MINDS) continue
+
+      const reach = thing.size * 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: a shark cruising past the glass is
+      // nowhere near a crab back in the murk, however neatly they line up.
+      const near = (1 - away / reach) * abreast(one.depth, thing.depth)
+      if (near <= seen.near) continue
+
+      seen.chased = near * (BULK + (thing.menace ?? 0) * (1 - BULK))
+      seen.from = thing.x
+      seen.near = near
+    }
+
+    return seen
+  }
+
+  function carry(at: number, seconds: number, water: readonly Presence[]): void {
+    const one = walkers[at]
+    const doing = doings[at]
+    if (!one || !doing) return
+
+    doing.at += seconds
+
+    const was = held[at]
+    if (was) was.since += seconds
+
+    if (one.kind === "crab") {
+      const seen = minded(one, water)
+      doing.fright = Math.max(0, Math.max(doing.fright - seconds / FRIGHT_FADE, seen.near))
+      doing.chased = Math.max(0, Math.max(doing.chased - seconds / FRIGHT_FADE, seen.chased))
+
+      // Stop being a moving thing, and run only once that has plainly not
+      // worked. Both answers are taken before the bout it was in gets a say,
+      // and the bout is left where it was: what it was doing before the
+      // shadow came over is what it goes back to afterwards.
+      if (doing.chased > BOLT_AT || doing.fright > SQUASH_AT) {
+        one.facing = one.x < seen.from ? -1 : 1
+        const gone = doing.pace * BOLT * seconds * one.facing
+        one.x += gone
+        doing.stride += (Math.abs(gone) / one.size) * GAIT
+        settle(one)
+        return
+      }
+
+      if (doing.fright > FREEZE_AT) {
+        settle(one)
+        return
+      }
+
+      if (doing.at >= doing.span) {
+        doing.going = !doing.going
+        doing.at = 0
+        doing.span = bout(doing.going)
+        if (!doing.going && random() < TURN_ODDS) one.facing = -one.facing
+      }
+
+      if (doing.going) {
+        const gone = doing.pace * seconds * one.facing
+        one.x += gone
+        doing.stride += (Math.abs(gone) / one.size) * GAIT
+      }
+    } else {
+      if (doing.at >= doing.span) {
+        doing.at = 0
+        doing.span = HOLD_LEAST + random() * HOLD_SPAN
+        one.facing = random() < 0.5 ? -1 : 1
+      }
+
+      one.x += doing.pace * seconds * one.facing
+      for (let arm = 0; arm < doing.arms.length; arm++) {
+        doing.arms[arm] = (doing.arms[arm] ?? 0) + (doing.rates[arm] ?? 0) * seconds
+      }
+    }
+
+    settle(one)
+  }
+
+  /**
+   * Off one side and on at the other, and standing on the ground it is over.
+   *
+   * What the water does with everything else that crosses it. Every path
+   * through a step ends here, including the one a frightened crab takes, since
+   * a crab that ran off the edge of the picture and stayed there would be a
+   * crab that was frightened once.
+   */
+  function settle(one: Walker): void {
+    const past = one.size * MARGIN
+    if (one.x < -past) one.x += width + past * 2
+    if (one.x > width + past) one.x -= width + past * 2
+
+    one.y = floor(one.x, one.depth)
+  }
+
+  /**
+   * How far this walker can have travelled since it was last drawn.
+   *
+   * The animal moves as a whole and its legs move under it, and both have to be
+   * in here because a renderer holds one drawing for the two of them. The whole
+   * is `x` and `y` and is exact. The legs are a bound: a crab's foot cannot
+   * outrun `GAIT_REACH` for a radian of gait, and a starfish's arm cannot
+   * outrun `creep` for a second of creeping, and neither is a measurement of
+   * the drawing because making one would cost the drawing.
+   *
+   * A crab that turns is redrawn whatever the arithmetic says. Its far legs are
+   * the ones that shorten, so a mirrored crab is a different animal from the
+   * front and nothing continuous describes the change.
+   */
+  function stir(at: number): number {
+    const one = walkers[at]
+    const doing = doings[at]
+    const was = held[at]
+    if (!one || !doing || !was) return Number.POSITIVE_INFINITY
+    if (was.facing !== one.facing) return Number.POSITIVE_INFINITY
+
+    const worked = GAIT_REACH * Math.abs(doing.stride - was.stride) + doing.creep * was.since
+
+    return Math.hypot(one.x - was.x, one.y - was.y) + one.size * worked
+  }
+
+  /** Redraw one where it currently stands. */
+  function draw(at: number): void {
+    const one = walkers[at]
+    const doing = doings[at]
+    if (!one || !doing) return
+
+    held[at] = {
+      facing: one.facing,
+      since: 0,
+      stride: doing.stride,
+      x: one.x,
+      y: one.y,
+    }
+    one.cut++
+
+    if (one.kind === "crab") {
+      one.body = crabShell(doing.stride)
+      one.legs = crabLegs({ facing: one.facing, stride: doing.stride })
+      return
+    }
+
+    one.body = starfishBody(
+      doing.odd.map((odd, arm) => odd * (1 + Math.sin(doing.arms[arm] ?? 0) * ARM_REACH)),
+    )
+  }
+
+  function stock(): void {
+    walkers.length = 0
+    doings.length = 0
+    held.length = 0
+
+    for (let made = 0; made < Math.max(0, options.crabs ?? 0); made++) born("crab")
+    for (let made = 0; made < Math.max(0, options.starfish ?? 0); made++) born("starfish")
+  }
+
+  function advance(seconds: number): void {
+    const step = Math.min(Math.max(seconds, 0), 0.1)
+    const water = options.about?.() ?? []
+
+    for (let at = 0; at < walkers.length; at++) {
+      carry(at, step, water)
+      if (stir(at) >= tolerance) draw(at)
+    }
+  }
+
+  stock()
+  advance(0)
+
+  return {
+    resize(nextWidth, _height, nextFloor) {
+      const scale = Math.max(MIN_SPAN, nextWidth) / width
+      width = Math.max(MIN_SPAN, nextWidth)
+      floor = nextFloor
+
+      for (let at = 0; at < walkers.length; at++) {
+        const one = walkers[at]
+        if (!one) continue
+
+        one.x *= scale
+        one.y = floor(one.x, one.depth)
+        draw(at)
+      }
+    },
+
+    step: advance,
+
+    walkers,
+  }
+}