// Plotter Tide: a pen plotter drawing a chart coast. The land in the two lower corners is hatched in a rust pen; // the sea is "water-lined" in a slate pen: every tide line is the coast pushed seaward by a gap that is always positive // and grows with distance, so the lines crowd the shore, calm down further out, and never cross. // A pen works through each set line by line; the oldest lines wash away and are drawn again, so the sheet is never finished. // Two stocks: warm paper for a light window, blue-black night paper for a dark one. Pure string building. const WIDTH = 1600 const HEIGHT = 1000 /** The conversation sits between these; no ink goes between them. */ const COLUMN_LEFT = 432 const COLUMN_RIGHT = 1200 interface Stock { paper: string land: string ink: string rust: string } const DAY: Stock = { paper: '#f3eee3', land: '#e8d6bd', ink: '#1f2a48', rust: '#c4552d' } /** The same drawing in pale ink on blue-black paper. */ const NIGHT: Stock = { paper: '#141a27', land: '#1c2333', ink: '#aab6d0', rust: '#e98a5e' } interface Point { x: number y: number } interface Sample { point: Point inked: boolean } /** One piece of land and the sea around it. An islet is a closed ring; a coast is an arc whose centre lies off the sheet. */ interface Coast { seed: number isIslet: boolean centreX: number centreY: number landRadius: number bayDepth: number lineCount: number firstGap: number gapGrowth: number fullUntil: number keepToward: number angleFrom: number angleTo: number hatchLean: number } /** One pen's work. A zero in drawShare, farFrom or coastWidth means "not used". */ interface Job { name: string ink: string width: number opacity: number opacityFade: number cycleSeconds: number cycleStart: number absentShare: number drawShare: number farFrom: number coastWidth: number hidePen: boolean } interface JobMarkup { shapes: string keyframes: string strokes: string farStrokes: string } // The big coast: bottom right, where no panel sits over it. const EAST_COAST: Coast = { seed: 1, isIslet: false, centreX: 1650, centreY: 1050, landRadius: 300, bayDepth: 62, lineCount: 14, firstGap: 11, gapGrowth: 1.062, fullUntil: 0.5, keepToward: 0.7, angleFrom: Math.PI * 0.95, angleTo: Math.PI * 1.55, hatchLean: 1, } // The spit: bottom left, under the quiet lower half of the sidebar. const WEST_SPIT: Coast = { seed: 2, isIslet: false, centreX: -50, centreY: 1070, landRadius: 300, bayDepth: 56, lineCount: 17, firstGap: 11, gapGrowth: 1.058, fullUntil: 0.5, keepToward: 0.3, angleFrom: -Math.PI * 0.58, angleTo: Math.PI * 0.05, hatchLean: 1, } // The islet: small, right of the conversation and below the cards, so the top half of the sheet is not bare. const ISLET: Coast = { seed: 5, isIslet: true, centreX: 1436, centreY: 334, landRadius: 26, bayDepth: 7, lineCount: 5, firstGap: 7.5, gapGrowth: 1.2, fullUntil: 1, keepToward: 0.5, angleFrom: 0, angleTo: Math.PI * 2, hatchLean: 1, } /** A fixed pseudo-random number in 0..1 for a whole number, so every build is the same. */ function hash(number: number): number { const value = Math.sin(number * 127.1 + 311.7) * 43758.5453 return value - Math.floor(value) } function round(value: number): number { return Math.round(value * 10) / 10 } /** The coast's shape in -1..1 at a place `along` the shore (pixels). `calm` 0..1 smooths the small bays out, the way the sea does further from land. */ function bays(along: number, coast: Coast, calm: number): number { // An islet closes on itself, so its bays must fit a whole number of times into one turn. const turn = along / coast.landRadius const wide = coast.isIslet ? Math.sin(turn * 2 + coast.seed) : Math.sin(along / 97 + coast.seed * 1.7) const middle = (coast.isIslet ? Math.sin(turn * 3 + coast.seed * 2) : Math.sin(along / 41 + coast.seed * 3.1)) * (1 - calm) const small = (coast.isIslet ? Math.sin(turn * 5 + coast.seed * 3) : Math.sin(along / 17 + coast.seed * 5.3)) * (1 - calm) * (1 - calm) return (wide + 0.55 * middle + 0.25 * small) / 1.8 } /** Distance from the coast's centre to tide line `line` at `angle`; line 0 is the coast itself. */ function radiusAt(angle: number, line: number, coast: Coast): number { const along = angle * coast.landRadius let radius = coast.landRadius + coast.bayDepth * bays(along, coast, 0) let gap = coast.firstGap for (let step = 1; step <= line; step += 1) { const calm = Math.min(1, step / (coast.lineCount * 0.8)) // Wider gaps in the bays, narrower off the headlands: that is what flattens the lines seaward. Never below 0.64 of the gap, about 7 px at the shore. radius += gap * (1 - 0.36 * bays(along, coast, calm)) gap *= coast.gapGrowth } return radius } function pointAt(angle: number, line: number, coast: Coast): Point { const radius = radiusAt(angle, line, coast) return { x: coast.centreX + radius * Math.cos(angle), y: coast.centreY + radius * Math.sin(angle) } } function isOnSheet(point: Point): boolean { return point.x > -30 && point.x < WIDTH + 30 && point.y > -30 && point.y < HEIGHT + 30 } /** Outside the reading column; each line stops a different distance short of it, so the ends do not make a wall. */ function isOutsideColumn(point: Point, line: number, coast: Coast): boolean { const shy = 80 * hash(line * 17 + coast.seed * 7) return point.x < COLUMN_LEFT - shy || point.x > COLUMN_RIGHT + shy } function isOnLand(point: Point, coast: Coast): boolean { const dx = point.x - coast.centreX const dy = point.y - coast.centreY // atan2 answers in -pi..pi; the coast's own angles may lie a whole turn above that. let angle = Math.atan2(dy, dx) if (!coast.isIslet && angle < coast.angleFrom - 0.5) angle += Math.PI * 2 return Math.hypot(dx, dy) < radiusAt(angle, 0, coast) - 5 } function midway(first: Point, second: Point): string { return `${round((first.x + second.x) / 2)} ${round((first.y + second.y) / 2)}` } /** A smooth open path through the midpoints of the samples: one point per segment, so the string stays short. */ function smoothPath(points: Point[]): string { const first = points[0] const second = points[1] const third = points[2] const last = points[points.length - 1] if (points.length < 4 || !first || !second || !third || !last) return '' let path = `M${round(first.x)} ${round(first.y)}Q${round(second.x)} ${round(second.y)} ${midway(second, third)}` for (let index = 2; index < points.length - 1; index += 1) { const here = points[index] const next = points[index + 1] if (here && next) path += `T${midway(here, next)}` } return `${path}T${round(last.x)} ${round(last.y)}` } /** The same for a closed ring. */ function smoothRing(points: Point[]): string { const count = points.length const closing = points[count - 1] let path = '' for (let index = 0; index < count; index += 1) { const here = points[index] const next = points[(index + 1) % count] if (!here || !next || !closing) continue if (index === 0) path = `M${midway(closing, here)}Q${round(here.x)} ${round(here.y)} ${midway(here, next)}` else path += `T${midway(here, next)}` } return `${path}Z` } /** The longest unbroken run of samples that may be inked. */ function longestRun(samples: Sample[]): Point[] { let best: Point[] = [] let run: Point[] = [] for (const sample of samples) { if (sample.inked) run.push(sample.point) else { if (run.length > best.length) best = run run = [] } } return run.length > best.length ? run : best } /** The coast and its tide lines, path strings, shore first. The outer lines are shorter pieces. */ function tideLines(coast: Coast): string[] { const paths: string[] = [] for (let line = 0; line <= coast.lineCount; line += 1) { const stepAngle = 16 / radiusAt((coast.angleFrom + coast.angleTo) / 2, line, coast) const samples: Sample[] = [] for (let angle = coast.angleFrom; angle <= coast.angleTo; angle += stepAngle) { const point = pointAt(angle, line, coast) samples.push({ point, inked: isOnSheet(point) && isOutsideColumn(point, line, coast) }) } const points = longestRun(samples) const share = line / coast.lineCount const fade = Math.max(0, (share - coast.fullUntil) / (1 - coast.fullUntil)) const keep = Math.max(4, Math.floor(points.length * (1 - fade * (0.35 + 0.3 * hash(line + coast.seed * 31))))) const slack = Math.max(points.length - keep, 0) const start = Math.min(Math.max(Math.floor(slack * (coast.keepToward + (hash(line * 11 + coast.seed) - 0.5) * 0.4)), 0), slack) const kept = points.slice(start, start + keep) // The pen goes out along one line and comes back along the next, the way a plotter does. if (line % 2 === 1) kept.reverse() const path = smoothPath(kept) if (path) paths.push(path) } return paths } /** An islet's shore and tide lines: closed rings, shore first. */ function isletRings(coast: Coast): string[] { const paths: string[] = [] for (let line = 0; line <= coast.lineCount; line += 1) { const count = Math.max(12, Math.round((radiusAt(0, line, coast) * 6.3) / 14)) const points: Point[] = [] for (let index = 0; index < count; index += 1) points.push(pointAt((index / count) * Math.PI * 2 + line * 0.9, line, coast)) paths.push(smoothRing(points)) } return paths } /** The land, one filled shape under the hatching: the coast, closed through its centre, which lies off the sheet. */ function landShape(coast: Coast, colour: string): string { let path = '' for (let angle = coast.angleFrom; angle <= coast.angleTo; angle += 0.04) { const point = pointAt(angle, 0, coast) path += `${path ? 'L' : 'M'}${round(point.x)} ${round(point.y)}` } if (!coast.isIslet) path += `L${coast.centreX} ${coast.centreY}` return `` } /** Straight hatch strokes across the land, path strings in the order a pen would take them. */ function landHatch(coast: Coast): string[] { const paths: string[] = [] const spacing = 15 let stroke = 0 for (let offset = -HEIGHT; offset < WIDTH + HEIGHT; offset += spacing) { // One hatch line runs down-left from (offset, 0); walk it and keep the piece that lies on the land. let first: Point | null = null let last: Point | null = null for (let step = 0; step < HEIGHT + 60; step += 4) { const point = { x: offset - step * coast.hatchLean, y: step } if (isOnSheet(point) && isOnLand(point, coast)) { if (!first) first = point last = point } else if (first) break } if (!first || !last || Math.hypot(last.x - first.x, last.y - first.y) < 14) continue const from = stroke % 2 === 0 ? first : last const to = stroke % 2 === 0 ? last : first paths.push(`M${round(from.x)} ${round(from.y)}L${round(to.x)} ${round(to.y)}`) stroke += 1 } return paths } /** One pen's job: the paths drawn strictly one after another on a shared cycle, each washed away again before its next turn. * Returns the shapes for , the job's own keyframes, and the strokes (the far tide lines apart, so they can ride the tide further). */ function penJob(paths: string[], job: Job): JobMarkup { let shapes = '' let strokes = '' let farStrokes = '' let heads = '' let farHeads = '' const stepSeconds = job.cycleSeconds / paths.length // Normally a stroke takes exactly its turn; a job may ask for a shorter stroke, so its lines are rarely caught half made. const drawnAt = job.drawShare > 0 ? job.drawShare : round(100 / paths.length) const restUntil = 100 - job.absentShare - drawnAt for (let line = 0; line < paths.length; line += 1) { const id = `${job.name}${line}` // Line k starts one step after line k - 1, so it is one step less far into its cycle. const phase = (((job.cycleStart - line * stepSeconds) % job.cycleSeconds) + job.cycleSeconds) % job.cycleSeconds const timing = `style="animation-delay:${round(-phase)}s"` const opacity = round((job.opacity - job.opacityFade * (line / paths.length)) * 100) / 100 shapes += `` // The first path of a land job is the coast itself: a firmer line than the hatching. const firm = line === 0 && job.coastWidth > 0 ? ` stroke-width="${job.coastWidth}" stroke-opacity="0.9"` : ` stroke-opacity="${opacity}"` const isFar = job.farFrom > 0 && line >= job.farFrom if (isFar) farStrokes += `` else strokes += `` if (!job.hidePen && isFar) farHeads += `` else if (!job.hidePen) heads += `` } const keyframes = ` .${job.name} .ink{animation:ink-${job.name} ${job.cycleSeconds}s linear infinite}.${job.name} .pen{animation:pen-${job.name} ${job.cycleSeconds}s linear infinite} @keyframes ink-${job.name}{0%{stroke-dashoffset:1.01;opacity:1}${drawnAt}%{stroke-dashoffset:0;opacity:1}${round(drawnAt * 2.5)}%{stroke-dashoffset:0;opacity:.74}${restUntil}%{stroke-dashoffset:0;opacity:.74}${restUntil + drawnAt}%{stroke-dashoffset:-1.01}100%{stroke-dashoffset:-1.01;opacity:.74}} @keyframes pen-${job.name}{0%{stroke-dashoffset:0;opacity:1}${drawnAt}%{stroke-dashoffset:-1;opacity:1}${drawnAt + 0.01}%{stroke-dashoffset:-1;opacity:0}100%{stroke-dashoffset:-1;opacity:0}}` const near = `${strokes}${heads}` const far = `${farStrokes}${farHeads}` return { shapes, keyframes, strokes: near, farStrokes: far } } /** The whole sheet on one stock. */ function plotterTideSheet(stock: Stock): string { const eastSea = penJob(tideLines(EAST_COAST).slice(1), { name: 'e', ink: stock.ink, width: 1.15, opacity: 1, opacityFade: 0.4, cycleSeconds: 136, cycleStart: 30, absentShare: 20, drawShare: 0, farFrom: 7, coastWidth: 0, hidePen: false }) const westSea = penJob(tideLines(WEST_SPIT).slice(1), { name: 'w', ink: stock.ink, width: 1.15, opacity: 1, opacityFade: 0.4, cycleSeconds: 126, cycleStart: 75, absentShare: 20, drawShare: 0, farFrom: 8, coastWidth: 0, hidePen: false }) const isletSea = penJob(isletRings(ISLET).slice(1), { name: 'i', ink: stock.ink, width: 1.1, opacity: 0.8, opacityFade: 0.3, cycleSeconds: 150, cycleStart: 40, absentShare: 14, drawShare: 5, farFrom: 0, coastWidth: 0, hidePen: true }) const eastLand = penJob(tideLines(EAST_COAST).slice(0, 1).concat(landHatch(EAST_COAST)), { name: 'f', ink: stock.rust, width: 1, opacity: 0.8, opacityFade: 0, cycleSeconds: 118, cycleStart: 60, absentShare: 4, drawShare: 0, farFrom: 0, coastWidth: 1.3, hidePen: false }) const westLand = penJob(tideLines(WEST_SPIT).slice(0, 1).concat(landHatch(WEST_SPIT)), { name: 'g', ink: stock.rust, width: 1, opacity: 0.8, opacityFade: 0, cycleSeconds: 104, cycleStart: 20, absentShare: 4, drawShare: 0, farFrom: 0, coastWidth: 1.3, hidePen: false }) const isletLand = penJob(isletRings(ISLET).slice(0, 1), { name: 'j', ink: stock.rust, width: 1, opacity: 0.8, opacityFade: 0, cycleSeconds: 140, cycleStart: 9, absentShare: 6, drawShare: 6, farFrom: 0, coastWidth: 1.3, hidePen: true }) const jobs = [eastSea, westSea, isletSea, eastLand, westLand, isletLand] const style = ` path{fill:none;stroke-linecap:round;stroke-linejoin:round} .ink{stroke-dasharray:1 2} .pen{stroke-dasharray:.0001 3;stroke-width:8;opacity:0} .tide{animation:tide 70s ease-in-out infinite alternate}${jobs.map(job => job.keyframes).join('')} @keyframes tide{from{transform:translate(0,0)}to{transform:var(--move)}} @media (prefers-reduced-motion: reduce){*{animation:none!important}}` return `${jobs.map(job => job.shapes).join('')} ${landShape(EAST_COAST, stock.land)}${landShape(WEST_SPIT, stock.land)}${landShape(ISLET, stock.land)} ${eastSea.strokes}${eastSea.farStrokes} ${westSea.strokes}${westSea.farStrokes} ${isletSea.strokes} ${eastLand.strokes}${westLand.strokes}${isletLand.strokes} ` } /** Plotter Tide on warm paper, for a light window (scene.svg). */ export function plotterTideSvg(): string { return plotterTideSheet(DAY) } /** Plotter Tide on blue-black night paper, for a dark window (scene-night.svg). */ export function plotterTideNightSvg(): string { return plotterTideSheet(NIGHT) }