diff --git a/README.md b/README.md
index b6b0435..a662286 100644
--- a/README.md
+++ b/README.md
@@ -145,7 +145,7 @@ The terminal tells you why your repo got its plan:
this repo is Tokyo: mostly small buildings (median 99 lines); 3.3 imports per file, so everything connects
```
-Some repos also get a condition on top of their plan. A repo with no recent commits is a ghost town. One where most files haven't been touched in years is ancient ruins. A sudden rush of commits makes a boomtown, and a repo that's mostly tests is a garden city.
+Some repos also get a condition on top of their plan. A repo with no recent commits is a ghost town. One where most files haven't been touched in years is ancient ruins. A sudden rush of commits makes a boomtown, and a repo that's mostly tests is a garden city. A repo twenty years old whose first five years still stand is an old walled city: a wall with towers and gates goes round the quarter where those founding files cluster, or round the whole city when they're spread all through it.
## How to read the city
diff --git a/deploy/cloudflare/container/version.mjs b/deploy/cloudflare/container/version.mjs
index 5d8d697..44e26ed 100644
--- a/deploy/cloudflare/container/version.mjs
+++ b/deploy/cloudflare/container/version.mjs
@@ -2,4 +2,4 @@
// scanner changes what it finds: cities are cached per version, and the Worker only keeps a city from a
// container that says it runs this version (after a deploy, containers already running keep the old
// image for a while, and their cities mustn't be cached as new ones).
-export const SCANNER = 8;
+export const SCANNER = 9;
diff --git a/src/classify.mjs b/src/classify.mjs
index 8b65455..0989028 100644
--- a/src/classify.mjs
+++ b/src/classify.mjs
@@ -199,6 +199,8 @@ export function cityMetrics(city, now = Date.now() / 1000) {
const recentWindow = 90 * 86400;
const recentCommits = commits.filter(c => c[0] > end - recentWindow).length;
const avgPerWindow = commitCount / Math.max(1, seen / recentWindow);
+ // the old walled city: how many of the files still standing were built in the repo's first five years
+ const founded = city.truncated && city.firstCommit ? city.firstCommit : city.start;
return {
files: n,
@@ -232,6 +234,7 @@ export function cityMetrics(city, now = Date.now() / 1000) {
commitsPerWeek: commitCount / Math.max(1, seen / (7 * 86400)),
idleYears: history ? Math.max(0, (now - end) / YEAR) : 0,
staleShare: F.filter(f => end - f.last > 2 * YEAR).length / Math.max(1, n),
+ foundingShare: F.filter(f => f.born < founded + 5 * YEAR).length / Math.max(1, n),
recentBoost: avgPerWindow && commitCount >= 200 && recentCommits >= 30 ? recentCommits / avgPerWindow : 0,
hardware: (city.extras?.hardwareFiles || 0) > 0,
infraFiles: infraIdx.length,
@@ -353,6 +356,7 @@ const ARCHETYPES = {
const STATES = {
ruins: m => m.history && m.staleShare > 0.35 && m.ageYears > 4 && `ancient ruins: ${pct(m.staleShare)} of files untouched for 2+ years`,
ghost: m => m.history && m.idleYears > 1.5 && `ghost town: no commits for ${m.idleYears.toFixed(1)} years`,
+ walled: m => m.history && m.ageYears >= 20 && m.foundingShare >= 0.2 && `old walled city: ${pct(m.foundingShare)} of files date from its first five years, ${Math.floor(m.ageYears)} years ago`,
boom: m => m.history && m.recentBoost > 2.5 && `boomtown: ${m.recentBoost.toFixed(1)}× the usual commit rate lately`,
garden: m => m.testShare > 0.6 && `garden city: ${pct(m.testShare)} of the code is tests`,
maze: m => m.cycleShare > 0.5 && `old medina: ${pct(m.cycleShare)} of files sit in import cycles`,
diff --git a/test/snapshots/SNKRX.json b/test/snapshots/SNKRX.json
index 2a119b2..e95a30e 100644
--- a/test/snapshots/SNKRX.json
+++ b/test/snapshots/SNKRX.json
@@ -48,6 +48,7 @@
"ageYears": 1.310410614241894,
"commitsPerWeek": 1.5210158948424426,
"staleShare": 0,
+ "foundingShare": 1,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/You-Dont-Know-JS.json b/test/snapshots/You-Dont-Know-JS.json
index 1630d69..0f41f18 100644
--- a/test/snapshots/You-Dont-Know-JS.json
+++ b/test/snapshots/You-Dont-Know-JS.json
@@ -44,6 +44,7 @@
"ageYears": 12.173959965269855,
"commitsPerWeek": 1.5474957466593235,
"staleShare": 0.8409090909090909,
+ "foundingShare": 0.8181818181818182,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/axum.json b/test/snapshots/axum.json
index 5f59b3a..1debc5a 100644
--- a/test/snapshots/axum.json
+++ b/test/snapshots/axum.json
@@ -44,6 +44,7 @@
"ageYears": 4.853932998707126,
"commitsPerWeek": 4.540585715188863,
"staleShare": 0.07339449541284404,
+ "foundingShare": 1,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/flask.json b/test/snapshots/flask.json
index bea2de2..f5e387f 100644
--- a/test/snapshots/flask.json
+++ b/test/snapshots/flask.json
@@ -44,6 +44,7 @@
"ageYears": 15.872805283038,
"commitsPerWeek": 1.9523790852940475,
"staleShare": 0.28,
+ "foundingShare": 0.72,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/gallery.json b/test/snapshots/gallery.json
index 122c27e..99c33a6 100644
--- a/test/snapshots/gallery.json
+++ b/test/snapshots/gallery.json
@@ -51,6 +51,7 @@
"ageYears": 4.083967665475194,
"commitsPerWeek": 1.7738517481402771,
"staleShare": 0.07407407407407407,
+ "foundingShare": 1,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/gson.json b/test/snapshots/gson.json
index 8d11143..74c5583 100644
--- a/test/snapshots/gson.json
+++ b/test/snapshots/gson.json
@@ -44,6 +44,7 @@
"ageYears": 17.625486126955156,
"commitsPerWeek": 1.285239865134112,
"staleShare": 0.2727272727272727,
+ "foundingShare": 0.5950413223140496,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/jq.json b/test/snapshots/jq.json
index ad0bedc..a81b345 100644
--- a/test/snapshots/jq.json
+++ b/test/snapshots/jq.json
@@ -44,6 +44,7 @@
"ageYears": 13.832254480695617,
"commitsPerWeek": 1.3702857351105027,
"staleShare": 0.37209302325581395,
+ "foundingShare": 0.9069767441860465,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/ky.json b/test/snapshots/ky.json
index 579764e..44c6297 100644
--- a/test/snapshots/ky.json
+++ b/test/snapshots/ky.json
@@ -44,6 +44,7 @@
"ageYears": 8.094338574543057,
"commitsPerWeek": 0.840533064359412,
"staleShare": 0.019230769230769232,
+ "foundingShare": 0.34615384615384615,
"recentBoost": 9.25338705587434,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/nanoGPT.json b/test/snapshots/nanoGPT.json
index dd7ece8..1bd21a3 100644
--- a/test/snapshots/nanoGPT.json
+++ b/test/snapshots/nanoGPT.json
@@ -44,6 +44,7 @@
"ageYears": 1.9501042221208202,
"commitsPerWeek": 1.09086993273011,
"staleShare": 0,
+ "foundingShare": 1,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/test/snapshots/terraform-aws-eks.json b/test/snapshots/terraform-aws-eks.json
index 63b5bd5..f0738ba 100644
--- a/test/snapshots/terraform-aws-eks.json
+++ b/test/snapshots/terraform-aws-eks.json
@@ -44,6 +44,7 @@
"ageYears": 8.336243884199051,
"commitsPerWeek": 1.209269634892521,
"staleShare": 0.20454545454545456,
+ "foundingShare": 0.6590909090909091,
"recentBoost": 0,
"hardware": false,
"infraFiles": 88,
diff --git a/test/snapshots/uuid.json b/test/snapshots/uuid.json
index f4da96f..4c6b946 100644
--- a/test/snapshots/uuid.json
+++ b/test/snapshots/uuid.json
@@ -44,6 +44,7 @@
"ageYears": 12.440389256470707,
"commitsPerWeek": 0.14327050590446247,
"staleShare": 0.6190476190476191,
+ "foundingShare": 0.7142857142857143,
"recentBoost": 0,
"hardware": false,
"infraFiles": 0,
diff --git a/web/index.html b/web/index.html
index b9196ee..d9d8fa7 100644
--- a/web/index.html
+++ b/web/index.html
@@ -268,6 +268,7 @@
+
diff --git a/web/main.js b/web/main.js
index bda7c26..aec90a6 100644
--- a/web/main.js
+++ b/web/main.js
@@ -8,6 +8,7 @@ import { ShaderPass } from 'three/addons/postprocessing/ShaderPass.js';
import { hierarchy, treemap, treemapSquarify } from 'd3-hierarchy';
import { buildStudio } from './studio.js';
import { buildLayout, CITY_KINDS } from './layouts.js';
+import { planWall, foundingEnd } from './walls.js';
import { createPixelPipeline } from './pixel.js';
import { rubbleMesh, RUBBLE_VERTEX } from './rubble.js';
import { PERF, HEAP, timed } from './perf.js';
@@ -171,6 +172,12 @@ if (layout) {
Object.assign(B[i], { x: l.x, z: l.z, w: l.w * 0.88, d: l.d * 0.88, rot: l.rot, y: base + (l.y || 0), h: Math.max(layout.heights[i], unit * 0.1) });
});
}
+// an old walled city (twenty years on, its founding files still standing) keeps its old town behind a
+// wall, whatever the plan; it goes up when the founding years end (not on the circuit board, which is
+// no city: it has no old town to wall)
+const wall = layout && STYLE !== 'chip' && data.identity?.states?.some(s => s.id === 'walled')
+ ? timed('wall', () => { const until = foundingEnd(data), w = planWall({ layout, files, until }); return w && { ...w, born: Math.max(0, t01(until)) }; })
+ : null;
// ------------------------------------------------------------ renderer
// ?record=1&w=1920&h=1080&fps=30&dur=20 → deterministic frame capture driven by the CLI
@@ -433,7 +440,7 @@ const glowAttr = new Float32Array(N); // 1 for the buildings of the district und
// the circuit board's parts are fetched only for it
const chip = STYLE === 'chip' ? await import('./chip.js') : null;
const studio = NEON ? null : timed('studio (all)', () => buildStudio({ name: STYLE, scene, renderer, B, files, districts, unit, SIZE, plateStep, cx, cz,
- shared, heat, focusAttr, glowAttr, inDeg, hub, t01, layout, chip }));
+ shared, heat, focusAttr, glowAttr, inDeg, hub, t01, layout, chip, wall }));
if (studio) {
document.body.classList.add('studio', `style-${STYLE}`);
if (studio.style.uiFont) document.body.style.setProperty('--ui-font', studio.style.uiFont);
diff --git a/web/studio.js b/web/studio.js
index 14b9046..ba3971a 100644
--- a/web/studio.js
+++ b/web/studio.js
@@ -20,7 +20,7 @@ export const STYLES = {
hemi: { sky: '#f6f3ee', ground: '#a69d90', intensity: 1.25 },
heightScale: 0.42, maxHeight: 4.5,
building: '#f1ede6', buildingJitter: 0.035, ground: '#d8d1c5', plate: '#e4ded4', roughness: 0.92,
- rail: '#8f877c', water: '#b7c2c3', land: '#ddd6ca', yard: '#c9c4b8', dirt: '#c8b48f', sand: '#e6d8b5', dune: '#d6c49c', cliff: '#cbbfae', plaza: '#ece7de', park: '#c6cab0', lawn: '#d4d4bf', hill: '#d9d1c4', road: '#c9c1b4',
+ rail: '#8f877c', water: '#b7c2c3', land: '#ddd6ca', yard: '#c9c4b8', dirt: '#c8b48f', sand: '#e6d8b5', dune: '#d6c49c', cliff: '#cbbfae', plaza: '#ece7de', park: '#c6cab0', lawn: '#d4d4bf', hill: '#d9d1c4', road: '#c9c1b4', wall: '#d3cbbd',
windows: 0, accent: '#d8452b', edges: { color: '#2a2724', opacity: 0.07 },
toneMapping: THREE.NeutralToneMapping, exposure: 1.15, bloom: null,
ink: '#2a2724', inkSoft: 'rgba(42,39,36,.55)', font: "'Instrument Serif', Georgia, serif", labelCase: 'none',
@@ -28,7 +28,7 @@ export const STYLES = {
plan: {
background: '#f1ede4', fog: null, flat: true,
building: '#1c1b1a', buildingJitter: 0, ground: '#f1ede4', plate: '#e7e2d7',
- rail: '#2f5d7c', water: '#dce3e3', land: '#f1ede4', yard: '#e4e0d6', dirt: '#e0d2b6', sand: '#f1e7d0', dune: '#e6d9bc', cliff: '#ddd5c6', plaza: '#ece8df', park: '#e1e3d0', lawn: '#ebebdf', hill: '#e4dfd4', road: '#ddd7cb',
+ rail: '#2f5d7c', water: '#dce3e3', land: '#f1ede4', yard: '#e4e0d6', dirt: '#e0d2b6', sand: '#f1e7d0', dune: '#e6d9bc', cliff: '#ddd5c6', plaza: '#ece8df', park: '#e1e3d0', lawn: '#ebebdf', hill: '#e4dfd4', road: '#ddd7cb', wall: '#6b655c',
windows: 0, accent: '#d23c2a', edges: { color: '#d23c2a', opacity: 0.22 },
toneMapping: THREE.NoToneMapping, exposure: 1.0, bloom: null,
ink: '#1c1b1a', inkSoft: 'rgba(28,27,26,.55)', font: "'Instrument Serif', Georgia, serif", labelCase: 'upper',
@@ -38,7 +38,7 @@ export const STYLES = {
sun: { color: '#fff4e0', intensity: 2.6, elevation: 50, azimuth: 75 },
hemi: { sky: '#c4e4ee', ground: '#61944a', intensity: 1.0 },
building: '#bdb293', buildingJitter: 0.06, ground: '#61944a', plate: '#cdc8d2', roughness: 1,
- rail: '#4a4458', water: '#2f6188', land: '#61944a', yard: '#9c97a8', dirt: '#968a6e', sand: '#dccfa4', dune: '#bdb293', cliff: '#968a6e', plaza: '#e0d7b8', park: '#3d6b36', lawn: '#93bf62', hill: '#3d6b36', road: '#6e6880',
+ rail: '#4a4458', water: '#2f6188', land: '#61944a', yard: '#9c97a8', dirt: '#968a6e', sand: '#dccfa4', dune: '#bdb293', cliff: '#968a6e', plaza: '#e0d7b8', park: '#3d6b36', lawn: '#93bf62', hill: '#3d6b36', road: '#6e6880', wall: '#968a6e',
windows: 0, accent: '#c0413b', edges: null,
toneMapping: THREE.NoToneMapping, exposure: 1.0, bloom: null,
ink: '#14121c', inkSoft: 'rgba(20,18,28,.7)', font: "'Pixelify Sans', monospace", uiFont: "'Pixelify Sans', monospace", labelCase: 'none',
@@ -49,7 +49,7 @@ export const STYLES = {
hemi: { sky: '#56607e', ground: '#17151a', intensity: 1.15 },
heightScale: 0.55, maxHeight: 6,
building: '#3d4049', buildingJitter: 0.04, ground: '#14161c', plate: '#24262e', roughness: 0.8,
- rail: '#6d6050', water: '#0b1626', land: '#1c1e25', yard: '#25272e', dirt: '#2a241c', sand: '#2a2620', dune: '#221f1a', cliff: '#1d1f25', plaza: '#2d2f37', park: '#18211a', lawn: '#1b211d', hill: '#15161c', road: '#0e0f13',
+ rail: '#6d6050', water: '#0b1626', land: '#1c1e25', yard: '#25272e', dirt: '#2a241c', sand: '#2a2620', dune: '#221f1a', cliff: '#1d1f25', plaza: '#2d2f37', park: '#18211a', lawn: '#1b211d', hill: '#15161c', road: '#0e0f13', wall: '#3a3833',
windows: 1, windowColor: '#ffc27a', accent: '#ffc27a', edges: { color: '#ffc27a', opacity: 0.018 }, hubEdgeBoost: 3,
toneMapping: THREE.ACESFilmicToneMapping, exposure: 1.1, bloom: { strength: 0.35, radius: 0.4, threshold: 0.85 },
ink: '#e8e2d6', inkSoft: 'rgba(232,226,214,.55)', font: "'Instrument Serif', Georgia, serif", labelCase: 'none',
@@ -92,7 +92,7 @@ function slabEach(list) {
return geos.length ? mergeGeometries(geos) : null;
}
-function buildTerrain(scene, layout, S, plateStep, shared, street, blockBorn) {
+function buildTerrain(scene, layout, S, plateStep, shared, street, blockBorn, wall) {
const mat = color => S.flat ? new THREE.MeshBasicMaterial({ color })
: new THREE.MeshStandardMaterial({ color, roughness: 0.95, flatShading: true });
const add = (geo, color, surface) => {
@@ -213,6 +213,19 @@ function buildTerrain(scene, layout, S, plateStep, shared, street, blockBorn) {
mesh.castShadow = mesh.receiveShadow = !S.flat;
scene.add(mesh);
}
+ // the old town's wall (walls.js): stone runs along the streets, square towers with red roofs, all
+ // going up together when the founding years end. They stand from the ground up: round a whole city
+ // on the sea they cross the water between its islands, and stand in it rather than over it
+ if (wall) {
+ const wh = u * 0.5, ts = u * 0.46, th = wh * 1.8;
+ const grown = g => { const n = g.attributes.position.count, a = new Float32Array(n * 2); for (let k = 0; k < n; k++) { a[k * 2] = wall.born; a[k * 2 + 1] = 0; } return g.setAttribute('aGrow', new THREE.BufferAttribute(a, 2)); };
+ if (wall.walls.length) add(grown(mergeGeometries(wall.walls.map(([xa, za, xb, zb, t]) => new THREE.BoxGeometry(Math.hypot(xb - xa, zb - za), landTop + wh, t)
+ .rotateY(-Math.atan2(zb - za, xb - xa)).translate((xa + xb) / 2, (landTop + wh) / 2, (za + zb) / 2)))), S.wall);
+ if (wall.towers.length) {
+ add(grown(mergeGeometries(wall.towers.map(([x, z]) => new THREE.BoxGeometry(ts, landTop + th, ts).translate(x, (landTop + th) / 2, z)))), S.wall);
+ add(grown(mergeGeometries(wall.towers.map(([x, z]) => new THREE.ConeGeometry(ts * 0.78, ts * 0.8, 4).rotateY(Math.PI / 4).translate(x, landTop + th + ts * 0.4, z)))), S.accent);
+ }
+ }
for (const h of S.flat ? [] : layout.hills) { // seen from straight above, hills are just blobs
const mesh = new THREE.Mesh(new THREE.IcosahedronGeometry(1, 2), mat(S.hill));
mesh.scale.set(h.r, h.h, h.r * 0.8);
@@ -223,7 +236,7 @@ function buildTerrain(scene, layout, S, plateStep, shared, street, blockBorn) {
}
export function buildStudio(ctx) {
- const { name, scene, renderer, B, files, districts, unit, SIZE, plateStep, cx, cz, shared, heat, focusAttr, inDeg, hub, t01, layout, chip } = ctx;
+ const { name, scene, renderer, B, files, districts, unit, SIZE, plateStep, cx, cz, shared, heat, focusAttr, inDeg, hub, t01, layout, chip, wall } = ctx;
// a desert city stands on sand: the open ground and the lawns between blocks become dunes
const S = layout?.sand ? { ...STYLES[name], land: STYLES[name].sand, lawn: STYLES[name].dune } : STYLES[name];
const N = files.length;
@@ -291,7 +304,7 @@ export function buildStudio(ctx) {
scene.add(ground);
// ---- city terrain from a planner: land, raised blocks, parks, plazas, bridges, hills
- if (layout) timed('terrain', () => buildTerrain(scene, layout, S, plateStep, shared, street, streets?.blockBorn));
+ if (layout) timed('terrain', () => buildTerrain(scene, layout, S, plateStep, shared, street, streets?.blockBorn, wall));
// district names appear with their land
// (a district's name goes up with its land, ahead of its first building)
// (and not before the ground under the name itself has come up: a district's first file can be far off)
diff --git a/web/walls.js b/web/walls.js
new file mode 100644
index 0000000..ee9ac9f
--- /dev/null
+++ b/web/walls.js
@@ -0,0 +1,342 @@
+// The old walled city (the classifier's 'walled' state): a repo twenty years old whose first five
+// years still stand keeps them behind a city wall. The wall goes round the blocks where those
+// founding files cluster, down the middle of the streets between them and the newer town, so it
+// never cuts through a building whatever the plan. Towers stand along it, gates open where it
+// meets the widest streets, and it goes up when the founding years end. When the founding files are
+// spread evenly through the city there is no old quarter to pick out: the whole city is the old town,
+// and the wall goes round its edge.
+//
+// planWall works on the finished layout and returns plain numbers; the studio turns them into walls.
+
+const YEAR = 365.25 * 86400;
+
+// the end of the founding years, by the same founding day the classifier counts from
+export function foundingEnd(data) {
+ const founded = data.truncated && data.firstCommit ? data.firstCommit : data.start;
+ return founded + 5 * YEAR;
+}
+
+function inside([x, z], poly) {
+ let c = false;
+ for (let k = 0, m = poly.length - 1; k < poly.length; m = k++) {
+ const [xa, za] = poly[k], [xb, zb] = poly[m];
+ if ((za > z) !== (zb > z) && x < xa + (z - za) / (zb - za) * (xb - xa)) c = !c;
+ }
+ return c;
+}
+
+// convex hull of points [x, z] (monotone chain), in order round it
+function hull(pts) {
+ pts.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+ const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+ const lo = [], hi = [];
+ for (const p of pts) { while (lo.length >= 2 && cross(lo[lo.length - 2], lo[lo.length - 1], p) <= 0) lo.pop(); lo.push(p); }
+ for (let k = pts.length - 1; k >= 0; k--) { const p = pts[k]; while (hi.length >= 2 && cross(hi[hi.length - 2], hi[hi.length - 1], p) <= 0) hi.pop(); hi.push(p); }
+ return lo.slice(0, -1).concat(hi.slice(0, -1));
+}
+
+// the old town: the round patch of the city where founding buildings are thickest, the one with the
+// most of them over what the city's average would put there (a quarter of the city at most); null
+// when there is none (founding files spread evenly, or too few files for a quarter of their own)
+function oldTown(layout, xs, zs, old) {
+ const u = layout.unit, n = xs.length;
+ let oldAll = 0;
+ for (const o of old) oldAll += o;
+ const floor = oldAll / n, least = Math.max(8, Math.ceil(n * 0.04)), most = Math.ceil(n * 0.25);
+ if (oldAll < 6 || least > most) return null;
+ const olds = [];
+ for (let k = 0; k < n; k++) if (old[k]) olds.push(k);
+ let X0 = Infinity, Z0 = Infinity, X1 = -Infinity, Z1 = -Infinity;
+ for (let k = 0; k < n; k++) { X0 = Math.min(X0, xs[k]); Z0 = Math.min(Z0, zs[k]); X1 = Math.max(X1, xs[k]); Z1 = Math.max(Z1, zs[k]); }
+ // the lots round each centre are counted in thin rings out from it rather than sorted by distance
+ // (a sort per centre took a second on a city of 30,000 files)
+ const ring = u * 0.1, R = Math.ceil(Math.hypot(X1 - X0, Z1 - Z0) / ring) + 1;
+ const ringOf = (k, cx, cz) => Math.floor(Math.sqrt((xs[k] - cx) ** 2 + (zs[k] - cz) ** 2) / ring);
+ const count = new Int32Array(R), founding = new Int32Array(R);
+ let best = null;
+ for (let c = 0; c < olds.length; c += Math.ceil(olds.length / 200)) {
+ const cx = xs[olds[c]], cz = zs[olds[c]];
+ count.fill(0); founding.fill(0);
+ for (let k = 0; k < n; k++) { const r = ringOf(k, cx, cz); count[r]++; founding[r] += old[k]; }
+ for (let r = 0, m = 0, gain = 0; r < R; r++) {
+ m += count[r]; gain += founding[r] - floor * count[r];
+ if (m > most) break;
+ if (m >= least && (!best || gain > best.gain)) best = { gain, cx, cz, r, m };
+ }
+ }
+ if (!best || best.gain <= 0) return null;
+ const town = new Uint8Array(n);
+ for (let k = 0; k < n; k++) if (ringOf(k, best.cx, best.cz) <= best.r) town[k] = 1;
+ // a block goes in or out whole, so the wall keeps to the streets; only a block too big for that
+ // (a whole compound of the factory town) is split between its buildings. Blocks are filed under the
+ // squares of a coarse grid they cover, so a lot only tries the few around it
+ const g = u * 4, GW = Math.floor((X1 - X0) / g) + 1, GH = Math.floor((Z1 - Z0) / g) + 1;
+ const filed = Array.from({ length: GW * GH }, () => []);
+ const blocks = layout.blocks.map((b, id) => {
+ const bx = b.poly.map(p => p[0]), bz = b.poly.map(p => p[1]);
+ const box = [Math.min(...bx), Math.min(...bz), Math.max(...bx), Math.max(...bz)];
+ for (let j = Math.max(0, Math.floor((box[1] - Z0) / g)); j <= Math.min(GH - 1, Math.floor((box[3] - Z0) / g)); j++)
+ for (let i = Math.max(0, Math.floor((box[0] - X0) / g)); i <= Math.min(GW - 1, Math.floor((box[2] - X0) / g)); i++) filed[j * GW + i].push(id);
+ return { poly: b.poly, box, lots: [] };
+ });
+ for (let k = 0; k < n; k++) {
+ const x = xs[k], z = zs[k];
+ const id = filed[Math.floor((z - Z0) / g) * GW + Math.floor((x - X0) / g)].find(id => {
+ const b = blocks[id];
+ return x >= b.box[0] && x <= b.box[2] && z >= b.box[1] && z <= b.box[3] && inside([x, z], b.poly);
+ });
+ if (id !== undefined) blocks[id].lots.push(k);
+ }
+ for (const b of blocks) {
+ if (!b.lots.length || b.lots.length > best.m * 0.3) continue;
+ const keep = b.lots.filter(k => town[k]).length >= b.lots.length / 2 ? 1 : 0;
+ for (const k of b.lots) town[k] = keep;
+ }
+ let kept = 0;
+ for (let k = 0; k < n; k++) kept += town[k] & old[k];
+ return kept >= 6 ? town : null;
+}
+
+// → { walls: [[xa, za, xb, zb, thickness]] straight pieces of wall, towers: [[x, z]], gates: [[x, z]] },
+// or null for a city with no lots at all
+export function planWall({ layout, files, until }) {
+ const lot = i => layout.lots[i] && layout.lots[i].w > 0.01;
+ const live = [...files.keys()].filter(i => !files[i].gone && lot(i));
+ // the files deleted lately stand for most of the timeline: they have no say in where the old town
+ // is, but the wall goes round them like any other building
+ const gone = [...files.keys()].filter(i => files[i].gone && lot(i));
+ if (!live.length) return null;
+ const foot = [...live, ...gone].map(i => { const l = layout.lots[i]; return { ...l, r: Math.hypot(l.w, l.d) / 2, c: Math.cos(l.rot || 0), s: Math.sin(l.rot || 0) }; });
+ const here = foot.slice(0, live.length);
+ const town = oldTown(layout, here.map(l => l.x), here.map(l => l.z), live.map(i => files[i].born < until ? 1 : 0));
+ // with no old quarter to pick out, or none big enough to wall, the old town is the whole city
+ return town && quarterWall(layout, foot, live.length, town) || cityWall(layout, foot);
+}
+
+// half a gate's width, and half a tower's (studio.js: 0.46 wide, the eaves of its roof out to 0.26), in lots
+const GATE = 0.45, TOWER = 0.26;
+
+// towers: a pair flanking each gate, then one every few lots along the wall, where `clear` lets them
+// (filed by squares three lots wide, so a long wall doesn't check each spot against every tower)
+function placeTowers(u, along, gates, clear) {
+ const towers = [], D = u * 3, filed = new Map();
+ const key = (x, z) => Math.floor(x / D) * 65536 + Math.floor(z / D);
+ const put = t => { towers.push(t); const k = key(t[0], t[1]); if (!filed.has(k)) filed.set(k, []); filed.get(k).push(t); };
+ const free = ([x, z]) => {
+ for (let a = -1; a <= 1; a++) for (let b = -1; b <= 1; b++)
+ for (const t of filed.get(key(x + a * D, z + b * D)) || []) if (Math.hypot(x - t[0], z - t[1]) < D) return false;
+ return true;
+ };
+ for (const g of gates) {
+ const ring = along.filter(p => Math.abs(Math.hypot(p[0] - g[0], p[1] - g[1]) - u * (GATE + 0.25)) < u * 0.2 && clear(p));
+ if (!ring.length) continue;
+ const a = ring[0], b = ring.reduce((m, q) => Math.hypot(q[0] - a[0], q[1] - a[1]) > Math.hypot(m[0] - a[0], m[1] - a[1]) ? q : m, a);
+ put(a); if (b !== a) put(b);
+ }
+ for (const p of along) if (free(p) && clear(p)) put(p);
+ return towers;
+}
+
+// the whole city as the old town: the wall follows its outline, the hull round all its buildings
+// (deleted ones too) out as far as a wall stands from them, so it's one town even where it's scattered
+// over islands and open ground, and it never comes near a building
+function cityWall(layout, foot) {
+ const u = layout.unit, reach = u * 0.7, thick = u * 0.24;
+ const corners = foot.flatMap(l => [[-1, -1], [1, -1], [1, 1], [-1, 1]].map(([a, b]) =>
+ // three.js turns a lot's +x to (cos r, -sin r) and +z to (sin r, cos r)
+ [l.x + (l.c * a * l.w + l.s * b * l.d) / 2, l.z + (-l.s * a * l.w + l.c * b * l.d) / 2]));
+ const out = hull(hull(corners).flatMap(([x, z]) => Array.from({ length: 8 }, (_, k) => [x + Math.cos(k * Math.PI / 4) * reach, z + Math.sin(k * Math.PI / 4) * reach])));
+ const edges = out.map((a, k) => [a, out[(k + 1) % out.length]]);
+ // gates: one to each side, straight out from the middle of the city
+ let cx = 0, cz = 0;
+ for (const [x, z] of out) { cx += x / out.length; cz += z / out.length; }
+ const gates = [];
+ for (let side = 0; side < 4; side++) {
+ const dx = Math.round(Math.cos(side * Math.PI / 2)), dz = Math.round(Math.sin(side * Math.PI / 2));
+ for (const [[xa, za], [xb, zb]] of edges) {
+ const ex = xb - xa, ez = zb - za, den = dx * ez - dz * ex;
+ if (!den) continue;
+ const t = ((xa - cx) * ez - (za - cz) * ex) / den, s = ((xa - cx) * dz - (za - cz) * dx) / den;
+ if (t > 0 && s >= 0 && s <= 1) { gates.push([cx + dx * t, cz + dz * t]); break; }
+ }
+ }
+ // each edge, less the gaps for the gates; a piece runs on by half its thickness past a corner, so
+ // the pieces meet there
+ const walls = [], along = [];
+ for (const [[xa, za], [xb, zb]] of edges) {
+ const L = Math.hypot(xb - xa, zb - za);
+ if (L < 1e-9) continue;
+ const ux = (xb - xa) / L, uz = (zb - za) / L;
+ const cuts = [];
+ for (const [gx, gz] of gates) { // where this edge passes within half a gate's width of a gate
+ const m = (gx - xa) * ux + (gz - za) * uz, h2 = (u * GATE) ** 2 - ((gx - xa) * uz - (gz - za) * ux) ** 2;
+ if (h2 > 0) cuts.push([m - Math.sqrt(h2), m + Math.sqrt(h2)]);
+ }
+ cuts.sort((a, b) => a[0] - b[0]);
+ let from = -thick / 2;
+ for (const [c0, c1] of [...cuts, [Infinity, Infinity]]) {
+ const to = Math.min(c0, L + thick / 2);
+ if (to > from) walls.push([xa + ux * from, za + uz * from, xa + ux * to, za + uz * to, thick]);
+ from = Math.max(from, c1);
+ if (from >= L + thick / 2) break;
+ }
+ for (let d = 0; d < L; d += u * 0.1) along.push([xa + ux * d, za + uz * d]);
+ }
+ const towers = placeTowers(u, along, gates, ([x, z]) => gates.every(g => Math.hypot(x - g[0], z - g[1]) >= u * GATE));
+ return { walls, towers, gates };
+}
+
+// a quarter of the city as the old town: every patch of ground labelled with its nearest building's
+// lot (a chamfer distance transform), and the wall run where ground that belongs to the old town meets
+// ground that belongs to the rest; null when there's too little of it to wall
+function quarterWall(layout, foot, live, town) {
+ const u = layout.unit;
+ const reach = u * 0.7; // how far out from its buildings a wall stands when nothing is across the street
+ // only the ground round the old town is needed, with room for the lots across its streets
+ let X0 = Infinity, Z0 = Infinity, X1 = -Infinity, Z1 = -Infinity;
+ for (let k = 0; k < live; k++) if (town[k]) { const l = foot[k]; X0 = Math.min(X0, l.x - l.r); Z0 = Math.min(Z0, l.z - l.r); X1 = Math.max(X1, l.x + l.r); Z1 = Math.max(Z1, l.z + l.r); }
+ X0 -= reach * 2; Z0 -= reach * 2; X1 += reach * 2; Z1 += reach * 2;
+ // cells an eighth of a lot, or bigger on a big town to keep to three million of them: counted by
+ // area, so a long thin one gets cells as fine as a square one of the same size
+ const cell = Math.max(u * 0.12, Math.sqrt((X1 - X0) * (Z1 - Z0) / 3e6));
+ const W = Math.ceil((X1 - X0) / cell), H = Math.ceil((Z1 - Z0) / cell), N = W * H;
+ const lab = new Int32Array(N).fill(-1), dist = new Float32Array(N).fill(1e9);
+ // a lot takes every cell it touches, not only the ones whose middle it covers (half a cell more
+ // along each of its sides, a little over for the wall's overlap), so no wall cell is on a building
+ const seed = k => {
+ const l = foot[k], pad = cell * 0.52 * (Math.abs(l.c) + Math.abs(l.s)), r = l.r + cell * 1.5;
+ const i0 = Math.max(0, Math.floor((l.x - r - X0) / cell)), i1 = Math.min(W - 1, Math.ceil((l.x + r - X0) / cell));
+ const j0 = Math.max(0, Math.floor((l.z - r - Z0) / cell)), j1 = Math.min(H - 1, Math.ceil((l.z + r - Z0) / cell));
+ for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) {
+ // three.js turns a lot's +x to (cos r, -sin r) and +z to (sin r, cos r)
+ const dx = X0 + (i + 0.5) * cell - l.x, dz = Z0 + (j + 0.5) * cell - l.z;
+ if (Math.abs(dx * l.c - dz * l.s) <= l.w / 2 + pad && Math.abs(dx * l.s + dz * l.c) <= l.d / 2 + pad) { lab[j * W + i] = k; dist[j * W + i] = 0; }
+ }
+ };
+ const R2 = Math.SQRT2;
+ const relax = (p, q, w) => { if (dist[q] + w < dist[p]) { dist[p] = dist[q] + w; lab[p] = lab[q]; } };
+ const sweep = () => {
+ for (let j = 0; j < H; j++) for (let i = 0; i < W; i++) {
+ const p = j * W + i;
+ if (i > 0) relax(p, p - 1, 1);
+ if (j > 0) { relax(p, p - W, 1); if (i > 0) relax(p, p - W - 1, R2); if (i < W - 1) relax(p, p - W + 1, R2); }
+ }
+ for (let j = H - 1; j >= 0; j--) for (let i = W - 1; i >= 0; i--) {
+ const p = j * W + i;
+ if (i < W - 1) relax(p, p + 1, 1);
+ if (j < H - 1) { relax(p, p + W, 1); if (i < W - 1) relax(p, p + W + 1, R2); if (i > 0) relax(p, p + W - 1, R2); }
+ }
+ };
+ const inTown = new Uint8Array(foot.length);
+ inTown.set(town);
+ for (let k = 0; k < live; k++) seed(k);
+ sweep();
+ if (foot.length > live) {
+ // a deleted building belongs to the side of the street its ground was on without it, then stands
+ // in the field like the rest, so the wall goes down the street past it, not through it
+ for (let k = live; k < foot.length; k++) {
+ const i = Math.floor((foot[k].x - X0) / cell), j = Math.floor((foot[k].z - Z0) / cell);
+ inTown[k] = i >= 0 && j >= 0 && i < W && j < H && lab[j * W + i] >= 0 ? inTown[lab[j * W + i]] : 0;
+ }
+ for (let k = live; k < foot.length; k++) seed(k);
+ sweep();
+ }
+ const near = reach / cell;
+
+ // the wall: the old town's ground along its edge, two cells thick, out in the street (not on a block)
+ const own = new Uint8Array(N);
+ for (let p = 0; p < N; p++) own[p] = lab[p] >= 0 && inTown[lab[p]] && dist[p] <= near ? 1 : 0;
+ // one town in one piece: the biggest stretch of its ground (not a few lots across the canal), and
+ // with no holes in it (a yard in the middle is inside the walls, not walled off)
+ const id = new Int32Array(N), queue = new Int32Array(N);
+ const pieces = (want) => {
+ const size = [];
+ id.fill(-1);
+ for (let s = 0; s < N; s++) {
+ if (own[s] !== want || id[s] >= 0) continue;
+ const k = size.length;
+ let head = 0, tail = 0, edge = false;
+ queue[tail++] = s; id[s] = k;
+ while (head < tail) {
+ const p = queue[head++], i = p % W;
+ if (i === 0 || i === W - 1 || p < W || p >= N - W) edge = true;
+ if (i > 0 && own[p - 1] === want && id[p - 1] < 0) { id[p - 1] = k; queue[tail++] = p - 1; }
+ if (i < W - 1 && own[p + 1] === want && id[p + 1] < 0) { id[p + 1] = k; queue[tail++] = p + 1; }
+ if (p >= W && own[p - W] === want && id[p - W] < 0) { id[p - W] = k; queue[tail++] = p - W; }
+ if (p < N - W && own[p + W] === want && id[p + W] < 0) { id[p + W] = k; queue[tail++] = p + W; }
+ }
+ size.push({ n: tail, edge });
+ }
+ return size;
+ };
+ const land = pieces(1);
+ const main = land.reduce((b, s, k) => s.n > land[b].n ? k : b, 0);
+ for (let p = 0; p < N; p++) if (own[p] && id[p] !== main) own[p] = 0;
+ const holes = pieces(0);
+ for (let p = 0; p < N; p++) if (!own[p] && !holes[id[p]].edge) own[p] = 1;
+ const edge = (src) => {
+ const out = new Uint8Array(N);
+ for (let j = 0; j < H; j++) for (let i = 0; i < W; i++) {
+ const p = j * W + i;
+ if (src[p] && (i === 0 || j === 0 || i === W - 1 || j === H - 1 || !src[p - 1] || !src[p + 1] || !src[p - W] || !src[p + W])) out[p] = 1;
+ }
+ return out;
+ };
+ const e1 = edge(own), inner = own.map((v, p) => v && !e1[p] ? 1 : 0), e2 = edge(inner);
+ const wall = own.map((v, p) => (e1[p] || e2[p]) && dist[p] >= 1 ? 1 : 0);
+ const at = p => [X0 + (p % W + 0.5) * cell, Z0 + (Math.floor(p / W) + 0.5) * cell];
+ const wallCells = [];
+ for (let p = 0; p < N; p++) if (wall[p]) wallCells.push(p);
+ if (wallCells.length < 20) return null;
+
+ // gates: one to each side of the old town, where the wall crosses the widest street there
+ let cxs = 0, czs = 0;
+ for (const p of wallCells) { const [x, z] = at(p); cxs += x; czs += z; }
+ const c = [cxs / wallCells.length, czs / wallCells.length];
+ const gates = [];
+ for (let side = 0; side < 4; side++) {
+ let best = -1;
+ for (const p of wallCells) {
+ const [x, z] = at(p), a = Math.atan2(z - c[1], x - c[0]);
+ const s = ((Math.round(a / (Math.PI / 2)) % 4) + 4) % 4;
+ if (s !== side || !e1[p] || dist[p] >= near * 0.95) continue; // a street between blocks, not open ground
+ if (best < 0 || dist[p] > dist[best]) best = p;
+ }
+ if (best >= 0) gates.push(at(best));
+ }
+ const gap = p => { const [x, z] = at(p); return gates.some(g => Math.hypot(x - g[0], z - g[1]) < u * GATE); };
+ for (const p of wallCells) if (gap(p)) wall[p] = 0;
+
+ // a tower is wider than the wall: it stands only where none of the ground under it touches a building
+ const clear = ([x, z]) => {
+ const i0 = Math.floor((x - u * TOWER - X0) / cell), i1 = Math.floor((x + u * TOWER - X0) / cell);
+ const j0 = Math.floor((z - u * TOWER - Z0) / cell), j1 = Math.floor((z + u * TOWER - Z0) / cell);
+ if (i0 < 0 || j0 < 0 || i1 >= W || j1 >= H) return false;
+ for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) if (dist[j * W + i] === 0) return false;
+ return true;
+ };
+ const towers = placeTowers(u, wallCells.filter(p => wall[p] && e1[p]).map(at), gates, clear);
+
+ // the wall as boxes: a run of cells along a row, stacked onto the same run in the rows before it, so
+ // it's a handful of boxes rather than thousands (each a hair over its cells, so they meet)
+ const boxes = [];
+ let open = new Map();
+ for (let j = 0; j < H; j++) {
+ const next = new Map();
+ for (let i = 0; i < W; i++) {
+ if (!wall[j * W + i]) continue;
+ let k = i;
+ while (k + 1 < W && wall[j * W + k + 1]) k++;
+ const b = open.get(i * W + k) || boxes[boxes.push([i, k, j, j]) - 1];
+ b[3] = j; next.set(i * W + k, b);
+ i = k;
+ }
+ open = next;
+ }
+ const hair = cell * 0.01;
+ const walls = boxes.map(([i0, i1, j0, j1]) => {
+ const x0 = X0 + i0 * cell - hair, x1 = X0 + (i1 + 1) * cell + hair, z0 = Z0 + j0 * cell - hair, z1 = Z0 + (j1 + 1) * cell + hair;
+ return x1 - x0 >= z1 - z0 ? [x0, (z0 + z1) / 2, x1, (z0 + z1) / 2, z1 - z0] : [(x0 + x1) / 2, z0, (x0 + x1) / 2, z1, x1 - x0];
+ });
+ return { walls, towers, gates };
+}