ascii-city 0.1.0 → 0.3.0

package/README.md

@@ -8,6 +8,10 @@ layers:
 
 - **The base** — `js/citygen.js`, a seeded city generator: spec in, deterministic
   city model out. Pure data, no rendering, strictly printable ASCII (0x20–0x7E).
+  The city is INFINITE: roads sit on a jittered lattice and every block is a
+  pure function of (seed, coordinates), so `generateRegion()` can materialize
+  any window of it; `js/world.js` slides a 160×160 window around the player
+  (regen ~3ms, bit-identical overlap, so recentring is invisible).
 - **The sim** — `js/sim.js`, the shared gameplay core: player (on foot or
   driving), civilian traffic, pedestrians, police + wanted stars, delivery
   missions + money, radio stations, and BFS GPS routing.
@@ -24,7 +28,10 @@ python3 serve.py 8670
 ```
 
 http://localhost:8670 — click to walk. WASD move, mouse look, shift run,
-M minimap, N new seed, 1-4 glyph size, arrows work without pointer lock.
+F or left-click shoots, E enters/exits cars, V toggles third person,
+M minimap, N new seed, 1-4 glyph size. Police respond to crimes by default
+(`engine.police: false` for a peaceful city; `engine.missions: true` adds
+deliveries and money).
 
 ## Run — terminal
 
@@ -32,7 +39,9 @@ M minimap, N new seed, 1-4 glyph size, arrows work without pointer lock.
 npx . # from the repo, or: npm i -g . && ascii-city
 ```
 
-Same city, same raycaster, rendered as ANSI truecolor cells. In terminals
+Same city, same raycaster, rendered as ANSI truecolor cells. V toggles a
+third-person chase cam, F fires (hold in kitty terminals), E jacks cars,
+and the HUD shows a speedometer while driving. In terminals
 with the kitty keyboard protocol (iTerm2, Ghostty, kitty, WezTerm) you get
 real hold-to-move: hold WASD, shift to run, hold arrows or drag the mouse
 to look. Elsewhere (e.g. Terminal.app, which never reports key releases)

package/js/citygen.js

@@ -1,8 +1,10 @@
 // citygen.js — the city factory.
 //
-// generateCity(config) -> CityModel. Pure data out, no rendering, fully
-// deterministic from config.seed. The model (cells + heightMap + buildings)
-// is what the future first-person raycast engine will consume.
+// The city is INFINITE and deterministic: every road, block, and building is a
+// pure function of (seed, world coordinates). generateRegion() materializes any
+// rectangular window of it; generateCity() is the finite wrapper the debug page
+// uses. Roads live on a jittered lattice (avenue k sits at k*spacing + hash
+// jitter), so "what is at (x,z)?" never depends on anything far away.
 //
 // Fully ASCII: every configurable glyph must be printable ASCII (0x20–0x7E);
 // assertAscii() warns if a config breaks that.
