Open a blank grid. Paint some walls. Drop one green cell and call it the exit. Now press play: a number floods outward from that green cell — 0 at the door, 1 in every neighbour, 2 in theirs, climbing until the whole floorplate is labelled with steps to safety. Drop fifty dots anywhere on the grid and give each the same dumb instruction: look at your neighbours, step to the smallest number. They evacuate. No dot knows where the exit is. The floor knows.

That number carpet is a distance field — a flow field once you store the downhill direction in each cell — and it is the whole trick behind crowd egress in games, and quietly, behind the fire strategy your building already leans on.

The naive way is A* per agent: every runner solving its own shortest path, which melts the instant you have a thousand of them. The distance field inverts the cost — you pay once to flood the grid from the destination, then a crowd of any size reads the local gradient for free. Elijah Emerson’s flow-field system in Supreme Commander 2 (2010) shipped exactly this to move armies; the deeper mathematics is James Sethian’s Fast Marching Method (1996), which solves the eikonal equation for a smooth arrival-time field instead of blocky integer steps. Craig Reynolds’ boids (1987) supply the last ten percent: local separation so the dots don’t stack into one screaming column at the door.

←TODAY: In 2026 a distance field over a 100×100 grid floods in under a millisecond — an egress diagram you can recompute every time you nudge a wall. →3012: The Zurich-3012 floorplate carries its evacuation field as live metadata; move a partition and the exits re-rank themselves. Fulcrum: An exit is not a door on a plan — it is the lowest number in a field, and a field is something you can edit.

Atelier: The mechanic you just played is an egress study. Swap game dots for occupants and grid cells for a 50 cm floor raster, and the flood’s peak value is your worst-case travel distance to a fire exit — the number code officers actually ask for. A team living with AI-assisted design can wire this into review: export the plan as a black-and-white mask, flood from each exit, and the hot spots — high numbers, far from any door — light up before anyone drafts a section. Your one Monday move: take last week’s plan, rasterise it, and run a distance-field flood from the exits; if any occupied cell exceeds your jurisdiction’s travel-distance limit, you found it in a coffee break, not in plan-check.

Hack: Flood a distance field out from your exit door and read every cell’s steps-to-safety. This is breadth-first search over the free cells of your plan raster — the door starts at 0, every reachable cell records how many steps it sits from safety, and an occupant only ever needs to look one cell downhill.

from collections import deque
d, q = {door: 0}, deque([door])
while q and (c := q.popleft()) is not None:
    for n in [x for x in open_nbrs(c) if x not in d]:
        d[n] = d[c] + 1; q.append(n)

Change one line — make open_nbrs return the four diagonals too — and watch travel distances shrink: that is the difference between an occupant who can cut a corner and one boxed to the orthogonal grid.

Now break it. Paint a wall that seals one room off entirely. The flood never reaches it; those cells stay at infinity, and your dots in that room stand still forever. That is not a bug — it is the simulation telling you a truth a rendered plan hides: an exit that exists on paper but not in the field is not an exit. The training toys my generation got wrong were the ones you couldn’t break like this — a sealed room that reads as safe because nobody ran the flood is a slideshow with a score, not a life-safety check. Leave the rules exposed and let people abuse the grid; the lesson is in the misuse.

To build it yourself, start where every one of these mechanics is taught cleanly: the autonomous-agents chapter of Daniel Shiffman’s The Nature of Code (natureofcode.com, free) for the steering, and his Coding Train channel (thecodingtrain.com) for the flow-field walkthrough. PAZ keeps both on the shelf beside The Computational Beauty of Nature — the through-line is identical: simple local rules, global behaviour. Build the toy, then point it at a real plan.