From cf9ab5e77414625ece04ebdd8eadd7a2f57bdfb1 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Wed, 4 Nov 2026 11:37:27 +0100 Subject: [PATCH 01/23] Draw the map with WebGL2 by default, with the 2D canvas as fallback - Sea, land, waves, clouds, cables, tubes and packets are drawn by the graphics card; the land is geometry built once, so panning and zooming repaint nothing. - Cities, labels and markers are painted once into a sprite atlas and drawn in one call (with drawImage in 2D, which speeds up the 2D map too). - Settings > Map drawing: Auto or Always 2D, per device. Browsers without WebGL2, a lost context and puzzles keep the 2D map. - npm run bench:gpu compares 2D and WebGL in a real browser on a real GPU; ?fps shows a frame meter. --- CHANGELOG.md | 3 + docs/ARCHITECTURE.md | 3 +- package.json | 1 + scripts/gpu-bench.js | 56 +++++++ scripts/lib/fuzz-page.js | 2 +- scripts/lib/gpu-bench-client.js | 96 ++++++++++++ site/i18n/de.js | 4 + site/i18n/es.js | 4 + site/i18n/fr.js | 4 + site/i18n/it.js | 4 + site/i18n/pt.js | 4 + src/agent/20-commands.js | 2 +- src/game/90-actions/10-interface.js | 1 + src/game/90-actions/95-puzzles.js | 2 +- src/game/96-map/10-canvas.js | 3 +- src/game/96-map/30-settings.js | 1 + src/game/96-map/50-link-geometry.js | 9 +- src/game/96-map/55-link-look.js | 17 +++ src/game/96-map/56-webgl.js | 59 ++++++++ src/game/96-map/57-webgl-background.js | 93 ++++++++++++ src/game/96-map/58-webgl-links.js | 86 +++++++++++ src/game/96-map/59-gl-sprites.js | 76 ++++++++++ src/game/96-map/60-draw.js | 51 ++++--- src/game/96-map/70-world-layer.js | 6 +- src/game/96-map/80-cities.js | 119 ++++++++++----- src/game/96-map/88-cable-ships.js | 6 +- src/game/96-map/95-clicks.js | 2 +- src/game/96-map/97-fps-meter.js | 11 ++ src/game/99-loop.js | 7 +- src/i18n/en.js | 4 + src/index.html | 1 + src/styles/00-base.css | 2 + tests/cable-labels.test.js | 2 +- tests/regions.test.js | 3 +- tests/speed.test.js | 6 +- tests/webgl-map.test.js | 195 +++++++++++++++++++++++++ 36 files changed, 862 insertions(+), 83 deletions(-) create mode 100644 scripts/gpu-bench.js create mode 100644 scripts/lib/gpu-bench-client.js create mode 100644 src/game/96-map/55-link-look.js create mode 100644 src/game/96-map/56-webgl.js create mode 100644 src/game/96-map/57-webgl-background.js create mode 100644 src/game/96-map/58-webgl-links.js create mode 100644 src/game/96-map/59-gl-sprites.js create mode 100644 src/game/96-map/97-fps-meter.js create mode 100644 tests/webgl-map.test.js diff --git a/CHANGELOG.md b/CHANGELOG.md index b10e1f4..a076f4e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,9 @@ All notable changes to this project are documented here. The project follows - The NOC charts have tooltips, on the dashboard and on the wallboard in the NOC window: hover (or touch) a chart to see every series on that day, with a total. Click an entry in the legend to hide or show that series, and the scale follows what is left. The "how it arrives" bars on the Traffic tab show the same kind of tooltip, and its legend picks which ways in (caches, PNIs, IX peering, transit) the table counts. - Bilbao joins the map, where the transatlantic cables really come ashore: Marea Carey, Grace Hopscotch and Sol Survivor now land there instead of Madrid. It has no exchange of its own, so traffic heads inland to Madrid, and Drizzle Electric, Tangerine Telecom and the big carriers sell transit there. A link you already run on the old Madrid landings keeps working as a plain subsea link, and the Mid-Atlantic Accent scenario now goes Azores, Bilbao, Madrid, and Marea Carey now leaves the American coast at Virginia Beach instead of crossing the northeast to New Jersey. Columbus III-and-a-half now comes ashore near Cádiz, where it really landed, on its way to Madrid. - Puzzles are easier to read, above all on phones: the three stars are now three goals in plain words, and the one you are working on says what is wrong and what to do, with a Show me button. The map marks it too: a red ring around a city that still needs traffic, and a pulsing ✂ on a link whose cut would hurt. On phones the sheet starts small so the map gets the screen; swipe it up for the rest. Cities far from the puzzle are left off the map, and stepping stones you are not using are small dots without a name until you tap one, build there or zoom in. +- The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same; Settings › Map drawing › Always 2D keeps the old drawing, and browsers without WebGL2 keep it on their own. +- Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the usual map also draws far fewer shapes each frame. + ## [2.9.1] — 2026-11-04 - Jokes in the game now poke fun at networks, cables and routers, never at people, countries or beliefs. A few networks have new names (Atlas Hold-the-Line Telecom, Star-Blink, Telekom Malay-tency, Oh Yas Sénégal, Afghan Tele-Pass, Island-Hop Micronesia, Tel-One-derful, Tango Two-Step), so do three of the names for your own cables, and about forty descriptions of networks, cities, cables and events were rewritten. diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index f067aa0..6b2d383 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -41,7 +41,7 @@ hoisted across files, and top-level statements run in path order. Find code by n | `93-ui/` | DOM helpers (`$`, `btn`, `morph`), the phone tab bar, install pitch, HUD, left panel, city and link panels, decommissioning | | `94-dashboard/` | Scenario and level progress, where to meet a network, customers and connections overviews, lease swaps, the NOC dashboard and its own window for a second display (`90-noc-window.js`: this page at `?noc=`, a read-only copy of `S` and `R` over a BroadcastChannel, clicks sent back to the game; `91-noc-wall.js`: its wallboard), the bank, hints | | `95-modals/` | Toasts, notifications, modals, title screen, what's new, help, the link and own-cable modals | -| `96-map/` | The canvas: resize, land and clouds, settings, level of detail, link geometry, `draw()`, the world layer, cities, input and click delegation | +| `96-map/` | The canvas: resize, land and clouds, settings, level of detail, link geometry, how each tube looks, the WebGL map (the default, 2D as fallback: context, background, tubes, and the sprite atlas cities, labels and markers are drawn from, in 2D too), `draw()`, the world layer, cities, input and click delegation | | `99-loop.js` | `frame()` and `boot()` | `src/styles/` holds the CSS the same way: base, HUD, drawers, toasts, modal, tablet, then phone. @@ -75,6 +75,7 @@ Development runs on `npm run dev` (assembles the development page on every reque | `scripts/test.js` | `npm test`: runs every `tests/*.test.js` | | `scripts/release-notes.js` | Extracts a version's CHANGELOG bullets | | `scripts/perf-bench.js`, `perf-browser.js`, `perf-stats.js`, `perf-fixture.js` | Big-network benchmark, base vs head, headless and in Chromium as a desktop and a throttled phone, with a significance test per row (posted on every PR by `perf.yml` + `perf-comment.yml`), and the generator of its save, `tests/fixtures/big-network.json` | +| `scripts/gpu-bench.js`, `scripts/lib/gpu-bench-client.js` | `npm run bench:gpu -- --save FILE`: the map in your own browser on your own graphics card, 2D against WebGL, scenario by scenario; the table shows in the page and in the terminal | | `scripts/mcp.js`, `scripts/lib/mcp-game.js`, `scripts/lib/mcp-headless.js`, `src/agent/` | The game as a local MCP server, on the official SDK over stdio or HTTP: typed tools to play, inspect and debug it from an AI client, headless or in the player's own tab ([MCP.md](MCP.md)) | | `scripts/agent/relay.js`, `scripts/lib/mcp-browser.js`, `scripts/lib/relay-client.js` | The agent relay `npm run dev` hosts at `/agent`, and the MCP server's side of it: how a tool reaches the game in the player's tab | | `scripts/i18n-check.js`, `scripts/i18n-add.js`, `scripts/lib/dict.js` | Translation coverage and dictionary order; adding, renaming and removing entries | diff --git a/package.json b/package.json index 997c3d1..41b7083 100644 --- a/package.json +++ b/package.json @@ -19,6 +19,7 @@ "page": "node scripts/lib/page.js", "serve": "npm run build && npx --yes serve@14.2.4 _site", "perf": "node scripts/perf-bench.js", + "bench:gpu": "node scripts/gpu-bench.js", "mcp": "node scripts/mcp.js", "mcp:browser": "node scripts/mcp.js --browser" }, diff --git a/scripts/gpu-bench.js b/scripts/gpu-bench.js new file mode 100644 index 0000000..52cfd8a --- /dev/null +++ b/scripts/gpu-bench.js @@ -0,0 +1,56 @@ +#!/usr/bin/env node +// The map's speed on your own graphics card, 2D against WebGL, in the browser you play in: +// +// npm run bench:gpu -- --save path/to/save.json (an exported save, or a plain one; default: the perf fixture) +// +// then open the printed address in Chrome, Edge or Firefox and press Start. Headless benchmarks (npm run perf) draw the +// canvas in software, so they cannot say what a GPU does; this one runs where the GPU is. Each scenario plays a few +// seconds with the 2D map and with the WebGL tubes, the table shows in the page, and the server prints it here when the +// run ends. Options: --port N (8090), --secs N per scenario (6), --host 0.0.0.0 to open it from a phone on your network, +// --out FILE to also write the table there. Under WSL, the Windows browser reaches http://localhost:PORT as it is. +// In the address: ?only=gl or ?only=2d (one renderer), ?scen=x1-mid,pan (some scenarios), ?dpr=2 (a 4K screen's +// pixels on a smaller one), ?auto (start at once). The game's clock keeps running: incidents do not pause it. +const fs = require('node:fs'); +const os = require('node:os'); +const http = require('node:http'); +const path = require('node:path'); +const { assemble, ROOT } = require('./lib/page'); + +const args = process.argv.slice(2); +const opt = (k, d) => { const i = args.indexOf('--' + k); return i >= 0 ? args[i + 1] : d; }; +const PORT = +opt('port', 8090), HOST = opt('host', 'localhost'), SECS = +opt('secs', 6), OUT = opt('out', null); +const SAVE = path.resolve(opt('save', path.join(ROOT, 'tests', 'fixtures', 'big-network.json'))); +const SITE = path.join(ROOT, 'site'); +const TYPES = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css', '.json': 'application/json', + '.svg': 'image/svg+xml', '.png': 'image/png', '.ico': 'image/x-icon', '.webmanifest': 'application/manifest+json' }; + +// An exported save is {app, version, S}; a plain one is S itself. +const save = (() => { const d = JSON.parse(fs.readFileSync(SAVE, 'utf8')); return JSON.stringify({ S: d && d.S && d.S.pops ? d.S : d }); })(); +const client = fs.readFileSync(path.join(__dirname, 'lib', 'gpu-bench-client.js'), 'utf8'); +const page = () => assemble().html.replace('', ``); + +http.createServer((req, res) => { + const url = new URL(req.url, 'http://localhost'); + try { + if (url.pathname === '/' || url.pathname === '/index.html') { res.writeHead(200, { 'content-type': TYPES['.html'], 'cache-control': 'no-store' }); return res.end(page()); } + if (url.pathname === '/__bench/save.json') { res.writeHead(200, { 'content-type': TYPES['.json'], 'cache-control': 'no-store' }); return res.end(save); } + if (url.pathname === '/__bench/results' && req.method === 'POST') { + let body = ''; req.on('data', (c) => { body += c; }); req.on('end', () => { + try { const r = JSON.parse(body); console.log('\n' + r.md + '\n'); if (OUT) { fs.writeFileSync(OUT, r.md + '\n\n```json\n' + JSON.stringify(r, null, 1) + '\n```\n'); console.log(`(also written to ${OUT})`); } } catch (e) { console.error('bad results', e); } + res.writeHead(204); res.end(); }); + return; + } + // The service worker would cache this page over the real one: none here. + if (url.pathname === '/sw.js') { res.writeHead(404); return res.end(); } + const file = path.join(SITE, path.normalize(decodeURIComponent(url.pathname)).replace(/^([/\\]|\.\.)+/, '')); + if (!file.startsWith(SITE + path.sep) || !fs.statSync(file, { throwIfNoEntry: false })?.isFile()) { res.writeHead(404); return res.end(); } + res.writeHead(200, { 'content-type': TYPES[path.extname(file)] || 'application/octet-stream', 'cache-control': 'no-store' }); + fs.createReadStream(file).pipe(res); + } catch (e) { res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' }); res.end(String(e && e.stack || e)); } +}).listen(PORT, HOST, () => { + const s = JSON.parse(save).S; + console.log(`GPU benchmark: ${path.basename(SAVE)} (${Object.keys(s.pops || {}).length} POPs, ${(s.links || []).length} links), ${SECS}s per scenario`); + console.log(`Open http://localhost:${PORT}/ in your browser, press Start and keep the tab in front.`); + if (HOST === '0.0.0.0') for (const l of Object.values(os.networkInterfaces()).flat()) if (l && l.family === 'IPv4' && !l.internal) console.log(` from another device: http://${l.address}:${PORT}/`); + console.log('Ctrl+C to stop.'); +}); diff --git a/scripts/lib/fuzz-page.js b/scripts/lib/fuzz-page.js index 71d5ca5..f7c413c 100644 --- a/scripts/lib/fuzz-page.js +++ b/scripts/lib/fuzz-page.js @@ -3,7 +3,7 @@ // stay in lockstep; this file only offers what a player could do now (buttons on screen, POPs, cities) and digests what // routing gave, as strings the driver compares. (() => { - const DENY = new Set(['animSet', 'cont', 'exportSave', 'importGo', 'importPick', 'install', 'langSet', 'menu', 'mute', 'newgame', 'phonePlay', 'phoneSpeed', + const DENY = new Set(['animSet', 'cont', 'exportSave', 'importGo', 'importPick', 'install', 'langSet', 'mapSet', 'menu', 'mute', 'newgame', 'phonePlay', 'phoneSpeed', 'prefSet', 'pzShare', 'resetAsk', 'settings', 'settingsClose', 'share', 'shareDl', 'shareGo', 'slotBack', 'slotDel', 'slotDelGo', 'slotExport', 'slotMenu', 'slotRetry', 'slotSpace', 'slotSwitch', 'slotTake', 'soundSet', 'speed', 'start', 'toTitle', 'traceCopy', 'updateLater', 'updateNow', 'vpSet', 'wsShare', // Leave the game or open what is not this game: the title screen, menus of other modes, AI helpers that fetch. diff --git a/scripts/lib/gpu-bench-client.js b/scripts/lib/gpu-bench-client.js new file mode 100644 index 0000000..7c0f6bb --- /dev/null +++ b/scripts/lib/gpu-bench-client.js @@ -0,0 +1,96 @@ +// The benchmark panel that scripts/gpu-bench.js adds to the game page. It runs in your own browser, so it measures your +// graphics card: the save is loaded, then each scenario plays for a few seconds with the 2D map and with the WebGL +// tubes, and the frames are timed as they really reach the screen (requestAnimationFrame). Results show in the panel +// and go back to the terminal that started the server. Nothing is saved: the page's save() is switched off. +(() => { + const CFG = window.__BENCH__ || {}, SECS = CFG.secs || 6, WARM = 1500; + const SCEN = [ + { id: 'x1-far', label: 'Map at x1, zoomed out (0.6)', speed: 1, z: 0.6 }, + { id: 'x1-mid', label: 'Map at x1 (zoom 1.4)', speed: 1, z: 1.4 }, + { id: 'x1-near', label: 'Map at x1, zoomed in (3.2)', speed: 1, z: 3.2 }, + { id: 'pan', label: 'Panning at x1 (zoom 1.4)', speed: 1, z: 1.4, pan: true }, + { id: 'x8', label: 'Game at x8 (zoom 1.4)', speed: 8, z: 1.4 }, + ]; + // ?only=gl or ?only=2d runs one renderer; ?scen=x1-mid,pan runs only those scenarios; ?dpr=2 below. + const QS = new URLSearchParams(location.search), ONLY = QS.get('only'), PICK = QS.get('scen'); + if (PICK) SCEN.splice(0, SCEN.length, ...SCEN.filter((s) => PICK.split(',').includes(s.id))); + const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); + const box = document.createElement('div'); + box.style.cssText = 'position:fixed;top:8px;left:50%;transform:translateX(-50%);z-index:100000;background:rgba(30,38,64,.94);color:#fff;font:13px/1.4 system-ui,sans-serif;padding:12px 14px;border-radius:12px;max-width:94vw;max-height:80vh;overflow:auto;box-shadow:0 6px 24px rgba(0,0,0,.35)'; + box.innerHTML = 'Series of Tubes · GPU benchmark
Loading…
'; + const st = (t) => { box.querySelector('#bst').textContent = t; }; + let SAVE = null, MD = ''; + + function fresh() { + S = migrate(JSON.parse(SAVE)); UI.started = true; UI.pitched = true; UI.sel = null; UI.anim = 'on'; applyAnim(); + closeModal(); compute(); renderAll(); + const h = CITY[S.home] || CITIES[0]; cam.x = h.x; cam.y = h.y; + } + const q = (s, x) => (s.length ? s[Math.min(s.length - 1, Math.floor(s.length * x))] : 0); + async function measure(sc, hz) { + fresh(); cam.z = sc.z; UI.speed = sc.speed; WL.key = null; + await sleep(WARM); + const fr = [], dr = [], day0 = S.day; let last = 0, stop = false, hidden = false, long = 0, panX = cam.x; + const D0 = draw; + draw = function (t) { const a = performance.now(); try { return D0(t); } finally { dr.push(performance.now() - a); } }; + let po = null; try { po = new PerformanceObserver((l) => { long += l.getEntries().length; }); po.observe({ type: 'longtask' }); } catch (e) { /* not in this browser */ } + // Frames slower than three refreshes, with the day they fell on and their draw(): where the stutters are. + const t00 = performance.now(), slow = []; + const tick = (t) => { if (last) { fr.push(t - last); if (t - last > 50) slow.push({ at: Math.round(t - t00), ms: Math.round(t - last), day: S.day, draw: +(dr[dr.length - 1] || 0).toFixed(1) }); } last = t; if (document.hidden) hidden = true; + if (sc.pan) { panX += 0.18 * (t - (tick.p || t)) / cam.z; cam.x = panX; tick.p = t; } + if (!stop) requestAnimationFrame(tick); }; + requestAnimationFrame(tick); + const t0 = performance.now(); await sleep(SECS * 1000); stop = true; const T = (performance.now() - t0) / 1000; + draw = D0; if (po) po.disconnect(); UI.speed = 0; + const s = fr.slice().sort((a, b) => a - b), d = dr.slice().sort((a, b) => a - b), budget = 1000 / hz; + return { fps: +(fr.length / T).toFixed(1), p50: +q(s, 0.5).toFixed(1), p95: +q(s, 0.95).toFixed(1), p99: +q(s, 0.99).toFixed(1), max: +q(s, 1).toFixed(1), + dropped: +(100 * fr.filter((x) => x > budget * 1.5).length / Math.max(1, fr.length)).toFixed(1), + drawMs: +(d.reduce((a, x) => a + x, 0) / Math.max(1, d.length)).toFixed(2), drawP95: +q(d, 0.95).toFixed(2), + daysPerSec: +((S.day - day0) / T).toFixed(2), longTasks: long, hidden, drawMax: +q(d, 1).toFixed(1), slow }; + } + async function refresh() { + const a = []; let l = 0; await new Promise((r) => { const f = (t) => { if (l) a.push(t - l); l = t; if (a.length < 90) requestAnimationFrame(f); else r(); }; requestAnimationFrame(f); }); + a.sort((x, y) => x - y); return Math.round(1000 / a[a.length >> 1]); + } + function table(res, env) { + const rows = SCEN.map((sc) => { const a = res['2d'][sc.id], b = res.gl && res.gl[sc.id]; + const f = (m, k, u = '') => (m ? `${m[k]}${u}` : '-'); + return `| ${sc.label} | ${f(a, 'fps')} | ${f(b, 'fps')} | ${f(a, 'p95', ' ms')} | ${f(b, 'p95', ' ms')} | ${f(a, 'drawMs', ' ms')} | ${f(b, 'drawMs', ' ms')} |`; }); + return [`**${env.gpu || 'unknown GPU'}** · ${env.ua}`, `${env.w}×${env.h} at ${env.dpr}× · ${env.hz} Hz screen · ${env.cores} threads · ${env.save}`, '', + '| Scenario | 2D fps | WebGL fps | 2D p95 frame | WebGL p95 frame | 2D draw() | WebGL draw() |', + '|---|--:|--:|--:|--:|--:|--:|', ...rows, + '', `p95 frame: the slowest 5% of frames. draw(): CPU time per frame on the main thread.${env.invalid ? ' ⚠️ The tab was hidden during a run: those numbers are not valid.' : ''}`].join('\n'); + } + async function run() { + const go = box.querySelector('#bgo'); go.disabled = true; + save = () => {}; + // An incident pauses the game (autoPause): the clock must keep running for the timings to mean anything. + autoPause = () => false; + fresh(); UI.speed = 0; st('Measuring the screen refresh…'); await sleep(500); + const hz = await refresh(); + const want0 = GLX.want, glOk = mapGl(true, false) && glInit(); const env = { gpu: GLX.gpu, ua: navigator.userAgent.replace(/^Mozilla\/5\.0 /, ''), w: innerWidth, h: innerHeight, dpr: devicePixelRatio, hz, cores: navigator.hardwareConcurrency, save: `${Object.keys(S.pops).length} POPs · ${S.links.length} links` }; + mapGl(false, false); + const res = { '2d': {}, gl: glOk ? {} : null }; + for (const r of (glOk ? ['2d', 'gl'] : ['2d']).filter((x) => !ONLY || x === ONLY)) { mapGl(r === 'gl', false); + for (const sc of SCEN) { st(`${r === 'gl' ? 'WebGL' : '2D'} · ${sc.label} (${SECS}s)… keep this tab in front`); const m = await measure(sc, hz); res[r][sc.id] = m; if (m.hidden) env.invalid = true; } } + mapGl(want0, false); fresh(); UI.speed = 0; + MD = table(res, env); + st(glOk ? 'Done. The results are also in the terminal.' : 'Done (no WebGL2 here: 2D only).'); + box.querySelector('#bout').innerHTML = '
' + MD.replace(/&/g, '&').replace(/';
+    box.querySelector('#bcp').hidden = false; go.disabled = false; go.textContent = 'Run again';
+    try { await fetch('/__bench/results', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ env, res, md: MD }) }); } catch (e) { /* the panel has them */ }
+  }
+  addEventListener('load', async () => {
+    document.body.appendChild(box);
+    while (typeof migrate !== 'function' || typeof GLX === 'undefined') await sleep(50);
+    // ?dpr=2 draws the map as a screen of that density would (a 4K screen's pixels, measured on a smaller one).
+    const DPRQ = +QS.get('dpr'); if (DPRQ > 0) { Object.defineProperty(window, 'devicePixelRatio', { get: () => DPRQ }); resize(); WL.key = null; }
+    await sleep(800);
+    try { SAVE = JSON.stringify((await (await fetch('/__bench/save.json')).json()).S || null); } catch (e) { st('Could not load the save: ' + e); return; }
+    if (SAVE === 'null') { st('The save file has no game in it.'); return; }
+    st(`Ready: ${SCEN.length} scenarios × 2 renderers, about ${Math.ceil(SCEN.length * 2 * (SECS + 3) / 60)} minutes. Keep this tab in front and do not touch the map.`);
+    const go = box.querySelector('#bgo'); go.disabled = false; go.onclick = () => run().catch((e) => st('Failed: ' + (e && e.stack || e)));
+    box.querySelector('#bcp').onclick = () => navigator.clipboard.writeText(MD).then(() => st('Copied.'), () => st('Copy failed: select the table instead.'));
+    if (/[?&]auto\b/.test(location.search)) go.onclick();
+  });
+})();
diff --git a/site/i18n/de.js b/site/i18n/de.js
index 3ffe669..809873c 100644
--- a/site/i18n/de.js
+++ b/site/i18n/de.js
@@ -3911,12 +3911,15 @@
 "settings.agent_api":"Agent-API",
 "settings.agent_relay_connected":"Agenten-Relay verbunden: Jetzt kann ein Tool dieses Spiel in diesem Tab spielen.",
 "settings.agent_s_clock":"Uhr des Agenten",
+"settings.always_2d":"Immer 2D",
 "settings.an_early_heads_up_below_60":"Eine frühe Warnung unter 60 % Zufriedenheit, lange bevor sie wütend sind.",
+"settings.auto_draws_the_map_with_your":"Auto zeichnet die Karte mit deiner Grafikkarte, wenn der Browser es erlaubt, damit auch große Netze flüssig bleiben. Immer 2D läuft überall, ist auf großen Karten aber langsamer.",
 "settings.auto_follows_your_device_s_reduce":"Auto folgt der Einstellung „Bewegung reduzieren“ deines Geräts. Aus friert die Karte ein: keine wandernden Pakete, kein Pulsieren, kein schwebender Text.",
 "settings.customers_and_alerts":"Kunden und Warnungen",
 "settings.display_and_sound":"Anzeige und Ton",
 "settings.for_reporting_layout_bugs_shows_what":"Zum Melden von Layout-Fehlern: zeigt, was dein Bildschirm dem Spiel mitteilt.",
 "settings.let_an_ai_agent_drive_this_game":"Eine KI soll dieses Spiel spielen",
+"settings.map_drawing":"Kartendarstellung",
 "settings.n_min":"{n} Min.",
 "settings.n_sec":"{n} s",
 "settings.only_trouble_and_milestones_pop_up":"Nur Ärger und Meilensteine poppen auf; alles andere landet still im NOC-Log. In Best Effort standardmäßig an.",
@@ -3929,6 +3932,7 @@
 "settings.the_agent_moves_it":"Der Agent stellt sie",
 "settings.the_clock_while_an_agent_plays":"Die Uhr, während ein Agent spielt",
 "settings.the_game_stops_so_you_can":"Das Spiel hält an, damit du ihren Dienst reparieren kannst, bevor sie kündigen. Am nützlichsten bei hoher Geschwindigkeit.",
+"settings.this_browser_cannot_so_the_map":"Dieser Browser kann das nicht, also wird die Karte in 2D gezeichnet.",
 "settings.warn_when_a_customer_gets_unhappy":"Bei unzufriedenen Kunden warnen",
 "settings.while_agent_mode_is_on_the":"Solange der Agenten-Modus an ist, gehört die Uhr nicht dir. Mit Tempo läuft sie von selbst und lässt sich von Hand nicht anhalten, auch nicht durch ein offenes Fenster (deins eingeschlossen), und sie wartet, solange kein Agent verbunden ist. Oder der Agent stellt sie, und nichts passiert, bis er nach Tagen fragt. Die Seite verbindet sich mit dem lokalen Agenten-Relay (npm run dev bringt eins mit), damit Tools wie der MCP-Server dieses Spiel spielen können, während du zusiehst.",
 "share_card.build_the_internet_one_tube_at":"Bau das Internet, eine Röhre nach der anderen",
diff --git a/site/i18n/es.js b/site/i18n/es.js
index e90856f..9744b6b 100644
--- a/site/i18n/es.js
+++ b/site/i18n/es.js
@@ -3909,12 +3909,15 @@
 "settings.agent_api":"API de agentes",
 "settings.agent_relay_connected":"Relay de agentes conectado: ahora una herramienta puede jugar esta partida en esta pestaña.",
 "settings.agent_s_clock":"Reloj del agente",
+"settings.always_2d":"Siempre 2D",
 "settings.an_early_heads_up_below_60":"Un aviso temprano por debajo del 60 % de felicidad, mucho antes de que estén furiosos.",
+"settings.auto_draws_the_map_with_your":"Auto dibuja el mapa con tu tarjeta gráfica cuando el navegador lo permite, y así las redes grandes siguen fluidas. Siempre 2D funciona en todas partes, pero va más lento en mapas grandes.",
 "settings.auto_follows_your_device_s_reduce":"Auto sigue el ajuste de reducir movimiento de tu dispositivo. Desactivado congela el mapa: sin paquetes en movimiento, pulsos ni texto flotante.",
 "settings.customers_and_alerts":"Clientes y alertas",
 "settings.display_and_sound":"Pantalla y sonido",
 "settings.for_reporting_layout_bugs_shows_what":"Para informar de fallos de diseño: muestra lo que tu pantalla le dice al juego.",
 "settings.let_an_ai_agent_drive_this_game":"Deja que un agente de IA juegue",
+"settings.map_drawing":"Dibujo del mapa",
 "settings.n_min":"{n} min",
 "settings.n_sec":"{n} s",
 "settings.only_trouble_and_milestones_pop_up":"Solo aparecen los problemas y los hitos; todo lo demás va en silencio al registro del NOC. Activado por defecto en Best Effort.",
@@ -3927,6 +3930,7 @@
 "settings.the_agent_moves_it":"Lo mueve el agente",
 "settings.the_clock_while_an_agent_plays":"El reloj mientras juega un agente",
 "settings.the_game_stops_so_you_can":"El juego se detiene para que arregles su servicio antes de que cancelen. Muy útil a alta velocidad.",
+"settings.this_browser_cannot_so_the_map":"Este navegador no puede, así que el mapa se dibuja en 2D.",
 "settings.warn_when_a_customer_gets_unhappy":"Avisar cuando un cliente se descontenta",
 "settings.while_agent_mode_is_on_the":"Mientras el modo agente está activo, el reloj no es tuyo. Con un ritmo, corre solo y no se puede pausar a mano, ni siquiera con una ventana abierta (las tuyas incluidas), y espera mientras no haya ningún agente conectado. O lo mueve el agente, y no pasa nada hasta que pide días. La página se conecta al relay local de agentes (npm run dev trae uno), para que herramientas como el servidor MCP jueguen esta partida mientras miras.",
 "share_card.build_the_internet_one_tube_at":"Construye internet, un tubo a la vez",
diff --git a/site/i18n/fr.js b/site/i18n/fr.js
index 2c7461a..85ebe05 100644
--- a/site/i18n/fr.js
+++ b/site/i18n/fr.js
@@ -3909,12 +3909,15 @@
 "settings.agent_api":"API agent",
 "settings.agent_relay_connected":"Relais pour agents connecté : un outil peut maintenant jouer cette partie dans cet onglet.",
 "settings.agent_s_clock":"Horloge de l'agent",
+"settings.always_2d":"Toujours en 2D",
 "settings.an_early_heads_up_below_60":"Une alerte précoce sous 60 % de satisfaction, bien avant qu’il soit furieux.",
+"settings.auto_draws_the_map_with_your":"Auto dessine la carte avec ta carte graphique quand le navigateur le permet, ce qui garde les grands réseaux fluides. Toujours en 2D marche partout mais rame sur les grandes cartes.",
 "settings.auto_follows_your_device_s_reduce":"Auto suit le réglage « réduire les animations » de ton appareil. Inactif fige la carte : plus de paquets en mouvement, de pulsations ni de texte flottant.",
 "settings.customers_and_alerts":"Clients et alertes",
 "settings.display_and_sound":"Affichage et son",
 "settings.for_reporting_layout_bugs_shows_what":"Pour signaler des bugs de mise en page : montre ce que ton écran dit au jeu.",
 "settings.let_an_ai_agent_drive_this_game":"Laisser un agent IA jouer",
+"settings.map_drawing":"Dessin de la carte",
 "settings.n_min":"{n} min",
 "settings.n_sec":"{n} s",
 "settings.only_trouble_and_milestones_pop_up":"Seuls les problèmes et les étapes s'affichent ; tout le reste va discrètement dans le journal du NOC. Activé par défaut en Best Effort.",
@@ -3927,6 +3930,7 @@
 "settings.the_agent_moves_it":"L'agent l'avance",
 "settings.the_clock_while_an_agent_plays":"L'horloge pendant qu'un agent joue",
 "settings.the_game_stops_so_you_can":"Le jeu s’arrête pour que tu répares leur service avant qu’ils résilient. Surtout utile à grande vitesse.",
+"settings.this_browser_cannot_so_the_map":"Ce navigateur ne peut pas, la carte est donc dessinée en 2D.",
 "settings.warn_when_a_customer_gets_unhappy":"Prévenir quand un client devient mécontent",
 "settings.while_agent_mode_is_on_the":"Tant que le mode agent est actif, l'horloge n'est plus à toi. Avec un rythme, elle tourne toute seule et ne peut pas être mise en pause à la main, pas même par une fenêtre ouverte (les tiennes comprises), et elle attend tant qu'aucun agent n'est connecté. Ou bien c'est l'agent qui l'avance, et rien ne se passe tant qu'il ne demande pas de jours. La page se connecte au relais local pour agents (npm run dev en lance un), pour que des outils comme le serveur MCP jouent cette partie pendant que tu regardes.",
 "share_card.build_the_internet_one_tube_at":"Construis Internet, un tube à la fois",
diff --git a/site/i18n/it.js b/site/i18n/it.js
index 3381ff8..31ade7b 100644
--- a/site/i18n/it.js
+++ b/site/i18n/it.js
@@ -3909,12 +3909,15 @@
 "settings.agent_api":"API per agenti",
 "settings.agent_relay_connected":"Relay per agenti collegato: ora uno strumento può giocare questa partita in questa scheda.",
 "settings.agent_s_clock":"Orologio dell'agente",
+"settings.always_2d":"Sempre 2D",
 "settings.an_early_heads_up_below_60":"Un avviso in anticipo sotto il 60% di soddisfazione, molto prima che siano furiosi.",
+"settings.auto_draws_the_map_with_your":"Auto disegna la mappa con la tua scheda grafica quando il browser lo consente, così anche le reti grandi restano fluide. Sempre 2D funziona ovunque ma è più lento sulle mappe grandi.",
 "settings.auto_follows_your_device_s_reduce":"Auto segue l’impostazione “riduci movimento” del tuo dispositivo. Off congela la mappa: niente pacchetti in movimento, pulsazioni o testo fluttuante.",
 "settings.customers_and_alerts":"Clienti e avvisi",
 "settings.display_and_sound":"Schermo e audio",
 "settings.for_reporting_layout_bugs_shows_what":"Per segnalare bug di layout: mostra cosa lo schermo dice al gioco.",
 "settings.let_an_ai_agent_drive_this_game":"Lascia giocare un agente IA",
+"settings.map_drawing":"Disegno della mappa",
 "settings.n_min":"{n} min",
 "settings.n_sec":"{n} s",
 "settings.only_trouble_and_milestones_pop_up":"Compaiono solo i problemi e i traguardi; tutto il resto finisce in silenzio nel registro del NOC. Attivo di default in Best Effort.",
@@ -3927,6 +3930,7 @@
 "settings.the_agent_moves_it":"Lo muove l'agente",
 "settings.the_clock_while_an_agent_plays":"L'orologio mentre gioca un agente",
 "settings.the_game_stops_so_you_can":"Il gioco si ferma così puoi sistemare il servizio prima che disdicano. Utilissimo ad alta velocità.",
+"settings.this_browser_cannot_so_the_map":"Questo browser non può, quindi la mappa è disegnata in 2D.",
 "settings.warn_when_a_customer_gets_unhappy":"Avvisa quando un cliente diventa scontento",
 "settings.while_agent_mode_is_on_the":"Finché la modalità agente è attiva, l'orologio non è tuo. Con un ritmo va da solo e non si può fermare a mano, nemmeno con una finestra aperta (comprese le tue), e aspetta finché non è collegato nessun agente. Oppure lo muove l'agente, e non succede nulla finché non chiede dei giorni. La pagina si collega al relay locale per agenti (npm run dev ne avvia uno), così strumenti come il server MCP possono giocare questa partita mentre guardi.",
 "share_card.build_the_internet_one_tube_at":"Costruisci internet, un tubo alla volta",
diff --git a/site/i18n/pt.js b/site/i18n/pt.js
index e021902..b46d71c 100644
--- a/site/i18n/pt.js
+++ b/site/i18n/pt.js
@@ -3909,12 +3909,15 @@
 "settings.agent_api":"API para agentes",
 "settings.agent_relay_connected":"Relay de agentes ligado: agora uma ferramenta pode jogar este jogo nesta aba.",
 "settings.agent_s_clock":"Relógio do agente",
+"settings.always_2d":"Sempre 2D",
 "settings.an_early_heads_up_below_60":"Um aviso antecipado abaixo de 60% de satisfação, bem antes de ficarem furiosos.",
+"settings.auto_draws_the_map_with_your":"Auto desenha o mapa com sua placa de vídeo quando o navegador permite, o que mantém redes grandes fluidas. Sempre 2D funciona em qualquer lugar, mas é mais lento em mapas grandes.",
 "settings.auto_follows_your_device_s_reduce":"Auto segue a configuração de reduzir movimento do seu aparelho. Desligado congela o mapa: sem pacotes andando, pulsos ou texto flutuante.",
 "settings.customers_and_alerts":"Clientes e alertas",
 "settings.display_and_sound":"Tela e som",
 "settings.for_reporting_layout_bugs_shows_what":"Para reportar bugs de layout: mostra o que sua tela informa ao jogo.",
 "settings.let_an_ai_agent_drive_this_game":"Deixa um agente de IA jogar",
+"settings.map_drawing":"Desenho do mapa",
 "settings.n_min":"{n} min",
 "settings.n_sec":"{n} s",
 "settings.only_trouble_and_milestones_pop_up":"Só aparecem problemas e marcos; todo o resto vai em silêncio para o registro do NOC. Ligado por padrão no Best Effort.",
@@ -3927,6 +3930,7 @@
 "settings.the_agent_moves_it":"O agente move-o",
 "settings.the_clock_while_an_agent_plays":"O relógio enquanto um agente joga",
 "settings.the_game_stops_so_you_can":"O jogo para para você consertar o serviço antes que cancelem. Muito útil em alta velocidade.",
+"settings.this_browser_cannot_so_the_map":"Este navegador não consegue, então o mapa é desenhado em 2D.",
 "settings.warn_when_a_customer_gets_unhappy":"Avisar quando um cliente ficar insatisfeito",
 "settings.while_agent_mode_is_on_the":"Enquanto o modo agente estiver ligado, o relógio não é teu. Com um ritmo, corre sozinho e não pode ser parado à mão, nem por uma janela aberta (as tuas incluídas), e espera enquanto nenhum agente estiver ligado. Ou é o agente que o move, e nada acontece até ele pedir dias. A página liga-se ao relay local de agentes (npm run dev traz um), para que ferramentas como o servidor MCP joguem este jogo enquanto vês.",
 "share_card.build_the_internet_one_tube_at":"Construa a internet, um tubo de cada vez",
diff --git a/src/agent/20-commands.js b/src/agent/20-commands.js
index 7c58a63..e558955 100644
--- a/src/agent/20-commands.js
+++ b/src/agent/20-commands.js
@@ -551,6 +551,6 @@ const API_DENY={
   start:'start',newgame:'start',cont:'start',toTitle:'start',resetAsk:'start',
   exportSave:'files',importGo:'files',importPick:'files',slotExport:'files',
   slotBack:'slots',slotDel:'slots',slotDelGo:'slots',slotMenu:'slots',slotRetry:'slots',slotSpace:'slots',slotSwitch:'slots',slotTake:'slots',
-  animSet:'prefs',langSet:'prefs',menu:'prefs',mute:'prefs',prefSet:'prefs',settings:'prefs',settingsClose:'prefs',soundSet:'prefs',vpSet:'prefs',
+  animSet:'prefs',langSet:'prefs',mapSet:'prefs',menu:'prefs',mute:'prefs',prefSet:'prefs',settings:'prefs',settingsClose:'prefs',soundSet:'prefs',vpSet:'prefs',
   install:'browser',share:'browser',shareDl:'browser',shareGo:'browser',traceCopy:'browser',updateLater:'browser',updateNow:'browser',wsShare:'browser',pzShare:'browser',
 };
diff --git a/src/game/90-actions/10-interface.js b/src/game/90-actions/10-interface.js
index b75c863..4224aac 100644
--- a/src/game/90-actions/10-interface.js
+++ b/src/game/90-actions/10-interface.js
@@ -22,6 +22,7 @@ const ACT={
    toast(B.equity?tr('interface.you_bought_out_bank_they_flew',{bank:esc(B.name)}):tr('interface.loan_from_bank_repaid_early',{bank:esc(B.name)}),'good');after();renderBank();},
  leaseSwap:({a,b,src})=>{if(!S.pops[a]||!S.pops[b]||a===b)return;$('dash').hidden=true;UI.lmode='df';UI.dfSrc=['lease','build','cable'].includes(src)?src:isSub(a,b)?'cable':'build';UI.dfSys=lvl()>=3?'roadm':'lite';openLinkModal(a,b);},
  dashLink:({id})=>{$('dash').hidden=true;selectLink(id);focusLink(id);},
+ mapSet:({v})=>{if(!['auto','2d'].includes(v))return;mapGl(v==='auto');refreshSettings();},
  animSet:({v})=>{if(!['auto','on','off'].includes(v))return;UI.anim=v;try{localStorage.setItem('sot-anim',v);}catch(e){}applyAnim();refreshSettings();},
  soundSet:({v})=>{UI.muted=v==='off';try{localStorage.setItem('sot-mute',UI.muted?'1':'0');}catch(e){}renderHUD();refreshSettings();},
  langSet:({v})=>{if(!Object.hasOwn(LANGS,v)||v===LANG)return;try{localStorage.setItem('sot-lang',v);}catch(e){}save(true);location.reload();},
diff --git a/src/game/90-actions/95-puzzles.js b/src/game/90-actions/95-puzzles.js
index 69433ea..3af3af5 100644
--- a/src/game/90-actions/95-puzzles.js
+++ b/src/game/90-actions/95-puzzles.js
@@ -58,6 +58,6 @@ Object.assign(ACT,{
 // open anything in it. Everything but these and the pz* actions does nothing while a puzzle is on. The main game's
 // routing controls (metric, standby, the redundancy check) work in a puzzle too, and their changes can be undone.
 // This file is the last of the actions, so every one is here to wrap.
-const PZ_ACTS=new Set(['animSet','closeModal','closePanel','help','helpClose','install','keepPlaying','langSet','linkCheck','menu','metricMode','metricSet','mute','prefSet','puzzleDoor','puzzleMenu','selLink','setMetric','setStandby','settings','settingsClose','soundSet','speed','updateLater','updateNow','vpSet','whatsNewShow']);
+const PZ_ACTS=new Set(['animSet','closeModal','closePanel','help','helpClose','install','keepPlaying','langSet','linkCheck','mapSet','menu','metricMode','metricSet','mute','prefSet','puzzleDoor','puzzleMenu','selLink','setMetric','setStandby','settings','settingsClose','soundSet','speed','updateLater','updateNow','vpSet','whatsNewShow']);
 const PZ_UNDO=new Set(['metricMode','metricSet','setMetric','setStandby']);
 for(const k of Object.keys(ACT)){const f=ACT[k];if(PZ_UNDO.has(k))ACT[k]=a=>{if(pzOn())pzSnap();return f(a);};else if(!PZ_ACTS.has(k)&&!/^pz[A-Z]/.test(k))ACT[k]=a=>pzOn()?undefined:f(a);}
diff --git a/src/game/96-map/10-canvas.js b/src/game/96-map/10-canvas.js
index 3210b61..e3021cc 100644
--- a/src/game/96-map/10-canvas.js
+++ b/src/game/96-map/10-canvas.js
@@ -1,5 +1,6 @@
 /* ================= CANVAS ================= */
-const cv=$('map'),ctx=cv.getContext('2d');
+// ctx is the 2D context draw() paints with: the map's own (CTX0), or with WebGL on the overlay above the card (56-webgl.js).
+const cv=$('map'),CTX0=cv.getContext('2d');let ctx=CTX0;
 const cam={x:1050,y:330,z:0.8};
 let CW=0,CH=0,DPR=1;
 /* Installed on an iPhone home screen with a translucent status bar, iOS can report a viewport one status bar
diff --git a/src/game/96-map/30-settings.js b/src/game/96-map/30-settings.js
index 98750ea..348036a 100644
--- a/src/game/96-map/30-settings.js
+++ b/src/game/96-map/30-settings.js
@@ -30,6 +30,7 @@ function settingsHtml(){const seg=(lab,act,cur,opts,note)=>`
${tr('settings.display_and_sound')} ${seg(tr('common.animations'),'animSet',UI.anim||'auto',[['auto',tr('common.auto')],['on',tr('common.on')],['off',tr('common.off')]],tr('settings.auto_follows_your_device_s_reduce'))} + ${seg(tr('settings.map_drawing'),'mapSet',GLX.want?'auto':'2d',[['auto',tr('common.auto')],['2d',tr('settings.always_2d')]],tr('settings.auto_draws_the_map_with_your')+(GLX.want&&!glInit()?' '+tr('settings.this_browser_cannot_so_the_map'):''))} ${seg(tr('common.sound'),'soundSet',UI.muted?'off':'on',[['on',tr('common.on')],['off',tr('common.off')]])}
${langPick('langSel')}
${seg(tr('common.viewport_info'),'vpSet',VP_T?'on':'off',[['on',tr('common.on')],['off',tr('common.off')]],tr('settings.for_reporting_layout_bugs_shows_what'))} diff --git a/src/game/96-map/50-link-geometry.js b/src/game/96-map/50-link-geometry.js index 5c03a54..f737267 100644 --- a/src/game/96-map/50-link-geometry.js +++ b/src/game/96-map/50-link-geometry.js @@ -30,8 +30,9 @@ function segDist(x,y,a,b){const dx=b[0]-a[0],dy=b[1]-a[1],L=dx*dx+dy*dy||1;const // Cable names are drawn in one font, so each width is measured once. const LBW=new Map(),labW=t=>{let w=LBW.get(t);if(w===undefined)LBW.set(t,w=ctx.measureText(t).width);return w;}; try{document.fonts&&document.fonts.ready.then(()=>LBW.clear());}catch(e){} -function drawCables(ks){const z=cam.z,selC=UI.drag&&UI.drag.mode==='link'?UI.drag.from:(UI.sel&&UI.sel.type==='city'?UI.sel.id:null),cached=!!(WL.cv&&WL.key&&WL.cab); - if(!selC&&z<1.7&&cached)return; +function drawCables(ks){const G=glOn(),z=cam.z,selC=UI.drag&&UI.drag.mode==='link'?UI.drag.from:(UI.sel&&UI.sel.type==='city'?UI.sel.id:null),cached=!!(WL.cv&&WL.key&&WL.cab)&&!G; + // On the card the cables are drawn by glBegin(); here only their labels are left. + if(!selC&&z<1.7&&cached)return;if(G&&!selC&&z<1.7)return; ctx.font='800 10px Nunito, sans-serif';ctx.textAlign='center';ctx.textBaseline='middle'; // Labels that would sit on another, or on a segment shorter than the name, are left out (a selected city's always show). // Placed labels go in a 64px grid, so each check only looks at its neighbours. @@ -41,8 +42,8 @@ function drawCables(ks){const z=cam.z,selC=UI.drag&&UI.drag.mode==='link'?UI.dra for(let cx=c0;cx<=c1;cx++)for(let cy=r0;cy<=r1;cy++){const k=cx*8192+cy;let o=LG.get(k);if(!o)LG.set(k,o=[]);o.push(b);}return true;}; const ar=arOn();for(const cp of CABLE_PAIRS){const C=CAB[cp.cid],hot=!!selC&&(cp.a===selC||cp.b===selC);if(!hot&&cached&&z<1.7)continue;if(ar&&!hot&&!(arKind(cp.a)&&arKind(cp.b)))continue;const col=cableCol(C); for(const k of ks){const sp=cp.pts.map(p=>toS(p[0],p[1],k));let mn=Infinity,mx=-Infinity;for(const q of sp){if(q[0]mx)mx=q[0];}if(mx<-20||mn>CW+20)continue; - if(hot||!cached){ctx.globalAlpha=hot?0.95:0.4;ctx.strokeStyle=col;ctx.lineWidth=hot?3:1.6;ctx.lineJoin='round';ctx.setLineDash(C.age==='old'?[6,5]:[]);ctx.beginPath();ctx.moveTo(sp[0][0],sp[0][1]);for(let i=1;i=1.7&&!ar))&&lbOk(sp[Math.floor(sp.length/2)][0],sp[Math.floor(sp.length/2)][1]-8,labW(C.name),sp,hot)){const m=sp[Math.floor(sp.length/2)];ctx.globalAlpha=hot?1:0.75;ctx.lineWidth=3;ctx.strokeStyle='rgba(255,255,255,.85)';ctx.strokeText(C.name,m[0],m[1]-8);ctx.fillStyle=col;ctx.fillText(C.name,m[0],m[1]-8);} + if(!G&&(hot||!cached)){ctx.globalAlpha=hot?0.95:0.4;ctx.strokeStyle=col;ctx.lineWidth=hot?3:1.6;ctx.lineJoin='round';ctx.setLineDash(C.age==='old'?[6,5]:[]);ctx.beginPath();ctx.moveTo(sp[0][0],sp[0][1]);for(let i=1;i=1.7&&!ar))&&lbOk(sp[Math.floor(sp.length/2)][0],sp[Math.floor(sp.length/2)][1]-8,labW(C.name),sp,hot)){const m=sp[Math.floor(sp.length/2)];ctx.globalAlpha=hot?1:0.75;textStamp(C.name,ctx.font,10,labW(C.name),col,'rgba(255,255,255,.85)',3,m[0],m[1]-8);} ctx.globalAlpha=1;}}} function bezGeom(l,at){const A=CITY[l.a],B=CITY[l.b];const i=at!==undefined?at:lineIdx(l);const key=l.id+'|b'+i;const hit=GEO.get(key);if(hit)return hit; const bx=A.x+wrapDx(A.x,B.x),by=B.y;const dx=bx-A.x,dy=by-A.y,len=Math.hypot(dx,dy)||1;let nx=-dy/len,ny=dx/len;if(ny>0){nx=-nx;ny=-ny;} diff --git a/src/game/96-map/55-link-look.js b/src/game/96-map/55-link-look.js new file mode 100644 index 0000000..8ca98b6 --- /dev/null +++ b/src/game/96-map/55-link-look.js @@ -0,0 +1,17 @@ +/* How each tube on the map looks today, worked out once for both maps (the 2D canvas in drawFrame() and the card in + 58-webgl-links.js), so they cannot drift apart. */ +// Dash patterns, by number: none, cut, virtual circuit, being built, standby; 5 the fiber's dots, 6 an old cable. +const LDASH=[[],[8,8],[2,7],[10,8],[4,6],[1,6],[6,5]]; +// A tube is a group of links drawn as one line: its capacity, load and state, its base width, colour and dash. +function linkLook(grp,day){const l=grp[0],many=grp.length>1,up=many?grp.filter(x=>!linkDown(x)):null; + const cap=many?up.reduce((a,x)=>a+capOf(x),0):capOf(l),load=many?grp.reduce((a,x)=>a+(R.load[x.id]||0),0):(R.load[l.id]||0),u=cap?load/cap:0,df=l.kind==='df',bld=df&&l.ready>day,cut=!bld&&(many?!up.length:linkDown(l))&&!(df&&!(l.ch||[]).length),dark=df&&!bld&&!(l.ch||[]).length,vx=l.kind==='vxc',idle=!cut&&!bld&&load<1e-3&&(many?up.length>0&&up.every(x=>x.standby):!!l.standby); + return {l,many,up,cap,load,u,df,bld,cut,dark,vx,idle,w0:vx?2.2:(2.5+Math.max(...grp.map(tierW))*1.8+(many?Math.min(1.5,(grp.length-1)*0.5):0)), + col:bld?'#C9B27C':dark?'#5D6788':cut?'#FF4D5E':idle?'#9AA3BE':vx?FAB[l.prov].col:l.sub?(u>0.001?utilCol(u):'#7FD8EE'):utilCol(u),dash:cut?1:vx?2:bld?3:idle?4:0, + pk:!cut&&load>0.01?clamp(Math.round(2+u*10),2,12):0};} // packets on the line: more as it fills +// The map's tubes as the picture needs them: the groups, their geometry and how each one looks. It changes with the +// links and with the day's routing (R), not with the camera, so it is kept until one of those changes. +let MLK=null; +function mapLinks(day){const key=[S.links,S.links.length,R,day]; + if(MLK&&key.every((v,i)=>v===MLK.key[i]))return MLK; + const PI=pairIdx(),LG=linkGroups(),GM=LG.map(g=>linkGeom(g[0],PI.get(edgeKey(g[0])))); + return MLK={key,PI,LG,GM,looks:LG.map(g=>linkLook(g,day))};} diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js new file mode 100644 index 0000000..1469c6c --- /dev/null +++ b/src/game/96-map/56-webgl.js @@ -0,0 +1,59 @@ +/* The map on the graphics card (WebGL2), wherever the browser can; Settings › Map drawing › Always 2D keeps the 2D + canvas instead (a choice per device). A late-game map sends the 2D canvas several strokes per tube every frame (thousands on a + big network) and repaints the land whenever you pan; here the card draws it all from buffers that change only with + the network, so a frame costs the processor a few draws and uniforms. + Two canvases sit over #map, which stays empty: #mapgl, where the card draws the background (57), the tubes and + packets (58) and the pictures of cities, labels and markers (59); and #mapfx, a transparent 2D canvas over it for + the few things still painted shape by shape (the drag preview, the chaos monkey), cleared only after it was used. + Puzzles, and any browser without WebGL2 or whose context fails or is lost, keep the 2D map. */ +const GLX={want:true,dead:false,gl:null,c:null,f:null,fx:null,key:[],nSeg:0,nPk:0,sel:false,shown:false,gpu:''}; +try{GLX.want=localStorage.getItem('sot-map')!=='2d';}catch(e){} +const glOn=()=>GLX.want&&!GLX.dead&&!!S&&!pzOn()&&glInit(); +// Switches the WebGL map on or off: the setting keeps the choice in this browser (keep), the GPU benchmark does not. +function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeItem('sot-map'):localStorage.setItem('sot-map','2d');}catch(e){} + if(!on)glShow(false);GLX.key=[];UI.drawnAt=0;return on&&!GLX.dead;} +function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=document.getElementById('mapgl'),fx=document.getElementById('mapfx');if(e)e.hidden=!on;if(fx)fx.hidden=!on;} +function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.dead=true;GLX.gl=null;glShow(false);} +const GL_HEAD='#version 300 es\nprecision highp float;precision highp int;\n'; +// Clip space from CSS px (the shaders work in CSS px, as the 2D map does, and use uDpr only for anti-aliasing). +const GL_CLIP='vec4 clip(vec2 p,vec2 v,float z){return vec4(p.x/v.x*2.-1.,1.-p.y/v.y*2.,z,1.);}\n'; +function glProg(gl,vs,fs){const sh=(t,s)=>{const x=gl.createShader(t);gl.shaderSource(x,s);gl.compileShader(x);if(!gl.getShaderParameter(x,gl.COMPILE_STATUS))throw new Error('shader: '+gl.getShaderInfoLog(x));return x;}; + const p=gl.createProgram();gl.attachShader(p,sh(gl.VERTEX_SHADER,vs));gl.attachShader(p,sh(gl.FRAGMENT_SHADER,fs));gl.linkProgram(p); + if(!gl.getProgramParameter(p,gl.LINK_STATUS))throw new Error('link: '+gl.getProgramInfoLog(p)); + const u={},n=gl.getProgramParameter(p,gl.ACTIVE_UNIFORMS);for(let i=0;ia+x,0)*4; + gl.bindVertexArray(v);gl.bindBuffer(gl.ARRAY_BUFFER,b);if(data)gl.bufferData(gl.ARRAY_BUFFER,data,gl.STATIC_DRAW); + let off=0;sizes.forEach((n,i)=>{gl.enableVertexAttribArray(i);gl.vertexAttribPointer(i,n,gl.FLOAT,false,stride,off);gl.vertexAttribDivisor(i,div);off+=n*4;}); + gl.bindVertexArray(null);return {v,b};} +function glInit(){if(GLX.gl)return true;if(GLX.dead)return false; + try{const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');if(!c||!f||!c.getContext)throw new Error('no map layers'); + const gl=c.getContext('webgl2',{alpha:true,premultipliedAlpha:true,antialias:false,depth:true,stencil:true,powerPreference:'high-performance'}); + if(!gl||typeof gl.createShader!=='function')throw new Error('no WebGL2'); + const P=(vs,fs)=>glProg(gl,vs,fs),progs={line:P(GL_LINE_VS,GL_LINE_FS),pk:P(GL_PK_VS,GL_PK_FS),fill:P(FILL_VS,FILL_FS),fan:P(FAN_VS,FAN_FS),ell:P(ELL_VS,ELL_FS),circ:P(CIRC_VS,CIRC_FS)}; + // The tubes' points for the packets: floats read with texelFetch, never filtered. + const tex=gl.createTexture();gl.bindTexture(gl.TEXTURE_2D,tex);for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.NEAREST); + c.addEventListener('webglcontextlost',e=>{e.preventDefault();glKill('the graphics context was lost');UI.drawnAt=0;}); + try{const x=gl.getExtension('WEBGL_debug_renderer_info');GLX.gpu=String(x?gl.getParameter(x.UNMASKED_RENDERER_WEBGL):gl.getParameter(gl.RENDERER));}catch(e){} + glsInit(gl); + // The overlay is cleared only after something was painted on it: clearing a whole screen of empty canvas every + // frame makes the browser send the layer to the screen again, which on a 4K screen cost more than the map itself. + const fx=f.getContext('2d'),CP=CanvasRenderingContext2D.prototype; + for(const m of ['fill','stroke','fillRect','strokeRect','fillText','strokeText','drawImage','putImageData']){const fn=CP[m];fx[m]=function(){GLX.fxUsed=true;return fn.apply(this,arguments);};} + const V=s=>glVao(gl,s); + Object.assign(GLX,progs,{gl,c,f,fx,fxUsed:true,tex,land:{},lv:V([4,4,4]),pv:V([4,4]),cb:V([4,4,4]),wv:V([4,4,4]),cl:V([4]),empty:gl.createVertexArray()});return true;} + catch(e){glKill(e);return false;}} +// Colours as [r,g,b,a] from '#rrggbb', '#rgb' or 'rgba(r,g,b,a)', kept by string. +const GLCOL=new Map(); +function glColor(s){let v=GLCOL.get(s);if(v)return v;let r=0,g=0,b=0,a=1; + if(s[0]==='#'){let h=s.slice(1);if(h.length===3)h=h.replace(/./g,x=>x+x);r=parseInt(h.slice(0,2),16)/255;g=parseInt(h.slice(2,4),16)/255;b=parseInt(h.slice(4,6),16)/255;} + else{const m=/rgba?\(([^)]*)\)/.exec(s);if(m){const p=m[1].split(',').map(x=>parseFloat(x));r=p[0]/255;g=p[1]/255;b=p[2]/255;a=p.length>3?p[3]:1;}} + v=[r,g,b,a];GLCOL.set(s,v);return v;} +// Sets a line or a point program's view for copy k of the map (wm: the line width multiplier). +function glSet(gl,P,k,wm){gl.uniform2f(P.u.uView,CW,CH);gl.uniform3f(P.u.uCam,cam.x-k*W,cam.y,cam.z);gl.uniform1f(P.u.uWMul,wm);gl.uniform1f(P.u.uDpr,DPR);} +// A full-screen fill, from one premultiplied colour at the bottom to another at the top (the sea), or of one colour +// (the land and the clouds, through the stencil). +const FILL_VS=GL_HEAD+`void main(){vec2 p=vec2((gl_VertexID&1)==0?-1.:1.,(gl_VertexID&2)==0?-1.:1.);gl_Position=vec4(p,0.,1.);}`; +const FILL_FS=GL_HEAD+`uniform vec4 uTop,uBot;uniform float uH;out vec4 o;void main(){o=mix(uBot,uTop,gl_FragCoord.y/uH);}`; +function glFill(gl,top,bot=top){const P=GLX.fill;gl.useProgram(P.p);gl.uniform4fv(P.u.uTop,top);gl.uniform4fv(P.u.uBot,bot);gl.uniform1f(P.u.uH,GLX.c.height);gl.bindVertexArray(GLX.empty);gl.drawArrays(gl.TRIANGLE_STRIP,0,4);} diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js new file mode 100644 index 0000000..d696257 --- /dev/null +++ b/src/game/96-map/57-webgl-background.js @@ -0,0 +1,93 @@ +/* The background on the card, painted first each frame: the sea, the land, the waves, the clouds and the cables, as + the 2D map paints them (drawFrame(), paintWorld()) and in the same colours. The land and the cables are geometry + built once, so panning and zooming repaint nothing; only the waves and the clouds move. */ +const glPm=s=>{const [r,g,b,a]=glColor(s);return [r*a,g*a,b*a,a];}; // premultiplied, as the card blends +const SEA_TOP=glPm('#62CBEA'),SEA_BOT=glPm('#43AED6'),CLOUD_COL=glPm('rgba(255,255,255,.55)'); +const LAND_SHADOW=glPm('rgba(20,90,130,.35)'),LAND_GRASS=glPm('#9BDA6C'),HILL_COL=glPm('#86CB5B'),HILL_SHINE=glPm('rgba(255,255,255,.18)'); +// The land's fill: a fan of triangles per coastline, counted in the stencil (each pixel flips once per triangle over +// it, so what is inside ends odd), then one cover where the stencil is odd. uOff shifts it in CSS px (the shadow). +const FAN_VS=GL_HEAD+GL_CLIP+`layout(location=0) in vec2 aV;uniform vec2 uView,uOff;uniform vec3 uCam; +void main(){gl_Position=clip((aV-uCam.xy)*uCam.z+uView*.5+uOff,uView,0.);}`; +const FAN_FS=GL_HEAD+`out vec4 o;void main(){o=vec4(0.);}`; +// Ellipses (the hills and their shine): centre and radii in map units, one premultiplied colour, smooth edges. +const ELL_VS=GL_HEAD+GL_CLIP+`layout(location=0) in vec4 aE;uniform vec2 uView;uniform vec3 uCam;out vec2 vq;flat out vec2 vr; +void main(){vec2 c=(aE.xy-uCam.xy)*uCam.z+uView*.5,r=aE.zw*uCam.z,m=r+1.;vq=vec2((gl_VertexID&1)==0?-m.x:m.x,(gl_VertexID&2)==0?-m.y:m.y);vr=r;gl_Position=clip(c+vq,uView,0.);}`; +const ELL_FS=GL_HEAD+`in vec2 vq;flat in vec2 vr;uniform vec4 uCol;uniform float uDpr;out vec4 o; +void main(){float d=(length(vq/vr)-1.)*min(vr.x,vr.y),a=clamp(.5-d*uDpr,0.,1.);if(a<=0.)discard;o=uCol*a;}`; +// Discs for the stencil only (the clouds' puffs): centre and radius in map units. +const CIRC_VS=GL_HEAD+GL_CLIP+`layout(location=0) in vec4 aC;uniform vec2 uView;uniform vec3 uCam;out vec2 vq;flat out float vr; +void main(){vec2 c=(aC.xy-uCam.xy)*uCam.z+uView*.5;float r=aC.z*uCam.z,m=r+1.;vq=vec2((gl_VertexID&1)==0?-m:m,(gl_VertexID&2)==0?-m:m);vr=r;gl_Position=clip(c+vq,uView,0.);}`; +const CIRC_FS=GL_HEAD+`in vec2 vq;flat in float vr;out vec4 o;void main(){if(length(vq)>vr)discard;o=vec4(1.);}`; +/* The land, built once per level of detail (the far view leaves out the islets as LANDP_FAR does): the fan for the + fills, the coastlines as line segments (paintWorld()'s curves, four segments each) for the sand and the dark edge, + and the hills. */ +function glLandGeo(gl,far){const key=far?'far':'all';let G=GLX.land[key];if(G)return G; + const keep=far?new Set(LANDP_FAR):null,fan=[],sand=[],edge=[],SAND=glColor('#F8E6A8'),EDGE=glColor('#1E2640'); + COAST.forEach((ring,ri)=>{if(keep&&!keep.has(LANDP_ALL[ri]))return;const n=ring.length;if(n<3)return; + // As smoothPath(): a quadratic curve from the middle of each side to the next, through the corner between them. + const mid=(a,b)=>[(a[0]+b[0])/2,(a[1]+b[1])/2],P=[];let m=mid(ring[n-1],ring[0]);P.push(m); + for(let i=0;inew Float32Array(a); + return GLX.land[key]={fan:glVao(gl,[2],0,F(fan)).v,nFan:fan.length/2,sand:glVao(gl,[4,4,4],1,F(sand)).v,edge:glVao(gl,[4,4,4],1,F(edge)).v,nSeg:sand.length/LINE_STRIDE, + hills:glVao(gl,[4],1,F(hills)).v,shine:glVao(gl,[4],1,F(shine)).v,nHill:HILLS.length};} +// Fills the land's shape (shifted by ox, oy CSS px) with one colour, for every copy of the map. +function glLandFill(gl,G,ks,ox,oy,col){const P=GLX.fan;gl.enable(gl.STENCIL_TEST); + gl.useProgram(P.p);gl.uniform2f(P.u.uView,CW,CH);gl.uniform2f(P.u.uOff,ox,oy);gl.bindVertexArray(G.fan); + gl.colorMask(false,false,false,false);gl.stencilFunc(gl.ALWAYS,0,1);gl.stencilOp(gl.KEEP,gl.KEEP,gl.INVERT);gl.stencilMask(1); + for(const k of ks){gl.uniform3f(P.u.uCam,cam.x-k*W,cam.y,cam.z);gl.drawArrays(gl.TRIANGLES,0,G.nFan);} + // The cover paints where the count is odd and sets the stencil back to zero for the next user. + gl.colorMask(true,true,true,true);gl.stencilFunc(gl.NOTEQUAL,0,1);gl.stencilOp(gl.ZERO,gl.ZERO,gl.ZERO);gl.stencilMask(255); + glFill(gl,col);gl.disable(gl.STENCIL_TEST);} +function glEllipses(gl,vao,n,ks,col){const P=GLX.ell;gl.useProgram(P.p);gl.bindVertexArray(vao);gl.uniform2f(P.u.uView,CW,CH);gl.uniform1f(P.u.uDpr,DPR);gl.uniform4fv(P.u.uCol,col); + for(const k of ks){gl.uniform3f(P.u.uCam,cam.x-k*W,cam.y,cam.z);gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,n);}} +// In paintWorld()'s order: the shadow (5, 7 px down and right), the sand, the grass, the hills, the coastline. +function glLand(gl,ks){const G=glLandGeo(gl,lodFar()); + glLandFill(gl,G,ks,5,7,LAND_SHADOW); + glLines(gl,G.sand,G.nSeg,ks); + glLandFill(gl,G,ks,0,0,LAND_GRASS); + glEllipses(gl,G.hills,G.nHill,ks,HILL_COL);glEllipses(gl,G.shine,G.nHill,ks,HILL_SHINE); + glLines(gl,G.edge,G.nSeg,ks);} +// The waves: each one two quadratic curves of four segments, swaying with the map's clock as in drawFrame(). They are +// written into the same array every frame (no garbage for the collector to pick up while you play). +const WAVE_COL=glColor('rgba(255,255,255,.45)'); +function glWaves(gl,now,ks){const A=GLX.wa||(GLX.wa=new Float32Array(WAVES.length*8*LINE_STRIDE)),ph0=now/900;let m=0; + for(const [x,y,ph] of WAVES){const o=Math.sin(ph0+ph*6)*3; + for(const [x0,cx,cy,x1] of [[x-9+o,x-4.5+o,y-4,x+o],[x+o,x+4.5+o,y+4,x+9+o]]){let px=x0,py=y; + for(let j=1;j<=4;j++){const t=j/4,u=1-t,qx=u*u*x0+2*u*t*cx+t*t*x1,qy=u*u*y+2*u*t*cy+t*t*y;glSegAt(A,m++,px,py,qx,qy,0,2,0,0,WAVE_COL[3],WAVE_COL);px=qx;py=qy;}}} + gl.bindBuffer(gl.ARRAY_BUFFER,GLX.wv.b);gl.bufferData(gl.ARRAY_BUFFER,A.subarray(0,m*LINE_STRIDE),gl.DYNAMIC_DRAW);glLines(gl,GLX.wv.v,m,ks);} +// The clouds: their puffs are stencilled as one shape, then filled once, so overlapping puffs do not stack. +function glClouds(gl,now,ks){const A=[];for(const k of ks)for(const c of CLOUDS){const x=((c.x+now/1000*c.v)%(W+200))-100+k*W,y=c.y; + A.push(x,y,16*c.s,0, x+18*c.s,y-8*c.s,20*c.s,0, x+40*c.s,y,15*c.s,0);} + if(!A.length)return;const F=new Float32Array(A),P=GLX.circ;gl.bindBuffer(gl.ARRAY_BUFFER,GLX.cl.b);gl.bufferData(gl.ARRAY_BUFFER,F,gl.DYNAMIC_DRAW); + gl.enable(gl.STENCIL_TEST);gl.stencilFunc(gl.ALWAYS,1,255);gl.stencilOp(gl.KEEP,gl.KEEP,gl.REPLACE);gl.colorMask(false,false,false,false); + gl.useProgram(P.p);gl.bindVertexArray(GLX.cl.v);gl.uniform2f(P.u.uView,CW,CH);gl.uniform3f(P.u.uCam,cam.x,cam.y,cam.z);gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,F.length/4); + gl.colorMask(true,true,true,true);gl.stencilFunc(gl.EQUAL,1,255);gl.stencilOp(gl.KEEP,gl.KEEP,gl.KEEP);glFill(gl,CLOUD_COL);gl.disable(gl.STENCIL_TEST);} +// The cables, as drawCables() strokes them: rebuilt only when the highlighted city or the architect view changes. +function glCables(gl,ks,selC,ar){const key=[selC,ar]; + if(!GLX.ckey||key.some((v,i)=>v!==GLX.ckey[i])){const A=[]; + for(const cp of CABLE_PAIRS){const hot=!!selC&&(cp.a===selC||cp.b===selC);if(ar&&!hot&&!(arKind(cp.a)&&arKind(cp.b)))continue; + const C=CAB[cp.cid],[r,g,b]=glColor(cableCol(C)),col=[r,g,b,hot?.95:.4];let cum=0; + for(let j=0;j+1d.length?`if(k==${i})return vec2(${d[0]}.,${d[1]}.);`:'').join('')}return vec2(0.);} +void main(){vec2 h=uView*.5,a=(aSeg.xy-uCam.xy)*uCam.z+h,b=(aSeg.zw-uCam.xy)*uCam.z+h; + float w=aP.y*uWMul,hw=w*.5;int fl=int(aP.w+.5);vec4 col=vec4(aC.yzw,1.);vec2 dash=dashOf(int(aP.z+.5));bool skip=false; + if(uPass==${LP.halo}){hw=(w+14.)*.5;col=vec4(1.,79./255.,154./255.,.35);dash=vec2(0.);skip=(fl&${LINE_SEL})==0;} + else if(uPass==${LP.casing}){hw=(w+4.)*.5;col=vec4(30./255.,38./255.,64./255.,1.);} + else if(uPass==${LP.dots}){hw=max(1.,w*.25)*.5;col=vec4(1.,1.,1.,.75);dash=dashOf(5);skip=(fl&${LINE_FIBER})==0||uBusy>.5;} + else if(uPass==${LP.plain})col.a=aC.x; + if(skip){gl_Position=vec4(2.,2.,2.,1.);return;} + vec2 d=b-a;float L=length(d);vec2 t=L>1e-4?d/L:vec2(1.,0.),n=vec2(-t.y,t.x);float m=hw+1./uDpr; + float sx=(gl_VertexID&1)==0?-m:L+m,sy=(gl_VertexID&2)==0?-m:m; + vLoc=vec2(sx,sy);vLen=L;vS0=aP.x*uCam.z;vHalf=hw;vCol=col;vDash=dash;vButt=uPass==${LP.plain}&&(fl&${LINE_ROUND})==0?1.:0.; + gl_Position=clip(a+t*sx+n*sy,uView,(uPass==${LP.plain}?.9998:aC.x)*2.-1.);}`; +const GL_LINE_FS=GL_HEAD+`in vec2 vLoc;in float vLen,vS0,vHalf,vButt;flat in vec4 vCol;flat in vec2 vDash;uniform float uDpr;out vec4 o; +void main(){float x=vLoc.x,y=vLoc.y,d; + if(vButt>.5&&(x<0.||x>vLen))discard; + if(vDash.x<=0.){float c=clamp(x,0.,vLen);d=length(vec2(x-c,y));} + else{float P=vDash.x+vDash.y,g=vS0+x,k=floor(g/P);d=1e9; + for(int i=-1;i<=1;i++){float a0=(k+float(i))*P,lo=max(a0,vS0),hi=min(a0+vDash.x,vS0+vLen);if(lo<=hi){float c=clamp(g,lo,hi);d=min(d,length(vec2(g-c,y)));}}} + float al=clamp((vHalf-d)*uDpr+.5,0.,1.);if(al<=0.)discard;o=vec4(vCol.rgb*vCol.a*al,vCol.a*al);}`; +// Plain lines (coasts, waves, cables): colour and opacity from the data, flat ends unless LINE_ROUND, under the tubes. +function glLines(gl,vao,n,ks){const L=GLX.line;gl.useProgram(L.p);gl.bindVertexArray(vao);gl.uniform1i(L.u.uPass,LP.plain);gl.uniform1f(L.u.uBusy,0); + for(const k of ks){glSet(gl,L,k,1);gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,n);}} +/* Packets: one instance per packet; where it is on its tube comes from the tube's points (a float texture of x, y and + the share of the length so far, GL_PTS_W texels a row), found by bisection the way polyAtXY() finds it. */ +const GL_PTS_W=2048; +const GL_PK_VS=GL_HEAD+GL_CLIP+`layout(location=0) in vec4 aK;layout(location=1) in vec4 aQ; +uniform vec2 uView;uniform vec3 uCam;uniform float uWMul,uDpr,uT,uFar;uniform highp sampler2D uPts; +out vec2 vLoc;flat out float vR,vLw; +vec4 P(int i){return texelFetch(uPts,ivec2(i%${GL_PTS_W},i/${GL_PTS_W}),0);} +void main(){float n=uFar>.5?max(1.,floor(aK.w*.5)):aK.w,i=aQ.x;if(i>=n){gl_Position=vec4(2.,2.,2.,1.);return;} + float t=fract(uT*90./max(aK.z*uCam.z,40.)+i/n);if(mod(i,2.)>.5)t=1.-t; + int o=int(aK.x+.5),lo=1,hi=int(aK.y+.5)-1;for(int s=0;s<16&&lop0.z?(t-p0.z)/(p1.z-p0.z):0.;vec2 c=(mix(p0.xy,p1.xy,f)-uCam.xy)*uCam.z+uView*.5; + float w=aQ.y*uWMul,r=uFar>.5?1.6:max(2.2,w*.42),lw=uFar>.5?1.:1.5,m=r+lw*.5+1./uDpr; + vec2 q=vec2((gl_VertexID&1)==0?-m:m,(gl_VertexID&2)==0?-m:m);vLoc=q;vR=r;vLw=lw; + gl_Position=clip(c+q,uView,aQ.z*2.-1.);}`; +const GL_PK_FS=GL_HEAD+`in vec2 vLoc;flat in float vR,vLw;uniform float uDpr;out vec4 o; +void main(){float d=length(vLoc),out_=clamp((vR+vLw*.5-d)*uDpr+.5,0.,1.);if(out_<=0.)discard; + float inn=clamp((vR-vLw*.5-d)*uDpr+.5,0.,1.);vec3 c=mix(vec3(30./255.,38./255.,64./255.),vec3(1.),inn);o=vec4(c*out_,out_);}`; +/* The tubes as instance data: their segments (see LINE_STRIDE; later tubes are nearer), their packets (first point, + points, length, packets | which, base width, depth, -), and every tube's points in the texture. */ +function glBuild(LG,GM,looks,selId){const gl=GLX.gl,N=LG.length;let ns=0,np=0,nk=0; + for(let gi=0;gix.id===selId);if(hot)sel=true;const fl=(hot?LINE_SEL:0)|(L.df&&!L.bld&&!L.dark?LINE_FIBER:0),p0=pi; + for(let j=0;jv!==GLX.key[i])){glBuild(ML.LG,ML.GM,ML.looks,selId);GLX.key=key;} + gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);gl.enable(gl.DEPTH_TEST);gl.depthFunc(gl.LEQUAL);gl.depthMask(true); + const L=GLX.line,K=GLX.pk,wm=sc*(far?0.5:1),lines=(pass)=>{gl.useProgram(L.p);gl.bindVertexArray(GLX.lv.v);gl.uniform1f(L.u.uBusy,busy?1:0);gl.uniform1i(L.u.uPass,pass); + for(const k of ks){glSet(gl,L,k,wm);gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,GLX.nSeg);}}; + if(GLX.nSeg)for(const pass of [LP.casing,LP.colour,LP.dots])lines(pass); + if(GLX.nPk){gl.useProgram(K.p);gl.bindVertexArray(GLX.pv.v);gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLX.tex);gl.uniform1i(K.u.uPts,0); + gl.uniform1f(K.u.uT,now/1000);gl.uniform1f(K.u.uFar,far?1:0);for(const k of ks){glSet(gl,K,k,wm);gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,GLX.nPk);}} + // The selection's halo goes over earlier tubes but under its own line and later ones, as in 2D. + if(GLX.sel&&GLX.nSeg){gl.depthFunc(gl.LESS);gl.depthMask(false);lines(LP.halo);gl.depthMask(true);} + gl.bindVertexArray(null);} diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js new file mode 100644 index 0000000..ff44065 --- /dev/null +++ b/src/game/96-map/59-gl-sprites.js @@ -0,0 +1,76 @@ +/* Pictures on the card. Cities, labels, markers and everything that bobs or pulses on them (cones, ships, offer + bubbles, hot badges, floaters) are painted once with the 2D canvas, packed into one texture (the atlas), and drawn + as instanced quads, with the small round things (lights, steam, glows) as discs, in one draw per frame after the + tubes. Without WebGL the same calls draw the pictures with the 2D canvas, so the map's code does not care which. */ +const SPR_MAX=1400,SPR_STRIDE=13; +const SPRS=new Map(); +const GLS={prog:null,vao:null,buf:null,tex:null,size:4096,shx:0,shy:0,shh:0,frame:false,data:new Float32Array(SPR_STRIDE*2048),n:0}; +/* One record is 13 floats: x,y,w,h (CSS px) | u0,v0,u1,v1 (atlas) | r,g,b,a | kind. A picture (kind 0) takes its + colours from the atlas and a from the record; a disc (kind 1) is centred on x,y with radius w, in colour r,g,b,a. */ +const SPR_VS=GL_HEAD+`layout(location=0) in vec4 aP;layout(location=1) in vec4 aUV;layout(location=2) in vec4 aC;layout(location=3) in float aK; +uniform vec2 uDev;uniform float uDpr;out vec2 vUV,vQ;out vec4 vC;flat out float vK,vR; +void main(){vec2 c=vec2((gl_VertexID&1)==0?0.:1.,(gl_VertexID&2)==0?0.:1.),p; + if(aK>.5){float m=aP.z+1./uDpr;vQ=(c*2.-1.)*m;vR=aP.z;vUV=vec2(0.);p=aP.xy+vQ;} + else{vQ=vec2(0.);vR=0.;vUV=mix(aUV.xy,aUV.zw,c);p=aP.xy+c*aP.zw;} + vC=aC;vK=aK;gl_Position=vec4(p.x*uDpr/uDev.x*2.-1.,1.-p.y*uDpr/uDev.y*2.,0.,1.);}`; +const SPR_FS=GL_HEAD+`uniform sampler2D uTex;uniform float uDpr;in vec2 vUV,vQ;in vec4 vC;flat in float vK,vR;out vec4 o; +void main(){if(vK>.5){float a=clamp((vR-length(vQ))*uDpr+.5,0.,1.)*vC.a;if(a<=0.)discard;o=vec4(vC.rgb*a,a);} + else o=texture(uTex,vUV)*vC.a;}`; +function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4,4,1]);GLS.vao=v;GLS.buf=b; + // 4096 px square (64 MB), or what the card allows if that is less (some phones). + GLS.size=Math.min(4096,gl.getParameter(gl.MAX_TEXTURE_SIZE)||4096); + GLS.tex=gl.createTexture();gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex); + gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,GLS.size,GLS.size,0,gl.RGBA,gl.UNSIGNED_BYTE,null); + for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.LINEAR); + for(const k of [gl.TEXTURE_WRAP_S,gl.TEXTURE_WRAP_T])gl.texParameteri(gl.TEXTURE_2D,k,gl.CLAMP_TO_EDGE); + GLS.shx=GLS.shy=GLS.shh=0;} +// Forgets every picture and starts the atlas again, after the pictures already queued are drawn (they point into it). +function spritesReset(){glsDrawNow();SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} +// A picture of w×h CSS px with its anchor at (ax,ay): painted once by paint(g) (the 2D canvas, at the screen's pixel +// density, which is part of the key), and kept in SPRS. +function spriteEntry(key,w,h,ax,ay,paint){key=DPR+'|'+key;let e=SPRS.get(key);if(e)return e; + if(SPRS.size>=SPR_MAX)spritesReset(); + const cv=document.createElement('canvas');cv.width=Math.ceil(w*DPR);cv.height=Math.ceil(h*DPR); + const g=cv.getContext('2d'),saved=ctx;ctx=g; + try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;} + e={cv,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1};SPRS.set(key,e);return e;} +// Puts a picture into the atlas (once), shelf by shelf. A full atlas starts again; this picture then waits a frame. +function glsEnsure(e){if(e.up)return true;const gl=GLX.gl;if(!gl||!GLS.prog)return false; + const pw=e.cv.width,ph=e.cv.height,A=GLS.size;if(pw>A||ph>A)return false; + if(GLS.shx+pw>A){GLS.shx=0;GLS.shy+=GLS.shh;GLS.shh=0;} + if(GLS.shy+ph>A){spritesReset();return false;} + const x=GLS.shx,y=GLS.shy;GLS.shx+=pw;GLS.shh=Math.max(GLS.shh,ph); + gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,true); + gl.texSubImage2D(gl.TEXTURE_2D,0,x,y,gl.RGBA,gl.UNSIGNED_BYTE,e.cv);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false); + Object.assign(e,{up:true,u0:x/A,v0:y/A,u1:(x+pw)/A,v1:(y+ph)/A});return true;} +// The next record in GLS.data, which grows as needed. +function glsNext(){if((GLS.n+1)*SPR_STRIDE>GLS.data.length){const nd=new Float32Array(GLS.data.length*2);nd.set(GLS.data);GLS.data=nd;}return GLS.n++*SPR_STRIDE;} +// Draws a picture at (x,y) of w×h CSS px, on the card for a frame drawn there, else with the 2D canvas. +function blit(e,x,y,w,h){if(GLS.frame&&glsEnsure(e)){const d=GLS.data,o=glsNext(); + d[o]=x;d[o+1]=y;d[o+2]=w;d[o+3]=h;d[o+4]=e.u0;d[o+5]=e.v0;d[o+6]=e.u1;d[o+7]=e.v1;d[o+8]=d[o+9]=d[o+10]=0;d[o+11]=ctx.globalAlpha;d[o+12]=0;} + else ctx.drawImage(e.cv,x,y,w,h);} +// A round dot of radius r at (x,y), in colour col (CSS colour string) at opacity a, on the card or the 2D canvas. +function dot(x,y,r,col,a){if(GLS.frame){const c=glColor(col),d=GLS.data,o=glsNext(); + d[o]=x;d[o+1]=y;d[o+2]=r;d[o+3]=d[o+4]=d[o+5]=d[o+6]=d[o+7]=0;d[o+8]=c[0];d[o+9]=c[1];d[o+10]=c[2];d[o+11]=(a===undefined?ctx.globalAlpha:a)*c[3];d[o+12]=1;} + else{const sa=ctx.globalAlpha;if(a!==undefined)ctx.globalAlpha=a;ctx.fillStyle=col;ctx.beginPath();ctx.arc(x,y,r,0,7);ctx.fill();ctx.globalAlpha=sa;}} +// A small picture w×h px at scale k with its anchor at (ax,ay), painted once by paint(g) with the origin on the anchor +// (k in steps of 1/24, as the cities), then drawn with the anchor at (x,y). Things that bob or pulse are drawn as these +// at a moving place, so the overlay above the card stays untouched (repainting it costs a whole screen of pixels). +function stamp(key,w,h,ax,ay,k,x,y,paint){const kq=Math.max(1/24,Math.round(k*24)/24),r=k/kq; + const e=spriteEntry(key+'|'+kq,Math.ceil(w*kq),Math.ceil(h*kq),ax*kq,ay*kq,g=>{g.translate(ax*kq,ay*kq);g.scale(kq,kq);paint(g);}); + blit(e,x-e.ax*r,y-e.ay*r,e.w*r,e.h*r);} +// Text with an outline, centred on (x,y), as a picture placed on whole device pixels; tw is its width, px its size. +function textStamp(t,font,px,tw,fill,stroke,lw,x,y){const W=Math.ceil(tw+lw+4),H=Math.ceil(px*1.5+lw+2); + const e=spriteEntry(['txt',t,font,fill,stroke,lw].join('|'),W,H,W/2,H/2,g=>{g.translate(W/2,H/2);g.font=font;g.textAlign='center';g.textBaseline='middle'; + if(lw){g.lineWidth=lw;g.lineJoin='round';g.strokeStyle=stroke;g.strokeText(t,0,0);}g.fillStyle=fill;g.fillText(t,0,0);}); + blit(e,Math.round((x-e.w/2)*DPR)/DPR,Math.round((y-e.h/2)*DPR)/DPR,e.w,e.h);} +// Sends the queued pictures to the card in one draw. +function glsDrawNow(){const gl=GLX.gl;if(!gl||!GLS.prog||!GLS.n){GLS.n=0;return;} + gl.useProgram(GLS.prog.p);gl.bindVertexArray(GLS.vao);gl.bindBuffer(gl.ARRAY_BUFFER,GLS.buf); + gl.bufferData(gl.ARRAY_BUFFER,GLS.data.subarray(0,GLS.n*SPR_STRIDE),gl.STREAM_DRAW); + gl.uniform2f(GLS.prog.u.uDev,GLX.c.width,GLX.c.height);gl.uniform1f(GLS.prog.u.uDpr,DPR);gl.uniform1i(GLS.prog.u.uTex,0); + gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex); + gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);gl.disable(gl.DEPTH_TEST); + gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,GLS.n);gl.bindVertexArray(null);GLS.n=0;} +// The end of a frame on the card: the pictures go up over the tubes. +function glsFrameEnd(){if(GLS.frame){glsDrawNow();GLS.frame=false;}} diff --git a/src/game/96-map/60-draw.js b/src/game/96-map/60-draw.js index 6324735..321fff0 100644 --- a/src/game/96-map/60-draw.js +++ b/src/game/96-map/60-draw.js @@ -1,11 +1,19 @@ -function draw(now){DFC=new Map();try{drawFrame(now);}finally{DFC=null;}} +function draw(now){DFC=new Map();try{drawFrame(now);}finally{DFC=null;glsFrameEnd();ctx=CTX0;}} +// Rectangles on a 64 px grid: a new one is compared only with the few that share its cells (a plain list made the +// label placement quadratic in the number of cities). +class RGrid{constructor(){this.m=new Map();} + cells(r,f){for(let cx=Math.floor(r.x/64);cx<=Math.floor((r.x+r.w)/64);cx++)for(let cy=Math.floor(r.y/64);cy<=Math.floor((r.y+r.h)/64);cy++)f(cx*100003+cy);} + push(r){this.cells(r,k=>{const a=this.m.get(k);if(a)a.push(r);else this.m.set(k,[r]);});} + hits(r){let h=false;this.cells(r,k=>{if(h)return;const a=this.m.get(k);if(a)for(const q of a)if(r.xlinkGeom(g[0],PI.get(edgeKey(g[0])))),busy=linesOnScreen(GM,ks)>MAP_BUSY; - for(let gi=0;gi1,up=many?grp.filter(x=>!linkDown(x)):null; - const gm=GM[gi],cap=many?up.reduce((a,x)=>a+capOf(x),0):capOf(l),load=many?grp.reduce((a,x)=>a+(R.load[x.id]||0),0):(R.load[l.id]||0),u=cap?load/cap:0,df=l.kind==='df',bld=df&&l.ready>day,cut=!bld&&(many?!up.length:linkDown(l))&&!(df&&!(l.ch||[]).length),dark=df&&!bld&&!(l.ch||[]).length,vx=l.kind==='vxc',idle=!cut&&!bld&&load<1e-3&&(many?up.length>0&&up.every(x=>x.standby):!!l.standby); + const far=lodFar(),ML=mapLinks(day),LG=ML.LG,GM=ML.GM,PI=ML.PI,busy=linesOnScreen(GM,ks)>MAP_BUSY; + // WebGL on: the card draws every line and packet now, and the rest (labels, markers, cities…) goes on the overlay. + const G=glOn();if(G)glFrame(ML,ks,far,busy,now,sc);else glShow(false); + for(let gi=0;gix.id===UI.sel.id))||(pz&&pzLinkHot(grp));let lab=null; - const w=(vx?2.2:(2.5+Math.max(...grp.map(tierW))*1.8+(many?Math.min(1.5,(grp.length-1)*0.5):0)))*sc*(far?0.5:1),np=gm.pts.length; + // Only what sits at the middle of a line is still painted here when the card draws the lines. + if(G&&!(bld||cut&&!vx||sel||z>0.9&&!busy))continue; + const w=w0*sc*(far?0.5:1),np=gm.pts.length; if(SX.length{let a=Infinity,b=-Infinity,c=Infinity,d=-Infinity;for(const p of gm.pts){if(p[0]b)b=p[0];if(p[1]d)d=p[1];}return [a,b,c,d];})()); if((bb[1]+k*W-cam.x)*cam.z+CW/2<-40||(bb[0]+k*W-cam.x)*cam.z+CW/2>CW+40||(bb[3]-cam.y)*cam.z+CH/2<-40||(bb[2]-cam.y)*cam.z+CH/2>CH+40)continue; + let mxx,my; + if(G){const m=gm.mid||(gm.mid=polyAt(gm.pts,gm.cum,.5));mxx=(m[0]+k*W-cam.x)*cam.z+CW/2;my=(m[1]-cam.y)*cam.z+CH/2;}else{ // Screen points as toS() gives them, kept in SX/SY. for(let i=0;i{ctx.beginPath();ctx.moveTo(SX[0],SY[0]);for(let i=1;i0.001?utilCol(u):'#7FD8EE'):utilCol(u);ctx.lineWidth=w;ctx.stroke();ctx.setLineDash([]); + ctx.strokeStyle='#1E2640';ctx.lineWidth=w+4;ctx.setLineDash(LDASH[dash]);path();ctx.stroke(); + ctx.strokeStyle=col;ctx.lineWidth=w;ctx.stroke();ctx.setLineDash([]); // Architect runs: tubes sharing one trench are drawn as strands of one bundle (one snip takes them all). if(pz&&many){ctx.strokeStyle='#1E2640';ctx.lineWidth=1.3;for(let j=1;jpolyAtXY(SX,SY,gm.cum,t); - if(!cut&&load>0.01){const n=clamp(Math.round(2+u*10),2,12)>>(far?1:0)||1,len=gm.len*z,spd=90; + if(pk){const n=pk>>(far?1:0)||1,len=gm.len*z,spd=90; ctx.fillStyle='#fff';ctx.strokeStyle='#1E2640';ctx.lineWidth=far?1:1.5; const rr2=far?1.6:Math.max(2.2,w*.42),base=now/1000*spd/Math.max(len,40);ctx.beginPath();for(let i=0;i0.9&&!busy)){const t=lab||(lab=pz?pzLinkLab(grp,up||[l],load,cap):many?groupLabel(grp,up):capName(l));ctx.font='800 11px "Baloo 2", sans-serif';let tw=LINKW.get(t);if(tw===undefined)LINKW.set(t,tw=ctx.measureText(t).width+10);ctx.fillStyle='#fff';ctx.strokeStyle='#1E2640';ctx.lineWidth=2;rr(mxx-tw/2,my-9,tw,17,8);ctx.fill();ctx.stroke();ctx.fillStyle='#1E2640';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(t,mxx,my+1);} + [mxx,my]=at(.5);} + if(bld){if(far)stamp('bldfar',12,12,6,6,1,mxx,my,g=>{g.fillStyle='#FF8A3D';g.strokeStyle='#1E2640';g.lineWidth=1.5;g.beginPath();g.arc(0,0,4,0,7);g.fill();g.stroke();});else drawCone(mxx,my,now);} + else if(cut&&!vx){if(far)stamp('cutfar',14,14,7,7,1,mxx,my,g=>{g.fillStyle='#FF4D5E';g.strokeStyle='#1E2640';g.lineWidth=1.5;g.beginPath();g.arc(0,0,5,0,7);g.fill();g.stroke();g.fillStyle='#fff';g.font='900 8px Nunito, sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText('!',0,0.5);});else if(!arPz)drawBackhoe(mxx,my,now,l.sub);} + else if(sel||(pz?!S.ar:z>0.9&&!busy)){const t=lab||(lab=pz?pzLinkLab(grp,up||[l],load,cap):many?groupLabel(grp,up):capName(l));ctx.font='800 11px "Baloo 2", sans-serif';let tw=LINKW.get(t);if(tw===undefined)LINKW.set(t,tw=ctx.measureText(t).width+10);pill(t,ctx.font,tw,17,8,'#fff','#1E2640','#1E2640',2,mxx,my-0.5,1.5);} // Every puzzle: say whether the tubes between two cities share one trench or take separate paths. if(pz&&!cut&&!bld&&(many||arPaths(l)>1)&&(many||lineIdx(l,PI.get(edgeKey(l)))===0))AR_PILLS.push([mxx,my+(sel||!S.ar?19:0),many?tr('architect.n_in_one_trench',{n:grp.length}):'✓ '+tr('architect.n_paths',{n:arPaths(l)}),many]); } @@ -78,7 +92,7 @@ function drawFrame(now){ // Place labels: your POPs and the selected city first, then others; a label that would overlap moves above its city or hides. const vis=[];for(const C of CITIES){if(C.off&&!cityOn(C.id))continue;if(pzHide(C.id))continue;for(const k of ks){const [sx,sy]=toS(C.x,C.y,k);if(sx<-60||sx>CW+60||sy<-60||sy>CH+60)continue;vis.push({C,sx,sy});}} const prio=v=>(UI.sel&&UI.sel.type==='city'&&UI.sel.id===v.C.id?0:S.pops[v.C.id]?1:2);vis.sort((a,b)=>prio(a)-prio(b)||b.C.P-a.C.P); - const rects=[],labs=[],hit=(r)=>rects.some(q=>r.xrects.hits(r); const farL=lodFar(); // Which cities show an offer bubble (a big one?) or an incident marker, worked out once for all of them. CM.off=new Set();CM.big=new Set();for(const o of S.offers){const big=BIZ_T[o.type].lv>=3||BIZ_T[o.type].event;for(const c of bCities(o)){CM.off.add(c);if(big)CM.big.add(c);}} @@ -93,7 +107,7 @@ function drawFrame(now){ const h=farL?6:cityTop(v.C.id,p);const below=farL?v.sy+15:v.sy+16*csc+8,above=farL?v.sy-15:v.sy-h*csc-17*csc;let ly=null; for(const y of [below,above]){const r={x:v.sx-tw/2-2,y:y-10,w:tw+4,h:21};if(!hit(r)){ly=y;rects.push(r);labs.push(r);break;}} // Your POPs may sit over a city icon, but not over another name: that one waits until you zoom in. - if(ly===null&&prio(v)===1)for(const y of [below,above]){const r={x:v.sx-tw/2,y:y-10,w:tw,h:21};if(!labs.some(q=>r.x=0;i--){const f=FLOATS[i],a=(now-f.t)/1600;if(a>1){FLOATS.splice(i,1);continue;} - for(const k of ks){const [sx,sy]=toS(f.x,f.y,k);ctx.globalAlpha=1-a*a;ctx.font='800 17px "Baloo 2", sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.lineWidth=4;ctx.strokeStyle='#fff';ctx.strokeText(f.text,sx,sy-a*40);ctx.fillStyle=f.col;ctx.fillText(f.text,sx,sy-a*40);ctx.globalAlpha=1;}} + const font='800 17px "Baloo 2", sans-serif';if(f.w===undefined){ctx.font=font;f.w=ctx.measureText(f.text).width;} + for(const k of ks){const [sx,sy]=toS(f.x,f.y,k);ctx.globalAlpha=1-a*a;textStamp(f.text,font,17,f.w,f.col,'#fff',4,sx,sy-a*40);ctx.globalAlpha=1;}} } /* A map with more than MAP_BUSY lines on screen (huge late-game networks) is a tangle where nobody reads thousands of overlapping labels or fiber dots, and painting them took about half of every frame. They come back once fewer lines @@ -116,7 +131,7 @@ function linesOnScreen(GM,ks){let n=0;for(const gm of GM){const b=gm.box||(gm.bo for(const k of ks){const x0=(b[0]+k*W-cam.x)*cam.z+CW/2,x1=(b[2]+k*W-cam.x)*cam.z+CW/2,y0=(b[1]-cam.y)*cam.z+CH/2,y1=(b[3]-cam.y)*cam.z+CH/2; if(!(x1<-40||x0>CW+40||y1<-40||y0>CH+40))n++;}}return n;} function ptsBox(pts){let a=Infinity,b=Infinity,c=-Infinity,d=-Infinity;for(const p of pts){if(p[0]c)c=p[0];if(p[1]>d)d=p[1];}return [a,b,c,d];} -function drawCone(x,y,now){const b=Math.sin(now/300)*1.5;ctx.save();ctx.translate(x,y-12+b);ctx.strokeStyle='#1E2640';ctx.lineWidth=2;ctx.fillStyle='#FF8A3D';ctx.beginPath();ctx.moveTo(-7,9);ctx.lineTo(0,-10);ctx.lineTo(7,9);ctx.closePath();ctx.fill();ctx.stroke();ctx.fillStyle='#fff';ctx.fillRect(-4,-1,8,3);ctx.fillStyle='#1E2640';rr(-10,8,20,4,2);ctx.fill();ctx.restore();} +function drawCone(x,y,now){stamp('cone',26,28,13,13,1,x,y-12+Math.sin(now/300)*1.5,()=>{ctx.strokeStyle='#1E2640';ctx.lineWidth=2;ctx.fillStyle='#FF8A3D';ctx.beginPath();ctx.moveTo(-7,9);ctx.lineTo(0,-10);ctx.lineTo(7,9);ctx.closePath();ctx.fill();ctx.stroke();ctx.fillStyle='#fff';ctx.fillRect(-4,-1,8,3);ctx.fillStyle='#1E2640';rr(-10,8,20,4,2);ctx.fill();});} // Static land + cable map, rendered once per zoom bucket into an offscreen canvas. function paintWorld(c,z,withCables){const LANDP=lodFar()?LANDP_FAR:LANDP_ALL; for(const o of [0,W,-W]){c.save();c.translate(o+5/z,7/z);c.fillStyle='rgba(20,90,130,.35)';for(const p of LANDP)c.fill(p);c.restore();} diff --git a/src/game/96-map/70-world-layer.js b/src/game/96-map/70-world-layer.js index ab36726..426de70 100644 --- a/src/game/96-map/70-world-layer.js +++ b/src/game/96-map/70-world-layer.js @@ -21,14 +21,12 @@ function worldLayer(z){ function drawWorldLayer(wl,k,z,k0){if(!wl.full&&k!==k0)return;const f=z*DPR/wl.sc,ox=(wl.full?k*W:wl.ox); ctx.setTransform(1,0,0,1,0,0);ctx.drawImage(wl.cv,Math.round(DPR*((ox-cam.x)*z+CW/2)),Math.round(DPR*((wl.oy-cam.y)*z+CH/2)),wl.cv.width*f,wl.cv.height*f);} function cableCol(C){return C.price<=0.85?'#14A88C':C.price<=1.1?'#2F7BEA':'#A05AE0';} -function drawBackhoe(x,y,now,sub){ - const b=Math.sin(now/180)*2;ctx.save();ctx.translate(x,y-14+b); +function drawBackhoe(x,y,now,sub){stamp('hoe|'+(sub?1:0),38,32,15,16,1,x,y-14+Math.sin(now/180)*2,()=>{ ctx.strokeStyle='#1E2640';ctx.lineWidth=2.2; if(sub){ // shark fin ctx.fillStyle='#6B7C99';ctx.beginPath();ctx.moveTo(-12,8);ctx.quadraticCurveTo(-2,-14,10,-12);ctx.quadraticCurveTo(4,-2,12,8);ctx.closePath();ctx.fill();ctx.stroke(); }else{ ctx.fillStyle='#FFD23F';rr(-12,-4,18,12,3);ctx.fill();ctx.stroke();rr(-8,-12,10,9,2);ctx.fillStyle='#BDE8FF';ctx.fill();ctx.stroke(); ctx.beginPath();ctx.moveTo(6,0);ctx.lineTo(14,-10);ctx.lineTo(19,2);ctx.stroke();ctx.fillStyle='#1E2640';ctx.beginPath();ctx.arc(-7,10,3,0,7);ctx.arc(2,10,3,0,7);ctx.fill(); - } - ctx.restore(); + }}); } diff --git a/src/game/96-map/80-cities.js b/src/game/96-map/80-cities.js index 31b55ec..d3be7ae 100644 --- a/src/game/96-map/80-cities.js +++ b/src/game/96-map/80-cities.js @@ -1,12 +1,26 @@ // Label widths by text (city labels by id, link labels and far-view labels by text): measuring text every frame is slow. const LBLW={},LINKW=new Map(),LBLF=new Map(),CM={off:new Set(),big:new Set(),inc:new Set(),far:false}; -try{document.fonts&&document.fonts.ready.then(()=>{for(const k in LBLW)delete LBLW[k];LINKW.clear();LBLF.clear();FRAME.length=0;});}catch(e){} +try{document.fonts&&document.fonts.ready.then(()=>{for(const k in LBLW)delete LBLW[k];LINKW.clear();LBLF.clear();FRAME.length=0;spritesReset();});}catch(e){} +// A label on a pill: its text and look never change, so it is painted once (spriteEntry) and drawn as a picture. The +// centre is x, y; the text sits at y+ty. The pill's box is w×h with corners r; the picture also takes the outline. +function pill(t,font,w,h,r,fill,ink,stroke,lw,x,y,ty){ + const pad=lw+2,W=Math.ceil(w+pad*2),H=Math.ceil(h+pad*2),key=['pill',t,font,w,h,r,fill,ink,stroke,lw,ty].join('|'); + const e=spriteEntry(key,W,H,W/2,H/2,g=>{g.translate(W/2,H/2);g.fillStyle=fill;g.strokeStyle=stroke;g.lineWidth=lw; + rr(-w/2,-h/2,w,h,r);g.fill();g.stroke();g.fillStyle=ink;g.font=font;g.textAlign='center';g.textBaseline='middle';g.fillText(t,0,ty);}); + // Whole device pixels, so the text stays as sharp as before. + blit(e,Math.round((x-e.w/2)*DPR)/DPR,Math.round((y-e.h/2)*DPR)/DPR,e.w,e.h);} +// Zoomed out a city is a small picture (a dot, or your POP's box), kept as a sprite; a POP in trouble glows under it. function drawCityFar(C,sx,sy,sc,now,lyOverride){ const p=S.pops[C.id],down=p&&p.down>S.day,sel=UI.sel&&UI.sel.type==='city'&&UI.sel.id===C.id,hov=UI.hover===C.id||(UI.snap&&UI.snap.id===C.id); - ctx.save();ctx.translate(sx,sy);ctx.strokeStyle='#1E2640'; - if(sel){ctx.strokeStyle='#FF4F9A';ctx.lineWidth=2.5;ctx.setLineDash([4,4]);ctx.lineDashOffset=-now/40;ctx.beginPath();ctx.arc(0,0,p?14:9,0,7);ctx.stroke();ctx.setLineDash([]);ctx.strokeStyle='#1E2640';} + if(p&&!down&&R.cityDem[C.id]>0&&sfOf(R,C.id)<0.9)dot(sx,sy,12,'rgba(255,77,94,1)',.35+.25*Math.sin(now/200)); + const t=cTier(C.id),ph=sel?Math.floor(now/40)%8:-1,key=['far',p?1:0,down?1:0,p&&p.site2?1:0,p?(p.routers||1)>=2?1:0:0,t,hov?1:0,hasIxAt(C.id)?1:0,CM.off.has(C.id)?1:0,CM.inc.has(C.id)?1:0,ph].join('|'); + stamp(key,36,36,18,18,1,sx,sy,()=>cityFarStatic(C,p,down,sel,hov,ph)); + if(lyOverride!==null&&(p||sel||hov)){ctx.font=`800 ${p?12:11}px "Baloo 2", sans-serif`;const t=C.name,wk=C.id+(p?1:0);let tw=LBLF.get(wk);if(tw===undefined)LBLF.set(wk,tw=ctx.measureText(t).width+12);const ly=lyOverride==null?sy+15:lyOverride; + pill(t,ctx.font,tw,16,8,p?'#FF4F9A':'#FFFFFF',p?'#FFFFFF':'#1E2640','#1E2640',1.6,sx,ly,1);} +} +function cityFarStatic(C,p,down,sel,hov,ph){ctx.strokeStyle='#1E2640'; + if(sel){ctx.strokeStyle='#FF4F9A';ctx.lineWidth=2.5;ctx.setLineDash([4,4]);ctx.lineDashOffset=-ph;ctx.beginPath();ctx.arc(0,0,p?14:9,0,7);ctx.stroke();ctx.setLineDash([]);ctx.lineDashOffset=0;ctx.strokeStyle='#1E2640';} if(p){ - if(!down&&R.cityDem[C.id]>0&&sfOf(R,C.id)<0.9){ctx.fillStyle=`rgba(255,77,94,${.35+.25*Math.sin(now/200)})`;ctx.beginPath();ctx.arc(0,0,12,0,7);ctx.fill();} const col=down?'#8A91A8':'#FF4F9A';ctx.lineWidth=1.8; if(p.site2){ctx.setLineDash([2,2]);ctx.beginPath();ctx.moveTo(0,0);ctx.lineTo(9,6);ctx.stroke();ctx.setLineDash([]);ctx.fillStyle=col;rr(5,3,9,7,3);ctx.fill();ctx.stroke();} if((p.routers||1)>=2){ctx.fillStyle=down?'#6E7590':'#D63B7F';rr(-6,-7,15,10,4);ctx.fill();ctx.stroke();} @@ -15,26 +29,25 @@ function drawCityFar(C,sx,sy,sc,now,lyOverride){ const t=cTier(C.id),r=FAR_R[t]*(hov?1.3:1);if(t===4){ctx.fillStyle='rgba(255,255,255,.55)';ctx.beginPath();ctx.arc(0,0,r+4.5,0,7);ctx.fill();} ctx.fillStyle=hasIxAt(C.id)?'#FFD23F':'#FFFFFF';ctx.lineWidth=t>=3?1.6:1.3;ctx.beginPath();ctx.arc(0,0,r,0,7);ctx.fill();ctx.stroke();} if(CM.off.has(C.id)){ctx.fillStyle='#16A866';ctx.lineWidth=1.2;ctx.beginPath();ctx.arc(p?9:5,p?-7:-5,3,0,7);ctx.fill();ctx.stroke();} - if(CM.inc.has(C.id)){ctx.fillStyle='#FF4D5E';ctx.lineWidth=1.2;ctx.beginPath();ctx.arc(p?-9:-5,p?-7:-5,3.4,0,7);ctx.fill();ctx.stroke();} - ctx.restore(); - if(lyOverride!==null&&(p||sel||hov)){ctx.font=`800 ${p?12:11}px "Baloo 2", sans-serif`;const t=C.name,wk=C.id+(p?1:0);let tw=LBLF.get(wk);if(tw===undefined)LBLF.set(wk,tw=ctx.measureText(t).width+12);const ly=lyOverride==null?sy+15:lyOverride; - ctx.fillStyle=p?'#FF4F9A':'#FFFFFF';ctx.strokeStyle='#1E2640';ctx.lineWidth=1.6;rr(sx-tw/2,ly-8,tw,16,8);ctx.fill();ctx.stroke(); - ctx.fillStyle=p?'#FFFFFF':'#1E2640';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(t,sx,ly+1);} -} -function drawCity(C,sx,sy,sc,now,lyOverride,dem){ - if(CM.far)return drawCityFar(C,sx,sy,sc,now,lyOverride); - const hot=(UI.hotMap||{})[C.id]; - const p=S.pops[C.id],down=p&&p.down>S.day,sel=UI.sel&&UI.sel.type==='city'&&UI.sel.id===C.id,hov=UI.hover===C.id||(UI.snap&&UI.snap.id===C.id); - // No room for its skyline here: a quiet dot, a little bigger for bigger cities, until you zoom in (cityRoom). - if(dem&&!p&&!sel&&!hov){const r=(2.6+cTier(C.id)*0.35)*sc;ctx.fillStyle=hasIxAt(C.id)?'#FFD23F':'#FFFFFF';ctx.strokeStyle='#1E2640';ctx.lineWidth=1.6;ctx.beginPath();ctx.arc(sx,sy+2*sc,r,0,7);ctx.fill();ctx.stroke();return;} - const t=cTier(C.id),cs=p?1:CSC[t]; - const k=sc*(hov?1.15:1); - ctx.save();ctx.translate(sx,sy); - if(UI.feed&&UI.feed.has(C.id)){ctx.strokeStyle='#FF8A3D';ctx.lineWidth=4;ctx.setLineDash([3,5]);ctx.beginPath();ctx.arc(0,-6*k,36*k,0,7);ctx.stroke();ctx.setLineDash([]);} - if(sel){ctx.strokeStyle='#FF4F9A';ctx.lineWidth=3;ctx.setLineDash([6,6]);ctx.lineDashOffset=-now/40;ctx.beginPath();ctx.arc(0,-6*k,30*k,0,7);ctx.stroke();ctx.setLineDash([]);} - // A flood is filling ports here: they pulse until it is over (#242). - if(p&&R.ddosHot&&R.ddosHot[C.id]){ctx.strokeStyle='#FF4D5E';ctx.lineWidth=3;ctx.setLineDash([4,4]);ctx.lineDashOffset=now/30;ctx.beginPath();ctx.arc(0,-6*k,33*k,0,7);ctx.stroke();ctx.setLineDash([]);} - if(p&&!down&&R.cityDem[C.id]>0&&sfOf(R,C.id)<0.9){const a=.35+.25*Math.sin(now/200);ctx.fillStyle=`rgba(255,77,94,${a})`;ctx.beginPath();ctx.arc(0,-6*k,26*k,0,7);ctx.fill();} + if(CM.inc.has(C.id)){ctx.fillStyle='#FF4D5E';ctx.lineWidth=1.2;ctx.beginPath();ctx.arc(p?-9:-5,p?-7:-5,3.4,0,7);ctx.fill();ctx.stroke();}} +// A city's picture is painted once per state and kept as a sprite (citySprite). What moves every frame is painted on top +// (cityMoving): the lights, the steam, a flashing IX, the hot badges and the offer bubble. The rings and the glow move too, +// but in steps (cityPhase), so their sprite changes only at a step. +const CSPR_STEP=24; +function cityPhase(C,p,sel,now){const ph={sel:0,dd:0,gl:-1}; + if(sel)ph.sel=Math.floor(now/40)%12; // dash period 12 px, lineDashOffset -now/40 + if(p&&R.ddosHot&&R.ddosHot[C.id])ph.dd=Math.floor(now/30)%8; // dash period 8 px, lineDashOffset now/30 + if(p&&!(p.down>S.day)&&R.cityDem[C.id]>0&&sfOf(R,C.id)<0.9)ph.gl=Math.round((Math.sin(now/200)+1)*3.5); // 8 levels of .35+.25·sin + return ph;} +// The IX badge. Hot (a flood or a fault) it flashes: cityMoving() then draws it from two pictures, one per colour. +function cityIX(C,p,t,h,hot,now){const mine=!!S.myIx[C.id],joined=hasIxAt(C.id),q=!p&&!hot&&ixQuiet(C.id),Rr=q?6.5:8.5,ix=p?19:SKY_W[t]/2+(q?2:4); + ctx.fillStyle=hot?(Math.sin(now/180)>0?'#FF4D5E':'#FF8A3D'):mine?'#FF4F9A':joined?'#FFD23F':'#FFFFFF';ctx.beginPath();for(let i=0;i<6;i++){const a=Math.PI/3*i+Math.PI/6;ctx.lineTo(ix+Rr*Math.cos(a),-h+2+Rr*Math.sin(a));}ctx.closePath();ctx.fill();ctx.lineWidth=q?1.4:2;ctx.stroke(); + ctx.fillStyle=mine||hot?'#fff':'#1E2640';ctx.font=`900 ${q?6.5:8}px Nunito, sans-serif`;ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText('IX',ix,-h+2.5);} +// Everything about the city that does not move, in the city's own frame (origin on the city). Drawn into a sprite. +function cityStatic(C,p,t,cs,k,ph,st){const down=st.down; + if(st.feed){ctx.strokeStyle='#FF8A3D';ctx.lineWidth=4;ctx.setLineDash([3,5]);ctx.beginPath();ctx.arc(0,-6*k,36*k,0,7);ctx.stroke();ctx.setLineDash([]);} + if(st.sel){ctx.strokeStyle='#FF4F9A';ctx.lineWidth=3;ctx.setLineDash([6,6]);ctx.lineDashOffset=-ph.sel;ctx.beginPath();ctx.arc(0,-6*k,30*k,0,7);ctx.stroke();ctx.setLineDash([]);ctx.lineDashOffset=0;} + if(p&&R.ddosHot&&R.ddosHot[C.id]){ctx.strokeStyle='#FF4D5E';ctx.lineWidth=3;ctx.setLineDash([4,4]);ctx.lineDashOffset=ph.dd;ctx.beginPath();ctx.arc(0,-6*k,33*k,0,7);ctx.stroke();ctx.setLineDash([]);ctx.lineDashOffset=0;} ctx.scale(k*cs,k*cs); ctx.fillStyle='rgba(30,38,64,.2)';ctx.beginPath();ctx.ellipse(0,9,p?20:SKY_W[t]/2+5,5,0,0,7);ctx.fill(); const h=p?18:SKY_H[t]; @@ -56,30 +69,56 @@ function drawCity(C,sx,sy,sc,now,lyOverride,dem){ if((p.routers||1)>=2){ctx.fillStyle=down?'#6E7590':'#D63B7F';rr(-13,-13,34,16,6);ctx.fill();ctx.stroke();} if(p.gen){ctx.fillStyle='#FFD23F';rr(-27,-1,9,11,2);ctx.fill();ctx.stroke();} ctx.fillStyle=down?'#8A91A8':'#FF4F9A';rr(-17,-7,34,16,6);ctx.fill();ctx.stroke(); - if(!down&&(R.nodeLoad[C.id]||0)>=(R.nodeCap[C.id]||1e12)*0.95){for(let i=0;i<3;i++){const t=(now/700+i/3)%1;ctx.fillStyle=`rgba(90,98,130,${0.55*(1-t)})`;ctx.beginPath();ctx.arc(6+i*3,-12-t*18,3+t*4,0,7);ctx.fill();}} if((p.rgen||0)>0){const G=RG[p.rgen||0];ctx.fillStyle=G.badge?'#7CFFB2':'#FFD23F';ctx.beginPath();ctx.arc(17,-7,6,0,7);ctx.fill();ctx.lineWidth=1.8;ctx.stroke();ctx.fillStyle='#1E2640';ctx.font='900 8px Nunito, sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(G.badge||String(G.cls+1),17,-6.5);ctx.lineWidth=2.2;} - const sf=sfOf(R,C.id); - for(let i=0;i<4;i++){const on=down?false:(((now/(160+i*37))|0)+i)%3!==0;ctx.fillStyle=down?'#3B4260':on?(sf<0.9?'#FF4D5E':'#7CFFB2'):'#2A3150';ctx.beginPath();ctx.arc(-10+i*6.6,1,2.1,0,7);ctx.fill();} if(down){ctx.fillStyle='#fff';ctx.font='900 14px "Baloo 2", sans-serif';ctx.textAlign='center';ctx.fillText('zzz',20,-14);} if(flip)ctx.restore(); ctx.translate(0,-2); } - const ixn=ixName(C.id); - // The IX badge sits at the skyline's top right, whatever its width. - if(ixn&&(ixShown(C.id,p)||(hot&&hot.ix)||sel||hov)){const mine=!!S.myIx[C.id],joined=hasIxAt(C.id),ixHot=hot&&hot.ix,q=!p&&!ixHot&&ixQuiet(C.id),R=q?6.5:8.5,ix=p?19:SKY_W[t]/2+(q?2:4); - ctx.fillStyle=ixHot?(Math.sin(now/180)>0?'#FF4D5E':'#FF8A3D'):mine?'#FF4F9A':joined?'#FFD23F':'#FFFFFF';ctx.beginPath();for(let i=0;i<6;i++){const a=Math.PI/3*i+Math.PI/6;ctx.lineTo(ix+R*Math.cos(a),-h+2+R*Math.sin(a));}ctx.closePath();ctx.fill();ctx.lineWidth=q?1.4:2;ctx.stroke(); - ctx.fillStyle=mine||ixHot?'#fff':'#1E2640';ctx.font=`900 ${q?6.5:8}px Nunito, sans-serif`;ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText('IX',ix,-h+2.5);} - if(hot&&p){let y=-14;const pulse=.75+.25*Math.sin(now/200);for(const k of ['r','t','p','c']){if(!hot[k])continue;ctx.globalAlpha=pulse;ctx.fillStyle='#FF4D5E';ctx.beginPath();ctx.arc(-29,y,6.5,0,7);ctx.fill();ctx.globalAlpha=1;ctx.lineWidth=2;ctx.strokeStyle='#1E2640';ctx.stroke();ctx.fillStyle='#fff';ctx.font='900 8px Nunito, sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(HOTL[k],-29,y+0.5);y+=14;}} - const off=CM.off.has(C.id); - if(off){const by=-h-16+Math.sin(now/250)*3;ctx.fillStyle='#fff';ctx.lineWidth=2.2;ctx.beginPath();ctx.ellipse(-2,by,11,9,0,0,7);ctx.fill();ctx.stroke();ctx.beginPath();ctx.moveTo(-5,by+8);ctx.lineTo(-7,by+14);ctx.lineTo(0,by+8);ctx.fillStyle='#fff';ctx.fill();const big=CM.big.has(C.id);ctx.fillStyle=big?'#FF4F9A':'#16A866';ctx.font='900 13px "Baloo 2", sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(big?'$$':'$',-2,by+1);} - const inc=CM.inc.has(C.id); - if(inc){ctx.fillStyle='#FF4D5E';ctx.beginPath();ctx.arc(-20,-h+2,7,0,7);ctx.fill();ctx.lineWidth=2;ctx.stroke();ctx.fillStyle='#fff';ctx.font='900 11px Nunito, sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText('!',-20,-h+3);} - ctx.restore(); + if(st.ixDraw&&!st.ixHot)cityIX(C,p,t,h,false,0); + if(st.inc){ctx.fillStyle='#FF4D5E';ctx.beginPath();ctx.arc(-20,-h+2,7,0,7);ctx.fill();ctx.lineWidth=2;ctx.stroke();ctx.fillStyle='#fff';ctx.font='900 11px Nunito, sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText('!',-20,-h+3);} +} +// The picture of a city in a given state, at the quantised scale kq: painted once and kept until it is not needed. +function citySprite(C,p,t,cs,kq,ph,st){ + const key=['city',C.id,t,kq,st.down?1:0,p?1:0,p&&p.site2?1:0,p&&p.site2&&siteDown(C.id,'b')?1:0,p&&p.ringcut>S.day?1:0,p?(p.routers||1):0,p&&p.gen?1:0,p?(p.rgen||0):0,C.au?1:0, + st.ixDraw?1:0,st.ixHot?1:0,ixName(C.id)||'',S.myIx[C.id]?1:0,hasIxAt(C.id)?1:0,!p&&ixQuiet(C.id)?1:0,st.feed?1:0,st.sel?ph.sel:-1,ph.dd,st.inc?1:0].join('|'); + const W=Math.ceil(92*kq),H=Math.ceil(84*kq),ax=45*kq,ay=46*kq; + return spriteEntry(key,W,H,ax,ay,g=>{g.translate(ax,ay);cityStatic(C,p,t,cs,kq,ph,st);});} +// The parts that move, in the city's frame at the true scale k. +function cityMoving(C,p,t,cs,k,sx,sy,now,h,st,hot){const down=st.down,K=k*cs; + if(p){// The POP's own frame is shifted 2 down, and mirrored Down Under (C.au): mp() takes a point of that frame to the city's. + const fl=!!C.au,mp=(x,y)=>fl?[-x,-y-2]:[x,y+2],sf=sfOf(R,C.id),at=(x,y)=>{const q=mp(x,y);return [sx+q[0]*K,sy+q[1]*K];}; + if(!down&&(R.nodeLoad[C.id]||0)>=(R.nodeCap[C.id]||1e12)*0.95){for(let i=0;i<3;i++){const tt=(now/700+i/3)%1,[x,y]=at(6+i*3,-12-tt*18);dot(x,y,(3+tt*4)*K,'rgba(90,98,130,1)',0.55*(1-tt));}} + // The four lights: a disc each, lit or not. + for(let i=0;i<4;i++){const lit=down?false:(((now/(160+i*37))|0)+i)%3!==0,[x,y]=at(-10+i*6.6,1),col=down?'#3B4260':lit?(sf<0.9?'#FF4D5E':'#7CFFB2'):'#2A3150';dot(x,y,2.1*K,col,1);} + } + // A flashing IX: two pictures, one per colour. + if(st.ixDraw&&st.ixHot){const on=Math.sin(now/180)>0,ix=p?19:SKY_W[t]/2+4;stamp('ixhot'+(on?1:0),22,22,11,11,K,sx+ix*K,sy+(2-h)*K,()=>{ctx.translate(-ix,h-2);ctx.strokeStyle='#1E2640';cityIX(C,p,t,h,true,on?1:-1);});} + // Hot badges: the red disc pulses, the ring and the letter over it stay. + if(hot&&p){let y=-14;const pulse=.75+.25*Math.sin(now/200);for(const kk of ['r','t','p','c']){if(!hot[kk])continue;const bx=sx-29*K,by=sy+y*K;dot(bx,by,6.5*K,'#FF4D5E',pulse); + stamp('hotb|'+HOTL[kk],18,18,9,9,K,bx,by,g=>{g.lineWidth=2;g.strokeStyle='#1E2640';g.beginPath();g.arc(0,0,6.5,0,7);g.stroke();g.fillStyle='#fff';g.font='900 8px Nunito, sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText(HOTL[kk],0,0.5);});y+=14;}} + // The offer bubble bobs over the city. + if(st.off)stamp('offer|'+(st.big?2:1),30,28,15,12,K,sx-2*K,sy+(-h-16+Math.sin(now/250)*3)*K,g=>{g.fillStyle='#fff';g.strokeStyle='#1E2640';g.lineWidth=2.2;g.beginPath();g.ellipse(0,0,11,9,0,0,7);g.fill();g.stroke(); + g.beginPath();g.moveTo(-3,8);g.lineTo(-5,14);g.lineTo(2,8);g.fill();g.fillStyle=st.big?'#FF4F9A':'#16A866';g.font='900 13px "Baloo 2", sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText(st.big?'$$':'$',0,1);});} +function drawCity(C,sx,sy,sc,now,lyOverride,dem){ + if(CM.far)return drawCityFar(C,sx,sy,sc,now,lyOverride); + const hot=(UI.hotMap||{})[C.id]; + const p=S.pops[C.id],down=p&&p.down>S.day,sel=UI.sel&&UI.sel.type==='city'&&UI.sel.id===C.id,hov=UI.hover===C.id||(UI.snap&&UI.snap.id===C.id); + // No room for its skyline here: a quiet dot, a little bigger for bigger cities, until you zoom in (cityRoom). + if(dem&&!p&&!sel&&!hov){const r=(2.6+cTier(C.id)*0.35)*sc,rq=Math.round(r*4)/4,fill=hasIxAt(C.id)?'#FFD23F':'#FFFFFF',S2=Math.ceil(rq*2+4); + const e=spriteEntry(['quiet',rq,fill].join('|'),S2,S2,S2/2,S2/2,g=>{g.translate(S2/2,S2/2);g.fillStyle=fill;g.strokeStyle='#1E2640';g.lineWidth=1.6;g.beginPath();g.arc(0,0,rq,0,7);g.fill();g.stroke();}); + blit(e,sx-e.ax,sy+2*sc-e.ay,e.w,e.h);return;} + const t=cTier(C.id),cs=p?1:CSC[t],k=sc*(hov?1.15:1),kq=Math.round(k*CSPR_STEP)/CSPR_STEP; + const ixn=ixName(C.id),ixDraw=!!ixn&&(ixShown(C.id,p)||(hot&&hot.ix)||sel||hov),ixHot=!!(ixDraw&&hot&&hot.ix); + const st={down:!!down,feed:!!(UI.feed&&UI.feed.has(C.id)),sel:!!sel,inc:CM.inc.has(C.id),ixDraw,ixHot,off:CM.off.has(C.id),big:CM.big.has(C.id)}; + const ph=cityPhase(C,p,sel,now),spr=citySprite(C,p,t,cs,kq,ph,st),r=k/kq; + // The glow of a city in trouble pulses: a disc each frame, under the picture (as it was under the skyline). + if(ph.gl>=0)dot(sx,sy-6*k,26*k,'rgba(255,77,94,1)',.35+.25*(2*ph.gl/7-1)); + blit(spr,sx-spr.ax*r,sy-spr.ay*r,spr.w*r,spr.h*r); + cityMoving(C,p,t,cs,k,sx,sy,now,p?18:SKY_H[t],st,hot); // label if((cam.z>=0.62||p||sel||hov)&&(lyOverride!==null||hov)){ ctx.font=`800 ${p?13:12}px "Baloo 2", sans-serif`;const t=C.name,tw=LBLW[C.id+(p?1:0)]||(LBLW[C.id+(p?1:0)]=ctx.measureText(t).width+14),ly=lyOverride==null?sy+16*sc+8:lyOverride; - ctx.fillStyle=p?'#FF4F9A':'#FFFFFF';ctx.strokeStyle='#1E2640';ctx.lineWidth=2;rr(sx-tw/2,ly-9,tw,19,9);ctx.fill();ctx.stroke(); - ctx.fillStyle=p?'#FFFFFF':'#1E2640';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(t,sx,ly+1); + pill(t,ctx.font,tw,19,9,p?'#FF4F9A':'#FFFFFF',p?'#FFFFFF':'#1E2640','#1E2640',2,sx,ly+0.5,0.5); } } diff --git a/src/game/96-map/88-cable-ships.js b/src/game/96-map/88-cable-ships.js index e9af80b..f3a4744 100644 --- a/src/game/96-map/88-cable-ships.js +++ b/src/game/96-map/88-cable-ships.js @@ -24,13 +24,13 @@ function shipAt(s,T){const f=S.fleet&&S.fleet[s.id],H=shipHomePt(s);if(!f||T>=f. else{p=1-(T-f.done)/Math.max(0.01,f.back-f.done);mode='back';} p=clamp(p,0,1);const [x,y]=polyAt(r.pts,r.cum,p),[x2]=polyAt(r.pts,r.cum,clamp(p+(mode==='back'?-0.01:0.01),0,1));return {x,y,m:mode,dx:x2-x||1};} // A cartoon cable ship: red hull, white bridge, the yellow bow sheave cable ships are known by; a wake when under way. -function shipSprite(x,y,face,sc,col,now,mode){const c=ctx;c.save();c.translate(x,y+Math.sin(now/420+x*0.05)*1.2*sc);c.scale(face*sc,sc); +function shipSprite(x,y,face,sc,col,now,mode){const bl=mode==='work'&&Math.floor(now/350)%2; + stamp(['ship',col,face,mode,bl?1:0].join('|'),52,32,26,18,sc,x,y+Math.sin(now/420+x*0.05)*1.2*sc,c=>{c.scale(face,1); if(mode!=='port'&&mode!=='work'){c.strokeStyle='rgba(255,255,255,.85)';c.lineWidth=1.6;c.beginPath();c.moveTo(-10,3);c.quadraticCurveTo(-16,1,-22,4);c.moveTo(-10,5);c.quadraticCurveTo(-15,8,-21,9);c.stroke();} c.fillStyle=col;c.strokeStyle='#1E2640';c.lineWidth=1.6;c.lineJoin='round';c.beginPath();c.moveTo(-11,0);c.lineTo(11,0);c.lineTo(8,6);c.lineTo(-9,6);c.closePath();c.fill();c.stroke(); c.fillStyle='#fff';c.beginPath();c.rect(-7,-7,8,7);c.fill();c.stroke();c.fillStyle='#1E2640';c.fillRect(-5,-5,4,2); c.beginPath();c.arc(9,-2,2.6,0,7);c.fillStyle='#FFD23F';c.fill();c.stroke(); - if(mode==='work'&&Math.floor(now/350)%2){c.fillStyle='#FFD23F';c.font='900 11px sans-serif';c.textAlign='center';c.fillText('✦',12,-8);} - c.restore();} + if(bl){c.fillStyle='#FFD23F';c.font='900 11px sans-serif';c.textAlign='center';c.fillText('✦',12,-8);}});} function drawShips(ks,now){SHIP_HITS.length=0;if(!S||pzOn()||!S.fleet)return; const T=S.day+(UI.speed?clamp(acc/DAY_MS,0,0.999):0),z=cam.z,sc=Math.max(0.85,Math.min(1.5,Math.sqrt(z)))*(lodFar()?0.9:1.05),list=[]; for(const s of SHIPS){const p=shipAt(s,T);if(p.m==='port'&&z<1.1)continue;list.push({p,s,col:s.club==='prv'?'#7A5CFF':'#FF4D5E'});} diff --git a/src/game/96-map/95-clicks.js b/src/game/96-map/95-clicks.js index 85479d9..dd6bd7c 100644 --- a/src/game/96-map/95-clicks.js +++ b/src/game/96-map/95-clicks.js @@ -11,5 +11,5 @@ let PD={t:0,b:null}; document.addEventListener('pointerdown',e=>{PD={t:performance.now(),b:e.target.closest('[data-act]')};},true); function tapOk(e,b){if(!e.isTrusted||!PD.t||e.detail===0)return true;const now=performance.now();if(now-PD.t>4000)return true; if(PD.b!==b)return false;if((UI.layerAt||0)>PD.t)return false;const ts=b.closest('.toast');if(ts&&PD.t-(+ts.dataset.born||0)<500)return false;return true;} -document.addEventListener('click',e=>{const b=e.target.closest('[data-act]');if(!b||b.disabled)return;if(!$('modal').hidden&&!b.closest('#modal'))return;if(!tapOk(e,b))return;audioInit();const fn=ACT[b.dataset.act];if(!fn)return;if(!S&&!['start','keys','randomName','pickStart','cont','help','helpClose','newgame','mute','animSet','soundSet','langSet','closeModal','speed','bankClose','whatsNewShow','updateNow','updateLater','importPick','importGo','modeSet','presetSet','chaosSet','puzzleDoor','puzzleMenu','pzStart','pzArStart','pzWeekly','scenarios','startScn','startWeekly','settings','settingsClose','prefSet','vpSet','install','pitchSkip','slotMenu','slotExport','slotDel','slotDelGo','slotBack','slotSwitch','slotTake','slotSpace','toTitle'].includes(b.dataset.act))return;let a={};try{a=JSON.parse(b.dataset.args||'{}');}catch(_){}fn(a);}); +document.addEventListener('click',e=>{const b=e.target.closest('[data-act]');if(!b||b.disabled)return;if(!$('modal').hidden&&!b.closest('#modal'))return;if(!tapOk(e,b))return;audioInit();const fn=ACT[b.dataset.act];if(!fn)return;if(!S&&!['start','keys','randomName','pickStart','cont','help','helpClose','newgame','mute','animSet','mapSet','soundSet','langSet','closeModal','speed','bankClose','whatsNewShow','updateNow','updateLater','importPick','importGo','modeSet','presetSet','chaosSet','puzzleDoor','puzzleMenu','pzStart','pzArStart','pzWeekly','scenarios','startScn','startWeekly','settings','settingsClose','prefSet','vpSet','install','pitchSkip','slotMenu','slotExport','slotDel','slotDelGo','slotBack','slotSwitch','slotTake','slotSpace','toTitle'].includes(b.dataset.act))return;let a={};try{a=JSON.parse(b.dataset.args||'{}');}catch(_){}fn(a);}); diff --git a/src/game/96-map/97-fps-meter.js b/src/game/96-map/97-fps-meter.js new file mode 100644 index 0000000..4ad6efd --- /dev/null +++ b/src/game/96-map/97-fps-meter.js @@ -0,0 +1,11 @@ +/* A frame meter for measuring the map on a real device: open the game once with ?fps (?nofps hides it again). + Frames per second, the slowest frames, the time draw() takes, and which renderer and graphics card draw the map. */ +const FPSM={on:false,el:null,fr:[],dr:[],last:0,shown:0,dms:-1}; +try{const q=location.search;if(/[?&]fps\b/.test(q))localStorage.setItem('sot-fps','1');else if(/[?&]nofps\b/.test(q))localStorage.removeItem('sot-fps'); + FPSM.on=localStorage.getItem('sot-fps')==='1';}catch(e){} +function fpsNote(now){const M=FPSM;if(M.last)M.fr.push(now-M.last);M.last=now;if(M.dms>=0){M.dr.push(M.dms);M.dms=-1;} + if(now-M.shown<500)return;M.shown=now; + if(!M.el){M.el=document.createElement('pre');M.el.id='fpsm';M.el.style.cssText='position:fixed;right:8px;bottom:calc(var(--tabbar,0px) + 8px);z-index:99;margin:0;padding:6px 8px;background:rgba(30,38,64,.85);color:#7CFFB2;font:11px/1.35 ui-monospace,monospace;border-radius:8px;pointer-events:none;white-space:pre';document.body.appendChild(M.el);} + const f=M.fr.splice(0),d=M.dr.splice(0),s=f.slice().sort((a,b)=>a-b),sum=f.reduce((a,x)=>a+x,0),q=x=>s.length?s[Math.min(s.length-1,Math.floor(s.length*x))].toFixed(0):'-'; + const gl=GLX.shown&&!GLX.dead; + M.el.textContent=`${sum?(f.length*1000/sum).toFixed(0):0} fps · p95 ${q(.95)} ms · max ${q(1)} ms\ndraw ${d.length?(d.reduce((a,x)=>a+x,0)/d.length).toFixed(1):'-'} ms · ${gl?'WebGL':'2D'} · x${UI.speed||0}`+(gl?`\n${GLX.nSeg} segments · ${GLX.nPk} packets\n${GLX.gpu.slice(0,60)}`:'');} diff --git a/src/game/99-loop.js b/src/game/99-loop.js index 2020ceb..b139bd3 100644 --- a/src/game/99-loop.js +++ b/src/game/99-loop.js @@ -12,7 +12,8 @@ function frame(now){ if(S&&!S.lost&&$('modal').hidden&&UI.speed&&!pzOn())runClock(dt); if((UI.speed||pzOn())&&!(S&&S.lost))animT+=dt; /* paused = frozen dots, waves and clouds */ const t=animOn()?animT:0; - if(!(UI.mapHid=mapHidden())&&!mapStill(t,now)){try{draw(t);}catch(e){tickErr(e);}UI.drawnAt=now;} + if(!(UI.mapHid=mapHidden())&&!mapStill(t,now)){const d0=FPSM.on?performance.now():0;try{draw(t);}catch(e){tickErr(e);}UI.drawnAt=now;if(FPSM.on)FPSM.dms=performance.now()-d0;} + if(FPSM.on)fpsNote(now); } // dt of real time at UI.speed: the days it adds up to. The frame calls it; so may a clock that also runs where frames // do not (src/agent/, a hidden tab), under the frame's own conditions otherwise. @@ -27,12 +28,12 @@ function mapHidden(){for(const id of ['dashCard','bankCard']){const c=$(id);if(c const r=c.getBoundingClientRect();if(r.top<=1&&r.left<=1&&r.right>=innerWidth-1&&r.bottom>=innerHeight-1)return true;}return false;} /* Paused, or with animations off, the map only changes when you move it, point at something or the network changes. Until then the last frame is still right, so it is not drawn again (phones keep cool). It is redrawn at least once - a second anyway, and every frame while the land picture is still catching up with a zoom. */ + a second anyway, and every frame while the land picture is still catching up with a zoom (the WebGL map has none). */ const FRAME=[]; function mapStill(t,now){const sl=UI.sel,dr=UI.drag; const v=[t,cam.x,cam.y,cam.z,CW,CH,DPR,S,R,S&&S.day,S&&S.links.length,S&&S.offers.length,S&&S.inc.length,sl&&sl.type,sl&&sl.id,UI.hover,UI.snap&&UI.snap.id,dr&&dr.mode,dr&&dr.cx,dr&&dr.cy,FLOATS.length,UI.mk?UI.mk.tx:0,UI.mk?UI.mk.mood:0]; let same=v.length===FRAME.length;for(let i=0;i +
'; const st = (t) => { box.querySelector('#bst').textContent = t; }; - let SAVE = null, MD = ''; + let SAVE = null, MD = '', TRIAL = 0; + // Ends what the last trial left running before the next one starts, so nothing of one lands on the other: the clock + // stops, its frame callback is cancelled (measure() does that, and TRIAL turns away one already queued), and a day + // still being routed in the worker is waited for. Its answer runs dayPost() on the old save; one that never comes is + // dropped (rwDone() ignores an answer to no job). Then the clock's leftovers are cleared. + async function settle() { + UI.speed = 0; TRIAL++; + const t0 = performance.now(); + while (RW.job && performance.now() - t0 < SETTLE) await sleep(10); + if (RW.job) { console.warn('[bench] the route worker did not answer: its day is dropped'); RW.job = null; } + acc = 0; animT = 0; + } + // The save again, with the same random numbers every time (S.rng makes Math.random() follow it, as in a scenario). function fresh() { - S = migrate(JSON.parse(SAVE)); UI.started = true; UI.pitched = true; UI.sel = null; UI.anim = 'on'; applyAnim(); + S = migrate(JSON.parse(SAVE)); S.rng = SEED; UI.started = true; UI.pitched = true; UI.sel = null; UI.anim = 'on'; applyAnim(); closeModal(); compute(); renderAll(); const h = CITY[S.home] || CITIES[0]; cam.x = h.x; cam.y = h.y; } + async function reset() { await settle(); fresh(); } const q = (s, x) => (s.length ? s[Math.min(s.length - 1, Math.floor(s.length * x))] : 0); - async function measure(sc, hz) { - fresh(); cam.z = sc.z; UI.speed = sc.speed; WL.key = null; + async function measure(sc, hz, r) { + await reset(); cam.z = sc.z; UI.speed = sc.speed; WL.key = null; + const trial = TRIAL; await sleep(WARM); - const fr = [], dr = [], day0 = S.day; let last = 0, stop = false, hidden = false, long = 0, panX = cam.x; + const fr = [], dr = [], gpu = [], pend = [], day0 = S.day; let last = 0, stop = false, hidden = false, long = 0, panX = cam.x, raf = 0, glF = 0, flatF = 0, disjoint = 0; + // The card's own time, where the browser lets us read it: a timer around each WebGL draw(), read when it is ready. + const gl = r === 'gl' ? GLX.gl : null; let tq = null; try { tq = gl && gl.getExtension('EXT_disjoint_timer_query_webgl2'); } catch (e) { /* none */ } + const poll = () => { while (pend.length) { const x = pend[0]; if (!gl.getQueryParameter(x, gl.QUERY_RESULT_AVAILABLE)) break; pend.shift(); + const ns = gl.getQueryParameter(x, gl.QUERY_RESULT); gl.deleteQuery(x); if (gl.getParameter(tq.GPU_DISJOINT_EXT)) disjoint++; else gpu.push(ns / 1e6); } }; const D0 = draw; - draw = function (t) { const a = performance.now(); try { return D0(t); } finally { dr.push(performance.now() - a); } }; + draw = function (t) { let x = null; if (tq && GLX.gl === gl && pend.length < 16) { x = gl.createQuery(); gl.beginQuery(tq.TIME_ELAPSED_EXT, x); } + const a = performance.now(); + try { return D0(t); } finally { dr.push(performance.now() - a); if (x) { gl.endQuery(tq.TIME_ELAPSED_EXT); pend.push(x); } if (GLX.shown) glF++; else flatF++; } }; let po = null; try { po = new PerformanceObserver((l) => { long += l.getEntries().length; }); po.observe({ type: 'longtask' }); } catch (e) { /* not in this browser */ } // Frames slower than three refreshes, with the day they fell on and their draw(): where the stutters are. const t00 = performance.now(), slow = []; - const tick = (t) => { if (last) { fr.push(t - last); if (t - last > 50) slow.push({ at: Math.round(t - t00), ms: Math.round(t - last), day: S.day, draw: +(dr[dr.length - 1] || 0).toFixed(1) }); } last = t; if (document.hidden) hidden = true; + const tick = (t) => { if (stop || trial !== TRIAL) return; + if (last) { fr.push(t - last); if (t - last > 50) slow.push({ at: Math.round(t - t00), ms: Math.round(t - last), day: S.day, draw: +(dr[dr.length - 1] || 0).toFixed(1) }); } last = t; if (document.hidden) hidden = true; if (sc.pan) { panX += 0.18 * (t - (tick.p || t)) / cam.z; cam.x = panX; tick.p = t; } - if (!stop) requestAnimationFrame(tick); }; - requestAnimationFrame(tick); - const t0 = performance.now(); await sleep(SECS * 1000); stop = true; const T = (performance.now() - t0) / 1000; + if (tq) poll(); + raf = requestAnimationFrame(tick); }; + raf = requestAnimationFrame(tick); + const t0 = performance.now(); await sleep(SECS * 1000); stop = true; cancelAnimationFrame(raf); const T = (performance.now() - t0) / 1000; draw = D0; if (po) po.disconnect(); UI.speed = 0; - const s = fr.slice().sort((a, b) => a - b), d = dr.slice().sort((a, b) => a - b), budget = 1000 / hz; + if (tq) { poll(); for (const x of pend) gl.deleteQuery(x); } + const s = fr.slice().sort((a, b) => a - b), d = dr.slice().sort((a, b) => a - b), g = gpu.slice().sort((a, b) => a - b), budget = 1000 / hz; return { fps: +(fr.length / T).toFixed(1), p50: +q(s, 0.5).toFixed(1), p95: +q(s, 0.95).toFixed(1), p99: +q(s, 0.99).toFixed(1), max: +q(s, 1).toFixed(1), dropped: +(100 * fr.filter((x) => x > budget * 1.5).length / Math.max(1, fr.length)).toFixed(1), drawMs: +(d.reduce((a, x) => a + x, 0) / Math.max(1, d.length)).toFixed(2), drawP95: +q(d, 0.95).toFixed(2), + gpuMs: g.length ? +(g.reduce((a, x) => a + x, 0) / g.length).toFixed(2) : null, gpuP95: g.length ? +q(g, 0.95).toFixed(2) : null, gpuN: g.length, disjoint, + // Which map really drew the frames: a WebGL run that fell back to 2D (or a 2D run on the card) is not what it says. + drawn: glF && flatF ? 'mixed' : glF ? 'gl' : flatF ? '2d' : 'none', glFrames: glF, flatFrames: flatF, daysPerSec: +((S.day - day0) / T).toFixed(2), longTasks: long, hidden, drawMax: +q(d, 1).toFixed(1), slow }; } + // Several runs of one scenario: the median of each number; the flags and the stutters of all of them. + function merge(ms) { + if (ms.length === 1) return ms[0]; + const o = {}, med = (a) => { const s = a.slice().sort((x, y) => x - y); return s[(s.length - 1) >> 1]; }; + for (const k of Object.keys(ms[0])) { + const v = ms.map((m) => m[k]); + o[k] = k === 'slow' ? v.flat() : k === 'drawn' ? [...new Set(v)].join('+') : typeof v[0] === 'boolean' ? v.some(Boolean) : v.every((x) => typeof x === 'number') ? med(v) : v[0]; + } + o.runs = ms.length; return o; + } async function refresh() { const a = []; let l = 0; await new Promise((r) => { const f = (t) => { if (l) a.push(t - l); l = t; if (a.length < 90) requestAnimationFrame(f); else r(); }; requestAnimationFrame(f); }); a.sort((x, y) => x - y); return Math.round(1000 / a[a.length >> 1]); } function table(res, env) { - const rows = SCEN.map((sc) => { const a = res['2d'][sc.id], b = res.gl && res.gl[sc.id]; - const f = (m, k, u = '') => (m ? `${m[k]}${u}` : '-'); - return `| ${sc.label} | ${f(a, 'fps')} | ${f(b, 'fps')} | ${f(a, 'p95', ' ms')} | ${f(b, 'p95', ' ms')} | ${f(a, 'drawMs', ' ms')} | ${f(b, 'drawMs', ' ms')} |`; }); - return [`**${env.gpu || 'unknown GPU'}** · ${env.ua}`, `${env.w}×${env.h} at ${env.dpr}× · ${env.hz} Hz screen · ${env.cores} threads · ${env.save}`, '', - '| Scenario | 2D fps | WebGL fps | 2D p95 frame | WebGL p95 frame | 2D draw() | WebGL draw() |', - '|---|--:|--:|--:|--:|--:|--:|', ...rows, - '', `p95 frame: the slowest 5% of frames. draw(): CPU time per frame on the main thread.${env.invalid ? ' ⚠️ The tab was hidden during a run: those numbers are not valid.' : ''}`].join('\n'); + const gpu = res.gl && SCEN.some((sc) => res.gl[sc.id] && res.gl[sc.id].gpuMs != null); + const rows = SCEN.map((sc) => { const a = res['2d'] && res['2d'][sc.id], b = res.gl && res.gl[sc.id]; + const f = (m, k, u = '') => (m && m[k] != null ? `${m[k]}${u}` : '-'); + return `| ${sc.label} | ${f(a, 'fps')} | ${f(b, 'fps')} | ${f(a, 'p95', ' ms')} | ${f(b, 'p95', ' ms')} | ${f(a, 'drawMs', ' ms')} | ${f(b, 'drawMs', ' ms')} |${gpu ? ` ${f(b, 'gpuMs', ' ms')} |` : ''}`; }); + // A run is only what it says if its frames were drawn by the map it names. + const off = []; for (const [r, want] of [['2d', '2d'], ['gl', 'gl']]) for (const sc of SCEN) { const m = res[r] && res[r][sc.id]; if (m && m.drawn !== want && m.drawn !== 'none') off.push(`${sc.label} (${r === 'gl' ? 'WebGL' : '2D'}: ${m.flatFrames} frames in 2D, ${m.glFrames} on the card)`); } + return [`**${env.gpu || 'unknown GPU'}** · ${env.ua}`, `${env.w}×${env.h} at ${env.dpr}× · ${env.hz} Hz screen · ${env.cores} threads · ${env.save}${env.reps > 1 ? ` · median of ${env.reps} runs` : ''}`, '', + `| Scenario | 2D fps | WebGL fps | 2D p95 frame | WebGL p95 frame | 2D draw() | WebGL draw() |${gpu ? ' WebGL GPU |' : ''}`, + `|---|--:|--:|--:|--:|--:|--:|${gpu ? '--:|' : ''}`, ...rows, + '', `fps and p95 frame: requestAnimationFrame's cadence (p95: the slowest 5% of frames). draw(): CPU time on the main thread to build and submit a frame; the card may still be working when it returns, so it is not the cost of drawing.${gpu ? ' WebGL GPU: the card\'s own time per frame (EXT_disjoint_timer_query_webgl2).' : ' No GPU timer in this browser: the card\'s own time is not measured.'}${env.invalid ? ' ⚠️ The tab was hidden during a run: those numbers are not valid.' : ''}`, + ...(off.length ? ['', `⚠️ Not drawn by the map they name: ${off.join('; ')}.`] : [])].join('\n'); } async function run() { const go = box.querySelector('#bgo'); go.disabled = true; save = () => {}; // An incident pauses the game (autoPause): the clock must keep running for the timings to mean anything. autoPause = () => false; - fresh(); UI.speed = 0; st('Measuring the screen refresh…'); await sleep(500); + await reset(); st('Measuring the screen refresh…'); await sleep(500); const hz = await refresh(); - const want0 = GLX.want, glOk = mapGl(true, false) && glInit(); const env = { gpu: GLX.gpu, ua: navigator.userAgent.replace(/^Mozilla\/5\.0 /, ''), w: innerWidth, h: innerHeight, dpr: devicePixelRatio, hz, cores: navigator.hardwareConcurrency, save: `${Object.keys(S.pops).length} POPs · ${S.links.length} links` }; + const want0 = GLX.want, glOk = mapGl(true, false) && glInit(); const env = { gpu: GLX.gpu, ua: navigator.userAgent.replace(/^Mozilla\/5\.0 /, ''), w: innerWidth, h: innerHeight, dpr: devicePixelRatio, hz, cores: navigator.hardwareConcurrency, save: `${Object.keys(S.pops).length} POPs · ${S.links.length} links`, reps: REPS }; mapGl(false, false); - const res = { '2d': {}, gl: glOk ? {} : null }; - for (const r of (glOk ? ['2d', 'gl'] : ['2d']).filter((x) => !ONLY || x === ONLY)) { mapGl(r === 'gl', false); - for (const sc of SCEN) { st(`${r === 'gl' ? 'WebGL' : '2D'} · ${sc.label} (${SECS}s)… keep this tab in front`); const m = await measure(sc, hz); res[r][sc.id] = m; if (m.hidden) env.invalid = true; } } - mapGl(want0, false); fresh(); UI.speed = 0; + const rends = (glOk ? ['2d', 'gl'] : ['2d']).filter((x) => !ONLY || x === ONLY), all = {}; + // Scenario by scenario, both renderers in turn, the first one changing every time: neither always runs on a cold or + // a tired browser. + let n = 0; + for (let rep = 0; rep < REPS; rep++) for (const [i, sc] of SCEN.entries()) for (const r of (rep + i) % 2 ? rends.slice().reverse() : rends) { + mapGl(r === 'gl', false); n++; + st(`${r === 'gl' ? 'WebGL' : '2D'} · ${sc.label}${REPS > 1 ? ` · run ${rep + 1}/${REPS}` : ''} (${SECS}s, ${n}/${REPS * SCEN.length * rends.length})… keep this tab in front`); + const m = await measure(sc, hz, r); ((all[r] = all[r] || {})[sc.id] = all[r][sc.id] || []).push(m); if (m.hidden) env.invalid = true; + } + const res = { '2d': null, gl: null }; + for (const r of Object.keys(all)) { res[r] = {}; for (const id of Object.keys(all[r])) res[r][id] = merge(all[r][id]); } + mapGl(want0, false); await reset(); MD = table(res, env); st(glOk ? 'Done. The results are also in the terminal.' : 'Done (no WebGL2 here: 2D only).'); box.querySelector('#bout').innerHTML = '
' + MD.replace(/&/g, '&').replace(/';
     box.querySelector('#bcp').hidden = false; go.disabled = false; go.textContent = 'Run again';
     try { await fetch('/__bench/results', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ env, res, md: MD }) }); } catch (e) { /* the panel has them */ }
   }
+  // tests/gpu-bench.test.js drives the pieces without the panel.
+  if (CFG.expose) { window.__bench = { settle, reset, measure, merge, table, setSave: (s) => { SAVE = s; } }; return; }
   addEventListener('load', async () => {
     document.body.appendChild(box);
     while (typeof migrate !== 'function' || typeof GLX === 'undefined') await sleep(50);
@@ -88,7 +144,8 @@
     await sleep(800);
     try { SAVE = JSON.stringify((await (await fetch('/__bench/save.json')).json()).S || null); } catch (e) { st('Could not load the save: ' + e); return; }
     if (SAVE === 'null') { st('The save file has no game in it.'); return; }
-    st(`Ready: ${SCEN.length} scenarios × 2 renderers, about ${Math.ceil(SCEN.length * 2 * (SECS + 3) / 60)} minutes. Keep this tab in front and do not touch the map.`);
+    const runs = SCEN.length * (ONLY ? 1 : 2) * REPS;
+    st(`Ready: ${SCEN.length} scenarios × ${ONLY ? 1 : 2} renderers${REPS > 1 ? ` × ${REPS}` : ''}, about ${Math.ceil(runs * (SECS + 3) / 60)} minutes. Keep this tab in front and do not touch the map.`);
     const go = box.querySelector('#bgo'); go.disabled = false; go.onclick = () => run().catch((e) => st('Failed: ' + (e && e.stack || e)));
     box.querySelector('#bcp').onclick = () => navigator.clipboard.writeText(MD).then(() => st('Copied.'), () => st('Copy failed: select the table instead.'));
     if (/[?&]auto\b/.test(location.search)) go.onclick();
diff --git a/scripts/perf-bench.js b/scripts/perf-bench.js
index 272e9ac..2732cf2 100644
--- a/scripts/perf-bench.js
+++ b/scripts/perf-bench.js
@@ -98,7 +98,10 @@ md += `### Headless (jsdom)\n\nOur JavaScript only: jsdom has no layout and its
 const slow = base ? slowIn(res, 2) : [];
 const { PROFILES } = browser ? require('./perf-browser') : { PROFILES: [] };
 for (const p of PROFILES) {
-  md += `\n### Chromium ${browser.version}: ${p.key === 'phone' ? 'phone' : 'desktop'}\n\n${p.key === 'phone' ? 'A 390×844 screen at 3× pixel density, with the CPU slowed down 4× like a mid-range Android.' : 'A 1280×800 window at full speed.'} Real DOM, layout and canvas.\n\n` + table(browser.profiles[p.key], 2 * p.rate);
+  // The map row is the whole frame, up to a pixel read back from the surface that drew it; say which one that was.
+  const mp = browser.profiles[p.key].maps, mapName = (m) => (!m || !m.length ? 'no map' : m.map((x) => (x === 'gl' ? 'WebGL' : '2D canvas')).join(' then '));
+  const drew = mp ? ` The map was drawn with ${base ? `${mapName(mp.base)} (base) and ${mapName(mp.head)} (this PR)` : mapName(mp.head)}; its row waits for that surface to finish.` : '';
+  md += `\n### Chromium ${browser.version}: ${p.key === 'phone' ? 'phone' : 'desktop'}\n\n${p.key === 'phone' ? 'A 390×844 screen at 3× pixel density, with the CPU slowed down 4× like a mid-range Android.' : 'A 1280×800 window at full speed.'} Real DOM, layout and canvas.${drew}\n\n` + table(browser.profiles[p.key], 2 * p.rate);
   if (base) slow.push(...slowIn(browser.profiles[p.key], 2 * p.rate).map((l) => `${l} (Chromium ${p.key})`));
 }
 if (base) {
diff --git a/scripts/perf-browser.js b/scripts/perf-browser.js
index a8a7123..01bf39e 100644
--- a/scripts/perf-browser.js
+++ b/scripts/perf-browser.js
@@ -36,10 +36,15 @@ async function openPage(browser, profile, file, save, errors) {
   // One run of a workload, timed inside the page so the round trip to Node does not count. Garbage is collected
   // first, so a run never pays for the one before it (its own garbage still costs it, as in the game).
   // The browser leaves layout and canvas drawing for the next frame, so code that changes the DOM or draws the map
-  // would look free: each run ends by forcing both (reading a size, and one pixel back from the map canvas).
+  // would look free: each run ends by forcing both (reading a size, and one pixel back from the surface the map was
+  // last drawn on: the WebGL canvas when the card drew it, which waits for the card to finish, else the 2D canvas).
+  // A run also says which map drew (gl, 2d, or none when it drew nothing).
   const time = async (k, body) => { await cdp.send('HeapProfiler.collectGarbage'); return page.evaluate(([k, body]) => {
     const F = window.__fx || (window.__fx = {}); const f = F[k] || (F[k] = new Function(body)); const map = document.getElementById('map').getContext('2d');
-    const t = performance.now(); f(); void document.documentElement.offsetHeight; map.getImageData(0, 0, 1, 1); return performance.now() - t; }, [k, body]); };
+    const G = typeof GLX === 'object' ? GLX : null, px = window.__px || (window.__px = new Uint8Array(4));
+    const t = performance.now(); f(); void document.documentElement.offsetHeight;
+    const gl = G && G.shown && G.gl; if (gl) gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, px); else map.getImageData(0, 0, 1, 1);
+    return { ms: performance.now() - t, map: G && G.shown ? 'gl' : '2d' }; }, [k, body]); };
   return { ctx, time };
 }
 
@@ -54,15 +59,18 @@ async function runBrowser({ head, base, save, metrics, runs, exe }) {
     for (const p of PROFILES) {
       const h = await openPage(hb, p, head, save, errors), b = base ? await openPage(bb, p, base, save, errors) : null;
       const res = out.profiles[p.key] = {};
+      // Which map each version drew with, over all the runs that drew one (a version falling back mid-run shows both).
+      const maps = res.maps = { head: new Set(), base: new Set() };
       for (const [k, , body] of metrics) {
-        const H = [], B = [];
+        const H = [], B = [], go = async (v, into, m) => { const r = await v.time(k, body); into.push(r.ms); if (k === 'map') m.add(r.map); };
         for (const v of [h, b].filter(Boolean)) { await v.time(k, body); await v.time(k, body); }   // warm up
         for (let i = 0; i < runs; i++) {
           // Alternate who goes first, like the jsdom runs.
-          if (b && i % 2) { B.push(await b.time(k, body)); H.push(await h.time(k, body)); } else { H.push(await h.time(k, body)); if (b) B.push(await b.time(k, body)); }
+          if (b && i % 2) { await go(b, B, maps.base); await go(h, H, maps.head); } else { await go(h, H, maps.head); if (b) await go(b, B, maps.base); }
         }
         res[k] = { head: median(H), base: b ? median(B) : null, samples: { head: H.map((x) => +x.toFixed(1)), base: b ? B.map((x) => +x.toFixed(1)) : null } };
       }
+      res.maps = { head: [...maps.head], base: b ? [...maps.base] : null };
       await h.ctx.close(); if (b) await b.ctx.close();
     }
   } finally { await hb.close(); if (bb) await bb.close(); }
diff --git a/tests/gpu-bench.test.js b/tests/gpu-bench.test.js
new file mode 100644
index 0000000..d72670c
--- /dev/null
+++ b/tests/gpu-bench.test.js
@@ -0,0 +1,80 @@
+// The GPU benchmark's panel (scripts/lib/gpu-bench-client.js): one trial must never reach into the next. A day the route
+// worker is still routing lands on the save it was routed for, a pan's frame callback stops with its trial, every
+// trial starts from the same random numbers, and the table says which map really drew each run.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { load } = require('./harness');
+
+const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
+const CLIENT = fs.readFileSync(path.join(__dirname, '..', 'scripts', 'lib', 'gpu-bench-client.js'), 'utf8');
+
+function open(cfg = {}) {
+  const h = load({ seed: 777 });
+  h.ev(`window.__BENCH__=${JSON.stringify({ expose: true, secs: 0.15, warm: 0, settleMs: 300, ...cfg })};`);
+  h.ev(CLIENT);
+  h.ev(`__bench.setSave(${JSON.stringify(SAVE)});save=()=>{};`);
+  return h;
+}
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// A day in flight in the worker when the trial ends: rwDone() would run its dayPost() whenever the answer comes.
+const IN_FLIGHT = `window.__old=S;RW.seq=41;RW.job={seq:41,d:201,gen:RW.gen-1,t:0};window.__posts=[];
+  dayPost=function(d){__posts.push({d,old:S===__old});};`;
+
+test('a late answer from the route worker lands on the trial it belongs to, not the next one', async () => {
+  const { ev, errors } = open();
+  await ev('__bench.reset()');
+  ev(IN_FLIGHT);
+  ev('setTimeout(()=>rwDone({seq:41}),60)');
+  await ev('__bench.reset()');
+  assert.deepEqual(JSON.parse(ev('JSON.stringify(__posts)')), [{ d: 201, old: true }], 'its day ran on the old save, before the new one was loaded');
+  assert.equal(ev('S!==__old&&RW.job===null'), true);
+  assert.deepEqual(errors, []);
+});
+
+test('an answer that never comes is dropped, and coming late it changes nothing', async () => {
+  const { ev, errors } = open();
+  await ev('__bench.reset()');
+  ev(IN_FLIGHT);
+  ev('console.warn=()=>{}');
+  await ev('__bench.reset()');
+  assert.equal(ev('RW.job'), null, 'the next trial does not wait for it forever');
+  ev('rwDone({seq:41})');
+  assert.deepEqual(JSON.parse(ev('JSON.stringify(__posts)')), [], 'nothing ran on the new save');
+  assert.deepEqual(errors, []);
+});
+
+test('a pan stops with its trial: the next trial’s camera is left alone', async () => {
+  const { ev, errors } = open();
+  const m = JSON.parse(await ev('__bench.measure({id:"pan",pan:true,z:1.4,speed:0},60,"2d").then(JSON.stringify)'));
+  assert.ok(m.fps > 0, 'the pan ran');
+  ev('cam.x=0');
+  await wait(120);
+  assert.equal(ev('cam.x'), 0, 'no frame of the pan came after it');
+  const x8 = await ev('(async()=>{const p=__bench.measure({id:"x8",z:1.4,speed:8},60,"2d");await new Promise(r=>setTimeout(r,20));const x=cam.x;await p;return [x,cam.x];})()');
+  assert.equal(x8[0], x8[1], 'the next scenario keeps its camera where it put it');
+  assert.deepEqual(errors, []);
+});
+
+test('every trial starts from the same random numbers and an empty clock', async () => {
+  const { ev, errors } = open();
+  const draws = async () => { await ev('acc=12345;animT=999;__bench.reset()'); return ev('JSON.stringify([acc,animT,Math.random(),Math.random(),Math.random()])'); };
+  const a = await draws(), b = await draws();
+  assert.equal(a, b);
+  assert.deepEqual(JSON.parse(a).slice(0, 2), [0, 0]);
+  assert.deepEqual(errors, []);
+});
+
+test('the table says which map drew each run, and what each column measures', () => {
+  const { ev } = open();
+  const md = ev(`(()=>{const m=(drawn,gl,flat,gpu)=>({fps:60,p95:17,drawMs:1,drawn,glFrames:gl,flatFrames:flat,gpuMs:gpu});
+    const res={'2d':{'x1-mid':m('2d',0,300,null)},gl:{'x1-mid':m('mixed',12,288,0.8)}};
+    return __bench.table(res,{gpu:'stub',ua:'ua',w:1,h:1,dpr:1,hz:60,cores:1,save:'s',reps:1});})()`);
+  assert.match(md, /WebGL GPU/, 'a GPU column when the card timed its frames');
+  assert.match(md, /CPU time on the main thread/, 'draw() is said to be CPU time');
+  assert.match(md, /Not drawn by the map they name: Map at x1 \(zoom 1\.4\) \(WebGL: 288 frames in 2D/, 'a run that fell back to 2D is flagged');
+  const merged = JSON.parse(ev(`JSON.stringify(__bench.merge([{fps:50,drawn:'gl',hidden:false,slow:[1]},{fps:70,drawn:'gl',hidden:true,slow:[2]},{fps:60,drawn:'2d',hidden:false,slow:[]}]))`));
+  assert.deepEqual(merged, { fps: 60, drawn: 'gl+2d', hidden: true, slow: [1, 2], runs: 3 });
+});

From 39941c257e5704b4a01ef8edb2431dd285636fba Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 14:45:48 +0100
Subject: [PATCH 04/23] WebGL map: keep the 2D map where WebGL is drawn by the
 processor
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With the perf benchmark now waiting for the surface the map was drawn on,
headless Chromium showed what WebGL costs without a graphics card: its
SwiftShader renderer spends about 8 µs per instance, so the coastlines alone
(29k segments, twice) took about 480 ms and a big map 1.4 s a frame, where the
2D canvas takes 46 ms. Players get the same with a blocked driver, a virtual
machine or Mesa's llvmpipe. glInit() now reads the renderer first and keeps
the 2D map on SwiftShader, llvmpipe, softpipe, lavapipe, WARP or any
"software" renderer; GLX.soft lets the GPU benchmark measure them anyway.
---
 CHANGELOG.md                    |  2 +-
 scripts/lib/gpu-bench-client.js |  2 ++
 src/game/96-map/56-webgl.js     |  9 +++++++--
 tests/webgl-map.test.js         | 25 +++++++++++++++++++++++++
 4 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64021a0..1f268f8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,7 +9,7 @@ All notable changes to this project are documented here. The project follows
 - The NOC charts have tooltips, on the dashboard and on the wallboard in the NOC window: hover (or touch) a chart to see every series on that day, with a total. Click an entry in the legend to hide or show that series, and the scale follows what is left. The "how it arrives" bars on the Traffic tab show the same kind of tooltip, and its legend picks which ways in (caches, PNIs, IX peering, transit) the table counts.
 - Bilbao joins the map, where the transatlantic cables really come ashore: Marea Carey, Grace Hopscotch and Sol Survivor now land there instead of Madrid. It has no exchange of its own, so traffic heads inland to Madrid, and Drizzle Electric, Tangerine Telecom and the big carriers sell transit there. A link you already run on the old Madrid landings keeps working as a plain subsea link, and the Mid-Atlantic Accent scenario now goes Azores, Bilbao, Madrid, and Marea Carey now leaves the American coast at Virginia Beach instead of crossing the northeast to New Jersey. Columbus III-and-a-half now comes ashore near Cádiz, where it really landed, on its way to Madrid.
 - Puzzles are easier to read, above all on phones: the three stars are now three goals in plain words, and the one you are working on says what is wrong and what to do, with a Show me button. The map marks it too: a red ring around a city that still needs traffic, and a pulsing ✂ on a link whose cut would hurt. On phones the sheet starts small so the map gets the screen; swipe it up for the rest. Cities far from the puzzle are left off the map, and stepping stones you are not using are small dots without a name until you tap one, build there or zoom in.
-- The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same; Settings › Map drawing › Always 2D keeps the old drawing, and browsers without WebGL2 keep it on their own, as does a game whose graphics card fails while you play.
+- The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same; Settings › Map drawing › Always 2D keeps the old drawing, and browsers without WebGL2 or without a usable graphics card keep it on their own, as does a game whose graphics card fails while you play.
 - Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the usual map also draws far fewer shapes each frame.
 
 ## [2.9.1] — 2026-11-04
diff --git a/scripts/lib/gpu-bench-client.js b/scripts/lib/gpu-bench-client.js
index 4fe4d42..690fbb3 100644
--- a/scripts/lib/gpu-bench-client.js
+++ b/scripts/lib/gpu-bench-client.js
@@ -139,6 +139,8 @@
   addEventListener('load', async () => {
     document.body.appendChild(box);
     while (typeof migrate !== 'function' || typeof GLX === 'undefined') await sleep(50);
+    // A software renderer is measured too here (the game itself keeps the 2D map on one); the table names the renderer.
+    GLX.soft = true;
     // ?dpr=2 draws the map as a screen of that density would (a 4K screen's pixels, measured on a smaller one).
     const DPRQ = +QS.get('dpr'); if (DPRQ > 0) { Object.defineProperty(window, 'devicePixelRatio', { get: () => DPRQ }); resize(); WL.key = null; }
     await sleep(800);
diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js
index 5306506..d6be4f4 100644
--- a/src/game/96-map/56-webgl.js
+++ b/src/game/96-map/56-webgl.js
@@ -5,9 +5,13 @@
    Two canvases sit over #map, which stays empty: #mapgl, where the card draws the background (57), the tubes and
    packets (58) and the pictures of cities, labels and markers (59); and #mapfx, a transparent 2D canvas over it for
    the few things still painted shape by shape (the drag preview, the chaos monkey), cleared only after it was used.
-   Puzzles, and any browser without WebGL2 or whose context fails or is lost, keep the 2D map. */
+   Puzzles, and any browser without WebGL2 or whose context fails or is lost, keep the 2D map. So does WebGL drawn by
+   the processor (no usable graphics card: a blocked driver, a virtual machine): there every instance of a line costs
+   microseconds, and a big map took a second and a half a frame where the 2D canvas takes 50 ms. */
 const GLX={want:true,dead:false,gl:null,c:null,f:null,fx:null,key:[],nSeg:0,nPk:0,nHalo:0,shown:false,gpu:''};
 try{GLX.want=localStorage.getItem('sot-map')!=='2d';}catch(e){}
+// Renderers that are the processor pretending to be a graphics card (GLX.soft: use them anyway, for the GPU benchmark).
+const GL_SOFT=/swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/i;
 const glOn=()=>GLX.want&&!GLX.dead&&!!S&&!pzOn()&&glInit();
 // Switches the WebGL map on or off: the setting keeps the choice in this browser (keep), the GPU benchmark does not.
 function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeItem('sot-map'):localStorage.setItem('sot-map','2d');}catch(e){}
@@ -33,11 +37,12 @@ function glInit(){if(GLX.gl)return true;if(GLX.dead)return false;
   try{const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');if(!c||!f||!c.getContext)throw new Error('no map layers');
     const gl=c.getContext('webgl2',{alpha:true,premultipliedAlpha:true,antialias:false,depth:true,stencil:true,powerPreference:'high-performance'});
     if(!gl||typeof gl.createShader!=='function')throw new Error('no WebGL2');
+    try{const x=gl.getExtension('WEBGL_debug_renderer_info');GLX.gpu=String(x?gl.getParameter(x.UNMASKED_RENDERER_WEBGL):gl.getParameter(gl.RENDERER));}catch(e){}
+    if(!GLX.soft&&GL_SOFT.test(GLX.gpu))throw new Error('no graphics card, only '+GLX.gpu);
     const P=(vs,fs)=>glProg(gl,vs,fs),progs={line:P(GL_LINE_VS,GL_LINE_FS),pk:P(GL_PK_VS,GL_PK_FS),fill:P(FILL_VS,FILL_FS),fan:P(FAN_VS,FAN_FS),ell:P(ELL_VS,ELL_FS),circ:P(CIRC_VS,CIRC_FS)};
     // The tubes' points for the packets: floats read with texelFetch, never filtered.
     const tex=gl.createTexture();gl.bindTexture(gl.TEXTURE_2D,tex);for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.NEAREST);
     c.addEventListener('webglcontextlost',e=>{e.preventDefault();glKill('the graphics context was lost');UI.drawnAt=0;});
-    try{const x=gl.getExtension('WEBGL_debug_renderer_info');GLX.gpu=String(x?gl.getParameter(x.UNMASKED_RENDERER_WEBGL):gl.getParameter(gl.RENDERER));}catch(e){}
     glsInit(gl);
     // The overlay is cleared only after something was painted on it: clearing a whole screen of empty canvas every
     // frame makes the browser send the layer to the screen again, which on a 4K screen cost more than the map itself.
diff --git a/tests/webgl-map.test.js b/tests/webgl-map.test.js
index baacae9..2d70dea 100644
--- a/tests/webgl-map.test.js
+++ b/tests/webgl-map.test.js
@@ -305,3 +305,28 @@ test('selecting a tube sends its halo to the card, not the network again', () =>
   assert.equal(r.haloDraw, 0, 'and the halo is gone');
   assert.deepEqual(errors, []);
 });
+
+// A WebGL2 context that compiles everything and names its renderer: enough for glInit() to run to the end.
+const FAKE_GL = (name) => `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};const c=document.getElementById('mapgl');c.getContext=(t)=>t!=='webgl2'?null:new Proxy({},{get(t,k){
+  if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+  if(k==='getExtension')return ()=>({UNMASKED_RENDERER_WEBGL:'REN'});
+  if(k==='getParameter')return (p)=>p==='REN'?${JSON.stringify(name)}:p==='ACTIVE_UNIFORMS'?0:4096;
+  if(k==='getShaderParameter'||k==='getProgramParameter')return (x,p)=>p==='ACTIVE_UNIFORMS'?0:true;
+  return ()=>({});}});})()`;
+
+test('a graphics card drawn by the processor keeps the 2D map; a real one gets the card', () => {
+  for (const [name, gl] of [['ANGLE (Google, Vulkan 1.3.0 (SwiftShader Device (Subzero) (0x0000C0DE)), SwiftShader driver)', false],
+    ['llvmpipe (LLVM 17.0.6, 256 bits)', false], ['Microsoft Basic Render Driver', false],
+    ['ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)', true], ['Apple M2', true], ['Mali-G78', true]]) {
+    const { ev } = open();
+    ev(FAKE_GL(name));
+    ev('console.warn=()=>{}');
+    assert.equal(ev('glInit()'), gl, name);
+    assert.equal(ev('GLX.dead'), !gl, name);
+    assert.equal(ev('GLX.gpu'), name, 'the renderer is still named');
+  }
+  const { ev } = open();
+  ev(FAKE_GL('SwiftShader driver'));
+  ev('GLX.soft=true');
+  assert.equal(ev('glInit()'), true, 'the GPU benchmark can still measure it');
+});

From 2ff634a0eddaca06e5d1fd682cdfd4dbf5a777d9 Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 16:37:32 +0100
Subject: [PATCH 05/23] WebGL map: paint the card's pictures on one canvas, so
 a long zoom keeps the context

Every sprite kept its own  once it was in the atlas: a long pan and zoom made
~20,000 of them, then a frame of one to two seconds, then CONTEXT_LOST and a silent
fallback to 2D (4 sweeps out of 5). The card's pictures are now painted on one reused
canvas and sent to the atlas at once (texSubImage2D with a sub-rectangle); a full atlas
restarts and takes the picture at once. The 2D map, and a picture too big for the atlas,
keep a canvas each. The card's and the 2D map's pictures are kept apart, and giving the
card up drops its pictures.
---
 CHANGELOG.md                     |   1 +
 src/game/96-map/56-webgl.js      |   2 +-
 src/game/96-map/59-gl-sprites.js |  40 ++++++++----
 tests/webgl-sprites.test.js      | 102 +++++++++++++++++++++++++++++++
 4 files changed, 132 insertions(+), 13 deletions(-)
 create mode 100644 tests/webgl-sprites.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1f268f8..2640db8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ All notable changes to this project are documented here. The project follows
 - Puzzles are easier to read, above all on phones: the three stars are now three goals in plain words, and the one you are working on says what is wrong and what to do, with a Show me button. The map marks it too: a red ring around a city that still needs traffic, and a pulsing ✂ on a link whose cut would hurt. On phones the sheet starts small so the map gets the screen; swipe it up for the rest. Cities far from the puzzle are left off the map, and stepping stones you are not using are small dots without a name until you tap one, build there or zoom in.
 - The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same; Settings › Map drawing › Always 2D keeps the old drawing, and browsers without WebGL2 or without a usable graphics card keep it on their own, as does a game whose graphics card fails while you play.
 - Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the usual map also draws far fewer shapes each frame.
+- Long zooms stay on the graphics card: the pictures of cities and labels are painted on one shared canvas instead of each keeping its own, so the browser no longer runs out of room for them and switches to the slower drawing.
 
 ## [2.9.1] — 2026-11-04
 
diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js
index d6be4f4..2819c7d 100644
--- a/src/game/96-map/56-webgl.js
+++ b/src/game/96-map/56-webgl.js
@@ -19,7 +19,7 @@ function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeIte
 function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=document.getElementById('mapgl'),fx=document.getElementById('mapfx');if(e)e.hidden=!on;if(fx)fx.hidden=!on;}
 // Marks an error as the card's own, so draw() falls back to 2D instead of trying WebGL again every frame.
 function glErr(e){const x=e instanceof Error?e:new Error(String(e));x.glErr=true;return x;}
-function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.dead=true;GLX.gl=null;glShow(false);}
+function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.dead=true;GLX.gl=null;spritesDrop();glShow(false);}
 const GL_HEAD='#version 300 es\nprecision highp float;precision highp int;\n';
 // Clip space from CSS px (the shaders work in CSS px, as the 2D map does, and use uDpr only for anti-aliasing).
 const GL_CLIP='vec4 clip(vec2 p,vec2 v,float z){return vec4(p.x/v.x*2.-1.,1.-p.y/v.y*2.,z,1.);}\n';
diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js
index 87eeee6..234cf94 100644
--- a/src/game/96-map/59-gl-sprites.js
+++ b/src/game/96-map/59-gl-sprites.js
@@ -26,30 +26,46 @@ function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4
   GLS.shx=GLS.shy=GLS.shh=0;}
 // Forgets every picture and starts the atlas again, after the pictures already queued are drawn (they point into it).
 function spritesReset(){glsDrawNow();SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;}
+// The card given up: its pictures go (they have no canvas to be drawn from in 2D) and the atlas is forgotten.
+function spritesDrop(){GLS.n=0;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;}
+/* The card's pictures are painted on one canvas, reused, and each goes into the atlas as soon as it is painted: a
+   canvas kept per picture made the browser hold thousands of them while you zoomed, until it lost the graphics context
+   and the map fell back to 2D. The 2D map, and a picture too big for the atlas, keep their own canvas. */
+const GLS_PAD={cv:null,g:null};
+function glsPad(pw,ph){const P=GLS_PAD;if(!P.cv){P.cv=document.createElement('canvas');P.cv.width=P.cv.height=256;}
+  if(P.cv.width=SPR_MAX)spritesReset();
-  const cv=document.createElement('canvas');cv.width=Math.ceil(w*DPR);cv.height=Math.ceil(h*DPR);
-  const g=cv.getContext('2d'),saved=ctx;ctx=g;
-  try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;}
-  e={cv,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1};SPRS.set(key,e);return e;}
-// Puts a picture into the atlas (once), shelf by shelf. A full atlas starts again; this picture then waits a frame.
-function glsEnsure(e){if(e.up)return true;const gl=GLX.gl;if(!gl||!GLS.prog)return false;
-  try{return glsPut(gl,e);}catch(x){throw glErr(x);}}
-function glsPut(gl,e){const pw=e.cv.width,ph=e.cv.height,A=GLS.size;if(pw>A||ph>A)return false;
+  const pw=Math.ceil(w*DPR),ph=Math.ceil(h*DPR),saved=ctx;
+  e={cv:null,pw,ph,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1};
+  if(gpu&&pw<=GLS.size&&ph<=GLS.size){const P=glsPad(pw,ph),g=P.g;
+    g.save();g.setTransform(1,0,0,1,0,0);g.clearRect(0,0,pw,ph);ctx=g;
+    try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;g.restore();}
+    // A full atlas starts again (glsPut), and the picture goes into the empty one at once: the pad is reused next.
+    try{if(!glsPut(GLX.gl,e,P.cv))glsPut(GLX.gl,e,P.cv);}catch(x){throw glErr(x);}
+  }else{const cv=document.createElement('canvas');cv.width=pw;cv.height=ph;const g=cv.getContext('2d');ctx=g;
+    try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;}e.cv=cv;}
+  SPRS.set(key,e);return e;}
+// Puts a picture with its own canvas into the atlas (once), shelf by shelf. A full atlas starts again; this picture then waits a frame.
+function glsEnsure(e){if(e.up)return true;const gl=GLX.gl;if(!gl||!GLS.prog||!e.cv)return false;
+  try{return glsPut(gl,e,e.cv);}catch(x){throw glErr(x);}}
+function glsPut(gl,e,src){const pw=e.pw,ph=e.ph,A=GLS.size;if(pw>A||ph>A)return false;
   if(GLS.shx+pw>A){GLS.shx=0;GLS.shy+=GLS.shh;GLS.shh=0;}
   if(GLS.shy+ph>A){spritesReset();return false;}
   const x=GLS.shx,y=GLS.shy;GLS.shx+=pw;GLS.shh=Math.max(GLS.shh,ph);
   gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,true);
-  gl.texSubImage2D(gl.TEXTURE_2D,0,x,y,gl.RGBA,gl.UNSIGNED_BYTE,e.cv);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false);
+  // Only the picture's corner of the source: the pad is bigger than most pictures.
+  gl.texSubImage2D(gl.TEXTURE_2D,0,x,y,pw,ph,gl.RGBA,gl.UNSIGNED_BYTE,src);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false);
   Object.assign(e,{up:true,u0:x/A,v0:y/A,u1:(x+pw)/A,v1:(y+ph)/A});return true;}
 // The next record in GLS.data, which grows as needed: take it before reading GLS.data, which it may replace.
 function glsNext(){if((GLS.n+1)*SPR_STRIDE>GLS.data.length){const nd=new Float32Array(GLS.data.length*2);nd.set(GLS.data);GLS.data=nd;}return GLS.n++*SPR_STRIDE;}
 // Draws a picture at (x,y) of w×h CSS px, on the card for a frame drawn there, else with the 2D canvas.
 function blit(e,x,y,w,h){if(GLS.frame&&glsEnsure(e)){const o=glsNext(),d=GLS.data;
     d[o]=x;d[o+1]=y;d[o+2]=w;d[o+3]=h;d[o+4]=e.u0;d[o+5]=e.v0;d[o+6]=e.u1;d[o+7]=e.v1;d[o+8]=d[o+9]=d[o+10]=0;d[o+11]=ctx.globalAlpha;d[o+12]=0;}
-  else ctx.drawImage(e.cv,x,y,w,h);}
+  else if(e.cv)ctx.drawImage(e.cv,x,y,w,h);}
 // A round dot of radius r at (x,y), in colour col (CSS colour string) at opacity a, on the card or the 2D canvas.
 function dot(x,y,r,col,a){if(GLS.frame){const c=glColor(col),o=glsNext(),d=GLS.data;
     d[o]=x;d[o+1]=y;d[o+2]=r;d[o+3]=d[o+4]=d[o+5]=d[o+6]=d[o+7]=0;d[o+8]=c[0];d[o+9]=c[1];d[o+10]=c[2];d[o+11]=(a===undefined?ctx.globalAlpha:a)*c[3];d[o+12]=1;}
diff --git a/tests/webgl-sprites.test.js b/tests/webgl-sprites.test.js
new file mode 100644
index 0000000..e5d765c
--- /dev/null
+++ b/tests/webgl-sprites.test.js
@@ -0,0 +1,102 @@
+// The card's pictures (src/game/96-map/59-gl-sprites.js): painted on one reused canvas and sent to the atlas at once, so
+// a long zoom does not leave the browser holding a canvas per picture (it lost the graphics context and fell back to 2D).
+// The 2D map keeps a canvas per picture. jsdom has no WebGL: a stand-in context records what would go to the card.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { load } = require('./harness');
+
+const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
+
+function open() {
+  const h = load({ seed: 777 });
+  h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();S.nextFail=S.day+999;S.nextEvent=S.day+999;compute();`);
+  return h;
+}
+
+const STUB = `(()=>{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in t)return t[k];if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+  return (...a)=>{calls.push([k,...a]);return {};};}});
+  const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');
+  const P=()=>({p:{},u:{}}),B=()=>({v:{},b:{}});
+  Object.assign(GLX,{want:true,dead:false,gl,c,f,fx:f.getContext('2d'),line:P(),pk:P(),fill:P(),fan:P(),ell:P(),land:{},circ:P(),tex:{},lv:B(),hv:B(),pv:B(),cb:B(),wv:B(),cl:B(),empty:{},key:[],gpu:'stub'});
+  GLS.prog=P();GLS.vao={};GLS.buf={};GLS.tex={};GLS.size=4096;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;
+  // Counts the canvases the page makes from here on.
+  const ce=document.createElement.bind(document);window.__canvases=0;document.createElement=function(t){if(String(t).toLowerCase()==='canvas')__canvases++;return ce.apply(document,arguments);};
+  return gl;})()`;
+
+// Frames over a zoom from far to near and back, as a player pinching would.
+const ZOOM = `(()=>{const h=CITY[S.home];cam.x=h.x;cam.y=h.y;for(let i=0;i<=40;i++){cam.z=0.5*Math.pow(9,(1-Math.cos(i/40*Math.PI*2))/2);draw(1000+i*16);}})()`;
+
+test('on the card, pictures are painted on one canvas and each goes into the atlas as it is painted', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  ev(ZOOM);
+  const r = JSON.parse(ev(`(()=>{const subs=GLX.gl.calls.filter(c=>c[0]==='texSubImage2D'),es=[...SPRS.values()];
+    return JSON.stringify({canvases:__canvases,subs:subs.length,sprites:es.length,mine:es.filter(e=>e.cv).length,
+      allUp:es.every(e=>e.up),rect:subs.every(c=>c.length===10&&c[9]===GLS_PAD.cv&&c[5]>0&&c[6]>0),
+      fit:subs.every(c=>c[5]<=GLS_PAD.cv.width&&c[6]<=GLS_PAD.cv.height),keys:es.length?[...SPRS.keys()].every(k=>k[0]==='g'):false});})()`));
+  assert.ok(r.sprites > 50, `a zoom paints many pictures (${r.sprites})`);
+  assert.ok(r.canvases <= 1, `one canvas for all of them, not one each (${r.canvases} made)`);
+  assert.equal(r.mine, 0, 'no picture keeps a canvas of its own');
+  assert.equal(r.allUp, true, 'every picture is in the atlas');
+  assert.ok(r.subs >= r.sprites, 'each was sent once, when painted');
+  assert.equal(r.rect, true, 'only its corner of the pad, from the pad');
+  assert.equal(r.fit, true);
+  assert.equal(r.keys, true, 'kept apart from the 2D map’s pictures');
+  assert.deepEqual(errors, []);
+});
+
+test('a full atlas starts again and the picture that did not fit goes into the new one at once', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{GLS.frame=true;GLS.n=0;ctx=GLX.fx;GLS.shy=GLS.size-4;GLS.shx=GLS.size-2;GLS.shh=4;
+    const before=SPRS.size;let draws=0;const gd=glsDraw;glsDraw=function(){draws++;};
+    const e=spriteEntry('big',40,40,20,20,g=>{g.fillRect(0,0,40,40);});blit(e,10,10,40,40);
+    glsDraw=gd;const r={up:e.up,u0:e.u0,v0:e.v0,kept:SPRS.get('g'+DPR+'|big')===e,size:SPRS.size,n:GLS.n,cv:!!e.cv,shy:GLS.shy};GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify(r);})()`));
+  assert.equal(r.up, true, 'the picture is in the atlas');
+  assert.equal(r.u0, 0); assert.equal(r.v0, 0);
+  assert.equal(r.kept, true, 'and kept under its key after the restart');
+  assert.equal(r.size, 1, 'the old pictures are gone');
+  assert.equal(r.n, 1, 'drawn this frame');
+  assert.equal(r.cv, false);
+  assert.deepEqual(errors, []);
+});
+
+test('the 2D map keeps a canvas per picture, and its pictures are not the card’s', () => {
+  const { ev, errors } = open();
+  ev(`mapGl(false);const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;draw(1000);`);
+  const r = JSON.parse(ev(`(()=>{const es=[...SPRS.entries()];return JSON.stringify({n:es.length,cv:es.every(([k,e])=>k[0]==='c'&&e.cv&&e.cv.width===e.pw&&e.cv.height===e.ph),up:es.some(([,e])=>e.up)});})()`));
+  assert.ok(r.n > 10);
+  assert.equal(r.cv, true, 'each with its own canvas, at its size');
+  assert.equal(r.up, false, 'nothing went to a card');
+  assert.deepEqual(errors, []);
+});
+
+test('giving the card up drops its pictures; the 2D map paints its own', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  ev(`const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;draw(1000);`);
+  assert.ok(ev('SPRS.size') > 10);
+  ev(`window.__warn=0;console.warn=function(){__warn++;};glKill('test')`);
+  assert.equal(ev('SPRS.size'), 0, 'no picture without a canvas is left behind');
+  assert.equal(ev('GLS.shx+GLS.shy+GLS.shh'), 0, 'the atlas is forgotten');
+  ev('draw(1016)');
+  assert.ok(ev('SPRS.size') > 10);
+  assert.equal(ev(`[...SPRS.values()].every(e=>e.cv)`), true, 'the 2D map’s pictures have their canvas');
+  assert.ok(ev('ctx===CTX0'));
+  assert.deepEqual(errors, []);
+});
+
+test('a picture too big for the atlas keeps its own canvas and is painted on the overlay', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{GLS.frame=true;GLS.n=0;ctx=GLX.fx;GLS.size=64;const n0=GLX.fx.calls.n;
+    const e=spriteEntry('huge',200,30,100,15,g=>{g.fillRect(0,0,200,30);});blit(e,0,0,200,30);
+    const r={cv:!!e.cv,up:e.up,n:GLS.n,fx:GLX.fx.calls.n-n0};GLS.frame=false;GLS.n=0;ctx=CTX0;GLS.size=4096;return JSON.stringify(r);})()`));
+  assert.equal(r.cv, true);
+  assert.equal(r.up, false);
+  assert.equal(r.n, 0, 'not queued for the card');
+  assert.ok(r.fx >= 1, 'drawn on the overlay instead');
+  assert.deepEqual(errors, []);
+});

From eeeccc60d42bcdaed7c7895aef0c91d206563f77 Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 16:39:57 +0100
Subject: [PATCH 06/23] WebGL map: keep the cities' pictures while the zoom
 moves, paint them sharp once it rests

The scale of a city's picture is in steps of 1/24, so a pinch repainted every city every
~4 % of zoom: hundreds of pictures a frame, and the atlas full and reset over and over.
On the card, while the zoom moves, pictures that grow with it (cities, ships, badges) keep
the step of the scale held when it began, stretched by up to 1.25x either way by the
card's filtering, and take a new one beyond that; 250 ms after the zoom stops they are
painted at their own step again, and a still map is drawn once more for it. The 2D map
paints every step as before.
---
 CHANGELOG.md                      |  1 +
 src/game/96-map/59-gl-sprites.js  | 18 +++++-
 src/game/96-map/60-draw.js        |  2 +-
 src/game/96-map/80-cities.js      | 11 ++--
 src/game/96-map/88-cable-ships.js |  2 +-
 src/game/99-loop.js               |  2 +-
 tests/webgl-zoom-sprites.test.js  | 91 +++++++++++++++++++++++++++++++
 7 files changed, 115 insertions(+), 12 deletions(-)
 create mode 100644 tests/webgl-zoom-sprites.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2640db8..946f84e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@ All notable changes to this project are documented here. The project follows
 - The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same; Settings › Map drawing › Always 2D keeps the old drawing, and browsers without WebGL2 or without a usable graphics card keep it on their own, as does a game whose graphics card fails while you play.
 - Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the usual map also draws far fewer shapes each frame.
 - Long zooms stay on the graphics card: the pictures of cities and labels are painted on one shared canvas instead of each keeping its own, so the browser no longer runs out of room for them and switches to the slower drawing.
+- Zooming is smoother on big maps: while you zoom, cities and ships keep their picture and are only redrawn sharp once the zoom stops, instead of being repainted at every small step.
 
 ## [2.9.1] — 2026-11-04
 
diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js
index 234cf94..b2aef43 100644
--- a/src/game/96-map/59-gl-sprites.js
+++ b/src/game/96-map/59-gl-sprites.js
@@ -70,10 +70,22 @@ function blit(e,x,y,w,h){if(GLS.frame&&glsEnsure(e)){const o=glsNext(),d=GLS.dat
 function dot(x,y,r,col,a){if(GLS.frame){const c=glColor(col),o=glsNext(),d=GLS.data;
     d[o]=x;d[o+1]=y;d[o+2]=r;d[o+3]=d[o+4]=d[o+5]=d[o+6]=d[o+7]=0;d[o+8]=c[0];d[o+9]=c[1];d[o+10]=c[2];d[o+11]=(a===undefined?ctx.globalAlpha:a)*c[3];d[o+12]=1;}
   else{const sa=ctx.globalAlpha;if(a!==undefined)ctx.globalAlpha=a;ctx.fillStyle=col;ctx.beginPath();ctx.arc(x,y,r,0,7);ctx.fill();ctx.globalAlpha=sa;}}
+/* Pictures that grow with the zoom (cities, ships, badges) are painted at steps of 1/24 of their scale. On the card,
+   while the zoom moves, they keep the step of the scale they had when it began, stretched by up to 1.25× either way
+   (the card filters them smoothly), and are painted again at the right step once the zoom rests (ZOOM_REST ms): a
+   pinch otherwise repainted every city at every step, hundreds of pictures a frame, and filled the atlas over and
+   over. ZH.sc is the icon scale held, ZH.f how much a picture is painted smaller (<1) or bigger than it shows. */
+const CSPR_STEP=24,ZOOM_REST=250,ZH={z:0,t:-1e9,sc:0,f:1};
+function zoomHold(sc,G){const t=performance.now();if(cam.z!==ZH.z){ZH.z=cam.z;ZH.t=t;}
+  if(!G||!ZH.sc||t-ZH.t>=ZOOM_REST||sc/ZH.sc>1.25||ZH.sc/sc>1.25)ZH.sc=sc;ZH.f=ZH.sc/sc;}
+// The zoom moved a moment ago: the pictures may be stretched, so a still map is drawn again once it rests (mapStill()).
+const zoomMoving=()=>performance.now()-ZH.tMath.max(1/CSPR_STEP,Math.round(k*ZH.f*CSPR_STEP)/CSPR_STEP);
 // A small picture w×h px at scale k with its anchor at (ax,ay), painted once by paint(g) with the origin on the anchor
-// (k in steps of 1/24, as the cities), then drawn with the anchor at (x,y). Things that bob or pulse are drawn as these
-// at a moving place, so the overlay above the card stays untouched (repainting it costs a whole screen of pixels).
-function stamp(key,w,h,ax,ay,k,x,y,paint){const kq=Math.max(1/24,Math.round(k*24)/24),r=k/kq;
+// (k in steps of 1/24, as the cities; zoomed: k grows with the zoom, and is held while it moves, sprQ()), then drawn with
+// the anchor at (x,y). Things that bob or pulse are drawn as these at a moving place, so the overlay above the card
+// stays untouched (repainting it costs a whole screen of pixels).
+function stamp(key,w,h,ax,ay,k,x,y,paint,zoomed){const kq=zoomed?sprQ(k):Math.max(1/CSPR_STEP,Math.round(k*CSPR_STEP)/CSPR_STEP),r=k/kq;
   const e=spriteEntry(key+'|'+kq,Math.ceil(w*kq),Math.ceil(h*kq),ax*kq,ay*kq,g=>{g.translate(ax*kq,ay*kq);g.scale(kq,kq);paint(g);});
   blit(e,x-e.ax*r,y-e.ay*r,e.w*r,e.h*r);}
 // Text with an outline, centred on (x,y), as a picture placed on whole device pixels; tw is its width, px its size.
diff --git a/src/game/96-map/60-draw.js b/src/game/96-map/60-draw.js
index f42754e..9448ad9 100644
--- a/src/game/96-map/60-draw.js
+++ b/src/game/96-map/60-draw.js
@@ -36,7 +36,7 @@ function drawFrame(now){
   }
   ctx.setTransform(DPR,0,0,DPR,0,0);
   if(!S)return;
-  const sc=iconScale(),day=S.day;
+  const sc=iconScale(),day=S.day;zoomHold(sc,G);
   // cable systems
   drawCables(ks);
   // links
diff --git a/src/game/96-map/80-cities.js b/src/game/96-map/80-cities.js
index 9b40c4b..ebce4ff 100644
--- a/src/game/96-map/80-cities.js
+++ b/src/game/96-map/80-cities.js
@@ -32,8 +32,7 @@ function cityFarStatic(C,p,down,sel,hov,ph){ctx.strokeStyle='#1E2640';
   if(CM.inc.has(C.id)){ctx.fillStyle='#FF4D5E';ctx.lineWidth=1.2;ctx.beginPath();ctx.arc(p?-9:-5,p?-7:-5,3.4,0,7);ctx.fill();ctx.stroke();}}
 // A city's picture is painted once per state and kept as a sprite (citySprite). What moves every frame is painted on top
 // (cityMoving): the lights, the steam, a flashing IX, the hot badges and the offer bubble. The rings and the glow move too,
-// but in steps (cityPhase), so their sprite changes only at a step.
-const CSPR_STEP=24;
+// but in steps (cityPhase), so their sprite changes only at a step; so does its scale (sprQ(), 59-gl-sprites.js).
 // dd is -1 without an attack: the attack's ring at step 0 must not share a sprite with no ring at all.
 function cityPhase(C,p,sel,now){const ph={sel:0,dd:-1,gl:-1};
   if(sel)ph.sel=Math.floor(now/40)%12;                       // dash period 12 px, lineDashOffset -now/40
@@ -94,13 +93,13 @@ function cityMoving(C,p,t,cs,k,sx,sy,now,h,st,hot){const down=st.down,K=k*cs;
     for(let i=0;i<4;i++){const lit=down?false:(((now/(160+i*37))|0)+i)%3!==0,[x,y]=at(-10+i*6.6,1),col=down?'#3B4260':lit?(sf<0.9?'#FF4D5E':'#7CFFB2'):'#2A3150';dot(x,y,2.1*K,col,1);}
   }
   // A flashing IX: two pictures, one per colour.
-  if(st.ixDraw&&st.ixHot){const on=Math.sin(now/180)>0,ix=p?19:SKY_W[t]/2+4;stamp('ixhot'+(on?1:0),22,22,11,11,K,sx+ix*K,sy+(2-h)*K,()=>{ctx.translate(-ix,h-2);ctx.strokeStyle='#1E2640';cityIX(C,p,t,h,true,on?1:-1);});}
+  if(st.ixDraw&&st.ixHot){const on=Math.sin(now/180)>0,ix=p?19:SKY_W[t]/2+4;stamp('ixhot'+(on?1:0),22,22,11,11,K,sx+ix*K,sy+(2-h)*K,()=>{ctx.translate(-ix,h-2);ctx.strokeStyle='#1E2640';cityIX(C,p,t,h,true,on?1:-1);},true);}
   // Hot badges: the red disc pulses, the ring and the letter over it stay.
   if(hot&&p){let y=-14;const pulse=.75+.25*Math.sin(now/200);for(const kk of ['r','t','p','c']){if(!hot[kk])continue;const bx=sx-29*K,by=sy+y*K;dot(bx,by,6.5*K,'#FF4D5E',pulse);
-    stamp('hotb|'+HOTL[kk],18,18,9,9,K,bx,by,g=>{g.lineWidth=2;g.strokeStyle='#1E2640';g.beginPath();g.arc(0,0,6.5,0,7);g.stroke();g.fillStyle='#fff';g.font='900 8px Nunito, sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText(HOTL[kk],0,0.5);});y+=14;}}
+    stamp('hotb|'+HOTL[kk],18,18,9,9,K,bx,by,g=>{g.lineWidth=2;g.strokeStyle='#1E2640';g.beginPath();g.arc(0,0,6.5,0,7);g.stroke();g.fillStyle='#fff';g.font='900 8px Nunito, sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText(HOTL[kk],0,0.5);},true);y+=14;}}
   // The offer bubble bobs over the city.
   if(st.off)stamp('offer|'+(st.big?2:1),30,28,15,12,K,sx-2*K,sy+(-h-16+Math.sin(now/250)*3)*K,g=>{g.fillStyle='#fff';g.strokeStyle='#1E2640';g.lineWidth=2.2;g.beginPath();g.ellipse(0,0,11,9,0,0,7);g.fill();g.stroke();
-    g.beginPath();g.moveTo(-3,8);g.lineTo(-5,14);g.lineTo(2,8);g.fill();g.fillStyle=st.big?'#FF4F9A':'#16A866';g.font='900 13px "Baloo 2", sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText(st.big?'$$':'$',0,1);});}
+    g.beginPath();g.moveTo(-3,8);g.lineTo(-5,14);g.lineTo(2,8);g.fill();g.fillStyle=st.big?'#FF4F9A':'#16A866';g.font='900 13px "Baloo 2", sans-serif';g.textAlign='center';g.textBaseline='middle';g.fillText(st.big?'$$':'$',0,1);},true);}
 function drawCity(C,sx,sy,sc,now,lyOverride,dem){
   if(CM.far)return drawCityFar(C,sx,sy,sc,now,lyOverride);
   const hot=(UI.hotMap||{})[C.id];
@@ -109,7 +108,7 @@ function drawCity(C,sx,sy,sc,now,lyOverride,dem){
   if(dem&&!p&&!sel&&!hov){const r=(2.6+cTier(C.id)*0.35)*sc,rq=Math.round(r*4)/4,fill=hasIxAt(C.id)?'#FFD23F':'#FFFFFF',S2=Math.ceil(rq*2+4);
     const e=spriteEntry(['quiet',rq,fill].join('|'),S2,S2,S2/2,S2/2,g=>{g.translate(S2/2,S2/2);g.fillStyle=fill;g.strokeStyle='#1E2640';g.lineWidth=1.6;g.beginPath();g.arc(0,0,rq,0,7);g.fill();g.stroke();});
     blit(e,sx-e.ax,sy+2*sc-e.ay,e.w,e.h);return;}
-  const t=cTier(C.id),cs=p?1:CSC[t],k=sc*(hov?1.15:1),kq=Math.round(k*CSPR_STEP)/CSPR_STEP;
+  const t=cTier(C.id),cs=p?1:CSC[t],k=sc*(hov?1.15:1),kq=sprQ(k);
   const ixn=ixName(C.id),ixDraw=!!ixn&&(ixShown(C.id,p)||(hot&&hot.ix)||sel||hov),ixHot=!!(ixDraw&&hot&&hot.ix);
   const st={down:!!down,feed:!!(UI.feed&&UI.feed.has(C.id)),sel:!!sel,inc:CM.inc.has(C.id),ixDraw,ixHot,off:CM.off.has(C.id),big:CM.big.has(C.id)};
   const ph=cityPhase(C,p,sel,now),spr=citySprite(C,p,t,cs,kq,ph,st),r=k/kq;
diff --git a/src/game/96-map/88-cable-ships.js b/src/game/96-map/88-cable-ships.js
index f3a4744..881ac69 100644
--- a/src/game/96-map/88-cable-ships.js
+++ b/src/game/96-map/88-cable-ships.js
@@ -30,7 +30,7 @@ function shipSprite(x,y,face,sc,col,now,mode){const bl=mode==='work'&&Math.floor
   c.fillStyle=col;c.strokeStyle='#1E2640';c.lineWidth=1.6;c.lineJoin='round';c.beginPath();c.moveTo(-11,0);c.lineTo(11,0);c.lineTo(8,6);c.lineTo(-9,6);c.closePath();c.fill();c.stroke();
   c.fillStyle='#fff';c.beginPath();c.rect(-7,-7,8,7);c.fill();c.stroke();c.fillStyle='#1E2640';c.fillRect(-5,-5,4,2);
   c.beginPath();c.arc(9,-2,2.6,0,7);c.fillStyle='#FFD23F';c.fill();c.stroke();
-  if(bl){c.fillStyle='#FFD23F';c.font='900 11px sans-serif';c.textAlign='center';c.fillText('✦',12,-8);}});}
+  if(bl){c.fillStyle='#FFD23F';c.font='900 11px sans-serif';c.textAlign='center';c.fillText('✦',12,-8);}},true);}
 function drawShips(ks,now){SHIP_HITS.length=0;if(!S||pzOn()||!S.fleet)return;
   const T=S.day+(UI.speed?clamp(acc/DAY_MS,0,0.999):0),z=cam.z,sc=Math.max(0.85,Math.min(1.5,Math.sqrt(z)))*(lodFar()?0.9:1.05),list=[];
   for(const s of SHIPS){const p=shipAt(s,T);if(p.m==='port'&&z<1.1)continue;list.push({p,s,col:s.club==='prv'?'#7A5CFF':'#FF4D5E'});}
diff --git a/src/game/99-loop.js b/src/game/99-loop.js
index b139bd3..83390ba 100644
--- a/src/game/99-loop.js
+++ b/src/game/99-loop.js
@@ -31,7 +31,7 @@ function mapHidden(){for(const id of ['dashCard','bankCard']){const c=$(id);if(c
    a second anyway, and every frame while the land picture is still catching up with a zoom (the WebGL map has none). */
 const FRAME=[];
 function mapStill(t,now){const sl=UI.sel,dr=UI.drag;
-  const v=[t,cam.x,cam.y,cam.z,CW,CH,DPR,S,R,S&&S.day,S&&S.links.length,S&&S.offers.length,S&&S.inc.length,sl&&sl.type,sl&&sl.id,UI.hover,UI.snap&&UI.snap.id,dr&&dr.mode,dr&&dr.cx,dr&&dr.cy,FLOATS.length,UI.mk?UI.mk.tx:0,UI.mk?UI.mk.mood:0];
+  const v=[t,cam.x,cam.y,cam.z,CW,CH,DPR,S,R,S&&S.day,S&&S.links.length,S&&S.offers.length,S&&S.inc.length,sl&&sl.type,sl&&sl.id,UI.hover,UI.snap&&UI.snap.id,dr&&dr.mode,dr&&dr.cx,dr&&dr.cy,FLOATS.length,UI.mk?UI.mk.tx:0,UI.mk?UI.mk.mood:0,zoomMoving()];
   let same=v.length===FRAME.length;for(let i=0;i__T,configurable:true});`);
+  return h;
+}
+
+const STUB = `(()=>{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in t)return t[k];if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+  return (...a)=>{calls.push([k,...a]);return {};};}});
+  const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');
+  const P=()=>({p:{},u:{}}),B=()=>({v:{},b:{}});
+  Object.assign(GLX,{want:true,dead:false,gl,c,f,fx:f.getContext('2d'),line:P(),pk:P(),fill:P(),fan:P(),ell:P(),land:{},circ:P(),tex:{},lv:B(),hv:B(),pv:B(),cb:B(),wv:B(),cl:B(),empty:{},key:[],gpu:'stub'});
+  GLS.prog=P();GLS.vao={};GLS.buf={};GLS.tex={};GLS.size=4096;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;return gl;})()`;
+
+// One POP's city pictures painted during frames from zoom z0 to z1 (the clock moving 16 ms a frame), by scale.
+const ZOOM = (z0, z1, n) => `(()=>{const id=S.home,C=CITY[id];cam.x=C.x;cam.y=C.y;const seen=new Set(),bad=[];
+  for(let i=0;i<=${n};i++){cam.z=${z0}+(${z1}-${z0})*i/${n};__T+=16;draw(__T);
+    for(const k of SPRS.keys()){const p=k.split('|');if(p[1]==='city'&&p[2]===id)seen.add(+p[4]);}
+    const k=cityScale(iconScale()),kq=[...SPRS.keys()].filter(x=>x.split('|')[1]==='city'&&x.split('|')[2]===id).map(x=>+x.split('|')[4]);
+    if(kq.length&&!kq.some(q=>Math.max(q/k,k/q)<=1.25*(1+.5/24/0.7)))bad.push(i);}
+  return JSON.stringify({steps:[...seen].sort(),bad});})()`;
+
+test('on the card a zoom keeps each city’s picture for a while, and paints it at the right step once it rests', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  ev(`cam.z=0.6;draw(__T);__T+=1000;draw(__T)`);
+  const r = JSON.parse(ev(ZOOM(0.6, 1.6, 60)));
+  // Without the hold, every 1/24 step between the two scales gets a picture.
+  const plain = ev(`(()=>{const s=new Set();for(let i=0;i<=60;i++){cam.z=0.6+i/60;s.add(Math.round(cityScale(iconScale())*24)/24);}return s.size;})()`);
+  assert.ok(plain >= 10, `the zoom crosses many steps (${plain})`);
+  assert.ok(r.steps.length <= 4, `the city was painted at ${r.steps.length} scales during the zoom (${r.steps}), not ${plain}`);
+  assert.deepEqual(r.bad, [], 'a picture is never stretched more than 1.25× either way (and half a step)');
+  assert.equal(ev('zoomMoving()'), true);
+  ev('__T+=300;draw(__T)');
+  const rest = JSON.parse(ev(`(()=>{const id=S.home,want=Math.round(cityScale(iconScale())*24)/24;
+    return JSON.stringify({f:ZH.f,want,has:[...SPRS.keys()].some(k=>{const p=k.split('|');return p[1]==='city'&&p[2]===id&&+p[4]===want;}),moving:zoomMoving()});})()`));
+  assert.equal(rest.moving, false);
+  assert.equal(rest.f, 1, 'at rest nothing is stretched');
+  assert.equal(rest.has, true, 'the city is painted again at its own step');
+  assert.deepEqual(errors, []);
+});
+
+test('the 2D map paints cities at their own step on every frame of a zoom, as before', () => {
+  const { ev, errors } = open();
+  ev(`mapGl(false);cam.z=0.8;draw(__T);`);
+  const r = JSON.parse(ev(`(()=>{const id=S.home,C=CITY[id];cam.x=C.x;cam.y=C.y;const bad=[];
+    for(let i=0;i<=30;i++){cam.z=0.8+i/30;__T+=16;SPRS.clear();draw(__T);const want=Math.round(cityScale(iconScale())*24)/24;
+      if(ZH.f!==1||![...SPRS.keys()].some(k=>{const p=k.split('|');return p[1]==='city'&&p[2]===id&&+p[4]===want;}))bad.push(i);}
+    return JSON.stringify({bad});})()`));
+  assert.deepEqual(r.bad, []);
+  assert.deepEqual(errors, []);
+});
+
+test('a still map is drawn again when the zoom comes to rest, so the stretched pictures do not stay', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  // Animations off: the loop skips frames while nothing changes.
+  ev(`cam.z=1;draw(__T);mapStill(0,__T);UI.drawnAt=__T;cam.z=1.3;__T+=16;mapStill(0,__T);draw(__T);UI.drawnAt=__T;`);
+  ev(`__T+=16`);
+  assert.equal(ev('mapStill(0,__T)'), true, 'nothing moved since the last frame');
+  ev(`__T+=300`);
+  assert.equal(ev('mapStill(0,__T)'), false, 'the zoom has rested: one more frame');
+  ev(`draw(__T);UI.drawnAt=__T;__T+=16`);
+  assert.equal(ev('ZH.f'), 1);
+  assert.equal(ev('mapStill(0,__T)'), true, 'and then the map stays still again');
+  assert.deepEqual(errors, []);
+});
+
+test('pictures that keep their size whatever the zoom (far-view cities, cones, diggers) are never held or stretched', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{cam.z=1;draw(__T);__T+=1000;cam.z=1;draw(__T);cam.z=1.4;__T+=16;draw(__T);GLS.frame=true;GLS.n=0;ctx=GLX.fx;
+    const f=ZH.f;drawCone(100,100,0);drawBackhoe(200,100,0,false);const D=GLS.data,o=[D[2],D[3],D[SPR_STRIDE+2],D[SPR_STRIDE+3]];
+    const keys=[...SPRS.keys()].filter(k=>['cone','hoe'].includes(k.split('|')[1]));GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify({f,o,keys});})()`));
+  assert.notEqual(r.f, 1, 'the zoom is moving and city pictures are held');
+  assert.deepEqual(r.o, [26, 28, 38, 32], 'drawn at their own size');
+  assert.ok(r.keys.length >= 2 && r.keys.every(k => k.endsWith('|1')), 'painted at scale 1: ' + r.keys);
+  assert.deepEqual(errors, []);
+});

From 3482142ae59c45d5887eb0da0c3a6786f86c103a Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 16:42:03 +0100
Subject: [PATCH 07/23] WebGL map: simplify the coastlines for the zoom

On the card the land was most of a frame's work (the stencil fills twice, the sand, the
edge), and it scales with vertices, not pixels. The land is now built per zoom level
(powers of 2) with each coastline simplified (Douglas-Peucker) so that no point moves
more than 0.25 px at the level's zoom; zooming in takes the finer level at once, zooming
out keeps it until the zoom is 10 % under it. COAST, onLand() and the 2D map are
unchanged.
---
 CHANGELOG.md                           |  1 +
 src/game/96-map/57-webgl-background.js | 38 +++++++++----
 tests/webgl-coast.test.js              | 76 ++++++++++++++++++++++++++
 tests/webgl-map.test.js                |  5 +-
 4 files changed, 108 insertions(+), 12 deletions(-)
 create mode 100644 tests/webgl-coast.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 946f84e..8811912 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ All notable changes to this project are documented here. The project follows
 - Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the usual map also draws far fewer shapes each frame.
 - Long zooms stay on the graphics card: the pictures of cities and labels are painted on one shared canvas instead of each keeping its own, so the browser no longer runs out of room for them and switches to the slower drawing.
 - Zooming is smoother on big maps: while you zoom, cities and ships keep their picture and are only redrawn sharp once the zoom stops, instead of being repainted at every small step.
+- The graphics card draws the coastlines with fewer points when you zoom out, where the extra detail was smaller than a pixel, so the map costs it a lot less work, which helps phones most.
 
 ## [2.9.1] — 2026-11-04
 
diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js
index d696257..5d5d7b9 100644
--- a/src/game/96-map/57-webgl-background.js
+++ b/src/game/96-map/57-webgl-background.js
@@ -18,15 +18,33 @@ void main(){float d=(length(vq/vr)-1.)*min(vr.x,vr.y),a=clamp(.5-d*uDpr,0.,1.);i
 const CIRC_VS=GL_HEAD+GL_CLIP+`layout(location=0) in vec4 aC;uniform vec2 uView;uniform vec3 uCam;out vec2 vq;flat out float vr;
 void main(){vec2 c=(aC.xy-uCam.xy)*uCam.z+uView*.5;float r=aC.z*uCam.z,m=r+1.;vq=vec2((gl_VertexID&1)==0?-m:m,(gl_VertexID&2)==0?-m:m);vr=r;gl_Position=clip(c+vq,uView,0.);}`;
 const CIRC_FS=GL_HEAD+`in vec2 vq;flat in float vr;out vec4 o;void main(){if(length(vq)>vr)discard;o=vec4(1.);}`;
-/* The land, built once per level of detail (the far view leaves out the islets as LANDP_FAR does): the fan for the
-   fills, the coastlines as line segments (paintWorld()'s curves, four segments each) for the sand and the dark edge,
-   and the hills. */
-function glLandGeo(gl,far){const key=far?'far':'all';let G=GLX.land[key];if(G)return G;
-  const keep=far?new Set(LANDP_FAR):null,fan=[],sand=[],edge=[],SAND=glColor('#F8E6A8'),EDGE=glColor('#1E2640');
-  COAST.forEach((ring,ri)=>{if(keep&&!keep.has(LANDP_ALL[ri]))return;const n=ring.length;if(n<3)return;
-    // As smoothPath(): a quadratic curve from the middle of each side to the next, through the corner between them.
-    const mid=(a,b)=>[(a[0]+b[0])/2,(a[1]+b[1])/2],P=[];let m=mid(ring[n-1],ring[0]);P.push(m);
-    for(let i=0;i[(a[0]+b[0])/2,(a[1]+b[1])/2];let m=mid(ring[n-1],ring[0]);P.push(m);
+  for(let i=0;i0))return P;const keep=new Uint8Array(n),st=[0,n-1],t2=tol*tol;keep[0]=keep[n-1]=1;
+  while(st.length){const b=st.pop(),a=st.pop(),ax=P[a][0],ay=P[a][1],dx=P[b][0]-ax,dy=P[b][1]-ay,L=dx*dx+dy*dy||1e-12;let m=-1,md=t2;
+    for(let i=a+1;i1?1:t;const ex=ax+t*dx-P[i][0],ey=ay+t*dy-P[i][1],d=ex*ex+ey*ey;if(d>md){md=d;m=i;}}
+    if(m>=0){keep[m]=1;st.push(a,m,m,b);}}
+  const o=[];for(let i=0;icur||z{if(keep&&!keep.has(LANDP_ALL[ri]))return;if(ring.length<3)return;
+    const P=coastSimplify(coastPts(ri),tol);if(P.length<4)return;
     for(let i=1;i+1{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in t)return t[k];if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+  return (...a)=>{calls.push([k,...a]);return {};};}});
+  const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');
+  const P=()=>({p:{},u:{}}),B=()=>({v:{},b:{}});
+  Object.assign(GLX,{want:true,dead:false,gl,c,f,fx:f.getContext('2d'),line:P(),pk:P(),fill:P(),fan:P(),ell:P(),land:{},circ:P(),tex:{},lv:B(),hv:B(),pv:B(),cb:B(),wv:B(),cl:B(),empty:{},key:[],gpu:'stub'});return gl;})()`;
+
+test('a simplified coastline never strays more than the tolerance from the full one', () => {
+  const { ev, errors } = open();
+  const r = JSON.parse(ev(`(()=>{const out=[];let worst=0,rings=0,kept=0,all=0;
+    for(const lv of [-2,-1,0,1,3]){const tol=COAST_TOL/Math.pow(2,lv);
+      COAST.forEach((ring,ri)=>{if(ring.length<3)return;const P=coastPts(ri),Q=coastSimplify(P,tol),at=new Map(P.map((p,i)=>[p,i]));rings++;kept+=Q.length;all+=P.length;
+        if(Q[0]!==P[0]||Q[Q.length-1]!==P[P.length-1])out.push('ends '+ri);
+        for(let j=0;j+1a))out.push('order '+ri);
+          const ax=P[a][0],ay=P[a][1],dx=P[b][0]-ax,dy=P[b][1]-ay,L=dx*dx+dy*dy||1e-12;
+          for(let i=a+1;iworst)worst=d;}}});}
+    return JSON.stringify({bad:out.slice(0,5),worst,rings,share:kept/all});})()`));
+  assert.deepEqual(r.bad, [], 'each ring keeps its ends and its order');
+  assert.ok(r.worst <= 1 + 1e-9, `no point further than the tolerance (worst ${r.worst.toFixed(3)} of it)`);
+  assert.ok(r.rings > 50);
+  assert.ok(r.share < 0.6, `points are left out (${(r.share * 100).toFixed(0)} % kept)`);
+  assert.deepEqual(errors, []);
+});
+
+test('zoomed out the land has a few times fewer segments, and the closer the zoom the more it keeps', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{const full=glLandGeo(GLX.gl,false),n=lv=>glLandGeo(GLX.gl,false,lv).nSeg;
+    return JSON.stringify({full:full.nSeg,fullFan:full.nFan,l_1:n(-1),l0:n(0),l1:n(1),l3:n(3),far:glLandGeo(GLX.gl,true,-1).nSeg,once:glLandGeo(GLX.gl,false,0)===glLandGeo(GLX.gl,false,0),
+      fan:glLandGeo(GLX.gl,false,-1).nFan});})()`));
+  assert.ok(r.l_1 * 3 < r.full, `zoom 0.5–1: ${r.l_1} segments, ${r.full} in full`);
+  assert.ok(r.l_1 < r.l0 && r.l0 < r.l1 && r.l1 <= r.l3 && r.l3 <= r.full, JSON.stringify(r));
+  assert.ok(r.far < r.l_1, 'the far view still leaves out the islets');
+  assert.ok(r.fan * 3 < r.fullFan, 'the fill’s fan shrinks as much');
+  assert.equal(r.once, true, 'each level is built once');
+  assert.deepEqual(errors, []);
+});
+
+test('the zoom level takes the finer level at once and keeps it a little while zooming out', () => {
+  const { ev, errors } = open();
+  const lv = JSON.parse(ev(`(()=>{delete GLX.coastLv;return JSON.stringify([1.5,2.1,1.95,1.85,1.8,0.9,0.95,0.4].map(coastLevel));})()`));
+  assert.deepEqual(lv, [0, 1, 1, 1, 0, -1, -1, -2]);
+  assert.deepEqual(errors, []);
+});
+
+test('each frame on the card fills the land from its zoom level’s geometry; the coastlines and the 2D map stay as they were', () => {
+  const { ev, errors } = open();
+  const coast = ev('JSON.stringify(COAST)');
+  ev(STUB);
+  const fans = JSON.parse(ev(`(()=>{const h=CITY[S.home];cam.x=h.x;cam.y=h.y;delete GLX.coastLv;const o=[];
+    for(const z of [0.6,1.4,3.2]){cam.z=z;GLX.gl.calls.length=0;draw(1000);const want=glLandGeo(GLX.gl,lodFar(),coastLevel(z)).nFan;
+      o.push(GLX.gl.calls.filter(c=>c[0]==='drawArrays'&&c[1]==='TRIANGLES').every(c=>c[3]===want));}return JSON.stringify(o);})()`));
+  assert.deepEqual(fans, [true, true, true]);
+  assert.equal(ev('JSON.stringify(COAST)'), coast, 'COAST is never changed (onLand() reads it)');
+  let built = 0;
+  ev(`mapGl(false);window.__lg=glLandGeo;glLandGeo=function(){__built++;return __lg.apply(this,arguments);};window.__built=0;cam.z=0.6;draw(1016);cam.z=3.2;draw(1032);`);
+  built = ev('__built');
+  assert.equal(built, 0, 'the 2D map does not use it');
+  assert.deepEqual(errors, []);
+});
diff --git a/tests/webgl-map.test.js b/tests/webgl-map.test.js
index 2d70dea..7d41a6e 100644
--- a/tests/webgl-map.test.js
+++ b/tests/webgl-map.test.js
@@ -108,14 +108,15 @@ test('the land is geometry on the card: one fan per coastline, its outlines, its
     const pts=COAST.reduce((a,p)=>a+p.length,0);
     GLX.gl.calls.length=0;cam.z=1.4;draw(1000);
     const fans=GLX.gl.calls.filter(c=>c[0]==='drawArrays'&&c[1]==='TRIANGLES').map(c=>c[3]);
-    return JSON.stringify({nFan:all.nFan,nSeg:all.nSeg,farSeg:far.nSeg,pts,hills:all.nHill,again:glLandGeo(GLX.gl,false)===all,fans,
+    const lv=glLandGeo(GLX.gl,false,coastLevel(1.4));
+    return JSON.stringify({nFan:all.nFan,nSeg:all.nSeg,farSeg:far.nSeg,pts,hills:all.nHill,again:glLandGeo(GLX.gl,false)===all,fans,lvFan:lv.nFan,
       wl:GLX.gl.calls.some(c=>c[0]==='texImage2D'&&c[6]===WL.cv)});})()`));
   assert.equal(r.nFan % 3, 0, 'whole triangles');
   assert.equal(r.nSeg, r.pts * 4, 'each curve of the coast in four segments');
   assert.ok(r.farSeg < r.nSeg, 'zoomed out, the islets are left out as in 2D');
   assert.equal(r.hills, ev('HILLS.length'));
   assert.ok(r.again, 'built once');
-  assert.ok(r.fans.length >= 2 && r.fans.every(n => n === r.nFan), 'shadow and grass are filled each frame from the same fan');
+  assert.ok(r.fans.length >= 2 && r.fans.every(n => n === r.lvFan), 'shadow and grass are filled each frame from the same fan (the zoom level’s)');
   assert.equal(r.wl, false, 'no picture of the land is uploaded');
   assert.deepEqual(errors, []);
 });

From 87b153db6f9d507deb7958fdf9aa026c6cd5aa50 Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 17:19:27 +0100
Subject: [PATCH 08/23] WebGL map: keep the pictures' keys, the waves and the
 clouds out of the garbage

A frame joined a key for every city, label, quiet dot and stamp it drew, built a closure
to paint each even when the picture was already there, concatenated a prefix onto every
key, made an array per city per copy of the map for its place on screen, and rebuilt
the waves' and the clouds' arrays. Keys are now kept per city (packed into one number for
the yes/no parts), per label text and look, per stamp and scale, and joined again only
when the picture changes; pictures already painted are found before any closure is
made; the card's and the 2D map's pictures are two maps, so keys need no prefix; the
cities' places and the POP lights are computed in place; the waves and the clouds are
written into arrays kept from frame to frame.

Sampled heap profile, TTL save, RTX 4060 Ti: allocations under drawFrame 68 -> 37 MB/s
at x1 and 62 -> 43 MB/s during a pan/zoom sweep; under glBegin 5.4 -> 0.5 MB/s.
---
 CHANGELOG.md                           |  1 +
 src/game/96-map/57-webgl-background.js | 12 ++--
 src/game/96-map/59-gl-sprites.js       | 22 +++++--
 src/game/96-map/60-draw.js             |  4 +-
 src/game/96-map/80-cities.js           | 40 ++++++++----
 tests/webgl-frame-garbage.test.js      | 89 ++++++++++++++++++++++++++
 tests/webgl-sprites.test.js            | 10 +--
 tests/webgl-zoom-sprites.test.js       | 12 ++--
 8 files changed, 153 insertions(+), 37 deletions(-)
 create mode 100644 tests/webgl-frame-garbage.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8811912..dc7bad2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@ All notable changes to this project are documented here. The project follows
 - Long zooms stay on the graphics card: the pictures of cities and labels are painted on one shared canvas instead of each keeping its own, so the browser no longer runs out of room for them and switches to the slower drawing.
 - Zooming is smoother on big maps: while you zoom, cities and ships keep their picture and are only redrawn sharp once the zoom stops, instead of being repainted at every small step.
 - The graphics card draws the coastlines with fewer points when you zoom out, where the extra detail was smaller than a pixel, so the map costs it a lot less work, which helps phones most.
+- The map leaves far less memory behind it on every frame for the browser to clean up while you play.
 
 ## [2.9.1] — 2026-11-04
 
diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js
index 5d5d7b9..ebab529 100644
--- a/src/game/96-map/57-webgl-background.js
+++ b/src/game/96-map/57-webgl-background.js
@@ -74,13 +74,17 @@ function glLand(gl,ks){const G=glLandGeo(gl,lodFar(),coastLevel(cam.z));
 const WAVE_COL=glColor('rgba(255,255,255,.45)');
 function glWaves(gl,now,ks){const A=GLX.wa||(GLX.wa=new Float32Array(WAVES.length*8*LINE_STRIDE)),ph0=now/900;let m=0;
   for(const [x,y,ph] of WAVES){const o=Math.sin(ph0+ph*6)*3;
-    for(const [x0,cx,cy,x1] of [[x-9+o,x-4.5+o,y-4,x+o],[x+o,x+4.5+o,y+4,x+9+o]]){let px=x0,py=y;
+    // Two curves: up from x-9 to x, then down to x+9 (no array literals per wave: they were garbage every frame).
+    for(let c=0;c<2;c++){const x0=x+o+(c?0:-9),cx=x0+4.5,cy=y+(c?4:-4),x1=x0+9;let px=x0,py=y;
       for(let j=1;j<=4;j++){const t=j/4,u=1-t,qx=u*u*x0+2*u*t*cx+t*t*x1,qy=u*u*y+2*u*t*cy+t*t*y;glSegAt(A,m++,px,py,qx,qy,0,2,0,0,WAVE_COL[3],WAVE_COL);px=qx;py=qy;}}}
   gl.bindBuffer(gl.ARRAY_BUFFER,GLX.wv.b);gl.bufferData(gl.ARRAY_BUFFER,A.subarray(0,m*LINE_STRIDE),gl.DYNAMIC_DRAW);glLines(gl,GLX.wv.v,m,ks);}
 // The clouds: their puffs are stencilled as one shape, then filled once, so overlapping puffs do not stack.
-function glClouds(gl,now,ks){const A=[];for(const k of ks)for(const c of CLOUDS){const x=((c.x+now/1000*c.v)%(W+200))-100+k*W,y=c.y;
-  A.push(x,y,16*c.s,0, x+18*c.s,y-8*c.s,20*c.s,0, x+40*c.s,y,15*c.s,0);}
-  if(!A.length)return;const F=new Float32Array(A),P=GLX.circ;gl.bindBuffer(gl.ARRAY_BUFFER,GLX.cl.b);gl.bufferData(gl.ARRAY_BUFFER,F,gl.DYNAMIC_DRAW);
+function glClouds(gl,now,ks){const need=ks.length*CLOUDS.length*12;if(!need)return;
+  // Written into one array kept from frame to frame, grown when more copies of the map show.
+  if(!GLX.ca||GLX.ca.lengthsprMap().get(key);
 // A picture of w×h CSS px with its anchor at (ax,ay): painted once by paint(g) (the 2D canvas, at the screen's pixel
-// density, which is part of the key), and kept in SPRS. The card's pictures and the 2D map's are kept apart ('g', 'c').
-function spriteEntry(key,w,h,ax,ay,paint){const gpu=GLS.frame&&!!GLX.gl&&!!GLS.prog;key=(gpu?'g':'c')+DPR+'|'+key;let e=SPRS.get(key);if(e)return e;
-  if(SPRS.size>=SPR_MAX)spritesReset();
+// density), and kept by key in SPRS (the card's) or SPRC (the 2D map's).
+function spriteEntry(key,w,h,ax,ay,paint){const M=sprMap(),gpu=M===SPRS;let e=M.get(key);if(e)return e;
+  if(SPRS.size+SPRC.size>=SPR_MAX)spritesReset();
   const pw=Math.ceil(w*DPR),ph=Math.ceil(h*DPR),saved=ctx;
   e={cv:null,pw,ph,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1};
   if(gpu&&pw<=GLS.size&&ph<=GLS.size){const P=glsPad(pw,ph),g=P.g;
@@ -48,7 +53,7 @@ function spriteEntry(key,w,h,ax,ay,paint){const gpu=GLS.frame&&!!GLX.gl&&!!GLS.p
     try{if(!glsPut(GLX.gl,e,P.cv))glsPut(GLX.gl,e,P.cv);}catch(x){throw glErr(x);}
   }else{const cv=document.createElement('canvas');cv.width=pw;cv.height=ph;const g=cv.getContext('2d');ctx=g;
     try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;}e.cv=cv;}
-  SPRS.set(key,e);return e;}
+  M.set(key,e);return e;}
 // Puts a picture with its own canvas into the atlas (once), shelf by shelf. A full atlas starts again; this picture then waits a frame.
 function glsEnsure(e){if(e.up)return true;const gl=GLX.gl;if(!gl||!GLS.prog||!e.cv)return false;
   try{return glsPut(gl,e,e.cv);}catch(x){throw glErr(x);}}
@@ -85,8 +90,11 @@ const sprQ=k=>Math.max(1/CSPR_STEP,Math.round(k*ZH.f*CSPR_STEP)/CSPR_STEP);
 // (k in steps of 1/24, as the cities; zoomed: k grows with the zoom, and is held while it moves, sprQ()), then drawn with
 // the anchor at (x,y). Things that bob or pulse are drawn as these at a moving place, so the overlay above the card
 // stays untouched (repainting it costs a whole screen of pixels).
+// The full key of a stamp at scale kq, kept per key: it was built again for every stamp on every frame.
+const STK=new Map();
 function stamp(key,w,h,ax,ay,k,x,y,paint,zoomed){const kq=zoomed?sprQ(k):Math.max(1/CSPR_STEP,Math.round(k*CSPR_STEP)/CSPR_STEP),r=k/kq;
-  const e=spriteEntry(key+'|'+kq,Math.ceil(w*kq),Math.ceil(h*kq),ax*kq,ay*kq,g=>{g.translate(ax*kq,ay*kq);g.scale(kq,kq);paint(g);});
+  let m=STK.get(key);if(!m||m.kq!==kq){if(STK.size>4000)STK.clear();STK.set(key,m={kq,k:key+'|'+kq});}
+  const e=spriteHas(m.k)||spriteEntry(m.k,Math.ceil(w*kq),Math.ceil(h*kq),ax*kq,ay*kq,g=>{g.translate(ax*kq,ay*kq);g.scale(kq,kq);paint(g);});
   blit(e,x-e.ax*r,y-e.ay*r,e.w*r,e.h*r);}
 // Text with an outline, centred on (x,y), as a picture placed on whole device pixels; tw is its width, px its size.
 function textStamp(t,font,px,tw,fill,stroke,lw,x,y){const W=Math.ceil(tw+lw+4),H=Math.ceil(px*1.5+lw+2);
diff --git a/src/game/96-map/60-draw.js b/src/game/96-map/60-draw.js
index 9448ad9..eea050b 100644
--- a/src/game/96-map/60-draw.js
+++ b/src/game/96-map/60-draw.js
@@ -96,7 +96,7 @@ function drawFrame(now){
   // cities
   UI.feed=null;if(UI.sel&&UI.sel.type==='link'){const sl=S.links.find(x=>x.id===UI.sel.id);const rec=sl&&R.ef[edgeKey(sl)];if(rec){UI.feed=new Set(Object.keys(rec.eg).map(k=>R.egDesc[k].city));UI.dest=new Set(Object.keys(rec.dst));}}
   // Place labels: your POPs and the selected city first, then others; a label that would overlap moves above its city or hides.
-  const vis=[];for(const C of CITIES){if(C.off&&!cityOn(C.id))continue;if(pzHide(C.id))continue;for(const k of ks){const [sx,sy]=toS(C.x,C.y,k);if(sx<-60||sx>CW+60||sy<-60||sy>CH+60)continue;vis.push({C,sx,sy});}}
+  const vis=[];for(const C of CITIES){const sy=(C.y-cam.y)*cam.z+CH/2;if(sy<-60||sy>CH+60)continue;if(C.off&&!cityOn(C.id))continue;if(pzHide(C.id))continue;for(const k of ks){const sx=(C.x+k*W-cam.x)*cam.z+CW/2;if(sx<-60||sx>CW+60)continue;vis.push({C,sx,sy});}}
   const prio=v=>(UI.sel&&UI.sel.type==='city'&&UI.sel.id===v.C.id?0:S.pops[v.C.id]?1:2);vis.sort((a,b)=>prio(a)-prio(b)||b.C.P-a.C.P);
   const rects=new RGrid(),labs=new RGrid(),hit=(r)=>rects.hits(r);
   const farL=lodFar();
@@ -116,7 +116,7 @@ function drawFrame(now){
     if(ly===null&&prio(v)===1)for(const y of [below,above]){const r={x:v.sx-tw/2,y:y-10,w:tw,h:21};if(!labs.hits(r)){ly=y;rects.push(r);labs.push(r);break;}}
     if(ly===null&&(prio(v)===0||(prio(v)===1&&(v.C.id===S.home||UI.hover===v.C.id)))){ly=below;const r={x:v.sx-tw/2,y:below-10,w:tw,h:21};rects.push(r);labs.push(r);}
     v.ly=ly;}
-  if(pzOn()){for(const v of vis.slice().reverse())pzDrawCity(v,csc,now);pzDrawMarks(ks,now);}else for(const v of vis.slice().reverse())drawCity(v.C,v.sx,v.sy,csc,now,v.ly,v.dem);
+  if(pzOn()){for(let i=vis.length-1;i>=0;i--)pzDrawCity(vis[i],csc,now);pzDrawMarks(ks,now);}else for(let i=vis.length-1;i>=0;i--){const v=vis[i];drawCity(v.C,v.sx,v.sy,csc,now,v.ly,v.dem);}
   // cable ships at sea (88-cable-ships.js), over the city labels so a ship leaving port stays in sight
   drawShips(ks,now);
   // Architect runs: what the tubes between two cities are (one trench, or separate paths), above the cities.
diff --git a/src/game/96-map/80-cities.js b/src/game/96-map/80-cities.js
index ebce4ff..3c6eb38 100644
--- a/src/game/96-map/80-cities.js
+++ b/src/game/96-map/80-cities.js
@@ -1,11 +1,15 @@
 // Label widths by text (city labels by id, link labels and far-view labels by text): measuring text every frame is slow.
-const LBLW={},LINKW=new Map(),LBLF=new Map(),CM={off:new Set(),big:new Set(),inc:new Set(),far:false};
+const LBLW={},LINKW=new Map(),LBLF=new Map(),FKEY=new Map(),QKEY=new Map(),CM={off:new Set(),big:new Set(),inc:new Set(),far:false};
 try{document.fonts&&document.fonts.ready.then(()=>{for(const k in LBLW)delete LBLW[k];LINKW.clear();LBLF.clear();FRAME.length=0;spritesReset();});}catch(e){}
 // A label on a pill: its text and look never change, so it is painted once (spriteEntry) and drawn as a picture. The
 // centre is x, y; the text sits at y+ty. The pill's box is w×h with corners r; the picture also takes the outline.
+// Keys are kept by text (PILLK), one per look: joining them for every label on every frame was most of the map's garbage.
+const PILLK=new Map();
 function pill(t,font,w,h,r,fill,ink,stroke,lw,x,y,ty){
-  const pad=lw+2,W=Math.ceil(w+pad*2),H=Math.ceil(h+pad*2),key=['pill',t,font,w,h,r,fill,ink,stroke,lw,ty].join('|');
-  const e=spriteEntry(key,W,H,W/2,H/2,g=>{g.translate(W/2,H/2);g.fillStyle=fill;g.strokeStyle=stroke;g.lineWidth=lw;
+  const pad=lw+2,W=Math.ceil(w+pad*2),H=Math.ceil(h+pad*2);let L=PILLK.get(t),m=null;
+  if(L)for(let i=0;i4000)PILLK.clear();PILLK.set(t,L=[]);}L.push(m={font,w,h,r,fill,ink,stroke,lw,ty,k:['pill',t,font,w,h,r,fill,ink,stroke,lw,ty].join('|')});}
+  const e=spriteHas(m.k)||spriteEntry(m.k,W,H,W/2,H/2,g=>{g.translate(W/2,H/2);g.fillStyle=fill;g.strokeStyle=stroke;g.lineWidth=lw;
     rr(-w/2,-h/2,w,h,r);g.fill();g.stroke();g.fillStyle=ink;g.font=font;g.textAlign='center';g.textBaseline='middle';g.fillText(t,0,ty);});
   // Whole device pixels, so the text stays as sharp as before.
   blit(e,Math.round((x-e.w/2)*DPR)/DPR,Math.round((y-e.h/2)*DPR)/DPR,e.w,e.h);}
@@ -13,8 +17,10 @@ function pill(t,font,w,h,r,fill,ink,stroke,lw,x,y,ty){
 function drawCityFar(C,sx,sy,sc,now,lyOverride){
   const p=S.pops[C.id],down=p&&p.down>S.day,sel=UI.sel&&UI.sel.type==='city'&&UI.sel.id===C.id,hov=UI.hover===C.id||(UI.snap&&UI.snap.id===C.id);
   if(p&&!down&&R.cityDem[C.id]>0&&sfOf(R,C.id)<0.9)dot(sx,sy,12,'rgba(255,77,94,1)',.35+.25*Math.sin(now/200));
-  const t=cTier(C.id),ph=sel?Math.floor(now/40)%8:-1,key=['far',p?1:0,down?1:0,p&&p.site2?1:0,p?(p.routers||1)>=2?1:0:0,t,hov?1:0,hasIxAt(C.id)?1:0,CM.off.has(C.id)?1:0,CM.inc.has(C.id)?1:0,ph].join('|');
-  stamp(key,36,36,18,18,1,sx,sy,()=>cityFarStatic(C,p,down,sel,hov,ph));
+  const t=cTier(C.id),ph=sel?Math.floor(now/40)%8:-1,f=(p?1:0)|(down?2:0)|(p&&p.site2?4:0)|(p&&(p.routers||1)>=2?8:0)|(hov?16:0)|(hasIxAt(C.id)?32:0)|(CM.off.has(C.id)?64:0)|(CM.inc.has(C.id)?128:0);
+  // The key, kept per city and built again only when the picture changes.
+  let m=FKEY.get(C.id);if(!m||m.f!==f||m.t!==t||m.ph!==ph)FKEY.set(C.id,m={f,t,ph,k:'far|'+t+'|'+f+'|'+ph});
+  stamp(m.k,36,36,18,18,1,sx,sy,()=>cityFarStatic(C,p,down,sel,hov,ph));
   if(lyOverride!==null&&(p||sel||hov)){ctx.font=`800 ${p?12:11}px "Baloo 2", sans-serif`;const t=C.name,wk=C.id+(p?1:0);let tw=LBLF.get(wk);if(tw===undefined)LBLF.set(wk,tw=ctx.measureText(t).width+12);const ly=lyOverride==null?sy+15:lyOverride;
     pill(t,ctx.font,tw,16,8,p?'#FF4F9A':'#FFFFFF',p?'#FFFFFF':'#1E2640','#1E2640',1.6,sx,ly,1);}
 }
@@ -79,18 +85,25 @@ function cityStatic(C,p,t,cs,k,ph,st){const down=st.down;
   if(st.inc){ctx.fillStyle='#FF4D5E';ctx.beginPath();ctx.arc(-20,-h+2,7,0,7);ctx.fill();ctx.lineWidth=2;ctx.stroke();ctx.fillStyle='#fff';ctx.font='900 11px Nunito, sans-serif';ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText('!',-20,-h+3);}
 }
 // The picture of a city in a given state, at the quantised scale kq: painted once and kept until it is not needed.
-function citySprite(C,p,t,cs,kq,ph,st){
-  const key=['city',C.id,t,kq,st.down?1:0,p?1:0,p&&p.site2?1:0,p&&p.site2&&siteDown(C.id,'b')?1:0,p&&p.ringcut>S.day?1:0,p?(p.routers||1):0,p&&p.gen?1:0,p?(p.rgen||0):0,C.au?1:0,
-    st.ixDraw?1:0,st.ixHot?1:0,ixName(C.id)||'',S.myIx[C.id]?1:0,hasIxAt(C.id)?1:0,!p&&ixQuiet(C.id)?1:0,st.feed?1:0,st.sel?ph.sel:-1,ph.dd,st.inc?1:0].join('|');
+// Its key is kept per city (CKEY) and joined again only when one of its parts changes: the yes/no parts are bits of f.
+const CKEY=new Map();
+function citySprite(C,p,t,cs,kq,ph,st){const id=C.id,
+    f=(st.down?1:0)|(p?2:0)|(p&&p.site2?4:0)|(p&&p.site2&&siteDown(id,'b')?8:0)|(p&&p.ringcut>S.day?16:0)|(p&&p.gen?32:0)|(C.au?64:0)|(st.ixDraw?128:0)|
+      (st.ixHot?256:0)|(S.myIx[id]?512:0)|(hasIxAt(id)?1024:0)|(!p&&ixQuiet(id)?2048:0)|(st.feed?4096:0)|(st.inc?8192:0),
+    ro=p?(p.routers||1):0,rg=p?(p.rgen||0):0,ix=ixName(id)||'',sp=st.sel?ph.sel:-1,dd=ph.dd;
+  let m=CKEY.get(id);
+  if(!m||m.t!==t||m.kq!==kq||m.f!==f||m.ro!==ro||m.rg!==rg||m.ix!==ix||m.sp!==sp||m.dd!==dd)CKEY.set(id,m={t,kq,f,ro,rg,ix,sp,dd,k:['city',id,t,kq,f,ro,rg,ix,sp,dd].join('|')});
+  const e=spriteHas(m.k);if(e)return e;
   const W=Math.ceil(92*kq),H=Math.ceil(84*kq),ax=45*kq,ay=46*kq;
-  return spriteEntry(key,W,H,ax,ay,g=>{g.translate(ax,ay);cityStatic(C,p,t,cs,kq,ph,st);});}
+  return spriteEntry(m.k,W,H,ax,ay,g=>{g.translate(ax,ay);cityStatic(C,p,t,cs,kq,ph,st);});}
 // The parts that move, in the city's frame at the true scale k.
 function cityMoving(C,p,t,cs,k,sx,sy,now,h,st,hot){const down=st.down,K=k*cs;
   if(p){// The POP's own frame is shifted 2 down, and mirrored Down Under (C.au): mp() takes a point of that frame to the city's.
-    const fl=!!C.au,mp=(x,y)=>fl?[-x,-y-2]:[x,y+2],sf=sfOf(R,C.id),at=(x,y)=>{const q=mp(x,y);return [sx+q[0]*K,sy+q[1]*K];};
-    if(!down&&(R.nodeLoad[C.id]||0)>=(R.nodeCap[C.id]||1e12)*0.95){for(let i=0;i<3;i++){const tt=(now/700+i/3)%1,[x,y]=at(6+i*3,-12-tt*18);dot(x,y,(3+tt*4)*K,'rgba(90,98,130,1)',0.55*(1-tt));}}
+    // A point (x,y) of that frame is at sx+(fl?-x:x)*K, sy+(fl?-y-2:y+2)*K (written out: no array per light per frame).
+    const fl=!!C.au,sf=sfOf(R,C.id);
+    if(!down&&(R.nodeLoad[C.id]||0)>=(R.nodeCap[C.id]||1e12)*0.95){for(let i=0;i<3;i++){const tt=(now/700+i/3)%1,x=6+i*3,y=-12-tt*18;dot(sx+(fl?-x:x)*K,sy+(fl?-y-2:y+2)*K,(3+tt*4)*K,'rgba(90,98,130,1)',0.55*(1-tt));}}
     // The four lights: a disc each, lit or not.
-    for(let i=0;i<4;i++){const lit=down?false:(((now/(160+i*37))|0)+i)%3!==0,[x,y]=at(-10+i*6.6,1),col=down?'#3B4260':lit?(sf<0.9?'#FF4D5E':'#7CFFB2'):'#2A3150';dot(x,y,2.1*K,col,1);}
+    for(let i=0;i<4;i++){const lit=down?false:(((now/(160+i*37))|0)+i)%3!==0,x=-10+i*6.6,col=down?'#3B4260':lit?(sf<0.9?'#FF4D5E':'#7CFFB2'):'#2A3150';dot(sx+(fl?-x:x)*K,sy+(fl?-3:3)*K,2.1*K,col,1);}
   }
   // A flashing IX: two pictures, one per colour.
   if(st.ixDraw&&st.ixHot){const on=Math.sin(now/180)>0,ix=p?19:SKY_W[t]/2+4;stamp('ixhot'+(on?1:0),22,22,11,11,K,sx+ix*K,sy+(2-h)*K,()=>{ctx.translate(-ix,h-2);ctx.strokeStyle='#1E2640';cityIX(C,p,t,h,true,on?1:-1);},true);}
@@ -106,7 +119,8 @@ function drawCity(C,sx,sy,sc,now,lyOverride,dem){
   const p=S.pops[C.id],down=p&&p.down>S.day,sel=UI.sel&&UI.sel.type==='city'&&UI.sel.id===C.id,hov=UI.hover===C.id||(UI.snap&&UI.snap.id===C.id);
   // No room for its skyline here: a quiet dot, a little bigger for bigger cities, until you zoom in (cityRoom).
   if(dem&&!p&&!sel&&!hov){const r=(2.6+cTier(C.id)*0.35)*sc,rq=Math.round(r*4)/4,fill=hasIxAt(C.id)?'#FFD23F':'#FFFFFF',S2=Math.ceil(rq*2+4);
-    const e=spriteEntry(['quiet',rq,fill].join('|'),S2,S2,S2/2,S2/2,g=>{g.translate(S2/2,S2/2);g.fillStyle=fill;g.strokeStyle='#1E2640';g.lineWidth=1.6;g.beginPath();g.arc(0,0,rq,0,7);g.fill();g.stroke();});
+    const qk=rq*8+(fill==='#FFFFFF'?0:1);let key=QKEY.get(qk);if(!key)QKEY.set(qk,key=['quiet',rq,fill].join('|'));
+    const e=spriteHas(key)||spriteEntry(key,S2,S2,S2/2,S2/2,g=>{g.translate(S2/2,S2/2);g.fillStyle=fill;g.strokeStyle='#1E2640';g.lineWidth=1.6;g.beginPath();g.arc(0,0,rq,0,7);g.fill();g.stroke();});
     blit(e,sx-e.ax,sy+2*sc-e.ay,e.w,e.h);return;}
   const t=cTier(C.id),cs=p?1:CSC[t],k=sc*(hov?1.15:1),kq=sprQ(k);
   const ixn=ixName(C.id),ixDraw=!!ixn&&(ixShown(C.id,p)||(hot&&hot.ix)||sel||hov),ixHot=!!(ixDraw&&hot&&hot.ix);
diff --git a/tests/webgl-frame-garbage.test.js b/tests/webgl-frame-garbage.test.js
new file mode 100644
index 0000000..a672b14
--- /dev/null
+++ b/tests/webgl-frame-garbage.test.js
@@ -0,0 +1,89 @@
+// A frame on the card makes little garbage (src/game/96-map/57-webgl-background.js, 59-gl-sprites.js, 80-cities.js):
+// the keys of the pictures are kept per city and per label and built again only when the picture changes, and the
+// waves and the clouds are written into arrays kept from frame to frame. What is drawn stays the same.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { load } = require('./harness');
+
+const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
+
+function open() {
+  const h = load({ seed: 777 });
+  h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();S.nextFail=S.day+999;S.nextEvent=S.day+999;compute();`);
+  return h;
+}
+
+const STUB = `(()=>{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in t)return t[k];if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+  return (...a)=>{calls.push([k,...a]);return {};};}});
+  const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');
+  const P=()=>({p:{},u:{}}),B=()=>({v:{},b:{}});
+  Object.assign(GLX,{want:true,dead:false,gl,c,f,fx:f.getContext('2d'),line:P(),pk:P(),fill:P(),fan:P(),ell:P(),land:{},circ:P(),tex:{},lv:B(),hv:B(),pv:B(),cb:B(),wv:B(),cl:B(),empty:{},key:[],gpu:'stub'});
+  GLS.prog=P();GLS.vao={};GLS.buf={};GLS.tex={};GLS.size=4096;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;return gl;})()`;
+
+// Counts the keys joined during one frame (Array#join with '|', as the picture keys are), but the ships' (a handful).
+const JOINS = (body) => `(()=>{let n=0;const j=Array.prototype.join;Array.prototype.join=function(s){if(s==='|'&&this[0]!=='ship')n++;return j.apply(this,arguments);};
+  try{${body}}finally{Array.prototype.join=j;}return n;})()`;
+
+for (const [view, z] of [['near', 1.4], ['far', 0.6]]) {
+  test(`an unchanged frame on the card joins no picture key again (${view} view)`, () => {
+    const { ev, errors } = open();
+    ev(STUB);
+    ev(`const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=${z};UI.sel=null;draw(1000);draw(1016);`);
+    const first = ev(JOINS(`SPRS.clear();CKEY.clear();PILLK.clear();FKEY.clear();QKEY.clear();draw(1032);`));
+    const again = ev(JOINS('draw(1048);'));
+    assert.ok(first > 20, `a first frame builds its keys (${first})`);
+    assert.equal(again, 0, 'the next one builds none');
+    assert.deepEqual(errors, []);
+  });
+}
+
+test('a city whose state changes gets a new picture, and its old one back after', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{const id=S.home,C=CITY[id],p=S.pops[id];cam.x=C.x;cam.y=C.y;cam.z=1.4;UI.sel=null;
+    const pic=()=>{draw(1000);return CKEY.get(id).k;};const a=pic();const was=p.down;p.down=S.day+3;const b=pic();p.down=was;const c=pic();
+    UI.sel={type:'city',id};const d=pic();UI.sel=null;
+    const before=CKEY.get(id).k,gen=p.gen;p.gen=!gen;const e=pic();p.gen=gen;
+    return JSON.stringify({a,b,c,d,e,before});})()`));
+  assert.notEqual(r.b, r.a, 'down: another picture');
+  assert.equal(r.c, r.a, 'back up: the same picture');
+  assert.notEqual(r.d, r.a, 'selected: another picture');
+  assert.notEqual(r.e, r.before, 'a generator: another picture');
+  assert.deepEqual(errors, []);
+});
+
+test('labels with the same text but another look are other pictures', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{GLS.frame=true;GLS.n=0;ctx=GLX.fx;const f='800 12px "Baloo 2", sans-serif';
+    pill('Lagos',f,50,19,9,'#FFFFFF','#1E2640','#1E2640',2,10,10,.5);pill('Lagos',f,50,19,9,'#FF4F9A','#FFFFFF','#1E2640',2,10,10,.5);pill('Lagos',f,50,19,9,'#FFFFFF','#1E2640','#1E2640',2,10,10,.5);
+    const n=GLS.n,L=PILLK.get('Lagos').length,u=new Set([0,1,2].map(i=>GLS.data[i*SPR_STRIDE+4]+','+GLS.data[i*SPR_STRIDE+5])).size;GLS.frame=false;GLS.n=0;ctx=CTX0;
+    return JSON.stringify({n,L,u});})()`));
+  assert.equal(r.n, 3);
+  assert.equal(r.L, 2, 'two looks kept for one text');
+  assert.equal(r.u, 2, 'two pictures in the atlas, the third label reuses the first');
+  assert.deepEqual(errors, []);
+});
+
+test('the waves and the clouds are what they were, written into arrays kept from frame to frame', () => {
+  const { ev, errors } = open();
+  ev(STUB);
+  const r = JSON.parse(ev(`(()=>{const ks=[-1,0,1],now=12345,gl=GLX.gl;
+    glWaves(gl,now,ks);const wa=GLX.wa,ph0=now/900,want=[];let m=0,bad=0;
+    for(const [x,y,ph] of WAVES){const o=Math.sin(ph0+ph*6)*3;for(const [x0,cx,cy,x1] of [[x-9+o,x-4.5+o,y-4,x+o],[x+o,x+4.5+o,y+4,x+9+o]]){let px=x0,py=y;
+      for(let j=1;j<=4;j++){const t=j/4,u=1-t,qx=u*u*x0+2*u*t*cx+t*t*x1,qy=u*u*y+2*u*t*cy+t*t*y,o2=m*LINE_STRIDE;
+        if(wa[o2]!==Math.fround(px)||wa[o2+1]!==Math.fround(py)||wa[o2+2]!==Math.fround(qx)||wa[o2+3]!==Math.fround(qy))bad++;m++;px=qx;py=qy;}}}
+    glWaves(gl,now+16,ks);const sameW=GLX.wa===wa;
+    glClouds(gl,now,ks);const ca=GLX.ca,A=[];for(const k of ks)for(const c of CLOUDS){const x=((c.x+now/1000*c.v)%(W+200))-100+k*W,y=c.y;A.push(x,y,16*c.s,0, x+18*c.s,y-8*c.s,20*c.s,0, x+40*c.s,y,15*c.s,0);}
+    const sent=gl.calls.filter(c=>c[0]==='bufferData').pop()[2],cbad=A.filter((v,i)=>sent[i]!==Math.fround(v)).length;
+    glClouds(gl,now+16,ks);
+    return JSON.stringify({bad,m,sameW,cbad,clen:sent.length,alen:A.length,sameC:GLX.ca===ca});})()`));
+  assert.equal(r.bad, 0, `every wave segment where it was (${r.m} segments)`);
+  assert.equal(r.sameW, true);
+  assert.equal(r.clen, r.alen, 'one record per puff');
+  assert.equal(r.cbad, 0, 'every puff where it was');
+  assert.equal(r.sameC, true, 'the clouds’ array is kept');
+  assert.deepEqual(errors, []);
+});
diff --git a/tests/webgl-sprites.test.js b/tests/webgl-sprites.test.js
index e5d765c..cf7665c 100644
--- a/tests/webgl-sprites.test.js
+++ b/tests/webgl-sprites.test.js
@@ -35,7 +35,7 @@ test('on the card, pictures are painted on one canvas and each goes into the atl
   const r = JSON.parse(ev(`(()=>{const subs=GLX.gl.calls.filter(c=>c[0]==='texSubImage2D'),es=[...SPRS.values()];
     return JSON.stringify({canvases:__canvases,subs:subs.length,sprites:es.length,mine:es.filter(e=>e.cv).length,
       allUp:es.every(e=>e.up),rect:subs.every(c=>c.length===10&&c[9]===GLS_PAD.cv&&c[5]>0&&c[6]>0),
-      fit:subs.every(c=>c[5]<=GLS_PAD.cv.width&&c[6]<=GLS_PAD.cv.height),keys:es.length?[...SPRS.keys()].every(k=>k[0]==='g'):false});})()`));
+      fit:subs.every(c=>c[5]<=GLS_PAD.cv.width&&c[6]<=GLS_PAD.cv.height),keys:es.length>0&&SPRC.size===0});})()`));
   assert.ok(r.sprites > 50, `a zoom paints many pictures (${r.sprites})`);
   assert.ok(r.canvases <= 1, `one canvas for all of them, not one each (${r.canvases} made)`);
   assert.equal(r.mine, 0, 'no picture keeps a canvas of its own');
@@ -53,7 +53,7 @@ test('a full atlas starts again and the picture that did not fit goes into the n
   const r = JSON.parse(ev(`(()=>{GLS.frame=true;GLS.n=0;ctx=GLX.fx;GLS.shy=GLS.size-4;GLS.shx=GLS.size-2;GLS.shh=4;
     const before=SPRS.size;let draws=0;const gd=glsDraw;glsDraw=function(){draws++;};
     const e=spriteEntry('big',40,40,20,20,g=>{g.fillRect(0,0,40,40);});blit(e,10,10,40,40);
-    glsDraw=gd;const r={up:e.up,u0:e.u0,v0:e.v0,kept:SPRS.get('g'+DPR+'|big')===e,size:SPRS.size,n:GLS.n,cv:!!e.cv,shy:GLS.shy};GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify(r);})()`));
+    glsDraw=gd;const r={up:e.up,u0:e.u0,v0:e.v0,kept:SPRS.get('big')===e,size:SPRS.size,n:GLS.n,cv:!!e.cv,shy:GLS.shy};GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify(r);})()`));
   assert.equal(r.up, true, 'the picture is in the atlas');
   assert.equal(r.u0, 0); assert.equal(r.v0, 0);
   assert.equal(r.kept, true, 'and kept under its key after the restart');
@@ -66,7 +66,7 @@ test('a full atlas starts again and the picture that did not fit goes into the n
 test('the 2D map keeps a canvas per picture, and its pictures are not the card’s', () => {
   const { ev, errors } = open();
   ev(`mapGl(false);const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;draw(1000);`);
-  const r = JSON.parse(ev(`(()=>{const es=[...SPRS.entries()];return JSON.stringify({n:es.length,cv:es.every(([k,e])=>k[0]==='c'&&e.cv&&e.cv.width===e.pw&&e.cv.height===e.ph),up:es.some(([,e])=>e.up)});})()`));
+  const r = JSON.parse(ev(`(()=>{const es=[...SPRC.entries()];return JSON.stringify({n:es.length,cv:SPRS.size===0&&es.every(([k,e])=>e.cv&&e.cv.width===e.pw&&e.cv.height===e.ph),up:es.some(([,e])=>e.up)});})()`));
   assert.ok(r.n > 10);
   assert.equal(r.cv, true, 'each with its own canvas, at its size');
   assert.equal(r.up, false, 'nothing went to a card');
@@ -82,8 +82,8 @@ test('giving the card up drops its pictures; the 2D map paints its own', () => {
   assert.equal(ev('SPRS.size'), 0, 'no picture without a canvas is left behind');
   assert.equal(ev('GLS.shx+GLS.shy+GLS.shh'), 0, 'the atlas is forgotten');
   ev('draw(1016)');
-  assert.ok(ev('SPRS.size') > 10);
-  assert.equal(ev(`[...SPRS.values()].every(e=>e.cv)`), true, 'the 2D map’s pictures have their canvas');
+  assert.ok(ev('SPRC.size') > 10);
+  assert.equal(ev(`[...SPRC.values()].every(e=>e.cv)`), true, 'the 2D map’s pictures have their canvas');
   assert.ok(ev('ctx===CTX0'));
   assert.deepEqual(errors, []);
 });
diff --git a/tests/webgl-zoom-sprites.test.js b/tests/webgl-zoom-sprites.test.js
index dc8ea40..ae35c7f 100644
--- a/tests/webgl-zoom-sprites.test.js
+++ b/tests/webgl-zoom-sprites.test.js
@@ -27,8 +27,8 @@ const STUB = `(()=>{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in
 // One POP's city pictures painted during frames from zoom z0 to z1 (the clock moving 16 ms a frame), by scale.
 const ZOOM = (z0, z1, n) => `(()=>{const id=S.home,C=CITY[id];cam.x=C.x;cam.y=C.y;const seen=new Set(),bad=[];
   for(let i=0;i<=${n};i++){cam.z=${z0}+(${z1}-${z0})*i/${n};__T+=16;draw(__T);
-    for(const k of SPRS.keys()){const p=k.split('|');if(p[1]==='city'&&p[2]===id)seen.add(+p[4]);}
-    const k=cityScale(iconScale()),kq=[...SPRS.keys()].filter(x=>x.split('|')[1]==='city'&&x.split('|')[2]===id).map(x=>+x.split('|')[4]);
+    for(const k of SPRS.keys()){const p=k.split('|');if(p[0]==='city'&&p[1]===id)seen.add(+p[3]);}
+    const k=cityScale(iconScale()),kq=[...SPRS.keys()].filter(x=>x.split('|')[0]==='city'&&x.split('|')[1]===id).map(x=>+x.split('|')[3]);
     if(kq.length&&!kq.some(q=>Math.max(q/k,k/q)<=1.25*(1+.5/24/0.7)))bad.push(i);}
   return JSON.stringify({steps:[...seen].sort(),bad});})()`;
 
@@ -45,7 +45,7 @@ test('on the card a zoom keeps each city’s picture for a while, and paints it
   assert.equal(ev('zoomMoving()'), true);
   ev('__T+=300;draw(__T)');
   const rest = JSON.parse(ev(`(()=>{const id=S.home,want=Math.round(cityScale(iconScale())*24)/24;
-    return JSON.stringify({f:ZH.f,want,has:[...SPRS.keys()].some(k=>{const p=k.split('|');return p[1]==='city'&&p[2]===id&&+p[4]===want;}),moving:zoomMoving()});})()`));
+    return JSON.stringify({f:ZH.f,want,has:[...SPRS.keys()].some(k=>{const p=k.split('|');return p[0]==='city'&&p[1]===id&&+p[3]===want;}),moving:zoomMoving()});})()`));
   assert.equal(rest.moving, false);
   assert.equal(rest.f, 1, 'at rest nothing is stretched');
   assert.equal(rest.has, true, 'the city is painted again at its own step');
@@ -56,8 +56,8 @@ test('the 2D map paints cities at their own step on every frame of a zoom, as be
   const { ev, errors } = open();
   ev(`mapGl(false);cam.z=0.8;draw(__T);`);
   const r = JSON.parse(ev(`(()=>{const id=S.home,C=CITY[id];cam.x=C.x;cam.y=C.y;const bad=[];
-    for(let i=0;i<=30;i++){cam.z=0.8+i/30;__T+=16;SPRS.clear();draw(__T);const want=Math.round(cityScale(iconScale())*24)/24;
-      if(ZH.f!==1||![...SPRS.keys()].some(k=>{const p=k.split('|');return p[1]==='city'&&p[2]===id&&+p[4]===want;}))bad.push(i);}
+    for(let i=0;i<=30;i++){cam.z=0.8+i/30;__T+=16;SPRC.clear();draw(__T);const want=Math.round(cityScale(iconScale())*24)/24;
+      if(ZH.f!==1||![...SPRC.keys()].some(k=>{const p=k.split('|');return p[0]==='city'&&p[1]===id&&+p[3]===want;}))bad.push(i);}
     return JSON.stringify({bad});})()`));
   assert.deepEqual(r.bad, []);
   assert.deepEqual(errors, []);
@@ -83,7 +83,7 @@ test('pictures that keep their size whatever the zoom (far-view cities, cones, d
   ev(STUB);
   const r = JSON.parse(ev(`(()=>{cam.z=1;draw(__T);__T+=1000;cam.z=1;draw(__T);cam.z=1.4;__T+=16;draw(__T);GLS.frame=true;GLS.n=0;ctx=GLX.fx;
     const f=ZH.f;drawCone(100,100,0);drawBackhoe(200,100,0,false);const D=GLS.data,o=[D[2],D[3],D[SPR_STRIDE+2],D[SPR_STRIDE+3]];
-    const keys=[...SPRS.keys()].filter(k=>['cone','hoe'].includes(k.split('|')[1]));GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify({f,o,keys});})()`));
+    const keys=[...SPRS.keys()].filter(k=>['cone','hoe'].includes(k.split('|')[0]));GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify({f,o,keys});})()`));
   assert.notEqual(r.f, 1, 'the zoom is moving and city pictures are held');
   assert.deepEqual(r.o, [26, 28, 38, 32], 'drawn at their own size');
   assert.ok(r.keys.length >= 2 && r.keys.every(k => k.endsWith('|1')), 'painted at scale 1: ' + r.keys);

From fb76a1e6fd8f826a1ef5c47b64eb1aff8e5a171e Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 19:08:36 +0100
Subject: [PATCH 09/23] 2D map: draw the pictures with the map's own pen, as
 main did

Cities, markers and labels are now pictures painted once on a canvas of their own. Drawn straight on the map,
main's dashed rings (the selected city, the cities feeding a selected tube, a flood), the cones' tips, a sleeping
POP's "zzz" and a working cable ship's spark took the state the tubes and labels left on the map's canvas: round
line ends and corners, text centred on its middle. A new canvas starts with square ends and text on its baseline, so
the rings came out with square dashes and the "zzz" sat higher. Every picture now starts with that pen (sprPen()),
on the card's shared canvas too.

tests/map-2d.test.js holds the 2D map to main, for players who keep it:
- for the same state, a frame drawn from the kept pictures is, call for call, the frame painted with no cache at
  all: over every state a POP can be in, a city without a POP, random views of the big network with days passing,
  and seeded random games after every move and day (the route-fuzz driver, two pages in lockstep);
- every tube's width, colour, dash and packets follow main's formulas;
- the 2D map never asks for WebGL, never draws a picture without a canvas, keeps one canvas per picture, draws as
  a 2D map after the card is switched off or lost, and paints again at a new pixel density;
- money pop-ups fade as before; every picture starts with the right pen.
Planted bugs (incomplete keys, a stale key memo, the tubes' looks kept without the routing, one shared 2D canvas,
no pen) each fail it. A pixel comparison with main in Chromium (desktop and phone, the fixture, a late-game save and
states from random games) found the pen and nothing else beyond sub-pixel edges.
---
 src/game/96-map/59-gl-sprites.js |   8 +-
 tests/map-2d.test.js             | 308 +++++++++++++++++++++++++++++++
 2 files changed, 314 insertions(+), 2 deletions(-)
 create mode 100644 tests/map-2d.test.js

diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js
index 9ecdf6c..5bb1053 100644
--- a/src/game/96-map/59-gl-sprites.js
+++ b/src/game/96-map/59-gl-sprites.js
@@ -48,12 +48,16 @@ function spriteEntry(key,w,h,ax,ay,paint){const M=sprMap(),gpu=M===SPRS;let e=M.
   e={cv:null,pw,ph,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1};
   if(gpu&&pw<=GLS.size&&ph<=GLS.size){const P=glsPad(pw,ph),g=P.g;
     g.save();g.setTransform(1,0,0,1,0,0);g.clearRect(0,0,pw,ph);ctx=g;
-    try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;g.restore();}
+    try{g.setTransform(DPR,0,0,DPR,0,0);sprPen(g);paint(g);}finally{ctx=saved;g.restore();}
     // A full atlas starts again (glsPut), and the picture goes into the empty one at once: the pad is reused next.
     try{if(!glsPut(GLX.gl,e,P.cv))glsPut(GLX.gl,e,P.cv);}catch(x){throw glErr(x);}
   }else{const cv=document.createElement('canvas');cv.width=pw;cv.height=ph;const g=cv.getContext('2d');ctx=g;
-    try{g.setTransform(DPR,0,0,DPR,0,0);paint(g);}finally{ctx=saved;}e.cv=cv;}
+    try{g.setTransform(DPR,0,0,DPR,0,0);sprPen(g);paint(g);}finally{ctx=saved;}e.cv=cv;}
   M.set(key,e);return e;}
+/* A picture starts with the pen the map's own canvas has when it draws cities and markers: the tubes leave it with
+   round line ends and corners, the labels with text centred on its middle. Drawn straight on the map, the dashed rings,
+   the cones' tips and a sleeping POP's "zzz" took those, and a new canvas has others (square ends, text on its baseline). */
+function sprPen(g){g.lineCap='round';g.lineJoin='round';g.textAlign='center';g.textBaseline='middle';}
 // Puts a picture with its own canvas into the atlas (once), shelf by shelf. A full atlas starts again; this picture then waits a frame.
 function glsEnsure(e){if(e.up)return true;const gl=GLX.gl;if(!gl||!GLS.prog||!e.cv)return false;
   try{return glsPut(gl,e,e.cv);}catch(x){throw glErr(x);}}
diff --git a/tests/map-2d.test.js b/tests/map-2d.test.js
new file mode 100644
index 0000000..450ad59
--- /dev/null
+++ b/tests/map-2d.test.js
@@ -0,0 +1,308 @@
+// The 2D map, for players who keep it (Settings › Map drawing › Always 2D, or no usable graphics card). The WebGL work
+// changed it too: cities, labels and markers are painted once as pictures and reused (59-gl-sprites.js), and each
+// tube's look is worked out once per day's routing (mapLinks(), 55-link-look.js). These tests hold the 2D map to what
+// it drew before:
+// - a frame drawn with the pictures kept from earlier states is, call for call, the frame painted from scratch: no
+//   picture is ever shown for a state it was not painted for (on the big network, and in seeded random games);
+// - every tube's width, colour, dash and packets follow the formulas main's 2D map used, after every move and day;
+// - the 2D map never asks for WebGL, never draws a picture it has no canvas for, and keeps one canvas per picture;
+// - every picture starts with the pen main's map had when it drew the same thing straight on the map (round line
+//   ends, centred text), or its dashed rings and markers would come out differently.
+// The page's clock is set by hand, so nothing depends on how fast the test runs. Comparing pixels with main needs a real
+// browser, which npm test does not use: that was done by hand, in Chromium, for this change.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { load } = require('./harness');
+const page = require('../scripts/lib/page');
+const { openPage, playGame, rng } = require('../scripts/lib/route-fuzz');
+
+const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
+
+/* In the page: every canvas made from now on records what is drawn on it, and the map's own context records the
+   frame. A picture is known by what was painted on it (a hash of its calls), so a frame's calls say which picture went
+   where. WebGL is not there (getContext gives null for it), and every request for it is counted. */
+const KIT = `window.__M2D=(()=>{
+  const N=v=>typeof v==='number'?String(Math.round(v*1000)/1000):v==null?String(v):typeof v==='function'?'fn':
+    v instanceof HTMLCanvasElement?v.__cid():Array.isArray(v)?'['+v.map(N).join(',')+']':typeof v==='object'?'obj':String(v);
+  const M=['arc','arcTo','beginPath','bezierCurveTo','clearRect','clip','closePath','drawImage','ellipse','fill','fillRect','fillText',
+    'lineTo','moveTo','quadraticCurveTo','rect','resetTransform','restore','rotate','roundRect','save','scale','setLineDash','setTransform',
+    'stroke','strokeRect','strokeText','transform','translate'];
+  // With each call that paints, the state of the context it uses (a picture does not care about the font, say).
+  const IMG=['globalAlpha','globalCompositeOperation'],FILL=[...IMG,'fillStyle'],LINE=[...IMG,'strokeStyle','lineWidth','lineDashOffset','lineJoin','lineCap'],
+    TXT=['font','textAlign','textBaseline'];
+  const PAINT={drawImage:IMG,clearRect:[],fill:FILL,fillRect:FILL,stroke:LINE,strokeRect:LINE,fillText:[...FILL,...TXT],strokeText:[...LINE,...TXT]};
+  const DEF={globalAlpha:1,fillStyle:'#000000',strokeStyle:'#000000',lineWidth:1,font:'10px sans-serif',lineDashOffset:0,lineJoin:'miter',lineCap:'butt',
+    textAlign:'start',textBaseline:'alphabetic',globalCompositeOperation:'source-over'};
+  function rec(c,keep){const Q={h:2166136261,n:0,log:keep?[]:null};
+    const add=s=>{for(let i=0;i>>0;Q.n++;if(Q.log)Q.log.push(s);};
+    for(const m of M)c[m]=function(...a){let s=m+'('+a.map(N).join(',')+')';for(const k of PAINT[m]||[])s+=' '+N(this[k]);add(s);};
+    Object.assign(c,DEF);c.__Q=Q;return c;}
+  const blank=()=>new Proxy({},{get(t,k){if(k in t)return t[k];if(k==='measureText')return s=>({width:String(s).length*7});
+    if(k==='createLinearGradient'||k==='createRadialGradient'||k==='createPattern')return ()=>({addColorStop(){}});
+    if(k==='getImageData')return ()=>({data:new Uint8ClampedArray(4)});if(k==='canvas')return null;return ()=>{};},set(t,k,v){t[k]=v;return true;}});
+  const asked=[];
+  HTMLCanvasElement.prototype.getContext=function(type){asked.push(type);if(type!=='2d')return null;return this.__ctx||(this.__ctx=rec(blank(),false));};
+  HTMLCanvasElement.prototype.__cid=function(){const q=this.__ctx&&this.__ctx.__Q;return q?'cv:'+q.h.toString(36)+'.'+q.n:'cv:?';};
+  rec(CTX0,true);
+  // A picture drawn in a 2D frame without a canvas of its own would simply not show.
+  let lost=0;const blit0=blit;blit=function(e,...a){if(!GLS.frame&&!e.cv)lost++;return blit0(e,...a);};
+  // One frame's calls on the map's canvas, from a known state of the context.
+  function frame(t){const Q=CTX0.__Q;Q.log.length=0;Q.h=2166136261;Q.n=0;Object.assign(CTX0,DEF);draw(t);return Q.log.slice();}
+  function inv(){let dup=0,bad=0;const seen=new Set();
+    for(const e of SPRC.values()){if(!e.cv){bad++;continue;}if(seen.has(e.cv))dup++;seen.add(e.cv);if(e.cv.width!==e.pw||e.cv.height!==e.ph)bad++;}
+    return {webgl:asked.filter(x=>x!=='2d').length,sprs:SPRS.size,glsFrame:GLS.frame,ctx0:ctx===CTX0,glShown:!document.getElementById('mapgl').hidden,
+      pad:!!GLS_PAD.cv,shared:dup,badCanvas:bad,lost};}
+  // Without the cache: every picture is painted again for every call, as if nothing were kept, even within a frame.
+  let nocache=false;const none={get(){},set(){},has:()=>false,size:0},sprMap0=sprMap;sprMap=function(){const m=sprMap0();return nocache?none:m;};
+  /* The same state drawn twice: with the pictures kept from every state before (kept), then painting every picture
+     again (fresh). The land picture is settled first, so both frames find it as it is. */
+  function pair(t){__T+=1000;if(S)worldLayer(cam.z);lost=0;
+    const kept=frame(t),had=SPRC.size;nocache=true;let fresh;try{fresh=frame(t);}finally{nocache=false;}
+    let d=-1;for(let i=0,n=Math.max(kept.length,fresh.length);i1,up=many?grp.filter(x=>!linkDown(x)):null;
+    const cap=many?up.reduce((a,x)=>a+capOf(x),0):capOf(l),load=many?grp.reduce((a,x)=>a+(R.load[x.id]||0),0):(R.load[l.id]||0),u=cap?load/cap:0,df=l.kind==='df',bld=df&&l.ready>day,cut=!bld&&(many?!up.length:linkDown(l))&&!(df&&!(l.ch||[]).length),dark=df&&!bld&&!(l.ch||[]).length,vx=l.kind==='vxc',idle=!cut&&!bld&&load<1e-3&&(many?up.length>0&&up.every(x=>x.standby):!!l.standby);
+    const w=(vx?2.2:(2.5+Math.max(...grp.map(tierW))*1.8+(many?Math.min(1.5,(grp.length-1)*0.5):0)));
+    return {w,dash:cut?[8,8]:vx?[2,7]:bld?[10,8]:idle?[4,6]:[],col:bld?'#C9B27C':dark?'#5D6788':cut?'#FF4D5E':idle?'#9AA3BE':vx?FAB[l.prov].col:l.sub?(u>0.001?utilCol(u):'#7FD8EE'):utilCol(u),
+      pk:!cut&&load>0.01?clamp(Math.round(2+u*10),2,12):0,cut,bld,dark,vx,cap,load,up:up&&up.map(x=>x.id)};}
+  // The kept looks (mapLinks) against groups, geometry and looks worked out again now, the way main did.
+  function looks(){if(!S||!R)return [];const ML=mapLinks(S.day),PI=pairIdx(),LG=linkGroups(),bad=[];
+    if(JSON.stringify(ML.LG.map(g=>g.map(l=>l.id)))!==JSON.stringify(LG.map(g=>g.map(l=>l.id))))return ['the tubes are not grouped as now'];
+    LG.forEach((g,i)=>{const gm=linkGeom(g[0],PI.get(edgeKey(g[0])));if(JSON.stringify(gm.pts)!==JSON.stringify(ML.GM[i].pts))bad.push('geometry of '+g[0].id);
+      const n=ML.looks[i],o=JSON.stringify(ref(g,S.day)),m=JSON.stringify({w:n.w0,dash:LDASH[n.dash],col:n.col,pk:n.pk,cut:n.cut,bld:n.bld,dark:n.dark,vx:n.vx,cap:n.cap,load:n.load,up:n.up&&n.up.map(x=>x.id)});
+      if(o!==m)bad.push(g[0].id+': main '+o+' kept '+m);});
+    return bad.slice(0,3);}
+  /* A view of the map: the camera on a city at a zoom, maybe a city or a tube selected, maybe a city under the
+     pointer, at clock t. u: numbers in [0,1) from the test's own seeded generator. */
+  function view(u){if(!S)return null;const pops=Object.keys(S.pops),at=pops.length&&u[0]<.7?pops[Math.floor(u[1]*pops.length)]:CITIES[Math.floor(u[1]*CITIES.length)].id,C=CITY[at];
+    cam.x=C.x+(u[2]-.5)*80;cam.y=C.y+(u[3]-.5)*60;cam.z=[.45,.7,1,1.6,3.2][Math.floor(u[4]*5)];
+    UI.sel=u[5]<.35?null:u[5]<.6?{type:'city',id:at}:S.links.length?{type:'link',id:S.links[Math.floor(u[6]*S.links.length)].id}:null;
+    UI.hover=u[7]<.3?at:null;return Math.floor(u[8]*20000);}
+  function check(u){const keep={x:cam.x,y:cam.y,z:cam.z,sel:UI.sel,hov:UI.hover};
+    try{const t=view(u);if(t===null)return null;const r=pair(t);r.looks=looks();r.view={at:UI.sel,z:cam.z,t};return r;}
+    finally{cam.x=keep.x;cam.y=keep.y;cam.z=keep.z;UI.sel=keep.sel;UI.hover=keep.hov;}}
+  return {frame,pair,inv,looks,check,view,asked};})();0`;
+
+// What a check returned, as the problems it shows (none: an empty list).
+function problems(r, where) {
+  if (!r) return [];
+  const out = [];
+  if (r.diff) out.push(`${where}: a kept picture differs from a fresh one at call ${r.diff.at}\n  kept:  ${r.diff.kept.join('\n         ')}\n  fresh: ${r.diff.fresh.join('\n         ')}`);
+  for (const l of r.looks || []) out.push(`${where}: ${l}`);
+  if (r.webgl) out.push(`${where}: WebGL asked for ${r.webgl} times`);
+  if (r.lost) out.push(`${where}: ${r.lost} pictures drawn without a canvas`);
+  if (r.shared || r.badCanvas) out.push(`${where}: ${r.shared} pictures share a canvas, ${r.badCanvas} have none or one of the wrong size`);
+  if (r.pad) out.push(`${where}: the card's shared canvas was made`);
+  if (r.sprs || r.glsFrame || !r.ctx0 || r.glShown) out.push(`${where}: card state leaked into 2D ${JSON.stringify({ sprs: r.sprs, glsFrame: r.glsFrame, ctx0: r.ctx0, glShown: r.glShown })}`);
+  return out;
+}
+
+// A card that records what it is asked (jsdom has no WebGL), as in tests/webgl-zoom-sprites.test.js.
+const GLSTUB = `window.__GLSTUB=(()=>{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in t)return t[k];if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+      return (...a)=>{calls.push(k);return {};};}});
+    const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');const P=()=>({p:{},u:{}}),B=()=>({v:{},b:{}});
+    const fx=document.createElement('canvas').getContext('2d');
+    Object.assign(GLX,{want:true,dead:false,gl,c,f,fx,line:P(),pk:P(),fill:P(),fan:P(),ell:P(),land:{},circ:P(),tex:{},lv:B(),hv:B(),pv:B(),cb:B(),wv:B(),cl:B(),empty:{},key:[],gpu:'stub'});
+    GLS.prog=P();GLS.vao={};GLS.buf={};GLS.tex={};GLS.size=4096;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;return gl;})();0`;
+
+function open() {
+  const h = load({ seed: 777 });
+  h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();S.nextFail=S.day+999;S.nextEvent=S.day+999;compute();
+    window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});mapGl(false);`);
+  h.ev(KIT);
+  return h;
+}
+
+test('the 2D map draws the same frame from kept pictures as from fresh ones, whatever happens to a POP', () => {
+  const { ev, errors } = open();
+  const found = [];
+  assert.ok(ev('CW>300&&CH>300'), 'the map has a size');
+  // One city goes through every state its picture can show. After each change the map is looked at from the same
+  // views (every zoom, plain, under the pointer, selected), so a picture kept from an earlier state is found under its
+  // key whenever the key leaves out what changed.
+  const STEPS = [
+    '0',
+    'S.pops[S.home].down=S.day+3',
+    'S.pops[S.home].down=0;S.pops[S.home].routers=2',
+    'S.pops[S.home].gen=1',
+    'S.pops[S.home].rgen=1',
+    'S.pops[S.home].site2=S.pops[S.home].site2||{}',
+    'S.pops[S.home].ringcut=S.day+2',
+    "S.inc.push({id:'t-site',type:'site',ref:S.home,site:'b',until:S.day+5})",
+    'R.ddosHot=Object.assign({},R.ddosHot,{[S.home]:1})',
+    'UI.hotMap={[S.home]:{r:1,t:1,ix:1}}',
+    "S.myIx[S.home]=S.myIx[S.home]||{name:'Test-IX',members:[],next:S.day+4}",
+    'S.pops[S.home].routers=3;S.pops[S.home].rgen=0;S.pops[S.home].gen=0',
+    'delete R.ddosHot[S.home];UI.hotMap=null;S.pops[S.home].ringcut=0',
+    'S.pops[S.home].down=S.day+1',
+    // A city without a POP next to it: an incident there, then an exchange.
+    "S.inc.push({id:'t-x',type:'cut',ref:__OTHER,until:S.day+3})",
+    "S.myIx[__OTHER]={name:'Other-IX',members:[],next:S.day+4}",
+  ];
+  // The other city: the nearest one without a POP.
+  ev("window.__OTHER=CITIES.filter(c=>!S.pops[c.id]&&!c.off).sort((a,b)=>Math.hypot(a.x-CITY[S.home].x,a.y-CITY[S.home].y)-Math.hypot(b.x-CITY[S.home].x,b.y-CITY[S.home].y))[0].id;0");
+  let checks = 0;
+  // u (see view()): centred on the home POP or on the other city, at zoom index z; nothing selected, the city under
+  // the pointer, or selected.
+  const VIEWS = [];
+  for (const city of ['pop', 'other']) for (let z = 0; z < 5; z++) for (const [sel, hov] of [[0.1, 0.9], [0.1, 0.1], [0.5, 0.9]]) VIEWS.push({ city, u: [city === 'pop' ? 0 : 0.9, 0, 0.5, 0.5, z / 5 + 0.01, sel, 0, hov, (z + 1) / 7] });
+  for (const step of STEPS) {
+    ev(step);
+    // Each change is looked at from the city it touches (both at the start).
+    const on = step === '0' ? null : step.includes('__OTHER') ? 'other' : 'pop';
+    VIEWS.forEach(({ city, u }, v) => {
+      if (on && city !== on) return;
+      const at = city === 'pop' ? 'Object.keys(S.pops).indexOf(S.home)/Object.keys(S.pops).length' : 'CITIES.findIndex(c=>c.id===__OTHER)/CITIES.length';
+      ev(`window.__U=${JSON.stringify(u)};__U[1]=${at}+1e-9;0`);
+      found.push(...problems(JSON.parse(ev('JSON.stringify(__M2D.check(__U))')), `after "${step}", view ${v} (${city})`));
+      checks++;
+    });
+  }
+  assert.ok(checks >= 250);
+  assert.deepEqual(found.slice(0, 5), []);
+  assert.deepEqual(errors, []);
+});
+
+test('the 2D map draws the same from kept pictures as from fresh ones, and tubes as main did, over random views of the big network', () => {
+  const { ev, errors } = open();
+  const r = rng(99), found = [];
+  for (let i = 0; i < 60; i++) {
+    // Now and then a day passes (failures and events on), so cuts, builds, floods and offers come and go.
+    if (i % 6 === 5) ev('S.nextFail=S.day;S.nextEvent=S.day;dayTick();compute();');
+    const u = Array.from({ length: 9 }, () => r());
+    found.push(...problems(JSON.parse(ev(`JSON.stringify(__M2D.check(${JSON.stringify(u)}))`)), `view ${i} (day ${ev('S.day')})`));
+  }
+  assert.deepEqual(found.slice(0, 5), []);
+  assert.deepEqual(errors, []);
+});
+
+test('in seeded random games, after every move and day, the 2D map draws the same from kept pictures and tubes as main did', () => {
+  const file = path.join(os.tmpdir(), `tubes-map2d-${process.pid}.html`);
+  fs.writeFileSync(file, page.assemble().html);
+  try {
+    // A normal game, a sandbox, a scenario and a puzzle (the seeds of tests/route-fuzz.test.js). The big network is the
+    // test above: a whole game of it, routed again after every move on two pages, takes a minute.
+    for (const seed of [20, 23, 27, 26]) {
+      // Two pages of this checkout play the game in lockstep (scripts/lib/route-fuzz.js): drawing the map on both, between
+      // moves, must not make them part (the 2D map must not change the game).
+      const P = { base: openPage(file, 'a'), head: openPage(file, 'b') };
+      for (const p of [P.base, P.head]) p.ev(`window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});mapGl(false);${KIT}`);
+      const r = rng(seed * 7919), found = [];
+      let checks = 0;
+      const g = playGame(P, seed, { moves: 40, maxDays: 4, onMove: () => {
+        const u = Array.from({ length: 9 }, () => r());
+        for (const p of [P.base, P.head]) {
+          const out = JSON.parse(p.ev(`JSON.stringify(__M2D.check(${JSON.stringify(u)}))`));
+          if (out) checks++;
+          found.push(...problems(out, `seed ${seed}, page ${p.label}`));
+        }
+      } });
+      assert.equal(g.div, null, `seed ${seed}: the two pages parted: ${JSON.stringify(g.div && { where: g.div.where, last: g.div.last })}`);
+      assert.ok(checks >= 20, `seed ${seed}: the map was checked (${checks})`);
+      assert.deepEqual(found.slice(0, 5), [], `seed ${seed}`);
+      assert.deepEqual(g.errors, [], `seed ${seed}`);
+    }
+  } finally { fs.rmSync(file, { force: true }); }
+});
+
+test('a 2D map without WebGL2 never asks for it again, and its pictures each keep their own canvas', () => {
+  const h = load({ seed: 777 });
+  // Auto mode, in a browser where WebGL2 is not there.
+  h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();compute();
+    window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});`);
+  h.ev(KIT);
+  h.ev('mapGl(true,false);draw(__T);');
+  const first = JSON.parse(h.ev('JSON.stringify({asked:__M2D.asked.filter(x=>x!=="2d").length,gl:!!GLX.gl,glOn:glOn()})'));
+  assert.equal(first.gl, false);
+  assert.equal(first.glOn, false, 'auto mode draws in 2D');
+  for (let i = 0; i < 20; i++) h.ev(`cam.z=${0.5 + i * 0.15};__T+=16;draw(__T);`);
+  const inv = JSON.parse(h.ev('JSON.stringify(__M2D.inv())'));
+  assert.ok(inv.webgl <= first.asked, `WebGL was asked for again (${inv.webgl} after ${first.asked})`);
+  assert.deepEqual(problems({ ...inv, webgl: 0 }, 'zoom'), []);
+  assert.ok(h.ev('SPRC.size') > 50, 'the pictures are kept');
+  assert.deepEqual(h.errors, []);
+});
+
+test('the 2D map after the card is given up, or switched off, draws as a 2D map that never had one', () => {
+  const { ev, errors } = open();
+  // A card (a recording stand-in) draws a few frames and fills its own pictures.
+  ev(GLSTUB);
+  const views = (tag) => {
+    const out = [];
+    for (let v = 0; v < 8; v++) {
+      const u = [0.2, v / 8, 0.5, 0.5, (v % 5) / 5 + 0.01, v / 8, 0.3, v % 2 ? 0.1 : 0.9, v / 8];
+      out.push(...problems(JSON.parse(ev(`JSON.stringify(__M2D.check(${JSON.stringify(u)}))`)), `${tag}, view ${v}`));
+    }
+    return out;
+  };
+  // Switched off in the settings, with the card's pictures still kept.
+  for (let i = 0; i < 6; i++) ev(`cam.z=${0.5 + i * 0.4};__T+=16;draw(__T);`);
+  assert.ok(ev('SPRS.size') > 20, 'the card painted its pictures');
+  ev('mapGl(false)');
+  // pad and sprs: the card's own, left from its frames; what matters is that the 2D frames never use them.
+  const off = views('switched off').filter((p) => !/card's shared canvas|card state leaked/.test(p) || /ctx0":false|glShown":true|glsFrame":true/.test(p));
+  assert.deepEqual(off.slice(0, 5), []);
+  // Back on, then the card fails: the session's map stays 2D.
+  ev('mapGl(true);__T+=16;draw(__T);glKill(new Error("test"));');
+  assert.equal(ev('SPRS.size'), 0, 'the card’s pictures are forgotten');
+  const dead = views('given up').filter((p) => !/card's shared canvas/.test(p));
+  assert.deepEqual(dead.slice(0, 5), []);
+  assert.deepEqual(errors, []);
+});
+
+test('the 2D map paints its pictures again for a new pixel density', () => {
+  const { ev, errors } = open();
+  ev('__T+=16;draw(__T);');
+  assert.ok(ev('SPRC.size') > 20);
+  ev('DPR=2;__T+=16;draw(__T);');
+  const bad = JSON.parse(ev('JSON.stringify([...SPRC.values()].filter(e=>e.pw!==Math.ceil(e.w*2)||e.ph!==Math.ceil(e.h*2)).length)'));
+  assert.equal(bad, 0, 'every picture is at the new density');
+  const r = JSON.parse(ev('JSON.stringify(__M2D.check([0,0,0.5,0.5,0.5,0.1,0,0.9,0.3]))'));
+  assert.deepEqual(problems(r, 'at 2×'), []);
+  assert.deepEqual(errors, []);
+});
+
+test('money pop-ups on the 2D map fade out as before', () => {
+  const { ev, errors } = open();
+  const C = 'CITY[S.home]';
+  ev(`cam.x=${C}.x;cam.y=${C}.y;cam.z=1;__T+=16;FLOATS.push({x:${C}.x,y:${C}.y,text:'+$1,234',col:'#16A866',t:__T});`);
+  // At 0, 40% and 80% of its life: drawn at opacity 1-a².
+  const alphas = [];
+  for (const a of [0, 0.4, 0.8]) {
+    const log = JSON.parse(ev(`JSON.stringify(__M2D.frame(FLOATS[FLOATS.length-1].t+${a * 1600}))`));
+    const last = log.filter((s) => s.startsWith('drawImage(')).pop();
+    alphas.push(+last.split(' ')[1]);
+  }
+  assert.deepEqual(alphas, [1, 0.84, 0.36]);
+  ev(`__M2D.frame(FLOATS[FLOATS.length-1].t+1700)`);
+  assert.equal(ev('FLOATS.length'), 0, 'gone after its life');
+  // The same text in two colours at once: two pictures, each in its own colour.
+  ev(`FLOATS.push({x:${C}.x,y:${C}.y,text:'+$500',col:'#16A866',t:5000},{x:${C}.x+40,y:${C}.y,text:'+$500',col:'#FF4D5E',t:5000});`);
+  const r = JSON.parse(ev('JSON.stringify(__M2D.pair(5400))'));
+  assert.deepEqual(problems(r, 'two pop-ups'), []);
+  assert.deepEqual(errors, []);
+});
+
+test('every picture starts with the pen the map had when it drew them itself: round line ends and corners, centred text', () => {
+  const { ev, errors } = open();
+  // Drawn straight on the map, main's dashed rings, cones and "zzz" took the state the tubes and labels left there.
+  let n = 0;
+  const pen = (spoil) => JSON.parse(ev(`(()=>{let o;spriteEntry('t-pen|${n++}',10,10,5,5,g=>{o={cap:g.lineCap,join:g.lineJoin,align:g.textAlign,base:g.textBaseline};
+    ${spoil ? "g.lineCap='butt';g.lineJoin='miter';g.textAlign='start';g.textBaseline='alphabetic';" : ''}});return JSON.stringify(o);})()`));
+  const want = { cap: 'round', join: 'round', align: 'center', base: 'middle' };
+  assert.deepEqual(pen(true), want, 'a 2D picture');
+  assert.deepEqual(pen(false), want, 'the next 2D picture');
+  // On the card one canvas is reused for every picture: each starts from that pen again, whatever the last one did.
+  ev(GLSTUB);
+  ev('GLS.frame=true;');
+  try {
+    assert.deepEqual(pen(true), want, 'a picture on the card');
+    assert.deepEqual(pen(false), want, 'the next picture on the card, on the same canvas');
+    assert.ok(ev('!!GLS_PAD.cv&&SPRS.size>=2'), 'the card’s pictures went through its shared canvas');
+  } finally { ev('GLS.frame=false;'); }
+  assert.deepEqual(errors, []);
+});

From 52c8aaffd6e50c3113af213eb99a98ea295aec8b Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 19:08:42 +0100
Subject: [PATCH 10/23] WebGL map: give the card up for 2D when it runs out of
 memory without saying so

A card short of memory may refuse a texture or a buffer without throwing: the call only leaves OUT_OF_MEMORY for
getError(), which nothing read. Refused, the 64 MB atlas drew every city, label and marker as a black box while the
map stayed on the card (seen in Chromium by refusing it).

The big uploads now read it (glMem()): the atlas, the land for each zoom level, the tubes once a day, the cables.
The atlas tries 2048 px (16 MB) before giving up; any other refusal is the card's error, so draw() gives WebGL up
for the session and draws the same frame again in 2D. getError() is never read on an ordinary frame: each read waits
for the card.

tests/webgl-out-of-memory.test.js: a 4096 px atlas refused gives a 2048 px one; both refused, or the land or the
tubes refused, leave the map in 2D in that frame with no glitch for the player; panning reads no error.
---
 src/game/96-map/56-webgl.js            |  6 ++
 src/game/96-map/57-webgl-background.js |  7 ++-
 src/game/96-map/58-webgl-links.js      |  2 +-
 src/game/96-map/59-gl-sprites.js       | 10 ++--
 tests/webgl-out-of-memory.test.js      | 82 ++++++++++++++++++++++++++
 5 files changed, 99 insertions(+), 8 deletions(-)
 create mode 100644 tests/webgl-out-of-memory.test.js

diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js
index 2819c7d..aa4ee57 100644
--- a/src/game/96-map/56-webgl.js
+++ b/src/game/96-map/56-webgl.js
@@ -20,6 +20,12 @@ function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=docume
 // Marks an error as the card's own, so draw() falls back to 2D instead of trying WebGL again every frame.
 function glErr(e){const x=e instanceof Error?e:new Error(String(e));x.glErr=true;return x;}
 function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.dead=true;GLX.gl=null;spritesDrop();glShow(false);}
+/* A card short of memory may refuse a texture or a buffer without throwing: it only leaves OUT_OF_MEMORY for
+   getError(), and the texture then draws black (every picture a black box) or the buffer draws nothing. So the big
+   uploads (the atlas, the land, the tubes, the cables) read it, and give the card up like any of its errors. Never
+   every frame: each read waits for the card. Up to four flags are read, as one call returns only one. */
+function glMem(gl,what){for(let i=0;i<4;i++){const e=gl.getError();if(!e||e===gl.CONTEXT_LOST_WEBGL)return;
+  if(e===gl.OUT_OF_MEMORY)throw glErr(new Error('the graphics card is out of memory ('+what+')'));}}
 const GL_HEAD='#version 300 es\nprecision highp float;precision highp int;\n';
 // Clip space from CSS px (the shaders work in CSS px, as the 2D map does, and use uDpr only for anti-aliasing).
 const GL_CLIP='vec4 clip(vec2 p,vec2 v,float z){return vec4(p.x/v.x*2.-1.,1.-p.y/v.y*2.,z,1.);}\n';
diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js
index ebab529..a528c30 100644
--- a/src/game/96-map/57-webgl-background.js
+++ b/src/game/96-map/57-webgl-background.js
@@ -50,8 +50,9 @@ function glLandGeo(gl,far,lv){const key=(far?'far':'all')+(lv===undefined?'':'@'
     for(let i=0;i+1new Float32Array(a);
-  return GLX.land[key]={fan:glVao(gl,[2],0,F(fan)).v,nFan:fan.length/2,sand:glVao(gl,[4,4,4],1,F(sand)).v,edge:glVao(gl,[4,4,4],1,F(edge)).v,nSeg:sand.length/LINE_STRIDE,
-    hills:glVao(gl,[4],1,F(hills)).v,shine:glVao(gl,[4],1,F(shine)).v,nHill:HILLS.length};}
+  G={fan:glVao(gl,[2],0,F(fan)).v,nFan:fan.length/2,sand:glVao(gl,[4,4,4],1,F(sand)).v,edge:glVao(gl,[4,4,4],1,F(edge)).v,nSeg:sand.length/LINE_STRIDE,
+    hills:glVao(gl,[4],1,F(hills)).v,shine:glVao(gl,[4],1,F(shine)).v,nHill:HILLS.length};
+  glMem(gl,'the land');return GLX.land[key]=G;}
 // Fills the land's shape (shifted by ox, oy CSS px) with one colour, for every copy of the map.
 function glLandFill(gl,G,ks,ox,oy,col){const P=GLX.fan;gl.enable(gl.STENCIL_TEST);
   gl.useProgram(P.p);gl.uniform2f(P.u.uView,CW,CH);gl.uniform2f(P.u.uOff,ox,oy);gl.bindVertexArray(G.fan);
@@ -94,7 +95,7 @@ function glCables(gl,ks,selC,ar){const key=[selC,ar];
     for(const cp of CABLE_PAIRS){const hot=!!selC&&(cp.a===selC||cp.b===selC);if(ar&&!hot&&!(arKind(cp.a)&&arKind(cp.b)))continue;
       const C=CAB[cp.cid],[r,g,b]=glColor(cableCol(C)),col=[r,g,b,hot?.95:.4];let cum=0;
       for(let j=0;j+1.5){float a=clamp((vR-length(vQ))*uDpr+.5,0.,1.)*vC.a;if(a<=0.)discard;o=vec4(vC.rgb*a,a);}
   else o=texture(uTex,vUV)*vC.a;}`;
 function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4,4,1]);GLS.vao=v;GLS.buf=b;
-  // 4096 px square (64 MB), or what the card allows if that is less (some phones).
-  GLS.size=Math.min(4096,gl.getParameter(gl.MAX_TEXTURE_SIZE)||4096);
-  GLS.tex=gl.createTexture();gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);
-  gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,GLS.size,GLS.size,0,gl.RGBA,gl.UNSIGNED_BYTE,null);
+  // 4096 px square (64 MB), or what the card allows if that is less (some phones). A card that has not the memory for
+  // it gets 2048 (16 MB: more resets of the atlas, the same map); without even that, the map stays 2D (glMem).
+  GLS.tex=gl.createTexture();gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);glMem(gl,'setup');
+  for(GLS.size=Math.min(4096,gl.getParameter(gl.MAX_TEXTURE_SIZE)||4096);;GLS.size>>=1){
+    gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,GLS.size,GLS.size,0,gl.RGBA,gl.UNSIGNED_BYTE,null);
+    try{glMem(gl,'the pictures');break;}catch(e){if(GLS.size<=2048)throw e;}}
   for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.LINEAR);
   for(const k of [gl.TEXTURE_WRAP_S,gl.TEXTURE_WRAP_T])gl.texParameteri(gl.TEXTURE_2D,k,gl.CLAMP_TO_EDGE);
   GLS.shx=GLS.shy=GLS.shh=0;}
diff --git a/tests/webgl-out-of-memory.test.js b/tests/webgl-out-of-memory.test.js
new file mode 100644
index 0000000..4d49761
--- /dev/null
+++ b/tests/webgl-out-of-memory.test.js
@@ -0,0 +1,82 @@
+// A graphics card short of memory may refuse a texture or a buffer without throwing: the call only leaves
+// OUT_OF_MEMORY for getError(), and the atlas then drew every picture as a black box while the map stayed on the card.
+// The big uploads now read it (glMem(), src/game/96-map/56-webgl.js): the atlas tries 2048 px before giving up, and
+// any other refusal gives the card up for 2D in the same frame. getError() is never read on an ordinary frame (each
+// read waits for the card).
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { load } = require('./harness');
+
+const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
+
+/* A WebGL2 context that compiles everything, as tests/webgl-map.test.js's, and that refuses memory as asked in
+   window.__FAIL: atlas (the texture sizes refused), land (the first static buffer after setup), tubes (the tubes'
+   points). A refusal sets OUT_OF_MEMORY, read once by getError(); the reads are counted. */
+const GL = `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};window.__GE=0;window.__ERR=0;
+  const F=window.__FAIL;let setup=true;const c=document.getElementById('mapgl');
+  c.getContext=(t)=>t!=='webgl2'?null:new Proxy({},{get(t,k){
+    if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+    if(k==='getExtension')return ()=>({UNMASKED_RENDERER_WEBGL:'REN'});
+    if(k==='getParameter')return (p)=>p==='REN'?'Stub GPU':p==='ACTIVE_UNIFORMS'?0:4096;
+    if(k==='getShaderParameter'||k==='getProgramParameter')return (x,p)=>p==='ACTIVE_UNIFORMS'?0:true;
+    if(k==='getError')return ()=>{__GE++;const e=__ERR;__ERR=0;return e;};
+    if(k==='texImage2D')return (...a)=>{if(a[2]==='RGBA'&&(F.atlas||[]).includes(a[3]))__ERR='OUT_OF_MEMORY';if(a[2]==='RGBA32F'&&F.tubes)__ERR='OUT_OF_MEMORY';};
+    if(k==='bufferData')return (...a)=>{if(a[2]==='STATIC_DRAW'&&F.land&&!setup){F.land=false;__ERR='OUT_OF_MEMORY';}};
+    if(k==='useProgram')return ()=>{setup=false;};
+    return ()=>({});}});})()`;
+
+function open(fail) {
+  const h = load({ seed: 777 });
+  h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();compute();
+    window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});console.warn=()=>{};
+    window.__FAIL=${JSON.stringify(fail)};`);
+  h.ev(GL);
+  return h;
+}
+
+test('a card without memory for a 4096 px atlas gets a 2048 px one, and keeps the map', () => {
+  const { ev, errors } = open({ atlas: [4096] });
+  assert.equal(ev('glInit()'), true);
+  assert.equal(ev('GLS.size'), 2048);
+  assert.equal(ev('GLX.dead'), false);
+  assert.deepEqual(errors, []);
+});
+
+test('a card without memory for either atlas leaves the map in 2D', () => {
+  const { ev, errors } = open({ atlas: [4096, 2048] });
+  assert.equal(ev('glInit()'), false);
+  assert.equal(ev('GLX.dead'), true);
+  ev('__T+=16;draw(__T);');
+  assert.equal(ev('glOn()'), false, 'the map is drawn in 2D');
+  assert.equal(ev('document.getElementById("mapgl").hidden'), true);
+  assert.deepEqual(errors, []);
+});
+
+for (const what of ['land', 'tubes']) {
+  test(`a card that refuses the ${what} without throwing gives the map to 2D in the same frame`, () => {
+    const { ev, errors } = open({ [what]: true });
+    assert.equal(ev('glInit()'), true);
+    ev('UI.tickErr=false;__T+=16;draw(__T);');
+    assert.equal(ev('GLX.dead'), true, 'the card is given up');
+    assert.equal(ev('glOn()'), false);
+    assert.equal(ev('document.getElementById("mapgl").hidden'), true);
+    assert.equal(ev('ctx===CTX0&&!GLS.frame'), true);
+    assert.equal(ev('!!UI.tickErr'), false, 'no glitch for the player: the frame is drawn again in 2D');
+    // The next frames are plain 2D ones.
+    ev('__T+=16;draw(__T);__T+=16;draw(__T);');
+    assert.deepEqual(errors, []);
+  });
+}
+
+test('an ordinary frame never asks the card for its errors', () => {
+  const { ev, errors } = open({});
+  assert.equal(ev('glInit()'), true);
+  ev('__T+=16;draw(__T);');
+  assert.equal(ev('GLX.dead'), false);
+  assert.ok(ev('__GE') > 0, 'the first frame checked its uploads');
+  ev('__GE=0;for(let i=0;i<30;i++){cam.x+=3;__T+=16;draw(__T);}');
+  assert.equal(ev('__GE'), 0, 'panning sends nothing big, so nothing is read');
+  assert.deepEqual(errors, []);
+});

From cdc7c6d1eb8eafeee6df6948ff5fe00ee44a92c1 Mon Sep 17 00:00:00 2001
From: Antoine <20756073+antt0n@users.noreply.github.com>
Date: Wed, 4 Nov 2026 19:21:23 +0100
Subject: [PATCH 11/23] Settings: one Diagnostic info readout for the screen,
 the map's drawing and its speed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Settings › Viewport info is now Diagnostic info, and the frame meter of the WebGL work joins it: one readout in a
corner instead of two, for bug reports. It shows:
- what the screen tells the game, as before (sizes, visual viewport, safe areas, standalone, the tab bar);
- what draws the map: WebGL2 and the graphics card's name, or 2D and why (Always 2D, a puzzle, no WebGL2, a
  processor pretending to be a card, a lost context, a card out of memory: glKill() keeps the reason);
- how fast: frames per second, the 95th percentile and slowest frame, draw()'s mean time, the speed and zoom, and on
  the card its segments and packets.
?vp and ?fps open it, ?novp and ?nofps close it, five taps on the date toggle it, and a device that had the frame
meter on keeps it. Its text stays technical and in English: it is pasted into reports. On a 360 px phone it wraps
inside the screen and never takes a tap. The setting's name and description are translated.

tests/diagnostic-info.test.js: the setting, the readout's parts, each reason for 2D, the frame figures, the address
flags and the old setting, the taps, and the phone layout.
---
 CHANGELOG.md                                |   1 +
 site/i18n/de.js                             |   4 +-
 site/i18n/es.js                             |   4 +-
 site/i18n/fr.js                             |   4 +-
 site/i18n/it.js                             |   4 +-
 site/i18n/pt.js                             |   4 +-
 src/game/90-actions/89-game-and-settings.js |   2 +-
 src/game/96-map/10-canvas.js                |  10 --
 src/game/96-map/30-settings.js              |   2 +-
 src/game/96-map/56-webgl.js                 |   2 +-
 src/game/96-map/97-diagnostics.js           |  36 +++++++
 src/game/96-map/97-fps-meter.js             |  11 --
 src/game/99-loop.js                         |   4 +-
 src/i18n/en.js                              |   4 +-
 tests/diagnostic-info.test.js               | 106 ++++++++++++++++++++
 15 files changed, 160 insertions(+), 38 deletions(-)
 create mode 100644 src/game/96-map/97-diagnostics.js
 delete mode 100644 src/game/96-map/97-fps-meter.js
 create mode 100644 tests/diagnostic-info.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc7bad2..39252dc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ All notable changes to this project are documented here. The project follows
 - Zooming is smoother on big maps: while you zoom, cities and ships keep their picture and are only redrawn sharp once the zoom stops, instead of being repainted at every small step.
 - The graphics card draws the coastlines with fewer points when you zoom out, where the extra detail was smaller than a pixel, so the map costs it a lot less work, which helps phones most.
 - The map leaves far less memory behind it on every frame for the browser to clean up while you play.
+- Settings › Viewport info is now Diagnostic info: besides your screen's size, it shows how the map is drawn (by the graphics card or in 2D, and why) and how fast, ready to copy into a bug report.
 
 ## [2.9.1] — 2026-11-04
 
diff --git a/site/i18n/de.js b/site/i18n/de.js
index 809873c..66b00a6 100644
--- a/site/i18n/de.js
+++ b/site/i18n/de.js
@@ -1610,7 +1610,6 @@
 "common.vendor_tac":"Hersteller-TAC",
 "common.venus":"Venus",
 "common.via_rs":"über RS",
-"common.viewport_info":"Ansichtsinfo",
 "common.vigilante":"Selbstjustiz",
 "common.walk_away":"Aussteigen",
 "common.wave_lease":"Wave-Miete",
@@ -3916,8 +3915,9 @@
 "settings.auto_draws_the_map_with_your":"Auto zeichnet die Karte mit deiner Grafikkarte, wenn der Browser es erlaubt, damit auch große Netze flüssig bleiben. Immer 2D läuft überall, ist auf großen Karten aber langsamer.",
 "settings.auto_follows_your_device_s_reduce":"Auto folgt der Einstellung „Bewegung reduzieren“ deines Geräts. Aus friert die Karte ein: keine wandernden Pakete, kein Pulsieren, kein schwebender Text.",
 "settings.customers_and_alerts":"Kunden und Warnungen",
+"settings.diagnostic_info":"Diagnoseinfos",
 "settings.display_and_sound":"Anzeige und Ton",
-"settings.for_reporting_layout_bugs_shows_what":"Zum Melden von Layout-Fehlern: zeigt, was dein Bildschirm dem Spiel mitteilt.",
+"settings.for_bug_reports_shows_your_screen":"Für Fehlerberichte: zeigt in einer Ecke die Größe deines Bildschirms, wie die Karte gezeichnet wird (Grafikkarte oder 2D, und warum) und wie schnell.",
 "settings.let_an_ai_agent_drive_this_game":"Eine KI soll dieses Spiel spielen",
 "settings.map_drawing":"Kartendarstellung",
 "settings.n_min":"{n} Min.",
diff --git a/site/i18n/es.js b/site/i18n/es.js
index 9744b6b..c82b48f 100644
--- a/site/i18n/es.js
+++ b/site/i18n/es.js
@@ -1608,7 +1608,6 @@
 "common.vendor_tac":"TAC del fabricante",
 "common.venus":"Venus",
 "common.via_rs":"vía RS",
-"common.viewport_info":"Información del viewport",
 "common.vigilante":"Justiciero",
 "common.walk_away":"Marcharse",
 "common.wave_lease":"Alquiler de onda",
@@ -3914,8 +3913,9 @@
 "settings.auto_draws_the_map_with_your":"Auto dibuja el mapa con tu tarjeta gráfica cuando el navegador lo permite, y así las redes grandes siguen fluidas. Siempre 2D funciona en todas partes, pero va más lento en mapas grandes.",
 "settings.auto_follows_your_device_s_reduce":"Auto sigue el ajuste de reducir movimiento de tu dispositivo. Desactivado congela el mapa: sin paquetes en movimiento, pulsos ni texto flotante.",
 "settings.customers_and_alerts":"Clientes y alertas",
+"settings.diagnostic_info":"Información de diagnóstico",
 "settings.display_and_sound":"Pantalla y sonido",
-"settings.for_reporting_layout_bugs_shows_what":"Para informar de fallos de diseño: muestra lo que tu pantalla le dice al juego.",
+"settings.for_bug_reports_shows_your_screen":"Para informar de fallos: muestra en una esquina el tamaño de tu pantalla, cómo se dibuja el mapa (tarjeta gráfica o 2D, y por qué) y a qué velocidad.",
 "settings.let_an_ai_agent_drive_this_game":"Deja que un agente de IA juegue",
 "settings.map_drawing":"Dibujo del mapa",
 "settings.n_min":"{n} min",
diff --git a/site/i18n/fr.js b/site/i18n/fr.js
index 85ebe05..0999427 100644
--- a/site/i18n/fr.js
+++ b/site/i18n/fr.js
@@ -1608,7 +1608,6 @@
 "common.vendor_tac":"TAC du constructeur",
 "common.venus":"Vénus",
 "common.via_rs":"via RS",
-"common.viewport_info":"Infos viewport",
 "common.vigilante":"Justicier",
 "common.walk_away":"Laisser tomber",
 "common.wave_lease":"Location de longueur d’onde",
@@ -3914,8 +3913,9 @@
 "settings.auto_draws_the_map_with_your":"Auto dessine la carte avec ta carte graphique quand le navigateur le permet, ce qui garde les grands réseaux fluides. Toujours en 2D marche partout mais rame sur les grandes cartes.",
 "settings.auto_follows_your_device_s_reduce":"Auto suit le réglage « réduire les animations » de ton appareil. Inactif fige la carte : plus de paquets en mouvement, de pulsations ni de texte flottant.",
 "settings.customers_and_alerts":"Clients et alertes",
+"settings.diagnostic_info":"Infos de diagnostic",
 "settings.display_and_sound":"Affichage et son",
-"settings.for_reporting_layout_bugs_shows_what":"Pour signaler des bugs de mise en page : montre ce que ton écran dit au jeu.",
+"settings.for_bug_reports_shows_your_screen":"Pour signaler un bug : affiche dans un coin la taille de ton écran, comment la carte est dessinée (carte graphique ou 2D, et pourquoi) et à quelle vitesse.",
 "settings.let_an_ai_agent_drive_this_game":"Laisser un agent IA jouer",
 "settings.map_drawing":"Dessin de la carte",
 "settings.n_min":"{n} min",
diff --git a/site/i18n/it.js b/site/i18n/it.js
index 31ade7b..3855c17 100644
--- a/site/i18n/it.js
+++ b/site/i18n/it.js
@@ -1608,7 +1608,6 @@
 "common.vendor_tac":"TAC del vendor",
 "common.venus":"Venere",
 "common.via_rs":"via RS",
-"common.viewport_info":"Info viewport",
 "common.vigilante":"Giustiziere",
 "common.walk_away":"Lascia perdere",
 "common.wave_lease":"Affitto della wave",
@@ -3914,8 +3913,9 @@
 "settings.auto_draws_the_map_with_your":"Auto disegna la mappa con la tua scheda grafica quando il browser lo consente, così anche le reti grandi restano fluide. Sempre 2D funziona ovunque ma è più lento sulle mappe grandi.",
 "settings.auto_follows_your_device_s_reduce":"Auto segue l’impostazione “riduci movimento” del tuo dispositivo. Off congela la mappa: niente pacchetti in movimento, pulsazioni o testo fluttuante.",
 "settings.customers_and_alerts":"Clienti e avvisi",
+"settings.diagnostic_info":"Info di diagnostica",
 "settings.display_and_sound":"Schermo e audio",
-"settings.for_reporting_layout_bugs_shows_what":"Per segnalare bug di layout: mostra cosa lo schermo dice al gioco.",
+"settings.for_bug_reports_shows_your_screen":"Per segnalare bug: mostra in un angolo le dimensioni dello schermo, come viene disegnata la mappa (scheda grafica o 2D, e perché) e a che velocità.",
 "settings.let_an_ai_agent_drive_this_game":"Lascia giocare un agente IA",
 "settings.map_drawing":"Disegno della mappa",
 "settings.n_min":"{n} min",
diff --git a/site/i18n/pt.js b/site/i18n/pt.js
index b46d71c..9939e1c 100644
--- a/site/i18n/pt.js
+++ b/site/i18n/pt.js
@@ -1608,7 +1608,6 @@
 "common.vendor_tac":"TAC do fabricante",
 "common.venus":"Vênus",
 "common.via_rs":"via RS",
-"common.viewport_info":"Info do viewport",
 "common.vigilante":"Justiceiro",
 "common.walk_away":"Desistir",
 "common.wave_lease":"Aluguel da wave",
@@ -3914,8 +3913,9 @@
 "settings.auto_draws_the_map_with_your":"Auto desenha o mapa com sua placa de vídeo quando o navegador permite, o que mantém redes grandes fluidas. Sempre 2D funciona em qualquer lugar, mas é mais lento em mapas grandes.",
 "settings.auto_follows_your_device_s_reduce":"Auto segue a configuração de reduzir movimento do seu aparelho. Desligado congela o mapa: sem pacotes andando, pulsos ou texto flutuante.",
 "settings.customers_and_alerts":"Clientes e alertas",
+"settings.diagnostic_info":"Informações de diagnóstico",
 "settings.display_and_sound":"Tela e som",
-"settings.for_reporting_layout_bugs_shows_what":"Para reportar bugs de layout: mostra o que sua tela informa ao jogo.",
+"settings.for_bug_reports_shows_your_screen":"Para reportar bugs: mostra em um canto o tamanho da sua tela, como o mapa é desenhado (placa de vídeo ou 2D, e por quê) e a que velocidade.",
 "settings.let_an_ai_agent_drive_this_game":"Deixa um agente de IA jogar",
 "settings.map_drawing":"Desenho do mapa",
 "settings.n_min":"{n} min",
diff --git a/src/game/90-actions/89-game-and-settings.js b/src/game/90-actions/89-game-and-settings.js
index fb83f74..a1671dc 100644
--- a/src/game/90-actions/89-game-and-settings.js
+++ b/src/game/90-actions/89-game-and-settings.js
@@ -35,7 +35,7 @@ Object.assign(ACT,{
  settings:()=>{UI.setOpen=true;openModal(settingsHtml());},
  settingsClose:()=>{UI.setOpen=false;if(!S||!UI.started)showTitle();else closeModal();},
  prefSet:({v})=>{const [k,b]=String(v).split(':');if(!own(PREF_DEF,k))return;setPref(k,b==='1');sfx('click');refreshSettings();},
- vpSet:({v})=>{vpOn(v==='on');refreshSettings();},
+ vpSet:({v})=>{diagOn(v==='on');refreshSettings();},
  resetAsk:()=>openModal(`

${tr('game_and_settings.start_a_new_network')}

${tr('game_and_settings.name_and_everything_it_owns_will',{name:esc(S?S.name:tr('common.your_network'))})}

${btn(tr('game_and_settings.delete_and_start_over'),'newgame',{},'red big')}${btn(tr('common.keep_playing'),'closeModal',{},'ghost big')}
`), whatsNewShow:()=>whatsNew(true,true), updateNow:()=>{save(true);location.reload();}, diff --git a/src/game/96-map/10-canvas.js b/src/game/96-map/10-canvas.js index e3021cc..ff76dfb 100644 --- a/src/game/96-map/10-canvas.js +++ b/src/game/96-map/10-canvas.js @@ -14,15 +14,5 @@ function fixStandaloneHeight(){const R0=document.documentElement; R0.classList.toggle('iosfix',on);if(on)R0.style.setProperty('--app-h',sh+'px');else R0.style.removeProperty('--app-h');return on?sh:0;} function resize(){const ah=fixStandaloneHeight();DPR=Math.min(2,window.devicePixelRatio||1);CW=innerWidth;CH=ah||innerHeight;cv.width=CW*DPR;cv.height=CH*DPR;} addEventListener('resize',()=>{resize();WL.key=null;renderLeft();fitHud();});resize(); -// Viewport readout for debugging phone layouts: open the game once with ?vp in the address (or the start URL). -function vpDebug(){let el=document.getElementById('vpdbg');if(!el){el=document.createElement('pre');el.id='vpdbg';el.style.cssText='position:fixed;left:8px;bottom:calc(var(--tabbar,0px) + 8px);z-index:99;margin:0;padding:6px 8px;background:rgba(30,38,64,.85);color:#7CFFB2;font:11px/1.35 ui-monospace,monospace;border-radius:8px;pointer-events:none';document.body.appendChild(el); - const pr=document.createElement('div');pr.id='vpprobe';pr.style.cssText='position:fixed;visibility:hidden;padding:env(safe-area-inset-top,0px) 0 env(safe-area-inset-bottom,0px)';document.body.appendChild(pr);} - const pr=document.getElementById('vpprobe'),cs=getComputedStyle(pr),vv=window.visualViewport,de=document.documentElement,tb=document.getElementById('tabbar').getBoundingClientRect(); - el.textContent=`inner ${innerWidth}×${innerHeight} · screen ${screen.width}×${screen.height}\nvv ${vv?Math.round(vv.width)+'×'+Math.round(vv.height)+' top '+Math.round(vv.offsetTop):'-'} · client ${de.clientHeight}\nsafe top ${cs.paddingTop} bottom ${cs.paddingBottom}\nstandalone ${navigator.standalone===true||!!(window.matchMedia&&matchMedia('(display-mode: standalone)').matches)} · iosfix ${de.classList.contains('iosfix')} · CH ${CH}\nbody ${Math.round(document.body.getBoundingClientRect().height)} · tabbar ${Math.round(tb.top)}–${Math.round(tb.bottom)}`;} -let VP_T=null;const vpOn=on=>{clearInterval(VP_T);VP_T=null;const el=document.getElementById('vpdbg');if(el)el.remove();if(on){VP_T=setInterval(vpDebug,500);vpDebug();}try{on?localStorage.setItem('sot-vp','1'):localStorage.removeItem('sot-vp');}catch(e){}}; -if(/[?&]vp\b/.test(location.search))vpOn(true);else if(/[?&]novp\b/.test(location.search))vpOn(false); -try{if(localStorage.getItem('sot-vp')==='1')vpOn(true);}catch(e){} -// Inside an installed app there is no address bar: five quick taps on the date toggle the readout. -{let taps=[];document.getElementById('hDate').closest('.chip,div').addEventListener('click',()=>{const t=performance.now();taps=taps.filter(x=>t-x<1500).concat(t);if(taps.length>=5){taps=[];vpOn(!VP_T);}});} // iOS settles the standalone viewport a moment after launch and after rotating. for(const t of [300,1000])setTimeout(()=>{resize();WL.key=null;},t);addEventListener('pageshow',()=>{resize();WL.key=null;}); diff --git a/src/game/96-map/30-settings.js b/src/game/96-map/30-settings.js index 348036a..f3025be 100644 --- a/src/game/96-map/30-settings.js +++ b/src/game/96-map/30-settings.js @@ -33,7 +33,7 @@ function settingsHtml(){const seg=(lab,act,cur,opts,note)=>`
${langPick('langSel')}
- ${seg(tr('common.viewport_info'),'vpSet',VP_T?'on':'off',[['on',tr('common.on')],['off',tr('common.off')]],tr('settings.for_reporting_layout_bugs_shows_what'))} + ${seg(tr('settings.diagnostic_info'),'vpSet',DIAG.on?'on':'off',[['on',tr('common.on')],['off',tr('common.off')]],tr('settings.for_bug_reports_shows_your_screen'))} ${installRow()}
${btn(tr('common.done_8dd3'),'settingsClose',{},'pink')}
`;} const refreshSettings=()=>{if(UI.setOpen)openModal(settingsHtml());}; function animOn(){const m=UI.anim||'auto';if(m==='on')return true;if(m==='off')return false;try{return !matchMedia('(prefers-reduced-motion: reduce)').matches;}catch(e){return true;}} diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js index aa4ee57..3423544 100644 --- a/src/game/96-map/56-webgl.js +++ b/src/game/96-map/56-webgl.js @@ -19,7 +19,7 @@ function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeIte function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=document.getElementById('mapgl'),fx=document.getElementById('mapfx');if(e)e.hidden=!on;if(fx)fx.hidden=!on;} // Marks an error as the card's own, so draw() falls back to 2D instead of trying WebGL again every frame. function glErr(e){const x=e instanceof Error?e:new Error(String(e));x.glErr=true;return x;} -function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.dead=true;GLX.gl=null;spritesDrop();glShow(false);} +function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.why=String(why&&why.message||why);GLX.dead=true;GLX.gl=null;spritesDrop();glShow(false);} /* A card short of memory may refuse a texture or a buffer without throwing: it only leaves OUT_OF_MEMORY for getError(), and the texture then draws black (every picture a black box) or the buffer draws nothing. So the big uploads (the atlas, the land, the tubes, the cables) read it, and give the card up like any of its errors. Never diff --git a/src/game/96-map/97-diagnostics.js b/src/game/96-map/97-diagnostics.js new file mode 100644 index 0000000..b5a427e --- /dev/null +++ b/src/game/96-map/97-diagnostics.js @@ -0,0 +1,36 @@ +/* Settings › Diagnostic info: one readout in a corner, for bug reports. What the screen tells the game (for phone + layouts), how the map is drawn (the graphics card or 2D, and why), and how fast: frames per second, the slowest + frames, the time draw() takes. It is also opened with ?vp or ?fps in the address (?novp, ?nofps close it), and, + inside an installed app where there is no address bar, with five quick taps on the date. Its words are technical on + purpose and stay in English: they are pasted into bug reports. */ +const DIAG={on:false,el:null,t:null,fr:[],dr:[],last:0,dms:-1}; +// One frame of the loop (99-loop.js): its interval, and the time draw() took if the map was drawn. +function diagFrame(now){const D=DIAG;if(D.last)D.fr.push(now-D.last);D.last=now;if(D.dms>=0){D.dr.push(D.dms);D.dms=-1;} + if(D.fr.length>600)D.fr.splice(0,300);if(D.dr.length>600)D.dr.splice(0,300);} +// What draws the map, and why it is the 2D canvas when it is. +function diagMap(){if(!S)return 'map: none (title screen)';if(pzOn())return 'map: 2D (puzzle)';if(!GLX.want)return 'map: 2D (Always 2D)'; + if(GLX.dead)return 'map: 2D ('+(GLX.why||'no WebGL2')+')';return GLX.gl&&GLX.shown?'map: WebGL2 · '+(GLX.gpu||'unknown GPU'):'map: WebGL2 (starting)';} +// Frames since the last readout: per second, the 95th percentile and the slowest, and draw()'s mean. +function diagPerf(){const f=DIAG.fr.splice(0),d=DIAG.dr.splice(0),s=f.slice().sort((a,b)=>a-b),sum=f.reduce((a,x)=>a+x,0), + q=x=>s.length?s[Math.min(s.length-1,Math.floor(s.length*x))].toFixed(0):'-',gl=GLX.shown&&!GLX.dead; + return `${sum?(f.length*1000/sum).toFixed(0):'-'} fps · p95 ${q(.95)} ms · max ${q(1)} ms\ndraw ${d.length?(d.reduce((a,x)=>a+x,0)/d.length).toFixed(1):'-'} ms · x${UI.speed||0} · zoom ${cam.z.toFixed(2)}`+ + (gl?` · ${GLX.nSeg} segments · ${GLX.nPk} packets`:'');} +function diagShow(){const D=DIAG;let el=D.el; + if(!el){el=D.el=document.createElement('pre');el.id='diag';el.style.cssText='position:fixed;left:8px;bottom:calc(var(--tabbar,0px) + 8px);z-index:99;margin:0;padding:6px 8px;max-width:calc(100vw - 32px);background:rgba(30,38,64,.85);color:#7CFFB2;font:11px/1.35 ui-monospace,monospace;border-radius:8px;pointer-events:none;white-space:pre-wrap;overflow-wrap:anywhere'; + // A hidden probe reads the safe areas (the notch, the home bar) as CSS gives them. + const pr=document.createElement('div');pr.id='diagprobe';pr.style.cssText='position:fixed;visibility:hidden;padding:env(safe-area-inset-top,0px) 0 env(safe-area-inset-bottom,0px)';el.appendChild(pr); + D.txt=document.createTextNode('');el.appendChild(D.txt);document.body.appendChild(el);} + const cs=getComputedStyle(document.getElementById('diagprobe')),vv=window.visualViewport,de=document.documentElement,tb=document.getElementById('tabbar').getBoundingClientRect(), + sa=navigator.standalone===true||!!(window.matchMedia&&matchMedia('(display-mode: standalone)').matches); + D.txt.data=`Series of Tubes ${APP_VERSION} · ${LANG}\n`+ + `inner ${innerWidth}×${innerHeight} · screen ${screen.width}×${screen.height} · dpr ${window.devicePixelRatio||1}\n`+ + `vv ${vv?Math.round(vv.width)+'×'+Math.round(vv.height)+' top '+Math.round(vv.offsetTop):'-'} · client ${de.clientHeight}\nsafe top ${cs.paddingTop} bottom ${cs.paddingBottom}\n`+ + `standalone ${sa} · iosfix ${de.classList.contains('iosfix')} · CH ${CH}\nbody ${Math.round(document.body.getBoundingClientRect().height)} · tabbar ${Math.round(tb.top)}–${Math.round(tb.bottom)}\n`+ + diagMap()+'\n'+diagPerf();} +// Shows or hides the readout, and remembers it on this device. +function diagOn(on){const D=DIAG;clearInterval(D.t);D.t=null;if(D.el){D.el.remove();D.el=null;}D.on=!!on;D.fr.length=D.dr.length=0;D.last=0;D.dms=-1; + if(on){D.t=setInterval(diagShow,500);diagShow();} + try{on?localStorage.setItem('sot-vp','1'):localStorage.removeItem('sot-vp');localStorage.removeItem('sot-fps');}catch(e){}} +{const q=location.search;let on=false;try{on=localStorage.getItem('sot-vp')==='1'||localStorage.getItem('sot-fps')==='1';}catch(e){} + if(/[?&](vp|fps)\b/.test(q))on=true;else if(/[?&]no(vp|fps)\b/.test(q))on=false;diagOn(on);} +{let taps=[];document.getElementById('hDate').closest('.chip,div').addEventListener('click',()=>{const t=performance.now();taps=taps.filter(x=>t-x<1500).concat(t);if(taps.length>=5){taps=[];diagOn(!DIAG.on);}});} diff --git a/src/game/96-map/97-fps-meter.js b/src/game/96-map/97-fps-meter.js deleted file mode 100644 index 4ad6efd..0000000 --- a/src/game/96-map/97-fps-meter.js +++ /dev/null @@ -1,11 +0,0 @@ -/* A frame meter for measuring the map on a real device: open the game once with ?fps (?nofps hides it again). - Frames per second, the slowest frames, the time draw() takes, and which renderer and graphics card draw the map. */ -const FPSM={on:false,el:null,fr:[],dr:[],last:0,shown:0,dms:-1}; -try{const q=location.search;if(/[?&]fps\b/.test(q))localStorage.setItem('sot-fps','1');else if(/[?&]nofps\b/.test(q))localStorage.removeItem('sot-fps'); - FPSM.on=localStorage.getItem('sot-fps')==='1';}catch(e){} -function fpsNote(now){const M=FPSM;if(M.last)M.fr.push(now-M.last);M.last=now;if(M.dms>=0){M.dr.push(M.dms);M.dms=-1;} - if(now-M.shown<500)return;M.shown=now; - if(!M.el){M.el=document.createElement('pre');M.el.id='fpsm';M.el.style.cssText='position:fixed;right:8px;bottom:calc(var(--tabbar,0px) + 8px);z-index:99;margin:0;padding:6px 8px;background:rgba(30,38,64,.85);color:#7CFFB2;font:11px/1.35 ui-monospace,monospace;border-radius:8px;pointer-events:none;white-space:pre';document.body.appendChild(M.el);} - const f=M.fr.splice(0),d=M.dr.splice(0),s=f.slice().sort((a,b)=>a-b),sum=f.reduce((a,x)=>a+x,0),q=x=>s.length?s[Math.min(s.length-1,Math.floor(s.length*x))].toFixed(0):'-'; - const gl=GLX.shown&&!GLX.dead; - M.el.textContent=`${sum?(f.length*1000/sum).toFixed(0):0} fps · p95 ${q(.95)} ms · max ${q(1)} ms\ndraw ${d.length?(d.reduce((a,x)=>a+x,0)/d.length).toFixed(1):'-'} ms · ${gl?'WebGL':'2D'} · x${UI.speed||0}`+(gl?`\n${GLX.nSeg} segments · ${GLX.nPk} packets\n${GLX.gpu.slice(0,60)}`:'');} diff --git a/src/game/99-loop.js b/src/game/99-loop.js index 83390ba..41f70a8 100644 --- a/src/game/99-loop.js +++ b/src/game/99-loop.js @@ -12,8 +12,8 @@ function frame(now){ if(S&&!S.lost&&$('modal').hidden&&UI.speed&&!pzOn())runClock(dt); if((UI.speed||pzOn())&&!(S&&S.lost))animT+=dt; /* paused = frozen dots, waves and clouds */ const t=animOn()?animT:0; - if(!(UI.mapHid=mapHidden())&&!mapStill(t,now)){const d0=FPSM.on?performance.now():0;try{draw(t);}catch(e){tickErr(e);}UI.drawnAt=now;if(FPSM.on)FPSM.dms=performance.now()-d0;} - if(FPSM.on)fpsNote(now); + if(!(UI.mapHid=mapHidden())&&!mapStill(t,now)){const d0=DIAG.on?performance.now():0;try{draw(t);}catch(e){tickErr(e);}UI.drawnAt=now;if(DIAG.on)DIAG.dms=performance.now()-d0;} + if(DIAG.on)diagFrame(now); } // dt of real time at UI.speed: the days it adds up to. The frame calls it; so may a clock that also runs where frames // do not (src/agent/, a hidden tab), under the frame's own conditions otherwise. diff --git a/src/i18n/en.js b/src/i18n/en.js index b349a32..c4ee816 100644 --- a/src/i18n/en.js +++ b/src/i18n/en.js @@ -1609,7 +1609,6 @@ "common.vendor_tac":"Vendor TAC", "common.venus":"Venus", "common.via_rs":"via RS", -"common.viewport_info":"Viewport info", "common.vigilante":"Vigilante", "common.walk_away":"Walk away", "common.wave_lease":"Wave lease", @@ -3915,8 +3914,9 @@ "settings.auto_draws_the_map_with_your":"Auto draws the map with your graphics card when the browser allows it, which keeps big networks smooth. Always 2D works everywhere but is slower on big maps.", "settings.auto_follows_your_device_s_reduce":"Auto follows your device’s reduce-motion setting. Off freezes the map: no moving packets, pulses or floating text.", "settings.customers_and_alerts":"Customers and alerts", +"settings.diagnostic_info":"Diagnostic info", "settings.display_and_sound":"Display and sound", -"settings.for_reporting_layout_bugs_shows_what":"For reporting layout bugs: shows what your screen tells the game.", +"settings.for_bug_reports_shows_your_screen":"For bug reports: shows in a corner your screen's size, how the map is drawn (graphics card or 2D, and why) and how fast.", "settings.let_an_ai_agent_drive_this_game":"Let an AI agent drive this game", "settings.map_drawing":"Map drawing", "settings.n_min":"{n} min", diff --git a/tests/diagnostic-info.test.js b/tests/diagnostic-info.test.js new file mode 100644 index 0000000..324fcf6 --- /dev/null +++ b/tests/diagnostic-info.test.js @@ -0,0 +1,106 @@ +// Settings › Diagnostic info (src/game/96-map/97-diagnostics.js): one readout for bug reports, which replaced the +// separate viewport readout and frame meter. It shows the screen, what draws the map (and why it is 2D), and how fast; +// the setting, ?vp/?fps and five taps on the date open it, and it is remembered on the device. +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { load } = require('./harness'); + +const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8'); + +function open(opts = {}) { + const h = load({ seed: 777, ...opts }); + h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();compute();console.warn=()=>{};`); + // The readout refreshes on an interval: closing the window stops it, so the test process can end. + h.done = () => h.dom.window.close(); + return h; +} +const text = (ev) => ev('(()=>{const e=document.getElementById("diag");return e?e.textContent:null;})()'); + +test('the setting shows one readout with the screen, the map and its speed, and remembers it', () => { + const h = open(); + const { ev, errors } = h; + try { + assert.equal(text(ev), null, 'off by default'); + ev('ACT.settings()'); + assert.match(ev('$("modal").innerHTML'), new RegExp(ev('tr("settings.diagnostic_info")'))); + ev('ACT.vpSet({v:"on"})'); + const t = text(ev); + for (const part of ['Series of Tubes', 'inner ', 'screen ', 'safe top', 'tabbar', 'map: ', 'fps', 'draw ']) assert.ok(t.includes(part), `shows "${part}"`); + assert.equal(ev('document.querySelectorAll("#diag").length'), 1, 'one readout'); + assert.equal(ev('localStorage.getItem("sot-vp")'), '1'); + ev('ACT.vpSet({v:"off"})'); + assert.equal(text(ev), null); + assert.equal(ev('localStorage.getItem("sot-vp")'), null); + assert.deepEqual(errors, []); + } finally { h.done(); } +}); + +test('it says what draws the map, and why it is the 2D canvas', () => { + const h = open(); + const { ev, errors } = h; + try { + ev('diagOn(true)'); + const map = () => ev('diagMap()'); + ev('mapGl(false,false)'); + assert.equal(map(), 'map: 2D (Always 2D)'); + ev('mapGl(true,false);glKill(new Error("the graphics card is out of memory (the pictures)"))'); + assert.equal(map(), 'map: 2D (the graphics card is out of memory (the pictures))'); + ev('GLX.dead=false;GLX.gl={};GLX.shown=true;GLX.gpu="ANGLE (NVIDIA GeForce GTX 980)"'); + assert.equal(map(), 'map: WebGL2 · ANGLE (NVIDIA GeForce GTX 980)'); + ev('const s=S;S=null;window.__S=s'); + assert.equal(map(), 'map: none (title screen)'); + ev('S=__S;GLX.gl=null;GLX.shown=false'); + assert.deepEqual(errors, []); + } finally { h.done(); } +}); + +test('it measures frames per second, the slowest frames and draw()', () => { + const h = open(); + const { ev, errors } = h; + try { + ev('diagOn(true)'); + // 60 frames, so 59 intervals: 58 of 16 ms and a last one of 50 ms (978 ms in all), each map drawn in 2 ms. + ev('let t=1000;for(let i=0;i<60;i++){t+=i===59?50:16;DIAG.dms=2;diagFrame(t);}diagShow();'); + const t = text(ev); + assert.match(t, /\b60 fps · p95 16 ms · max 50 ms/); + assert.match(t, /draw 2\.0 ms · x0 · zoom /); + assert.deepEqual(errors, []); + } finally { h.done(); } +}); + +test('?fps and ?vp open it, ?nofps closes it, and the old frame meter setting carries over', () => { + for (const [url, storage, want] of [['?fps', {}, true], ['?vp', {}, true], ['?nofps', { 'sot-vp': '1' }, false], ['', { 'sot-fps': '1' }, true], ['', {}, false]]) { + const h = load({ seed: 777, url: 'https://tests.invalid/' + url, storage }); + try { + assert.equal(h.ev('!!document.getElementById("diag")'), want, `${url || 'no flag'} ${JSON.stringify(storage)}`); + assert.equal(h.ev('localStorage.getItem("sot-fps")'), null, 'the old key is gone'); + } finally { h.dom.window.close(); } + } +}); + +test('five quick taps on the date toggle it (an installed app has no address bar)', () => { + const h = open(); + const { ev, errors } = h; + try { + const tap = () => ev('document.getElementById("hDate").click()'); + for (let i = 0; i < 5; i++) tap(); + assert.equal(ev('DIAG.on'), true); + for (let i = 0; i < 5; i++) tap(); + assert.equal(ev('DIAG.on'), false); + assert.deepEqual(errors, []); + } finally { h.done(); } +}); + +test('on a 360 px phone the readout wraps inside the screen instead of running off it', () => { + const h = open(); + const { ev } = h; + try { + ev('diagOn(true)'); + const st = ev('document.getElementById("diag").style.cssText'); + assert.match(st, /max-width: calc\(100vw - 32px\)/); + assert.match(st, /white-space: pre-wrap/); + assert.match(st, /pointer-events: none/, 'it never takes a tap meant for the map'); + } finally { h.done(); } +}); From b03bec267ccc13a019aa8902759134733869f4d4 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Wed, 4 Nov 2026 20:59:05 +0100 Subject: [PATCH 12/23] 2D map: keep the land picture on the graphics card in Firefox on a computer The 2D map paints its land into an offscreen picture. In Firefox that picture was a software canvas (willReadFrequently), because Firefox on Android garbled big paths on its graphics card (#43). Firefox on a computer had it too, and a software canvas is sent to the card again on every frame, at a cost that grows with the picture: the whole world at mid zoom, four screens of it zoomed in. Only Firefox on Android keeps it now (softCanvas()). Measured in Firefox 159 on Windows (RTX 4090, full screen 2560x1440), 2D map, frames per second at zoom 0.6 / 1.1 / 1.6 / 3.2: - big-network fixture, main: 56 / 37 / 34 / 26; with this change: 64 / 49 / 51 / 78; - the 183-POP save, main: 32 / 25 / 25 / 22; with this change: 36 / 26 / 33 / 55. (Measured with the change injected into main's page; the land picture is the same code on this branch.) tests/world-layer-firefox.test.js: which browsers get the software canvas, and that the land is an ordinary one elsewhere. --- CHANGELOG.md | 1 + src/game/96-map/70-world-layer.js | 5 ++++- tests/world-layer-firefox.test.js | 36 +++++++++++++++++++++++++++++++ 3 files changed, 41 insertions(+), 1 deletion(-) create mode 100644 tests/world-layer-firefox.test.js diff --git a/CHANGELOG.md b/CHANGELOG.md index 39252dc..32a06d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ All notable changes to this project are documented here. The project follows - Zooming is smoother on big maps: while you zoom, cities and ships keep their picture and are only redrawn sharp once the zoom stops, instead of being repainted at every small step. - The graphics card draws the coastlines with fewer points when you zoom out, where the extra detail was smaller than a pixel, so the map costs it a lot less work, which helps phones most. - The map leaves far less memory behind it on every frame for the browser to clean up while you play. +- In Firefox on a computer, the 2D map is up to three times as fast when zoomed in: its land picture now stays on the graphics card instead of being sent to it again on every frame. Firefox on Android keeps the old way, which avoids its drawing glitches. - Settings › Viewport info is now Diagnostic info: besides your screen's size, it shows how the map is drawn (by the graphics card or in 2D, and why) and how fast, ready to copy into a bug report. ## [2.9.1] — 2026-11-04 diff --git a/src/game/96-map/70-world-layer.js b/src/game/96-map/70-world-layer.js index 426de70..20a94a8 100644 --- a/src/game/96-map/70-world-layer.js +++ b/src/game/96-map/70-world-layer.js @@ -2,7 +2,10 @@ GPU canvas implementations (Firefox on Android) garble big paths (#43). It is painted into an offscreen image instead: the whole world when that fits in MAXPX, otherwise the visible area plus a margin, repainted when you pan out of it. While a zoom gesture is still moving, the last image is scaled rather than repainted. */ -const SOFT_CANVAS=/Firefox\//.test(navigator.userAgent); +/* Only Firefox on Android gets that image as a software canvas (willReadFrequently). Firefox on a computer drew it + fine on the graphics card, and a software canvas there is sent to the card again on every frame, a cost that grows + with the image: zoomed in, the 2D map ran at half its speed. */ +const softCanvas=ua=>/Android.*Firefox\//.test(ua),SOFT_CANVAS=softCanvas(navigator.userAgent); function wlCovers(z){if(WL.full)return true;const hw=CW/2/z,hh=CH/2/z,w=WL.cv.width/WL.sc,h=WL.cv.height/WL.sc; return cam.x-hw>=WL.ox&&cam.x+hw<=WL.ox+w&&cam.y-hh>=WL.oy&&cam.y+hh<=WL.oy+h;} function worldLayer(z){ diff --git a/tests/world-layer-firefox.test.js b/tests/world-layer-firefox.test.js new file mode 100644 index 0000000..b77ad42 --- /dev/null +++ b/tests/world-layer-firefox.test.js @@ -0,0 +1,36 @@ +// The 2D map's land picture (src/game/96-map/70-world-layer.js) is a software canvas (willReadFrequently) only in +// Firefox on Android, which garbled big paths on its graphics card (#43). Firefox on a computer had it too, and sent +// the whole picture to the card again on every frame: measured in Firefox on Windows, full screen 2560x1440, zoomed in +// the 2D map ran at a third of its speed (zoom 3.2 on the big network: 26 fps, 78 without it). +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { load } = require('./harness'); + +const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8'); + +test('only Firefox on Android gets the land as a software canvas', () => { + const { ev } = load({ seed: 777 }); + const soft = (ua) => ev(`softCanvas(${JSON.stringify(ua)})`); + // Firefox on Android, phone and tablet. + assert.equal(soft('Mozilla/5.0 (Android 14; Mobile; rv:132.0) Gecko/132.0 Firefox/132.0'), true); + assert.equal(soft('Mozilla/5.0 (Android 13; Tablet; rv:128.0) Gecko/128.0 Firefox/128.0'), true); + // Firefox on a computer, and the other browsers. + assert.equal(soft('Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:159.0) Gecko/20100101 Firefox/159.0'), false); + assert.equal(soft('Mozilla/5.0 (X11; Linux x86_64; rv:153.0) Gecko/20100101 Firefox/153.0'), false); + assert.equal(soft('Mozilla/5.0 (Macintosh; Intel Mac OS X 14.5; rv:131.0) Gecko/20100101 Firefox/131.0'), false); + assert.equal(soft('Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Mobile Safari/537.36'), false); + assert.equal(soft('Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/130.0 Mobile/15E148 Safari/605.1.15'), false); +}); + +test('elsewhere the land picture is an ordinary canvas, which the browser may keep on the graphics card', () => { + const { ev, errors } = load({ seed: 777 }); + ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();compute();mapGl(false,false); + window.__opts=[];const gc=HTMLCanvasElement.prototype.getContext;HTMLCanvasElement.prototype.getContext=function(t,o){__opts.push(o||null);return gc.call(this,t,o);}; + WL.cv=null;WL.key=null;cam.z=1.6;worldLayer(cam.z);`); + assert.equal(ev('SOFT_CANVAS'), false); + assert.ok(ev('!!WL.cv'), 'the land was painted'); + assert.equal(ev('__opts.some(o=>o&&o.willReadFrequently)'), false); + assert.deepEqual(errors, []); +}); From fe109cff844fb26888807a64235b66ed5482573e Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Wed, 4 Nov 2026 23:04:48 +0100 Subject: [PATCH 13/23] WebGL map: fill overlapping coastlines as land, as the 2D map does The card filled the land by an odd/even count over all the coastlines at once, so two coasts that overlap cancelled out into sea: Timor, drawn by two coastlines, lost most of its inside and its shadow when zoomed in. The 2D map fills each coast on its own. The fan now turns every coast the same way and the stencil counts windings (+1 and -1 by the triangles' facing, filled where not zero), which is the 2D canvas's nonzero rule: an overlap counts 2 and stays land. Same number of draws. --- src/game/96-map/57-webgl-background.js | 16 +++++++--- tests/webgl-coast.test.js | 44 ++++++++++++++++++++++++++ 2 files changed, 56 insertions(+), 4 deletions(-) diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js index a528c30..544b8ed 100644 --- a/src/game/96-map/57-webgl-background.js +++ b/src/game/96-map/57-webgl-background.js @@ -41,11 +41,16 @@ function coastSimplify(P,tol){const n=P.length;if(n<4||!(tol>0))return P;const k // around a power of 2 does not switch back and forth. function coastLevel(z){const want=Math.floor(Math.log2(Math.max(z,1/64))),cur=GLX.coastLv; if(cur===undefined||want>cur||z{if(keep&&!keep.has(LANDP_ALL[ri]))return;if(ring.length<3)return; const P=coastSimplify(coastPts(ri),tol);if(P.length<4)return; - for(let i=1;i+1{let w=0;const s=(ax,ay,bx,by)=>(bx-ax)*(y-ay)-(by-ay)*(x-ax); + for(let i=0;i0&&d2>0&&d3>0)w++;else if(d1<0&&d2<0&&d3<0)w--;}return w;};`; + +test('two overlapping coastlines leave their overlap filled (Timor), at every zoom', () => { + const { ev, errors } = open(); + ev(WIND); + const r = JSON.parse(ev(`(()=>{const pt=[1692,600],o={both:[58,154].map(i=>inPoly(...pt,coastPts(i)))}; + for(const lv of [undefined,-1,0,1,2,3,4,5]){const tol=lv===undefined?0:COAST_TOL/Math.pow(2,lv),fan=[]; + COAST.forEach((ring,ri)=>{if(ring.length<3)return;const P=coastSimplify(coastPts(ri),tol);if(P.length>=4)coastFan(P,fan);}); + o['lv'+lv]=__wind(fan,...pt);} + return JSON.stringify(o);})()`)); + assert.deepEqual(r.both, [true, true], 'the point is inside both of Timor’s coastlines'); + for (const lv of [undefined, -1, 0, 1, 2, 3, 4, 5]) assert.equal(r['lv' + lv], 2, `level ${lv}: counted twice, so land (an odd/even count gave 0, sea)`); + assert.deepEqual(errors, []); +}); + +test('every coastline counts +1 inside, whichever way it was drawn', () => { + const { ev, errors } = open(); + ev(WIND); + const r = JSON.parse(ev(`(()=>{const sq=(x,y,s,cw)=>{const p=[[x,y],[x+s,y],[x+s,y+s],[x,y+s]];return cw?p.reverse():p;}; + const fan=[];coastFan(sq(0,0,10,false),fan);coastFan(sq(5,5,10,true),fan); + return JSON.stringify({a:__wind(fan,2,1),both:__wind(fan,8,6),b:__wind(fan,12,13),out:__wind(fan,20,20)});})()`)); + assert.deepEqual(r, { a: 1, both: 2, b: 1, out: 0 }, 'one square turned each way: the overlap is 2, not 0'); + assert.deepEqual(errors, []); +}); + +test('the card fills the land where the winding count is not zero, and leaves the stencil at zero', () => { + const { ev, errors } = open(); + ev(STUB); + const c = JSON.parse(ev(`(()=>{const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;GLX.gl.calls.length=0;draw(1000); + return JSON.stringify(GLX.gl.calls.filter(c=>/^stencil/.test(c[0])).map(c=>c.join(' ')));})()`)); + assert.ok(c.includes('stencilOpSeparate FRONT KEEP KEEP INCR_WRAP') && c.includes('stencilOpSeparate BACK KEEP KEEP DECR_WRAP'), 'counts windings, +1 one way and -1 the other'); + assert.ok(c.includes('stencilFunc NOTEQUAL 0 255'), 'fills where the count is not zero, on all 8 bits'); + assert.ok(c.includes('stencilOp ZERO ZERO ZERO'), 'and sets it back to zero'); + assert.ok(!c.some(s => /INVERT/.test(s)), 'no odd/even count left'); + assert.deepEqual(errors, []); +}); From 123b3d00eabc66d8b0e1137e83362f3a93b650c2 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Wed, 4 Nov 2026 23:06:11 +0100 Subject: [PATCH 14/23] WebGL map: give the card up for 2D when it refuses a picture without saying so The atlas, the land, the tubes and the cables read getError() after they are sent, but a picture sent into the atlas (texSubImage2D) was marked as sent at once: a card short of memory that only set OUT_OF_MEMORY left it kept and drawn from an atlas that never got it. A frame that sent new pictures now asks once, at its end and before drawing them; a refusal gives the map to 2D in the same frame and forgets the card's pictures. A frame that only reuses the atlas still asks nothing. --- src/game/96-map/59-gl-sprites.js | 13 ++++++---- tests/webgl-out-of-memory.test.js | 40 ++++++++++++++++++++++++++----- 2 files changed, 42 insertions(+), 11 deletions(-) diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js index c6f3bb8..615c48e 100644 --- a/src/game/96-map/59-gl-sprites.js +++ b/src/game/96-map/59-gl-sprites.js @@ -5,7 +5,7 @@ const SPR_MAX=1400,SPR_STRIDE=13; // The card's pictures (SPRS) and the 2D map's (SPRC), by key; both at the screen's pixel density SPR_DPR. const SPRS=new Map(),SPRC=new Map();let SPR_DPR=0; -const GLS={prog:null,vao:null,buf:null,tex:null,size:4096,shx:0,shy:0,shh:0,frame:false,data:new Float32Array(SPR_STRIDE*2048),n:0}; +const GLS={prog:null,vao:null,buf:null,tex:null,size:4096,shx:0,shy:0,shh:0,frame:false,data:new Float32Array(SPR_STRIDE*2048),n:0,up:0}; /* One record is 13 floats: x,y,w,h (CSS px) | u0,v0,u1,v1 (atlas) | r,g,b,a | kind. A picture (kind 0) takes its colours from the atlas and a from the record; a disc (kind 1) is centred on x,y with radius w, in colour r,g,b,a. */ const SPR_VS=GL_HEAD+`layout(location=0) in vec4 aP;layout(location=1) in vec4 aUV;layout(location=2) in vec4 aC;layout(location=3) in float aK; @@ -30,7 +30,7 @@ function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4 // Forgets every picture and starts the atlas again, after the pictures already queued are drawn (they point into it). function spritesReset(){glsDrawNow();SPRS.clear();SPRC.clear();GLS.shx=GLS.shy=GLS.shh=0;} // The card given up: its pictures go (they have no canvas to be drawn from in 2D) and the atlas is forgotten. -function spritesDrop(){GLS.n=0;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} +function spritesDrop(){GLS.n=GLS.up=0;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} /* The card's pictures are painted on one canvas, reused, and each goes into the atlas as soon as it is painted: a canvas kept per picture made the browser hold thousands of them while you zoomed, until it lost the graphics context and the map fell back to 2D. The 2D map, and a picture too big for the atlas, keep their own canvas. */ @@ -70,7 +70,7 @@ function glsPut(gl,e,src){const pw=e.pw,ph=e.ph,A=GLS.size;if(pw>A||ph>A)return gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,true); // Only the picture's corner of the source: the pad is bigger than most pictures. gl.texSubImage2D(gl.TEXTURE_2D,0,x,y,pw,ph,gl.RGBA,gl.UNSIGNED_BYTE,src);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false); - Object.assign(e,{up:true,u0:x/A,v0:y/A,u1:(x+pw)/A,v1:(y+ph)/A});return true;} + GLS.up++;Object.assign(e,{up:true,u0:x/A,v0:y/A,u1:(x+pw)/A,v1:(y+ph)/A});return true;} // The next record in GLS.data, which grows as needed: take it before reading GLS.data, which it may replace. function glsNext(){if((GLS.n+1)*SPR_STRIDE>GLS.data.length){const nd=new Float32Array(GLS.data.length*2);nd.set(GLS.data);GLS.data=nd;}return GLS.n++*SPR_STRIDE;} // Draws a picture at (x,y) of w×h CSS px, on the card for a frame drawn there, else with the 2D canvas. @@ -116,5 +116,8 @@ function glsDraw(gl,n){gl.useProgram(GLS.prog.p);gl.bindVertexArray(GLS.vao);gl. gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex); gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);gl.disable(gl.DEPTH_TEST); gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,n);gl.bindVertexArray(null);} -// The end of a frame on the card: the pictures go up over the tubes. The frame is over even if that draw fails. -function glsFrameEnd(){if(!GLS.frame)return;GLS.frame=false;glsDrawNow();} +/* The end of a frame on the card: the pictures go up over the tubes. The frame is over even if that draw fails. + A frame that sent new pictures first asks the card if it took them (once, however many): a card short of memory + may refuse one without throwing, and the picture would be kept as sent. It then gives the map to 2D (glMem() throws, + draw() draws the frame again there and glKill() forgets the card's pictures). A frame that only reuses the atlas asks nothing. */ +function glsFrameEnd(){if(!GLS.frame)return;GLS.frame=false;const up=GLS.up;GLS.up=0;if(up&&GLX.gl)glMem(GLX.gl,'the pictures');glsDrawNow();} diff --git a/tests/webgl-out-of-memory.test.js b/tests/webgl-out-of-memory.test.js index 4d49761..b43f4e0 100644 --- a/tests/webgl-out-of-memory.test.js +++ b/tests/webgl-out-of-memory.test.js @@ -13,12 +13,16 @@ const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json' /* A WebGL2 context that compiles everything, as tests/webgl-map.test.js's, and that refuses memory as asked in window.__FAIL: atlas (the texture sizes refused), land (the first static buffer after setup), tubes (the tubes' - points). A refusal sets OUT_OF_MEMORY, read once by getError(); the reads are counted. */ -const GL = `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};window.__GE=0;window.__ERR=0; - const F=window.__FAIL;let setup=true;const c=document.getElementById('mapgl'); + points), sprites (every picture sent into the atlas). A refusal sets OUT_OF_MEMORY, read once by getError(); the + reads are counted. It also counts the pictures sent (__SUB), what is deleted (__DEL) and the context let go (__LOST). */ +const GL = `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};window.__GE=0;window.__ERR=0;window.__SUB=0;window.__DEL=[];window.__LOST=0;window.__LOSTEV=0; + const F=window.__FAIL;let setup=true,lost=false;const c=document.getElementById('mapgl');c.addEventListener('webglcontextlost',()=>{__LOSTEV++;}); c.getContext=(t)=>t!=='webgl2'?null:new Proxy({},{get(t,k){ if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k; - if(k==='getExtension')return ()=>({UNMASKED_RENDERER_WEBGL:'REN'}); + if(k==='getExtension')return (n)=>n==='WEBGL_lose_context'?{loseContext:()=>{__LOST++;lost=true;c.dispatchEvent(new window.Event('webglcontextlost'));}}:{UNMASKED_RENDERER_WEBGL:'REN'}; + if(k==='isContextLost')return ()=>lost||!!window.__lostNow; + if(k==='deleteTexture'||k==='deleteBuffer')return (x)=>{__DEL.push(x);}; + if(k==='texSubImage2D')return ()=>{__SUB++;if(F.sprites)__ERR='OUT_OF_MEMORY';}; if(k==='getParameter')return (p)=>p==='REN'?'Stub GPU':p==='ACTIVE_UNIFORMS'?0:4096; if(k==='getShaderParameter'||k==='getProgramParameter')return (x,p)=>p==='ACTIVE_UNIFORMS'?0:true; if(k==='getError')return ()=>{__GE++;const e=__ERR;__ERR=0;return e;}; @@ -76,7 +80,31 @@ test('an ordinary frame never asks the card for its errors', () => { ev('__T+=16;draw(__T);'); assert.equal(ev('GLX.dead'), false); assert.ok(ev('__GE') > 0, 'the first frame checked its uploads'); - ev('__GE=0;for(let i=0;i<30;i++){cam.x+=3;__T+=16;draw(__T);}'); - assert.equal(ev('__GE'), 0, 'panning sends nothing big, so nothing is read'); + // Panning brings new cities into view, whose pictures are sent: only those frames ask, once each. + const pan = JSON.parse(ev(`(()=>{let quiet=0,asked=0,sent=0,most=0;for(let i=0;i<30;i++){const s=__SUB,g=__GE;cam.x+=3;__T+=16;draw(__T); + if(__SUB===s){quiet++;if(__GE>g)asked++;}else{sent++;most=Math.max(most,__GE-g);}}return JSON.stringify({quiet,asked,sent,most});})()`)); + assert.ok(pan.quiet > 0, 'some frames send no picture'); + assert.equal(pan.asked, 0, 'a frame that sends nothing big reads nothing'); + assert.ok(pan.most <= 4, 'a frame that sends pictures asks once (getError() read up to four flags), not once per picture'); + ev('__GE=0;for(let i=0;i<10;i++){__T+=16;draw(__T);}'); + assert.equal(ev('__GE'), 0, 'a still map reads nothing'); + assert.deepEqual(errors, []); +}); + +/* A picture the card refused without throwing (texSubImage2D only leaves OUT_OF_MEMORY) was kept as sent, and drawn + from an atlas that never got it. The frame now checks its new pictures before drawing them, and gives the map to 2D + in that same frame: no picture is kept as sent. */ +test('a picture the card refuses without throwing gives the map to 2D in the same frame', () => { + const { ev, errors } = open({ sprites: true }); + assert.equal(ev('glInit()'), true); + ev('UI.tickErr=false;const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;__T+=16;draw(__T);'); + assert.ok(ev('__SUB') > 0, 'pictures were sent'); + assert.equal(ev('GLX.dead'), true, 'the card is given up'); + assert.equal(ev('SPRS.size'), 0, 'no picture is kept as sent to the card'); + assert.equal(ev('glOn()'), false); + assert.equal(ev('document.getElementById("mapgl").hidden'), true); + assert.ok(ev('SPRC.size') > 0, 'the same frame was drawn again in 2D, with its own pictures'); + assert.equal(ev('!!UI.tickErr'), false, 'no glitch for the player'); + ev('__T+=16;draw(__T);'); assert.deepEqual(errors, []); }); From 10ef838e8718825304c35e34251710ca7579b7a5 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Wed, 4 Nov 2026 23:07:25 +0100 Subject: [PATCH 15/23] WebGL map: free what the card holds when it is given up for good Given up while its context still lived (memory refused, a setup failing half-way), the card kept the atlas (64 MB at 4096 px), the tubes' points and the rest while the 2D map began painting its own pictures. glKill() now deletes the biggest and lets the context go (WEBGL_lose_context, where the browser has it), unless the browser already lost it; glInit() keeps the context from the start so a failed setup is let go too, and the loss event of a context let go on purpose does not give the card up a second time. Always 2D still keeps the card for later. --- src/game/96-map/56-webgl.js | 16 +++++++++---- tests/webgl-out-of-memory.test.js | 38 +++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 4 deletions(-) diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js index 3423544..981aba4 100644 --- a/src/game/96-map/56-webgl.js +++ b/src/game/96-map/56-webgl.js @@ -8,7 +8,7 @@ Puzzles, and any browser without WebGL2 or whose context fails or is lost, keep the 2D map. So does WebGL drawn by the processor (no usable graphics card: a blocked driver, a virtual machine): there every instance of a line costs microseconds, and a big map took a second and a half a frame where the 2D canvas takes 50 ms. */ -const GLX={want:true,dead:false,gl:null,c:null,f:null,fx:null,key:[],nSeg:0,nPk:0,nHalo:0,shown:false,gpu:''}; +const GLX={want:true,dead:false,gl:null,ctx:null,c:null,f:null,fx:null,key:[],nSeg:0,nPk:0,nHalo:0,shown:false,gpu:''}; try{GLX.want=localStorage.getItem('sot-map')!=='2d';}catch(e){} // Renderers that are the processor pretending to be a graphics card (GLX.soft: use them anyway, for the GPU benchmark). const GL_SOFT=/swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/i; @@ -19,7 +19,15 @@ function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeIte function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=document.getElementById('mapgl'),fx=document.getElementById('mapfx');if(e)e.hidden=!on;if(fx)fx.hidden=!on;} // Marks an error as the card's own, so draw() falls back to 2D instead of trying WebGL again every frame. function glErr(e){const x=e instanceof Error?e:new Error(String(e));x.glErr=true;return x;} -function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.why=String(why&&why.message||why);GLX.dead=true;GLX.gl=null;spritesDrop();glShow(false);} +function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.why=String(why&&why.message||why);GLX.dead=true; + const gl=GLX.ctx;GLX.gl=GLX.ctx=null;spritesDrop();glFree(gl);glShow(false);} +/* The card given up for good (not Always 2D, which keeps it for later) still held what was sent to it, the atlas alone + 64 MB, while the 2D map starts painting its own pictures. So its biggest things are deleted and the context let go + (WEBGL_lose_context, where the browser has it), unless the browser already lost it, which freed them. glInit() keeps + the context in GLX.ctx from the start, so a setup that fails half-way is let go too. */ +function glFree(gl){try{if(gl&&gl.isContextLost()===false){for(const x of [GLS.tex,GLX.tex])if(x)gl.deleteTexture(x);if(GLS.buf)gl.deleteBuffer(GLS.buf); + const L=gl.getExtension('WEBGL_lose_context');if(L&&typeof L.loseContext==='function')L.loseContext();}}catch(e){} + GLS.tex=GLS.buf=GLS.vao=GLS.prog=null;GLX.tex=null;GLX.land={};GLS_PAD.cv=GLS_PAD.g=null;} /* A card short of memory may refuse a texture or a buffer without throwing: it only leaves OUT_OF_MEMORY for getError(), and the texture then draws black (every picture a black box) or the buffer draws nothing. So the big uploads (the atlas, the land, the tubes, the cables) read it, and give the card up like any of its errors. Never @@ -42,13 +50,13 @@ function glVao(gl,sizes,div=1,data=null){const v=gl.createVertexArray(),b=gl.cre function glInit(){if(GLX.gl)return true;if(GLX.dead)return false; try{const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');if(!c||!f||!c.getContext)throw new Error('no map layers'); const gl=c.getContext('webgl2',{alpha:true,premultipliedAlpha:true,antialias:false,depth:true,stencil:true,powerPreference:'high-performance'}); - if(!gl||typeof gl.createShader!=='function')throw new Error('no WebGL2'); + if(!gl||typeof gl.createShader!=='function')throw new Error('no WebGL2');GLX.ctx=gl; try{const x=gl.getExtension('WEBGL_debug_renderer_info');GLX.gpu=String(x?gl.getParameter(x.UNMASKED_RENDERER_WEBGL):gl.getParameter(gl.RENDERER));}catch(e){} if(!GLX.soft&&GL_SOFT.test(GLX.gpu))throw new Error('no graphics card, only '+GLX.gpu); const P=(vs,fs)=>glProg(gl,vs,fs),progs={line:P(GL_LINE_VS,GL_LINE_FS),pk:P(GL_PK_VS,GL_PK_FS),fill:P(FILL_VS,FILL_FS),fan:P(FAN_VS,FAN_FS),ell:P(ELL_VS,ELL_FS),circ:P(CIRC_VS,CIRC_FS)}; // The tubes' points for the packets: floats read with texelFetch, never filtered. const tex=gl.createTexture();gl.bindTexture(gl.TEXTURE_2D,tex);for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.NEAREST); - c.addEventListener('webglcontextlost',e=>{e.preventDefault();glKill('the graphics context was lost');UI.drawnAt=0;}); + c.addEventListener('webglcontextlost',e=>{e.preventDefault();if(GLX.dead)return;glKill('the graphics context was lost');UI.drawnAt=0;}); glsInit(gl); // The overlay is cleared only after something was painted on it: clearing a whole screen of empty canvas every // frame makes the browser send the layer to the screen again, which on a 4K screen cost more than the map itself. diff --git a/tests/webgl-out-of-memory.test.js b/tests/webgl-out-of-memory.test.js index b43f4e0..b09577c 100644 --- a/tests/webgl-out-of-memory.test.js +++ b/tests/webgl-out-of-memory.test.js @@ -108,3 +108,41 @@ test('a picture the card refuses without throwing gives the map to 2D in the sam ev('__T+=16;draw(__T);'); assert.deepEqual(errors, []); }); + +/* Given up for good while the context still lives (memory refused), the card kept the atlas (64 MB at 4096 px) and the + rest while the 2D map began painting its own pictures. glKill() now deletes the biggest and lets the context go. */ +test('giving the card up for good frees what it holds and lets the context go, and the frame is drawn in 2D', () => { + const { ev, errors } = open({ tubes: true }); + assert.equal(ev('glInit()'), true); + ev('window.__atlas=GLS.tex;window.__tubes=GLX.tex;window.__buf=GLS.buf;'); + ev('UI.tickErr=false;__T+=16;draw(__T);'); + assert.equal(ev('GLX.dead'), true); + assert.equal(ev('__DEL.includes(__atlas)&&__DEL.includes(__tubes)&&__DEL.includes(__buf)'), true, 'the atlas, the tubes’ points and the pictures’ buffer are deleted'); + assert.equal(ev('__LOST'), 1, 'the context is let go'); + assert.equal(ev('__LOSTEV'), 1, 'its loss event came once'); + assert.equal(ev('GLS.tex===null&&GLS.buf===null&&GLX.tex===null&&GLX.gl===null&&GLX.ctx===null'), true, 'nothing on the card is referenced'); + assert.equal(ev('GLX.why'), 'the graphics card is out of memory (the tubes)', 'the loss it caused does not replace the reason'); + assert.equal(ev('!!UI.tickErr'), false, 'the frame was drawn again in 2D'); + ev('__T+=16;draw(__T);'); + assert.deepEqual(errors, []); +}); + +test('a setup that fails half-way lets its context go too', () => { + const { ev, errors } = open({ atlas: [4096, 2048] }); + assert.equal(ev('glInit()'), false); + assert.equal(ev('__LOST'), 1); + assert.equal(ev('GLX.ctx'), null); + assert.deepEqual(errors, []); +}); + +test('a context the browser lost is not let go a second time', () => { + const { ev, errors } = open({}); + assert.equal(ev('glInit()'), true); + ev('__T+=16;draw(__T);'); + ev('window.__lostNow=true;document.getElementById("mapgl").dispatchEvent(new window.Event("webglcontextlost"));'); + assert.equal(ev('GLX.dead'), true); + assert.equal(ev('GLX.why'), 'the graphics context was lost'); + assert.equal(ev('__LOST'), 0, 'nothing to let go: the browser already did'); + ev('__T+=16;draw(__T);'); + assert.deepEqual(errors, []); +}); From d57b3ae10f4d379dc64033756a126eab95611c10 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Wed, 4 Nov 2026 23:56:58 +0100 Subject: [PATCH 16/23] WebGL map: say how the land's stencil counts, and what the land costs the card --- src/game/96-map/57-webgl-background.js | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js index 544b8ed..5055126 100644 --- a/src/game/96-map/57-webgl-background.js +++ b/src/game/96-map/57-webgl-background.js @@ -4,8 +4,8 @@ const glPm=s=>{const [r,g,b,a]=glColor(s);return [r*a,g*a,b*a,a];}; // premultiplied, as the card blends const SEA_TOP=glPm('#62CBEA'),SEA_BOT=glPm('#43AED6'),CLOUD_COL=glPm('rgba(255,255,255,.55)'); const LAND_SHADOW=glPm('rgba(20,90,130,.35)'),LAND_GRASS=glPm('#9BDA6C'),HILL_COL=glPm('#86CB5B'),HILL_SHINE=glPm('rgba(255,255,255,.18)'); -// The land's fill: a fan of triangles per coastline, counted in the stencil (each pixel flips once per triangle over -// it, so what is inside ends odd), then one cover where the stencil is odd. uOff shifts it in CSS px (the shadow). +// The land's fill: a fan of triangles per coastline, counted in the stencil (how many times the coasts wind round each +// pixel: glLandFill()), then one cover where the count is not zero. uOff shifts it in CSS px (the shadow). const FAN_VS=GL_HEAD+GL_CLIP+`layout(location=0) in vec2 aV;uniform vec2 uView,uOff;uniform vec3 uCam; void main(){gl_Position=clip((aV-uCam.xy)*uCam.z+uView*.5+uOff,uView,0.);}`; const FAN_FS=GL_HEAD+`out vec4 o;void main(){o=vec4(0.);}`; @@ -22,7 +22,9 @@ const CIRC_FS=GL_HEAD+`in vec2 vq;flat in float vr;out vec4 o;void main(){if(len lv (powers of 2): the fan for the fills, the coastlines as line segments (paintWorld()'s curves, four segments each) for the sand and the dark edge, and the hills. Zoomed out a coastline has far more points than pixels, and its vertices were most of the card's work: at level lv it is simplified so that no point moves more than COAST_TOL px at - the level's zoom (Douglas-Peucker). Without lv, the whole coastline. COAST and onLand() are not touched. */ + the level's zoom (Douglas-Peucker). Without lv, the whole coastline. COAST and onLand() are not touched. + Each level stays on the card once built (GLX.land, freed with the card): from 0.4 MB zoomed out to 3 MB at the + closest zoom, about 15 MB if a game visits every zoom, so zooming back never builds one again mid-gesture. */ const COAST_TOL=0.25,COASTP=[]; // A coastline as paintWorld() draws it (smoothPath(): a quadratic curve from the middle of each side to the next, // through the corner between them), four segments per curve; the first point is repeated at the end. From 57546ea18e417caaf4d7b3fea958bc4a3b51f7fa Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:00:34 +0100 Subject: [PATCH 17/23] 2D map: hold its pictures to 48 MB, letting go of those unused the longest MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The 2D map keeps a canvas per picture, and the list was capped only by its length (1 400). A long zoom on a big network paints every city again at each step of its scale, so a pinch from 0.6 to 3.2 and back held 181 MB of pictures (the TTL save: 179 MB) where one frame uses 2 to 23 MB. At the end of a frame over 48 MB, the pictures it did not use go, those unused the longest first, down to 36 MB, and each canvas let go is emptied (0×0) so its pixels are freed without waiting for the collector. The frame's own pictures are never let go, so a screen that needs more keeps what it needs. Finding a picture now marks it as used. Measured in jsdom on the same pinch (1280×800 at 2×): 43 MB at most (TTL: 40 MB); 4 781 pictures painted against 4 083 (TTL: 5 549 against 6 030); at most 321 painted in one frame, the same as before (the zoom's own steps). The card's atlas is unchanged: it has its own fixed size. --- src/game/96-map/59-gl-sprites.js | 23 +++++++--- src/game/96-map/60-draw.js | 4 +- tests/map-2d-sprite-budget.test.js | 68 ++++++++++++++++++++++++++++++ 3 files changed, 88 insertions(+), 7 deletions(-) create mode 100644 tests/map-2d-sprite-budget.test.js diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js index 615c48e..ad1d91e 100644 --- a/src/game/96-map/59-gl-sprites.js +++ b/src/game/96-map/59-gl-sprites.js @@ -5,6 +5,18 @@ const SPR_MAX=1400,SPR_STRIDE=13; // The card's pictures (SPRS) and the 2D map's (SPRC), by key; both at the screen's pixel density SPR_DPR. const SPRS=new Map(),SPRC=new Map();let SPR_DPR=0; +/* The 2D map's pictures each keep a canvas, so they are also held to a size: a long zoom on a big network paints every + city again at each step, and the list (only capped at SPR_MAX) held up to 180 MB of them where a frame shows 2 to + 23 MB. At the end of a frame over SPRC_BUDGET bytes, the pictures it did not use go, those unused the longest first, + down to 3/4 of the budget (so this happens once in a while, not every frame). The frame's own are always kept: a + screen that needs more than the budget keeps what it needs. A canvas let go is emptied (0×0) at once, which frees + its pixels without waiting for the collector. The card's atlas has its own fixed size (GLS.size). + SPR_F counts frames (draw()); finding or drawing a picture marks it as used in this one (e.f). */ +const SPRC_BUDGET=48*1048576;let SPRC_B=0,SPR_F=0; +const sprFree=e=>{if(e.cv){e.cv.width=e.cv.height=0;e.cv=null;}}; +function sprcTrim(){if(SPRC_B<=SPRC_BUDGET)return;const old=[];for(const [k,e] of SPRC)if(e.fa[0]-b[0]);const goal=SPRC_BUDGET*0.75; + for(const [,k,e] of old){if(SPRC_B<=goal)break;SPRC.delete(k);SPRC_B-=e.pw*e.ph*4;sprFree(e);}} const GLS={prog:null,vao:null,buf:null,tex:null,size:4096,shx:0,shy:0,shh:0,frame:false,data:new Float32Array(SPR_STRIDE*2048),n:0,up:0}; /* One record is 13 floats: x,y,w,h (CSS px) | u0,v0,u1,v1 (atlas) | r,g,b,a | kind. A picture (kind 0) takes its colours from the atlas and a from the record; a disc (kind 1) is centred on x,y with radius w, in colour r,g,b,a. */ @@ -28,7 +40,7 @@ function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4 for(const k of [gl.TEXTURE_WRAP_S,gl.TEXTURE_WRAP_T])gl.texParameteri(gl.TEXTURE_2D,k,gl.CLAMP_TO_EDGE); GLS.shx=GLS.shy=GLS.shh=0;} // Forgets every picture and starts the atlas again, after the pictures already queued are drawn (they point into it). -function spritesReset(){glsDrawNow();SPRS.clear();SPRC.clear();GLS.shx=GLS.shy=GLS.shh=0;} +function spritesReset(){glsDrawNow();for(const e of SPRC.values())sprFree(e);SPRS.clear();SPRC.clear();SPRC_B=0;GLS.shx=GLS.shy=GLS.shh=0;} // The card given up: its pictures go (they have no canvas to be drawn from in 2D) and the atlas is forgotten. function spritesDrop(){GLS.n=GLS.up=0;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} /* The card's pictures are painted on one canvas, reused, and each goes into the atlas as soon as it is painted: a @@ -41,20 +53,21 @@ function glsPad(pw,ph){const P=GLS_PAD;if(!P.cv){P.cv=document.createElement('ca // Where this frame's pictures are kept: the card's or the 2D map's. A new pixel density starts both again. function sprMap(){if(DPR!==SPR_DPR){SPR_DPR=DPR;spritesReset();}return GLS.frame&&!!GLX.gl&&!!GLS.prog?SPRS:SPRC;} // The picture already painted under key, if any: callers ask first, so a picture drawn every frame costs no closure. -const spriteHas=key=>sprMap().get(key); +const spriteHas=key=>{const e=sprMap().get(key);if(e)e.f=SPR_F;return e;}; // A picture of w×h CSS px with its anchor at (ax,ay): painted once by paint(g) (the 2D canvas, at the screen's pixel // density), and kept by key in SPRS (the card's) or SPRC (the 2D map's). -function spriteEntry(key,w,h,ax,ay,paint){const M=sprMap(),gpu=M===SPRS;let e=M.get(key);if(e)return e; +function spriteEntry(key,w,h,ax,ay,paint){const M=sprMap(),gpu=M===SPRS;let e=M.get(key);if(e){e.f=SPR_F;return e;} if(SPRS.size+SPRC.size>=SPR_MAX)spritesReset(); const pw=Math.ceil(w*DPR),ph=Math.ceil(h*DPR),saved=ctx; - e={cv:null,pw,ph,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1}; + e={cv:null,pw,ph,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1,f:SPR_F}; if(gpu&&pw<=GLS.size&&ph<=GLS.size){const P=glsPad(pw,ph),g=P.g; g.save();g.setTransform(1,0,0,1,0,0);g.clearRect(0,0,pw,ph);ctx=g; try{g.setTransform(DPR,0,0,DPR,0,0);sprPen(g);paint(g);}finally{ctx=saved;g.restore();} // A full atlas starts again (glsPut), and the picture goes into the empty one at once: the pad is reused next. try{if(!glsPut(GLX.gl,e,P.cv))glsPut(GLX.gl,e,P.cv);}catch(x){throw glErr(x);} }else{const cv=document.createElement('canvas');cv.width=pw;cv.height=ph;const g=cv.getContext('2d');ctx=g; - try{g.setTransform(DPR,0,0,DPR,0,0);sprPen(g);paint(g);}finally{ctx=saved;}e.cv=cv;} + try{g.setTransform(DPR,0,0,DPR,0,0);sprPen(g);paint(g);}finally{ctx=saved;}e.cv=cv; + if(M===SPRC)SPRC_B+=pw*ph*4;} M.set(key,e);return e;} /* A picture starts with the pen the map's own canvas has when it draws cities and markers: the tubes leave it with round line ends and corners, the labels with text centred on its middle. Drawn straight on the map, the dashed rings, diff --git a/src/game/96-map/60-draw.js b/src/game/96-map/60-draw.js index eea050b..6709e30 100644 --- a/src/game/96-map/60-draw.js +++ b/src/game/96-map/60-draw.js @@ -1,8 +1,8 @@ /* A frame. An error from the card itself (glErr()) gives WebGL up for this session and draws the same frame again in 2D, once; any other error goes on to the loop's tickErr(). Either way the 2D context and the sprite queue are reset. */ -function draw(now){for(let pass=0;;pass++){let err=null;DFC=new Map(); +function draw(now){for(let pass=0;;pass++){let err=null;DFC=new Map();SPR_F++; try{drawFrame(now);}catch(e){err=e;} - try{glsFrameEnd();}catch(e){if(!err)err=e;}finally{DFC=null;GLS.frame=false;GLS.n=0;ctx=CTX0;} + try{glsFrameEnd();}catch(e){if(!err)err=e;}finally{DFC=null;GLS.frame=false;GLS.n=0;ctx=CTX0;sprcTrim();} if(!err)return;if(!err.glErr||pass)throw err;glKill(err);}} // Rectangles on a 64 px grid: a new one is compared only with the few that share its cells (a plain list made the // label placement quadratic in the number of cities). diff --git a/tests/map-2d-sprite-budget.test.js b/tests/map-2d-sprite-budget.test.js new file mode 100644 index 0000000..217508f --- /dev/null +++ b/tests/map-2d-sprite-budget.test.js @@ -0,0 +1,68 @@ +// The 2D map keeps a canvas per picture (59-gl-sprites.js). A long zoom on a big network paints every city again at +// each step, and the list, capped only by its length, held up to 180 MB of pictures where a frame shows at most 23 MB. +// It is now held to SPRC_BUDGET bytes: past it, the pictures no frame used since the one before are let go, and those +// in use are always kept. The page's clock is set by hand, so nothing depends on how fast the test runs. +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { load } = require('./harness'); + +const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8'); + +// The big network on a 1280×800 screen at 2× in 2D. Canvases are counted as they are made; their contexts take any call. +function open() { + const h = load({ seed: 777 }); + h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();S.nextFail=S.day+999;S.nextEvent=S.day+999;compute(); + window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});mapGl(false,false); + DPR=2;CW=1280;CH=800;cam.x=CITY.fra.x;cam.y=CITY.fra.y;cam.z=0.6;window.__cv=0; + const ce=document.createElement.bind(document);document.createElement=function(t){const e=ce(t);if(String(t).toLowerCase()==='canvas')__cv++;return e;}; + HTMLCanvasElement.prototype.getContext=function(){return this.__c||(this.__c=new Proxy({},{get(t,k){if(k in t)return t[k]; + if(k==='measureText')return s=>({width:String(s).length*7});if(k==='createLinearGradient')return ()=>({addColorStop(){}});return ()=>{};},set(t,k,v){t[k]=v;return true;}}));}; + window.__bytes=()=>{let b=0;for(const e of SPRC.values())b+=e.pw*e.ph*4;return b;}; + // What the last frame drew: its pictures and their bytes. + window.__used=()=>{let n=0,b=0;for(const e of SPRC.values())if(e.f===SPR_F){n++;b+=e.pw*e.ph*4;}return {n,b};};`); + return h; +} +// A pinch from 0.6 to 3.2 and back in 180 frames of 16 ms: the most bytes held, and the most a frame used. +const PINCH = `(()=>{let held=0,used=0,drift=0;for(let i=0;i<=180;i++){const f=i<=90?i/90:(180-i)/90;cam.z=0.6*Math.pow(3.2/0.6,f);__T+=16;draw(__T); + const b=__bytes();held=Math.max(held,b);used=Math.max(used,__used().b);drift=Math.max(drift,Math.abs(b-SPRC_B));}return JSON.stringify({held,used,drift});})()`; + +test('a long zoom on the 2D map holds its pictures to the budget, plus what one frame needs', () => { + const { ev, errors } = open(); + const r = JSON.parse(ev(PINCH)); + const MB = 1048576, budget = ev('SPRC_BUDGET'); + assert.equal(r.drift, 0, 'the bytes counted are the bytes held'); + assert.ok(r.used > 5 * MB, `a frame uses a real share of it (${(r.used / MB).toFixed(1)} MB)`); + // After a frame, over the budget only if that frame alone needs more. + assert.ok(r.held <= Math.max(budget, r.used), `held ${(r.held / MB).toFixed(1)} MB, budget ${budget / MB} MB`); + assert.ok(r.held < 80 * MB, `far under the 180 MB it held before (${(r.held / MB).toFixed(1)} MB)`); + assert.deepEqual(errors, []); +}); + +test('the pictures a frame uses are never let go, and a still map paints nothing new', () => { + const { ev, errors } = open(); + ev(PINCH); + // Every picture the last frame drew is still kept (it was used, so it cannot have been let go). + ev('window.__keep=[];const b0=blit;blit=function(e,...a){__keep.push(e);return b0(e,...a);};__T+=16;draw(__T);blit=b0;'); + assert.ok(ev('__keep.length') > 50); + assert.equal(ev('__keep.every(e=>[...SPRC.values()].includes(e))'), true, 'every picture of the frame is kept'); + // The same view again and again: everything comes from the kept pictures. + ev('window.__c0=__cv;for(let i=0;i<5;i++){__T+=16;draw(__T);}'); + assert.equal(ev('__cv-__c0'), 0, 'no picture painted again'); + assert.deepEqual(errors, []); +}); + +test('under the budget nothing is let go', () => { + const { ev, errors } = open(); + ev('cam.z=1.1;__T+=16;draw(__T);window.__n=SPRC.size;window.__b=SPRC_B;'); + assert.ok(ev('__b') < ev('SPRC_BUDGET')); + // A small pan: new pictures come in, none goes. + ev('for(let i=0;i<10;i++){cam.x+=4;__T+=16;draw(__T);}'); + assert.ok(ev('SPRC.size') >= ev('__n'), 'the list only grew'); + assert.equal(ev('SPRC_B'), ev('__bytes()')); + // A reset (a new pixel density) forgets the bytes with the pictures. + ev('DPR=1;__T+=16;draw(__T);'); + assert.equal(ev('SPRC_B'), ev('__bytes()')); + assert.deepEqual(errors, []); +}); From 351b3aa5222762f843abd22cb4692169d7c58f2d Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:04:45 +0100 Subject: [PATCH 18/23] WebGL map: take a lost context back, and let it go for Always 2D The first loss of the WebGL context gave the card up for the session. A context can come back (a driver reset; on a phone, sometimes just leaving the app), so a phone that went to another app came back to the slower 2D map until the page was reloaded. Always 2D, chosen in Settings, kept the context and its 64 MB atlas for a map drawn in 2D. A loss now leaves the 2D map drawing while the context is away (glLost(): the event is cancelled so the browser may give it back), and everything on the card is built again on the same context when it comes back (glRestored(), glForget(): glInit() runs as for the first frame). A card lost more than GL_LOSSES (2) times is given up for the session, so a card that keeps failing does not keep the map switching. Always 2D lets the context go through WEBGL_lose_context and Auto asks for it back, the same path, never counted as a loss; a context the browser gives back after the player chose Always 2D is let go again. Without the extension, and for the GPU benchmark's switches (mapGl(on,false)), the context is kept as before. The listeners and the overlay's wrappers are set once. Diagnostic info says when the map waits for a lost context. Tests: webgl-context-restore (7), and the loss test of webgl-out-of-memory now waits for the context instead of giving it up. --- src/game/96-map/56-webgl.js | 31 ++++-- src/game/96-map/97-diagnostics.js | 2 +- tests/diagnostic-info.test.js | 4 +- tests/webgl-context-restore.test.js | 145 ++++++++++++++++++++++++++++ tests/webgl-out-of-memory.test.js | 7 +- 5 files changed, 177 insertions(+), 12 deletions(-) create mode 100644 tests/webgl-context-restore.test.js diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js index 981aba4..26fae66 100644 --- a/src/game/96-map/56-webgl.js +++ b/src/game/96-map/56-webgl.js @@ -5,29 +5,46 @@ Two canvases sit over #map, which stays empty: #mapgl, where the card draws the background (57), the tubes and packets (58) and the pictures of cities, labels and markers (59); and #mapfx, a transparent 2D canvas over it for the few things still painted shape by shape (the drag preview, the chaos monkey), cleared only after it was used. - Puzzles, and any browser without WebGL2 or whose context fails or is lost, keep the 2D map. So does WebGL drawn by + Puzzles, and any browser without WebGL2 or whose context fails, keep the 2D map; a lost context, until it is back. So does WebGL drawn by the processor (no usable graphics card: a blocked driver, a virtual machine): there every instance of a line costs microseconds, and a big map took a second and a half a frame where the 2D canvas takes 50 ms. */ -const GLX={want:true,dead:false,gl:null,ctx:null,c:null,f:null,fx:null,key:[],nSeg:0,nPk:0,nHalo:0,shown:false,gpu:''}; +const GLX={want:true,dead:false,lost:false,sleep:false,losses:0,lose:null,gl:null,ctx:null,c:null,f:null,fx:null,key:[],nSeg:0,nPk:0,nHalo:0,shown:false,gpu:''}; try{GLX.want=localStorage.getItem('sot-map')!=='2d';}catch(e){} // Renderers that are the processor pretending to be a graphics card (GLX.soft: use them anyway, for the GPU benchmark). const GL_SOFT=/swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/i; const glOn=()=>GLX.want&&!GLX.dead&&!!S&&!pzOn()&&glInit(); // Switches the WebGL map on or off: the setting keeps the choice in this browser (keep), the GPU benchmark does not. +// Chosen in Settings, Always 2D also lets the card's context go (glSleep()), and Auto takes it back. function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeItem('sot-map'):localStorage.setItem('sot-map','2d');}catch(e){} - if(!on)glShow(false);GLX.key=[];UI.drawnAt=0;return on&&!GLX.dead;} + if(!on){glShow(false);if(keep)glSleep();}else if(GLX.sleep){GLX.sleep=false;try{GLX.lose.restoreContext();}catch(e){}} + GLX.key=[];UI.drawnAt=0;return on&&!GLX.dead;} function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=document.getElementById('mapgl'),fx=document.getElementById('mapfx');if(e)e.hidden=!on;if(fx)fx.hidden=!on;} // Marks an error as the card's own, so draw() falls back to 2D instead of trying WebGL again every frame. function glErr(e){const x=e instanceof Error?e:new Error(String(e));x.glErr=true;return x;} function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.why=String(why&&why.message||why);GLX.dead=true; const gl=GLX.ctx;GLX.gl=GLX.ctx=null;spritesDrop();glFree(gl);glShow(false);} -/* The card given up for good (not Always 2D, which keeps it for later) still held what was sent to it, the atlas alone +/* The card given up for good (not Always 2D: glSleep()) still held what was sent to it, the atlas alone 64 MB, while the 2D map starts painting its own pictures. So its biggest things are deleted and the context let go (WEBGL_lose_context, where the browser has it), unless the browser already lost it, which freed them. glInit() keeps the context in GLX.ctx from the start, so a setup that fails half-way is let go too. */ function glFree(gl){try{if(gl&&gl.isContextLost()===false){for(const x of [GLS.tex,GLX.tex])if(x)gl.deleteTexture(x);if(GLS.buf)gl.deleteBuffer(GLS.buf); const L=gl.getExtension('WEBGL_lose_context');if(L&&typeof L.loseContext==='function')L.loseContext();}}catch(e){} GLS.tex=GLS.buf=GLS.vao=GLS.prog=null;GLX.tex=null;GLX.land={};GLS_PAD.cv=GLS_PAD.g=null;} +/* A lost context comes back. The browser may lose it (a driver reset; on a phone, sometimes just leaving the app) and + give it back (webglcontextrestored): the 2D map draws meanwhile, and everything on the card is built again on the + same context, as for the first frame. A card lost more than GL_LOSSES times is given up for the session, so a card + that keeps failing does not keep the map switching. Always 2D lets the context go the same way (WEBGL_lose_context) + and Auto asks for it back, so 64 MB of atlas and the rest are not held for a map that is not drawn. */ +const GL_LOSSES=2; +// Forgets what was on the card (the context itself is kept): glInit() builds it all again. +function glForget(){GLX.gl=null;spritesDrop();GLS.tex=GLS.buf=GLS.vao=GLS.prog=null;Object.assign(GLX,{tex:null,land:{},ckey:null,key:[]});glShow(false);UI.drawnAt=0;} +function glLost(e){if(GLX.dead)return;e.preventDefault();if(GLX.lost)return; // let go by Always 2D (glSleep()) + if(++GLX.losses>GL_LOSSES){glKill('the graphics context was lost '+GLX.losses+' times');return;} + GLX.lost=true;glForget();} +function glRestored(){if(GLX.dead)return;GLX.lost=false;glForget();if(!GLX.want)glSleep();} +// Always 2D: lets the context go, unless the browser has it already (its restore then finds Always 2D and lets it go). +function glSleep(){const L=GLX.lose;if(!GLX.ctx||GLX.dead||!L||typeof L.restoreContext!=='function')return; + if(GLX.lost){GLX.sleep=true;return;}glForget();GLX.sleep=GLX.lost=true;try{L.loseContext();}catch(e){GLX.sleep=GLX.lost=false;}} /* A card short of memory may refuse a texture or a buffer without throwing: it only leaves OUT_OF_MEMORY for getError(), and the texture then draws black (every picture a black box) or the buffer draws nothing. So the big uploads (the atlas, the land, the tubes, the cables) read it, and give the card up like any of its errors. Never @@ -47,21 +64,21 @@ function glVao(gl,sizes,div=1,data=null){const v=gl.createVertexArray(),b=gl.cre gl.bindVertexArray(v);gl.bindBuffer(gl.ARRAY_BUFFER,b);if(data)gl.bufferData(gl.ARRAY_BUFFER,data,gl.STATIC_DRAW); let off=0;sizes.forEach((n,i)=>{gl.enableVertexAttribArray(i);gl.vertexAttribPointer(i,n,gl.FLOAT,false,stride,off);gl.vertexAttribDivisor(i,div);off+=n*4;}); gl.bindVertexArray(null);return {v,b};} -function glInit(){if(GLX.gl)return true;if(GLX.dead)return false; +function glInit(){if(GLX.gl)return true;if(GLX.dead||GLX.lost)return false; try{const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');if(!c||!f||!c.getContext)throw new Error('no map layers'); const gl=c.getContext('webgl2',{alpha:true,premultipliedAlpha:true,antialias:false,depth:true,stencil:true,powerPreference:'high-performance'}); if(!gl||typeof gl.createShader!=='function')throw new Error('no WebGL2');GLX.ctx=gl; + if(!GLX.lose){c.addEventListener('webglcontextlost',glLost);c.addEventListener('webglcontextrestored',glRestored);try{GLX.lose=gl.getExtension('WEBGL_lose_context')||{};}catch(e){GLX.lose={};}} try{const x=gl.getExtension('WEBGL_debug_renderer_info');GLX.gpu=String(x?gl.getParameter(x.UNMASKED_RENDERER_WEBGL):gl.getParameter(gl.RENDERER));}catch(e){} if(!GLX.soft&&GL_SOFT.test(GLX.gpu))throw new Error('no graphics card, only '+GLX.gpu); const P=(vs,fs)=>glProg(gl,vs,fs),progs={line:P(GL_LINE_VS,GL_LINE_FS),pk:P(GL_PK_VS,GL_PK_FS),fill:P(FILL_VS,FILL_FS),fan:P(FAN_VS,FAN_FS),ell:P(ELL_VS,ELL_FS),circ:P(CIRC_VS,CIRC_FS)}; // The tubes' points for the packets: floats read with texelFetch, never filtered. const tex=gl.createTexture();gl.bindTexture(gl.TEXTURE_2D,tex);for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.NEAREST); - c.addEventListener('webglcontextlost',e=>{e.preventDefault();if(GLX.dead)return;glKill('the graphics context was lost');UI.drawnAt=0;}); glsInit(gl); // The overlay is cleared only after something was painted on it: clearing a whole screen of empty canvas every // frame makes the browser send the layer to the screen again, which on a 4K screen cost more than the map itself. const fx=f.getContext('2d'),CP=CanvasRenderingContext2D.prototype; - for(const m of ['fill','stroke','fillRect','strokeRect','fillText','strokeText','drawImage','putImageData']){const fn=CP[m];fx[m]=function(){GLX.fxUsed=true;return fn.apply(this,arguments);};} + if(!fx.__fxw){fx.__fxw=true;for(const m of ['fill','stroke','fillRect','strokeRect','fillText','strokeText','drawImage','putImageData']){const fn=CP[m];fx[m]=function(){GLX.fxUsed=true;return fn.apply(this,arguments);};}} const V=s=>glVao(gl,s); Object.assign(GLX,progs,{gl,c,f,fx,fxUsed:true,tex,land:{},lv:V([4,4,4]),hv:V([4,4,4]),pv:V([4,4]),cb:V([4,4,4]),wv:V([4,4,4]),cl:V([4]),empty:gl.createVertexArray()});return true;} catch(e){glKill(e);return false;}} diff --git a/src/game/96-map/97-diagnostics.js b/src/game/96-map/97-diagnostics.js index b5a427e..d80320f 100644 --- a/src/game/96-map/97-diagnostics.js +++ b/src/game/96-map/97-diagnostics.js @@ -9,7 +9,7 @@ function diagFrame(now){const D=DIAG;if(D.last)D.fr.push(now-D.last);D.last=now; if(D.fr.length>600)D.fr.splice(0,300);if(D.dr.length>600)D.dr.splice(0,300);} // What draws the map, and why it is the 2D canvas when it is. function diagMap(){if(!S)return 'map: none (title screen)';if(pzOn())return 'map: 2D (puzzle)';if(!GLX.want)return 'map: 2D (Always 2D)'; - if(GLX.dead)return 'map: 2D ('+(GLX.why||'no WebGL2')+')';return GLX.gl&&GLX.shown?'map: WebGL2 · '+(GLX.gpu||'unknown GPU'):'map: WebGL2 (starting)';} + if(GLX.dead)return 'map: 2D ('+(GLX.why||'no WebGL2')+')';if(GLX.lost)return 'map: 2D (graphics context lost, waiting for it back)';return GLX.gl&&GLX.shown?'map: WebGL2 · '+(GLX.gpu||'unknown GPU'):'map: WebGL2 (starting)';} // Frames since the last readout: per second, the 95th percentile and the slowest, and draw()'s mean. function diagPerf(){const f=DIAG.fr.splice(0),d=DIAG.dr.splice(0),s=f.slice().sort((a,b)=>a-b),sum=f.reduce((a,x)=>a+x,0), q=x=>s.length?s[Math.min(s.length-1,Math.floor(s.length*x))].toFixed(0):'-',gl=GLX.shown&&!GLX.dead; diff --git a/tests/diagnostic-info.test.js b/tests/diagnostic-info.test.js index 324fcf6..2713149 100644 --- a/tests/diagnostic-info.test.js +++ b/tests/diagnostic-info.test.js @@ -47,7 +47,9 @@ test('it says what draws the map, and why it is the 2D canvas', () => { assert.equal(map(), 'map: 2D (Always 2D)'); ev('mapGl(true,false);glKill(new Error("the graphics card is out of memory (the pictures)"))'); assert.equal(map(), 'map: 2D (the graphics card is out of memory (the pictures))'); - ev('GLX.dead=false;GLX.gl={};GLX.shown=true;GLX.gpu="ANGLE (NVIDIA GeForce GTX 980)"'); + ev('GLX.dead=false;GLX.lost=true'); + assert.equal(map(), 'map: 2D (graphics context lost, waiting for it back)'); + ev('GLX.lost=false;GLX.gl={};GLX.shown=true;GLX.gpu="ANGLE (NVIDIA GeForce GTX 980)"'); assert.equal(map(), 'map: WebGL2 · ANGLE (NVIDIA GeForce GTX 980)'); ev('const s=S;S=null;window.__S=s'); assert.equal(map(), 'map: none (title screen)'); diff --git a/tests/webgl-context-restore.test.js b/tests/webgl-context-restore.test.js new file mode 100644 index 0000000..734fa03 --- /dev/null +++ b/tests/webgl-context-restore.test.js @@ -0,0 +1,145 @@ +// A WebGL context can be lost and given back: a driver reset, or on a phone sometimes just leaving the app. The map +// gave the card up for the session at the first loss, so a phone that went to another app came back to the slower 2D +// map until the page was reloaded. It now draws in 2D while the context is away, and builds everything on the card +// again when the browser gives it back (webglcontextrestored), up to GL_LOSSES times a session. Settings › Map drawing +// › Always 2D lets the context go the same way (WEBGL_lose_context), and Auto asks for it back, so a map drawn in 2D +// does not hold 64 MB of atlas on the card. Switching for the GPU benchmark (mapGl(on,false)) keeps the context. +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { load } = require('./harness'); + +const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8'); + +/* A WebGL2 context that compiles everything, as tests/webgl-map.test.js's. It can be lost by the "browser" + (__browserLose(), __browserRestore()) or through WEBGL_lose_context (counted in __LOST and __RESTORE; without it when + window.__noExt). Events come at once, which the real ones do not: the code must not rely on either order. Textures + made are counted (__TEX), so a rebuild shows. */ +const GL = `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};window.__LOST=0;window.__RESTORE=0;window.__TEX=0; + let lost=false;const c=document.getElementById('mapgl'),fire=t=>c.dispatchEvent(new window.Event(t,{cancelable:true})); + window.__browserLose=()=>{lost=true;fire('webglcontextlost');};window.__browserRestore=()=>{lost=false;fire('webglcontextrestored');}; + const ext={loseContext:()=>{__LOST++;if(lost)return;lost=true;fire('webglcontextlost');},restoreContext:()=>{__RESTORE++;if(!lost)return;lost=false;fire('webglcontextrestored');}}; + const gl=new Proxy({},{get(t,k){ + if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k; + if(k==='getExtension')return (n)=>n==='WEBGL_lose_context'?(window.__noExt?null:ext):{UNMASKED_RENDERER_WEBGL:'REN'}; + if(k==='isContextLost')return ()=>lost; + if(k==='createTexture')return ()=>{__TEX++;return {};}; + if(k==='getParameter')return (p)=>p==='REN'?'Stub GPU':p==='ACTIVE_UNIFORMS'?0:4096; + if(k==='getShaderParameter'||k==='getProgramParameter')return (x,p)=>p==='ACTIVE_UNIFORMS'?0:true; + if(k==='getError')return ()=>0; + return ()=>({});}}); + c.getContext=(t)=>t==='webgl2'?gl:null;})()`; + +function open(storage) { + const h = load({ seed: 777, storage }); + h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();compute(); + window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});console.warn=()=>{}; + const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;`); + h.ev(GL); + return h; +} +const frame = (ev) => ev('__T+=16;draw(__T);JSON.stringify({gl:!!GLX.gl&&GLX.shown,dead:GLX.dead,lost:GLX.lost,sprs:SPRS.size,sprc:SPRC.size,err:!!UI.tickErr})'); + +test('a context the browser loses draws the map in 2D, then on the card again once it is back', () => { + const { ev, errors } = open(); + assert.equal(JSON.parse(frame(ev)).gl, true, 'drawn on the card'); + ev('UI.tickErr=false;__browserLose();'); + let f = JSON.parse(frame(ev)); + assert.deepEqual([f.gl, f.dead, f.lost, f.err], [false, false, true, false], 'in 2D while it is away, without a glitch'); + assert.equal(f.sprs, 0, 'the card’s pictures are forgotten (its atlas went with the context)'); + assert.ok(f.sprc > 0, 'the 2D map paints its own'); + assert.equal(ev('document.getElementById("mapgl").hidden'), true); + ev('window.__t0=__TEX;window.__built=0;const gb=glBuild;glBuild=function(){__built++;return gb.apply(this,arguments);};__browserRestore();'); + f = JSON.parse(frame(ev)); + assert.deepEqual([f.gl, f.dead, f.lost], [true, false, false], 'back on the card'); + assert.ok(ev('__TEX-__t0') >= 2, 'the atlas and the tubes’ points are made again'); + assert.equal(ev('__built'), 1, 'the tubes are built again'); + assert.ok(f.sprs > 0, 'the pictures are sent again'); + assert.equal(ev('GLX.losses'), 1); + assert.deepEqual(errors, []); +}); + +test(`a card lost more than GL_LOSSES times is given up for the session`, () => { + const { ev, errors } = open(); + frame(ev); + const n = ev('GL_LOSSES'); + for (let i = 0; i < n; i++) { ev('__browserLose()'); frame(ev); ev('__browserRestore()'); assert.equal(JSON.parse(frame(ev)).gl, true, `back after loss ${i + 1}`); } + ev('__browserLose()'); + let f = JSON.parse(frame(ev)); + assert.equal(f.dead, true, 'given up'); + assert.match(ev('GLX.why'), /lost 3 times/); + assert.equal(ev('__LOST'), 0, 'nothing to let go: the browser already did'); + // A late restore does not bring it back. + ev('__browserRestore()'); + f = JSON.parse(frame(ev)); + assert.deepEqual([f.gl, f.dead], [false, true]); + assert.deepEqual(errors, []); +}); + +test('Always 2D lets the context go, Auto takes it back, and neither counts as a loss', () => { + const { ev, errors } = open(); + frame(ev); + ev("ACT.mapSet({v:'2d'})"); + assert.equal(ev('__LOST'), 1, 'the context is let go'); + assert.equal(ev('GLX.gl===null&&GLS.tex===null&&SPRS.size===0'), true, 'nothing on the card is held'); + let f = JSON.parse(frame(ev)); + assert.deepEqual([f.gl, f.dead], [false, false]); + assert.equal(ev('localStorage.getItem("sot-map")'), '2d'); + ev("ACT.mapSet({v:'auto'})"); + assert.equal(ev('__RESTORE'), 1, 'asked back'); + f = JSON.parse(frame(ev)); + assert.deepEqual([f.gl, f.dead, f.lost], [true, false, false], 'on the card again'); + assert.equal(ev('GLX.losses'), 0, 'the player’s choice is not a failure'); + // Back and forth: still fine, still not counted. + for (let i = 0; i < 4; i++) { ev("ACT.mapSet({v:'2d'})"); frame(ev); ev("ACT.mapSet({v:'auto'})"); } + assert.equal(JSON.parse(frame(ev)).gl, true); + assert.equal(ev('GLX.losses'), 0); + assert.deepEqual(errors, []); +}); + +test('a context the browser gives back after the player chose Always 2D is let go again', () => { + const { ev, errors } = open(); + frame(ev); + ev('__browserLose()'); + ev("ACT.mapSet({v:'2d'})"); + assert.equal(ev('__LOST'), 0, 'already lost: nothing to let go yet'); + ev('__browserRestore()'); + assert.equal(ev('__LOST'), 1, 'let go as soon as it is back'); + assert.equal(JSON.parse(frame(ev)).gl, false); + ev("ACT.mapSet({v:'auto'})"); + assert.equal(JSON.parse(frame(ev)).gl, true); + assert.deepEqual(errors, []); +}); + +test('the GPU benchmark switches maps without letting the context go', () => { + const { ev, errors } = open(); + frame(ev); + ev('mapGl(false,false)'); + assert.equal(JSON.parse(frame(ev)).gl, false); + ev('mapGl(true,false)'); + assert.equal(JSON.parse(frame(ev)).gl, true); + assert.equal(ev('__LOST+__RESTORE'), 0); + assert.deepEqual(errors, []); +}); + +test('without WEBGL_lose_context, Always 2D keeps the context, as before', () => { + const { ev, errors } = open(); + ev('window.__noExt=true'); + frame(ev); + ev("ACT.mapSet({v:'2d'})"); + assert.equal(JSON.parse(frame(ev)).gl, false); + assert.equal(ev('!!GLX.gl'), true, 'kept for later'); + ev("ACT.mapSet({v:'auto'})"); + assert.equal(JSON.parse(frame(ev)).gl, true); + assert.deepEqual(errors, []); +}); + +test('a game started with Always 2D never makes a context', () => { + const { ev, errors } = open({ 'sot-map': '2d' }); + ev('window.__made=0;const gc=document.getElementById("mapgl").getContext;document.getElementById("mapgl").getContext=t=>{__made++;return gc(t);};'); + frame(ev); + ev("ACT.settings({})"); + assert.equal(ev('__made'), 0); + assert.deepEqual(errors, []); +}); diff --git a/tests/webgl-out-of-memory.test.js b/tests/webgl-out-of-memory.test.js index b09577c..fb54011 100644 --- a/tests/webgl-out-of-memory.test.js +++ b/tests/webgl-out-of-memory.test.js @@ -135,13 +135,14 @@ test('a setup that fails half-way lets its context go too', () => { assert.deepEqual(errors, []); }); +// A context the browser lost may come back (tests/webgl-context-restore.test.js): it is waited for, not let go. test('a context the browser lost is not let go a second time', () => { const { ev, errors } = open({}); assert.equal(ev('glInit()'), true); ev('__T+=16;draw(__T);'); - ev('window.__lostNow=true;document.getElementById("mapgl").dispatchEvent(new window.Event("webglcontextlost"));'); - assert.equal(ev('GLX.dead'), true); - assert.equal(ev('GLX.why'), 'the graphics context was lost'); + ev('window.__lostNow=true;document.getElementById("mapgl").dispatchEvent(new window.Event("webglcontextlost",{cancelable:true}));'); + assert.equal(ev('GLX.dead'), false, 'waiting for it to come back'); + assert.equal(ev('GLX.lost&&!glOn()'), true, 'the 2D map draws meanwhile'); assert.equal(ev('__LOST'), 0, 'nothing to let go: the browser already did'); ev('__T+=16;draw(__T);'); assert.deepEqual(errors, []); From b7a9ec3e3cd976f49edb2b99b38b982b97b02890 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:05:11 +0100 Subject: [PATCH 19/23] Settings: say whether the card can draw the map without setting it up MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Settings › Map drawing said "This browser cannot" by calling glInit(), so opening Settings on the title screen or in a puzzle, where the map is drawn in 2D, made the WebGL context and its 64 MB atlas. It now says what is known without asking the card (glCan()): a card given up or a browser without WebGL2 cannot; a card not tried yet counts as able. A card that turns out to be the processor's is still named once the game draws its first frame, in Diagnostic info and in Settings. Test in webgl-context-restore. --- src/game/96-map/30-settings.js | 2 +- src/game/96-map/56-webgl.js | 3 +++ tests/webgl-context-restore.test.js | 18 ++++++++++++++++++ 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/game/96-map/30-settings.js b/src/game/96-map/30-settings.js index f3025be..b2874fd 100644 --- a/src/game/96-map/30-settings.js +++ b/src/game/96-map/30-settings.js @@ -30,7 +30,7 @@ function settingsHtml(){const seg=(lab,act,cur,opts,note)=>`
${tr('settings.display_and_sound')} ${seg(tr('common.animations'),'animSet',UI.anim||'auto',[['auto',tr('common.auto')],['on',tr('common.on')],['off',tr('common.off')]],tr('settings.auto_follows_your_device_s_reduce'))} - ${seg(tr('settings.map_drawing'),'mapSet',GLX.want?'auto':'2d',[['auto',tr('common.auto')],['2d',tr('settings.always_2d')]],tr('settings.auto_draws_the_map_with_your')+(GLX.want&&!glInit()?' '+tr('settings.this_browser_cannot_so_the_map'):''))} + ${seg(tr('settings.map_drawing'),'mapSet',GLX.want?'auto':'2d',[['auto',tr('common.auto')],['2d',tr('settings.always_2d')]],tr('settings.auto_draws_the_map_with_your')+(GLX.want&&!glCan()?' '+tr('settings.this_browser_cannot_so_the_map'):''))} ${seg(tr('common.sound'),'soundSet',UI.muted?'off':'on',[['on',tr('common.on')],['off',tr('common.off')]])}
${langPick('langSel')}
${seg(tr('settings.diagnostic_info'),'vpSet',DIAG.on?'on':'off',[['on',tr('common.on')],['off',tr('common.off')]],tr('settings.for_bug_reports_shows_your_screen'))} diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js index 26fae66..7f4196d 100644 --- a/src/game/96-map/56-webgl.js +++ b/src/game/96-map/56-webgl.js @@ -13,6 +13,9 @@ try{GLX.want=localStorage.getItem('sot-map')!=='2d';}catch(e){} // Renderers that are the processor pretending to be a graphics card (GLX.soft: use them anyway, for the GPU benchmark). const GL_SOFT=/swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/i; const glOn=()=>GLX.want&&!GLX.dead&&!!S&&!pzOn()&&glInit(); +// Whether the card can draw the map, as far as is known without asking it: Settings says so without making a context +// (on the title screen or in a puzzle that made the 64 MB atlas for a map drawn in 2D). A card not tried yet counts as able. +const glCan=()=>!GLX.dead&&typeof WebGL2RenderingContext!=='undefined'; // Switches the WebGL map on or off: the setting keeps the choice in this browser (keep), the GPU benchmark does not. // Chosen in Settings, Always 2D also lets the card's context go (glSleep()), and Auto takes it back. function mapGl(on,keep=true){GLX.want=!!on;if(keep)try{on?localStorage.removeItem('sot-map'):localStorage.setItem('sot-map','2d');}catch(e){} diff --git a/tests/webgl-context-restore.test.js b/tests/webgl-context-restore.test.js index 734fa03..ea46ea2 100644 --- a/tests/webgl-context-restore.test.js +++ b/tests/webgl-context-restore.test.js @@ -143,3 +143,21 @@ test('a game started with Always 2D never makes a context', () => { assert.equal(ev('__made'), 0); assert.deepEqual(errors, []); }); + +// Settings said whether the card could draw the map by setting it up: opening them on the title screen or in a puzzle +// made the context and its 64 MB atlas for a map drawn in 2D. It now says what is known without asking the card. +test('opening Settings never makes a context, and still says when the card cannot', () => { + const { ev, errors } = open(); + ev('window.WebGL2RenderingContext=function(){};window.__made=0;const c=document.getElementById("mapgl"),gc=c.getContext;c.getContext=t=>{__made++;return gc(t);};'); + const note = () => ev("settingsHtml().includes(tr('settings.this_browser_cannot_so_the_map'))"); + ev('const s=S;S=null;window.__S=s;'); + assert.equal(note(), false, 'title screen: a card not tried yet counts as able'); + ev('S=__S;'); + assert.equal(note(), false); + assert.equal(ev('__made'), 0, 'no context made by Settings'); + ev('glKill(new Error("no graphics card, only SwiftShader"))'); + assert.equal(note(), true, 'a card given up: Settings says so'); + ev('delete window.WebGL2RenderingContext;GLX.dead=false;'); + assert.equal(note(), true, 'no WebGL2 in this browser: Settings says so'); + assert.deepEqual(errors, []); +}); From c652bce7d299d895d95ba1db5f604cf50e0a29b8 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:06:07 +0100 Subject: [PATCH 20/23] Diagnostic info: say how often the map was drawn, and drop a key no release had The loop runs at the screen's rate even when a still map is not drawn again, so the readout's "fps" said 60 or 240 on a map that was not being drawn at all, which a bug report would take for the map's speed. It now also says how often the map was drawn ("map drawn N/s"). The sot-fps setting it carried over only ever existed on this branch, never in a release, so it is no longer read or removed; ?fps and ?nofps still open and close the readout. --- src/game/96-map/97-diagnostics.js | 9 +++++---- tests/diagnostic-info.test.js | 13 +++++++------ 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/src/game/96-map/97-diagnostics.js b/src/game/96-map/97-diagnostics.js index d80320f..7098b72 100644 --- a/src/game/96-map/97-diagnostics.js +++ b/src/game/96-map/97-diagnostics.js @@ -10,10 +10,11 @@ function diagFrame(now){const D=DIAG;if(D.last)D.fr.push(now-D.last);D.last=now; // What draws the map, and why it is the 2D canvas when it is. function diagMap(){if(!S)return 'map: none (title screen)';if(pzOn())return 'map: 2D (puzzle)';if(!GLX.want)return 'map: 2D (Always 2D)'; if(GLX.dead)return 'map: 2D ('+(GLX.why||'no WebGL2')+')';if(GLX.lost)return 'map: 2D (graphics context lost, waiting for it back)';return GLX.gl&&GLX.shown?'map: WebGL2 · '+(GLX.gpu||'unknown GPU'):'map: WebGL2 (starting)';} -// Frames since the last readout: per second, the 95th percentile and the slowest, and draw()'s mean. +// Frames since the last readout: per second, the 95th percentile and the slowest, and draw()'s mean. The loop runs at +// the screen's rate even when a still map is not drawn again (mapStill()), so how often it was drawn is shown too. function diagPerf(){const f=DIAG.fr.splice(0),d=DIAG.dr.splice(0),s=f.slice().sort((a,b)=>a-b),sum=f.reduce((a,x)=>a+x,0), q=x=>s.length?s[Math.min(s.length-1,Math.floor(s.length*x))].toFixed(0):'-',gl=GLX.shown&&!GLX.dead; - return `${sum?(f.length*1000/sum).toFixed(0):'-'} fps · p95 ${q(.95)} ms · max ${q(1)} ms\ndraw ${d.length?(d.reduce((a,x)=>a+x,0)/d.length).toFixed(1):'-'} ms · x${UI.speed||0} · zoom ${cam.z.toFixed(2)}`+ + return `${sum?(f.length*1000/sum).toFixed(0):'-'} fps · map drawn ${sum?(d.length*1000/sum).toFixed(0):'-'}/s · p95 ${q(.95)} ms · max ${q(1)} ms\ndraw ${d.length?(d.reduce((a,x)=>a+x,0)/d.length).toFixed(1):'-'} ms · x${UI.speed||0} · zoom ${cam.z.toFixed(2)}`+ (gl?` · ${GLX.nSeg} segments · ${GLX.nPk} packets`:'');} function diagShow(){const D=DIAG;let el=D.el; if(!el){el=D.el=document.createElement('pre');el.id='diag';el.style.cssText='position:fixed;left:8px;bottom:calc(var(--tabbar,0px) + 8px);z-index:99;margin:0;padding:6px 8px;max-width:calc(100vw - 32px);background:rgba(30,38,64,.85);color:#7CFFB2;font:11px/1.35 ui-monospace,monospace;border-radius:8px;pointer-events:none;white-space:pre-wrap;overflow-wrap:anywhere'; @@ -30,7 +31,7 @@ function diagShow(){const D=DIAG;let el=D.el; // Shows or hides the readout, and remembers it on this device. function diagOn(on){const D=DIAG;clearInterval(D.t);D.t=null;if(D.el){D.el.remove();D.el=null;}D.on=!!on;D.fr.length=D.dr.length=0;D.last=0;D.dms=-1; if(on){D.t=setInterval(diagShow,500);diagShow();} - try{on?localStorage.setItem('sot-vp','1'):localStorage.removeItem('sot-vp');localStorage.removeItem('sot-fps');}catch(e){}} -{const q=location.search;let on=false;try{on=localStorage.getItem('sot-vp')==='1'||localStorage.getItem('sot-fps')==='1';}catch(e){} + try{on?localStorage.setItem('sot-vp','1'):localStorage.removeItem('sot-vp');}catch(e){}} +{const q=location.search;let on=false;try{on=localStorage.getItem('sot-vp')==='1';}catch(e){} if(/[?&](vp|fps)\b/.test(q))on=true;else if(/[?&]no(vp|fps)\b/.test(q))on=false;diagOn(on);} {let taps=[];document.getElementById('hDate').closest('.chip,div').addEventListener('click',()=>{const t=performance.now();taps=taps.filter(x=>t-x<1500).concat(t);if(taps.length>=5){taps=[];diagOn(!DIAG.on);}});} diff --git a/tests/diagnostic-info.test.js b/tests/diagnostic-info.test.js index 2713149..722ddd8 100644 --- a/tests/diagnostic-info.test.js +++ b/tests/diagnostic-info.test.js @@ -63,21 +63,22 @@ test('it measures frames per second, the slowest frames and draw()', () => { const { ev, errors } = h; try { ev('diagOn(true)'); - // 60 frames, so 59 intervals: 58 of 16 ms and a last one of 50 ms (978 ms in all), each map drawn in 2 ms. - ev('let t=1000;for(let i=0;i<60;i++){t+=i===59?50:16;DIAG.dms=2;diagFrame(t);}diagShow();'); + // 60 frames, so 59 intervals: 58 of 16 ms and a last one of 50 ms (978 ms in all); the map drawn on every other + // one (a still map is not drawn again), in 2 ms: 30 in 978 ms, 31 a second. + ev('let t=1000;for(let i=0;i<60;i++){t+=i===59?50:16;if(i%2)DIAG.dms=2;diagFrame(t);}diagShow();'); const t = text(ev); - assert.match(t, /\b60 fps · p95 16 ms · max 50 ms/); + assert.match(t, /\b60 fps · map drawn 31\/s · p95 16 ms · max 50 ms/); assert.match(t, /draw 2\.0 ms · x0 · zoom /); assert.deepEqual(errors, []); } finally { h.done(); } }); -test('?fps and ?vp open it, ?nofps closes it, and the old frame meter setting carries over', () => { - for (const [url, storage, want] of [['?fps', {}, true], ['?vp', {}, true], ['?nofps', { 'sot-vp': '1' }, false], ['', { 'sot-fps': '1' }, true], ['', {}, false]]) { +test('?fps and ?vp open it, ?nofps closes it, and it stays open on this device', () => { + for (const [url, storage, want] of [['?fps', {}, true], ['?vp', {}, true], ['?nofps', { 'sot-vp': '1' }, false], ['', { 'sot-vp': '1' }, true], ['', {}, false]]) { const h = load({ seed: 777, url: 'https://tests.invalid/' + url, storage }); try { assert.equal(h.ev('!!document.getElementById("diag")'), want, `${url || 'no flag'} ${JSON.stringify(storage)}`); - assert.equal(h.ev('localStorage.getItem("sot-fps")'), null, 'the old key is gone'); + assert.equal(h.ev('localStorage.getItem("sot-vp")'), want ? '1' : null, 'remembered as one setting'); } finally { h.dom.window.close(); } } }); From 32f330b1c389a808b078961ddaa48814bd7b1f50 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:09:59 +0100 Subject: [PATCH 21/23] WebGL map: check the pictures sent to the card at most once a second A frame that sent pictures read getError() to know whether the card took them. In every browser WebGL runs in another process, and each read waits for it to finish everything sent so far, uploads included: a wait on the main thread on exactly the frames that already cost the most (a pan or a zoom sends pictures on most frames, up to 321 in one). The card keeps an error until it is read, so one read a second still finds a refusal: the pictures are now checked at most every GL_MEM_EVERY (1 000) ms, and a picture refused in between shows at worst as a dark box until then, after which the map goes to 2D as before. The first pictures sent into a new atlas are still checked at once, where a card that allocates it lazily refuses. The cost could not be timed here (no Vulkan driver on this machine for Chromium to reach the graphics card); the change bounds it whatever it is. Tests: webgl-out-of-memory reads at most twice in two seconds of panning, and a refusal after the first check gives the map to 2D within a second. --- src/game/96-map/59-gl-sprites.js | 20 +++++++++++------ tests/webgl-out-of-memory.test.js | 37 +++++++++++++++++++++++-------- 2 files changed, 41 insertions(+), 16 deletions(-) diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js index ad1d91e..309c1d7 100644 --- a/src/game/96-map/59-gl-sprites.js +++ b/src/game/96-map/59-gl-sprites.js @@ -17,7 +17,7 @@ const sprFree=e=>{if(e.cv){e.cv.width=e.cv.height=0;e.cv=null;}}; function sprcTrim(){if(SPRC_B<=SPRC_BUDGET)return;const old=[];for(const [k,e] of SPRC)if(e.fa[0]-b[0]);const goal=SPRC_BUDGET*0.75; for(const [,k,e] of old){if(SPRC_B<=goal)break;SPRC.delete(k);SPRC_B-=e.pw*e.ph*4;sprFree(e);}} -const GLS={prog:null,vao:null,buf:null,tex:null,size:4096,shx:0,shy:0,shh:0,frame:false,data:new Float32Array(SPR_STRIDE*2048),n:0,up:0}; +const GLS={prog:null,vao:null,buf:null,tex:null,size:4096,shx:0,shy:0,shh:0,frame:false,data:new Float32Array(SPR_STRIDE*2048),n:0,up:0,upq:false,memT:-1e9}; /* One record is 13 floats: x,y,w,h (CSS px) | u0,v0,u1,v1 (atlas) | r,g,b,a | kind. A picture (kind 0) takes its colours from the atlas and a from the record; a disc (kind 1) is centred on x,y with radius w, in colour r,g,b,a. */ const SPR_VS=GL_HEAD+`layout(location=0) in vec4 aP;layout(location=1) in vec4 aUV;layout(location=2) in vec4 aC;layout(location=3) in float aK; @@ -38,11 +38,11 @@ function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4 try{glMem(gl,'the pictures');break;}catch(e){if(GLS.size<=2048)throw e;}} for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.LINEAR); for(const k of [gl.TEXTURE_WRAP_S,gl.TEXTURE_WRAP_T])gl.texParameteri(gl.TEXTURE_2D,k,gl.CLAMP_TO_EDGE); - GLS.shx=GLS.shy=GLS.shh=0;} + GLS.shx=GLS.shy=GLS.shh=0;GLS.memT=-1e9;GLS.upq=false;} // Forgets every picture and starts the atlas again, after the pictures already queued are drawn (they point into it). function spritesReset(){glsDrawNow();for(const e of SPRC.values())sprFree(e);SPRS.clear();SPRC.clear();SPRC_B=0;GLS.shx=GLS.shy=GLS.shh=0;} // The card given up: its pictures go (they have no canvas to be drawn from in 2D) and the atlas is forgotten. -function spritesDrop(){GLS.n=GLS.up=0;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} +function spritesDrop(){GLS.n=GLS.up=0;GLS.upq=false;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} /* The card's pictures are painted on one canvas, reused, and each goes into the atlas as soon as it is painted: a canvas kept per picture made the browser hold thousands of them while you zoomed, until it lost the graphics context and the map fell back to 2D. The 2D map, and a picture too big for the atlas, keep their own canvas. */ @@ -130,7 +130,13 @@ function glsDraw(gl,n){gl.useProgram(GLS.prog.p);gl.bindVertexArray(GLS.vao);gl. gl.enable(gl.BLEND);gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);gl.disable(gl.DEPTH_TEST); gl.drawArraysInstanced(gl.TRIANGLE_STRIP,0,4,n);gl.bindVertexArray(null);} /* The end of a frame on the card: the pictures go up over the tubes. The frame is over even if that draw fails. - A frame that sent new pictures first asks the card if it took them (once, however many): a card short of memory - may refuse one without throwing, and the picture would be kept as sent. It then gives the map to 2D (glMem() throws, - draw() draws the frame again there and glKill() forgets the card's pictures). A frame that only reuses the atlas asks nothing. */ -function glsFrameEnd(){if(!GLS.frame)return;GLS.frame=false;const up=GLS.up;GLS.up=0;if(up&&GLX.gl)glMem(GLX.gl,'the pictures');glsDrawNow();} + Pictures sent are checked (did the card take them?): a card short of memory may refuse one without throwing, and the + picture would be kept as sent. It then gives the map to 2D (glMem() throws, draw() draws the frame again there and + glKill() forgets the card's pictures). Each read waits for the card to finish everything sent so far, so it is done + at most once every GL_MEM_EVERY ms: the card keeps an error until it is read, so a later read still finds it, and a + picture refused in between shows at worst as a dark box for that time. The first pictures sent into a new atlas are + checked at once (a card that allocates it lazily refuses there). A frame that only reuses the atlas asks nothing. */ +const GL_MEM_EVERY=1000; +function glsFrameEnd(){if(!GLS.frame)return;GLS.frame=false;if(GLS.up)GLS.upq=true;GLS.up=0; + if(GLS.upq&&GLX.gl){const t=performance.now();if(t-GLS.memT>=GL_MEM_EVERY){GLS.memT=t;GLS.upq=false;glMem(GLX.gl,'the pictures');}} + glsDrawNow();} diff --git a/tests/webgl-out-of-memory.test.js b/tests/webgl-out-of-memory.test.js index fb54011..75a7bc5 100644 --- a/tests/webgl-out-of-memory.test.js +++ b/tests/webgl-out-of-memory.test.js @@ -1,8 +1,8 @@ // A graphics card short of memory may refuse a texture or a buffer without throwing: the call only leaves // OUT_OF_MEMORY for getError(), and the atlas then drew every picture as a black box while the map stayed on the card. // The big uploads now read it (glMem(), src/game/96-map/56-webgl.js): the atlas tries 2048 px before giving up, and -// any other refusal gives the card up for 2D in the same frame. getError() is never read on an ordinary frame (each -// read waits for the card). +// any other refusal gives the card up for 2D in the same frame, or for a picture within a second. getError() is never +// read on an ordinary frame, and at most once a second while pictures are sent (each read waits for the card). const test = require('node:test'); const assert = require('node:assert/strict'); const fs = require('node:fs'); @@ -80,13 +80,17 @@ test('an ordinary frame never asks the card for its errors', () => { ev('__T+=16;draw(__T);'); assert.equal(ev('GLX.dead'), false); assert.ok(ev('__GE') > 0, 'the first frame checked its uploads'); - // Panning brings new cities into view, whose pictures are sent: only those frames ask, once each. - const pan = JSON.parse(ev(`(()=>{let quiet=0,asked=0,sent=0,most=0;for(let i=0;i<30;i++){const s=__SUB,g=__GE;cam.x+=3;__T+=16;draw(__T); - if(__SUB===s){quiet++;if(__GE>g)asked++;}else{sent++;most=Math.max(most,__GE-g);}}return JSON.stringify({quiet,asked,sent,most});})()`)); - assert.ok(pan.quiet > 0, 'some frames send no picture'); - assert.equal(pan.asked, 0, 'a frame that sends nothing big reads nothing'); - assert.ok(pan.most <= 4, 'a frame that sends pictures asks once (getError() read up to four flags), not once per picture'); - ev('__GE=0;for(let i=0;i<10;i++){__T+=16;draw(__T);}'); + // Panning brings new cities into view, whose pictures are sent: they are checked at most once a second (each read + // waits for the card), the first time a second after the first frame's check. + const pan = JSON.parse(ev(`(()=>{let sent=0,reads=0,most=0,at=[];for(let i=0;i<120;i++){const s=__SUB,g=__GE;cam.x+=3;__T+=16;draw(__T); + if(__SUB>s)sent++;if(__GE>g){reads++;at.push(i);}most=Math.max(most,__GE-g);}return JSON.stringify({sent,reads,most,at});})()`)); + assert.ok(pan.sent > 5, 'frames send pictures'); + assert.ok(pan.reads >= 1 && pan.reads <= 2, `about two seconds of panning read the errors once or twice, not once per frame that sends (${JSON.stringify(pan)})`); + assert.ok(pan.most <= 4, 'one check reads at most four flags'); + // The pan's last pictures are still to be checked: once, on the next frame a second on. Then a still map reads nothing. + ev('__GE=0;__T+=1100;draw(__T);'); + assert.ok(ev('__GE') <= 4, 'the pictures left over are checked once'); + ev('__GE=0;for(let i=0;i<10;i++){__T+=1100;draw(__T);}'); assert.equal(ev('__GE'), 0, 'a still map reads nothing'); assert.deepEqual(errors, []); }); @@ -109,6 +113,21 @@ test('a picture the card refuses without throwing gives the map to 2D in the sam assert.deepEqual(errors, []); }); +// The card keeps an error until it is read: a picture refused between two checks is found by the next one. +test('a picture refused after the first check gives the map to 2D within a second', () => { + const { ev, errors } = open({}); + assert.equal(ev('glInit()'), true); + ev('UI.tickErr=false;const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;__T+=16;draw(__T);'); + assert.equal(ev('GLX.dead'), false); + ev('__FAIL.sprites=true;'); + const n = ev('(()=>{let i=0;for(;i<120&&!GLX.dead;i++){cam.x+=5;__T+=16;draw(__T);}return i;})()'); + assert.equal(ev('GLX.dead'), true, 'given up'); + assert.ok(n * 16 <= 1000 + 32, `within a second (${n} frames)`); + assert.equal(ev('SPRS.size'), 0, 'no picture is kept as sent'); + assert.equal(ev('!!UI.tickErr'), false, 'no glitch for the player'); + assert.deepEqual(errors, []); +}); + /* Given up for good while the context still lives (memory refused), the card kept the atlas (64 MB at 4096 px) and the rest while the 2D map began painting its own pictures. glKill() now deletes the biggest and lets the context go. */ test('giving the card up for good frees what it holds and lets the context go, and the frame is drawn in 2D', () => { From 8c2000f6b1241b3b856e59d163c9c865532e5ff9 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:10:29 +0100 Subject: [PATCH 22/23] CHANGELOG: one bullet per change players will see The WebGL work had eight bullets, so with upstream's three the app's What's new (five bullets) showed only two of ours, and four described fixes to the WebGL map itself, which no release has had: a zoom that lost the context, the cities repainted at every step of a zoom, the coastlines' points, the garbage per frame. What a player gets from them goes into the first bullet (smooth zooms, the coastlines, Always 2D freeing the card, a lost card coming back), which leaves four, each with the pull request's number. --- CHANGELOG.md | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 32a06d4..57e00c3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,14 +9,10 @@ All notable changes to this project are documented here. The project follows - The NOC charts have tooltips, on the dashboard and on the wallboard in the NOC window: hover (or touch) a chart to see every series on that day, with a total. Click an entry in the legend to hide or show that series, and the scale follows what is left. The "how it arrives" bars on the Traffic tab show the same kind of tooltip, and its legend picks which ways in (caches, PNIs, IX peering, transit) the table counts. - Bilbao joins the map, where the transatlantic cables really come ashore: Marea Carey, Grace Hopscotch and Sol Survivor now land there instead of Madrid. It has no exchange of its own, so traffic heads inland to Madrid, and Drizzle Electric, Tangerine Telecom and the big carriers sell transit there. A link you already run on the old Madrid landings keeps working as a plain subsea link, and the Mid-Atlantic Accent scenario now goes Azores, Bilbao, Madrid, and Marea Carey now leaves the American coast at Virginia Beach instead of crossing the northeast to New Jersey. Columbus III-and-a-half now comes ashore near Cádiz, where it really landed, on its way to Madrid. - Puzzles are easier to read, above all on phones: the three stars are now three goals in plain words, and the one you are working on says what is wrong and what to do, with a Show me button. The map marks it too: a red ring around a city that still needs traffic, and a pulsing ✂ on a link whose cut would hurt. On phones the sheet starts small so the map gets the screen; swipe it up for the rest. Cities far from the puzzle are left off the map, and stepping stones you are not using are small dots without a name until you tap one, build there or zoom in. -- The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same; Settings › Map drawing › Always 2D keeps the old drawing, and browsers without WebGL2 or without a usable graphics card keep it on their own, as does a game whose graphics card fails while you play. -- Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the usual map also draws far fewer shapes each frame. -- Long zooms stay on the graphics card: the pictures of cities and labels are painted on one shared canvas instead of each keeping its own, so the browser no longer runs out of room for them and switches to the slower drawing. -- Zooming is smoother on big maps: while you zoom, cities and ships keep their picture and are only redrawn sharp once the zoom stops, instead of being repainted at every small step. -- The graphics card draws the coastlines with fewer points when you zoom out, where the extra detail was smaller than a pixel, so the map costs it a lot less work, which helps phones most. -- The map leaves far less memory behind it on every frame for the browser to clean up while you play. -- In Firefox on a computer, the 2D map is up to three times as fast when zoomed in: its land picture now stays on the graphics card instead of being sent to it again on every frame. Firefox on Android keeps the old way, which avoids its drawing glitches. -- Settings › Viewport info is now Diagnostic info: besides your screen's size, it shows how the map is drawn (by the graphics card or in 2D, and why) and how fast, ready to copy into a bug report. +- The map is now drawn by the graphics card wherever the browser can, so panning, zooming and fast play stay smooth on big networks and big screens. The map looks the same, and zoomed out the card draws the coastlines with fewer points where the extra detail was smaller than a pixel, which helps phones most. Settings › Map drawing › Always 2D keeps the old drawing and frees what the graphics card held, and browsers without WebGL2 or without a usable graphics card keep it on their own. If the graphics card stops for a moment (on a phone, switching apps can do that), the map is drawn in 2D until it is back, and stays in 2D for a game where it keeps failing. (#281) +- Cities, labels, building cones, ships, offer bubbles and money pop-ups are painted once and then reused, so the map also draws far fewer shapes each frame. (#281) +- In Firefox on a computer, the 2D map is up to three times as fast when zoomed in: its land picture now stays on the graphics card instead of being sent to it again on every frame. Firefox on Android keeps the old way, which avoids its drawing glitches. (#281) +- Settings › Viewport info is now Diagnostic info: besides your screen's size, it shows how the map is drawn (by the graphics card or in 2D, and why) and how fast, ready to copy into a bug report. (#281) ## [2.9.1] — 2026-11-04 From c3e1dd93485aa38c93dfbdda2c738c9c98648490 Mon Sep 17 00:00:00 2001 From: Antoine <20756073+antt0n@users.noreply.github.com> Date: Thu, 5 Nov 2026 00:59:38 +0100 Subject: [PATCH 23/23] WebGL map: keep each picture in a clear border in the atlas The card blends the texels around the point it reads, so a picture drawn off whole pixels, or stretched while a zoom moves, read half a texel past its edge: its neighbour in the atlas, or a picture left from before the last reset. The map showed thin coloured lines along the edges of cities and labels. Each picture now goes in with a clear one-texel border, and painting on the pad is clipped to the picture so the border stays clear. --- src/game/96-map/59-gl-sprites.js | 27 ++++++++++------ tests/webgl-sprites.test.js | 53 +++++++++++++++++++++++++++++++- 2 files changed, 70 insertions(+), 10 deletions(-) diff --git a/src/game/96-map/59-gl-sprites.js b/src/game/96-map/59-gl-sprites.js index 309c1d7..997e7a1 100644 --- a/src/game/96-map/59-gl-sprites.js +++ b/src/game/96-map/59-gl-sprites.js @@ -45,7 +45,11 @@ function spritesReset(){glsDrawNow();for(const e of SPRC.values())sprFree(e);SPR function spritesDrop(){GLS.n=GLS.up=0;GLS.upq=false;SPRS.clear();GLS.shx=GLS.shy=GLS.shh=0;} /* The card's pictures are painted on one canvas, reused, and each goes into the atlas as soon as it is painted: a canvas kept per picture made the browser hold thousands of them while you zoomed, until it lost the graphics context - and the map fell back to 2D. The 2D map, and a picture too big for the atlas, keep their own canvas. */ + and the map fell back to 2D. The 2D map, and a picture too big for the atlas, keep their own canvas. + Each picture goes in with a clear border of GLS_GAP px: the card blends the texels around the point it reads, so a + picture drawn off whole pixels or a little stretched read half a texel past its edge, and showed a thin line of its + neighbour in the atlas (or of a picture from before the last reset, which leaves the texture as it was). */ +const GLS_GAP=1; const GLS_PAD={cv:null,g:null}; function glsPad(pw,ph){const P=GLS_PAD;if(!P.cv){P.cv=document.createElement('canvas');P.cv.width=P.cv.height=256;} if(P.cv.width=SPR_MAX)spritesReset(); const pw=Math.ceil(w*DPR),ph=Math.ceil(h*DPR),saved=ctx; e={cv:null,pw,ph,w,h,ax,ay,up:false,u0:0,v0:0,u1:1,v1:1,f:SPR_F}; - if(gpu&&pw<=GLS.size&&ph<=GLS.size){const P=glsPad(pw,ph),g=P.g; - g.save();g.setTransform(1,0,0,1,0,0);g.clearRect(0,0,pw,ph);ctx=g; - try{g.setTransform(DPR,0,0,DPR,0,0);sprPen(g);paint(g);}finally{ctx=saved;g.restore();} + const G=GLS_GAP; + if(gpu&&pw+2*G<=GLS.size&&ph+2*G<=GLS.size){const P=glsPad(pw+2*G,ph+2*G),g=P.g; + // Clipped to the picture, as its own canvas would be, so the border stays clear. + g.save();g.setTransform(1,0,0,1,0,0);g.clearRect(0,0,pw+2*G,ph+2*G);g.beginPath();g.rect(G,G,pw,ph);g.clip();ctx=g; + try{g.setTransform(DPR,0,0,DPR,G,G);sprPen(g);paint(g);}finally{ctx=saved;g.restore();} // A full atlas starts again (glsPut), and the picture goes into the empty one at once: the pad is reused next. try{if(!glsPut(GLX.gl,e,P.cv))glsPut(GLX.gl,e,P.cv);}catch(x){throw glErr(x);} }else{const cv=document.createElement('canvas');cv.width=pw;cv.height=ph;const g=cv.getContext('2d');ctx=g; @@ -74,16 +80,19 @@ function spriteEntry(key,w,h,ax,ay,paint){const M=sprMap(),gpu=M===SPRS;let e=M. the cones' tips and a sleeping POP's "zzz" took those, and a new canvas has others (square ends, text on its baseline). */ function sprPen(g){g.lineCap='round';g.lineJoin='round';g.textAlign='center';g.textBaseline='middle';} // Puts a picture with its own canvas into the atlas (once), shelf by shelf. A full atlas starts again; this picture then waits a frame. -function glsEnsure(e){if(e.up)return true;const gl=GLX.gl;if(!gl||!GLS.prog||!e.cv)return false; - try{return glsPut(gl,e,e.cv);}catch(x){throw glErr(x);}} -function glsPut(gl,e,src){const pw=e.pw,ph=e.ph,A=GLS.size;if(pw>A||ph>A)return false; +function glsEnsure(e){if(e.up)return true;const gl=GLX.gl,G=GLS_GAP;if(!gl||!GLS.prog||!e.cv)return false; + if(e.pw+2*G>GLS.size||e.ph+2*G>GLS.size)return false; + const P=glsPad(e.pw+2*G,e.ph+2*G),g=P.g;g.setTransform(1,0,0,1,0,0);g.clearRect(0,0,e.pw+2*G,e.ph+2*G);g.drawImage(e.cv,G,G); + try{return glsPut(gl,e,P.cv);}catch(x){throw glErr(x);}} +// src holds the picture at (GLS_GAP,GLS_GAP), in a clear border that goes into the atlas with it. +function glsPut(gl,e,src){const G=GLS_GAP,pw=e.pw+2*G,ph=e.ph+2*G,A=GLS.size;if(pw>A||ph>A)return false; if(GLS.shx+pw>A){GLS.shx=0;GLS.shy+=GLS.shh;GLS.shh=0;} if(GLS.shy+ph>A){spritesReset();return false;} const x=GLS.shx,y=GLS.shy;GLS.shx+=pw;GLS.shh=Math.max(GLS.shh,ph); gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,true); - // Only the picture's corner of the source: the pad is bigger than most pictures. + // Only the picture's corner of the source (with its border): the pad is bigger than most pictures. gl.texSubImage2D(gl.TEXTURE_2D,0,x,y,pw,ph,gl.RGBA,gl.UNSIGNED_BYTE,src);gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false); - GLS.up++;Object.assign(e,{up:true,u0:x/A,v0:y/A,u1:(x+pw)/A,v1:(y+ph)/A});return true;} + GLS.up++;Object.assign(e,{up:true,u0:(x+G)/A,v0:(y+G)/A,u1:(x+pw-G)/A,v1:(y+ph-G)/A});return true;} // The next record in GLS.data, which grows as needed: take it before reading GLS.data, which it may replace. function glsNext(){if((GLS.n+1)*SPR_STRIDE>GLS.data.length){const nd=new Float32Array(GLS.data.length*2);nd.set(GLS.data);GLS.data=nd;}return GLS.n++*SPR_STRIDE;} // Draws a picture at (x,y) of w×h CSS px, on the card for a frame drawn there, else with the 2D canvas. diff --git a/tests/webgl-sprites.test.js b/tests/webgl-sprites.test.js index cf7665c..95d4874 100644 --- a/tests/webgl-sprites.test.js +++ b/tests/webgl-sprites.test.js @@ -47,6 +47,57 @@ test('on the card, pictures are painted on one canvas and each goes into the atl assert.deepEqual(errors, []); }); +// The card blends the texels around the point it reads: a picture drawn off whole pixels, or stretched while a zoom +// moves, read half a texel past its edge, and the map showed thin coloured lines around cities (its neighbour in the +// atlas, or a picture from before the last reset). So each picture goes in with a clear border, and never touches another. +test('on the card, every picture sits in the atlas in a clear border of its own', () => { + const { ev, errors } = open(); + ev(STUB); + // What the pad is asked to do for each picture: cleared, clipped to the picture, painted inside the border. + ev(`(()=>{const P=glsPad(1,1),g=P.g;window.__pad=[];for(const k of ['clearRect','rect','setTransform'])g[k]=(...a)=>__pad.push([k,...a]);})()`); + ev(ZOOM); + const r = JSON.parse(ev(`(()=>{const A=GLS.size,G=GLS_GAP,es=[...SPRS.values()].filter(e=>e.up); + const R=es.map(e=>({x0:Math.round(e.u0*A),y0:Math.round(e.v0*A),x1:Math.round(e.u1*A),y1:Math.round(e.v1*A),e})); + const exact=R.every(q=>q.x1-q.x0===q.e.pw&&q.y1-q.y0===q.e.ph); + const inside=R.every(q=>q.x0>=G&&q.y0>=G&&q.x1+G<=A&&q.y1+G<=A); + let touch=0;for(let i=0;ic[0]==='texSubImage2D').slice(-es.length); + const sent=subs.every(c=>R.some(q=>c[3]===q.x0-G&&c[4]===q.y0-G&&c[5]===q.e.pw+2*G&&c[6]===q.e.ph+2*G)); + // Each picture: clearRect(0,0,W,H), then rect(G,G,W-2G,H-2G) for the clip, then the transform that paints inside it. + const at=__pad.flatMap((c,i)=>c[0]==='clearRect'?[i]:[]),nx=(i,k)=>__pad[i+k]||[]; + return JSON.stringify({n:es.length,exact,inside,touch,sent,G, + cleared:at.length>=es.length&&at.every(i=>nx(i,0)[1]===0&&nx(i,0)[2]===0), + clipped:at.every(i=>{const c=nx(i,0),q=nx(i,1);return q[0]==='rect'&&q[1]===G&&q[2]===G&&q[3]===c[3]-2*G&&q[4]===c[4]-2*G;}), + offset:at.every(i=>{const q=nx(i,2);return q[0]==='setTransform'&&q[5]===G&&q[6]===G;})});})()`)); + assert.ok(r.n > 50, `a zoom paints many pictures (${r.n})`); + assert.ok(r.G >= 1, 'a border of at least one texel'); + assert.equal(r.exact, true, 'the picture’s own texels are read, no more'); + assert.equal(r.inside, true, 'with room for its border inside the atlas'); + assert.equal(r.touch, 0, 'no two pictures (with their borders) overlap or touch'); + assert.equal(r.sent, true, 'each was sent with its border'); + assert.equal(r.cleared, true, 'the pad is cleared from its corner, border included'); + assert.equal(r.clipped, true, 'painting is clipped to the picture, so the border stays clear'); + assert.equal(r.offset, true, 'and starts inside the border'); + assert.deepEqual(errors, []); +}); + +test('a picture with its own canvas goes into the atlas in a clear border too', () => { + const { ev, errors } = open(); + ev(STUB); + const r = JSON.parse(ev(`(()=>{const e=spriteEntry('own',20,10,10,5,g=>{g.fillRect(0,0,20,10);}); + const P=glsPad(1,1),g=P.g,log=[];g.clearRect=(...a)=>log.push(['clear',...a]);g.drawImage=(cv,x,y)=>log.push(['draw',cv===e.cv,x,y]); + const ok=glsEnsure(e),A=GLS.size,G=GLS_GAP,s=GLX.gl.calls.filter(c=>c[0]==='texSubImage2D').pop(); + return JSON.stringify({cv:!!e.cv,ok,log,G,u0:e.u0*A,v0:e.v0*A,u1:e.u1*A,v1:e.v1*A,pw:e.pw,ph:e.ph,sent:s.slice(3,7),pad:s[9]===P.cv});})()`)); + assert.equal(r.cv, true, 'painted outside a card frame, so with its own canvas'); + assert.equal(r.ok, true); + assert.deepEqual(r.log, [['clear', 0, 0, r.pw + 2 * r.G, r.ph + 2 * r.G], ['draw', true, r.G, r.G]], 'copied into a cleared pad, inside the border'); + assert.deepEqual([r.u0, r.v0, r.u1, r.v1], [r.G, r.G, r.G + r.pw, r.G + r.ph]); + assert.deepEqual(r.sent, [0, 0, r.pw + 2 * r.G, r.ph + 2 * r.G]); + assert.equal(r.pad, true); + assert.deepEqual(errors, []); +}); + test('a full atlas starts again and the picture that did not fit goes into the new one at once', () => { const { ev, errors } = open(); ev(STUB); @@ -55,7 +106,7 @@ test('a full atlas starts again and the picture that did not fit goes into the n const e=spriteEntry('big',40,40,20,20,g=>{g.fillRect(0,0,40,40);});blit(e,10,10,40,40); glsDraw=gd;const r={up:e.up,u0:e.u0,v0:e.v0,kept:SPRS.get('big')===e,size:SPRS.size,n:GLS.n,cv:!!e.cv,shy:GLS.shy};GLS.frame=false;GLS.n=0;ctx=CTX0;return JSON.stringify(r);})()`)); assert.equal(r.up, true, 'the picture is in the atlas'); - assert.equal(r.u0, 0); assert.equal(r.v0, 0); + assert.equal(r.u0, 1 / 4096, 'at the start of the new atlas, past its clear border'); assert.equal(r.v0, 1 / 4096); assert.equal(r.kept, true, 'and kept under its key after the restart'); assert.equal(r.size, 1, 'the old pictures are gone'); assert.equal(r.n, 1, 'drawn this frame');