@@ -19,25 +21,25 @@ export const AXIS_V = 1, AXIS_H = 2, CENTER_V = 4, CENTER_H = 8;
 
 export const DEFAULT_CONFIG = {
   seed: 'neon-sector-101',
-  size: { width: 160, depth: 120 },
+  size: { width: 160, depth: 120 }, // finite mode (debug page) only
 
   roads: {
     avenueSpacing: [30, 44],
     streetSpacing: [13, 20],
     avenueWidth: 5,
     streetWidth: 3,
-    jitter: 0.5, // 0 = even spacing, 1 = full range
+    jitter: 0.5, // 0 = even lattice, 1 = full range
   },
 
-  // weight: share of blocks. centerBias > 0 pulls toward the center, < 0 to the edge.
+  // weight: share of blocks; clustering comes from each district's noise field.
   districts: {
     noiseScale: 26,
     types: {
-      downtown:    { weight: 0.9,  centerBias:  1.2, height: [16, 52], parcelSize: 20, setback: [1, 2], fill: 0.9,  windowDensity: 0.6,  wallGlyph: '#', wallRamp: '@#%*+=:.', landmarkChance: 0.08 },
-      commercial:  { weight: 1.1,  centerBias:  0.5, height: [8, 20],  parcelSize: 12, setback: [1, 2], fill: 0.85, windowDensity: 0.5,  wallGlyph: '%', wallRamp: '&%#*+~;.', landmarkChance: 0.02 },
-      residential: { weight: 1.0,  centerBias: -0.2, height: [3, 9],   parcelSize: 8,  setback: [1, 3], fill: 0.75, windowDensity: 0.35, wallGlyph: ':', wallRamp: '#x*+=;:.', landmarkChance: 0 },
-      industrial:  { weight: 0.9,  centerBias: -1.0, height: [3, 7],   parcelSize: 16, setback: [1, 2], fill: 0.8,  windowDensity: 0.18, wallGlyph: '=', wallRamp: 'W#%*+~-.', landmarkChance: 0 },
-      park:        { weight: 0.7,  centerBias: -0.1 },
+      downtown:    { weight: 0.9,  height: [16, 52], parcelSize: 20, setback: [1, 2], fill: 0.9,  windowDensity: 0.6,  wallGlyph: '#', wallRamp: '@#%*+=:.', landmarkChance: 0.08 },
+      commercial:  { weight: 1.1,  height: [8, 20],  parcelSize: 12, setback: [1, 2], fill: 0.85, windowDensity: 0.5,  wallGlyph: '%', wallRamp: '&%#*+~;.', landmarkChance: 0.02 },
+      residential: { weight: 1.0,  height: [3, 9],   parcelSize: 8,  setback: [1, 3], fill: 0.75, windowDensity: 0.35, wallGlyph: ':', wallRamp: '#x*+=;:.', landmarkChance: 0 },
+      industrial:  { weight: 0.9,  height: [3, 7],   parcelSize: 16, setback: [1, 2], fill: 0.8,  windowDensity: 0.18, wallGlyph: '=', wallRamp: 'W#%*+~-.', landmarkChance: 0 },
+      park:        { weight: 0.7 },
     },
   },
 
@@ -110,45 +112,51 @@ export function assertAscii(config) {
   if (bad.length) console.warn('[citygen] non-ASCII glyphs configured:', bad.join(' '));
 }
 
-const gapFrom = (rng, [a, b], jitter) => {
-  const mid = (a + b) / 2;
-  return Math.max(3, Math.round(mid + rng.range(-0.5, 0.5) * jitter * (b - a)));
-};
-
-// Road left-edge positions along one axis: avenues first, streets fill the bands.
-function roadPlan(rng, total, roads) {
-  const list = [];
-  const avPos = [];
-  let x = Math.round(rng.range(roads.avenueSpacing[0] * 0.4, roads.avenueSpacing[1] * 0.9));
-  while (x < total - roads.avenueSpacing[0] * 0.5) {
-    avPos.push(x);
-    list.push({ pos: x, w: roads.avenueWidth, avenue: true });
-    x += gapFrom(rng, roads.avenueSpacing, roads.jitter) + roads.avenueWidth;
-  }
-  const bands = [];
-  let prev = 0;
-  for (const p of avPos) { bands.push([prev, p]); prev = p + roads.avenueWidth; }
-  bands.push([prev, total]);
-  const [smin, smax] = roads.streetSpacing;
-  for (const [b0, b1] of bands) {
-    let s = b0 + Math.round(rng.range(smin * 0.7, smax));
-    while (s + roads.streetWidth < b1 - smin * 0.4) {
-      list.push({ pos: s, w: roads.streetWidth, avenue: false });
-      s += gapFrom(rng, roads.streetSpacing, roads.jitter) + roads.streetWidth;
+// --- the road lattice: cut positions as pure functions of their index -----------
+
+// All road cuts (left edges) along one axis whose span intersects [lo, hi].
+// Avenues sit on a jittered lattice; streets subdivide each avenue band evenly,
+// each jittered by its own hash. Deterministic for any range, any order.
+function axisCuts(seed, axis, lo, hi, roads) {
+  const [aMin, aMax] = roads.avenueSpacing;
+  const pitch = (aMin + aMax) / 2 + roads.avenueWidth;      // avenue-to-avenue pitch
+  const jA = roads.jitter * (aMax - aMin) * 0.5;
+  const k0 = Math.floor(lo / pitch) - 2;
+  const k1 = Math.ceil(hi / pitch) + 2;
+  const avePos = k => Math.round(k * pitch + (hash01(seed, axis, 'av', k) - 0.5) * 2 * jA);
+  const cuts = [];
+  for (let k = k0; k <= k1; k++) {
+    const a0 = avePos(k), a1 = avePos(k + 1);
+    cuts.push({ pos: a0, w: roads.avenueWidth, avenue: true });
+    // streets in the band (a0+width .. a1)
+    const s0 = a0 + roads.avenueWidth;
+    const L = a1 - s0;
+    const [sMin, sMax] = roads.streetSpacing;
+    const sPitch = (sMin + sMax) / 2 + roads.streetWidth;
+    const n = Math.max(0, Math.round(L / sPitch) - 1);
+    const jS = Math.max(0, Math.min(roads.jitter * (sMax - sMin) * 0.5, L / (n + 1) / 2 - roads.streetWidth));
+    for (let j = 1; j <= n; j++) {
+      let pos = Math.round(s0 + (L * j) / (n + 1) + (hash01(seed, axis, 'st', k, j) - 0.5) * 2 * jS);
+      pos = Math.max(s0 + 3, Math.min(a1 - roads.streetWidth - 3, pos));
+      cuts.push({ pos, w: roads.streetWidth, avenue: false });
     }
   }
-  return list.sort((a, b) => a.pos - b.pos);
+  cuts.sort((a, b) => a.pos - b.pos);
+  // drop any accidental overlaps (extreme configs)
+  const out = [];
+  for (const c of cuts) {
+    if (!out.length || c.pos >= out[out.length - 1].pos + out[out.length - 1].w + 3) out.push(c);
+  }
+  return out.filter(c => c.pos + c.w > lo && c.pos < hi);
 }
 
-// Block intervals between road spans on one axis.
-function intervals(total, roadsList) {
+// Block intervals (world coords) between road spans on one axis.
+function intervals(cuts) {
   const iv = [];
-  let prev = 0;
-  for (const r of roadsList) {
-    if (r.pos > prev) iv.push([prev, r.pos]);
-    prev = Math.max(prev, r.pos + r.w);
+  for (let i = 0; i + 1 < cuts.length; i++) {
+    const a = cuts[i].pos + cuts[i].w, b = cuts[i + 1].pos;
+    if (b > a) iv.push([a, b]);
   }
-  if (prev < total) iv.push([prev, total]);
   return iv;
 }
 
@@ -173,92 +181,110 @@ function subdivide(rng, rect, target, minSide) {
   return out;
 }
 
-export function generateCity(userConfig = {}) {
+// --- region generation ------------------------------------------------------------
+
+// Materialize the window [rx, rx+rw) x [rz, rz+rd) of the infinite city.
+// Cell arrays are local to the window; buildings/trees/fountains/blocks carry
+// WORLD coordinates. model.ox/oz is the window origin.
+export function generateRegion(userConfig, rx, rz, rw, rd) {
   const t0 = performance.now();
-  const config = mergeConfig(DEFAULT_CONFIG, userConfig);
+  const config = userConfig.__merged ? userConfig : mergeConfig(DEFAULT_CONFIG, userConfig);
+  config.__merged = true;
   assertAscii(config);
   const seed = String(config.seed);
-  const W = config.size.width | 0, D = config.size.depth | 0;
-  const N = W * D;
+  const M = 64; // margin: catches any block overlapping the window edge
 
-  const cells = new Uint8Array(N);          // CELL.*
-  const roadAxis = new Uint8Array(N);       // AXIS_* flags
+  const N = rw * rd;
+  const cells = new Uint8Array(N);
+  const roadAxis = new Uint8Array(N);
   const heightMap = new Uint16Array(N);
   const bIndex = new Int32Array(N).fill(-1);
-  const idx = (x, z) => z * W + x;
-
-  // --- roads ---------------------------------------------------------------
-  const vRoads = roadPlan(rngStream(seed, 'roads-x'), W, config.roads);
-  const hRoads = roadPlan(rngStream(seed, 'roads-z'), D, config.roads);
-  for (const r of vRoads) {
-    const type = r.avenue ? CELL.AVENUE : CELL.STREET;
-    const center = r.pos + (r.w >> 1);
-    for (let x = r.pos; x < r.pos + r.w && x < W; x++) {
-      for (let z = 0; z < D; z++) {
-        const i = idx(x, z);
+  const inR = (x, z) => x >= rx && z >= rz && x < rx + rw && z < rz + rd;
+  const li = (x, z) => (z - rz) * rw + (x - rx);
+
+  const xCuts = axisCuts(seed, 'x', rx - M, rx + rw + M, config.roads);
+  const zCuts = axisCuts(seed, 'z', rz - M, rz + rd + M, config.roads);
+
+  // --- roads -----------------------------------------------------------------
+  for (const c of xCuts) { // vertical roads
+    const type = c.avenue ? CELL.AVENUE : CELL.STREET;
+    const center = c.pos + (c.w >> 1);
+    for (let x = Math.max(c.pos, rx); x < Math.min(c.pos + c.w, rx + rw); x++) {
+      for (let z = rz; z < rz + rd; z++) {
+        const i = li(x, z);
         cells[i] = Math.max(cells[i], type);
         roadAxis[i] |= AXIS_V | (x === center ? CENTER_V : 0);
       }
     }
   }
-  for (const r of hRoads) {
-    const type = r.avenue ? CELL.AVENUE : CELL.STREET;
-    const center = r.pos + (r.w >> 1);
-    for (let z = r.pos; z < r.pos + r.w && z < D; z++) {
-      for (let x = 0; x < W; x++) {
-        const i = idx(x, z);
+  for (const c of zCuts) { // horizontal roads
+    const type = c.avenue ? CELL.AVENUE : CELL.STREET;
+    const center = c.pos + (c.w >> 1);
+    for (let z = Math.max(c.pos, rz); z < Math.min(c.pos + c.w, rz + rd); z++) {
+      for (let x = rx; x < rx + rw; x++) {
+        const i = li(x, z);
         cells[i] = Math.max(cells[i], type);
         roadAxis[i] |= AXIS_H | (z === center ? CENTER_H : 0);
       }
     }
   }
 
-  // --- blocks + districts ---------------------------------------------------
-  const xIv = intervals(W, vRoads);
-  const zIv = intervals(D, hRoads);
+  // --- blocks + districts --------------------------------------------------------
+  const xIv = intervals(xCuts);
+  const zIv = intervals(zCuts);
   const typeNames = Object.keys(config.districts.types);
   const noiseFns = {};
   for (const name of typeNames) {
     noiseFns[name] = makeValueNoise(seed + ' district ' + name, config.districts.noiseScale);
   }
 
-  const blocks = [];
   const minBlock = config.blocks.minSide;
-  for (const [zx0, zx1] of zIv) {
+  const blocks = [];
+  for (const [z0, z1] of zIv) {
     for (const [x0, x1] of xIv) {
-      const w = x1 - x0, d = zx1 - zx0;
-      if (w < minBlock || d < minBlock) continue; // sliver stays LOT
-      const cx = x0 + w / 2, cz = zx0 + d / 2;
-      const dist = Math.hypot(cx - W / 2, cz - D / 2) / Math.hypot(W / 2, D / 2); // 0 center..1 corner
+      const w = x1 - x0, d = z1 - z0;
+      if (w < minBlock || d < minBlock) continue;
+      if (x1 <= rx || z1 <= rz || x0 >= rx + rw || z0 >= rz + rd) continue; // outside window
+      const cx = x0 + w / 2, cz = z0 + d / 2;
       let best = typeNames[0], bestScore = -1;
       for (const name of typeNames) {
         const t = config.districts.types[name];
-        const bias = Math.max(0.05, 1 + (t.centerBias ?? 0) * (0.5 - dist));
-        const score = (t.weight ?? 1) * bias * (0.3 + 1.4 * noiseFns[name](cx, cz));
+        const score = (t.weight ?? 1) * (0.3 + 1.4 * noiseFns[name](cx, cz));
         if (score > bestScore) { bestScore = score; best = name; }
       }
-      blocks.push({ x: x0, z: zx0, w, d, district: best, kind: 'built' });
+      blocks.push({ x: x0, z: z0, w, d, district: best, kind: 'built' });
     }
   }
 
-  // --- fill blocks -----------------------------------------------------------
+  // sidewalk lookup for the street-tree spacing rule (pure, order-free)
+  const findIv = (iv, v) => {
+    for (const [a, b] of iv) if (v >= a && v < b) return [a, b];
+    return null;
+  };
+  const isSidewalk = (x, z) => {
+    const bx = findIv(xIv, x), bz = findIv(zIv, z);
+    if (!bx || !bz) return false;
+    if (bx[1] - bx[0] < minBlock || bz[1] - bz[0] < minBlock) return false;
+    return x === bx[0] || x === bx[1] - 1 || z === bz[0] || z === bz[1] - 1;
+  };
+
+  // --- fill blocks ---------------------------------------------------------------
   const buildings = [];
   const fountains = [];
-  const G = config.glyphs;
   const B = config.buildings;
+  const setCell = (x, z, v) => { if (inR(x, z)) cells[li(x, z)] = v; };
 
   for (const blk of blocks) {
     const rng = rngStream(seed, 'block ' + blk.x + ',' + blk.z);
     const dcfg = config.districts.types[blk.district];
 
-    // sidewalk ring
     for (let x = blk.x; x < blk.x + blk.w; x++) {
-      cells[idx(x, blk.z)] = CELL.SIDEWALK;
-      cells[idx(x, blk.z + blk.d - 1)] = CELL.SIDEWALK;
+      setCell(x, blk.z, CELL.SIDEWALK);
+      setCell(x, blk.z + blk.d - 1, CELL.SIDEWALK);
     }
     for (let z = blk.z; z < blk.z + blk.d; z++) {
-      cells[idx(blk.x, z)] = CELL.SIDEWALK;
-      cells[idx(blk.x + blk.w - 1, z)] = CELL.SIDEWALK;
+      setCell(blk.x, z, CELL.SIDEWALK);
+      setCell(blk.x + blk.w - 1, z, CELL.SIDEWALK);
     }
 
     const inner = { x: blk.x + 1, z: blk.z + 1, w: blk.w - 2, d: blk.d - 2 };
@@ -266,47 +292,48 @@ export function generateCity(userConfig = {}) {
 
     if (blk.district === 'park') {
       blk.kind = 'park';
-      for (let z = inner.z; z < inner.z + inner.d; z++) {
-        for (let x = inner.x; x < inner.x + inner.w; x++) {
-          const i = idx(x, z);
-          let tree = hash01(seed, 'tree', x, z) < config.props.treeDensity;
-          // keep trees at least 2 cells apart (checked against already-placed neighbors)
-          if (tree && x > inner.x && cells[idx(x - 1, z)] === CELL.TREE) tree = false;
-          if (tree && z > inner.z && (
-            cells[idx(x, z - 1)] === CELL.TREE ||
-            (x > inner.x && cells[idx(x - 1, z - 1)] === CELL.TREE) ||
-            (x < inner.x + inner.w - 1 && cells[idx(x + 1, z - 1)] === CELL.TREE)
+      // plant on a block-local grid so spacing decisions never depend on the window
+      const tmp = new Uint8Array(inner.w * inner.d);
+      for (let z = 0; z < inner.d; z++) {
+        for (let x = 0; x < inner.w; x++) {
+          const wx = inner.x + x, wz = inner.z + z;
+          let tree = hash01(seed, 'tree', wx, wz) < config.props.treeDensity;
+          if (tree && x > 0 && tmp[z * inner.w + x - 1]) tree = false;
+          if (tree && z > 0 && (
+            tmp[(z - 1) * inner.w + x] ||
+            (x > 0 && tmp[(z - 1) * inner.w + x - 1]) ||
+            (x < inner.w - 1 && tmp[(z - 1) * inner.w + x + 1])
           )) tree = false;
-          cells[i] = tree ? CELL.TREE : CELL.PARK;
+          tmp[z * inner.w + x] = tree ? 1 : 0;
+          setCell(wx, wz, tree ? CELL.TREE : CELL.PARK);
         }
       }
-      // cross paths through the middle
       const px = inner.x + (inner.w >> 1), pz = inner.z + (inner.d >> 1);
-      for (let x = inner.x; x < inner.x + inner.w; x++) cells[idx(x, pz)] = CELL.PLAZA;
-      for (let z = inner.z; z < inner.z + inner.d; z++) cells[idx(px, z)] = CELL.PLAZA;
+      for (let x = inner.x; x < inner.x + inner.w; x++) setCell(x, pz, CELL.PLAZA);
+      for (let z = inner.z; z < inner.z + inner.d; z++) setCell(px, z, CELL.PLAZA);
       continue;
     }
 
     if (rng.chance(config.blocks.plazaChance)) {
       blk.kind = 'plaza';
       for (let z = inner.z; z < inner.z + inner.d; z++) {
-        for (let x = inner.x; x < inner.x + inner.w; x++) cells[idx(x, z)] = CELL.PLAZA;
+        for (let x = inner.x; x < inner.x + inner.w; x++) setCell(x, z, CELL.PLAZA);
       }
       fountains.push({ x: inner.x + (inner.w >> 1), z: inner.z + (inner.d >> 1) });
       for (const [cx2, cz2] of [[inner.x, inner.z], [inner.x + inner.w - 1, inner.z], [inner.x, inner.z + inner.d - 1], [inner.x + inner.w - 1, inner.z + inner.d - 1]]) {
-        if (rng.chance(0.5)) cells[idx(cx2, cz2)] = CELL.TREE;
+        if (rng.chance(0.5)) setCell(cx2, cz2, CELL.TREE);
       }
       continue;
     }
 
     // parcels -> buildings
     const parcels = subdivide(rng, inner, dcfg.parcelSize ?? 12, Math.max(4, B.minSide + 2));
-    for (const p of parcels) {
-      const brng = rngStream(seed, 'bldg ' + p.x + ',' + p.z);
-      if (!brng.chance(dcfg.fill ?? 0.8)) continue; // vacant lot
+    for (const pcl of parcels) {
+      const brng = rngStream(seed, 'bldg ' + pcl.x + ',' + pcl.z);
+      if (!brng.chance(dcfg.fill ?? 0.8)) continue;
       const sb = brng.int(dcfg.setback?.[0] ?? 1, dcfg.setback?.[1] ?? 2);
-      const bx = p.x + sb, bz = p.z + sb;
-      const bw = p.w - sb * 2, bd = p.d - sb * 2;
+      const bx = pcl.x + sb, bz = pcl.z + sb;
+      const bw = pcl.w - sb * 2, bd = pcl.d - sb * 2;
       if (bw < B.minSide || bd < B.minSide) continue;
 
       const [h0, h1] = dcfg.height ?? [3, 8];
@@ -320,8 +347,8 @@ export function generateCity(userConfig = {}) {
       const tiers = [{ inset: 0, h }];
       if (h >= 14 && brng.chance(B.tieredChance)) {
         let inset = 0, top = h;
-        const n = brng.int(1, 2);
-        for (let t = 0; t < n; t++) {
+        const nT = brng.int(1, 2);
+        for (let t = 0; t < nT; t++) {
           inset += brng.int(1, 2);
           if (bw - inset * 2 < 3 || bd - inset * 2 < 3) break;
           top += brng.int(4, 10);
@@ -330,9 +357,10 @@ export function generateCity(userConfig = {}) {
       }
       const height = tiers[tiers.length - 1].h;
 
-      const id = buildings.length;
+      const idx = buildings.length;
       buildings.push({
-        id, x: bx, z: bz, w: bw, d: bd,
+        id: bx * 92821 + bz, // stable across any window
+        x: bx, z: bz, w: bw, d: bd,
         district: blk.district, height, tiers, landmark,
         windowDensity: Math.min(1, (dcfg.windowDensity ?? 0.4) * B.windowScale * brng.range(0.75, 1.15)),
         litIdx: brng.int(0, 3),
@@ -341,17 +369,17 @@ export function generateCity(userConfig = {}) {
         antenna: landmark || (height >= 18 && brng.chance(B.antennaChance)),
       });
 
-      for (let z = bz; z < bz + bd; z++) {
-        for (let x = bx; x < bx + bw; x++) {
-          const i = idx(x, z);
+      for (let z = Math.max(bz, rz); z < Math.min(bz + bd, rz + rd); z++) {
+        for (let x = Math.max(bx, rx); x < Math.min(bx + bw, rx + rw); x++) {
+          const i = li(x, z);
           cells[i] = CELL.BUILDING;
-          bIndex[i] = id;
+          bIndex[i] = idx;
         }
       }
       for (const t of tiers) {
-        for (let z = bz + t.inset; z < bz + bd - t.inset; z++) {
-          for (let x = bx + t.inset; x < bx + bw - t.inset; x++) {
-            const i = idx(x, z);
+        for (let z = Math.max(bz + t.inset, rz); z < Math.min(bz + bd - t.inset, rz + rd); z++) {
+          for (let x = Math.max(bx + t.inset, rx); x < Math.min(bx + bw - t.inset, rx + rw); x++) {
+            const i = li(x, z);
             if (t.h > heightMap[i]) heightMap[i] = t.h;
           }
         }
@@ -359,41 +387,39 @@ export function generateCity(userConfig = {}) {
     }
   }
 
-  // --- props ------------------------------------------------------------------
+  // --- street trees + tree list ------------------------------------------------------
+  const stChance = config.props.streetTreeChance;
+  const candidate = (x, z) => isSidewalk(x, z) && hash01(seed, 'streettree', x, z) < stChance;
   const trees = [];
-  for (let z = 0; z < D; z++) {
-    for (let x = 0; x < W; x++) {
-      const i = idx(x, z);
-      if (cells[i] === CELL.SIDEWALK && hash01(seed, 'streettree', x, z) < config.props.streetTreeChance) {
-        let clear = true;
-        for (let dz2 = -2; dz2 <= 0 && clear; dz2++) {
-          for (let dx2 = -2; dx2 <= 2; dx2++) {
-            if (dz2 === 0 && dx2 >= 0) break; // only cells already scanned
-            const nx = x + dx2, nz = z + dz2;
-            if (nx >= 0 && nx < W && nz >= 0 && cells[nz * W + nx] === CELL.TREE) { clear = false; break; }
-          }
-        }
-        if (clear) cells[i] = CELL.TREE;
+  for (let z = rz; z < rz + rd; z++) {
+    for (let x = rx; x < rx + rw; x++) {
+      const i = li(x, z);
+      if (cells[i] === CELL.SIDEWALK && candidate(x, z) &&
+          !candidate(x - 1, z) && !candidate(x - 2, z) &&
+          !candidate(x, z - 1) && !candidate(x, z - 2) &&
+          !candidate(x - 1, z - 1) && !candidate(x + 1, z - 1)) {
+        cells[i] = CELL.TREE;
       }
       if (cells[i] === CELL.TREE) {
         heightMap[i] = Math.max(heightMap[i], 2);
         trees.push({
           x, z,
-          h: 1.2 + 0.8 * hash01(seed, 'treeh', x, z),   // total height in storeys — game scale
-          r: 0.3 + 0.2 * hash01(seed, 'treer', x, z),   // canopy radius in cells
+          h: 1.2 + 0.8 * hash01(seed, 'treeh', x, z),
+          r: 0.3 + 0.2 * hash01(seed, 'treer', x, z),
         });
       }
     }
   }
 
-  // --- stats ------------------------------------------------------------------
+  // --- stats ----------------------------------------------------------------------
   const byDistrict = {};
   for (const b of blocks) byDistrict[b.district] = (byDistrict[b.district] ?? 0) + 1;
   let tallest = 0;
   for (const b of buildings) tallest = Math.max(tallest, b.height);
 
   return {
-    config, seed, width: W, depth: D,
+    config, seed,
+    ox: rx, oz: rz, width: rw, depth: rd,
     cells, roadAxis, heightMap, bIndex,
     blocks, buildings, trees, fountains,
     stats: {
@@ -406,3 +432,9 @@ export function generateCity(userConfig = {}) {
     },
   };
 }
+
+// Finite wrapper (debug page, skyline probe, tests).
+export function generateCity(userConfig = {}) {
+  const config = mergeConfig(DEFAULT_CONFIG, userConfig);
+  return generateRegion(config, 0, 0, config.size.width | 0, config.size.depth | 0);
+}

package/js/config.js

@@ -5,6 +5,7 @@
 export const CITY_SPEC = {
   city: {
     seed: 'neon-sector-101',
+    // the city is INFINITE in the walker/TUI; size only bounds the debug page
     size: { width: 160, depth: 120 },
   },
 
@@ -17,6 +18,7 @@ export const CITY_SPEC = {
     walkSpeed: 4.5,    // cells per second
     runMult: 2.4,
     mouseSens: 0.0023,
-    game: false,       // true = GTA mode: missions, money, wanted stars, cops
+    police: true,      // wanted stars + cops respond to crimes
+    missions: false,   // deliveries + money + GPS ('game: true' turns both on)
   },
 };

package/js/render_map.js

@@ -7,6 +7,7 @@ import { shade } from './palettes.js';
 
 export function renderMap(canvas, model, atlas, pal) {
   const { width: W, depth: D, cells, roadAxis, heightMap, bIndex, buildings, seed } = model;
+  const ox = model.ox ?? 0, oz = model.oz ?? 0;
   const G = model.config.glyphs;
   canvas.width = W * atlas.cw;
   canvas.height = D * atlas.ch;
@@ -57,13 +58,13 @@ export function renderMap(canvas, model, atlas, pal) {
           const ax = roadAxis[i];
           const crossing = (ax & AXIS_V) && (ax & AXIS_H);
           if (!crossing) {
-            if ((ax & CENTER_V) && z % 4 < 2) { ch = '|'; col = pal.lane; }
-            else if ((ax & CENTER_H) && x % 4 < 2) { ch = '-'; col = pal.lane; }
+            if ((ax & CENTER_V) && ((z + oz) & 3) < 2) { ch = '|'; col = pal.lane; }
+            else if ((ax & CENTER_H) && ((x + ox) & 3) < 2) { ch = '-'; col = pal.lane; }
           }
           break;
         }
         case CELL.STREET:
-          if (hash01(seed, 'tex', x, z) < 0.15) { ch = '.'; col = pal.road; }
+          if (hash01(seed, 'tex', x + ox, z + oz) < 0.15) { ch = '.'; col = pal.road; }
           break;
         case CELL.SIDEWALK:
           ch = G.sidewalk; col = pal.sidewalk;
@@ -76,7 +77,7 @@ export function renderMap(canvas, model, atlas, pal) {
           break;
         }
         case CELL.PARK:
-          ch = G.grass[Math.floor(hash01(seed, 'grass', x, z) * G.grass.length)];
+          ch = G.grass[Math.floor(hash01(seed, 'grass', x + ox, z + oz) * G.grass.length)];
           col = pal.park;
           break;
         case CELL.TREE:
@@ -86,11 +87,11 @@ export function renderMap(canvas, model, atlas, pal) {
           ch = G.plaza; col = pal.plaza;
           break;
         default: // LOT
-          if (hash01(seed, 'lot', x, z) < 0.3) { ch = G.lot; col = pal.lot; }
+          if (hash01(seed, 'lot', x + ox, z + oz) < 0.3) { ch = G.lot; col = pal.lot; }
       }
       if (ch !== ' ') atlas.draw(ctx, ch, col, x, z);
     }
   }
 
-  for (const f of model.fountains) atlas.draw(ctx, G.fountain, pal.fountain, f.x, f.z);
+  for (const f of model.fountains) atlas.draw(ctx, G.fountain, pal.fountain, f.x - ox, f.z - oz);
 }

package/js/render_skyline.js

@@ -13,6 +13,7 @@ const BANDS = [
 
 export function renderSkyline(canvas, model, atlas, pal) {
   const { width: W, depth: D, buildings, seed } = model;
+  const ox = model.ox ?? 0, oz = model.oz ?? 0;
   const G = model.config.glyphs;
 
   let maxH = 6;
@@ -48,7 +49,7 @@ export function renderSkyline(canvas, model, atlas, pal) {
 
   const sorted = buildings.slice().sort((a, b) => a.z - b.z); // far first
   for (const b of sorted) {
-    const frac = (b.z + b.d / 2) / D;
+    const frac = (b.z - oz + b.d / 2) / D;
     const band = BANDS[frac < 0.34 ? 0 : frac < 0.67 ? 1 : 2];
     const br = band.brightness;
     const wallC = shade(pal.districts[b.district] ?? pal.wall, 0.5 * br);
@@ -59,7 +60,7 @@ export function renderSkyline(canvas, model, atlas, pal) {
     const skyBgC = shade(pal.sky[1], 0.9); // fill behind glyphs so far layers get occluded
 
     for (const tier of b.tiers) {
-      const tx = b.x + tier.inset;
+      const tx = b.x - ox + tier.inset;
       const tw = b.w - tier.inset * 2;
       if (tw < 1) continue;
       const th = Math.min(tier.h, rows - band.lift - 2);
@@ -95,7 +96,7 @@ export function renderSkyline(canvas, model, atlas, pal) {
     }
 
     if (b.antenna) {
-      const ax = b.x + (b.w >> 1);
+      const ax = b.x - ox + (b.w >> 1);
       const topY = ground - band.lift - Math.min(b.height, rows - band.lift - 2) - 1;
       if (topY - 2 >= 0 && ax >= 0 && ax < W) {
         atlas.draw(ctx, '|', edgeC, ax, topY - 1);