@codincod/ornament 0.0.0-stage → 0.2.0

package/src/paint/life.ts

@@ -0,0 +1,611 @@
+/**
+ * Everything alive, and everything going over the top of it.
+ *
+ * The shoal, the clownfish in their anemones, the bait ball, the big animals
+ * that cross once in a while, the cephalopods, what walks on the bottom, and
+ * the boats. All of it is the ornament's own simulation; what is here is what
+ * `Seascape.qml` decides, which is how heavy each of them is drawn and how far
+ * back it stands.
+ */
+import type { Cephalopods } from "../cephalopods.ts"
+import { octopusArms, octopusHead, squidArms, squidBody } from "../cephalopods.ts"
+import type { Eels } from "../eels.ts"
+import { frameAt, SPAN } from "../fish_shape.ts"
+import {
+  armsOf,
+  bell,
+  combRows,
+  HAIR_GIRTH,
+  hairOf,
+  ARM_GIRTH as JELLY_ARM,
+  type Jellies,
+  moonMarks,
+  sparks,
+  washOf,
+} from "../jellies.ts"
+import type { Nemos } from "../nemos.ts"
+import { HULL, type Passers, PING_RINGS, ringAt, SCREWS, SUB_SCREW, SUBMARINE } from "../passers.ts"
+import type { Puffers } from "../puffers.ts"
+import { type Shoal, SPECIES } from "../shoal.ts"
+import type { Swarm } from "../swarm.ts"
+import { BODIES, VEIL_INK, VEILS, type Visitors } from "../visitors.ts"
+import type { Walkers } from "../walkers.ts"
+import { disc, ring } from "./light.ts"
+import { OWN, type Pen, TONE } from "./pen.ts"
+import { trace } from "./trace.ts"
+
+/** How dark an animal in the open water may be, and how much of that weight it
+ *  keeps at the back of it. */
+const OPEN_WATER = 0.22
+const DEPTH_INK = 0.65
+
+/**
+ * How much further back a veil stands than the animal wearing it.
+ *
+ * Enough for the depth buffer to settle it and not enough to be a distance. The
+ * solid pass takes its turn by how far back a thing stands rather than by the
+ * order it arrived in, so two drawings at one depth is two drawings fighting
+ * over the same pixels.
+ */
+const BEHIND = 0.002
+
+/** The rest of the ceilings, each one thing's share of full ink. */
+const CRAWLER_INK = 0.42
+const CRAWLER_LIFT = 0.8
+const CRAWLER_RISEN = 0.62
+const EEL_INK = 0.46
+const PUFFER_INK = 0.44
+const FROTH_INK = 0.3
+const FROTH_LET_GO = 0.45
+const HAZE_INK = 0.04
+const HULL_INK = 0.16
+const JELLY_INK = 0.17
+
+/**
+ * How much of a jellyfish's own light there is, and how much of it survives a
+ * sunlit afternoon.
+ *
+ * Almost none. A flash is measured against the water around it, so a display
+ * that reads across a whole screen at midnight is nothing at all at noon, and
+ * the animal has not changed: the water it is being seen against has. What is
+ * kept in daylight is a hint, because a jellyfish that went perfectly dark at
+ * dawn would be an animal switching off on a schedule.
+ */
+const JELLY_LIGHT = 0.62
+const JELLY_DAY = 0.12
+
+/**
+ * And how much of the light a comb jelly does not make.
+ *
+ * The rows are a diffraction grating, so what runs along them is the water's
+ * own light taken apart, and the rule runs the other way: it is at its best in
+ * the sun and there is nothing to take apart at midnight. Two lights on two
+ * animals swimming past each other, one needing the day and one needing the
+ * dark, which is the sort of thing this water is for.
+ */
+const JELLY_SHEEN = 0.5
+const JELLY_NIGHT = 0.15
+const PING_INK = 0.62
+const SPECK_INK = 0.16
+const VISITOR_INK = 0.42
+
+/** How much of a weight is punched back out again for an eye or a cut line. */
+const CUT_SHADE = 0.34
+
+/** What the bodies are drawn as lines at, in their own units. */
+const ARM_GIRTH = 0.075
+const TENTACLE_GIRTH = 0.035
+
+/**
+ * How thick an eel is drawn, against how tall it stands.
+ *
+ * Thin, and the roundness of the cap does the rest. What a colony reads as at
+ * this distance is a texture with a grain to it, and the grain is the gaps: a
+ * girth that closed them would draw a patch of grass.
+ */
+const EEL_GIRTH = 0.12
+
+/** How big an eye is against the body it is in. */
+const EYE_SIZE = 0.11
+
+/** How many of each are ever drawn at once. */
+const MOST = { froth: 220, passers: 4, specks: 3000, visitors: 6 }
+
+/** Where the boats sit, which is over everything in the water. */
+const LANE = { froth: 1.15, passer: 1.2 }
+
+/**
+ * What a weight is worth at a distance, for anything in the open water.
+ *
+ * It keeps a share of its weight whatever the distance, because an animal that
+ * faded into the murk as far as the ground does is an animal the eye loses in
+ * the middle of a stroke.
+ */
+function afloat(full: number, depth: number): number {
+  return full * (1 - DEPTH_INK + DEPTH_INK * depth)
+}
+
+/** And what it is worth for anything standing on the bottom, which does fade
+ *  the whole way: the murk it is seen through is the ground's. */
+function far(full: number, depth: number): number {
+  return HAZE_INK + (full - HAZE_INK) * Math.min(1, Math.max(0, depth))
+}
+
+export function paintShoal(pen: Pen, shoal: Shoal): void {
+  for (const fish of shoal.fish) {
+    const weight = afloat(OPEN_WATER, fish.depth)
+    if (weight <= 0.002) continue
+
+    const frame = frameAt(fish.tail)
+    const spot = {
+      facing: fish.facing,
+      scale: fish.size / SPAN,
+      tilt: fish.tilt,
+      x: fish.x,
+      y: fish.y,
+    }
+
+    // The billed kinds are a whole drawing of their own rather than this one
+    // with a bill laid over it. Two fills would put a seam across the
+    // swordfish's face wherever the bill's buried root crossed the head.
+    pen.fill(
+      trace(SPECIES[fish.kind].bill > 0 ? frame.billed : frame.d),
+      {
+        lane: fish.depth,
+        shade: fish.y,
+        weight,
+      },
+      spot,
+    )
+
+    // The eye is punched out in the surface behind it rather than drawn in an
+    // ink of its own, which is why a fish reads as a cutout in the water
+    // instead of a sticker on it.
+    pen.fill(
+      [disc(frame.eye.x, frame.eye.y, frame.eye.r)],
+      {
+        lane: fish.depth,
+        shade: fish.y,
+        weight: weight * CUT_SHADE,
+      },
+      spot,
+    )
+  }
+}
+
+/**
+ * The clownfish, each in the anemone it lives in.
+ *
+ * `face` is the drawn width and its sign is the mirror, so the fish squeezes to
+ * nothing and opens out the other way, which is what a fish that has stopped
+ * actually does. A fish all the way into the tentacles is not drawn at all
+ * rather than drawn faintly: it has not become hard to see, it is behind
+ * something.
+ */
+export function paintNemos(pen: Pen, nemos: Nemos): void {
+  for (const nemo of nemos.nemos) {
+    const weight = afloat(OPEN_WATER, nemo.host.depth) * (1 - nemo.cover)
+    if (weight <= 0.002) continue
+
+    pen.fill(
+      trace(frameAt(nemo.beat).d),
+      {
+        lane: -3 + nemo.host.depth,
+        shade: nemo.y,
+        weight,
+      },
+      {
+        facing: nemo.face,
+        scale: nemo.length / SPAN,
+        tilt: nemo.tilt,
+        x: nemo.x,
+        y: nemo.y,
+      },
+    )
+  }
+}
+
+/**
+ * A flock of thousands, which is a few hundred specks and a shape round them.
+ *
+ * Marks rather than fish. At the size one of these is on the screen a fish
+ * drawing is four pixels of nothing, and what makes a bait ball read is that it
+ * is a crowd with a body: hundreds of identical small marks, packed, all
+ * leaning the same way and all leaning a little differently.
+ */
+export function paintSwarm(pen: Pen, flock: Swarm): void {
+  let drawn = 0
+  for (const speck of flock.specks) {
+    if (drawn++ >= MOST.specks) break
+
+    const weight = afloat(SPECK_INK, speck.depth) * flock.weight
+    if (weight <= 0.002) continue
+
+    const girth = Math.max(0.7, speck.size * 0.42)
+    pen.line(
+      [
+        [
+          { x: -speck.size / 2, y: 0 },
+          { x: speck.size / 2, y: 0 },
+        ],
+      ],
+      {
+        lane: speck.depth,
+        shade: speck.y,
+        weight,
+        width: girth,
+      },
+      { tilt: speck.tilt, x: speck.x, y: speck.y },
+    )
+  }
+}
+
+/**
+ * The big animals: a turtle, a pod of dolphins, a manta, a shark going
+ * somewhere, and once in a very long while a thing that is none of those.
+ * Heavier than a fish, because what is being read across the whole picture is
+ * the shape, and a shape drawn at the shoal's weight is a smudge.
+ *
+ * One of them is not all body, and `VEILS` in the ornament says which and why.
+ * What it hands over is laid in first and a hair behind, so the animal's own
+ * outline takes the depth where the two overlap and only what is streaming
+ * clear of it is drawn sheer. Both or neither: a visitor drawn without the veil
+ * it declares is missing a part of itself rather than drawn more simply.
+ */
+export function paintVisitors(pen: Pen, visitors: Visitors): void {
+  let drawn = 0
+  for (const guest of visitors.crossing) {
+    if (drawn++ >= MOST.visitors) break
+
+    const weight = afloat(VISITOR_INK * guest.weight, guest.depth)
+    if (weight <= 0.002) continue
+
+    const spot = {
+      facing: guest.facing,
+      scale: guest.size,
+      tilt: guest.tilt,
+      x: guest.x,
+      y: guest.y,
+    }
+
+    const veil = VEILS[guest.kind]?.(guest.stroke)
+    if (veil) {
+      pen.fill(
+        trace(veil),
+        {
+          lane: guest.depth - BEHIND,
+          shade: guest.y,
+          weight: weight * VEIL_INK,
+        },
+        spot,
+      )
+    }
+
+    pen.fill(
+      trace(BODIES[guest.kind](guest.stroke)),
+      {
+        lane: guest.depth,
+        shade: guest.y,
+        weight,
+      },
+      spot,
+    )
+  }
+}
+
+/**
+ * Squid and octopus.
+ *
+ * A squid jets and drifts, which is the opposite rhythm to a tail. An octopus
+ * is on the bottom rather than in the water, except for the once in a long
+ * while when one lets go, so it recedes the way the bottom does and it runs
+ * between two weights by how far off the floor it is.
+ */
+export function paintInklings(pen: Pen, inklings: Cephalopods): void {
+  for (const squid of inklings.squids) {
+    const weight = afloat(OPEN_WATER, squid.depth)
+    if (weight <= 0.002) continue
+
+    const spot = {
+      facing: squid.facing,
+      scale: squid.size,
+      tilt: squid.tilt,
+      x: squid.x,
+      y: squid.y,
+    }
+    const mark = { lane: squid.depth, shade: squid.y, weight }
+
+    pen.fill(trace(squidBody(squid.squeeze)), mark, spot)
+    pen.line(squidArms(squid.squeeze), { ...mark, width: TENTACLE_GIRTH * squid.size }, spot)
+  }
+
+  for (const octopus of inklings.octopuses) {
+    const aloft = Math.max(-1, Math.min(1, octopus.lift / CRAWLER_LIFT))
+    const bedded = far(CRAWLER_INK, octopus.depth)
+    const risen = far(CRAWLER_RISEN, octopus.depth)
+
+    // Under the sand is under the haze. A buried one is not a faint animal, it
+    // is a bump in the ground with an animal somewhere inside it.
+    const weight = aloft < 0 ? bedded * (1 + aloft * 0.7) : bedded + (risen - bedded) * aloft
+    if (weight <= 0.002) continue
+
+    const spot = { scale: octopus.size, x: octopus.x, y: octopus.y }
+    const mark = { lane: octopus.depth, shade: octopus.y, weight }
+
+    pen.fill(trace(octopusHead(octopus.breath)), mark, spot)
+    pen.line(octopusArms(octopus), { ...mark, width: ARM_GIRTH * octopus.size }, spot)
+  }
+}
+
+/**
+ * The jellyfish, all seven, and one of them is a float and two are not
+ * jellyfish at all.
+ *
+ * Three of the eight make their own light, and none of it is on until
+ * something touches them. It is drawn in the moon's colour, since this palette
+ * has no blue in it and nothing else in the water glows at all, and it is
+ * weighed against the hour: a flash is measured against the water around it,
+ * so these are a night thing. The comb jelly's rows are the exception that
+ * proves the rule, and they run the other way; see the note on `JELLY_SHEEN`.
+ *
+ * Lighter than anything else in the water on purpose. A bell is a bag of water
+ * inside water: it stops a little of the light and passes the rest, and drawn
+ * at a fish's weight it comes out as a cut-out mushroom. What hangs under one
+ * is lighter again, at the share `visitors.ts` settled on for a mermaid's
+ * hair, and for the reason it gives there: a fine mass scatters light where a
+ * body stops it.
+ *
+ * The order is the animal's own. Whatever hangs goes in first and a hair
+ * further back, so the bell takes the depth where the two overlap and only
+ * what is streaming clear of it is drawn sheer. Then the marks, punched out of
+ * the bell the way a fish's eye is punched out of its head, and last the two
+ * kinds that carry a light of their own.
+ */
+export function paintJellies(pen: Pen, jellies: Jellies, daylight: number): void {
+  const hour = Math.min(1, Math.max(0, daylight))
+  // What a made light is worth at this hour, and what a borrowed one is.
+  const dark = JELLY_DAY + (1 - JELLY_DAY) * (1 - hour)
+  const sun = JELLY_NIGHT + (1 - JELLY_NIGHT) * hour
+
+  for (const one of jellies.jellies) {
+    const weight = afloat(JELLY_INK, one.depth)
+    if (weight <= 0.002) continue
+
+    const spot = {
+      facing: one.facing,
+      scale: one.size,
+      tilt: one.tilt,
+      x: one.x,
+      y: one.y,
+    }
+    const mark = { lane: one.depth, shade: one.y, weight }
+    const behind = { ...mark, lane: one.depth - BEHIND }
+
+    const hair = hairOf(one)
+    if (hair.length > 0) {
+      pen.line(
+        hair,
+        {
+          ...behind,
+          weight: weight * VEIL_INK,
+          width: Math.max(0.6, HAIR_GIRTH[one.kind] * one.size),
+        },
+        spot,
+      )
+    }
+
+    const arms = armsOf(one)
+    if (arms.length > 0) {
+      pen.line(arms, { ...behind, width: JELLY_ARM[one.kind] * one.size }, spot)
+    }
+
+    pen.fill(trace(bell(one.kind, one.squeeze)), mark, spot)
+
+    // The four horseshoes, which are the reason a moon jelly is the jellyfish
+    // everybody can name. Punched back out of the bell rather than drawn over
+    // it, so they read as the animal being see-through.
+    if (one.kind === "moon") {
+      pen.line(
+        moonMarks(one.squeeze),
+        {
+          ...mark,
+          weight: weight * CUT_SHADE,
+          width: Math.max(0.8, 0.03 * one.size),
+        },
+        spot,
+      )
+    }
+
+    // The comb rows carry both kinds of light and they carry them on one set
+    // of lines: the wave the grating takes out of the water, which wants the
+    // sun, and the animal's own flash along the same eight canals, which wants
+    // the dark. One drawing, two sources, and the reader can tell them apart
+    // because only one of them moves.
+    for (const row of combRows(one)) {
+      const alpha = JELLY_SHEEN * row.glow * sun + JELLY_LIGHT * one.glow * dark
+      if (alpha <= 0.01) continue
+
+      pen.line(
+        [row.points],
+        {
+          alpha,
+          lane: one.depth,
+          shade: OWN,
+          tone: TONE.moon,
+          width: Math.max(0.8, 0.05 * one.size),
+        },
+        spot,
+      )
+    }
+
+    // A whole animal alight, bell, arms and tentacles at once, which is what
+    // most of the sea's bioluminescence looks like and is why the reach here
+    // goes well past the margin.
+    const wash = washOf(one)
+    if (wash) {
+      pen.light(one.x, one.y, {
+        alpha: JELLY_LIGHT * wash.glow * dark,
+        fall: 2.2,
+        lane: one.depth,
+        shade: OWN,
+        tone: TONE.moon,
+        width: wash.reach,
+      })
+    }
+
+    for (const flare of sparks(one)) {
+      // A light is a middle and a reach, so it cannot be handed a spot and has
+      // to be stood in the water here. Mirrored and then turned, in that
+      // order, which is the order `Spot` says and the order everything in this
+      // scene has got wrong at least once.
+      const across = flare.x * one.size * one.facing
+      const down = flare.y * one.size
+      const cos = Math.cos(one.tilt)
+      const sin = Math.sin(one.tilt)
+
+      pen.light(one.x + across * cos - down * sin, one.y + across * sin + down * cos, {
+        alpha: JELLY_LIGHT * flare.glow * dark,
+        fall: 1.6,
+        lane: one.depth,
+        shade: OWN,
+        tone: TONE.moon,
+        width: one.size * 0.34,
+      })
+    }
+  }
+}
+
+/**
+ * Crabs and starfish, which is everything down there that has legs and never
+ * uses them to leave.
+ *
+ * The legs first and the body over them, so a claw folded across the shell
+ * reads as a claw in front of a shell rather than a crack in it.
+ */
+/**
+ * The colony, standing out of the sand.
+ *
+ * A line each, and nothing else. The head is the round cap on the far end of
+ * it, which costs nothing and is what a garden eel actually looks like from any
+ * distance a reader is at: a stalk with a knot on the end.
+ *
+ * One drawing an animal rather than one for the bed, because the whole of the
+ * thing is that they are not doing the same thing at the same moment. A colony
+ * drawn as one shape could not have a wave cross it.
+ */
+export function paintEels(pen: Pen, eels: Eels): void {
+  for (const one of eels.eels) {
+    if (one.body.length < 2) continue
+
+    const weight = far(EEL_INK, one.depth)
+    if (weight <= 0.002) continue
+
+    pen.line([one.body], {
+      lane: one.depth,
+      shade: one.y,
+      weight,
+      width: Math.max(1, EEL_GIRTH * one.size * one.girth),
+    })
+  }
+}
+
+/**
+ * The one that stays.
+ *
+ * Drawn in the order it would be seen: the spines stand off the body, so they
+ * go under it and the body covers their roots. The eye is punched back out of
+ * the body at a lighter weight, which is the same trick every other face in
+ * this water is drawn with.
+ */
+export function paintPuffers(pen: Pen, puffers: Puffers): void {
+  for (const one of puffers.puffers) {
+    if (one.body.length < 3) continue
+
+    const weight = far(PUFFER_INK, one.depth)
+    if (weight <= 0.002) continue
+
+    const mark = { lane: one.depth, shade: one.y, weight }
+
+    if (one.spines.length > 0) pen.fill(one.spines, mark)
+    pen.fill([one.body], mark)
+    pen.fill([disc(one.eye.x, one.eye.y, one.size * EYE_SIZE)], {
+      ...mark,
+      weight: weight * CUT_SHADE,
+    })
+  }
+}
+
+export function paintWalkers(pen: Pen, walkers: Walkers): void {
+  for (const one of walkers.walkers) {
+    const weight = far(CRAWLER_INK, one.depth)
+    if (weight <= 0.002) continue
+
+    const spot = { facing: one.facing, scale: one.size, x: one.x, y: one.y }
+    const mark = { lane: one.depth, shade: one.y, weight }
+
+    pen.line(one.legs, { ...mark, width: ARM_GIRTH * one.size }, spot)
+    pen.fill(trace(one.body), mark, spot)
+  }
+}
+
+/**
+ * What goes past overhead, and what is looking for you.
+ *
+ * Minutes apart rather than seconds, and most sittings will hold neither: a
+ * scene you can watch the whole vocabulary of in a minute is wallpaper.
+ */
+export function paintPassers(pen: Pen, passers: Passers): void {
+  let drawn = 0
+  for (const one of passers.passing) {
+    if (drawn++ >= MOST.passers) break
+
+    const weight = HULL_INK * one.weight
+    const spot = { facing: one.facing, scale: one.scale, x: one.x, y: one.y }
+    const mark = { lane: LANE.passer, shade: one.y, weight }
+
+    if (one.kind === "boat") {
+      pen.fill(trace(HULL), mark, spot)
+      pen.fill(trace(SCREWS), mark, spot)
+    }
+
+    if (one.kind === "submarine") {
+      pen.fill(trace(SUBMARINE), mark, spot)
+      pen.fill(trace(SUB_SCREW), mark, spot)
+    }
+
+    // Sonar: three rings, staggered, going out and losing themselves in the
+    // water. One ring would be a bubble.
+    if (one.kind === "sonar") {
+      for (const stagger of PING_RINGS) {
+        const at = ringAt(one.along, stagger)
+        if (!at) continue
+
+        pen.line([ring(one.x, one.y, at.reach * one.scale)], {
+          alpha: PING_INK * at.weight * one.weight,
+          lane: LANE.passer,
+          shade: OWN,
+          tone: TONE.ink,
+          // Thick where it leaves and a hairline by the time it is spent. A
+          // front carries what it was sent with, spread over a circle that
+          // keeps growing.
+          width: Math.max(1, Math.round(4 * at.weight)),
+        })
+      }
+    }
+  }
+
+  // The churn a hull leaves: white water, filled rather than outlined, so
+  // overlapping puffs merge into one patch instead of piling their alphas into
+  // a bright knot wherever three of them meet.
+  let churned = 0
+  for (const puff of passers.wake) {
+    if (churned++ >= MOST.froth) break
+
+    pen.fill([disc(puff.x, puff.y, puff.r)], {
+      alpha: Math.min(1, (1 - puff.age) / FROTH_LET_GO),
+      lane: LANE.froth,
+      shade: puff.y,
+      weight: FROTH_INK * (1 - puff.age),
+    })
+  }
+}