Tilting

// #73 かたむく / Tilting
//
// Messages leave the left edge for the right edge. Three fates, decided at birth:
// they arrive and leave the picture, or they die somewhere on the way, or they
// never depart at all. The two failures deposit an identical mark where they died.
// Nothing about the mark says which kind it was — only where it happened.
//
// Then the whole world is compressed toward the receiving edge, which is the same
// thing as moving the eye onto the axis of travel. At the end there is no channel,
// only the edge.

const SIZE = 720;
const MARGIN = 60;
const ORIGIN_X = MARGIN;
const RECV_X = SIZE - MARGIN;
const SPAN = RECV_X - ORIGIN_X;

const EMIT_PER_FRAME = 3;
const SPEED = 2.4;

const P_ARRIVE = 0.55;
const P_DROP = 0.225;   // the remaining 0.225 never departs

const COMPRESS_END = 1800;
const DOT = 2.2;

export default function sketch(p) {
  let live = [];
  let dead = [];        // {x, y, kind}  kind: 0 = dropped, 1 = never sent
  let f = 0;

  const reseed = () => {
    const d = new Date();
    const seed = d.getFullYear() * 10000 + (d.getMonth() + 1) * 100 + d.getDate();
    p.noiseSeed(seed);
    p.randomSeed(seed);
  };

  // t = how far the world has been folded onto the receiving edge. 0 -> 1.
  const fold = () => p.constrain(f / COMPRESS_END, 0, 1);

  // the only transform in the piece. ratios are preserved by it; nothing is lost here.
  const mapX = (x, t) => x + (RECV_X - x) * t;

  const spawn = () => {
    const r = p.random();
    const y = p.random(MARGIN, SIZE - MARGIN);
    if (r < P_ARRIVE) {
      live.push({ x: ORIGIN_X, y, endX: RECV_X, kind: -1 });
    } else if (r < P_ARRIVE + P_DROP) {
      live.push({ x: ORIGIN_X, y, endX: p.random(ORIGIN_X, RECV_X), kind: 0 });
    } else {
      // never departs. it dies where it was made, on the frame it was made.
      dead.push({ x: ORIGIN_X, y, kind: 1 });
    }
  };

  p.setup = () => {
    p.createCanvas(SIZE, SIZE);
    reseed();
    p.background(11);
  };

  p.draw = () => {
    const t = fold();
    p.background(11, 255);

    for (let i = 0; i < EMIT_PER_FRAME; i++) spawn();

    // advance
    const still = [];
    for (const m of live) {
      m.x += SPEED;
      if (m.x >= m.endX) {
        if (m.kind === 0) dead.push({ x: m.endX, y: m.y, kind: 0 });
        // arrivals leave the picture and deposit nothing.
      } else {
        still.push(m);
      }
    }
    live = still;

    // what did not arrive. both kinds drawn identically.
    p.noStroke();
    p.fill(236, 232, 226, 150);
    for (const d of dead) p.circle(mapX(d.x, t), d.y, DOT);

    // what is still travelling
    p.fill(236, 232, 226, 46);
    for (const m of live) p.circle(mapX(m.x, t), m.y, DOT * 0.8);

    // the receiving edge
    p.stroke(236, 232, 226, 30);
    p.strokeWeight(1);
    p.line(RECV_X, MARGIN * 0.5, RECV_X, SIZE - MARGIN * 0.5);

    f++;
  };
}