@codincod/ornament 0.0.0-stage → 0.2.0

package/src/paint/sea.ts

@@ -0,0 +1,809 @@
+/**
+ * A whole sea, from the seed it grew from to the block of numbers a renderer
+ * reads.
+ *
+ * The simulations decide what is in the water and where it is; `pen.ts` says
+ * what one drawing looks like; the files beside it turn one kind of thing into
+ * drawings. This is what holds all of that together and hands out a frame.
+ *
+ * Nothing here draws. What comes back from `over` is a Float32Array with every
+ * drawing in the frame written into it, and what a renderer does with that is
+ * its own business: the site's `render/card.ts` cuts it into triangles for a graphics card,
+ * its `render/flat.ts` walks it onto a canvas, and the desktop's own renderer reads the
+ * same block out of V8.
+ *
+ * ## Why it is a factory
+ *
+ * Because a page has more than one sea on it. A hero has a band of water behind
+ * its words, a design system page has a specimen of every animal, and each of
+ * them is its own box with its own seed and its own day. A module holding one
+ * scene in module state can serve one screen, which is what a wallpaper is and
+ * what a page is not.
+ *
+ * ## Two ways to hand over the bed
+ *
+ * `bed: "marks"` paints the ground and every plant into the frame with
+ * everything else, which is what a renderer without a vertex shader wants.
+ * `bed: "wire"` leaves them out of the frame and hands them over instead
+ * through `layout` and `publish`: the shape once, and after that two numbers a
+ * plant, for a renderer that would rather bend them on the card.
+ */
+import { createBiome } from "../biome.ts"
+import { createCaustics } from "../caustics.ts"
+import { type Kind, manyIn } from "../census.ts"
+import { createCephalopods } from "../cephalopods.ts"
+import { createClouds } from "../cloud.ts"
+import { createCrags } from "../crags.ts"
+import { createDrift } from "../drift.ts"
+import { createEels } from "../eels.ts"
+import { createFlora, type Plant } from "../flora.ts"
+import { createJellies, KINDS as JELLY_KINDS } from "../jellies.ts"
+import { createNemos } from "../nemos.ts"
+import { createPassers } from "../passers.ts"
+import { thriving } from "../plenty.ts"
+import { createPuffers } from "../puffers.ts"
+import { createRays } from "../rays.ts"
+import { createReef } from "../reef.ts"
+import { createRelics } from "../relics.ts"
+import { createSeabed } from "../seabed.ts"
+import { createShoal, daySeed, KINDS as FISH_KINDS, wild } from "../shoal.ts"
+import { createSwarm } from "../swarm.ts"
+import { createVisitors } from "../visitors.ts"
+import { createWalkers } from "../walkers.ts"
+import { paintCaustics, paintFlora, paintGround, paintWater } from "./bed.ts"
+import {
+  paintEels,
+  paintInklings,
+  paintJellies,
+  paintNemos,
+  paintPassers,
+  paintPuffers,
+  paintShoal,
+  paintSwarm,
+  paintVisitors,
+  paintWalkers,
+} from "./life.ts"
+import { paintRays, paintSnow } from "./light.ts"
+import { Pen } from "./pen.ts"
+import { paintCrags, paintHeads, paintRelics, paintStones } from "./rock.ts"
+import { type Caster, paintShade } from "./shade.ts"
+import { type Asked, paintSky } from "./sky.ts"
+
+/** How thickly the bed is sown, per thousand px of width. */
+const PER_K = {
+  anemones: 34,
+  cliffs: 5.5,
+  corals: 46,
+  fans: 19,
+  grasses: 124,
+  kelps: 24,
+  stones: 40,
+} as const
+
+/**
+ * The most of each the bed will ever hold.
+ *
+ * High enough that a rich day is drawn rather than clipped, and no higher. What
+ * a given renderer can actually afford is its own business and it says so with
+ * `thin`, since the ceiling that suits a wallpaper on a desktop card is not the
+ * one that suits a band of water behind a paragraph.
+ */
+const MOST = {
+  anemones: 200,
+  cliffs: 16,
+  corals: 500,
+  fans: 220,
+  grasses: 1400,
+  kelps: 280,
+  stones: 108,
+} as const
+
+const LEAST = 2
+const REEF_HEADS = 34
+const RANGES = 6
+
+/**
+ * How far apart two openings of the same water can be, in seconds.
+ *
+ * Past this the scene is a scene anybody has seen, so there is nothing to be
+ * gained by winding further and a wind is not free.
+ */
+const CYCLE = 150
+
+/** Sand, a hill, a mound and a cliff, on the wire. */
+const GROUND = { cliff: 2, hill: 1, mound: 3, sand: 0 } as const
+
+/** What a plant's kind comes to on the wire. */
+const WIRE_KINDS: Record<string, number> = { anemone: 2, coral: 4, fan: 3, grass: 1, kelp: 0 }
+
+/**
+ * The floors and ceilings on what the water is allowed to hold.
+ *
+ * How many of each there are is `census.ts`'s answer, and these are what a
+ * frame will actually carry: a floor so a sliver of a box still has a sea in
+ * it, and a ceiling so a bloom is a busy water rather than a dropped frame.
+ * `night` is the share of a shoal that is still out after dark.
+ */
+const FISH = { least: 6, most: 52, night: 0.55 }
+const MOTES = { least: 40, most: 280, per: 12_500 }
+const CRAWLERS = { mostCrabs: 14, mostStarfish: 14 }
+const COLONY = { fewest: 10, most: 120 }
+const PUFFERS = { most: 3 }
+const JELLIES = { most: 20 }
+const SHAFTS = 5
+const CLOUDS = 4
+const VENTS = 3
+const SPECKS = 3000
+const MOST_INKLINGS = 4
+
+/** How much of its own length a fish swims in a second. */
+const CRUISE = 0.8
+
+/** How far the water is wound on before anybody sees it, in steps of a tenth. */
+const WIND_STEP = 1 / 10
+
+/**
+ * How much the light has to move before the shoal is told a new number.
+ *
+ * Dawn takes minutes and the count is worked towards over them, so this is only
+ * how often the question is asked.
+ */
+const DAWN_STEP = 0.01
+
+/**
+ * How far the frame wanders, as a share of the box's short side, and how far it
+ * rolls, in radians.
+ *
+ * Nobody holds a camera still. A picture that does not move at all is a picture
+ * on a tripod, and a tripod is the thing this scene is trying not to be.
+ */
+const SWAY_REACH = 0.005
+const SWAY_ROLL = 0.0022
+
+/**
+ * How many numbers one frame of this water is given room for.
+ *
+ * A busy sea is a few thousand drawings and a drawing is a few dozen numbers,
+ * so this is several times over what one has ever come to. It is a float array
+ * allocated once that lives as long as the sea does, which is why the default
+ * is a page's answer rather than a wallpaper's: a screen wants the room, and a
+ * page with a dozen small seas on it wants the megabytes back.
+ */
+const ROOM = 1 << 20
+
+/**
+ * A coral's drawing, as numbers.
+ *
+ * The corals are the one thing in the bed that arrives as SVG, and they are
+ * also the one thing that never moves, so each drawing is read once and handed
+ * over as coordinates from then on. Every twig in `flora.ts` is a move and one
+ * curve, which is the whole of the grammar this needs.
+ */
+const carved = new Map<string, number[]>()
+
+function twigOf(d: string): number[] {
+  const held = carved.get(d)
+  if (held) return held
+
+  const numbers = d.match(/-?\d+(\.\d+)?/g)
+  const cut = numbers ? numbers.map(Number) : []
+  carved.set(d, cut)
+  return cut
+}
+
+export interface SeaOptions {
+  /**
+   * Where the ground and the plants are handed over.
+   *
+   * `marks` puts them in the frame with everything else. `wire` leaves them out
+   * of it and answers `layout` and `publish` instead.
+   */
+  bed?: "marks" | "wire"
+  /**
+   * Wind the rare things on with everything else.
+   *
+   * A passer keeps an appointment rather than a stopwatch and a shark is out
+   * once in an evening, so a still taken the way a scene opens one is a still of
+   * empty water. A harness comparing two renderers needs a sea with something
+   * in it; a page does not, and this is off for one.
+   */
+  eager?: boolean
+  height: number
+  /**
+   * An hour asked for rather than read off the clock; see `sky.ts`.
+   */
+  hour?: Asked | null
+  /**
+   * A block to write frames into, rather than one of this sea's own.
+   *
+   * For a host that has to know where the block is before there is a sea to
+   * hold it. The desktop's renderer reads the address out of V8 once, as the
+   * bundle finishes loading, and borrows it from then on; a sea that allocated
+   * its own would be writing somewhere the host is not reading. `room` is
+   * ignored when this is given, since the block brought is the room there is.
+   */
+  into?: Float32Array
+  /**
+   * How far a thing may move from its last drawing before it is drawn again, in
+   * px.
+   */
+  /**
+   * How many numbers a frame of this water is given room for.
+   *
+   * Raise it for a whole screen. A frame that runs out ends on a whole drawing
+   * rather than halfway through one, so what a block too small costs is the
+   * last few things in the picture and never a picture that cannot be read.
+   */
+  room?: number
+  /**
+   * Which water this is. The calendar day by default, which is what makes
+   * tomorrow somewhere else.
+   */
+  seed?: number
+  /**
+   * How much of the bed this renderer will carry, as a share of the ceilings
+   * above.
+   *
+   * One number rather than a table, because what varies between renderers is
+   * how much of a frame they have and not which plant they like. At 1 the bed
+   * is as thick as a good day makes it.
+   */
+  thin?: number
+  tolerance?: number
+  width: number
+}
+
+export interface Sea {
+  /** How far the box is across, as the sea last understood it. */
+  readonly box: { height: number; width: number }
+  /** The block every frame is written into. Read it, do not keep it. */
+  readonly geometry: Float32Array
+  /** The bed, once, for a renderer bending it on the card. */
+  layout(): number
+  /** Everything that moves, this frame. Returns how many numbers were written. */
+  over(): number
+  /** Where every plant's sway has got to, for a renderer bending it on the card. */
+  publish(): number
+  resize(width: number, height: number): void
+  /** The seed this water grew from. */
+  readonly seed: number
+  step(seconds: number): void
+  /** Carry the water on by a stretch of time, as cheaply as it can be done. */
+  wind(seconds: number): void
+}
+
+function spread(perThousand: number, most: number, width: number, thin: number): number {
+  return Math.max(
+    LEAST,
+    Math.min(Math.round(most * thin), Math.round((width * perThousand) / 1000)),
+  )
+}
+
+/** The same, for anything that grows, which is as thick as the day decided. */
+function lush(perThousand: number, most: number, width: number, day: number, thin: number): number {
+  return spread(perThousand * day * thin, most, width, thin)
+}
+
+/**
+ * Which sea today is.
+ *
+ * The local calendar day, stirred. A day is the unit because both of the
+ * obvious ones are wrong: one fixed seed is the same sea forever, and a seed off
+ * the clock is a new seabed on every visit.
+ */
+export function today(): number {
+  return daySeed()
+}
+
+export function createSea(options: SeaOptions): Sea {
+  const wired = options.bed === "wire"
+  const eager = options.eager ?? false
+  const thin = Math.max(0.05, options.thin ?? 1)
+  const tolerance = options.tolerance ?? 0
+  const seed = options.seed ?? today()
+  const geometry = options.into ?? new Float32Array(Math.max(1 << 14, options.room ?? ROOM))
+
+  let box = { height: options.height, width: options.width }
+  let at = 0
+  let held = 0
+  let turn = 0
+  let daylight = 1
+  let aimed = -1
+
+  // Everything that might put something on the sand this frame, gathered into
+  // one array that is emptied and filled rather than made again: this is the
+  // one list in the scene that is as long as the shoal, and a fresh one of those
+  // every frame is a new allocation the size of the whole water sixty times a
+  // second.
+  const shade: Caster[] = []
+
+  const put = (value: number) => {
+    geometry[at++] = value
+  }
+
+  const water = createBiome()
+
+  const seabed = createSeabed({
+    cliffs: spread(PER_K.cliffs, MOST.cliffs, box.width, thin),
+    height: box.height,
+    ranges: RANGES,
+    seed,
+    stones: spread(PER_K.stones, MOST.stones, box.width, thin),
+    width: box.width,
+  })
+
+  const reef = createReef({
+    floor: seabed.floorAt,
+    heads: Math.max(LEAST, Math.round(REEF_HEADS * thin)),
+    height: box.height,
+    seed,
+    tolerance,
+    width: box.width,
+  })
+
+  const day = thriving(seed)
+
+  const alive = (kinds: readonly Kind[], least: number, most: number): number =>
+    Math.max(least, Math.min(most, Math.round(manyIn(kinds, box.width, box.height, seed))))
+
+  // Dug before the bed is sown, because the bed asks it where not to grow. The
+  // colony reads the water and nothing reads the colony: a garden eel is
+  // smaller than anything here that would care, and what a bed of them is to
+  // the rest of this sea is sand.
+  const eels = createEels({
+    about: water.about,
+    count: alive(["eel"], COLONY.fewest, COLONY.most),
+    floor: seabed.floorAt,
+    height: box.height,
+    seed,
+    tolerance,
+    width: box.width,
+  })
+
+  const flora = createFlora({
+    about: water.about,
+    anemones: lush(PER_K.anemones, MOST.anemones, box.width, day, thin),
+    bare: eels.bare,
+    corals: lush(PER_K.corals, MOST.corals, box.width, day, thin),
+    // A renderer bending the bed on the card takes every plant but the crown as
+    // a shape at rest, and the crown is the honest exception: it is a heading
+    // that keeps turning rather than a shape with a bend put through it.
+    cutting: wired ? ["anemone"] : undefined,
+    fans: lush(PER_K.fans, MOST.fans, box.width, day, thin),
+    floor: seabed.floorAt,
+    grasses: lush(PER_K.grasses, MOST.grasses, box.width, day, thin),
+    height: box.height,
+    kelps: lush(PER_K.kelps, MOST.kelps, box.width, day, thin),
+    seed,
+    tolerance,
+    width: box.width,
+  })
+
+  const fishCount = (): number => {
+    const full = alive(FISH_KINDS, FISH.least, FISH.most)
+    const hour = FISH.night + (1 - FISH.night) * daylight
+    return Math.max(FISH.least, Math.round(full * hour))
+  }
+
+  const moteCount = (): number =>
+    Math.max(MOTES.least, Math.min(MOTES.most, Math.round((box.width * box.height) / MOTES.per)))
+
+  const walkers = createWalkers({
+    about: water.about,
+    crabs: alive(["crab"], LEAST, CRAWLERS.mostCrabs),
+    floor: seabed.floorAt,
+    seed,
+    starfish: alive(["starfish"], LEAST, CRAWLERS.mostStarfish),
+    tolerance,
+    width: box.width,
+  })
+
+  // It reads the register and never enters it. Something the size of a fist
+  // that has stopped running is not a thing anything else in this water has to
+  // make a decision about, which is the whole of what being a pufferfish buys.
+  const puffers = createPuffers({
+    about: water.about,
+    count: alive(["puffer"], 0, PUFFERS.most),
+    floor: seabed.floorAt,
+    height: box.height,
+    seed,
+    tolerance,
+    width: box.width,
+  })
+
+  const shoal = createShoal({
+    count: fishCount(),
+    cruise: CRUISE,
+    height: box.height,
+    seed,
+    species: wild(seed),
+    width: box.width,
+  })
+
+  const inklings = createCephalopods({
+    floor: seabed.floorAt,
+    height: box.height,
+    octopuses: alive(["octopus"], 1, MOST_INKLINGS),
+    seed,
+    squids: alive(["squid"], 1, MOST_INKLINGS),
+    width: box.width,
+  })
+
+  // The cephalopods, entered from out here rather than from inside their own
+  // file. An octopus is measured across its arms rather than its head, which is
+  // twice the size it is drawn at and is the honest number: what a crab sees
+  // coming over a stone is the reach.
+  water.enter(() => {
+    const about = []
+    for (const pus of inklings.octopuses) {
+      if (pus.lift > 0) {
+        about.push({ depth: pus.depth, menace: 0.55, size: pus.size * 2, x: pus.x, y: pus.y })
+      }
+    }
+    for (const squid of inklings.squids) {
+      about.push({ depth: squid.depth, menace: 0.3, size: squid.size, x: squid.x, y: squid.y })
+    }
+    return about
+  })
+
+  const jellies = createJellies({
+    count: alive(JELLY_KINDS, 1, JELLIES.most),
+    floor: seabed.floorAt,
+    height: box.height,
+    seed,
+    water,
+    width: box.width,
+  })
+
+  const wreckage = createRelics({
+    floor: seabed.floorAt,
+    height: box.height,
+    seed,
+    width: box.width,
+  })
+  const passers = createPassers({ eager, height: box.height, seed, width: box.width })
+  const visitors = createVisitors({ eager, height: box.height, seed, water, width: box.width })
+  const flock = createSwarm({
+    count: Math.round(SPECKS * thin),
+    eager,
+    height: box.height,
+    seed,
+    water,
+    width: box.width,
+  })
+  const nemos = createNemos({ about: water.about, reef, seed })
+  const caustics = createCaustics({ seed })
+  const crags = createCrags({ floor: seabed.floorAt, height: box.height, seed, width: box.width })
+  const drift = createDrift({
+    floor: seabed.floorAt,
+    height: box.height,
+    motes: Math.round(moteCount() * thin),
+    seed,
+    tolerance,
+    vents: VENTS,
+    width: box.width,
+  })
+  const light = createRays({ count: SHAFTS, height: box.height, seed, width: box.width })
+  const clouds = createClouds({ count: CLOUDS, height: box.height, seed, width: box.width })
+
+  /** Whatever the water is most frightened of this frame. */
+  const felt = () => {
+    const above = passers.startle
+    const among = visitors.startle
+    if (!above) return among
+    if (!among) return above
+    return among.force > above.force ? among : above
+  }
+
+  const putPoints = (points: readonly { x: number; y: number }[]) => {
+    put(points.length)
+    for (const point of points) {
+      put(point.x)
+      put(point.y)
+    }
+  }
+
+  const putTwigs = (plant: Plant) => {
+    put(plant.twigs.length)
+    for (const twig of plant.twigs) {
+      const cut = twigOf(twig.d)
+      put(twig.width)
+      put(cut.length)
+      for (const n of cut) put(n)
+    }
+  }
+
+  /** What each anemone was last handed over at, so a still one is not sent
+   *  again. A plant says when it has recut itself, and nothing else does. */
+  const handed: number[] = []
+
+  return {
+    get box() {
+      return box
+    },
+
+    geometry,
+
+    layout(): number {
+      at = 0
+      put(3)
+      put(box.width)
+      put(box.height)
+      put(1 + seabed.ranges.length + 1 + seabed.cliffs.length)
+      put(flora.plants.length)
+
+      put(GROUND.sand)
+      put(1)
+      putPoints(seabed.ridge)
+
+      for (const band of seabed.ranges) {
+        put(GROUND.hill)
+        put(band.depth)
+        putPoints(band.ridge)
+      }
+
+      put(GROUND.mound)
+      put(reef.depth)
+      putPoints(reef.crest)
+
+      for (const cliff of seabed.cliffs) {
+        put(GROUND.cliff)
+        put(cliff.depth)
+        putPoints(cliff.ridge)
+      }
+
+      for (let p = 0; p < flora.plants.length; p++) {
+        const plant = flora.plants[p]
+        if (!plant) continue
+        put(WIRE_KINDS[plant.kind] ?? 0)
+        put(plant.depth)
+        put(plant.girth)
+        put(plant.scale)
+        put(plant.x)
+        put(plant.y)
+
+        if (plant.kind === "coral") {
+          putTwigs(plant)
+          continue
+        }
+        if (plant.kind === "anemone") continue
+
+        const frame = flora.madeOf(p)
+        if (!frame) {
+          put(0)
+          put(0)
+          continue
+        }
+
+        put(frame.limbs.length)
+        for (const limb of frame.limbs) {
+          put(limb.beat)
+          put(limb.give)
+          put(limb.own)
+          put(limb.seat)
+          put(limb.shift)
+          put(limb.slant)
+          put(limb.span)
+          put(limb.steps)
+          put(limb.stem)
+        }
+
+        put(frame.leaves.length)
+        for (const leaf of frame.leaves) {
+          put(leaf.limb)
+          put(leaf.seat)
+          putPoints(leaf.shape)
+        }
+      }
+
+      return at
+    },
+
+    /**
+     * A frame of the water.
+     *
+     * ```
+     * swayX swayY tilt overscan turn daylight
+     * count
+     * drawing: form tone weight shade alpha lane width fall fadeTop fadeSpan
+     *          thin soft n (m (x y)*m)*n
+     * ```
+     */
+    over(): number {
+      at = 0
+      const unit = Math.min(box.width, box.height) * SWAY_REACH
+
+      // Two sines an octave and a bit apart on each axis, which is the cheapest
+      // thing that does not read as a pendulum: one alone is a frame swinging,
+      // and two whose periods do not divide each other never come back to the
+      // same place twice in anything like a minute.
+      put(unit * (0.62 * Math.sin(held * 0.11) + 0.38 * Math.sin(held * 0.29 + 1.7)))
+      put(unit * (0.62 * Math.sin(held * 0.13 + 2.4) + 0.38 * Math.sin(held * 0.23 + 0.6)))
+      put(SWAY_ROLL * Math.sin(held * 0.09 + 1.1))
+
+      // How much bigger than its box the scene is drawn, so that a frame which
+      // has wandered is never a frame with the page showing along one edge. The
+      // margin covers the roll as well as the wander: a corner is swung by the
+      // angle times its distance from the middle, which is further than the
+      // middle goes.
+      const reach = unit + (Math.abs(SWAY_ROLL) * Math.hypot(box.width, box.height)) / 2
+      put(1 + (2 * reach) / Math.max(1, Math.min(box.width, box.height)))
+      put(turn)
+
+      const lit = at
+      put(daylight)
+
+      const pen = new Pen(geometry, at)
+      if (!wired) paintWater(pen, box)
+
+      const sky = paintSky(pen, box, clouds, options.hour ?? null)
+      daylight = sky.daylight
+      geometry[lit] = daylight
+
+      // The shoal follows the light. Reef fish shelter after dark and the water
+      // over the sand thins out, so the count is a share of the day's, and the
+      // shoal is told the number rather than made to be it: it works towards it
+      // from the edges over the minutes dawn takes anyway, because a fish
+      // appearing in the middle of the picture is the one thing the water
+      // promises never to do.
+      if (Math.abs(daylight - aimed) > DAWN_STEP) {
+        aimed = daylight
+        shoal.hold(fishCount())
+      }
+
+      if (!wired) {
+        paintGround(pen, seabed, reef, box)
+        paintFlora(pen, flora)
+      }
+
+      paintCrags(pen, crags, box)
+      paintStones(pen, seabed)
+      paintHeads(pen, reef)
+      paintRelics(pen, wreckage)
+      // Over the ground and under everything standing on it, which is where
+      // light that came through the surface has got to.
+      paintCaustics(pen, seabed, caustics, box, daylight)
+
+      // Under everything that swims and over everything that does not, which is
+      // the one place in the order where a shadow on the ground is true. Built
+      // here rather than asked of each painter, because what a thing puts on the
+      // sand is the same question whatever the thing is.
+      shade.length = 0
+      for (const one of shoal.fish) shade.push(one)
+      for (const one of jellies.jellies) shade.push(one)
+      for (const one of puffers.puffers) shade.push(one)
+      for (const one of walkers.walkers) shade.push(one)
+      for (const one of visitors.crossing) shade.push(one)
+      paintShade(pen, shade, seabed.floorAt, box.height)
+
+      paintRays(pen, light, daylight)
+      paintSnow(pen, drift)
+      paintShoal(pen, shoal)
+      paintNemos(pen, nemos)
+      paintSwarm(pen, flock)
+      paintInklings(pen, inklings)
+      paintJellies(pen, jellies, daylight)
+      paintEels(pen, eels)
+      paintPuffers(pen, puffers)
+      paintWalkers(pen, walkers)
+      paintVisitors(pen, visitors)
+      paintPassers(pen, passers)
+
+      at = pen.close()
+      return at
+    },
+
+    publish(): number {
+      at = 0
+      put(flora.plants.length)
+
+      for (let p = 0; p < flora.plants.length; p++) {
+        const plant = flora.plants[p]
+        const swing = flora.swinging[p]
+        if (!plant) continue
+        put(swing ? swing.amp : 0)
+        put(swing ? swing.own : 0)
+
+        if (plant.kind !== "anemone" || handed[p] === plant.cut) {
+          put(0)
+          continue
+        }
+
+        handed[p] = plant.cut
+        put(1)
+        putPoints(plant.points)
+        put(plant.blades.length)
+        for (const blade of plant.blades) putPoints(blade)
+      }
+
+      return at
+    },
+
+    resize(width: number, height: number): void {
+      box = { height, width }
+      seabed.resize(width, height)
+      reef.resize(width, height, seabed.floorAt)
+      eels.resize(width, height, seabed.floorAt)
+      puffers.resize(width, height, seabed.floorAt)
+      flora.resize(width, height, seabed.floorAt)
+      handed.length = 0
+    },
+
+    seed,
+
+    step(seconds: number): void {
+      // The passers and the visitors go first, so the fish answer the hull and
+      // the shark where they are this frame rather than where they were last
+      // one. Everything else here is indifferent to the order.
+      passers.step(seconds)
+      visitors.step(seconds)
+      flock.step(seconds, felt())
+      shoal.step(seconds, null, felt())
+      drift.step(seconds)
+      caustics.step(seconds)
+      light.step(seconds)
+      clouds.step(seconds)
+      flora.step(seconds)
+      inklings.step(seconds, passers.startle)
+      jellies.step(seconds, felt())
+      walkers.step(seconds)
+      eels.step(seconds)
+      puffers.step(seconds)
+      reef.step(seconds)
+      nemos.step(seconds)
+      wreckage.step(seconds)
+
+      held += seconds
+      turn = (turn + 1) % 512
+    },
+
+    /**
+     * Carry the whole water forward by a stretch of time, as cheaply as it can
+     * be done.
+     *
+     * Everything that swims has to be swum: where a fish is after a minute is
+     * the minute it spent getting there. The bed is the exception, because a
+     * plant has no memory. The passers are the other exception, and for the
+     * opposite reason: they keep appointments rather than a stopwatch, so
+     * winding them here would spend the day's boat on the two minutes of water
+     * that exist to be skipped.
+     */
+    wind(seconds: number): void {
+      const steps = Math.round(Math.max(0, seconds) / WIND_STEP)
+
+      for (let i = 0; i < steps; i++) {
+        if (eager) passers.step(WIND_STEP)
+        visitors.step(WIND_STEP)
+        flock.step(WIND_STEP, felt())
+        shoal.step(WIND_STEP, null, felt())
+        drift.step(WIND_STEP)
+        light.step(WIND_STEP)
+        clouds.step(WIND_STEP)
+        inklings.step(WIND_STEP, eager ? passers.startle : null)
+        jellies.step(WIND_STEP, felt())
+        walkers.step(WIND_STEP)
+        eels.step(WIND_STEP)
+        puffers.step(WIND_STEP)
+        nemos.step(WIND_STEP)
+        wreckage.step(WIND_STEP)
+      }
+
+      flora.wind(steps * WIND_STEP)
+      reef.wind(steps * WIND_STEP)
+      held += steps * WIND_STEP
+    },
+  }
+}
+
+/**
+ * How far to wind a sea that is opening now, in seconds.
+ *
+ * The wall clock wrapped at `CYCLE`, on top of the settling every scene owes
+ * itself. Nothing is written down and nothing is read back: a clock is a clock
+ * on every machine, so two boxes opening together open on the same moment of
+ * the same water for free, and one opening an hour later does not open on the
+ * same picture.
+ */
+export function opening(settle: number): number {
+  return settle + (Math.floor(Date.now() / 1000) % CYCLE)
+}