Versione 0.1.73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GiECd9RWGMKV7n3K1mdy8T

.gitea/workflows/test.yml

@@ -0,0 +1,68 @@
+# Le Gitea Actions del gioco: girano sul runner del PC di Andrea (make runner; label ubuntu-latest = node:22-bookworm).
+# A ogni push su main e a ogni tag i test unitari; su un tag vX.Y.Z (o a mano, «Run workflow») anche le venti prove nel
+# browser, una per job nell'immagine di Playwright, sulla scheda video del PC; se passa tutto, la release.
+# Il controllo dei file pubblicabili non sta qui (a pipeline partita il push è già pubblico): è l'hook pre-push.
+name: test
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Test unitari
+        run: node --version && node --test tests/*.test.mjs
+
+  # Le prove nel browser, una per job: l'elenco è SUITES di scripts/verify.mjs (verify.test.mjs pretende che coincidano),
+  # l'immagine ha la stessa versione di Playwright di package-lock.json (idem).
+  browser:
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    container:
+      image: mcr.microsoft.com/playwright:v1.64.1-noble
+      # La scheda video del PC (runtime NVIDIA di Docker): Chromium disegna lì, tests/chromium.mjs la trova da solo.
+      options: --gpus all -e NVIDIA_DRIVER_CAPABILITIES=all
+    strategy:
+      fail-fast: false
+      matrix:
+        prova: [principale, minigiochi, telefoni, ambient, veicoli, ingorgo, smarronata, briscola, tressette, scopa, biliardo, flipper, micro, cerbottana, condor, campana, bruciate, gara, telefono, risveglio, peso]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Playwright
+        run: npm ci --no-audit --no-fund
+      - name: Prova ${{ matrix.prova }}
+        run: node scripts/verify.mjs ${{ matrix.prova }}
+
+  release:
+    needs: [test, browser]
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Release del tag
+        env:
+          TOKEN: ${{ secrets.GITEA_TOKEN }}
+          TAG: ${{ github.ref_name }}
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+        run: |
+          prev=$(git describe --tags --abbrev=0 "$TAG^" 2>/dev/null || true)
+          {
+            echo "Si gioca su https://50037.manzolo.it; qui sotto lo zip di questa versione."
+            echo
+            echo "Cosa cambia${prev:+ da $prev}:"
+            echo
+            git log --no-merges --format='- %s' ${prev:+$prev..}"$TAG" | grep -v -e '^- Versione [0-9]' | cut -c1-400
+          } > note.md
+          node -e 'const fs=require("fs");process.stdout.write(JSON.stringify({tag_name:process.env.TAG,name:"Versione "+process.env.TAG.slice(1),body:fs.readFileSync("note.md","utf8")}))' > release.json
+          code=$(curl -s -o risposta.json -w '%{http_code}' -X POST -H "Authorization: token $TOKEN" -H 'Content-Type: application/json' --data @release.json "$API/releases")
+          cat risposta.json | head -c 400; echo
+          [ "$code" = 201 ] || [ "$code" = 409 ]

.gitignore

@@ -7,3 +7,4 @@ assets/generated/
 .venv/
 .env
 deploy.local.mk
+.verify-ok.json

CLAUDE.md

@@ -16,9 +16,19 @@ i suoi ricordi: non inventare persone, luoghi o fatti del paese al posto suoi; p
   (`tools/slice_sprites.py`, `scripts/build-site.sh`, `scripts/bump.sh`, `scripts/check-public.sh`, action di Pages).
 - Nessun build step: ES modules statici, server locale con `python3 -m http.server`.
 - Ogni funzionalità con il suo test; un test automatico percorre tutta la soluzione dell'avventura.
-- Verifica visiva nel browser con Playwright e swiftshader prima di dichiarare finito qualcosa di grafico.
+- Le prove nel browser sono a sezioni (`scripts/verify.mjs`, dal 2026-11-01): `make verify` rifà solo quelle i cui ingressi
+  sono cambiati dall'ultimo verde (la briscola se cambia la briscola, la partita intera se cambiano storia, motore, stile
+  o risorse). Un `chromium.launch` nuovo nelle prove usa `args: ARGS` di `tests/chromium.mjs`.
+  Gli effetti pesanti li scopre la prova `peso` (`tests/peso.browser.mjs`): sempre con swiftshader, misura arretrato grafico e
+  fotogrammi di ogni scena e primo piano; si rifà quando cambia un disegno (`*-render.js`, `render.js`, effetti). Una prova nuova in `tests/*.browser.mjs` va aggiunta a `SUITES` (il test `verify.test.mjs` lo pretende).
+- Verifica visiva nel browser con Playwright prima di dichiarare finito qualcosa di grafico. Chromium disegna sulla scheda
+  video del PC se c'è, altrimenti con swiftshader (`tests/chromium.mjs`, dal 2026-11-01: giro intero ~4 min invece di ~16).
 - Pubblicare (tag/bump/push) solo quando Andrea lo chiede.
 - Persone vere nel gioco solo con consenso; niente nomi, personaggi o musiche di giochi esistenti.
 - Prompt delle immagini in `prompts/` e fogli grezzi in `assets/raw/`: esclusi da git.
 - Sfondi nuovi: li genera **Codex** con il suo strumento immagini integrato, gratis e senza chiave API
   (`codex exec`, ricetta in `docs/GENERAZIONE_SFONDI.md`, «Generare con Codex»). Si lancia da qui, senza chiedere la chiave ad Andrea.
+- **Pubblicare (dal 2026-11-01)**: origin è https://git.manzolo.it/manzolo/leggenda-del-regolo, pubblico: prima `make check-public`, poi `git push origin main --tags`, solo se Andrea lo chiede.
+  `make deploy` costruisce l'immagine dal tag della versione, la spinge su `git.manzolo.it/manzolo/leggenda-regolo:vX.Y.Z` (e `:latest`); sul VPS il compose fissa quel tag e fa `docker compose pull && up -d`.
+  Per tornare indietro: sul VPS (`Workspaces/docker/leggenda-regolo/docker-compose.yml`) si rimette il tag precedente e si rifà pull e up.
+  Hook pre-push (`make hooks`, una volta per clone) lancia check-public; le Gitea Actions (`.gitea/workflows/test.yml`: test unitari a ogni push; sui tag, o a mano, anche le venti prove nel browser, una per job, poi la release) girano sul runner del PC, che si crea o riavvia con `make runner`.

Makefile

@@ -23,8 +23,8 @@ DST         ?= assets/scenes/$(notdir $(SRC))
 CROP        ?=
 COLORS      ?= 64
 
-.PHONY: help serve open test browser verify check-public bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
-        build up down restart logs ps shell image-size deploy deploy-vps deploy-logs clean distclean
+.PHONY: help serve open test browser verify verify-browser verify-plan check-public hooks bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
+        build up down restart logs ps shell image-size deploy deploy-logs runner clean distclean
 
 ## ------------------------------------------------------------ sviluppo
 
@@ -47,14 +47,26 @@ test: ## Test della logica, della storia, della soluzione completa e del generat
 	$(NODE) --test tests/*.test.mjs
 	$(PYTHON) -m unittest discover -s tests -p "test_*.py" -q
 
-browser: ## Partita completa nel browser con Playwright
+browser: ## Partita completa nel browser con Playwright (tre parti in processi paralleli, ~4,5 min)
 	$(NODE) tests/browser.mjs
 
-verify: test browser check-public ## Tutti i controlli
+verify: test check-public verify-browser ## Tutti i controlli: test unitari, file pubblicabili, prove nel browser cambiate (ALL=1: tutte)
+
+# Le prove nel browser a sezioni: si rifanno solo quelle i cui ingressi sono cambiati dall'ultimo verde (.verify-ok.json,
+# fuori da git); make verify-browser ALL=1 le rifà tutte, make verify-plan dice solo cosa rifarebbe; JOBS=2 in parallelo (con 4 vanno in timeout).
+verify-browser: ## Le prove nel browser da rifare (ALL=1 tutte; PROVE="briscola flipper" solo quelle)
+	$(NODE) scripts/verify.mjs $(if $(ALL),--all,) $(PROVE)
+
+verify-plan: ## Dice quali prove nel browser rifarebbe make verify, e perché
+	$(NODE) scripts/verify.mjs --plan
 
 check-public: ## Prima di pubblicare: niente prompt, fogli grezzi, segreti o nomi della rete di casa (tutta la storia)
 	bash scripts/check-public.sh
 
+hooks: ## Attiva gli hook del repo (pre-push: check-public prima di ogni push)
+	git config core.hooksPath scripts/git-hooks
+	@echo "hook attivi da scripts/git-hooks: $$(ls scripts/git-hooks | tr '\n' ' ')"
+
 bump: ## Nuova versione (PARTE=patch|minor|major): verifica, commit e tag v<versione>; poi make deploy
 	scripts/bump.sh $(or $(PARTE),patch)
 
@@ -121,47 +133,53 @@ image-size: ## Dimensione dell'immagine
 
 ## ------------------------------------------------------------ deploy su un server proprio
 
-# Host e indirizzo stanno in deploy.local.mk, fuori da git, per esempio:
-#   DEPLOY_HOST = root@mio-server
-#   DEPLOY_URL  = https://gioco.esempio
-#   VPS_HOST    = mio-vps                    (facoltativo: una seconda copia, con make deploy-vps)
-#   VPS_DIR     = docker/leggenda-regolo
+# Host e cartella stanno in deploy.local.mk, fuori da git, per esempio:
+#   DEPLOY_HOST  = root@mio-server
+#   DEPLOY_URL   = https://gioco.esempio
+#   DEPLOY_DIR   = docker/leggenda-regolo   (la cartella del compose sul server)
+#   DEPLOY_IMAGE = registry.esempio/utente/leggenda-regolo
 -include deploy.local.mk
-DEPLOY_DIR  ?= /root/leggenda-regolo
-DEPLOY_TMP  := $(shell mktemp -d -u /tmp/regolo-deploy.XXXXXX)
+DEPLOY_DIR   ?= /root/leggenda-regolo
+DEPLOY_IMAGE ?= git.manzolo.it/manzolo/leggenda-regolo
+DEPLOY_TMP   := $(shell mktemp -d -u /tmp/regolo-deploy.XXXXXX)
+# La versione dell'ultimo commit (non della cartella di lavoro): il tag git, dell'immagine e del compose.
+DEPLOY_VER   := v$(shell git show HEAD:src/version.js 2>/dev/null | sed -n "s/.*VERSION = '\([^']*\)'.*/\1/p")
 
-# Si pubblica l'ultimo commit (git archive HEAD), mai la cartella di lavoro: un'altra sessione può avere modifiche a
-# metà. Test su quella copia, immagine costruita e provata qui, poi spedita già pronta (docker save | docker load):
-# sul server non si compila niente.
+# Si pubblica il tag della versione dichiarata dall'ultimo commit (git archive vX.Y.Z, quello di make bump), mai la
+# cartella di lavoro: un'altra sessione può avere modifiche a metà, e i commit dopo il tag aspettano la versione dopo.
+# Test su quella copia, immagine costruita e provata qui, spinta sul registry di Gitea come :vX.Y.Z e :latest; il
+# VPS la scarica con il tag scritto nel suo compose (preso da HEAD, docker-compose.deploy.yml).
 SMOKE_PORT  ?= 18737
-deploy: ## Pubblica l'ultimo commit: test, immagine costruita e provata qui, spedita al server e riavviata
+deploy: ## Pubblica la versione dell'ultimo commit: test, immagine provata qui, push sul registry, pull e riavvio sul server
 	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }
-	mkdir -p $(DEPLOY_TMP) && git archive HEAD | tar -x -C $(DEPLOY_TMP)
+	@git rev-parse -q --verify 'refs/tags/$(DEPLOY_VER)' >/dev/null || { echo "manca il tag $(DEPLOY_VER): prima make bump"; exit 2; }
+	mkdir -p $(DEPLOY_TMP) && git archive $(DEPLOY_VER) | tar -x -C $(DEPLOY_TMP)
 	cd $(DEPLOY_TMP) && $(NODE) --test tests/*.test.mjs
-	docker build -q -t $(IMAGE):latest -t $(IMAGE):$$(git rev-parse --short HEAD) $(DEPLOY_TMP)
+	docker build -q -t $(DEPLOY_IMAGE):$(DEPLOY_VER) -t $(DEPLOY_IMAGE):latest $(DEPLOY_TMP)
 	@docker rm -f $(IMAGE)-prova >/dev/null 2>&1 || true
-	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(IMAGE):latest >/dev/null
+	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(DEPLOY_IMAGE):$(DEPLOY_VER) >/dev/null
 	@ok=1; sleep 1; for u in / /src/main.js /assets/voices/index.json /assets/audio/cartello.mp3; do \
 	  c=$$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:$(SMOKE_PORT)$$u); echo "  prova $$u → $$c"; [ "$$c" = 200 ] || ok=0; done; \
 	  docker rm -f $(IMAGE)-prova >/dev/null; [ $$ok = 1 ] || { echo "l'immagine non risponde come deve: non la spedisco"; exit 1; }
-	ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR)'
-	scp -q $(DEPLOY_TMP)/docker-compose.homeserver.yml $(DEPLOY_HOST):$(DEPLOY_DIR)/docker-compose.yml
-	docker save $(IMAGE):latest | gzip | ssh $(DEPLOY_HOST) 'gunzip | docker load -q && cd $(DEPLOY_DIR) && docker compose up -d && docker image prune -f >/dev/null'
+	docker push -q $(DEPLOY_IMAGE):$(DEPLOY_VER)
+	docker push -q $(DEPLOY_IMAGE):latest
+	git show HEAD:docker-compose.deploy.yml | sed 's|$(DEPLOY_IMAGE):VERSIONE|$(DEPLOY_IMAGE):$(DEPLOY_VER)|' | \
+	  ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR) && cat > $(DEPLOY_DIR)/docker-compose.yml'
+	ssh $(DEPLOY_HOST) 'cd $(DEPLOY_DIR) && docker compose pull -q && docker compose up -d && \
+	  docker image ls $(DEPLOY_IMAGE) --format "{{.Repository}}:{{.Tag}}" | grep -v -x -e $(DEPLOY_IMAGE):$(DEPLOY_VER) | xargs -r docker image rm >/dev/null; \
+	  docker image prune -f >/dev/null'
 	rm -rf $(DEPLOY_TMP)
-	@# Sul server il prune toglie l'immagine vecchia; qui restano solo latest e quella appena pubblicata.
-	@docker image ls $(IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $$(git rev-parse --short HEAD) | \
-	  xargs -r -I{} docker image rm -f $(IMAGE):{} >/dev/null
-	@echo "→ $(DEPLOY_URL) ($$(git log -1 --format='%h %s'))"
+	@# Qui restano solo latest e la versione appena pubblicata.
+	@docker image ls $(DEPLOY_IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $(DEPLOY_VER) | \
+	  xargs -r -I{} docker image rm -f $(DEPLOY_IMAGE):{} >/dev/null
+	@# L'indirizzo pubblico deve servire la versione appena spedita.
+	@v=$$(git show $(DEPLOY_VER):src/version.js | grep -o "VERSION = '[^']*'"); \
+	  for i in 1 2 3 4 5; do curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" && break; sleep 2; done; \
+	  curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" || { echo "$(DEPLOY_URL) non serve $$v"; exit 1; }
+	@echo "→ $(DEPLOY_URL) ($(DEPLOY_IMAGE):$(DEPLOY_VER), $$(git log -1 --format='%h %s' $(DEPLOY_VER)))"
 
-deploy-vps: ## Spedisce al VPS (VPS_HOST, VPS_DIR in deploy.local.mk) l'immagine dell'ultimo commit già provata da make deploy
-	@test -n "$(VPS_HOST)" -a -n "$(VPS_DIR)" || { echo "mancano VPS_HOST e VPS_DIR: scrivili in deploy.local.mk"; exit 2; }
-	@docker image inspect $(IMAGE):$$(git rev-parse --short HEAD) >/dev/null 2>&1 || \
-	  { echo "manca l'immagine dell'ultimo commit ($$(git rev-parse --short HEAD)): prima make deploy"; exit 1; }
-	ssh $(VPS_HOST) 'mkdir -p $(VPS_DIR)'
-	git show HEAD:docker-compose.homeserver.yml | ssh $(VPS_HOST) 'cat > $(VPS_DIR)/docker-compose.yml'
-	docker save $(IMAGE):$$(git rev-parse --short HEAD) $(IMAGE):latest | gzip | \
-	  ssh $(VPS_HOST) 'gunzip | docker load -q && cd $(VPS_DIR) && docker compose up -d && docker image prune -f >/dev/null'
-	@ssh $(VPS_HOST) "docker exec $(IMAGE) grep -o \"VERSION = '[^']*'\" /usr/share/nginx/html/src/version.js" | sed 's/^/→ $(VPS_HOST): /'
+runner: ## Crea (se manca) e avvia sul PC il runner delle Gitea Actions (tools/gitea-runner, scripts/runner.sh)
+	bash scripts/runner.sh
 
 deploy-logs: ## Log del container sul server di deploy
 	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }

README.md

@@ -23,7 +23,9 @@ Si gioca online su **https://50037.manzolo.it** (50037 è il CAP di San Piero),
 
 ## Giocare in locale
 
-Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES.
+Il gioco si scarica da **https://git.manzolo.it/manzolo/leggenda-del-regolo**: nella pagina dei
+[tag](https://git.manzolo.it/manzolo/leggenda-del-regolo/tags) c'è lo zip di ogni versione (l'ultima è quella online).
+Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES. Dentro la cartella scompattata:
 
 ```zsh
 python3 -m http.server 8000     # poi http://localhost:8000
@@ -40,16 +42,16 @@ Oppure `make up` (Docker, su http://localhost:8080). Non aprire `index.html` con
 - `assets/`: sfondi, sprite, musiche, voci, carattere, video.
 - `tools/`: gli strumenti (sprite dai fogli, voci con XTTS, musiche sintetizzate, favicon, taratura dei minigiochi).
 - `tests/`: `npm test` (unità: regole, storia coerente, voci, salvataggi) e `npm run browser` (Playwright: percorre
-  tutta la soluzione dell'avventura, su desktop e telefono); `npm run browser:briscola`, `:tressette`, `:scopa`,
-  `:biliardo`, `:effects` per le parti singole.
+  tutta la soluzione dell'avventura, su desktop e telefono, in tre processi paralleli; `--parte=` per una sola);
+  `npm run browser:briscola`, `:tressette`, `:scopa`, `:biliardo`, `:effects` per le parti singole.
 - `video/`: i copioni dei video «Come si gioca» e della demo, girati in una macchina virtuale.
 - `docs/`: `PROGETTO.md` (l'idea, i personaggi, la mappa) e `STATO.md` (dove siamo, cosa manca).
 
 ```zsh
-make verify        # sintassi, test, prova nel browser: quello che gira prima di ogni versione
+make verify        # test, file pubblicabili e le prove nel browser cambiate dall'ultimo verde (ALL=1: tutte)
 make voci          # le voci delle battute nuove (XTTS-v2 su GPU)
 make bump          # nuova versione: verifica, commit e tag
-make deploy        # pubblica l'ultimo commit (immagine Docker spedita al server)
+make deploy        # pubblica la versione: immagine sul registry di Gitea, il server la scarica
 ```
 
 ## Chi ha fatto cosa

assets/characters/andrea-birra.json

@@ -0,0 +1,70 @@
+{
+ "image": "andrea-birra.png",
+ "height": 120,
+ "frames": {
+  "walk_1": {
+   "x": 0,
+   "y": 0,
+   "w": 68,
+   "h": 114,
+   "ax": 40.2,
+   "ay": 114
+  },
+  "walk_2": {
+   "x": 70,
+   "y": 0,
+   "w": 41,
+   "h": 114,
+   "ax": 20.7,
+   "ay": 114
+  },
+  "walk_3": {
+   "x": 113,
+   "y": 0,
+   "w": 67,
+   "h": 114,
+   "ax": 38.4,
+   "ay": 114
+  },
+  "walk_4": {
+   "x": 182,
+   "y": 0,
+   "w": 46,
+   "h": 114,
+   "ax": 25.3,
+   "ay": 114
+  },
+  "cheer_1": {
+   "x": 230,
+   "y": 0,
+   "w": 51,
+   "h": 133,
+   "ax": 21.1,
+   "ay": 133
+  },
+  "cheer_2": {
+   "x": 283,
+   "y": 0,
+   "w": 55,
+   "h": 130,
+   "ax": 24.5,
+   "ay": 130
+  },
+  "cheer_3": {
+   "x": 340,
+   "y": 0,
+   "w": 62,
+   "h": 130,
+   "ax": 23.8,
+   "ay": 130
+  },
+  "talk": {
+   "x": 404,
+   "y": 0,
+   "w": 58,
+   "h": 120,
+   "ax": 21.7,
+   "ay": 120
+  }
+ }
+}

assets/voices/index.json

@@ -691,9 +691,13 @@
   "file": "andrea-b830f3f8ca.mp3",
   "sec": 6.87
  },
- "andrea|Un ghiacciolo ci starebbe. Ma prima il palio, poi i ghiaccioli.": {
-  "file": "andrea-2669d0fea1.mp3",
-  "sec": 5.23
+ "andrea|Un ghiacciolo ci starebbe. Ma prima... il flipper.": {
+  "file": "andrea-737d8c7f64.mp3",
+  "sec": 4.56
+ },
+ "andrea|Dentro, in fondo, fra le figurine: il flipper. Con San Piero dipinto sulla tavola.": {
+  "file": "andrea-61a0d27bbb.mp3",
+  "sec": 6.67
  },
  "andrea|La farmacia, con la croce verde. Mia nonna ci veniva per le pasticche e per le chiacchiere. Più per le chiacchiere.": {
   "file": "andrea-1447e3515d.mp3",
@@ -1667,6 +1671,22 @@
   "file": "zio_mario-b3e99c241a.mp3",
   "sec": 2.68
  },
+ "andrea|E con la Ghiacciomobile nel muro, come si fa?": {
+  "file": "andrea-e964cb256d.mp3",
+  "sec": 2.69
+ },
+ "zio_mario|Siamo a cavallo al ciuco!": {
+  "file": "zio_mario-e74a044fb6.mp3",
+  "sec": 1.22
+ },
+ "andrea|Menomale tu ci sei te, Zio!": {
+  "file": "andrea-eea2bd2097.mp3",
+  "sec": 2.29
+ },
+ "zio_mario|Alla terza tu capisci subito, al volo!": {
+  "file": "zio_mario-4317f4b5f3.mp3",
+  "sec": 2.03
+ },
  "andrea|Il parcheggio sotto casa. Col gesso ci si disegnava la pista delle macchinine, e si giocava finché non chiamavano per cena.": {
   "file": "andrea-8670e6ce99.mp3",
   "sec": 7.6
@@ -1915,6 +1935,22 @@
   "file": "zio_mario-5773e3350f.mp3",
   "sec": 1.13
  },
+ "andrea|Sai, Zio? Son stato in California!": {
+  "file": "andrea-d8f8c38415.mp3",
+  "sec": 3.33
+ },
+ "zio_mario|E dov'è?": {
+  "file": "zio_mario-1cb1e2ca51.mp3",
+  "sec": 0.43
+ },
+ "andrea|In America!": {
+  "file": "andrea-8c8a45db81.mp3",
+  "sec": 0.85
+ },
+ "zio_mario|Ahhh... sopra Firenzola!": {
+  "file": "zio_mario-67279d2518.mp3",
+  "sec": 2.73
+ },
  "andrea|Le case coi balconi pieni di vasi: qui ogni finestra è un giardino.": {
   "file": "andrea-ec81875c47.mp3",
   "sec": 5.22
@@ -1939,9 +1975,9 @@
   "file": "andrea-2603f4db73.mp3",
   "sec": 5.93
  },
- "andrea|Si gira piano, sennò le bruciate si bruciano davvero.": {
-  "file": "andrea-675499a046.mp3",
-  "sec": 3.07
+ "andrea|Posso girare io la manovella?": {
+  "file": "andrea-8febc84325.mp3",
+  "sec": 1.75
  },
  "andrea|Una bruciata calda, presa al volo. Scotta! Ma è buonissima.": {
   "file": "andrea-ebba87b32c.mp3",
@@ -1971,18 +2007,6 @@
   "file": "andrea-bfd09556ea.mp3",
   "sec": 5.63
  },
- "andrea|Che Iddio ve ne renda merito!! A voi e agli alpini!": {
-  "file": "andrea-6933735b75.mp3",
-  "sec": 3.95
- },
- "volontari|E a te, figliolo. To', un cartoccio: son belle calde.": {
-  "file": "volontari-e8705fe901.mp3",
-  "sec": 5.14
- },
- "andrea|Scottano! Ma son buonissime.": {
-  "file": "andrea-ff81f048f5.mp3",
-  "sec": 2.79
- },
  "andrea|La fanfara degli alpini. Quando sfilavano per il paese suonando, s'affacciava tutto San Piero.": {
   "file": "andrea-a372a71849.mp3",
   "sec": 6.3
@@ -2647,6 +2671,54 @@
   "file": "vecchietto-c8eae2e59e.mp3",
   "sec": 4.88
  },
+ "andrea|Che Iddio ve ne renda merito!! A voi e agli alpini!": {
+  "file": "andrea-6933735b75.mp3",
+  "sec": 3.95
+ },
+ "andrea|Vi do una mano alla manovella?": {
+  "file": "andrea-1308ef4494.mp3",
+  "sec": 1.53
+ },
+ "andrea|Buon lavoro!": {
+  "file": "andrea-ade8043e82.mp3",
+  "sec": 0.71
+ },
+ "volontari|E a te, figliolo. To', un cartoccio: son belle calde.": {
+  "file": "volontari-e8705fe901.mp3",
+  "sec": 5.14
+ },
+ "andrea|Scottano! Ma son buonissime.": {
+  "file": "andrea-ff81f048f5.mp3",
+  "sec": 2.79
+ },
+ "volontari|Su, giovanotto, che noi s'ha le braccia stanche!": {
+  "file": "volontari-98d33dbfbd.mp3",
+  "sec": 2.43
+ },
+ "volontari|Si gira sempre uguale: piano piano sotto si bruciano, a furia volan nel fuoco. Quando son cotte, nel sacco.": {
+  "file": "volontari-7db485651b.mp3",
+  "sec": 8.77
+ },
+ "volontari|Come te la senti?": {
+  "file": "volontari-a104846cbf.mp3",
+  "sec": 0.88
+ },
+ "andrea|No, dopo.": {
+  "file": "andrea-78ad61a67a.mp3",
+  "sec": 1.22
+ },
+ "volontari|Alla bona: ti si guarda noi, e se si bruciano un si dice a nessuno.": {
+  "file": "volontari-5761a9776b.mp3",
+  "sec": 4.82
+ },
+ "volontari|Seria: la gente è in fila, e il cartoccio lo vole bello pieno.": {
+  "file": "volontari-dad04d4161.mp3",
+  "sec": 3.99
+ },
+ "volontari|A fassi male? Allora ci si mette anche il fuoco forte.": {
+  "file": "volontari-839aa118ab.mp3",
+  "sec": 4.1
+ },
  "andrea|Barone! Che ci fai qui?": {
   "file": "andrea-83abae1419.mp3",
   "sec": 2.91
@@ -2899,6 +2971,30 @@
   "file": "arcu-26a5fb0d0c.mp3",
   "sec": 3.17
  },
+ "andrea|Una partita alla bona, tanto per sentire la molla.": {
+  "file": "andrea-ad00ae1145.mp3",
+  "sec": 3.38
+ },
+ "andrea|Una partita seria.": {
+  "file": "andrea-3479aca550.mp3",
+  "sec": 1.16
+ },
+ "andrea|Un'altra volta.": {
+  "file": "andrea-1b517ab1ef.mp3",
+  "sec": 0.9
+ },
+ "andrea|Sessantamila punti e sono contento.": {
+  "file": "andrea-74e53fb53a.mp3",
+  "sec": 2.65
+ },
+ "andrea|Centoventimila. Come quando ci lasciavo le cinquecento lire.": {
+  "file": "andrea-82ab821c37.mp3",
+  "sec": 4.43
+ },
+ "andrea|Duecentomila. Il record del River, o quasi.": {
+  "file": "andrea-00b37d42f9.mp3",
+  "sec": 4.32
+ },
  "andrea|Due tiri alla bona, tanto per scaldarmi.": {
   "file": "andrea-d564365fc2.mp3",
   "sec": 2.53
@@ -2987,10 +3083,6 @@
   "file": "andrea-9cc0991d39.mp3",
   "sec": 3.32
  },
- "andrea|No, dopo.": {
-  "file": "andrea-78ad61a67a.mp3",
-  "sec": 1.22
- },
  "andrea|C'è posto per uno?": {
   "file": "andrea-f7481e5519.mp3",
   "sec": 1.81
@@ -3619,6 +3711,38 @@
   "file": "andrea-356a1afe8d.mp3",
   "sec": 5.91
  },
+ "andrea|Traguardo! Se c'era la classifica, oggi ci mettevo le mie iniziali.": {
+  "file": "andrea-6fd4fcd345.mp3",
+  "sec": 4.64
+ },
+ "andrea|Tre palline, e tutte nella Sieve. Il flipper del River non perdona.": {
+  "file": "andrea-5c306f1589.mp3",
+  "sec": 5.57
+ },
+ "andrea|Lascio la pallina lì. Tanto il River non chiude.": {
+  "file": "andrea-dcbb849b12.mp3",
+  "sec": 4.02
+ },
+ "andrea|Bruciate coi fiocchi! Mezza Smarronata le mangia grazie a me.": {
+  "file": "andrea-145f20bff9.mp3",
+  "sec": 5.11
+ },
+ "volontari|Bravo, figliolo! Se ti va, l'anno prossimo la manovella è tua.": {
+  "file": "volontari-067aa2d701.mp3",
+  "sec": 4.42
+ },
+ "andrea|Un po' crude, un po' carbone... Le mangio io, va'.": {
+  "file": "andrea-6f3339acb0.mp3",
+  "sec": 4.06
+ },
+ "volontari|Ci vuole il polso, figliolo. Il polso e la pazienza.": {
+  "file": "volontari-3bb4fe1dc0.mp3",
+  "sec": 4.28
+ },
+ "andrea|Vi rendo la manovella. Mi fumano anche gli occhi.": {
+  "file": "andrea-367ddde0fe.mp3",
+  "sec": 3.61
+ },
  "andrea|Il manifesto dell'Ingorgo Sonoro dell'anno scorso. Da piazza fino a Cambray Digny, una console in ogni angolo.": {
   "file": "andrea-0c26e34815.mp3",
   "sec": 7.53

docker-compose.deploy.yml

@@ -0,0 +1,15 @@
+# Il compose del VPS (make deploy lo copia in DEPLOY_DIR con il tag della versione al posto di VERSIONE).
+# L'immagine viene dal registry di Gitea; niente porte esposte: il container sta sulla rete esterna nginx-net,
+# dove Nginx Proxy Manager del VPS lo pubblica col suo nome (50037.manzolo.it → leggenda-regolo:80).
+# Per tornare indietro: sul VPS si rimette il tag precedente qui sotto e si rifà `docker compose pull && docker compose up -d`.
+services:
+  leggenda-regolo:
+    image: git.manzolo.it/manzolo/leggenda-regolo:VERSIONE
+    container_name: leggenda-regolo
+    restart: unless-stopped
+    networks:
+      - nginx-net
+
+networks:
+  nginx-net:
+    external: true

docker-compose.homeserver.yml

@@ -1,13 +0,0 @@
-# Deploy dietro un reverse proxy (make deploy): l'immagine arriva già costruita dal PC (docker load), niente porte esposte, il container sta sulla rete esterna nginx-net,
-# dove l'NPM interno di home-server lo pubblica col suo nome (50037.manzolo.it → leggenda-regolo:80).
-services:
-  leggenda-regolo:
-    image: leggenda-regolo:latest
-    container_name: leggenda-regolo
-    restart: unless-stopped
-    networks:
-      - nginx-net
-
-networks:
-  nginx-net:
-    external: true

docs/IDEE.md

@@ -151,7 +151,7 @@ si segna qui con la data e il punto di `src/story/story.js` dove sta; le persone
   Al bar e al circolo:
   - *Calcio balilla al River*: due stecche sole (difesa e attacco), vista dall'alto come il biliardo, che ha già
     la fisica delle sponde. Il gioco da bar più sampierino che c'è; il River «coi flipper e le figurine» lo cita già.
-  - *Flipper del River*: più lavoro, ma la fisica delle biglie c'è già.
+  - *Flipper del River*: fatto il 31 ottobre (vedi STATO.md).
   - *Freccette al Circolo*: la mira vaga e si ferma al clic, tre freccette, si chiude il 301. Poco codice.
   - *Morra*: niente fisica, tutto dialogo e tempismo; molto toscana, le grida dei numeri in voce XTTS.
   Sport:

docs/STATO.md

@@ -41,7 +41,70 @@ Online su 50037.manzolo.it tutto fino agli effetti ambientali di Codex. Aperto,
   merito!! A voi e agli alpini!»), la fanfara degli alpini, gli alpini della polenta e del vino, la gente coi cartocci
   (anche nel tendone), le coppie del liscio che girano (`flourish` continuo).
   La musica di Andrea (Suno): il liscio fuori, più forte vicino alle coppie (`stages`), la mazurca nel tendone.
-  [DA ANDREA] le battute; un minigioco delle bruciate (girare il cilindro sul fuoco).
+  [DA ANDREA] le battute.
+- **Il minigioco delle bruciate (31 ottobre)**: dai volontari della Misericordia («Vi do una mano alla manovella?»), o
+  usando il cilindro, si sceglie il livello e si gira la manovella a mano (`src/engine/bruciate.js`, disegno in
+  `bruciate-render.js`, sfondo di Codex `assets/closeups/smarronata-bruciatore.png`). Il gesto: tenendo premuto si
+  fanno giri, grandi o piccoli e dovunque (conta quanto gira la direzione del dito); Spazio, frecce: una spinta a
+  colpo. Troppo piano le castagne di sotto si carbonizzano e quelle di sopra restano crude, troppo forte volano nel
+  fuoco; quando son cotte, «Rovescia nel sacco». Contano le buone su 18 (alla bona 10, seria 15, a fassi male 16);
+  vincendo, il flag `bruciate_fatte`. Test in `bruciate.test.mjs`, prova `npm run browser:bruciate`.
+  [DA ANDREA] le battute dei volontari; un premio (un cartoccio da portare via?).
+- **Il flipper del River / Il Regolo (31 ottobre)**: «Usa» o «Apri» il River in Via Provinciale, livello e
+  partita. Motore `src/engine/flipper.js`, disegno `flipper-render.js`. Tavolo rifatto in lacca scura, metallo,
+  rampe con ombre e luci ciano/ambra/viola, riflessi sulle palline e plastiche in rilievo; scena a 1280×720 con
+  coordinate logiche 640×360, gli altri ambienti restano in pixel art. Fondale di Codex conservato nel riquadro
+  illustrato del backglass; niente pannelli sopra il Trebbio. Superfici e bagliori in cache, senza disegnare la
+  strada nascosta sotto il flipper. Pannello a destra con progressione, timer, moltiplicatore e prossimo obiettivo.
+  Alleggerito (1 novembre): il mobile statico sta sullo sfondo CSS della tela (`cabinetBehind`), la tela si pulisce
+  e basta; estremità e giunti arrotondati solo nei livelli in cache. Arretrato grafico da 4,2 s a 0,03 s per 150
+  fotogrammi (regole e misure nella memoria «effetti leggeri»).
+  - Rampe FORTEZZA e TREBBIO: imbocchi centrali da 36 pixel, 27 utili alla pallina, salite accessibili con colpi
+    medi, 15.000 punti. Tre passaggi sulla stessa rampa entro 20 secondi dal primo: LOCK e nuova pallina gratis.
+    Un'altra rampa completata o il tempo esaurito interrompono la serie. Dopo il primo LOCK, primo passaggio
+    nell'altra rampa SPECIAL: jackpot da 100.000; tre passaggi ravvicinati fanno il secondo LOCK.
+  - Due LOCK alzano la rampa centrale SUPER SPECIAL: 250.000 punti (× moltiplicatore), una pallina extra in
+    riserva e, dal 1 novembre, **Il Regolo del futuro**. Un botto sintetico grave, lampo, onde d'urto, schegge
+    colorate e scossa del mobile precedono l'apertura in due metà del piano classico. Trasformazione di 3,2 s:
+    le tre palline restano protette, poi vengono servite sfalsate di 0,55 s verso le palette.
+    Prima della SUPER, perdere la sostitutiva recupera l'ultimo lock senza scalare vite.
+  - **Secondo campo vero**, disegnato in codice: niente corsie dei rioni o banchi classici; altri respingenti,
+    raccordi, tre percorsi sopraelevati e Regolo mobile sopra le palette. ORBITA DEL SERPENTE (loop esterno,
+    35.000 a giro), PONTE DELLA FORTEZZA (ponte incrociato, 50.000), SPIRA AL NEON (spirale più ripida,
+    65.000). Imbocchi dal basso, salita con perdita d'energia, quota e uscita nelle corsie interne; un tiro
+    debole ricade senza punti. Tabellone digitale, circuiti e bastioni immaginari, luci ciano/viola/rosa,
+    pulsazione musicale originale sintetizzata con Web Audio. È fantasia del mobile, nessun fatto nuovo sul paese.
+  - **Tre sigilli**: completare due volte ciascun percorso, in qualsiasi ordine e senza scadenza, poi colpire
+    il Regolo mobile: +500.000 e ritorno al classico con pallina sulla molla, senza consumare vite. Anche
+    perdendo l'ultima pallina si torna al classico, consumando una sola vita; il punteggio rimane. La SUPER
+    si può riaprire. Durante il multiball perdere una delle altre palline non scala la riserva.
+  - Completare una serie di bersagli alza il moltiplicatore jackpot fino a ×3, azzerato alla perdita di una vita.
+    Restano PONTI (+50.000 alternando le rampe entro 12 secondi), PALIO (+30.000), respingenti, bersagli e Regolo.
+    Traguardi 60.000/120.000/200.000: una pallina premio una sola volta, vittoria acquisita anche uscendo prima.
+  - Uscite laterali da 14/12 pixel, corsie di ritorno alle palette più ampie. Il canale di 10 pixel dietro la
+    Pieve, che portava la pallina dritta nell'uscita sinistra, è chiuso da due raccordi inclinati (1 novembre). Valvola inclinata alla corsia di
+    lancio: il lancio passa, i ritorni dal campo vengono deviati a sinistra. Ogni pallina ha contatti, scia e
+    anti-incastro propri; urti fra palline, palette mosse una sola volta per passo. Pausa ferma anche i timer.
+  - Luci che scorrono sulle rampe attive, frecce e spie 1/3–2/3–LOCK, rampa SUPER che si alza, fasci luminosi,
+    scintille, particelle e fanfare distinte per jackpot, apertura SUPER e multiball; la pallina resta leggibile.
+    Comandi: mouse, due dita, tasto destro, frecce, Spazio e pulsanti; istruzioni in «Come si gioca».
+  - Test `flipper.test.mjs`: sequenze a tutti i livelli e in entrambi gli ordini, trasformazione protetta,
+    rilascio sfalsato, fisica e punteggi dei nuovi percorsi, tiri reali dalla paletta, Regolo mobile, finale,
+    ritorno e nuova SUPER, ball save, stato serializzabile e disegno senza mutazioni. I salvataggi dell'avventura
+    continuano a usare il checkpoint prima del minigioco, come gli altri primi piani; la pausa mantiene il
+    campo in corso e rilascia i comandi senza avanzare il tempo. `npm test`: 326 test verdi.
+  - `node scripts/verify.mjs flipper`: desktop e touch, comandi e pausa nel futuro, percorso fino al finale;
+    schermate di esplosione, apertura, futuro, sigilli e ritorno in `/tmp/regolo-flipper`, guardate e corrette.
+    Arretrato grafico misurato separatamente su 150 fotogrammi classici, esplosione/apertura e futuro, con
+    lettura dei pixel prima e dopo. Fondali sullo sfondo CSS, binari e pannelli in cache, onde e schegge leggere;
+    niente filtri o tratti arrotondati nel disegno dinamico. Soglia per ogni misura: 1,5 s.
+    Verifica finale (1 novembre): `REGOLO_GPU=0`, SwiftShader, classico/esplosione/futuro **31/56/26 ms**
+    desktop e **27/22/22 ms** touch. Anche il comando senza variabili passa, selezionando SwiftShader.
+    `REGOLO_GPU=1`: **30/17/25 ms** desktop e **23/18/20 ms** touch, ma il renderer effettivo è
+    `ANGLE (Mesa, llvmpipe (LLVM 21.1.8 256 bits), OpenGL ES 3.2)`: ancora software. In questo ambiente
+    non sono esposti dispositivi GPU; la misura su scheda video fisica resta da fare su un host che la esponga.
+    Schermate del secondo backend in `/tmp/regolo-flipper/llvmpipe`.
+  [DA ANDREA] battute, premio nell'avventura (`flipper_vinto`), record persistente per livello.
 - **Dedica allo zio Mario (31 ottobre)**: nei Ringraziamenti, sotto quella al Lele e più piccola: «Al mio caro zio
   Mario, che mi ha fatto vivere tante avventure più belle della fantasia.»
 - **Il Taglia (31 ottobre)**: tolte le battute sulla sua altezza (Baldoria: non gli fa piacere).
@@ -81,6 +144,13 @@ Online su 50037.manzolo.it tutto fino agli effetti ambientali di Codex. Aperto,
   pieni zeppi di gente fino in primo piano (Andrea); la prima versione, con la piazza vuota davanti, in
   `assets/raw/ingorgo-v1/`. La voce legge «console» come «consòl» (`tools/pronuncia.json`).
   [DA ANDREA] i generi veri per piazza, le battute, i bar a tema; da fare: spillare la birra (minigioco) e bere.
+  Il 31 ottobre: la folla davanti ad Andrea (dalla vita in giù, `crowdFront` in render.js), Andrea con la birra alla
+  festa (foglio di Codex `andrea-birra`: cammina col bicchiere, fermo lo alza a tempo), sotto una console si sente solo
+  quella (`mix`), in cima a Via dell'Antica Posta si arriva sotto l'underground. Via Calimara entra nella festa (sfondo di
+  Codex, console nel giardino con la palla a specchi) con la musica anni '90 di Andrea (Suno, `ingorgo-anni90.mp3`);
+  da lontano la house della Piazza e il latino del Comune.
+  Anche l'inizio di Via Cipriani (sfondo di Codex, console sul campo da basket, laser rossi e strobo, folla che poga a
+  180 battiti) con la hardcore techno di Andrea (Suno, `ingorgo-hardcore.mp3`).
 - **Baldoria al campo sportivo (30 ottobre)**: Yuri Baldi, dei Ringraziamenti, al Campo principale con la maglia
   blucerchiata e un bandierone della Sampdoria grande come lui, che ogni tanto sventola (`flourish` delle persone).
   Sprite di Codex (`assets/raw/baldoria-sheet.png`; `make character … FIX=wave=1.2,…` perché Codex ha disegnato più
@@ -220,8 +290,10 @@ Online su 50037.manzolo.it tutto fino agli effetti ambientali di Codex. Aperto,
 
 **Si gioca** in Docker su http://localhost:8080 (`make up`; Manzolo Rush è stato fermato per liberare la porta) e,
 **online dal 2026-10-23**, su https://50037.manzolo.it (50037 è il CAP di San Piero), finché non va su GitHub Pages.
-Si aggiorna con `make deploy`: pubblica l'ultimo commit, immagine costruita e provata sul PC e spedita al container
-`leggenda-regolo` di home-server (NPM centrale → NPM interno di home-server → container).
+Dal 2026-10-31 il sito pubblico è sul **VPS Contabo** (CNAME `50037` → `vps.manzolo.it`, NPM del VPS col certificato
+Let's Encrypt → container `leggenda-regolo`); la copia su home-server è stata tolta. Si aggiorna con `make deploy`:
+test, immagine costruita e provata sul PC, spedita al VPS, e il controllo che https://50037.manzolo.it serva la
+versione nuova.
 
 - **Motore** (`src/engine/`): camminata con percorsi su aree concave, profondità, sette verbi + clic intelligente,
   clic destro / pressione lunga = guarda, inventario con "usa… con" e "dai… a", dialoghi a scelte (anche una
@@ -253,6 +325,50 @@ Si aggiorna con `make deploy`: pubblica l'ultimo commit, immagine costruita e pr
 - **Test**: `make test` (29 test, compresa la soluzione completa da `src/story/solution.js`) e `make browser`
   (partita completa con clic veri in Chromium, ripresa del salvataggio, telefono).
 
+- **Impaginazione (1 novembre, Andrea: «come mai non sfruttiamo tutto lo schermo?»):** la scena prende la finestra. La
+  riserva sotto non è più 250 px fissi ma l'altezza vera del pannello, 13,3 unità `--u` (un centesimo della larghezza
+  del gioco, `cqw`, fra 8,75 e 12,8 px: `#app` è un container). Frase, verbi, inventario, risposte, HUD e fumetti scalano
+  col gioco, non con la finestra: i verbi non si tagliano più nelle finestre piccole. Il pannello è alto sempre uguale
+  (ci stanno quattro risposte; da cinque il carattere cala, da sette ancora) così la scena non si muove nei dialoghi;
+  la frase è una riga sola coi puntini. «Schermo intero» nella Pausa (dove il browser lo permette). A 1040×590 la scena
+  passa da 604 a 842 px di larghezza, a 1366×650 da 711 a 935; sui telefoni niente cambia. Prova in `browser.mjs`.
+
+- **Prove a sezioni (1 novembre, idea di Andrea):** `scripts/verify.mjs` conosce gli ingressi di ogni prova nel browser
+  (i file da cui dipende: i propri, più il motore comune; per la partita intera tutto il gioco tranne i minigiochi a sé)
+  e rifà solo quelle la cui impronta è cambiata dall'ultimo verde, ricordato in `.verify-ok.json` fuori da git. Così
+  `make bump` dopo una modifica alla briscola riprova la briscola e basta; dopo una modifica alla storia la partita intera
+  e le scene speciali (ambient, veicoli, ingorgo, smarronata), non la briscola; dopo `style.css` o `game.js` tutto.
+  Le prove dei minigiochi, che prima non entravano in `make verify`, ora ci stanno. `make verify-plan` spiega.
+  Nella pipeline di Gitea (runner sul PC) sui tag, o a mano, girano tutte e venti, una per job nell'immagine di
+  Playwright, prima della release: il primo giro completo (1 novembre, a mano su main) verde in 17 minuti.
+
+- **Prove sulla scheda video (1 novembre, Andrea: «prova con la scheda video»):** Chromium disegnava con swiftshader,
+  sul processore: una schermata 633 ms. Con la RTX del PC (`--use-angle=gl-egl`) 41 ms; micro da 283 a 27 s, briscola da
+  259 a 29, flipper da 186 a 10; tutte e venti da ~16 minuti (due alla volta) a ~4 (sei alla volta), tutte verdi. Le
+  opzioni stanno in `tests/chromium.mjs`: scheda video se c'è (`/dev/dri`, `/dev/nvidia0`), altrimenti swiftshader;
+  `REGOLO_GPU=0/1` forza. Con 6 o 8 prove insieme il giro dura uguale: il limite è la partita intera (243 s, il tempo
+  del gioco, non della grafica). La pipeline dà la GPU ai job (`--gpus all`, runtime NVIDIA di Docker); runner a 6 job.
+
+- **Schermo intero e flipper (1 novembre sera, Andrea):** pulsante ⛶ accanto ai volumi e tasto F; il gioco non si ferma
+  più a 1280 px (fino a 2560: a 1920×1080 la scena è 1553 px e prende tutta l'altezza). Nei minigiochi la scena lascia
+  sotto lo spazio vero dei comandi (`fitControls` in main.js, `--below`; cresce subito, cala solo oltre 24 px, «Come si
+  gioca» aperto non conta: una frase che va a capo faceva saltare il piano). Al flipper «Solo tavola» nasconde la
+  pulsantiera (ricordato nel browser); sul telefono in orizzontale è nascosta sempre e «Lascia stare» sta in alto. La
+  molla si carica toccando al centro (fascia 256-384), ai lati le palette anche prima del lancio; a pallina ferma la
+  tavola dice «TIENI PREMUTO QUI». Ponti rifatti da Codex (parapetti, portali, luci che seguono la pallina).
+
+- **La prova del peso (1 novembre, Andrea: «senza GPU scoprivamo anche gli effetti troppo pesanti»):** con la scheda
+  video le prove non vedono più un effetto pesante. `tests/peso.browser.mjs` usa sempre swiftshader e, nel gioco vero,
+  in ogni scena nelle tre fasi e in ogni primo piano (il flipper anche in gioco e nel Regolo del futuro) misura
+  fotogrammi al secondo e arretrato grafico: soglie 30 e 400 ms (una scena normale pochi ms; un `ctx.filter` blur a
+  tutto schermo 816, quaranta tratti larghi trasparenti 718). Due trappole trovate: leggere i pixel della tela del
+  gioco la fa passare al processore (Chrome) e la misura cambia ciò che misura, quindi si legge una tela nuova
+  640×360; la prima visita di una scena paga il caricamento delle immagini, quindi prima si smaltisce. ~5 minuti, in
+  parallelo con le altre; si rifà quando cambia un disegno (`watch` in verify.mjs), e nella pipeline sempre.
+
+- **Flipper da tastiera (1 novembre, Andrea):** la freccia giù carica la molla come Spazio, i due Shift comandano le
+  palette (sinistro e destro, `e.code` passato da main.js ai minigiochi). Test unitario e nel browser.
+
 ## Materiale ricevuto da Andrea (in `assets/raw/`, escluso da git)
 
 | File | Cosa | Uso previsto |
@@ -373,8 +489,8 @@ I prompt fissi (stile, scene, foglio sprite) sono in `prompts/STILE.md`, escluso
   Il nome del sentiero è provvisorio.
 - La salita dei cipressi (foto di Andrea, 28 ottobre, sfondo di Codex): la strada bianca fra la casa del maestro
   Bacci (alle spalle) e il viale dei cipressi (lassù spuntano i cipressi). Nome provvisorio, battute provvisorie.
-- Seconda copia del gioco sul VPS Contabo con `make deploy-vps` (dopo `make deploy`). Per renderla pubblica serve
-  nel proxy del VPS la regola per 50037.manzolo.it; poi si sposta il DNS su Aruba.
+- Il gioco pubblico sta sul VPS Contabo (dal 31 ottobre: regola in NPM del VPS, DNS spostato su Aruba, certificato
+  Let's Encrypt); la copia su home-server è stata tolta (Andrea: «la tengo fuori e basta»).
 - Via Pietro Cipriani (fra Piazza e campeggio): Cinema Taiuti aperto con la locandina del Rattattù 2007 (stile da
   `assets/raw/riferimenti/rattattu-locandina.png`, scaletta illeggibile). Al campo da basket del Circolo, «Fai due tiri»
   (`src/engine/basket.js`, vista di lato, sfondo e sprite di Andrea col pallone da Codex): da solo, dieci palloni, a ogni
@@ -417,7 +533,7 @@ I prompt fissi (stile, scene, foglio sprite) sono in `prompts/STILE.md`, escluso
   truccatissimo, motore 6, viola e giallo dalla sua foto, ritratto di Codex, testa «non pervenuta»), Bini (Andrea
   Bini, consenso del 28 ottobre: Italjet Formula giallo, motore 5, ritratto di Codex), Cistola (CR 50 Z), Andrea (Malaguti Fifty rosso e nero), Tozzino (Booster blu
   scuro, di serie, casco alla Damon Hill di Codex: `prompts/personaggi/casco-tozzino.txt`), l'Arcu (Betino). Col telefono
-  si guida con un dito: premuto è gas, lo swipe indica dove andare sullo schermo (Codex, 28 ottobre). Puntella (Marco Villani) ha dato il consenso il 28 ottobre; chi ha `consenso: null` in piloti.js non corre. Mancano: quanto erano
+  si guida con un dito: premuto è gas, lo swipe indica dove andare sullo schermo (Codex, 28 ottobre). Il Boccino (Gabriele Chiesi, consenso del 31 ottobre) col suo NRG bianco e rosso numero 1 e il ritratto di Codex. Puntella (Marco Villani) ha dato il consenso il 28 ottobre; chi ha `consenso: null` in piloti.js non corre. Mancano: quanto erano
   truccati gli altri, le battute di Andrea, il rumore del motore (c'è solo
   quello dell'arrivo in griglia); i confini della paglia non si vedono sul quadro (revisione di Codex, punto 9).
 - Strade attorno a casa (Andrea, 28 ottobre): la scena `area_camper` ora si chiama «Le villette del Giannini» (ci abita

index.html

@@ -23,12 +23,14 @@
       <button id="notebook-button" hidden title="Taccuino (N)">Taccuino</button>
       <button id="spots-button" hidden title="Mostra cosa si può toccare (H)">?</button>
       <button id="back-button" hidden></button>
+      <button id="table-only" hidden title="Nasconde la pulsantiera: il flipper a tutta altezza (si gioca con mouse e tastiera)">Solo tavola</button>
     </div>
     <div id="sound">
       <button id="mute" aria-label="Togli l'audio" title="Audio (M)">♪</button>
       <input id="volume" type="range" min="0" max="100" step="5" aria-label="Volume della musica" title="Volume della musica">
       <label for="voice-volume" class="sound-label" title="Volume delle voci">bla</label>
       <input id="voice-volume" type="range" min="0" max="100" step="5" aria-label="Volume delle voci" title="Volume delle voci">
+      <button id="fullscreen-hud" aria-label="Schermo intero" title="Schermo intero (F)">⛶</button>
     </div>
     <section id="splash" class="overlay" aria-label="Manzolo (Poca) Art Presents">
       <p class="splash-name">Manzolo</p>
@@ -86,6 +88,7 @@
       <div class="buttons pause-buttons">
         <button id="resume">Riprendi</button>
         <button id="pause-map" class="secondary">Mappa</button>
+        <button id="fullscreen" class="secondary" title="Il gioco su tutto lo schermo; Esc per uscire">Schermo intero</button>
         <button id="save-file" class="secondary" title="Scarica la partita in un file da aprire su un altro dispositivo">Salva su file</button>
         <button class="open-credits secondary">Ringraziamenti</button>
         <button id="to-title" class="secondary">Torna al titolo</button>
@@ -295,6 +298,42 @@
       sinistra per la forza. I salti: la lancetta dell'equilibrio attraversa la barra; premi (o Spazio, o Salta) quando è
       nel verde. Troppo presto metti giù l'altro piede, troppo tardi pesti la riga.</p>
     </details>
+    <details id="bruciate-help" hidden><summary>Come si gioca</summary>
+      <p>Le bruciate della Smarronata, coi volontari della Misericordia: le castagne sono nel cilindro a rete sopra il
+      fuoco e si gira la manovella. Tieni premuto e fai dei giri, grandi o piccoli, dove vuoi, col mouse o col dito:
+      il cilindro gira con te. Oppure Spazio o le frecce: una spinta a ogni colpo.</p>
+      <p>In alto, GIRO: tienilo nel verde. Troppo piano le castagne non si rimescolano, quelle di sotto si carbonizzano e
+      quelle di sopra restano crude; troppo forte volano fuori, nel fuoco. COTTURA: quando è nel verde, Rovescia nel
+      sacco (o Invio). Contano le bruciate buone: alla bona ne bastano 10 su 18, seria 15, a fassi male 16.</p>
+    </details>
+    <details id="flipper-help" hidden><summary>Come si gioca</summary>
+      <p>Il Regolo, il flipper del River. Tieni premuto per caricare la molla e lascia per lanciare, oppure tieni
+      premuto Spazio o la freccia giù, o usa il pulsante Lancia. Una valvola impedisce alla pallina entrata in campo di tornare sulla molla.
+      Le frecce sinistra e destra, i due Shift, i pulsanti Flipper o le due metà della scena comandano le palette;
+      puoi usare due dita insieme e il tasto destro del mouse comanda sempre la paletta destra.</p>
+      <p>Le rampe FORTEZZA (ciano) e TREBBIO (ambra) valgono 15.000 punti. Tre passaggi completi sulla stessa
+      rampa entro 20 secondi dal primo fanno LOCK: la pallina viene trattenuta e ne arriva una nuova gratis.
+      Completare l'altra rampa interrompe la serie. Dopo il primo LOCK l'altra rampa diventa SPECIAL: il primo
+      passaggio paga un JACKPOT da 100.000, e tre passaggi ravvicinati fanno il secondo LOCK.</p>
+      <p>Con entrambi i LOCK si alza la rampa viola centrale, SUPER SPECIAL. Completala: 250.000 punti,
+      una pallina extra in riserva e una sorpresa esplosiva! Il piano si apre e rivela <strong>Il Regolo del futuro</strong>,
+      un secondo campo al neon. Durante la trasformazione le tre palline sono al sicuro; poi parte il MULTIBALL,
+      con uscite sfalsate verso le palette. I comandi restano gli stessi.</p>
+      <p>Nel futuro completa due volte ciascun percorso: il loop ORBITA DEL SERPENTE vale 35.000 a giro,
+      la rampa sopraelevata PONTE DELLA FORTEZZA 50.000 e la SPIRA AL NEON 65.000. Contano solo i giri
+      completi: un tiro troppo debole ricade senza premio. Ogni percorso carica un sigillo, senza limite di tempo.
+      Accesi tutti e tre, colpisci il Regolo coronato che si muove al centro: 500.000 punti e ritorno al tavolo
+      classico, con una pallina pronta sulla molla senza consumare la riserva. Torni al classico anche perdendo
+      l'ultima pallina in gioco: in quel caso consumi una sola vita. I punti restano e puoi riaprire la SUPER.
+      Se perdi la sostitutiva prima della SUPER, recuperi l'ultimo LOCK senza consumare una vita.</p>
+      <p>Completa i tre bersagli di un lato per alzare il moltiplicatore dei jackpot, fino a ×3 (si azzera alla
+      perdita di una vita). Alterna le due rampe entro 12 secondi per il bonus PONTI da 50.000; accendi le
+      quattro corsie dei rioni per il PALIO da 30.000. I respingenti valgono 1.000, i bersagli laterali 5.000
+      l'uno e 25.000 la serie, il Regolo coronato 10.000.</p>
+      <p>Parti con tre palline. Appena lanciata, la pallina è protetta una volta: 8 secondi alla bona, 4 seria,
+      1 a fassi male. Il traguardo è 60.000, 120.000 o 200.000 punti: raggiungerlo assegna una pallina premio
+      una sola volta per partita. Poi puoi continuare per il record, i LOCK e la SUPER SPECIAL.</p>
+    </details>
     <details id="cerbottana-help" hidden><summary>Come si gioca</summary>
       <p>La cerbottana, con lo stucco verde di Pierin di Frilli: dodici pallini contro il muro della piazza. Il bersaglio
       di gesso vale 10, 5 o 2 punti secondo il cerchio, ogni lattina sul muretto 3, il barattolo appeso che dondola (Seria

package.json

@@ -1,6 +1,6 @@
 {
   "name": "leggenda-del-regolo",
-  "version": "0.1.63",
+  "version": "0.1.73",
   "private": true,
   "type": "module",
   "scripts": {
@@ -12,6 +12,8 @@
     "browser:cerbottana": "node tests/cerbottana.browser.mjs",
     "browser:condor": "node tests/condor.browser.mjs",
     "browser:campana": "node tests/campana.browser.mjs",
+    "browser:bruciate": "node tests/bruciate.browser.mjs",
+    "browser:flipper": "node tests/flipper.browser.mjs",
     "browser:ingorgo": "node tests/ingorgo.browser.mjs",
     "browser:tressette": "node tests/tressette.browser.mjs",
     "browser:scopa": "node tests/scopa.browser.mjs",

scripts/git-hooks/pre-push

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Prima di ogni push: il repo su git.manzolo.it è pubblico, quindi niente che check-public bocci deve partire.
+# Si attiva una volta con `make hooks` (core.hooksPath = scripts/git-hooks).
+cd "$(git rev-parse --show-toplevel)" || exit 1
+bash scripts/check-public.sh || { echo; echo "pre-push: push bloccato da check-public (vedi sopra)."; exit 1; }

scripts/runner.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Crea (se manca) e avvia il runner delle Gitea Actions su questo PC: `make runner`.
+# Rifarlo da zero: `docker compose -f tools/gitea-runner/docker-compose.yml down`, cancellare $RUNNER_DATA e il runner
+# vecchio da Gitea (repo → Impostazioni → Actions → Runner), poi di nuovo `make runner`.
+# Il token di registrazione si chiede all'API di Gitea con le credenziali di git (serve lo scope write:repository).
+set -euo pipefail
+ROOT=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
+COMPOSE="$ROOT/tools/gitea-runner/docker-compose.yml"
+REPO=${RUNNER_REPO:-manzolo/leggenda-del-regolo}
+export RUNNER_DATA=${RUNNER_DATA:-$HOME/.local/share/gitea-runner}
+export GITEA_RUNNER_NAME=${GITEA_RUNNER_NAME:-pc-$(hostname | tr '[:upper:]' '[:lower:]')}
+mkdir -p "$RUNNER_DATA"
+
+if [[ ! -s $RUNNER_DATA/.runner ]]; then
+    pass=$(printf 'protocol=https\nhost=git.manzolo.it\n\n' | git credential fill | sed -n 's/^password=//p')
+    user=$(printf 'protocol=https\nhost=git.manzolo.it\n\n' | git credential fill | sed -n 's/^username=//p')
+    [[ -n $pass ]] || { echo "nessuna credenziale git per git.manzolo.it"; exit 1; }
+    tok=$(curl -sf -X POST -u "$user:$pass" "https://git.manzolo.it/api/v1/repos/$REPO/actions/runners/registration-token" |
+          python3 -c 'import json,sys; print(json.load(sys.stdin)["token"])') ||
+        { echo "Gitea non ha dato il token di registrazione (scope write:repository?)"; exit 1; }
+    echo "registro il runner $GITEA_RUNNER_NAME su $REPO"
+    GITEA_RUNNER_REGISTRATION_TOKEN=$tok docker compose -f "$COMPOSE" up -d
+    for _ in $(seq 30); do [[ -s $RUNNER_DATA/.runner ]] && break; sleep 1; done
+    [[ -s $RUNNER_DATA/.runner ]] || { docker logs --tail 20 gitea-runner; echo "registrazione non riuscita"; exit 1; }
+    chmod 600 "$RUNNER_DATA/.runner" 2>/dev/null || true
+fi
+# Senza token nell'ambiente del container: da qui in poi si autentica con .runner.
+docker compose -f "$COMPOSE" up -d
+# config.yaml si legge solo all'avvio: se è cambiato (capacità, opzioni) il runner riparte.
+[[ $(docker inspect -f '{{.State.StartedAt}}' gitea-runner | date -f - +%s) -lt $(stat -c %Y "$(dirname "$COMPOSE")/config.yaml") ]] && docker restart gitea-runner >/dev/null
+sleep 2; docker logs --tail 1 gitea-runner

scripts/verify.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// Le prove nel browser a sezioni (idea di Andrea, 1 novembre 2026): ogni prova ha i suoi ingressi, i file da cui dipende;
+// si rifà solo se la loro impronta (i blob di git, più i file modificati nella cartella di lavoro) è cambiata dall'ultimo
+// verde, ricordato in .verify-ok.json (fuori da git). Se cambia la briscola si riprova la briscola; se cambia la storia, il
+// motore, l'impaginazione o le risorse si riprova la partita intera (e le prove delle scene speciali), non la briscola.
+//   node scripts/verify.mjs            le prove da rifare, in parallelo, e aggiorna i verdi (JOBS: quante insieme; con la
+//                                      scheda video JOBS_GPU, senza 2: con quattro Chromium swiftshader le schermate vanno in timeout)
+//   node scripts/verify.mjs --plan     dice solo cosa rifarebbe e perché
+//   node scripts/verify.mjs --all      tutte, senza guardare i verdi
+//   node scripts/verify.mjs briscola   solo quelle nominate (anche se verdi)
+// I test unitari e check-public non stanno qui: costano pochi secondi e girano sempre (make verify).
+import { execFileSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { cpus } from 'node:os';
+import { GPU } from '../tests/chromium.mjs';
+
+// Il motore comune a tutto: cambia questo e si riprova ogni minigioco.
+export const ENGINE = ['index.html', 'style.css', 'src/main.js', 'src/engine/game.js', 'src/engine/render.js',
+    'tests/helpers.mjs', 'tests/chromium.mjs', 'package-lock.json'];
+// Non toccano il gioco nel browser: documenti, strumenti, pubblicazione, versione (make bump la cambia prima di verificare),
+// test unitari (girano sempre, a parte), e questo stesso script (lo prova verify.test.mjs).
+export const IGNORED = [/^docs\//, /^[^/]*\.md$/, /^src\/version\.js$/, /^package\.json$/, /^Makefile$/, /^scripts\//,
+    /^tools\//, /^video\//, /^\.gitea\//, /^prompts\//, /^LICENSE$/, /^Dockerfile$/, /^nginx\.conf$/, /^docker-compose/, /^requirements\.txt$/,
+    /^\.(gitignore|dockerignore|verify-ok\.json)$/, /^tests\/[^/]*\.test\.mjs$/, /^tests\/test_[^/]*\.py$/, /^deploy\.local\.mk$/, /(^|\/)__pycache__\//];
+
+// Le prove. `core: true` = dipende da tutto il gioco tranne i file dei minigiochi a sé (che hanno la loro prova); altrimenti
+// solo dal motore e dai propri file: quelli che si chiamano come la prova (src/engine/flipper.js, flipper-render.js,
+// assets/closeups/flipper-*.png, docs/BRISCOLA.md…) più gli `extra`. `watch`: file che la prova guarda senza toglierli
+// alle altre (il peso della grafica si rifà quando cambia un disegno, ma quel disegno resta anche della sua prova).
+// `run` sono gli argomenti di node.
+export const SUITES = {
+    principale: { core: true, run: ['tests/browser.mjs', '--parte=principale'], note: 'la partita intera, pausa e salvataggi' },
+    minigiochi: { core: true, run: ['tests/browser.mjs', '--parte=minigiochi'], note: 'libro, bocce, tiri, pesca e biliardo dalla partita' },
+    telefoni:   { core: true, run: ['tests/browser.mjs', '--parte=telefoni'], note: 'multimedia, telefoni, la finestra di Andrea, debug' },
+    ambient:    { core: true, run: ['tests/ambient.browser.mjs'], note: 'tutte le scene nelle tre fasi e gli effetti' },
+    veicoli:    { core: true, run: ['tests/veicoli.browser.mjs'], note: 'i veicoli nelle scene' },
+    ingorgo:    { core: true, run: ['tests/ingorgo.browser.mjs'], note: "l'Ingorgo Sonoro" },
+    smarronata: { core: true, run: ['tests/smarronata.browser.mjs'], note: 'la Smarronata del 1993' },
+    briscola:   { run: ['tests/briscola.browser.mjs'] },
+    tressette:  { run: ['tests/tressette.browser.mjs'] },
+    scopa:      { run: ['tests/scopa.browser.mjs'] },
+    biliardo:   { run: ['tests/biliardo.browser.mjs'] },
+    flipper:    { run: ['tests/flipper.browser.mjs'] },
+    micro:      { run: ['tests/micro.browser.mjs'] },
+    cerbottana: { run: ['tests/cerbottana.browser.mjs'] },
+    condor:     { run: ['tests/condor.browser.mjs'] },
+    campana:    { run: ['tests/campana.browser.mjs'] },
+    bruciate:   { run: ['tests/bruciate.browser.mjs'] },
+    gara:       { run: ['tests/gara.browser.mjs'], extra: ['src/engine/corsa.js', 'src/story/piloti.js', /^assets\/[^/]*\/(gara|gp|pilot)/] },
+    telefono:   { run: ['tests/telefono.browser.mjs'], extra: [/^assets\/muro\//] },
+    risveglio:  { run: ['tests/risveglio.browser.mjs'] },
+    // Sempre con swiftshader, come un telefono lento: con la scheda video le altre prove non vedono gli effetti pesanti.
+    peso:       { run: ['tests/peso.browser.mjs'], note: 'il peso della grafica, senza scheda video',
+        watch: [/-render\.js$/, /^src\/engine\/(ambient|incanto|risveglio|torch|viaggio|corsa|telefono)\.js$/, /^src\/story\/ambience\.js$/, /^assets\/effects\//] },
+};
+
+// Prove insieme con la scheda video (misurato il 1° novembre 2026 sul PC di Andrea, 16 thread e RTX 3080 Ti).
+const JOBS_GPU = 6; // con 6 e con 8 il giro intero dura uguale (~4 min): da solo «principale» ne prende 243 s
+
+const ownRe = name => new RegExp(`(^|/)${name}([-_.][^/]*)?$`, 'i');
+const matches = (path, rule) => rule instanceof RegExp ? rule.test(path) : rule === path;
+export const ignored = path => IGNORED.some(r => r.test(path));
+export function ownFiles(name, files) {
+    const s = SUITES[name], re = ownRe(name);
+    return files.filter(p => re.test(p) || (s.extra || []).some(r => matches(p, r)));
+}
+// Gli ingressi di una prova fra i file dati (tutti quelli di git più quelli nuovi nella cartella).
+export function inputsOf(name, files) {
+    const s = SUITES[name], live = files.filter(p => !ignored(p));
+    if (!s.core) return [...new Set([...ENGINE.filter(p => files.includes(p)), ...ownFiles(name, live),
+        ...live.filter(p => (s.watch || []).some(r => matches(p, r)))])].sort();
+    const others = Object.keys(SUITES).filter(n => !SUITES[n].core);
+    // I file degli altri minigiochi, e i file di prova delle altre prove (tests/ambient.browser.mjs non riguarda la partita).
+    const foreign = new Set([...others.flatMap(n => ownFiles(n, live)),
+        ...Object.keys(SUITES).filter(n => SUITES[n].run[0] !== s.run[0]).map(n => SUITES[n].run[0])]);
+    return live.filter(p => !foreign.has(p)).sort();
+}
+export const fingerprint = (paths, hashOf) => createHash('sha1').update(paths.map(p => `${p} ${hashOf(p)}`).join('\n')).digest('hex');
+
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const git = (...a) => execFileSync('git', a, { cwd: ROOT, encoding: 'utf8', maxBuffer: 1 << 26 });
+
+// I file del progetto con l'impronta di ognuno: il blob dell'indice di git, o il contenuto attuale se modificato o nuovo.
+export function snapshot() {
+    const hashes = new Map();
+    for (const line of git('ls-files', '-s', '-z').split('\0')) if (line) { const [meta, path] = line.split('\t'); hashes.set(path, meta.split(' ')[1]); }
+    const dirty = [];
+    for (const line of git('status', '--porcelain', '-z', '--untracked-files=all').split('\0')) {
+        if (!line) continue;
+        const code = line.slice(0, 2), path = line.slice(3);
+        if (code.includes('D')) hashes.delete(path); else dirty.push(path);
+    }
+    for (const path of dirty) if (existsSync(`${ROOT}/${path}`)) hashes.set(path, git('hash-object', '--', path).trim());
+    return hashes;
+}
+
+const OK_FILE = `${ROOT}/.verify-ok.json`;
+const readOk = () => { try { return JSON.parse(readFileSync(OK_FILE, 'utf8')); } catch { return {}; } };
+
+export function plan(hashes, ok, names = Object.keys(SUITES)) {
+    const files = [...hashes.keys()], out = [];
+    for (const name of names) {
+        const inputs = inputsOf(name, files), fp = fingerprint(inputs, p => hashes.get(p));
+        const was = ok[name], changed = was?.fingerprint === fp ? [] : inputs.filter(p => !was?.hashes || was.hashes[p] !== hashes.get(p));
+        out.push({ name, fp, inputs, changed, green: was?.fingerprint === fp, seconds: was?.seconds });
+    }
+    return out;
+}
+
+function run(name) {
+    return new Promise(resolve => {
+        const t0 = Date.now(), lines = [];
+        const p = spawn(process.execPath, SUITES[name].run, { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
+        let rest = '';
+        const onData = chunk => { const parts = (rest + chunk).split('\n'); rest = parts.pop(); for (const l of parts) { lines.push(l); console.log(`[${name}] ${l}`); } };
+        p.stdout.on('data', onData); p.stderr.on('data', onData);
+        p.on('close', code => { if (rest) console.log(`[${name}] ${rest}`); resolve({ name, code, seconds: Math.round((Date.now() - t0) / 1000) }); });
+    });
+}
+
+async function main() {
+    const args = process.argv.slice(2), all = args.includes('--all'), onlyPlan = args.includes('--plan');
+    const named = args.filter(a => !a.startsWith('--'));
+    for (const n of named) if (!SUITES[n]) { console.error(`prova sconosciuta: ${n} (${Object.keys(SUITES).join(', ')})`); process.exit(2); }
+    const hashes = snapshot(), ok = readOk();
+    const todo = plan(hashes, ok, named.length ? named : undefined).filter(p => all || named.length || !p.green);
+    const green = Object.keys(SUITES).filter(n => !todo.some(t => t.name === n));
+    if (!todo.length) { console.log(`Prove nel browser: tutte verdi dall'ultimo giro (${green.length}); niente da rifare.`); return; }
+    for (const t of todo) {
+        const why = all ? 'tutte' : named.includes(t.name) ? 'chiesta' : !ok[t.name] ? 'mai provata' : !t.changed.length ? "cambiato l'elenco dei file da cui dipende" : `cambiati ${t.changed.slice(0, 4).join(', ')}${t.changed.length > 4 ? ` e altri ${t.changed.length - 4}` : ''}`;
+        console.log(`da rifare: ${t.name}${t.seconds ? ` (~${t.seconds} s)` : ''}: ${why}`);
+    }
+    if (green.length && !named.length) console.log(`già verdi: ${green.join(', ')}`);
+    if (onlyPlan) return;
+    const jobs = Math.max(1, Number(process.env.JOBS) || Math.min(GPU ? JOBS_GPU : 2, Math.floor(cpus().length / (GPU ? 2 : 4))));
+    console.log(`Chromium ${GPU ? 'sulla scheda video' : 'con swiftshader'}, ${Math.min(jobs, todo.length) === 1 ? "una prova" : `${Math.min(jobs, todo.length)} prove`} alla volta.`);
+    const queue = todo.sort((a, b) => (b.seconds || 999) - (a.seconds || 999)), results = [];
+    const worker = async () => { for (let t; (t = queue.shift());) {
+        const r = await run(t.name); results.push(r);
+        if (r.code === 0) {
+            const now = readOk();
+            now[t.name] = { fingerprint: t.fp, seconds: r.seconds, when: new Date().toISOString(), hashes: Object.fromEntries(t.inputs.map(p => [p, hashes.get(p)])) };
+            writeFileSync(OK_FILE, JSON.stringify(now, null, 1) + '\n');
+        }
+    } };
+    await Promise.all(Array.from({ length: Math.min(jobs, queue.length) }, worker));
+    for (const r of results.sort((a, b) => a.name.localeCompare(b.name))) console.log(`${r.code === 0 ? 'OK  ' : 'FAIL'} ${r.name} (${r.seconds} s)`);
+    const failed = results.filter(r => r.code !== 0).map(r => r.name);
+    if (failed.length) { console.log(`Prove fallite: ${failed.join(', ')}`); process.exit(1); }
+    console.log(`Prove nel browser OK: ${results.length} rifatte${named.length ? '' : `, ${green.length} già verdi`}.`);
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) main();

src/engine/bruciate-render.js

@@ -0,0 +1,152 @@
+// Le bruciate in primo piano (bruciate.js): il cilindro a rete sopra il fuoco, visto di fronte, con le castagne dentro
+// che ricascano, la manovella a destra, le fiamme che lo lambiscono; in basso il giro della manovella e la cottura.
+// Niente filtri e niente passate trasparenti a tutto schermo (vedi risveglio.js): solo forme piccole.
+import { DRUM, CRANK, BAR, N, COOKED, BURNT, POUR, MAX_SPEED, inside, doneness } from './bruciate.js';
+import { text, panel } from './bocce-render.js';
+import { ambientHash as hash } from './ambient.js';
+
+const SACK = { x: 604, y: 268 }, FIRE = 252, RODS = 18, RINGS = 9;
+const lerp = (a, b, k) => a + (b - a) * k;
+const mix = (p, q, k) => `rgb(${p.map((v, i) => Math.round(lerp(v, q[i], k))).join(',')})`;
+// Il colore della buccia: lucida e rossiccia da cruda, scura da cotta, nera da carbone.
+const RAW = [168, 96, 50], DONE = [118, 64, 30], COAL = [26, 20, 18];
+const shell = cook => cook < COOKED ? mix(RAW, DONE, Math.max(0, cook) / COOKED) : mix(DONE, COAL, Math.min(1, (cook - COOKED) / (BURNT - COOKED)));
+
+// Dove sta una castagna sullo schermo, e quanto è davanti (per l'ordine e la luce).
+function place(k) {
+    return { x: lerp(DRUM.x0 + 8, DRUM.x1 - 8, k.x), y: DRUM.y + Math.sin(k.a) * DRUM.r * k.r, z: Math.cos(k.a) * k.r };
+}
+function chestnut(ctx, x, y, cook, z = 0) {
+    // Il bordino, perché si stacchino dal fondo del cilindro (chiaro su quelle carbone).
+    ctx.fillStyle = cook > BURNT ? '#6a5a4e' : '#1e120a';
+    ctx.beginPath(); ctx.ellipse(Math.round(x), Math.round(y), 7, 6, 0, 0, Math.PI * 2); ctx.fill();
+    ctx.fillStyle = shell(cook);
+    ctx.beginPath(); ctx.ellipse(Math.round(x), Math.round(y), 6, 5, 0, 0, Math.PI * 2); ctx.fill();
+    // La punta chiara e, da cotte, l'incisione aperta col giallo della castagna.
+    ctx.fillStyle = cook > BURNT ? '#2a2420' : '#d9b48a';
+    ctx.fillRect(Math.round(x) - 1, Math.round(y) - 4, 2, 1);
+    if (cook >= COOKED * 0.8 && cook <= BURNT) { ctx.fillStyle = '#e8c070'; ctx.fillRect(Math.round(x) - 2, Math.round(y) - 1, 4, 1); }
+    // Il riflesso del fuoco, più forte su quelle davanti.
+    if (cook < BURNT) { ctx.fillStyle = `rgba(255,190,120,${0.25 + 0.3 * Math.max(0, z)})`; ctx.fillRect(Math.round(x) + 1, Math.round(y) - 2, 2, 1); }
+}
+// Le fiamme che lambiscono il cilindro: lingue basse e storte, ognuna col suo passo, che ogni tanto si allungano.
+function flames(ctx, time, front) {
+    for (let i = 0; i < 17; i++) {
+        if ((i % 3 === 0) !== front) continue;
+        const r = hash(i * 7.3), x = DRUM.x0 + 6 + i * (DRUM.x1 - DRUM.x0 - 12) / 16 + 6 * (hash(i * 1.9) - 0.5);
+        const lick = Math.max(0, Math.sin(time * (1.3 + r) + i * 2.1)) ** 4, h = front ? 5 + 6 * r + 2 * Math.sin(time * (6 + r * 5) + i) + 7 * lick : 18 + 16 * r + 7 * Math.sin(time * (6 + r * 5) + i) + 22 * lick;
+        const w = 5 + 5 * hash(i * 3.1), sway = 2.5 * Math.sin(time * (3 + r) + i * 1.7);
+        for (const [k, color] of [[1, '#b8301a'], [0.7, '#ea7a1a'], [0.4, '#ffd04a']]) {
+            ctx.fillStyle = color;
+            ctx.beginPath();
+            ctx.moveTo(x - w * k, FIRE);
+            ctx.quadraticCurveTo(x - w * k * 0.2 + sway, FIRE - h * k * 0.6, x + sway * 2, FIRE - h * k);
+            ctx.quadraticCurveTo(x + w * k * 0.5 + sway, FIRE - h * k * 0.45, x + w * k, FIRE);
+            ctx.fill();
+        }
+    }
+}
+// Il cilindro appeso: la sbarra sulle due forcelle e i due ferri che lo reggono per l'asse.
+function hanger(ctx) {
+    ctx.fillStyle = '#2a2420'; ctx.fillRect(150, BAR - 3, 336, 6);
+    ctx.fillStyle = '#6a5a4a'; ctx.fillRect(150, BAR - 3, 336, 1);
+    for (const x of [DRUM.x0 - 12, DRUM.x1 + 12]) {
+        ctx.fillStyle = '#2a2420'; ctx.fillRect(x - 2, BAR, 4, DRUM.y - BAR + 4);
+        ctx.fillStyle = '#5a4a3e'; ctx.fillRect(x - 2, BAR, 1, DRUM.y - BAR + 4);
+        ctx.fillStyle = '#2a2420'; ctx.beginPath(); ctx.arc(x, DRUM.y, 5, 0, Math.PI * 2); ctx.fill();
+    }
+}
+// La rete: gli anelli e i tondini che girano col cilindro (quelli davanti più chiari).
+function mesh(ctx, c, front) {
+    const { x0, x1, y, r } = DRUM;
+    for (let j = 0; j < RODS; j++) {
+        const a = c.drum + j * Math.PI * 2 / RODS, z = Math.cos(a);
+        if (front !== z > 0) continue;
+        ctx.fillStyle = front ? '#9a9088' : '#3a302a';
+        ctx.fillRect(x0, Math.round(y + Math.sin(a) * r), x1 - x0, 1);
+    }
+    ctx.strokeStyle = front ? '#8a8078' : '#3a302a'; ctx.lineWidth = 1;
+    for (let i = 0; i <= RINGS; i++) {
+        const x = Math.round(lerp(x0, x1, i / RINGS)) + 0.5, end = i === 0 || i === RINGS;
+        ctx.beginPath(); ctx.ellipse(x, y, end ? 9 : 4, r, 0, front ? -Math.PI / 2 : Math.PI / 2, front ? Math.PI / 2 : Math.PI * 1.5); ctx.stroke();
+    }
+}
+function crank(ctx, c, time) {
+    const { x, y, rx, ry } = CRANK, a = c.drum;
+    // L'asse, da una forcella all'altra e fino alla manovella.
+    ctx.fillStyle = '#2a2420'; ctx.fillRect(DRUM.x0 - 16, y - 2, x - DRUM.x0 + 18, 4);
+    ctx.fillStyle = '#6a625a'; ctx.fillRect(DRUM.x0 - 16, y - 2, x - DRUM.x0 + 18, 1);
+    // Il giro da fare: un'ellisse tratteggiata che pulsa, finché il cilindro è fermo.
+    if (c.step === 'turn' && Math.abs(c.speed) < 0.5) {
+        ctx.strokeStyle = `rgba(255,224,140,${0.5 + 0.4 * Math.sin(time * 5)})`; ctx.setLineDash([3, 3]);
+        ctx.beginPath(); ctx.ellipse(x, y, rx + 6, ry + 6, 0, 0, Math.PI * 2); ctx.stroke(); ctx.setLineDash([]);
+        text(ctx, 'GIRA!', x, y + ry + 18, 6, '#ffe08c', 'center');
+    }
+    const hx = x + Math.cos(a) * rx, hy = y + Math.sin(a) * ry;
+    ctx.strokeStyle = '#5a5450'; ctx.lineWidth = 4; ctx.beginPath(); ctx.moveTo(x, y); ctx.lineTo(hx, hy); ctx.stroke();
+    ctx.strokeStyle = '#b0a698'; ctx.lineWidth = 1; ctx.beginPath(); ctx.moveTo(x, y - 1); ctx.lineTo(hx, hy - 1); ctx.stroke();
+    ctx.fillStyle = '#4a4440'; ctx.beginPath(); ctx.arc(x, y, 4, 0, Math.PI * 2); ctx.fill();
+    // L'impugnatura di legno, consumata dalle mani.
+    ctx.fillStyle = '#3a2414'; ctx.fillRect(Math.round(hx) - 4, Math.round(hy) - 8, 9, 16);
+    ctx.fillStyle = '#a0703c'; ctx.fillRect(Math.round(hx) - 3, Math.round(hy) - 7, 7, 14);
+    ctx.fillStyle = '#d6a062'; ctx.fillRect(Math.round(hx) - 2, Math.round(hy) - 6, 2, 12);
+}
+// In basso a sinistra (in alto ci sono i cursori del volume): il giro della manovella (rosso troppo piano, verde giusto, rosso troppo forte) e la cottura.
+function gauges(ctx, c) {
+    panel(ctx, 10, 296, 196, 54);
+    const bar = (y, label, k, zones, mark) => {
+        text(ctx, label, 18, y, 6, '#efd49e');
+        const x0 = 82, w = 116;
+        for (const [a, b, color] of zones) { ctx.fillStyle = color; ctx.fillRect(x0 + Math.round(a * w), y - 3, Math.max(1, Math.round((b - a) * w)), 7); }
+        ctx.fillStyle = mark; ctx.fillRect(x0 + Math.round(Math.max(0, Math.min(1, k)) * w) - 1, y - 6, 3, 13);
+    };
+    const s = c.skill, lo = s.lo / MAX_SPEED, hi = s.hi / MAX_SPEED;
+    bar(312, 'GIRO', Math.abs(c.speed) / MAX_SPEED, [[0, lo, '#8a3a2a'], [lo, hi, '#4f8a3a'], [hi, 1, '#b3402a']], '#fff4c8');
+    const top = BURNT * 1.15;
+    bar(334, 'COTTURA', doneness(c) / top, [[0, COOKED / top, '#b07a4a'], [COOKED / top, BURNT / top, '#6a8a3a'], [BURNT / top, 1, '#2a2420']], '#fff4c8');
+}
+function result(ctx, c) {
+    const r = c.result;
+    panel(ctx, 170, 120, 300, 104);
+    text(ctx, r.winner === 'player' ? 'BRUCIATE COI FIOCCHI!' : 'BRUCIATE COSÌ COSÌ', 320, 140, 8, '#efd49e', 'center');
+    const rows = [['Buone', r.good, '#9fd27a'], ['Crude', r.raw, '#e0b07a'], ['Carbonizzate', r.burnt, '#c0b0a0'], ['Nel fuoco', r.spilled, '#f08a5a']];
+    rows.forEach(([label, n, color], i) => { text(ctx, label, 200, 162 + i * 13, 6, color); text(ctx, `${n}`, 440, 162 + i * 13, 6, color, 'right'); });
+    text(ctx, `Ne servivano ${r.goal} su ${N}`, 320, 216, 5, '#d7ccb4', 'center');
+}
+
+export function drawBruciate(ctx, c, def, bg) {
+    const time = c.visual.time;
+    ctx.save();
+    if (bg) ctx.drawImage(bg, 0, 0, 640, 360);
+    else { ctx.fillStyle = '#6a5a40'; ctx.fillRect(0, 0, 640, 360); }
+    hanger(ctx);
+    // Il fondo del cilindro, scuro, col bagliore della brace sotto; poi le fiamme dietro e la rete di dietro.
+    ctx.fillStyle = 'rgba(74,46,30,0.72)'; ctx.fillRect(DRUM.x0, DRUM.y - DRUM.r, DRUM.x1 - DRUM.x0, DRUM.r * 2);
+    ctx.fillStyle = 'rgba(240,120,40,0.18)'; ctx.fillRect(DRUM.x0, DRUM.y + DRUM.r * 0.3, DRUM.x1 - DRUM.x0, DRUM.r * 0.7);
+    flames(ctx, time, false);
+    mesh(ctx, c, false);
+    // Le castagne: da dietro a davanti. Rovesciandole, scivolano tutte verso il sacco.
+    const pour = c.step === 'pour' ? Math.min(1, c.t / POUR) : c.step === 'result' ? 1 : 0;
+    const ks = (pour ? c.chestnuts.filter(k => !k.out) : inside(c)).map(k => ({ k, ...place(k) })).sort((p, q) => p.z - q.z);
+    for (const p of ks) {
+        if (pour) {
+            const d = Math.min(1, Math.max(0, pour * 1.6 - p.k.x * 0.6)), x = lerp(p.x, SACK.x, d), y = lerp(p.y, SACK.y, d) - Math.sin(d * Math.PI) * 40;
+            if (d < 1) chestnut(ctx, x, y, p.k.cook, 1);
+        } else chestnut(ctx, p.x, p.y, p.k.cook, p.z);
+    }
+    mesh(ctx, c, true);
+    flames(ctx, time, true);
+    crank(ctx, c, time);
+    // Quelle che volano nel fuoco, e lo sbuffo quando ci cascano.
+    for (const f of c.flying) {
+        const k = Math.min(1, f.t / 0.6), x = f.x + f.dir * 60 * k, y = lerp(f.y, FIRE - 6, k) - Math.sin(k * Math.PI) * 50;
+        if (f.t < 0.6) chestnut(ctx, x, y, 0.5);
+        else for (let i = 0; i < 4; i++) {
+            const s = (f.t - 0.6) / 0.6;
+            ctx.fillStyle = `rgba(200,195,185,${0.6 * (1 - s)})`;
+            ctx.beginPath(); ctx.arc(x + (i - 1.5) * 5 * (1 + s), FIRE - 10 - s * 30 - i * 3, 4 + s * 6, 0, Math.PI * 2); ctx.fill();
+        }
+    }
+    if (c.step === 'result') result(ctx, c); else gauges(ctx, c);
+    ctx.restore();
+}

src/engine/bruciate.js

@@ -0,0 +1,162 @@
+// Le bruciate della Smarronata (Andrea, 31 ottobre: «a manovella, a mano, fallo così»): coi volontari della
+// Misericordia si gira la manovella del cilindro a rete sopra il fuoco. Il gesto: tenendo premuto si fanno dei giri,
+// grandi o piccoli, dove si vuole (conta quanto gira la direzione del dito, non dove sta), come la manovella vera.
+// Le castagne stanno in fondo al cilindro: girando, la rete le alza e loro ricascano e si rimescolano. Troppo piano,
+// quelle di sotto restano sulla brace e si carbonizzano mentre quelle di sopra restano crude; troppo forte, la rete
+// le porta in cima e qualcuna salta fuori nel fuoco («mica si fa la centrifuga!»). Quando paiono cotte si rovesciano
+// nel sacco: contano quelle buone, né crude né bruciate. Per chi non può fare il gesto: Spazio, le frecce o il
+// pulsante Gira danno una spinta a ogni colpo. Unità: i pixel del primo piano 640×360, visto di fronte (sfondo di
+// Codex: assets/closeups/smarronata-bruciatore.png).
+
+// Il cilindro (fra le due forcelle dello sfondo) e la manovella, a destra: un giro visto di sbieco, un'ellisse.
+export const DRUM = { x0: 182, x1: 456, y: 190, r: 46 }, CRANK = { x: 506, y: 190, rx: 14, ry: 30 }, BAR = 92;
+export const N = 18, BOTTOM = Math.PI / 2;
+// Tempi in secondi; velocità in radianti al secondo.
+export const MIN_POUR = 4, POUR = 1.4, SPILL = 0.45, PUSH = 2.6, FRICTION = 1.4, LINE = 2.4, MAX_SPEED = 22;
+// Quando una castagna è cotta e quando è carbonizzata.
+export const COOKED = 0.85, BURNT = 1.6;
+// I livelli: sotto `lo` il cilindro gira troppo piano (le castagne non si rimescolano abbastanza), sopra `hi` le
+// castagne volano fuori; `time`, in quanti secondi cuociono girando bene; `goal`, quante buone ci vogliono.
+export const LEVELS = {
+    bona: { lo: 1.6, hi: 10, time: 20, goal: 10 },
+    seria: { lo: 2.2, hi: 8, time: 17, goal: 15 },
+    male: { lo: 2.8, hi: 6.5, time: 14, goal: 16 },
+};
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+const wrap = a => Math.atan2(Math.sin(a), Math.cos(a));
+function random(c) { c.seed = (Math.imul(c.seed, 1664525) + 1013904223) >>> 0; return c.seed / 4294967296; }
+const between = (c, lo, hi) => lo + (hi - lo) * random(c);
+
+// Dove ricasca una castagna: di nuovo in fondo, a un'altezza a caso nel mucchio, con la sua voglia di farsi alzare.
+function drop(c, k, side = 1) { Object.assign(k, { a: BOTTOM - side * between(c, 0, 0.55), r: between(c, 0.5, 0.93), lift: between(c, 0.55, 1.5) }); }
+
+export function newBruciate(seed = Date.now() >>> 0, def = {}) {
+    const level = LEVELS[def.level] ? def.level : 'seria';
+    const c = { step: 'turn', t: 0, seed, level, skill: LEVELS[level], current: 'player', power: 0, drum: 0, speed: 0,
+        pending: 0, grab: null, cursor: null, spin: 0, chestnuts: [], flying: [], line: null, lineT: 0, events: [], visual: { time: 0 } };
+    for (let i = 0; i < N; i++) { const k = { x: between(c, 0.06, 0.94), cook: between(c, 0, 0.08), out: false }; drop(c, k, random(c) < 0.5 ? 1 : -1); c.chestnuts.push(k); }
+    return c;
+}
+export const inside = c => c.chestnuts.filter(k => !k.out);
+// Quanto stanno a contatto con la rete sopra la brace: le castagne in fondo e di fuori; quelle di sopra quasi niente.
+export function contact(k) { return Math.max(0, Math.cos(k.a - BOTTOM)) ** 3 * clamp((k.r - 0.62) / 0.3, 0, 1); }
+// La cottura media delle castagne ancora nel cilindro, da 0 (crude) in su (1: cotte).
+export const doneness = c => { const ks = inside(c); return ks.length ? ks.reduce((s, k) => s + k.cook, 0) / ks.length : 0; };
+export const tally = c => {
+    const t = { good: 0, raw: 0, burnt: 0, spilled: 0 };
+    for (const k of c.chestnuts) t[k.out ? 'spilled' : k.cook < COOKED ? 'raw' : k.cook > BURNT ? 'burnt' : 'good']++;
+    return t;
+};
+function say(c, line) { c.line = line; c.lineT = LINE; }
+
+export function update(c, dt) {
+    if (!Number.isFinite(dt) || dt <= 0) return;
+    dt = Math.min(dt, 0.25); c.t += dt; c.visual.time += dt;
+    if (c.lineT > 0 && (c.lineT -= dt) <= 0) c.line = null;
+    for (const f of c.flying) f.t += dt;
+    c.flying = c.flying.filter(f => f.t < 1.2);
+    if (c.step === 'pour') { if (c.t >= POUR) finish(c); return; }
+    if (c.step !== 'turn') return;
+    // La velocità: tenendo la manovella è quella del gesto (smussata); lasciata, il cilindro rallenta da sé.
+    if (c.grab) c.speed += (c.pending / dt - c.speed) * (1 - Math.exp(-dt * 10));
+    else c.speed *= Math.exp(-FRICTION * dt);
+    c.pending = 0;
+    c.speed = clamp(c.speed, -MAX_SPEED, MAX_SPEED);
+    const w = c.speed, fast = Math.abs(w) > c.skill.hi, side = Math.sign(w) || 1, before = c.drum;
+    c.drum += w * dt;
+    // Il cigolio della manovella, a ogni mezzo giro.
+    if (Math.floor(before / Math.PI) !== Math.floor(c.drum / Math.PI)) c.events.push({ kind: 'bruciate-manovella', power: clamp(Math.abs(w) / 8, 0.3, 1) });
+    const rate = 1 / (c.skill.time * 0.45);
+    for (const k of inside(c)) {
+        // La rete se le porta dietro finché non ricascano in fondo; troppo forte le porta fino in cima e oltre.
+        k.a += w * dt * k.r;
+        if (!fast && (k.a - BOTTOM) * side > k.lift) drop(c, k, side);
+        const before = k.cook;
+        k.cook += dt * rate * (0.15 + 1.9 * contact(k));
+        if (before < COOKED && k.cook >= COOKED) c.events.push({ kind: 'bruciate-scoppio', power: 0.5 + 0.5 * random(c) });
+    }
+    // La centrifuga: ogni tanto ne vola fuori una, nel fuoco.
+    if (fast) {
+        c.spin += dt;
+        if (c.spin >= SPILL) {
+            c.spin = 0;
+            const k = inside(c).sort((p, q) => Math.cos(p.a - BOTTOM) - Math.cos(q.a - BOTTOM))[0];
+            if (k) { k.out = true; c.flying.push({ x: DRUM.x0 + k.x * (DRUM.x1 - DRUM.x0), y: DRUM.y + Math.sin(k.a) * DRUM.r * k.r, dir: side, t: 0 }); c.events.push({ kind: 'bruciate-cade', power: 0.8 }); }
+            say(c, random(c) < 0.5 ? 'Oh! Mica si fa la centrifuga!' : 'Piano, che le si butta nel fuoco!');
+        }
+    } else c.spin = Math.max(0, c.spin - dt);
+    if (!c.line && Math.abs(w) < c.skill.lo && c.t > 3 && inside(c).some(k => k.cook > BURNT - 0.3)) say(c, 'Gira, che sotto si bruciano!');
+    // Tutte nel fuoco o tutte carbone: si rovescia comunque.
+    if (!inside(c).length || inside(c).every(k => k.cook > BURNT)) pour(c);
+}
+function finish(c) {
+    const t = tally(c);
+    c.step = 'result'; c.speed = 0;
+    c.result = { winner: t.good >= c.skill.goal ? 'player' : 'cpu', ...t, goal: c.skill.goal };
+}
+export function pour(c) {
+    if (c.step !== 'turn') return false;
+    Object.assign(c, { step: 'pour', t: 0, grab: null });
+    c.events.push({ kind: 'bruciate-sacco', power: 0.8 });
+    return true;
+}
+
+// --- Comandi. Il gesto: la direzione del movimento, a ogni tratto, quanto ha girato rispetto al tratto prima.
+const STROKE = 3;
+export function aimScreen(c, [x, y]) {
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return false;
+    const g = c.grab;
+    if (g && c.step === 'turn') {
+        const [px, py] = g.last ?? [x, y], dx = x - px, dy = y - py;
+        if (Math.hypot(dx, dy) >= STROKE) {
+            const heading = Math.atan2(dy, dx);
+            if (g.heading !== null) c.pending += clamp(wrap(heading - g.heading), -1.2, 1.2);
+            g.heading = heading; g.last = [x, y];
+        } else if (!g.last) g.last = [x, y];
+    }
+    c.cursor = [x, y];
+    return true;
+}
+export function press(c, pointerId) {
+    if (c.step !== 'turn' || c.grab) return false;
+    c.grab = { pointerId, heading: null, last: c.cursor };
+    return true;
+}
+export function release(c, pointerId) {
+    if (!c.grab || c.grab.pointerId !== pointerId) return false;
+    c.grab = null; return true;
+}
+export const cancel = (c, pointerId) => (pointerId === undefined || c.grab?.pointerId === pointerId) && release(c, c.grab?.pointerId);
+// Una spinta alla manovella (Spazio, frecce): per chi non fa il gesto.
+export function push(c) {
+    if (c.step !== 'turn' || c.grab) return false;
+    c.speed = (Math.sign(c.speed) || 1) * (Math.abs(c.speed) + PUSH);
+    return true;
+}
+export function key(c, k, down) {
+    if (k === 'Enter') { if (down) shoot(c); return true; }
+    if (![' ', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(k)) return false;
+    if (down) push(c);
+    return true;
+}
+// Il pulsante: rovescia nel sacco (dopo i primi secondi).
+export const canThrow = c => c.step === 'turn' && c.t >= MIN_POUR;
+export const canAdjust = () => false;
+export const aimFree = () => true;
+export const shoot = c => canThrow(c) && pour(c);
+export const button = c => c.step === 'result' ? 'Finita' : c.step === 'pour' ? 'Nel sacco…' : 'Rovescia nel sacco';
+export function speedWord(c) {
+    const w = Math.abs(c.speed);
+    return w < 0.3 ? 'ferma' : w < c.skill.lo ? 'troppo piano' : w > c.skill.hi ? 'troppo forte' : 'giusta';
+}
+export function status(c) {
+    if (c.step === 'result') {
+        const r = c.result, extra = [r.raw && `${r.raw} crude`, r.burnt && `${r.burnt} carbonizzate`, r.spilled && `${r.spilled} nel fuoco`].filter(Boolean).join(', ');
+        return `${r.good} bruciate buone su ${N}${extra ? ` (${extra})` : ''}. ${r.winner === 'player' ? 'I volontari approvano!' : `Ne servivano ${r.goal}.`}`;
+    }
+    if (c.step === 'pour') return 'Nel sacco di iuta, a sudare...';
+    const cooked = `Cottura ${Math.round(doneness(c) * 100)}%.`;
+    if (c.line) return `${c.line} ${cooked}`;
+    const hint = c.t < 3 && Math.abs(c.speed) < 0.3 ? 'Tieni premuto e fai dei giri per girare la manovella.' : `Manovella ${speedWord(c)}.`;
+    return `${hint} ${cooked} Quando son cotte: Rovescia nel sacco.`;
+}

src/engine/flipper-art.js

@@ -0,0 +1,185 @@
+// Illustrazioni vettoriali del backglass, riusate come inserti in lacca sul campo.
+import { activeBalls } from './flipper.js';
+
+export const SCENES = {
+    regolo: { color: '#91f5b1', title: 'IL REGOLO SI RISVEGLIA', note: 'IL CUSTODE DELLA SIEVE', at: [320, 193] },
+    fortezza: { color: '#65ddec', title: 'LA FORTEZZA SI ACCENDE', note: 'SOPRA I BASTIONI', at: [320, 119] },
+    trebbio: { color: '#ffc16c', title: 'LA TORRE DEL TREBBIO', note: 'UN PASSAGGIO NELLA STORIA', at: [365, 164] },
+    pieve: { color: '#ffaccc', title: 'LE LUCI DELLA PIEVE', note: 'NEL CUORE DEL PAESE', at: [240, 174] },
+    rioni: { color: '#ffe6a0', title: 'I COLORI DEI RIONI', note: 'QUATTRO COLORI, UN PAESE', at: [320, 88] },
+    sieve: { color: '#6fcfff', title: 'SULLE ONDE DELLA SIEVE', note: 'IL VIAGGIO CONTINUA', at: [320, 280] },
+    cosmo: { color: '#dba5ff', title: 'IL REGOLO DEL FUTURO', note: 'OLTRE IL TEMPO', at: [320, 193] },
+    spira: { color: '#ff729e', title: 'NELLA SPIRA AL NEON', note: 'ENERGIA IN MOVIMENTO', at: [376, 170] },
+};
+const RAMP_SCENE = { sinistra: 'fortezza', destra: 'trebbio', super: 'cosmo', orbita: 'cosmo', ponte: 'fortezza', spira: 'spira' };
+
+// Solo lettura: nessun evento, punteggio o numero casuale della simulazione viene consumato dal disegno.
+export function flipperScene(c) {
+    const balls = activeBalls(c).filter(b => !b.waiting && b.releaseAt <= c.sim);
+    if (c.regolo.hit > 0 || balls.some(b => !b.ramp && Math.hypot(b.x - c.regolo.x, b.y - c.regolo.y) < 33)) return 'regolo';
+    const ramp = Object.keys(RAMP_SCENE).find(id => balls.some(b => b.ramp?.id === id));
+    if (ramp) return RAMP_SCENE[ramp];
+    if (!balls.length) return c.table === 'future' ? 'cosmo' : 'regolo';
+    if (c.bumpers.some(b => b.hit > 0)) return 'fortezza';
+    // Priorità stabile anche in multiball, indipendente dall'ordine delle palline.
+    if (balls.some(b => b.y < 106)) return c.table === 'future' ? 'cosmo' : 'rioni';
+    if (balls.some(b => b.x < 242 && b.y < 218)) return 'pieve';
+    if (balls.some(b => b.x > 398 && b.x < 432 && b.y < 218)) return 'trebbio';
+    if (balls.some(b => b.y < 180)) return 'fortezza';
+    if (balls.some(b => b.y < 244)) return c.table === 'future' ? 'cosmo' : 'regolo';
+    return 'sieve';
+}
+const TAU = Math.PI * 2;
+function stroke(g, pts, color, width = 1) {
+    g.beginPath(); pts.forEach(([x, y], i) => i ? g.lineTo(x, y) : g.moveTo(x, y));
+    g.strokeStyle = color; g.lineWidth = width; g.stroke();
+}
+function fill(g, pts, color) {
+    g.beginPath(); pts.forEach(([x, y], i) => i ? g.lineTo(x, y) : g.moveTo(x, y));
+    g.closePath(); g.fillStyle = color; g.fill();
+}
+function circle(g, x, y, r, color) { g.beginPath(); g.arc(x, y, r, 0, TAU); g.fillStyle = color; g.fill(); }
+
+export function paintRegolo(g, x, y, size, color = '#91f5b1') {
+    g.save(); g.translate(x, y); g.scale(size / 30, size / 30); g.lineCap = 'round'; g.lineJoin = 'round';
+    // Un serpente a spire, con ventre dorato, cresta, occhio e corona: leggibile anche come piccolo emblema.
+    const body = () => {
+        g.beginPath(); g.moveTo(-29, 22);
+        g.bezierCurveTo(-8, 28, 29, 23, 23, 7);
+        g.bezierCurveTo(17, -9, -24, 0, -18, 13);
+        g.bezierCurveTo(-13, 24, 13, 12, 9, 0);
+        g.bezierCurveTo(5, -11, -9, -9, -4, -23);
+    };
+    body(); g.strokeStyle = '#061d26'; g.lineWidth = 12; g.stroke();
+    body(); g.strokeStyle = color; g.lineWidth = 8; g.stroke();
+    body(); g.strokeStyle = '#153f43'; g.lineWidth = 4.6; g.stroke();
+    g.save(); g.translate(0, 2); body(); g.strokeStyle = '#ffe5a6'; g.lineWidth = 1.1; g.stroke(); g.restore();
+    for (let i = 0; i < 7; i++) {
+        const a = i * 0.36;
+        stroke(g, [[-16 + i * 5, 20 - Math.sin(a) * 3], [-15 + i * 5, 17 - Math.sin(a) * 3]], color, 1);
+    }
+    fill(g, [[-9, -26], [-4, -31], [5, -29], [12, -23], [9, -18], [0, -18], [-5, -14]], color);
+    stroke(g, [[3, -18], [11, -19], [15, -17], [18, -19]], '#ff92a7', 1);
+    circle(g, 4, -25, 2.1, '#071821'); circle(g, 4.5, -25.6, 0.8, '#ffffff');
+    fill(g, [[-8, -33], [-11, -43], [-4, -38], [0, -47], [5, -38], [12, -43], [8, -33]], '#ffdc88');
+    stroke(g, [[-8, -32], [8, -32]], '#fff5d5', 1.6); circle(g, 0, -38, 1.4, '#ff729e');
+    g.restore();
+}
+
+export function paintZoneSymbol(g, id) {
+    const { color, at: [x, y] } = SCENES[id];
+    g.save(); g.translate(x, y); g.lineJoin = 'round';
+    if (id === 'fortezza' || id === 'trebbio' || id === 'pieve') {
+        const roof = id === 'pieve' ? [[-12, -2], [0, -13], [12, -2]]
+            : id === 'trebbio' ? [[-7, 8], [-7, -14], [-3, -14], [-3, -10], [3, -10], [3, -14], [7, -14], [7, 8]]
+                : [[-14, 7], [-14, -7], [-9, -7], [-9, -3], [-4, -3], [-4, -10], [4, -10], [4, -3], [9, -3], [9, -7], [14, -7], [14, 7]];
+        stroke(g, roof, color, 1.3);
+        stroke(g, [[-10, 0], [-10, 9], [10, 9], [10, 0]], color, 0.8);
+        stroke(g, [[-3, 8], [-3, 2], [0, -1], [3, 2], [3, 8]], '#fff1c1', 0.8);
+    } else if (id === 'rioni') {
+        for (let i = 0; i < 4; i++) {
+            const px = -15 + i * 10;
+            fill(g, [[px, -10], [px + 7, -10], [px + 7, 3], [px + 3.5, 7], [px, 3]], ['#f97980', '#f7eac9', '#78e2ad', '#7bb6ff'][i]);
+        }
+    } else if (id === 'sieve') {
+        for (let i = 0; i < 3; i++) {
+            g.beginPath(); g.moveTo(-19, -6 + i * 6); g.bezierCurveTo(-8, -14 + i * 6, 8, 2 + i * 6, 19, -6 + i * 6);
+            g.strokeStyle = color; g.lineWidth = 1.2; g.stroke();
+        }
+    } else if (id === 'spira') {
+        for (let i = 0; i < 3; i++) {
+            g.beginPath(); g.ellipse(0, 0, 6 + i * 5, 4 + i * 4, -0.5, 0, TAU);
+            g.strokeStyle = color; g.lineWidth = 0.9; g.stroke();
+        }
+    }
+    g.restore();
+}
+
+function fortress(g, tower, color) {
+    fill(g, [[18, 69], [18, 43], [28, 39], [28, 32], [35, 32], [35, 41], [51, 40], [51, 29], [61, 29], [61, 39], [87, 37], [87, 26], [97, 26], [97, 36], [119, 34], [119, 29], [129, 29], [129, 65]], '#163648');
+    stroke(g, [[18, 43], [35, 41], [51, 40], [61, 39], [87, 37], [97, 36], [129, 34]], color, 1.5);
+    if (tower) {
+        fill(g, [[61, 63], [61, 14], [66, 14], [66, 19], [73, 19], [73, 12], [79, 12], [79, 19], [86, 19], [86, 14], [91, 14], [91, 63]], '#365062');
+        stroke(g, [[61, 63], [61, 14], [66, 14]], color, 1.3);
+        for (const y of [27, 40, 53]) { g.fillStyle = '#ffd590'; g.fillRect(73, y, 5, 7); }
+    }
+    for (let y = 46; y < 67; y += 7) stroke(g, [[22, y], [126, y - 6]], '#426076', 0.5);
+    for (const x of [33, 49, 101, 117]) { g.fillStyle = color; g.fillRect(x, 47, 2, 6); }
+    fill(g, [[67, 70], [67, 55], [73, 50], [80, 55], [80, 70]], '#071927');
+    stroke(g, [[14, 72], [74, 65], [135, 70]], color, 1);
+}
+
+// Una scena di 150 × 88, interamente in cache nel renderer.
+export function paintFlipperScene(g, id) {
+    const color = SCENES[id].color;
+    const sky = g.createLinearGradient(0, 0, 150, 88);
+    sky.addColorStop(0, '#071125'); sky.addColorStop(0.6, id === 'trebbio' ? '#38273b' : '#15364a'); sky.addColorStop(1, '#071925');
+    g.fillStyle = sky; g.fillRect(0, 0, 150, 88);
+    circle(g, 120, 19, 13, color + '18'); circle(g, 120, 19, 8, '#fff0be'); circle(g, 117, 16, 7, '#153044');
+    for (let i = 0; i < 20; i++) circle(g, (i * 47 + 13) % 150, (i * 23 + 9) % 57, i % 3 ? 0.5 : 0.9, color + 'aa');
+    fill(g, [[0, 59], [21, 37], [44, 53], [77, 27], [108, 51], [139, 33], [150, 40], [150, 88], [0, 88]], '#142b3c');
+    fill(g, [[0, 74], [39, 53], [67, 64], [99, 44], [150, 62], [150, 88], [0, 88]], '#1f4350');
+    for (let i = 0; i < 5; i++) {
+        g.beginPath(); g.moveTo(0, 74 + i * 3); g.bezierCurveTo(52, 58 + i * 3, 78, 91 + i * 2, 150, 67 + i * 4);
+        g.strokeStyle = i % 2 ? '#69b6ce66' : '#102837'; g.lineWidth = 1; g.stroke();
+    }
+    if (id === 'fortezza' || id === 'trebbio') fortress(g, id === 'trebbio', color);
+    else if (id === 'pieve') {
+        fill(g, [[30, 69], [30, 43], [59, 25], [87, 43], [87, 69]], '#406077');
+        fill(g, [[87, 68], [87, 23], [94, 13], [101, 23], [101, 68]], '#29495e');
+        stroke(g, [[26, 44], [59, 22], [90, 44]], color, 2);
+        circle(g, 59, 43, 7, '#142a3e'); circle(g, 59, 43, 4, '#ffc8de');
+        fill(g, [[52, 69], [52, 58], [59, 53], [66, 58], [66, 69]], '#102334');
+        g.fillStyle = '#ffdfa2'; g.fillRect(91, 28, 6, 9);
+    } else if (id === 'rioni') {
+        ['#f97980', '#f7eac9', '#78e2ad', '#7bb6ff'].forEach((c, i) => {
+            const x = 24 + i * 29, y = 23 + (i % 2) * 5;
+            stroke(g, [[x, y - 4], [x, 69]], '#d5c7a1', 1.2);
+            fill(g, [[x + 2, y], [x + 23, y + 3], [x + 23, y + 30], [x + 12, y + 38], [x + 2, y + 30]], c);
+            stroke(g, [[x + 12, y + 7], [x + 12, y + 27]], '#213347', 2);
+            stroke(g, [[x + 6, y + 17], [x + 18, y + 17]], '#213347', 2);
+        });
+    } else if (id === 'sieve') {
+        g.beginPath(); g.moveTo(10, 65); g.quadraticCurveTo(74, 9, 140, 65);
+        g.strokeStyle = '#0a1b2c'; g.lineWidth = 10; g.stroke(); g.strokeStyle = color; g.lineWidth = 2; g.stroke();
+        for (const x of [28, 49, 74, 99, 122]) stroke(g, [[x, 49 - Math.sin(x / 150 * Math.PI) * 10], [x, 73]], '#5f8b9f', 3);
+        paintRegolo(g, 77, 70, 12, '#91f5b1');
+    } else {
+        for (let i = 0; i < 3; i++) {
+            g.beginPath(); g.ellipse(75, 44, 28 + i * 12, 23 + i * 8, -0.4 + i * 0.3, 0, TAU);
+            g.strokeStyle = color + (i ? '55' : 'aa'); g.lineWidth = 0.8; g.stroke();
+        }
+        paintRegolo(g, 75, 51, id === 'spira' ? 26 : 30, color);
+    }
+    // Riflessi e retino del vetro inciso.
+    for (let y = 2; y < 88; y += 3) stroke(g, [[0, y], [150, y]], '#050f1c22', 0.5);
+}
+
+export function paintPlayfieldArt(g, future = false) {
+    const color = future ? '#ad8cff' : '#74c5bd';
+    g.save();
+    // Rosone centrale, smalti e serpente coronato sotto il piano di gioco.
+    for (const r of [30, 33, 43]) {
+        g.beginPath(); g.ellipse(320, 194, r, r * 0.83, 0, 0, TAU);
+        g.strokeStyle = color + '55'; g.lineWidth = r === 33 ? 1.4 : 0.6; g.stroke();
+    }
+    for (let i = 0; i < 16; i++) {
+        const a = i / 16 * TAU;
+        stroke(g, [[320 + Math.cos(a) * 37, 194 + Math.sin(a) * 31], [320 + Math.cos(a) * 41, 194 + Math.sin(a) * 34]], '#d6be7855', 0.8);
+    }
+    g.globalAlpha = 0.46; paintRegolo(g, 320, 202, 25, color); g.globalAlpha = 1;
+    for (const [x, side, tint] of [[239, -1, '#65ddec'], [402, 1, '#ffc16c']]) {
+        stroke(g, [[x, 217], [x - side * 10, 230], [x - side * 10, 242]], tint + '66', 1);
+        for (let i = 0; i < 3; i++) fill(g, [[x, 209 + i * 8], [x + 2, 212 + i * 8], [x, 215 + i * 8], [x - 2, 212 + i * 8]], tint + '88');
+    }
+    // Filetti dorati delle sponde e frecce smaltate verso le palette.
+    for (const side of [-1, 1]) {
+        const x = 320 + side * 67;
+        stroke(g, [[x, 263], [x - side * 14, 279], [x - side * 22, 300]], '#e7c88955', 0.8);
+        for (let i = 0; i < 3; i++) {
+            const cx = x - side * i * 7, y = 274 + i * 10;
+            stroke(g, [[cx - 3, y - 2], [cx, y + 1], [cx + 3, y - 2]], color + '77', 1);
+        }
+    }
+    g.restore();
+}

src/engine/flipper-render.js

@@ -0,0 +1,694 @@
+// Il Regolo / River: tavolo in lacca scura, metallo e inserti luminosi.
+// Le coordinate sono quelle della fisica. Le superfici statiche e i bagliori sono in cache a risoluzione doppia.
+import { R, SCORE, RAMP, FUTURE, PLUNGER_ZONE, layout, flipperSeg, alongRamp, rampHeight, waiting, canThrow, saveLeft, activeBalls, multiball, rampOpen } from './flipper.js';
+import { ambientHash as hash } from './ambient.js';
+import { SCENES, flipperScene, paintRegolo, paintZoneSymbol, paintFlipperScene, paintPlayfieldArt } from './flipper-art.js';
+
+const INK = '#071018', WHITE = '#eff9ff', MUTED = '#7b99aa';
+const TINT = { sinistra: '#65ddec', destra: '#ffc16c', super: '#dba5ff', orbita: '#58f4e2', ponte: '#c1a0ff', spira: '#ff729e' };
+const RIONI = ['#f97980', '#f7eac9', '#78e2ad', '#7bb6ff'];
+const TAU = Math.PI * 2, clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+const number = n => Math.round(n).toLocaleString('it-IT');
+function text(g, value, x, y, size = 7, color = WHITE, align = 'left', font = 'sans-serif', weight = 600) {
+    g.font = `${weight} ${size}px ${font}`; g.textAlign = align; g.textBaseline = 'middle'; g.fillStyle = color; g.fillText(value, x, y);
+}
+function path(g, points, close = false) {
+    g.beginPath(); points.forEach((p, i) => i ? g.lineTo(p[0], p[1]) : g.moveTo(p[0], p[1])); if (close) g.closePath();
+}
+function line(g, points, color, width = 1) { path(g, points); g.strokeStyle = color; g.lineWidth = width; g.stroke(); }
+function poly(g, points, color, edge) { path(g, points, true); g.fillStyle = color; g.fill(); if (edge) { g.strokeStyle = edge; g.lineWidth = 0.7; g.stroke(); } }
+function disc(g, x, y, r, color, edge) {
+    g.beginPath(); g.arc(x, y, r, 0, TAU); g.fillStyle = color; g.fill();
+    if (edge) { g.strokeStyle = edge; g.lineWidth = 0.7; g.stroke(); }
+}
+function box(g, x, y, w, h, color, edge, radius = 5) {
+    g.beginPath(); g.roundRect(x, y, w, h, radius); g.fillStyle = color; g.fill();
+    if (edge) { g.strokeStyle = edge; g.lineWidth = 0.7; g.stroke(); }
+}
+function gradient(g, x, y, w, h, stops) {
+    const v = g.createLinearGradient(x, y, x + w, y + h); stops.forEach(([at, color]) => v.addColorStop(at, color)); return v;
+}
+function metal(g, x, y, w = 20, h = 20) {
+    return gradient(g, x, y, w, h, [[0, '#f1f8f6'], [0.2, '#8b9da6'], [0.46, '#263641'], [0.62, '#c4d5dc'], [1, '#354a58']]);
+}
+function screw(g, x, y) { disc(g, x, y, 1.4, '#9caeb3', '#17262f'); line(g, [[x - 0.6, y + 0.6], [x + 0.6, y - 0.6]], '#273b47', 0.7); }
+const glowCache = new Map();
+function glow(g, x, y, radius, color, alpha = 1) {
+    if (typeof document === 'undefined') return;
+    let sprite = glowCache.get(color);
+    if (!sprite) {
+        sprite = Object.assign(document.createElement('canvas'), { width: 96, height: 96 });
+        const s = sprite.getContext('2d'), v = s.createRadialGradient(48, 48, 0, 48, 48, 48);
+        v.addColorStop(0, color + 'b0'); v.addColorStop(0.22, color + '50'); v.addColorStop(0.6, color + '15'); v.addColorStop(1, color + '00');
+        s.fillStyle = v; s.fillRect(0, 0, 96, 96); glowCache.set(color, sprite);
+    }
+    g.save(); g.globalAlpha *= alpha; g.globalCompositeOperation = 'screen'; g.drawImage(sprite, x - radius, y - radius, radius * 2, radius * 2); g.restore();
+}
+const layers = new Map();
+function layerOf(key, paint, bounds) {
+    let layer = layers.get(key);
+    if (!layer) {
+        layer = Object.assign(document.createElement('canvas'), { width: bounds[2] * 2, height: bounds[3] * 2 });
+        const l = layer.getContext('2d'); l.scale(2, 2); l.translate(-bounds[0], -bounds[1]); paint(l); layers.set(key, layer);
+    }
+    return layer;
+}
+function cached(g, key, paint, bounds = [0, 0, 640, 360]) {
+    if (typeof document === 'undefined') { paint(g); return; }
+    g.drawImage(layerOf(key, paint, bounds), ...bounds);
+}
+// Il display cambia con il percorso. Una breve permanenza e la dissolvenza evitano il tremolio sui confini.
+const apparitions = new WeakMap();
+function apparition(c, time) {
+    const next = flipperScene(c);
+    let d = apparitions.get(c);
+    if (!d || time < d.at || d.table !== c.table) {
+        d = { id: next, previous: next, at: time, pending: next, since: time, table: c.table }; apparitions.set(c, d);
+    }
+    if (next !== d.pending) { d.pending = next; d.since = time; }
+    if (next !== d.id && ((c.regolo.hit > 0) || (time - d.at > 0.65 && time - d.since > 0.12))) {
+        d.previous = d.id; d.id = next; d.at = time;
+    }
+    return d;
+}
+function livingBackglass(g, c, time) {
+    const d = apparition(c, time), scene = SCENES[d.id], fade = clamp((time - d.at) / 0.32, 0, 1);
+    box(g, 22, 236, 154, 91, '#061422', scene.color, 5);
+    g.save(); g.beginPath(); g.roundRect(24, 238, 150, 87, 4); g.clip();
+    const paint = id => cached(g, `vision:${id}`, l => { l.save(); l.translate(24, 238); paintFlipperScene(l, id); l.restore(); }, [24, 238, 150, 88]);
+    paint(d.previous);
+    g.save(); g.globalAlpha = fade; paint(d.id); g.restore();
+    // Poche luci nel cielo, animate separatamente dall'illustrazione in cache.
+    for (let i = 0; i < 5; i++) {
+        const x = 36 + i * 29, y = 254 + Math.sin(time * 0.8 + i * 2) * 6;
+        glow(g, x, y, 5, scene.color, 0.35 + Math.sin(time * 2 + i) * 0.2);
+    }
+    g.fillStyle = '#030b18c9'; g.fillRect(24, 238, 150, 12); g.fillRect(24, 309, 150, 16);
+    text(g, scene.title, 99, 244, 5.7, scene.color, 'center');
+    text(g, scene.note, 99, 317, 5, '#e5e9d8', 'center');
+    g.restore();
+    for (const x of [19, 179]) {
+        glow(g, x, 280, 15, scene.color, 0.4);
+        line(g, [[x, 256], [x, 304]], scene.color, 1.2);
+    }
+}
+function livingPlayfield(g, c, time) {
+    const d = apparition(c, time), scene = SCENES[d.id], balls = activeBalls(c).filter(b => !b.waiting && b.releaseAt <= c.sim);
+    const pulse = 0.5 + Math.sin(time * 2.5) * 0.12;
+    // Il rosone si risveglia sotto gli oggetti: palline, palette e bersagli si disegnano dopo.
+    glow(g, ...scene.at, 49, scene.color, balls.length ? 0.48 : 0.2);
+    g.save(); g.globalAlpha = (d.id === 'regolo' || d.id === 'cosmo' ? 0.65 : 0.16) * pulse;
+    cached(g, `regolo-insert:${scene.color}`, l => paintRegolo(l, 320, 202, 25, scene.color), [290, 160, 60, 70]);
+    g.restore();
+    if (balls.length && d.id !== 'regolo' && d.id !== 'cosmo') {
+        g.save(); g.globalAlpha = clamp((time - d.at) / 0.3, 0, 0.7);
+        cached(g, `zone-insert:${d.id}`, l => paintZoneSymbol(l, d.id), [scene.at[0] - 22, scene.at[1] - 18, 44, 36]);
+        g.restore();
+    }
+    for (const side of [-1, 1]) for (let i = 0; i < 18; i++) {
+        const x = side < 0 ? 196 : 452, y = 43 + i * 16;
+        const near = balls.some(b => Math.abs(b.y - y) < 25 && (side < 0 ? b.x < 325 : b.x > 315));
+        const chase = (i + Math.floor(time * (balls.length ? 9 : 3))) % 7 === 0;
+        const color = near ? scene.color : i % 3 === 0 ? '#c9a5ff' : side < 0 ? TINT.sinistra : TINT.destra;
+        box(g, x - 1, y - 2, 2, 4, near || chase ? color : '#2b4351', null, 0.6);
+        if (near || chase) glow(g, x, y, near ? 10 : 6, color, near ? 0.6 : 0.3);
+    }
+    for (const b of balls) {
+        if (b.ramp) continue;
+        glow(g, b.x, b.y, 21, scene.color, 0.25);
+        // Piccoli inserti a rombo, accesi dalla vicinanza della pallina.
+        for (const [x, y] of [[272, 175], [367, 175], [292, 274], [348, 274], [320, 297]]) {
+            const near = Math.hypot(b.x - x, b.y - y) < 48;
+            if (!near) continue;
+            glow(g, x, y, 12, scene.color, 0.6);
+            poly(g, [[x, y - 3], [x + 2, y], [x, y + 3], [x - 2, y]], scene.color);
+        }
+    }
+}
+// Il mobile, che non cambia mai, sta sullo sfondo CSS della tela in pagina invece di essere copiato a ogni fotogramma:
+// una copia a tutto schermo fra gli altri tratti costava da sola mezzo secondo ogni 150 fotogrammi (swiftshader). La
+// tela si pulisce e il mobile resta sotto; si ridisegna sulla tela solo durante la scossa, che lo sposta.
+const sheets = new Map();
+function cabinetBehind(g, key, paint) {
+    const canvas = g.canvas;
+    if (typeof document === 'undefined' || !(canvas instanceof HTMLCanvasElement) || !canvas.isConnected) return false;
+    let url = sheets.get(key);
+    if (!url) { url = `url(${layerOf(key, paint, [0, 0, 640, 360]).toDataURL()})`; sheets.set(key, url); }
+    if (canvas.dataset.cabinet !== key) { canvas.style.backgroundImage = url; canvas.style.backgroundSize = '100% 100%'; canvas.dataset.cabinet = key; }
+    return true;
+}
+export function cabinetAway(canvas) { canvas.style.backgroundPosition = ''; canvas.style.backgroundImage = ''; canvas.style.backgroundSize = ''; delete canvas.dataset.cabinet; }
+function crown(g, x, y, size, color) {
+    poly(g, [[x - size, y + size / 2], [x - size * 1.1, y - size / 2], [x - size / 2, y], [x, y - size], [x + size / 2, y], [x + size * 1.1, y - size / 2], [x + size, y + size / 2]], color);
+    line(g, [[x - size, y + size * 0.8], [x + size, y + size * 0.8]], color, 1);
+}
+function outline(g, c) {
+    path(g, [[200, 336], ...c.walls.slice(0, 12).map(w => w.a), [448, 72], [448, 336]], true);
+}
+function cabinet(g, c, bg, glass) {
+    g.fillStyle = gradient(g, 0, 0, 640, 360, [[0, '#0c1924'], [0.5, '#02070d'], [1, '#101a24']]); g.fillRect(0, 0, 640, 360);
+    // Due colonne da backglass, incassate nel mobile. Il paese resta un'illustrazione nel riquadro di sinistra.
+    box(g, 12, 14, 174, 332, '#0c1721', '#243746', 9);
+    box(g, 467, 14, 161, 332, '#0c1721', '#243746', 9);
+    line(g, [[24, 20], [174, 20]], '#355263', 0.7); line(g, [[479, 20], [616, 20]], '#355263', 0.7);
+    for (const x of [19, 179, 474, 621]) for (const y of [21, 339]) screw(g, x, y);
+    if (glass) {
+        g.save(); g.beginPath(); g.roundRect(24, 237, 150, 88, 4); g.clip();
+        g.drawImage(glass, 0, 170, 200, 130, 24, 237, 150, 98);
+        g.fillStyle = 'rgba(6,18,28,0.38)'; g.fillRect(24, 237, 150, 88); g.restore();
+    } else if (bg) {
+        g.save(); g.globalAlpha = 0.25; g.drawImage(bg, 200, 30, 230, 280, 24, 237, 150, 88); g.restore();
+    }
+    text(g, 'SAN PIERO A SIEVE', 99, 333, 6, MUTED, 'center');
+    // Parete esterna, fianco e bisello: l'ombra scende sotto il piano, non sopra gli oggetti.
+    g.save(); g.translate(2, 7); outline(g, c); g.fillStyle = '#010306'; g.fill(); g.lineWidth = 18; g.strokeStyle = '#010306'; g.stroke(); g.restore();
+    outline(g, c); g.lineWidth = 16; g.strokeStyle = '#182430'; g.stroke();
+    g.lineWidth = 11; g.strokeStyle = metal(g, 194, 0, 250, 30); g.stroke();
+    g.lineWidth = 6; g.strokeStyle = '#050c12'; g.stroke();
+    g.fillStyle = gradient(g, 240, 5, 140, 320, [[0, '#10252d'], [0.5, '#102d31'], [1, '#071720']]); g.fill();
+    g.save(); outline(g, c); g.clip();
+    glow(g, 225, 138, 150, TINT.sinistra, 0.17); glow(g, 415, 202, 140, TINT.destra, 0.13);
+    // Incisione della Sieve nel piano in lacca; pochi segni, con spazio per leggere i tiri.
+    for (let i = 0; i < 7; i++) {
+        g.beginPath(); g.moveTo(305 + i * 3, 70); g.bezierCurveTo(230 + i * 3, 160, 414 + i * 2, 198, 302 + i * 4, 328);
+        g.strokeStyle = i === 3 ? '#2c6570' : '#173e47'; g.lineWidth = i === 3 ? 1.4 : 0.6; g.stroke();
+    }
+    for (let i = 0; i < 40; i++) { g.fillStyle = '#28434b'; disc(g, 212 + hash(i * 7) * 211, 20 + hash(i * 13) * 304, 0.35, '#28434b'); }
+    g.strokeStyle = '#27464d'; g.lineWidth = 0.6;
+    for (const radius of [34, 39, 71]) { g.beginPath(); g.ellipse(320, 182, radius, radius * 0.7, 0, 0, TAU); g.stroke(); }
+    crown(g, 320, 182, 12, '#31585b');
+    // I bastioni stilizzati al fondo del piano.
+    poly(g, [[278, 83], [278, 60], [286, 60], [286, 50], [296, 50], [296, 59], [307, 59], [307, 45], [318, 45], [318, 59], [329, 59], [329, 50], [340, 50], [340, 60], [352, 60], [352, 83]], '#1e3e43', '#365358');
+    text(g, 'LA FORTEZZA', 315, 77, 5.5, '#5c7d7d', 'center');
+    paintPlayfieldArt(g);
+    for (const [i, x] of [257, 297, 340, 381].entries()) {
+        poly(g, [[x - 5, 83], [x + 5, 83], [x + 5, 92], [x, 96], [x - 5, 92]], RIONI[i] + '88', '#d8d7ab66');
+        line(g, [[x, 85], [x, 91]], '#0b263b', 1.2);
+    }
+    // La corsia della molla è una scanalatura separata, con il fondo metallico.
+    g.fillStyle = gradient(g, 432, 0, 16, 0, [[0, '#01070b'], [0.3, '#213442'], [0.65, '#0c1922'], [1, '#304754']]); g.fillRect(432, 72, 16, 264);
+    line(g, [[440, 86], [440, 306]], '#45606c', 0.5);
+    g.restore();
+    // Plastiche sagomate delle sponde, con spessore e gomma viva sul bordo interno.
+    for (const side of [-1, 1]) {
+        const x = side < 0 ? 236 : 404, tip = x - side * 26, color = side < 0 ? TINT.sinistra : TINT.destra;
+        poly(g, [[x, 248], [x, 287], [tip, 294]], '#02070c');
+        poly(g, [[x, 246], [x, 284], [tip, 290]], gradient(g, x, 246, -side * 25, 40, [[0, '#52717e'], [0.15, '#163140'], [1, '#091723']]), '#7d9ca5');
+        poly(g, [[x - side * 4, 261], [x - side * 4, 281], [tip + side * 8, 284]], '#173c4b', color);
+        screw(g, x, 249); screw(g, x, 282); screw(g, tip + side * 4, 287);
+    }
+    g.lineCap = 'round'; g.lineJoin = 'round';
+    for (const w of c.walls) {
+        if (w.gate) continue;
+        const pts = [w.a, w.b];
+        g.save(); g.translate(1, 2); line(g, pts, '#02070c', 3.5); g.restore();
+        line(g, pts, w.sling ? '#8c453b' : '#526c78', 2.3);
+        line(g, pts, w.sling ? '#ffab7c' : '#bdd2d5', 0.7);
+    }
+    box(g, 198, 336, 252, 17, '#080f16', '#35515c', 2);
+    text(g, 'R I V E R', 218, 345, 7, '#d6c49d');
+    text(g, 'LOCK  /  JACKPOT  /  MULTIBALL', 431, 345, 5.5, MUTED, 'right');
+    for (const side of [-1, 1]) for (let i = 0; i < 6; i++) {
+        const x = side < 0 ? 197 : 451, y = 106 + i * 36, color = side < 0 ? TINT.sinistra : TINT.destra;
+        glow(g, x, y, 14, color, 0.4); box(g, x - 0.7, y - 5, 1.4, 10, color, null, 0.7);
+    }
+}
+function rampPoint(r, s) {
+    const p = alongRamp(r, s), z = rampHeight(r, s); return { ...p, y: p.y - 1 - 8 * z };
+}
+function paintTrack(g, r) {
+    const pts = r.cum.map(s => { const p = rampPoint(r, s); return [p.x, p.y]; }), color = TINT[r.id];
+    g.lineCap = 'round'; g.lineJoin = 'round';
+    // Piedini e ombra portata. La quota è la stessa usata dalla pallina.
+    for (let s = 45; s < r.len; s += 75) {
+        const p = rampPoint(r, s);
+        line(g, [[p.x + 5, p.y], [p.x + 7, p.y + 10]], '#050c13', 3);
+        screw(g, p.x + 7, p.y + 10);
+    }
+    const track = (color, width, points = pts) => {
+        const pts = points;
+        g.beginPath(); g.moveTo(...pts[0]);
+        for (let i = 1; i < pts.length - 1; i++) {
+            const [x, y] = pts[i], a = pts[i - 1], b = pts[i + 1];
+            const d0 = Math.hypot(x - a[0], y - a[1]), d1 = Math.hypot(b[0] - x, b[1] - y), radius = Math.min(8, d0 / 3, d1 / 3);
+            g.lineTo(x - (x - a[0]) / d0 * radius, y - (y - a[1]) / d0 * radius);
+            g.quadraticCurveTo(x, y, x + (b[0] - x) / d1 * radius, y + (b[1] - y) / d1 * radius);
+        }
+        g.lineTo(...pts.at(-1)); g.strokeStyle = color; g.lineWidth = width; g.stroke();
+    };
+    g.save(); g.translate(3, 6); track('#02080cbb', 18); g.restore();
+    track(color + '18', 20); track('#02080e', 16); track(color, 14);
+    track(metal(g, 240, 45, 156, 205), 12); track('#07141e', 10);
+    track(gradient(g, 240, 40, 165, 220, [[0, '#386274'], [0.35, '#152a3b'], [0.7, '#385266'], [1, '#142c3b']]), 8);
+    track(color + '38', 4);
+    // Parapetti rialzati: montanti e tiranti triangolari fanno leggere il ponte anche da fermo.
+    for (const side of [-1, 1]) {
+        let previous;
+        for (let s = 34; s < r.len - 10; s += 18) {
+            const p = rampPoint(r, s), foot = [p.x + p.dy * 6.5 * side, p.y - p.dx * 6.5 * side];
+            const top = [foot[0], foot[1] - 5];
+            line(g, [foot, top], '#a6c6d2', 0.8);
+            if (previous) line(g, [previous, foot], color + '88', 0.65);
+            disc(g, ...top, 0.9, color); previous = top;
+        }
+        const rail = pts.map(([x, y], i) => {
+            const a = pts[Math.max(0, i - 1)], b = pts[Math.min(pts.length - 1, i + 1)];
+            const len = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
+            return [x + (b[1] - a[1]) / len * 6.5 * side, y - (b[0] - a[0]) / len * 6.5 * side - 5];
+        });
+        track('#06121d', 2.6, rail); track(color, 1.3, rail); track('#ffffff99', 0.45, rail);
+    }
+    for (let s = 12; s < r.len - 4; s += 22) {
+        const p = rampPoint(r, s);
+        line(g, [[p.x - p.dy * 4, p.y + p.dx * 4], [p.x + p.dy * 4, p.y - p.dx * 4]], '#7595a344', 0.7);
+        for (const side of [-1, 1]) disc(g, p.x + p.dy * 6 * side, p.y - p.dx * 6 * side, 0.7, color);
+    }
+    const [[x0, y], [x1]] = r.mouth, cx = (x0 + x1) / 2;
+    poly(g, [[cx - 6, y - 30], [cx + 6, y - 30], [x1, y + 2], [x0, y + 2]], '#030910');
+    poly(g, [[cx - 5, y - 30], [cx + 5, y - 30], [x1 - 1, y], [x0 + 1, y]], gradient(g, 0, y - 30, 0, 30, [[0, '#172b38'], [0.8, '#3c5d6b'], [1, '#a6c4c8']]), '#7795a2');
+    for (const side of [-1, 1]) {
+        const pts = [[cx + side * 6, y - 30], [cx + side * (x1 - x0) / 2, y]];
+        line(g, pts, '#07121c', 3); line(g, pts, color, 1); screw(g, cx + side * (x1 - x0) / 2, y);
+    }
+    // Portale d'ingresso in metallo: l'arco e le torrette incorniciano la bocca fisica della rampa.
+    const arch = [[x0 + 2, y - 2], [x0 + 2, y - 17], [cx - 8, y - 27], [cx + 8, y - 27], [x1 - 2, y - 17], [x1 - 2, y - 2]];
+    line(g, arch, '#020910', 5); line(g, arch, metal(g, x0, y - 27, x1 - x0, 27), 3.2); line(g, arch, color, 1);
+    for (const x of [x0 + 2, x1 - 2]) {
+        box(g, x - 2.5, y - 16, 5, 16, '#112735', '#8aaab7', 1);
+        box(g, x - 0.8, y - 13, 1.6, 9, color, null, 0.5);
+    }
+    box(g, cx - 10, y - 31, 20, 8, '#0a1b28', color, 2);
+    crown(g, cx, y - 27, 2.3, color);
+    for (let i = 0; i < 2; i++) line(g, [[cx - 3, y - 5 - i * 5], [cx, y - 8 - i * 5], [cx + 3, y - 5 - i * 5]], color + 'aa', 0.8);
+    text(g, r.points ? number(r.points) : r.id === 'super' ? 'SUPER' : '15.000', cx, y - 18, 4.5, WHITE, 'center');
+}
+function trackEnergy(g, c, r, time, hot, balls) {
+    const color = TINT[r.id], riders = balls.filter(b => b.ramp?.id === r.id);
+    const charged = hot || riders.length > 0;
+    // Luci sui bordi: il centro rimane libero per seguire la pallina.
+    for (let k = 0; k < (charged ? 7 : 3); k++) {
+        const p = rampPoint(r, (time * (charged ? 155 : 48) + k * r.len / (charged ? 7 : 3)) % r.len);
+        for (const side of [-1, 1]) {
+            const x = p.x + p.dy * 6.5 * side, y = p.y - p.dx * 6.5 * side - 5;
+            if (charged) glow(g, x, y, 7, color, 0.5);
+            disc(g, x, y, charged ? 1.1 : 0.8, charged ? WHITE : color);
+        }
+    }
+    for (const b of riders) {
+        // La scia segue la distanza percorsa, anche quando un tiro debole ricade indietro.
+        for (let i = 7; i > 0; i--) {
+            const s = b.ramp.s - Math.sign(b.ramp.v) * i * 4;
+            if (s < 0 || s > r.len) continue;
+            const p = rampPoint(r, s);
+            g.save(); g.globalAlpha *= (1 - i / 8) * 0.65;
+            line(g, [[p.x - p.dy * 3, p.y + p.dx * 3], [p.x + p.dy * 3, p.y - p.dx * 3]], color, 2);
+            g.restore();
+        }
+        const p = rampPoint(r, b.ramp.s); glow(g, b.x, p.y, 14, color, 0.8);
+    }
+    const [[x0, y], [x1]] = r.mouth, pulse = 0.45 + Math.sin(time * (charged ? 7 : 2)) * 0.15;
+    for (const x of [x0 + 2, x1 - 2]) glow(g, x, y - 10, 11, color, charged ? 0.85 : pulse);
+}
+function rampLights(g, c, r, time, balls) {
+    const color = TINT[r.id], locked = c.locks.some(l => l.rampId === r.id);
+    const combo = !c.locks.length && c.lastRamp && c.lastRamp.id !== r.id && r.id !== 'super';
+    const invited = c.special === r.id || multiball(c), hot = invited || combo || r.lit > 0;
+    trackEnergy(g, c, r, time, hot, balls);
+    const [[x0, y], [x1]] = r.mouth, x = (x0 + x1) / 2;
+    for (let i = 0; i < 3; i++) {
+        const lit = locked || (c.rampRun.id === r.id && c.rampRun.count > i);
+        if (lit) glow(g, x - 8 + i * 8, y + 6, 7, color, 0.7);
+        disc(g, x - 8 + i * 8, y + 6, 1.8, lit ? color : '#102a36', lit ? '#d6faff' : '#46616a');
+    }
+    const pulse = 0.6 + 0.4 * Math.sin(time * (invited || combo ? 8 : 3));
+    if (invited || combo) glow(g, x, y + 16, 23, color, pulse);
+    poly(g, [[x, y + 10], [x + 4, y + 16], [x + 1.5, y + 16], [x + 1.5, y + 22], [x - 1.5, y + 22], [x - 1.5, y + 16], [x - 4, y + 16]], invited ? WHITE : color);
+    box(g, x - 23, y + 24, 46, 10, '#08151e', color, 3);
+    text(g, locked ? 'LOCKED' : r.id === 'super' ? 'SUPER SPECIAL' : invited ? 'JACKPOT' : combo ? 'COMBO +50K' : r.id === 'sinistra' ? 'FORTEZZA' : 'TREBBIO', x, y + 29, r.id === 'super' ? 5.1 : 5.8, invited ? WHITE : color, 'center');
+}
+function bumper(g, b, time) {
+    const hot = b.hit > 0, color = hot ? '#ffce84' : b.x < 310 ? '#76e4ec' : b.x > 330 ? '#ffbf81' : '#91f5b1';
+    glow(g, b.x, b.y, hot ? 29 : 18, color, hot ? 1 : 0.24);
+    g.beginPath(); g.ellipse(b.x + 1, b.y + 5, b.r + 2, b.r, 0, 0, TAU); g.fillStyle = '#01080d'; g.fill();
+    disc(g, b.x, b.y + 1, b.r, metal(g, b.x - 10, b.y - 10, 20, 20), '#07111b');
+    disc(g, b.x, b.y, b.r - 2, '#172835', color);
+    const v = g.createRadialGradient(b.x - 3, b.y - 4, 0, b.x, b.y, b.r - 3);
+    v.addColorStop(0, hot ? '#fff8d4' : '#427382'); v.addColorStop(1, hot ? '#d9813d' : '#10232e');
+    disc(g, b.x, b.y - 1, b.r - 4, v, '#759ca7');
+    crown(g, b.x, b.y - 1, 3, hot ? '#fffaf0' : '#d6e9d9');
+    for (let i = 0; i < 8; i++) {
+        const a = i * TAU / 8;
+        disc(g, b.x + Math.cos(a) * (b.r + 2.5), b.y + Math.sin(a) * (b.r + 2.5), 0.65, hot || (i + Math.floor(time * 5)) % 8 < 2 ? color : '#315260');
+    }
+    for (const dx of [-8, 8]) screw(g, b.x + dx, b.y);
+    if (hot) { g.strokeStyle = color; g.lineWidth = 1; g.beginPath(); g.arc(b.x, b.y, b.r + 4 + Math.sin(time * 24) * 2, 0, TAU); g.stroke(); }
+}
+function target(g, c) {
+    for (const t of c.targets) {
+        const [x, y] = t.a, h = t.b[1] - y, color = t.bank === 'pieve' ? TINT.sinistra : TINT.destra;
+        box(g, x - 3, y - 1, 6, h + 2, '#030c12', '#45606d', 1);
+        if (t.down) { line(g, [[x - 2, y + h - 1], [x + 2, y + h - 1]], color); continue; }
+        g.fillStyle = metal(g, x - 2, y, 5, 6); g.fillRect(x - 2, y, 4, h);
+        g.fillStyle = color; g.fillRect(x - 1, y + 2, 2, h - 5); glow(g, x, y + h / 2, 8, color, 0.35);
+    }
+    const o = c.regolo;
+    glow(g, o.x, o.y, o.hit > 0 ? 30 : 18, '#99e5aa', o.hit > 0 ? 1 : 0.4);
+    disc(g, o.x + 1, o.y + 3, o.r + 1, '#02090b');
+    disc(g, o.x, o.y, o.r + 1, metal(g, o.x - 6, o.y - 6), '#c5b682');
+    disc(g, o.x, o.y, o.r - 1, '#18483e', '#94d7a5'); crown(g, o.x, o.y, 3.4, '#f7dda0');
+    text(g, c.future && Object.values(c.future.hits).every(n => n === 2) ? 'LIBERAMI!' : 'REGOLO', o.x, o.y + (c.table === 'future' ? 20 : -14), 5, '#acd6b7', 'center');
+}
+function paddle(g, c, side) {
+    const f = c.flippers[side], { a: [x, y], b: [tx, ty] } = flipperSeg(c, side), len = Math.hypot(tx - x, ty - y);
+    glow(g, x, y, 13, side === 'left' ? TINT.sinistra : TINT.destra, f.held.length ? 0.7 : 0.3);
+    g.save(); g.translate(x, y); g.rotate(Math.atan2(ty - y, tx - x));
+    const shape = () => { g.beginPath(); g.moveTo(0, -3); g.lineTo(len, -2.3); g.quadraticCurveTo(len + 3, 0, len, 2.3); g.lineTo(0, 3); g.arc(0, 0, 3, Math.PI / 2, Math.PI * 1.5); g.closePath(); };
+    g.save(); g.translate(1, 4); shape(); g.fillStyle = '#00080c'; g.fill(); g.restore();
+    shape(); g.fillStyle = '#e9eee4'; g.fill(); g.strokeStyle = '#d36754'; g.lineWidth = 1.4; g.stroke();
+    line(g, [[3, -1.7], [len - 2, -1.3]], '#ffffff', 0.8); screw(g, 0, 0); g.restore();
+}
+function ball(g, b, color = '#bcecff') {
+    const z = b.ramp?.z ?? 0, x = b.x, y = b.y - 1 - z * 8, r = R + z;
+    g.beginPath(); g.ellipse(x + 2 + z * 3, b.y + 3 + z * 2, r + 1, r * 0.55, 0, 0, TAU); g.fillStyle = '#00080dcc'; g.fill();
+    const v = g.createRadialGradient(x - r * 0.35, y - r * 0.45, 0, x, y, r);
+    v.addColorStop(0, '#ffffff'); v.addColorStop(0.2, '#f6ffff'); v.addColorStop(0.42, color); v.addColorStop(0.65, '#667d8e'); v.addColorStop(0.8, '#132435'); v.addColorStop(1, '#b1ccdc');
+    disc(g, x, y, r, v, '#bfdee8'); disc(g, x - r * 0.3, y - r * 0.4, 0.9, '#ffffff');
+}
+function lock(g, held, time) {
+    const b = held.ball, color = TINT[held.rampId];
+    glow(g, b.x, b.y, 22, color, 0.5 + 0.15 * Math.sin(time * 4));
+    box(g, b.x - 9, b.y - 11, 18, 22, '#07151e', color, 5); ball(g, b, color);
+    for (const dx of [-6, 6]) line(g, [[b.x + dx, b.y - 8], [b.x + dx, b.y + 7]], metal(g, b.x - 6, b.y, 12, 10), 2);
+    text(g, 'LOCK', b.x, b.y - 16, 5.5, color, 'center');
+}
+function plunger(g, c) {
+    const x = 440, pull = c.holding ? c.power * 12 : 0;
+    for (let y = 327 + pull; y < 347; y += 2.5) line(g, [[436, y], [444, y + 1]], '#adbdc4', 0.8);
+    box(g, 435, 324 + pull, 10, 4, metal(g, 435, 324, 10, 4), '#3c687b', 1);
+    for (let i = 0; i < 8; i++) {
+        g.fillStyle = canThrow(c) || c.holding ? (i / 8 < c.power ? TINT.destra : '#1e3844') : '#1e3844';
+        g.fillRect(437, 290 - i * 6, 6, 2);
+    }
+    // La valvola disegnata coincide con il segmento inclinato della fisica.
+    const gate = c.walls.find(w => w.gate);
+    line(g, [gate.a, gate.b], '#061017', 3); line(g, [gate.a, gate.b], '#b0d1d5', 1.2); screw(g, ...gate.a);
+    if (waiting(c)) text(g, 'LANCIA', x, 302, 4.5, TINT.destra, 'center');
+}
+const shown = new WeakMap();
+export function shownScore(d, time) { const k = Math.min(1, (time - d.t0) / 0.5); return k >= 1 ? d.to : d.from + Math.floor((d.to - d.from) * k / 10) * 10; }
+function board(g, c, time) {
+    glow(g, 99, 43, 25, SCENES[apparition(c, time).id].color, 0.4);
+    crown(g, 99, 43, 10, '#e7c889');
+    text(g, 'IL REGOLO', 99, 77, 24, '#eee8d7', 'center', 'Georgia, serif', 500);
+    text(g, 'R I V E R   /   P I N B A L L', 99, 96, 5.8, '#7f9d9e', 'center');
+    box(g, 23, 111, 152, 80, '#030b13', '#2c4a58', 6);
+    text(g, 'PUNTEGGIO', 34, 123, 6, MUTED);
+    let d = shown.get(c);
+    if (!d) { d = { from: c.score, to: c.score, t0: time }; shown.set(c, d); }
+    if (d.to !== c.score) { d.from = shownScore(d, time); d.to = c.score; d.t0 = time; }
+    const score = c.step === 'result' ? c.score : shownScore(d, time);
+    glow(g, 99, 146, 55, '#6dddf4', 0.2);
+    const digits = String(score).padStart(6, '0');
+    text(g, digits, 99, 146, Math.min(28, 132 / (digits.length * 0.6)), '#c4f6ff', 'center', 'monospace', 500);
+    const message = c.step === 'result' ? (c.result.winner === 'player' ? 'TRAGUARDO FATTO!' : 'FINE PARTITA') : c.line ?? (waiting(c) ? 'CARICA LA MOLLA' : 'PUNTA AL LOCK');
+    text(g, message, 99, 176, 7, c.line ? '#ffdc93' : MUTED, 'center');
+    const progress = Math.min(1, c.score / c.skill.goal), remaining = Math.max(0, c.skill.goal - c.score);
+    box(g, 28, 195, 142, 2, '#203641', null, 1);
+    if (progress) box(g, 28, 195, 142 * progress, 2, '#e7c889', null, 1);
+    text(g, remaining ? `MANCANO ${number(remaining)}` : 'TRAGUARDO  /  PALLINA +1', 99, 206, 6, '#c7c8ac', 'center');
+    text(g, 'PALLINE', 28, 225, 6, MUTED);
+    for (let i = 0; i < Math.min(8, c.balls); i++) disc(g, 88 + i * 9, 225, 2.4, i === 0 ? '#d4f6fc' : '#4f7786', '#8aacb5');
+    if (c.balls > 8) text(g, `+${c.balls - 8}`, 162, 225, 5, WHITE, 'right');
+    livingBackglass(g, c, time);
+    if (c.step === 'result') {
+        box(g, 24, 246, 150, 62, '#06131deb', '#c8b579', 5);
+        text(g, c.result.winner === 'player' ? 'TRAGUARDO FATTO!' : 'FINE PARTITA', 99, 264, 9, '#efdfa8', 'center');
+        text(g, `${number(c.result.score)} PUNTI`, 99, 287, 11, WHITE, 'center', 'monospace');
+    }
+    const save = saveLeft(c);
+    if (save > 0) { box(g, 248, 325, 144, 8, '#0b272f', '#4d9b9d', 3); text(g, `BALL SAVE  ${Math.ceil(save)}s`, 320, 329, 5, '#a4f7d1', 'center'); }
+}
+function mission(g, c, time) {
+    const multi = multiball(c);
+    text(g, 'LA CACCIA AL', 480, 35, 6, MUTED); text(g, 'JACKPOT', 480, 51, 17, '#f0d59d', 'left', 'Georgia, serif');
+    text(g, 'DUE LOCK. UNA SUPER SPECIAL.', 480, 69, 5.5, '#8aabb8');
+    for (let i = 0; i < 2; i++) {
+        const id = i ? 'destra' : 'sinistra', color = TINT[id], y = 83 + i * 56, held = c.locks.some(l => l.rampId === id);
+        const count = held || multi ? 3 : c.rampRun.id === id ? c.rampRun.count : 0;
+        box(g, 479, y, 137, 49, '#102431', c.special === id || multi ? color : '#28424e', 5);
+        text(g, `0${i + 1}`, 489, y + 12, 6, color, 'left', 'monospace');
+        text(g, i ? 'TREBBIO' : 'FORTEZZA', 507, y + 12, 8, '#d4e6eb');
+        for (let k = 0; k < 3; k++) { box(g, 489 + k * 28, y + 25, 22, 4, k < count ? color : '#213e4c', null, 1); }
+        const note = multi ? 'JACKPOT ATTIVO' : held ? 'PALLINA TRATTENUTA' : count ? `${count}/3   ·   ${Math.max(0, Math.ceil(c.rampRun.until - c.sim))}s PER IL LOCK` : '3 PASSAGGI IN 20 SECONDI';
+        text(g, note, 489, y + 39, 5.5, held ? color : MUTED);
+        if (held) { disc(g, 604, y + 12, 3, color); glow(g, 604, y + 12, 10, color, 0.6); }
+    }
+    const open = c.special === 'super';
+    box(g, 479, 195, 137, 64, open || multi ? '#241d3c' : '#121f2c', open ? TINT.super : '#364052', 5);
+    if (open) glow(g, 547, 222, 52, TINT.super, 0.25 + 0.15 * Math.sin(time * 5));
+    text(g, '03   SUPER SPECIAL', 489, 208, 7.5, open ? '#f1d8ff' : '#a5a5b7');
+    text(g, multi ? `${activeBalls(c).length} PALLINE IN GIOCO` : open ? 'RAMPA CENTRALE APERTA' : 'COMPLETA ENTRAMBI I LOCK', 489, 224, 5.5, open || multi ? '#ead6fc' : MUTED);
+    text(g, '+1 PALLINA  +  MULTIBALL', 489, 241, 6, '#d3bfdc');
+    text(g, `JACKPOT ×${c.jackpotX}`, 480, 278, 8, '#f2d5a0');
+    text(g, number((open ? SCORE.super : SCORE.jackpot) * c.jackpotX), 615, 278, 10, '#ffe4b2', 'right', 'monospace');
+    text(g, 'I BERSAGLI COMPLETI ALZANO IL ×', 480, 292, 5, MUTED);
+    line(g, [[480, 303], [615, 303]], '#2c424d', 0.6);
+    text(g, multi ? 'LE RAMPE PAGANO JACKPOT' : c.special === 'super' ? 'MIRA ALLA FRECCIA VIOLA' : c.special ? 'L’ALTRO LOCK ACCENDE LA SUPER' : c.lastRamp ? `COMBO +50.000  /  ${Math.max(0, Math.ceil(RAMP.combo - (c.sim - c.lastRamp.at)))}s` : 'ALTERNARE LE RAMPE: +50.000', 548, 316, 5.5, '#aec5c9', 'center');
+    text(g, multi ? 'MULTIBALL' : c.special === 'super' ? 'SUPER SPECIAL' : 'LOCK • SPECIAL • JACKPOT', 548, 333, 6, multi || open ? TINT.super : '#6e8f9b', 'center');
+}
+function effects(g, c, time) {
+    const latest = c.fx.findLast(f => f.kind === 'celebrate');
+    for (const f of c.fx) {
+        const age = time - f.t;
+        if (age < 0) continue;
+        g.save();
+        if (f.kind === 'spark' && age < 0.5) {
+            g.globalAlpha = 1 - age / 0.5;
+            for (let i = 0; i < 8; i++) {
+                const a = hash(i * 7 + f.t) * TAU, length = (18 + hash(i * 9) * 45) * age;
+                line(g, [[f.x + Math.cos(a) * length, f.y + Math.sin(a) * length], [f.x + Math.cos(a) * (length + 3), f.y + Math.sin(a) * (length + 3)]], i % 2 ? '#f9edbc' : '#8de8fa', 1);
+            }
+        } else if (f.kind === 'ring' && age < 0.5) {
+            g.globalAlpha = 1 - age * 2; g.strokeStyle = '#b2f6ff'; g.lineWidth = 1.2;
+            g.beginPath(); g.ellipse(f.x, f.y, 12 + age * 42, 9 + age * 30, 0, 0, TAU); g.stroke();
+        } else if (f.kind === 'pop' && age < 1.1) {
+            g.globalAlpha = Math.min(1, (1.1 - age) * 3);
+            text(g, f.text, f.x, f.y - age * 22, 7, '#fff1c7', 'center', 'monospace');
+        } else if (f.kind === 'burst' && age < 1.5) {
+            g.globalAlpha = Math.min(1, (1.5 - age) * 2);
+            for (let i = 0; i < 28; i++) {
+                const a = hash(i * 9 + f.t) * TAU, speed = 25 + hash(i * 13) * 75;
+                const x = f.x + Math.cos(a) * speed * age, y = f.y + Math.sin(a) * speed * age + 20 * age * age;
+                if (x < 201 || x > 430 || y > 330) continue;
+                disc(g, x, y, 0.7 + hash(i), i % 2 ? '#a8e8ff' : '#ffe3a9');
+            }
+        } else if (f.kind === 'celebrate' && f === latest && age < 2.6) {
+            const color = f.color ?? TINT.super;
+            const fade = Math.min(1, age * 5, (2.6 - age) * 3);
+            g.globalAlpha = fade;
+            // Fasci stretti, limitati al campo: la pallina resta leggibile.
+            g.save(); outline(g, c); g.clip();
+            for (let i = 0; i < 5; i++) {
+                const a = -Math.PI / 2 + (i - 2) * 0.3 + Math.sin(time * 1.5) * 0.1;
+                poly(g, [[320, 305], [320 + Math.cos(a - 0.025) * 330, 305 + Math.sin(a - 0.025) * 330], [320 + Math.cos(a + 0.025) * 330, 305 + Math.sin(a + 0.025) * 330]], color + '18');
+            }
+            g.restore();
+            glow(g, 320, 277, 85, color, 0.45);
+            box(g, 257, 265, 126, 31, '#07111deb', color, 6);
+            text(g, f.text, 320, 276, 11, WHITE, 'center', 'sans-serif', 800);
+            text(g, f.points ? `+${number(f.points)}` : 'IL REGOLO SI RISVEGLIA', 320, 288, 6, color, 'center', 'monospace');
+        }
+        g.restore();
+    }
+}
+// Il secondo campo ha il suo fondale: circuiti incisi, bastioni sospesi e il serpente come costellazione.
+// Tutto questo, compresi i binari, si dipinge una volta sola; sul telefono restano solo luci e palline.
+function futureCabinet(g, c, bg, glass) {
+    cabinet(g, c, bg, glass);
+    g.save(); outline(g, c); g.clip();
+    g.fillStyle = gradient(g, 200, 0, 230, 340, [[0, '#080c29'], [0.5, '#14112d'], [1, '#061f2a']]); g.fillRect(200, 5, 232, 331);
+    for (let i = 0; i < 13; i++) {
+        const x = 205 + i * 18;
+        line(g, [[x, 320], [320 + (x - 320) * 0.35, 50]], '#18364a', 0.6);
+        line(g, [[201, 90 + i * 19], [432, 90 + i * 19]], '#18364a', 0.6);
+    }
+    glow(g, 320, 105, 115, '#975cff', 0.6); glow(g, 320, 281, 90, '#24dcda', 0.4);
+    poly(g, [[276, 99], [276, 73], [287, 73], [287, 62], [298, 62], [298, 76], [310, 76], [310, 53], [330, 53], [330, 76], [343, 76], [343, 62], [355, 62], [355, 75], [365, 75], [365, 99]], '#161e41', '#9c86ee');
+    line(g, [[278, 103], [320, 118], [363, 103]], '#58f4e2', 1);
+    text(g, 'FORTEZZA / NUCLEO', 320, 91, 5, '#d1c7ff', 'center');
+    const serpent = [[304, 277], [288, 265], [295, 252], [326, 252], [343, 270], [332, 284], [313, 284], [313, 271], [323, 267]];
+    line(g, serpent, '#143d50', 8); line(g, serpent, '#398c9c', 1); crown(g, 323, 264, 5, '#58f4e2');
+    paintPlayfieldArt(g, true);
+    for (const w of c.walls) if (!w.gate) { line(g, [w.a, w.b], '#2e526a', 3); line(g, [w.a, w.b], '#69b7c7', 0.7); }
+    g.restore();
+    // Il mobile stesso cambia: pannelli a circuito, la finestra sul River resta il legame col 2007.
+    for (const x of [12, 467]) { line(g, [[x + 9, 100], [x + 9, 31], [x + 31, 31]], '#58f4e2', 1.2); }
+    box(g, 198, 336, 252, 17, '#080f20', '#396c84', 2);
+    text(g, 'R I V E R  /  IL REGOLO DEL FUTURO', 320, 345, 6, '#99ffee', 'center');
+}
+function futureBoard(g, c) {
+    const ready = Object.values(c.future.hits).every(n => n === 2);
+    text(g, 'IL REGOLO', 99, 51, 21, WHITE, 'center', 'sans-serif', 800);
+    text(g, 'D E L   F U T U R O', 99, 76, 9, TINT.orbita, 'center');
+    text(g, 'IL RIVER HA UN SEGRETO.', 99, 94, 5.5, '#a69abf', 'center');
+    box(g, 23, 111, 152, 82, '#040c1c', '#396c84');
+    text(g, 'PUNTI / CONNESSIONE ATTIVA', 34, 124, 5.5, TINT.orbita);
+    text(g, number(c.score), 99, 148, 22, WHITE, 'center', 'monospace');
+    text(g, c.transform ? 'RISVEGLIO DEL NUCLEO' : ready ? 'COLPISCI IL REGOLO!' : c.line ?? 'CARICA I TRE SIGILLI', 99, 178, 6.5, '#d6c1ff', 'center');
+    text(g, `${activeBalls(c).length} IN CAMPO  /  ${c.balls} IN RISERVA`, 99, 210, 6, '#b7e1e7', 'center');
+    text(g, 'STESSI TASTI. UN ALTRO MONDO.', 99, 225, 5.5, MUTED, 'center');
+    text(g, 'I TRE SIGILLI', 480, 49, 16, WHITE);
+    text(g, 'DUE PERCORSI COMPLETI CIASCUNO', 480, 69, 5.5, TINT.orbita);
+    for (const [i, r] of c.ramps.entries()) {
+        const y = 85 + i * 57, color = TINT[r.id], n = c.future.hits[r.id];
+        box(g, 479, y, 137, 49, '#101d34', n === 2 ? color : '#334a68');
+        text(g, r.name, 487, y + 12, 6.5, color);
+        for (let k = 0; k < 2; k++) box(g, 488 + k * 34, y + 25, 27, 5, k < n ? color : '#29374a', null, 1);
+        text(g, `${n}/2`, 603, y + 27, 9, WHITE, 'right', 'monospace');
+        text(g, `OGNI GIRO +${number(r.points)}`, 488, y + 40, 5.5, MUTED);
+    }
+    text(g, ready ? 'IL REGOLO È VULNERABILE' : 'POI COLPISCI IL REGOLO MOBILE', 548, 274, 6, ready ? TINT.orbita : '#d6c1ff', 'center');
+    text(g, '+500.000', 548, 294, 22, WHITE, 'center', 'monospace');
+    text(g, 'FINALE O ULTIMA PALLINA PERSA:', 548, 318, 5.5, MUTED, 'center');
+    text(g, 'SI TORNA AL RIVER', 548, 332, 7, TINT.orbita, 'center');
+    livingBackglass(g, c, c.visual.time);
+}
+function futureField(g, c, time) {
+    livingPlayfield(g, c, time);
+    for (const b of c.bumpers) bumper(g, b, time);
+    target(g, c);
+    const ready = Object.values(c.future.hits).every(n => n === 2);
+    if (ready) glow(g, c.regolo.x, c.regolo.y, 30, TINT.orbita, 0.6);
+    const balls = activeBalls(c);
+    for (const b of balls) if (!b.ramp && b.releaseAt <= c.sim) ball(g, b);
+    for (const r of c.ramps) {
+        cached(g, `track:future:${r.id}`, layer => paintTrack(layer, r), [202, 0, 232, 258]);
+        const color = TINT[r.id], x = r.path[0][0], y = r.mouth[0][1];
+        trackEnergy(g, c, r, time, r.lit > 0 || c.future.hits[r.id] === 2, balls);
+        poly(g, [[x, y + 7], [x - 4, y + 14], [x + 4, y + 14]], color);
+        text(g, r.id.toUpperCase(), x, y + 21, 5.5, color, 'center');
+        for (const b of balls) if (b.ramp?.id === r.id) ball(g, b, color);
+    }
+    for (const side of ['left', 'right']) paddle(g, c, side);
+    plunger(g, c); effects(g, c, time); futureBoard(g, c);
+}
+function oldPlayfield(c, bg, glass) {
+    return l => {
+        const classic = { ...c, ...layout(), table: 'classic' };
+        cabinet(l, classic, bg, glass); target(l, classic);
+        classic.bumpers.forEach(b => bumper(l, b, 0)); classic.ramps.forEach(r => paintTrack(l, r));
+        for (const side of ['left', 'right']) paddle(l, classic, side);
+    };
+}
+function transformation(g, c, bg, glass) {
+    const age = c.sim - c.transform.at;
+    // Le due metà del vecchio piano scorrono via. Sono ritagli piccoli, mai copie dello schermo intero.
+    if (age >= FUTURE.reveal && age < 2.7 && typeof document !== 'undefined') {
+        const old = layerOf(`split:${!!bg}:${!!glass}`, oldPlayfield(c, bg, glass), [200, 5, 248, 331]);
+        const k = clamp((age - FUTURE.reveal) / 1.6, 0, 1), shift = k * k * 150;
+        g.save(); g.beginPath(); g.rect(200, 5, 248, 331); g.clip();
+        g.drawImage(old, 0, 0, 248, 662, 200 - shift, 5, 124, 331);
+        g.drawImage(old, 248, 0, 248, 662, 324 + shift, 5, 124, 331);
+        line(g, [[324 - shift, 5], [324 - shift, 336]], TINT.orbita, 2);
+        line(g, [[324 + shift, 5], [324 + shift, 336]], TINT.ponte, 2); g.restore();
+    }
+    // Una detonazione sola, poi schegge e onde sottili: nessun filtro o lampeggio continuo.
+    const blast = Math.min(age, 1.7);
+    if (age < 1.7) {
+        glow(g, 320, 165, 60 + blast * 100, '#b9faff', Math.max(0, 1 - blast / 1.7));
+        for (let i = 0; i < 3; i++) {
+            const radius = 10 + Math.max(0, blast - i * 0.13) * 210;
+            g.beginPath(); g.ellipse(320, 165, radius, radius * 0.7, 0, 0, TAU); g.strokeStyle = [WHITE, TINT.orbita, TINT.ponte][i]; g.lineWidth = 1.5; g.stroke();
+        }
+        for (let i = 0; i < 20; i++) {
+            const a = i * TAU / 20 + 0.12, d = 25 + blast * 210;
+            line(g, [[320 + Math.cos(a) * d, 165 + Math.sin(a) * d * 0.7], [320 + Math.cos(a) * (d + 24), 165 + Math.sin(a) * (d + 24) * 0.7]], i % 2 ? TINT.orbita : '#ffe3a4', 1.2);
+        }
+        for (let i = 0; i < 64; i++) {
+            const a = hash(i * 11) * TAU, speed = 80 + hash(i * 17) * 180, d = speed * blast;
+            const x = 320 + Math.cos(a) * d, y = 165 + Math.sin(a) * d * 0.7 + blast * blast * 22;
+            const color = [TINT.orbita, TINT.spira, '#ffe3a4', WHITE][i % 4];
+            poly(g, [[x, y - 3], [x + 2 + i % 3, y], [x, y + 4], [x - 2, y]], color);
+        }
+        if (age < 0.09) { g.fillStyle = '#e4ffff'; g.fillRect(201, 6, 230, 328); }
+    }
+    const title = age < FUTURE.reveal ? 'SUPER SPECIAL' : 'IL REGOLO DEL FUTURO';
+    box(g, 215, 145, 210, 47, '#050e24', age < FUTURE.reveal ? TINT.spira : TINT.orbita, 3);
+    text(g, title, 320, 163, age < FUTURE.reveal ? 22 : 16, WHITE, 'center', 'sans-serif', 900);
+    text(g, age < FUTURE.reveal ? 'IL RIVER NON SE L’ASPETTAVA.' : 'IL PIANO SI APRE. IL SERPENTE SI SVEGLIA.', 320, 181, 6, TINT.orbita, 'center');
+}
+export function drawFlipper(g, c, def, bg, glass) {
+    const time = c.visual.time;
+    // Niente estremità e giunti arrotondati nei tratti di ogni fotogramma: costano più di tutto il resto (vedi la
+    // memoria «effetti leggeri»); il mobile e i binari, in cache, li tengono.
+    g.save(); g.imageSmoothingEnabled = true; g.lineCap = 'butt'; g.lineJoin = 'miter';
+    const shake = c.fx.reduce((n, f) => f.kind === 'shake' ? Math.max(n, 1 - (time - f.t) / 0.3) : n, 0);
+    if (g.canvas?.style) g.canvas.style.backgroundPosition = '';
+    const future = c.table === 'future';
+    const key = `cabinet:${future}:${!!bg}:${!!glass}`, paint = layer => (future ? futureCabinet : cabinet)(layer, c, bg, glass);
+    if (c.transform) {
+        if (cabinetBehind(g, key, paint)) g.clearRect(0, 0, 640, 360); else cached(g, key, paint);
+        const age = c.sim - c.transform.at, force = Math.max(0, 1 - age / 1.1);
+        const dx = Math.sin(age * 79) * force * 4, dy = Math.cos(age * 67) * force * 3;
+        g.translate(dx, dy);
+        if (g.canvas?.style) g.canvas.style.backgroundPosition = `${dx}px ${dy}px`;
+        if (!future) cached(g, `split:${!!bg}:${!!glass}`, oldPlayfield(c, bg, glass), [200, 5, 248, 331]);
+        if (future) futureField(g, c, time); else { board(g, c, time); mission(g, c, time); }
+        transformation(g, c, bg, glass); g.restore(); return;
+    }
+    if (future) {
+        if (cabinetBehind(g, key, paint)) g.clearRect(0, 0, 640, 360); else cached(g, key, paint);
+        futureField(g, c, time); plungerHint(g, c, time); g.restore(); return;
+    }
+    if (shake > 0) { g.fillStyle = INK; g.fillRect(0, 0, 640, 360); g.translate(Math.sin(time * 75) * shake * 1.3, Math.cos(time * 63) * shake); cached(g, key, paint); }
+    else if (cabinetBehind(g, key, paint)) g.clearRect(0, 0, 640, 360);
+    else cached(g, key, paint);
+    livingPlayfield(g, c, time);
+    for (const [i, l] of c.lanes.entries()) {
+        if (l.lit) glow(g, l.x, l.y, 17, RIONI[i], 0.55);
+        disc(g, l.x, l.y, 5, '#06151d', l.lit ? RIONI[i] : '#47616b');
+        disc(g, l.x, l.y, 2.3, l.lit ? RIONI[i] : '#203a44');
+    }
+    target(g, c); c.bumpers.forEach(b => bumper(g, b, time));
+    if (c.special !== 'super') {
+        box(g, 305, 221, 30, 15, metal(g, 305, 221, 30, 15), '#354a5a', 3);
+        box(g, 307, 223, 26, 11, '#142431', null, 2); text(g, 'SUPER', 320, 228, 5, '#8b91ac', 'center');
+        for (let i = 0; i < 2; i++) disc(g, 315 + i * 10, 239, 1.6, c.locks.length > i ? TINT.super : '#263748');
+    }
+    const balls = activeBalls(c);
+    for (const [i, b] of balls.entries()) {
+        if (b.waiting) continue;
+        const color = [TINT.sinistra, TINT.destra, TINT.super][i];
+        b.trail.forEach(([x, y], k) => { g.save(); g.globalAlpha = k / b.trail.length * 0.35; disc(g, x, y - 1, 1 + k / b.trail.length * 2, color); g.restore(); });
+    }
+    for (const b of balls) if (!b.ramp && b.releaseAt <= c.sim) ball(g, b);
+    for (const r of c.ramps) {
+        if (!rampOpen(c, r)) continue;
+        g.save();
+        if (r.id === 'super') { const rise = clamp((time - c.superOpenedAt) / 0.65, 0, 1); g.globalAlpha = rise; g.translate(0, (1 - rise) * 18); }
+        cached(g, `track:${r.id}`, layer => paintTrack(layer, r), r.id === 'super' ? [208, 45, 148, 207] : [208, 0, 225, 238]); rampLights(g, c, r, time, balls);
+        for (const b of balls) if (b.ramp?.id === r.id) ball(g, b, TINT[r.id]);
+        g.restore();
+    }
+    c.locks.forEach(held => lock(g, held, time));
+    for (const b of balls) if (b.releaseAt > c.sim) lock(g, { ball: b, rampId: b.releasedFrom }, time);
+    for (const side of ['left', 'right']) paddle(g, c, side);
+    plunger(g, c); effects(g, c, time);
+    // Il riflesso bianco rende visibili le palline vicino alle palette anche durante la festa.
+    for (const b of balls) if (!b.ramp && b.y > 265 && b.releaseAt <= c.sim) ball(g, b);
+    board(g, c, time); mission(g, c, time); plungerHint(g, c, time);
+    g.restore();
+}
+// A pallina ferma, dove toccare per la molla (Andrea, 1 novembre: «sul telefono non è intuitivo premere al centro»): la
+// fascia centrale di flipper.js (press), tratteggiata, e la scritta che pulsa; sparisce appena si comincia a caricare.
+// Solo col dito (`c.touch`, da main.js): sul computer no, Andrea non la vuole.
+function plungerHint(g, c, time) {
+    if (!c.touch || !waiting(c) || c.holding) return;
+    const x0 = 320 - PLUNGER_ZONE + 4, x1 = 320 + PLUNGER_ZONE - 4, y0 = 196, y1 = 300, pulse = 0.8 + Math.sin(time * 4) * 0.2;
+    g.save(); g.globalAlpha = pulse; g.setLineDash([4, 3]);
+    g.strokeStyle = '#ffe08a'; g.lineWidth = 1.2; g.strokeRect(x0, y0, x1 - x0, y1 - y0); g.setLineDash([]);
+    box(g, 320 - 58, 262, 116, 32, '#07121c', '#ffe08a', 2);
+    text(g, 'TIENI PREMUTO QUI', 320, 272, 8.5, '#ffe08a', 'center', 'sans-serif', 800);
+    text(g, 'e lascia: MOLLA', 320, 285, 7, WHITE, 'center', 'sans-serif', 700);
+    g.restore();
+}

src/engine/flipper.js

@@ -0,0 +1,602 @@
+// Il flipper del River (Andrea, 31 ottobre: «una tavola bellissima, con San Piero dentro»). Visto dall'alto, la tavola
+// in verticale al centro del primo piano 640×360; la pallina parte dalla corsia di destra con la molla, fa il giro
+// dell'arco in cima, passa in una delle quattro corsie dei rioni, rimbalza sui tre funghi (i bastioni della Fortezza),
+// abbatte i bersagli della Pieve a sinistra e della torre a destra, tocca il Regolo, e giù dalle sponde elastiche ai
+// due flipper, con la Sieve dipinta che scorre nel buco in mezzo. Tre palline; si vince arrivando al traguardo di
+// punti del livello (e poi si può continuare per il record). Unità: i pixel del primo piano. La fisica va a passo
+// fisso (come il biliardo), con sottopassi quando pallina e flipper vanno forte.
+// Rivista con la revisione di Codex del 31 ottobre: punti solo a un urto nuovo (non al contatto che dura), due dita
+// sulla scena, annullare non lancia, niente cancelletto-ripiano, salvataggio col tempo della simulazione, corsie che
+// contano quando si attraversano, traguardo acquisito appena raggiunto. Valvola di lancio a senso unico.
+export const FIELD = { x0: 200, x1: 448, y0: 5, y1: 336 }, LANE = { x0: 432, x1: 448 }, R = 4.5;
+export const BALLS = 3, STEP = 1 / 240, MAX_SPEED = 980, CHARGE = 1.2, FLIP = { len: 34, rest: 0.5, up: -0.46, speed: 26, r: 3 };
+export const PIVOT = { left: [280, 314], right: [360, 314] };
+// I punti, generosi come sui flipper degli anni 2000 (Andrea: «aumenta i punti»).
+export const SCORE = { bumper: 1000, sling: 500, lane: 2500, palio: 30000, target: 5000, bank: 25000, regolo: 10000, ramp: 15000, ponti: 50000, jackpot: 100000, super: 250000 };
+// Le rampe (Andrea: «un paio di ponti sui quali sale la pallina»): si entra dal basso con abbastanza velocità, si
+// sale, si passa sopra la tavola e si scende dall'altra parte. Fatte tutte e due di fila: i PONTI.
+export const RAMP = { speed: 240, slope: 155, drag: 20, combo: 12, blend: 30, lockWindow: 20 };
+// Quanto deve picchiare un urto perché conti (velocità lungo la normale, px/s): il tremolio da gravità non conta.
+const IMPACT = 40, LANE_LINE = 104, BANK_RESET = 0.8, CLICK_HOLD = 0.16, NUDGE_AFTER = 2.5;
+// I livelli: la stessa fisica, quasi; cambiano il traguardo, il salvataggio della pallina appena lanciata e un po' la
+// gravità. La spinta dei funghi è uguale per tutti.
+export const LEVELS = {
+    bona: { g: 680, save: 8, kick: 340, goal: 60000 },
+    seria: { g: 740, save: 4, kick: 340, goal: 120000 },
+    male: { g: 800, save: 1, kick: 340, goal: 200000 },
+};
+export const RIONI = ['piazza', 'pieve', 'cardetole', 'campomigliaio'];
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function random(c) { c.seed = (Math.imul(c.seed, 1664525) + 1013904223) >>> 0; return c.seed / 4294967296; }
+const seg = (a, b, extra = {}) => ({ a, b, e: 0.55, touching: false, ...extra });
+
+// La tavola: sponde, corsie, sponde elastiche, funghi, bersagli. Le coordinate seguono il disegno di Codex
+// (assets/closeups/river-flipper.png): i tre dischi dei funghi, le quattro bandiere dei rioni, la corsia della molla.
+export function layout() {
+    const arc = [[200, 72], [203, 50], [212, 32], [228, 18], [252, 10], [288, 6], [324, 5], [360, 6], [396, 10], [420, 18], [436, 32], [445, 50], [448, 72]];
+    const walls = [];
+    for (let i = 1; i < arc.length; i++) walls.push(seg(arc[i - 1], arc[i], { e: 0.6 }));
+    walls.push(seg([200, 72], [200, 336]), seg([448, 72], [448, 336]));
+    // La corsia della molla, col fondo. Un lancio che non è ancora entrato in campo si può ritentare;
+    // dopo l'ingresso la valvola inclinata impedisce il ritorno, senza creare un ripiano orizzontale.
+    walls.push(seg([432, 70], [432, 336]), seg([432, 326], [448, 326], { e: 0.2 }));
+    // Valvola inclinata: lascia uscire il lancio e devia a sinistra ogni rientro dal campo.
+    walls.push(seg([432, 70], [448, 60], { gate: true, e: 0.7 }));
+    // Le corsie dei rioni, in cima, fra le bandiere: tre guide.
+    for (const x of [277, 319, 361]) walls.push(seg([x, 70], [x, 102], { e: 0.4 }));
+    // I divisori delle uscite laterali e le guide che portano ai flipper (la guida passa sopra il perno e continua un
+    // po' lungo il flipper: finendo sul perno la pallina ci restava incastrata).
+    // Le uscite lasciano solo 14/12 pixel; lo spazio recuperato allarga le corsie di ritorno.
+    walls.push(seg([214, 240], [214, 290]), seg([214, 290], [292, 314], { e: 0.3 }));
+    walls.push(seg([420, 240], [420, 290]), seg([420, 290], [348, 314], { e: 0.3 }));
+    // Le sponde elastiche sopra i flipper: il lato lungo spinge.
+    walls.push(seg([236, 246], [236, 284]), seg([236, 284], [262, 290]), seg([236, 246], [262, 290], { sling: true }));
+    walls.push(seg([404, 246], [404, 284]), seg([404, 284], [378, 290]), seg([404, 246], [378, 290], { sling: true }));
+    // I bersagli a caduta: la Pieve a sinistra, la torre a destra, con la sponda dietro.
+    walls.push(seg([210, 146], [210, 198]), seg([429, 146], [429, 198]));
+    // Dietro la Pieve, fra la parete e la sponda, restavano 10 pixel: la pallina (larga 9) che scivolava lungo la
+    // parete sinistra ci entrava e scendeva dritta nell'uscita laterale (Andrea: «a sinistra esce troppo facile»).
+    // A destra il canale è di 3 pixel e non esiste. Due raccordi inclinati lo chiudono sopra e sotto.
+    walls.push(seg([200, 136], [210, 146], { e: 0.5 }), seg([210, 198], [200, 208], { e: 0.5 }));
+    const targets = [];
+    for (const [bank, x] of [['pieve', 216], ['torre', 423]]) for (let i = 0; i < 3; i++) targets.push({ bank, i, a: [x, 150 + i * 16], b: [x, 162 + i * 16], down: false, touching: false });
+    const bumpers = [[281, 120], [360, 120], [320, 153]].map(([x, y]) => ({ x, y, r: 12, hit: 0, touching: false }));
+    // Il Regolo, in alto a destra sotto l'arco, dove la pallina scende dal giro.
+    const regolo = { x: 404, y: 62, r: 7, hit: 0, touching: false };
+    // Le corsie: ognuna fra due guide (o la sponda), con la bandiera dipinta in `x`; si accende attraversando in
+    // discesa la riga LANE_LINE.
+    const lanes = [[200, 277, 257], [277, 319, 297], [319, 361, 340], [361, 432, 381]].map(([x0, x1, x], i) => ({ x0, x1, x, y: LANE_LINE, rione: RIONI[i], lit: false }));
+    // Le due rampe: l'imbocco (un segmento che si attraversa in salita), il percorso sopra la tavola, l'uscita in
+    // fondo al percorso, dall'altra parte, dritta nella corsia di ritorno verso il flipper. Si incrociano una volta sola,
+    // in cima, come due ponti.
+    const ramps = [
+        // Imbocchi verso il centro, davanti alle sponde elastiche: 27 pixel utili alla pallina anziché 13.
+        { id: 'sinistra', mouth: [[255, 226], [291, 226]], path: [[273, 226], [273, 196], [247, 150], [250, 96], [262, 52], [290, 30], [322, 34], [352, 52], [378, 84], [394, 116], [411, 128], [411, 142]], lit: 0, touching: false },
+        { id: 'destra', mouth: [[349, 226], [385, 226]], path: [[367, 226], [367, 196], [393, 150], [390, 96], [378, 52], [350, 30], [318, 34], [288, 52], [262, 84], [246, 116], [229, 128], [229, 142]], lit: 0, touching: false },
+        { id: 'super', mouth: [[303, 232], [337, 232]], path: [[320, 232], [320, 188], [333, 145], [333, 96], [320, 72], [307, 96], [307, 145], [287, 168], [246, 180], [229, 198], [229, 220]], lit: 0, touching: false },
+    ];
+    // Lunghezze, e la cima (il punto più alto del disegno): fin lì si sale, poi si scende.
+    for (const r of ramps) {
+        r.len = 0; r.cum = [0];
+        for (let i = 1; i < r.path.length; i++) { r.len += Math.hypot(r.path[i][0] - r.path[i - 1][0], r.path[i][1] - r.path[i - 1][1]); r.cum.push(r.len); }
+        r.top = r.cum[r.path.reduce((best, p, i) => p[1] < r.path[best][1] ? i : best, 0)];
+    }
+    // Ogni pallina ricorda i propri contatti: in multiball un urto non cancella quello dell'altra.
+    [...walls, ...targets, ...bumpers, regolo].forEach((o, i) => { o.contactId = i; });
+    return { walls, targets, bumpers, regolo, lanes, ramps };
+}
+// Sotto il legno c'è una macchina impossibile: fantasia del mobile, non storia del paese.
+export const FUTURE = { reveal: 1.1, duration: 3.2, finale: 500000 };
+export function futureLayout() {
+    const base = layout();
+    // Restano il mobile, la molla e le guide alle palette; spariscono corsie e banchi classici.
+    const walls = base.walls.filter((w, i) => i < 17 || (i >= 20 && i < 30));
+    walls.push(seg([205, 90], [228, 125]), seg([428, 92], [409, 120]));
+    const bumpers = [[280, 157], [368, 169]].map(([x, y]) => ({ x, y, r: 11, hit: 0, touching: false }));
+    const regolo = { x: 320, y: 276, r: 9, hit: 0, touching: false };
+    const ramps = [
+        { id: 'orbita', name: 'ORBITA DEL SERPENTE', points: 35000, mouth: [[246, 235], [282, 235]], path: [[264, 235], [253, 197], [228, 158], [224, 89], [245, 42], [293, 25], [346, 29], [394, 50], [410, 89], [396, 116], [357, 112], [345, 85], [368, 64], [397, 85], [411, 135], [411, 220]] },
+        { id: 'ponte', name: 'PONTE DELLA FORTEZZA', points: 50000, mouth: [[302, 238], [338, 238]], path: [[320, 238], [320, 201], [300, 167], [300, 108], [315, 66], [338, 53], [356, 73], [349, 105], [313, 128], [267, 133], [229, 174], [229, 220]] },
+        { id: 'spira', slope: 300, name: 'SPIRA AL NEON', points: 65000, mouth: [[364, 235], [400, 235]], path: [[382, 235], [386, 203], [400, 165], [388, 132], [363, 128], [347, 151], [353, 178], [376, 187], [401, 180], [411, 204], [411, 245]] },
+    ];
+    for (const r of ramps) {
+        r.len = 0; r.cum = [0]; r.lit = 0;
+        for (let i = 1; i < r.path.length; i++) { r.len += Math.hypot(r.path[i][0] - r.path[i - 1][0], r.path[i][1] - r.path[i - 1][1]); r.cum.push(r.len); }
+        r.top = r.cum[r.path.reduce((best, p, i) => p[1] < r.path[best][1] ? i : best, 0)];
+    }
+    [...walls, ...bumpers, regolo].forEach((o, i) => { o.contactId = i; });
+    return { walls, targets: [], lanes: [], bumpers, regolo, ramps };
+}
+function openFuture(c) {
+    Object.assign(c, futureLayout()); c.table = 'future'; c.resets = {}; c.fx = [];
+    c.future = { hits: { orbita: 0, ponte: 0, spira: 0 } };
+    // La trasformazione parcheggia le tre palline al sicuro, poi le serve una alla volta.
+    activeBalls(c).forEach((b, i) => Object.assign(b, { x: i === 1 ? 411 : 229, y: 220 - i * 32, vx: 0, vy: 160,
+        ramp: null, contacts: [], trail: [], releaseAt: c.transform.until + i * 0.55, releasedFrom: i === 1 ? 'spira' : 'orbita' }));
+}
+function returnClassic(c, won = false) {
+    Object.assign(c, layout()); c.table = 'classic'; c.future = null; c.transform = null;
+    c.extraBalls = []; c.resets = {}; c.lastRamp = null; c.jackpotX = 1; c.saveUntil = 0; c.saved = false;
+    cancel(c); newBall(c);
+    if (won) { celebrate(c, 'REGOLO LIBERATO!', FUTURE.finale, '#74ffe0'); c.events.push({ kind: 'flipper-futuro-finale', power: 1 }); }
+    else announce(c, 'RITORNO AL RIVER');
+}
+// Il punto a `s` pixel lungo il percorso di una rampa, e la direzione lì.
+export function alongRamp(r, s) {
+    s = clamp(s, 0, r.len);
+    let i = 1; while (i < r.cum.length - 1 && r.cum[i] < s) i++;
+    const [ax, ay] = r.path[i - 1], [bx, by] = r.path[i], L = r.cum[i] - r.cum[i - 1] || 1, k = (s - r.cum[i - 1]) / L;
+    return { x: ax + (bx - ax) * k, y: ay + (by - ay) * k, dx: (bx - ax) / L, dy: (by - ay) / L };
+}
+
+export function newFlipper(seed = Date.now() >>> 0, def = {}) {
+    const level = LEVELS[def.level] ? def.level : 'seria';
+    const c = { step: 'play', t: 0, sim: 0, seed, level, skill: LEVELS[level], current: 'player', balls: BALLS, score: 0, power: 0.7,
+        holding: false, holdTime: 0, pointerId: null, cursor: null, accumulator: 0, events: [], line: null, lineT: 0, saved: false,
+        flippers: { left: { angle: FLIP.rest, omega: 0, held: [], click: 0 }, right: { angle: Math.PI - FLIP.rest, omega: 0, held: [], click: 0 } },
+        table: 'classic', transform: null, future: null, ball: null, extraBalls: [], locks: [], special: null, specialPaid: false, jackpotX: 1,
+        rampRun: { id: null, count: 0, until: 0 }, superOpenedAt: null,
+        saveUntil: 0, resets: {}, result: null, lastRamp: null, lines: [], lineId: 0, fx: [], trail: [], visual: { time: 0 }, ...layout() };
+    newBall(c);
+    return c;
+}
+function makeBall() { return { x: (LANE.x0 + LANE.x1) / 2, y: 318, vx: 0, vy: 0, waiting: true, inPlay: false, releaseAt: 0, ramp: null, contacts: [], trail: [], still: 0, anchor: null, rest: 0 }; }
+function newBall(c) { c.ball = makeBall(); c.trail = c.ball.trail; }
+export const activeBalls = c => [c.ball, ...c.extraBalls].filter(Boolean);
+export const multiball = c => c.extraBalls.length > 0;
+export const rampOpen = (c, r) => r.id !== 'super' || c.special === 'super';
+export const waiting = c => c.step === 'play' && !!c.ball?.waiting;
+export const canThrow = c => waiting(c) && !c.holding;
+export const canPress = canThrow;
+// Due permessi diversi: il cursore della molla solo prima del lancio, i flipper per tutta la partita.
+export const canAdjust = canThrow;
+export const canFlip = c => c.step === 'play';
+export const aimFree = () => true;
+export const powerAt = time => clamp(time / CHARGE, 0, 1);
+// Quanto resta del salvataggio della pallina, in secondi (0: non protetta).
+export const saveLeft = c => c.ball && !c.ball.waiting ? Math.max(0, c.saveUntil - c.sim) : 0;
+// Le scritte del tabellone: una alla volta, due secondi l'una; il traguardo passa davanti a tutte.
+function say(c, line, front = false) {
+    if (front || !c.line) { if (front && c.line) c.lines.unshift(c.line); c.line = line; c.lineT = 2; c.lineId++; }
+    else c.lines.push(line);
+}
+// Gli effetti sulla tavola (Andrea: «più spettacolare»): anelli, scintille, coriandoli, luci che corrono, punti che
+// volano, il lampo colorato e la scossa. Qui si segnano col loro tempo; li disegna flipper-render.js, e durano FX_LIFE.
+export const FX_LIFE = 3;
+function fx(c, kind, x, y, extra = {}) { c.fx.push({ kind, x, y, t: c.visual.time, ...extra }); }
+// I punti, che volano via dal punto colpito; al traguardo la vittoria è acquisita (anche uscendo prima), poi si
+// continua per il record.
+function add(c, points, at) {
+    c.score += points;
+    if (at) fx(c, 'pop', at[0], at[1], { text: `+${points}` });
+    if (!c.result && c.score >= c.skill.goal) {
+        c.result = { winner: 'player', score: c.score, goal: c.skill.goal }; say(c, 'TRAGUARDO!', true);
+        // La vittoria viene acquisita una volta sola: la pallina premio va nella riserva, senza fermare il tiro.
+        c.balls++; c.lines.unshift('PALLINA +1'); fx(c, 'pop', 324, 235, { text: '+1 PALLINA' });
+        c.events.push({ kind: 'flipper-traguardo', power: 1 }); fx(c, 'burst', 324, 170, { big: true }); fx(c, 'wash', 0, 0, { color: '255,210,80' }); fx(c, 'shake', 0, 0);
+    }
+    if (c.result) c.result.score = c.score;
+}
+
+// Il lancio: la molla spinge la pallina su per la corsia. Anche la molla più fiacca arriva all'arco (la velocità
+// minima dipende dalla gravità del livello); da lì in su, la forza decide quanto gira.
+export function launchSpeed(c, power) {
+    const min = Math.sqrt(2 * c.skill.g * 340), max = Math.max(min + 150, 900);
+    return min + (max - min) * clamp(power, 0, 1);
+}
+export function launch(c, power) {
+    if (!waiting(c)) return false;
+    // La molla vera non è mai identica due volte: un pelo di caso, così la partita non si ripete uguale.
+    c.ball.waiting = false; c.ball.vy = -launchSpeed(c, power) * (0.985 + random(c) * 0.03); c.ball.vx = 0;
+    // Il salvataggio vale una volta per pallina: persa subito, torna; persa di nuovo, è persa.
+    c.saveUntil = c.saved ? 0 : c.sim + c.skill.save; c.holding = false; c.holdTime = 0; c.pointerId = null;
+    c.events.push({ kind: 'flipper-lancio', power: 0.5 + 0.5 * clamp(power, 0, 1) });
+    return true;
+}
+// Il flipper: il tasto tenuto lo alza, lasciato ricade. Più dita o tasti insieme: resta su finché ne resta uno.
+// Un «clic» (il pulsante attivato da tastiera) lo tiene su per un attimo, abbastanza perché la fisica lo veda.
+export function hold(c, side, who, down) {
+    const f = c.flippers[side]; if (!f) return false;
+    const was = f.held.length > 0;
+    f.held = f.held.filter(h => h !== who); if (down) f.held.push(who);
+    if (who === 'click' && down) f.click = CLICK_HOLD;
+    if (!was && f.held.length && c.step === 'play') c.events.push({ kind: 'flipper-flip', power: 0.6 });
+    return true;
+}
+export function flipperSeg(c, side) {
+    const f = c.flippers[side], [px, py] = PIVOT[side];
+    return { a: [px, py], b: [px + Math.cos(f.angle) * FLIP.len, py + Math.sin(f.angle) * FLIP.len] };
+}
+
+// La fisica, a passi fissi.
+export function update(c, dt) {
+    if (!Number.isFinite(dt) || dt <= 0) return;
+    dt = Math.min(dt, 0.25); c.t += dt; c.visual.time += dt;
+    if (c.lineT > 0 && (c.lineT -= dt) <= 0) { c.line = c.lines.shift() ?? null; if (c.line) { c.lineT = 2; c.lineId++; } }
+    if (c.holding) { c.holdTime += dt; c.power = powerAt(c.holdTime); }
+    for (const b of c.bumpers) b.hit = Math.max(0, b.hit - dt); c.regolo.hit = Math.max(0, c.regolo.hit - dt);
+    c.fx = c.fx.filter(f => c.visual.time - f.t < FX_LIFE);
+    c.accumulator += dt;
+    while (c.accumulator >= STEP) { c.accumulator -= STEP; step(c); }
+    // La scia della pallina: le ultime posizioni, per la cometa.
+    for (const b of activeBalls(c)) {
+        if (!b.waiting && b.releaseAt <= c.sim) { b.trail.push([b.x, b.y]); if (b.trail.length > 10) b.trail.shift(); } else b.trail.length = 0;
+    }
+    c.trail = c.ball?.trail ?? [];
+}
+function moveFlippers(c, h) {
+    for (const side of ['left', 'right']) {
+        const f = c.flippers[side];
+        if (f.click > 0 && (f.click -= h) <= 0) f.held = f.held.filter(k => k !== 'click');
+        const target = f.held.length ? (side === 'left' ? FLIP.up : Math.PI - FLIP.up) : (side === 'left' ? FLIP.rest : Math.PI - FLIP.rest);
+        const previous = f.angle;
+        f.angle += clamp(target - f.angle, -FLIP.speed * h, FLIP.speed * h);
+        f.omega = (f.angle - previous) / h;
+    }
+}
+function step(c) {
+    c.sim += STEP;
+    if (c.transform) {
+        if (c.table !== 'future' && c.sim >= c.transform.at + FUTURE.reveal) openFuture(c);
+        if (c.sim < c.transform.until) { moveFlippers(c, STEP); return; }
+        c.transform = null; announce(c, 'CARICA I TRE SIGILLI');
+    }
+    if (c.table === 'future') {
+        c.regolo.x = 320 + Math.sin(c.sim * 1.6) * 24;
+    }
+    for (const r of c.ramps) r.lit = Math.max(0, r.lit - STEP);
+    if (c.lastRamp && c.sim - c.lastRamp.at > RAMP.combo) c.lastRamp = null;
+    if (c.rampRun.count && c.sim > c.rampRun.until) c.rampRun = { id: null, count: 0, until: 0 };
+    if (c.step !== 'play') { moveFlippers(c, STEP); return; }
+    for (const bank of Object.keys(c.resets)) if (c.sim >= c.resets[bank]) { for (const t of c.targets) if (t.bank === bank) t.down = false; delete c.resets[bank]; }
+    // Una fotografia delle palline all'inizio del passo: quelle appena liberate si muovono dal prossimo.
+    const balls = activeBalls(c), ground = balls.filter(b => !b.waiting && !b.ramp && b.releaseAt <= c.sim);
+    const from = new Map(ground.map(b => [b, { x: b.x, y: b.y }]));
+    for (const b of ground) { b.vy += c.skill.g * STEP; limit(b); }
+    const speed = Math.max(0, ...ground.map(b => Math.hypot(b.vx, b.vy)));
+    const n = clamp(Math.ceil((speed + FLIP.speed * FLIP.len) * STEP / R), 1, 6), h = STEP / n;
+    // Le palette avanzano una sola volta per sottopasso, indipendentemente dal numero di palline.
+    for (let i = 0; i < n; i++) {
+        moveFlippers(c, h);
+        for (const ball of ground) {
+            ball.x += ball.vx * h; ball.y += ball.vy * h;
+            if (ball.x < LANE.x0 - R) ball.inPlay = true;
+            for (const w of c.walls) collideSeg(c, ball, w);
+            for (const t of c.targets) if (!t.down) collideTarget(c, ball, t);
+            for (const b of c.bumpers) collideBumper(c, ball, b);
+            collideRegolo(c, ball);
+            for (const side of ['left', 'right']) collideFlipper(c, ball, side);
+            limit(ball);
+        }
+        for (let a = 0; a < ground.length; a++) for (let b = a + 1; b < ground.length; b++) collideBalls(ground[a], ground[b]);
+    }
+    for (const ball of balls) {
+        if (ball.waiting || ball.releaseAt > c.sim) continue;
+        if (ball.ramp) { rideRamp(c, ball); continue; }
+        crossLanes(c, from.get(ball), ball);
+        enterRamps(c, from.get(ball), ball);
+        // L'anti-incastro è indipendente per ogni pallina; non scuote quelle trattenute sulla paletta.
+        if (!ball.anchor || Math.hypot(ball.x - ball.anchor.x, ball.y - ball.anchor.y) > 3) { ball.anchor = { x: ball.x, y: ball.y }; ball.still = 0; }
+        else if ((ball.still += STEP) > NUDGE_AFTER) { ball.still = 0; ball.anchor = null; if (!cradled(c, ball)) { ball.vx += (random(c) - 0.5) * 160; ball.vy -= 90; } }
+        if (ball.x > LANE.x0 && ball.y > 318 && Math.hypot(ball.vx, ball.vy) < 12) {
+            if ((ball.rest += STEP) > 0.3) {
+                // In multiball una ricaduta nella molla si rilancia da sola: i comandi restano alle palette.
+                if (multiball(c)) { ball.vx = 0; ball.vy = -launchSpeed(c, 0.7); ball.rest = 0; }
+                else newBall(c);
+            }
+        } else ball.rest = 0;
+        if (ball.y > FIELD.y1 + R * 2) drain(c, ball);
+    }
+    if (c.future?.won) returnClassic(c, true);
+}
+function collideBalls(a, b) {
+    let dx = b.x - a.x, dy = b.y - a.y, d = Math.hypot(dx, dy);
+    if (d >= R * 2) return;
+    const nx = d > 1e-6 ? dx / d : 1, ny = d > 1e-6 ? dy / d : 0, push = (R * 2 - d) / 2;
+    a.x -= nx * push; a.y -= ny * push; b.x += nx * push; b.y += ny * push;
+    const speed = (a.vx - b.vx) * nx + (a.vy - b.vy) * ny;
+    if (speed > 0) { const impulse = speed * 0.95; a.vx -= nx * impulse; a.vy -= ny * impulse; b.vx += nx * impulse; b.vy += ny * impulse; }
+    limit(a); limit(b);
+}
+function limit(ball) { const v = Math.hypot(ball.vx, ball.vy); if (v > MAX_SPEED) { ball.vx *= MAX_SPEED / v; ball.vy *= MAX_SPEED / v; } }
+const cradled = (c, ball) => ['left', 'right'].some(side => c.flippers[side].held.length && Math.hypot(ball.x - PIVOT[side][0], ball.y - PIVOT[side][1]) < FLIP.len + 2 * R);
+// Le corsie: contano attraversando la riga in discesa, dovunque nella corsia (la posizione orizzontale interpolata).
+function crossLanes(c, from, ball) {
+    if (!(from.y < LANE_LINE && ball.y >= LANE_LINE)) return;
+    const k = (LANE_LINE - from.y) / (ball.y - from.y), x = from.x + (ball.x - from.x) * k;
+    const l = c.lanes.find(l => x >= l.x0 && x < l.x1);
+    if (!l || l.lit) return;
+    l.lit = true; add(c, SCORE.lane, [l.x, l.y]); c.events.push({ kind: 'flipper-corsia', power: 0.6 }); fx(c, 'spark', l.x, l.y);
+    if (c.lanes.every(k => k.lit)) {
+        add(c, SCORE.palio, [324, 150]); say(c, 'PALIO!'); c.events.push({ kind: 'flipper-palio', power: 1 }); for (const k of c.lanes) k.lit = false;
+        fx(c, 'burst', 324, 110, { big: true }); fx(c, 'wash', 0, 0, { color: '255,80,80' }); fx(c, 'shake', 0, 0);
+    }
+}
+// L'imbocco di una rampa: la pallina lo attraversa in salita, abbastanza forte, e sale sul ponte: da lì segue il
+// percorso (niente urti con la tavola sotto), rallentando in salita e riprendendo in discesa. Troppo piano, torna
+// indietro e ricasca dall'imbocco.
+function enterRamps(c, from, ball) {
+    for (const r of c.ramps) {
+        if (!rampOpen(c, r)) continue;
+        const [[x0, y], [x1]] = r.mouth;
+        if (!(from.y > y && ball.y <= y && ball.vy < 0)) continue;
+        const k = (y - from.y) / (ball.y - from.y), x = from.x + (ball.x - from.x) * k;
+        if (x < x0 + R || x > x1 - R) continue;
+        // Conta solo la velocità lungo il ponte (sfiorarlo di traverso non fa salire).
+        const p = alongRamp(r, 0), forward = ball.vx * p.dx + ball.vy * p.dy;
+        if (forward < RAMP.speed) continue;
+        ball.ramp = { id: r.id, s: 0, v: forward * 0.95, off: x - p.x };
+        c.events.push({ kind: 'flipper-rampa', power: 0.7 });
+        return;
+    }
+}
+// Sul ponte: si sale fino alla cima perdendo velocità, si scende riprendendola (la stessa energia, meno un po'
+// d'attrito); in cima la quota è massima. Da lì la velocità lungo il percorso, la posizione e la quota (`z`, 0..1).
+export function rampHeight(r, s) { return s < r.top ? s / r.top : 1 - (s - r.top) / (r.len - r.top); }
+function rideRamp(c, ball) {
+    const r = c.ramps.find(k => k.id === ball.ramp.id), on = ball.ramp, uphill = on.s < r.top, slope = r.slope ?? RAMP.slope;
+    on.v += (uphill ? -slope : slope * r.top / (r.len - r.top)) * STEP - Math.sign(on.v) * RAMP.drag * STEP;
+    on.s += on.v * STEP;
+    const p = alongRamp(r, on.s), blend = Math.max(0, 1 - on.s / RAMP.blend);
+    ball.x = p.x + on.off * blend; ball.y = p.y; on.z = rampHeight(r, on.s);
+    if (on.s >= r.len) {
+        // In fondo al ponte: giù dall'altra parte, con la velocità che ha. Gli ostacoli lì sotto, se per caso la
+        // pallina esce sopra uno di loro, non contano come urto nuovo.
+        const v = Math.max(on.v, 150);
+        ball.vx = p.dx * v; ball.vy = p.dy * v; ball.ramp = null;
+        ball.contacts = [...c.bumpers, c.regolo, ...c.targets, ...c.walls].map(o => o.contactId);
+        if (c.table === 'future') {
+            c.future.hits[r.id] = Math.min(2, c.future.hits[r.id] + 1); r.lit = 3;
+            add(c, r.points, [p.x, p.y]); announce(c, `${r.id.toUpperCase()} ${c.future.hits[r.id]}/2`);
+            fx(c, 'ring', p.x, p.y); c.events.push({ kind: 'flipper-futuro-giro', power: 1 }); return;
+        }
+        if (r.id !== 'super') add(c, SCORE.ramp, [p.x, p.y]);
+        r.lit = 3; c.events.push({ kind: 'flipper-bersaglio', power: 0.9 }); fx(c, 'chase', 0, 0, { ramp: r.id });
+        if (rampFeature(c, r, ball)) return;
+        if (c.lastRamp && c.lastRamp.id !== r.id) {
+            add(c, SCORE.ponti); say(c, 'I PONTI!'); say(c, `BONUS +${SCORE.ponti}`); c.events.push({ kind: 'flipper-ponti', power: 1 }); c.lastRamp = null;
+            fx(c, 'burst', 324, 60, { big: true }); fx(c, 'wash', 0, 0, { color: '120,200,255' }); fx(c, 'shake', 0, 0); fx(c, 'chase', 0, 0, { ramp: c.ramps.find(k => k.id !== r.id).id });
+        }
+        else { say(c, r.id === 'sinistra' ? 'PONTE SX' : 'PONTE DX'); say(c, `+${SCORE.ramp}`); c.lastRamp = { id: r.id, at: c.sim }; }
+    } else if (on.s <= 0) {
+        // Non ce l'ha fatta: ricasca dall'imbocco, lungo la direzione del ponte.
+        ball.vx = -p.dx * on.v; ball.vy = Math.max(60, -p.dy * on.v); ball.ramp = null; ball.y = r.mouth[0][1] + 1;
+    } else { ball.vx = p.dx * on.v; ball.vy = p.dy * on.v; }
+}
+// Tre passaggi completi sulla stessa rampa entro venti secondi. La finestra parte dal primo.
+function announce(c, line) {
+    // Gli eventi di fase sostituiscono i vecchi annunci dei ponti; il premio del traguardo mantiene la precedenza.
+    const prize = c.lines.includes('PALLINA +1'); c.lines = [];
+    if (c.line === 'TRAGUARDO!') { if (prize) c.lines.push('PALLINA +1'); c.lines.push(line); }
+    else { c.line = null; say(c, line, true); if (prize) c.lines.push('PALLINA +1'); }
+}
+function celebrate(c, title, points, color) {
+    if (points) add(c, points, [320, 184]);
+    announce(c, title);
+    fx(c, 'celebrate', 320, 170, { text: title, points, color });
+    fx(c, 'burst', 320, 150, { big: true }); fx(c, 'shake', 0, 0);
+}
+function rampFeature(c, r, ball) {
+    if (r.id === 'super') {
+        // La rampa centrale esiste solo con entrambi i lock: premio e tre palline sul campo.
+        if (c.locks.length !== 2) return true;
+        for (const [i, lock] of c.locks.entries()) {
+            const released = lock.ball;
+            // Le uscite verticali centrano le corsie interne: nessuna spinta verso le buche laterali.
+            released.vx = 0; released.vy = 170; released.waiting = false;
+            released.trail = []; released.still = 0; released.anchor = null; released.rest = 0;
+            released.releaseAt = c.sim + i * 0.45; released.releasedFrom = lock.rampId;
+            c.extraBalls.push(released);
+        }
+        // Uscita laterale sopra la paletta sinistra, con velocità moderata; niente tiro dritto nella buca.
+        ball.vx = 0; ball.vy = 160;
+        c.locks = []; c.special = null; c.specialPaid = false; c.superOpenedAt = null; c.lastRamp = null;
+        c.rampRun = { id: null, count: 0, until: 0 }; c.saveUntil = 0; c.saved = true; c.balls++;
+        celebrate(c, 'SUPER SPECIAL', SCORE.super * c.jackpotX, '#e1a0ff');
+        c.transform = { at: c.sim, until: c.sim + FUTURE.duration };
+        c.events.push({ kind: 'flipper-esplosione', power: 1 });
+        say(c, 'PALLINA +1'); say(c, 'MULTIBALL!');
+        c.events.push({ kind: 'flipper-super', power: 1 });
+        for (const ramp of c.ramps) { ramp.lit = 5; fx(c, 'chase', 0, 0, { ramp: ramp.id }); }
+        return true;
+    }
+    if (multiball(c)) {
+        celebrate(c, 'JACKPOT!', SCORE.jackpot * c.jackpotX, '#ffcf75');
+        c.events.push({ kind: 'flipper-jackpot', power: 1 }); return true;
+    }
+    if (c.locks.some(lock => lock.rampId === r.id)) { c.rampRun = { id: null, count: 0, until: 0 }; say(c, 'LOCK OCCUPATO'); return true; }
+    if (c.special === r.id && !c.specialPaid) {
+        c.specialPaid = true;
+        celebrate(c, 'JACKPOT!', SCORE.jackpot * c.jackpotX, '#ffcf75');
+        c.events.push({ kind: 'flipper-jackpot', power: 1 });
+    }
+    const continuing = c.rampRun.id === r.id && c.sim <= c.rampRun.until;
+    c.rampRun = { id: r.id, count: continuing ? c.rampRun.count + 1 : 1, until: continuing ? c.rampRun.until : c.sim + RAMP.lockWindow };
+    if (c.rampRun.count < 3) return c.locks.length > 0;
+    c.locks.push({ rampId: r.id, ball }); ball.vx = 0; ball.vy = 0; ball.trail = [];
+    c.special = c.locks.length === 2 ? 'super' : c.ramps.find(other => other.id !== 'super' && other.id !== r.id).id;
+    c.rampRun = { id: null, count: 0, until: 0 }; c.lastRamp = null;
+    c.saveUntil = 0; c.saved = false; c.holding = false; c.holdTime = 0; c.pointerId = null;
+    newBall(c);
+    celebrate(c, c.locks.length === 2 ? 'SUPER APERTA' : 'BALL LOCKED', 0, c.locks.length === 2 ? '#e1a0ff' : '#72edff');
+    c.events.push({ kind: 'flipper-lock', power: 1 });
+    if (c.special === 'super') { c.superOpenedAt = c.visual.time; c.events.push({ kind: 'flipper-super-open', power: 1 }); }
+    return true;
+}
+function drain(c, ball) {
+    c.events.push({ kind: 'flipper-buco', power: 0.8 }); fx(c, 'wash', 0, 0, { color: '40,60,160' });
+    if (multiball(c)) {
+        if (c.ball === ball) c.ball = c.extraBalls.shift();
+        else c.extraBalls = c.extraBalls.filter(b => b !== ball);
+        c.saveUntil = 0; c.saved = true; c.rampRun = { id: null, count: 0, until: 0 };
+        say(c, multiball(c) ? 'DUE IN GIOCO' : 'UNA IN GIOCO'); return;
+    }
+    if (c.sim < c.saveUntil) { say(c, 'SALVATA!'); c.saved = true; newBall(c); return; }
+    c.rampRun = { id: null, count: 0, until: 0 };
+    if (c.locks.length) {
+        // Si recupera l'ultimo lock. L'eventuale primo resta acquisito e non si scala la riserva.
+        c.locks.pop(); c.superOpenedAt = null;
+        c.special = c.locks.length ? c.ramps.find(r => r.id !== 'super' && r.id !== c.locks[0].rampId).id : null;
+        if (!c.locks.length) c.specialPaid = false;
+        c.lastRamp = null; c.saved = false; c.saveUntil = 0;
+        announce(c, 'LOCK LIBERO'); newBall(c); return;
+    }
+    if (c.table === 'future') returnClassic(c);
+    c.balls--; c.saved = false; c.lastRamp = null; c.jackpotX = 1;
+    if (c.balls > 0) { say(c, `PALLINE: ${c.balls}`); newBall(c); return; }
+    c.ball = null; c.step = 'result';
+    c.result = { winner: c.score >= c.skill.goal ? 'player' : 'cpu', score: c.score, goal: c.skill.goal };
+}
+function contact(ball, object, hit) {
+    const index = ball.contacts.indexOf(object.contactId), fresh = index < 0;
+    if (hit && fresh) ball.contacts.push(object.contactId);
+    else if (!hit && !fresh) ball.contacts.splice(index, 1);
+    object.touching = hit;
+    return fresh;
+}
+// Pallina contro un segmento: la si spinge fuori e si riflette la velocità. Torna la velocità d'urto lungo la
+// normale (positiva se picchiava), o null se non tocca; `touching` ricorda il contatto, per contare solo gli urti nuovi.
+function hitSeg(ball, w, e) {
+    const [ax, ay] = w.a, [bx, by] = w.b, dx = bx - ax, dy = by - ay, len2 = dx * dx + dy * dy || 1;
+    const u = clamp(((ball.x - ax) * dx + (ball.y - ay) * dy) / len2, 0, 1), px = ax + dx * u, py = ay + dy * u;
+    let nx = ball.x - px, ny = ball.y - py; const d = Math.hypot(nx, ny);
+    if (d >= R) { contact(ball, w, false); return null; }
+    if (d < 1e-6) { nx = -dy; ny = dx; const n = Math.hypot(nx, ny); nx /= n; ny /= n; } else { nx /= d; ny /= d; }
+    ball.x = px + nx * R; ball.y = py + ny * R;
+    const vn = ball.vx * nx + ball.vy * ny, fresh = contact(ball, w, true);
+    if (vn < 0 && e !== null) { ball.vx -= (1 + e) * vn * nx; ball.vy -= (1 + e) * vn * ny; }
+    return { vn: -vn, nx, ny, fresh };
+}
+function collideSeg(c, ball, w) {
+    if (w.gate) {
+        if (!ball.inPlay) return;
+        const hit = hitSeg(ball, w, w.e);
+        if (hit && hit.vn > 0) ball.vx = Math.min(-100, ball.vx);
+        return;
+    }
+    if (!w.sling) { hitSeg(ball, w, w.e); return; }
+    // La sponda elastica: spinge via lungo la normale, tenendo la componente di strisciamento, e un po' a caso come
+    // la gomma vera; solo a un urto nuovo, e solo se picchia.
+    const hit = hitSeg(ball, w, null);
+    if (!hit || hit.vn <= 0) return;
+    if (hit.fresh && hit.vn > IMPACT) {
+        const a = Math.atan2(hit.ny, hit.nx) + (random(c) - 0.5) * 0.24, s = 250 + random(c) * 30;
+        const tx = ball.vx + hit.vn * hit.nx, ty = ball.vy + hit.vn * hit.ny; // la parte lungo la sponda
+        ball.vx = Math.cos(a) * s + tx * 0.6; ball.vy = Math.sin(a) * s + ty * 0.6;
+        add(c, SCORE.sling); c.events.push({ kind: 'flipper-sponda', power: 0.6 }); fx(c, 'spark', ball.x, ball.y);
+    } else { ball.vx += 1.3 * hit.vn * hit.nx; ball.vy += 1.3 * hit.vn * hit.ny; }
+}
+function collideTarget(c, ball, t) {
+    const hit = hitSeg(ball, t, 0.5);
+    if (!hit || !hit.fresh || hit.vn < IMPACT) return;
+    t.down = true; add(c, SCORE.target, [t.a[0] + (t.bank === 'pieve' ? 14 : -14), (t.a[1] + t.b[1]) / 2]); c.events.push({ kind: 'flipper-bersaglio', power: 0.7 }); fx(c, 'spark', t.a[0], (t.a[1] + t.b[1]) / 2);
+    const bank = c.targets.filter(k => k.bank === t.bank);
+    if (bank.every(k => k.down)) { c.jackpotX = Math.min(3, c.jackpotX + 1); fx(c, 'pop', 320, 205, { text: `JACKPOT X${c.jackpotX}` }); add(c, SCORE.bank, [t.a[0] + (t.bank === 'pieve' ? 30 : -30), 174]); say(c, t.bank === 'pieve' ? 'LA PIEVE!' : 'IL TREBBIO!'); c.resets[t.bank] = c.sim + BANK_RESET; fx(c, 'burst', t.a[0] + (t.bank === 'pieve' ? 20 : -20), 174); }
+}
+// Pallina contro un cerchio: spinta fuori; torna la velocità d'urto lungo la normale (null se non tocca).
+function hitCircle(ball, o, e) {
+    const dx = ball.x - o.x, dy = ball.y - o.y, d = Math.hypot(dx, dy), min = R + o.r;
+    if (d >= min) { contact(ball, o, false); return null; }
+    const nx = d > 1e-6 ? dx / d : 0, ny = d > 1e-6 ? dy / d : -1;
+    ball.x = o.x + nx * min; ball.y = o.y + ny * min;
+    const vn = ball.vx * nx + ball.vy * ny, fresh = contact(ball, o, true);
+    if (vn < 0) { ball.vx -= (1 + e) * vn * nx; ball.vy -= (1 + e) * vn * ny; }
+    return { vn: -vn, nx, ny, fresh };
+}
+function collideBumper(c, ball, b) {
+    const hit = hitCircle(ball, b, 0.2);
+    if (!hit || !hit.fresh || hit.vn < IMPACT) return;
+    const a = Math.atan2(hit.ny, hit.nx) + (random(c) - 0.5) * 0.2;
+    ball.vx = Math.cos(a) * c.skill.kick; ball.vy = Math.sin(a) * c.skill.kick;
+    b.hit = 0.15; add(c, SCORE.bumper, [b.x, b.y - 16]); c.events.push({ kind: 'flipper-fungo', power: 0.8 }); fx(c, 'ring', b.x, b.y); fx(c, 'spark', ball.x, ball.y);
+}
+function collideRegolo(c, ball) {
+    const hit = hitCircle(ball, c.regolo, 0.7);
+    if (!hit || !hit.fresh || hit.vn < IMPACT) return;
+    if (c.table === 'future' && Object.values(c.future.hits).every(n => n === 2)) { c.future.won = true; return; }
+    c.regolo.hit = 0.3; add(c, SCORE.regolo, [c.regolo.x, c.regolo.y - 14]); say(c, 'IL REGOLO!'); c.events.push({ kind: 'flipper-bersaglio', power: 1 }); fx(c, 'burst', c.regolo.x, c.regolo.y); fx(c, 'ring', c.regolo.x, c.regolo.y);
+}
+// Il flipper è una capsula che gira: alla pallina si aggiunge la velocità del punto toccato.
+function collideFlipper(c, ball, side) {
+    const f = c.flippers[side], { a, b } = flipperSeg(c, side), [ax, ay] = a, dx = b[0] - ax, dy = b[1] - ay, len2 = dx * dx + dy * dy;
+    const u = clamp(((ball.x - ax) * dx + (ball.y - ay) * dy) / len2, 0, 1), px = ax + dx * u, py = ay + dy * u;
+    let nx = ball.x - px, ny = ball.y - py; const d = Math.hypot(nx, ny), min = R + FLIP.r;
+    if (d >= min) return false;
+    if (d < 1e-6) { nx = 0; ny = -1; } else { nx /= d; ny /= d; }
+    ball.x = px + nx * min; ball.y = py + ny * min;
+    // La velocità della superficie: ω × r, col raggio dal perno al punto toccato.
+    const rx = px - ax, ry = py - ay, sx = -f.omega * ry, sy = f.omega * rx;
+    const vn = (ball.vx - sx) * nx + (ball.vy - sy) * ny;
+    if (vn < 0) { ball.vx -= (1 + 0.45) * vn * nx; ball.vy -= (1 + 0.45) * vn * ny; }
+    return true;
+}
+
+// --- Comandi: col mouse o col dito, prima del lancio tenere premuto carica la molla e lasciare lancia; in gioco
+// la metà sinistra della scena alza il flipper sinistro, la destra il destro, finché si tiene premuto (anche due dita).
+export function aimScreen(c, [x, y]) { if (!Number.isFinite(x) || !Number.isFinite(y)) return false; c.cursor = [x, y]; return true; }
+// Un tocco (Andrea, 1 novembre: «il pollice destro sulla metà destra, il sinistro sulla sinistra, al centro per lanciare»):
+// al centro della scena, a pallina ferma, carica la molla; ai lati alza la paletta di quel lato, anche prima del lancio.
+// La tastiera ('key': Spazio, freccia giù) carica sempre.
+export const PLUNGER_ZONE = 64; // mezza larghezza della fascia centrale, in pixel di scena (256-384 su 640)
+export function press(c, pointerId = 'ptr') {
+    if (c.step !== 'play') return false;
+    const x = c.cursor?.[0] ?? 320;
+    if (waiting(c) && pointerId !== 'mouse-right' && (pointerId === 'key' || Math.abs(x - 320) < PLUNGER_ZONE)) {
+        if (c.holding) return false; c.holding = true; c.holdTime = 0; c.pointerId = pointerId; c.power = 0; return true;
+    }
+    return hold(c, pointerId === 'mouse-right' || x >= 320 ? 'right' : 'left', pointerId, true);
+}
+export function release(c, pointerId = 'ptr') {
+    if (c.holding && c.pointerId === pointerId) return launch(c, powerAt(c.holdTime));
+    let any = false;
+    for (const side of ['left', 'right']) if (c.flippers[side].held.includes(pointerId)) any = hold(c, side, pointerId, false) || any;
+    return any;
+}
+// Annullare interrompe senza fare niente: la molla si scarica, i flipper ricadono (tutti, senza puntatore).
+export function cancel(c, pointerId) {
+    const all = pointerId === undefined;
+    if (all || c.pointerId === pointerId) { c.holding = false; c.holdTime = 0; c.pointerId = null; }
+    for (const f of Object.values(c.flippers)) f.held = all ? [] : f.held.filter(id => id !== pointerId);
+    return true;
+}
+// I pulsanti «← Flipper» e «Flipper →» (tenuti premuti; da tastiera un colpo breve), le frecce e i due Shift.
+export const turn = (c, dir, who = 'button') => c.step === 'play' && hold(c, dir < 0 ? 'left' : 'right', who, true);
+export function stopTurn(c, who = 'button') {
+    if (who === 'click') return false; // il colpo breve finisce da sé
+    const l = hold(c, 'left', who, false), r = hold(c, 'right', who, false);
+    return l || r;
+}
+export const nudge = () => false;
+export function setPower(c, v) { if (!canThrow(c) || !Number.isFinite(v)) return false; c.power = clamp(v, 0, 1); return true; }
+export function key(c, k, down) {
+    if (c.step !== 'play') return false; // a partita finita Spazio e Invio chiudono il risultato (main.js)
+    if (['ArrowLeft', 'ArrowRight', 'ShiftLeft', 'ShiftRight'].includes(k)) { hold(c, k.endsWith('Left') ? 'left' : 'right', 'key-' + k, down); return true; }
+    // La molla: Spazio, o la freccia giù (si tira indietro come la molla vera).
+    if (k === ' ' || k === 'ArrowDown') { if (down) { if (!c.holding && waiting(c)) press(c, 'key'); } else if (c.holding && c.pointerId === 'key') release(c, 'key'); return true; }
+    if (k === 'Enter') { if (down) shoot(c); return true; }
+    return false;
+}
+// Per provare (main.js, con ?debug, tasto S): i due LOCK fatti davvero, tre giri a rampa, e la SUPER SPECIAL aperta.
+export function openSuper(c) {
+    for (const id of ['sinistra', 'sinistra', 'sinistra', 'destra', 'destra', 'destra']) {
+        if (c.special === 'super') break;
+        const r = c.ramps.find(r => r.id === id);
+        if (waiting(c)) launch(c, 0.8);
+        if (!c.ball) return false;
+        Object.assign(c.ball, { x: r.path[0][0], y: r.mouth[0][1] + 14, vx: 0, vy: -470, ramp: null });
+        let entered = false;
+        for (let i = 0; i < 1000; i++) { update(c, STEP); if (c.ball?.ramp) entered = true; else if (entered) break; }
+    }
+    return c.special === 'super';
+}
+// Il pulsante Lancia: con la forza del cursore.
+export const shoot = c => canThrow(c) && launch(c, c.power);
+export const button = c => c.step === 'result' ? 'Finita' : waiting(c) ? 'Lancia' : 'In gioco…';
+export function status(c) {
+    if (c.step === 'result') return `${c.result.score} punti. ${c.result.winner === 'player' ? `Traguardo ${c.result.goal}: fatto!` : `Ne servivano ${c.result.goal}.`}`;
+    const goal = c.result ? 'traguardo fatto, pallina premio vinta, ora il record' : `traguardo ${c.skill.goal}`;
+    const feature = c.transform ? 'SUPER SPECIAL! Il piano si apre: arriva il Regolo del futuro.' : c.table === 'future' ? `FUTURO: Orbita ${c.future.hits.orbita}/2 · Ponte ${c.future.hits.ponte}/2 · Spira ${c.future.hits.spira}/2. Poi Regolo mobile: +500000 e ritorno. Ultima pallina persa: ritorno, −1 vita.` : c.special === 'super' ? 'SUPER SPECIAL aperta al centro: pallina premio e multiball!' : multiball(c) ? `MULTIBALL: ${activeBalls(c).length} palline. Le rampe valgono JACKPOT!` : c.locks.length ? `LOCK ${c.locks.length}/2. Completa tre passaggi sulla rampa ${c.special} per aprire la SUPER SPECIAL.` : c.rampRun.count ? `Rampa ${c.rampRun.id}: ${c.rampRun.count}/3, restano ${Math.ceil(c.rampRun.until - c.sim)} secondi.` : 'Tre passaggi sulla stessa rampa in 20 secondi: LOCK.';
+    const tally = `Punti ${c.score} (${goal}), palline ${c.balls}.${feature ? ' ' + feature : ''}`;
+    if (c.line) return `${c.line} ${tally}`;
+    return waiting(c) ? `Tieni premuto per caricare la molla e lascia, o premi Lancia. ${tally}` : `Flipper: metà sinistra e destra della scena, o i pulsanti. ${tally}`;
+}

src/engine/game.js

@@ -18,6 +18,8 @@ import { newRisveglio, updateRisveglio } from './risveglio.js';
 import { newTelefono, updateTelefono, tapTelefono } from './telefono.js';
 import * as condor from './condor.js';
 import * as campana from './campana.js';
+import * as bruciate from './bruciate.js';
+import * as flipper from './flipper.js';
 import * as poker from './poker.js';
 
 // I minigiochi in primo piano: comandi opzionali per il tiro o per la scelta di una carta.
@@ -34,6 +36,8 @@ export const MINIGAMES = {
     cerbottana: { create: (seed, level) => cerbottana.newCerbottana(seed, { level }), update: cerbottana.update, press: cerbottana.press, release: cerbottana.release, cancel: cerbottana.cancel, aim: cerbottana.aimScreen },
     condor: { create: (seed, level) => condor.newCondor(seed, { level }), update: condor.update, press: condor.press, release: condor.release, cancel: condor.cancel, aim: condor.aimScreen },
     campana: { create: (seed, level) => campana.newCampana(seed, { level }), update: campana.update, press: campana.press, release: campana.release, cancel: campana.cancel, aim: campana.aimScreen },
+    bruciate: { create: (seed, level) => bruciate.newBruciate(seed, { level }), update: bruciate.update, press: bruciate.press, release: bruciate.release, cancel: bruciate.cancel, aim: bruciate.aimScreen },
+    flipper: { create: (seed, level) => flipper.newFlipper(seed, { level }), update: flipper.update, press: flipper.press, release: flipper.release, cancel: flipper.cancel, aim: flipper.aimScreen },
     micro: { create: (seed, level) => micro.newMicro(seed, { level }), update: micro.update, press: micro.press, release: micro.release, cancel: micro.cancel, aim: micro.aimScreen },
     gara: { create: (seed, level, deck, def) => gara.newGara(seed, { level, riders: def.riders }), update: gara.update, press: gara.press, release: gara.release, cancel: gara.cancel, aim: gara.aimScreen },
 };

src/engine/music.js

@@ -13,12 +13,14 @@ import { versioned } from '../version.js';
 // suona il suo, più forte quanto più Andrea (`at`) le è vicino (mix). Le console possono stare anche fuori dal quadro:
 // è la musica della piazza accanto, che arriva da lontano.
 // `ok(cond)` dice se una condizione della storia vale adesso (game.js, check).
-export function trackFor(story, { screen, scene, phase, closeup, at, ok = () => false }) {
+// `table`: la tavola del primo piano, se ne ha più d'una (il flipper: 'classic' o 'future'), che può avere la sua musica.
+export function trackFor(story, { screen, scene, phase, closeup, table, at, ok = () => false }) {
     const m = story.music ?? {};
     if (screen === 'splash') return null;
     if (screen === 'title' || screen === 'intro') return m.title ?? null;
     if (screen === 'ending') return m.ending ?? m.game ?? null;
-    if (closeup && story.closeups?.[closeup]?.music) return story.closeups[closeup].music;
+    const cu = closeup && story.closeups?.[closeup];
+    if (cu?.music) return cu.tableMusic?.[table] ?? cu.music;
     const sc = story.scenes[scene];
     const stages = (sc?.stages ?? []).filter(st => ok(st.when));
     if (stages.length) return mix(stages, at ?? sc.entry ?? [320, 300]);
@@ -26,12 +28,17 @@ export function trackFor(story, { screen, scene, phase, closeup, at, ok = () =>
 }
 
 // Il volume di ogni console: pieno fino a `near` pixel, poi cala fino a `far` (non sotto un filo, `floor`: la festa
-// si sente sempre). La più forte per prima.
+// si sente sempre). Sotto una console (entro `near`, sfumando fino a una volta e mezzo) le altre calano fino al loro
+// filo: lì si sente bene la sola musica di quella (Andrea, 31 ottobre, in cima a Via dell'Antica Posta). La più forte
+// per prima.
 export function mix(stages, [x, y]) {
-    return stages.map(st => {
-        const d = Math.hypot(x - st.at[0], (y - st.at[1]) * 1.5), near = st.near ?? 90, far = st.far ?? 520;
-        const k = Math.max(0, Math.min(1, (d - near) / (far - near)));
-        return { src: st.music, gain: Math.max(st.floor ?? 0.08, (1 - k) ** 1.6) };
+    const near = st => st.near ?? 90, floor = st => st.floor ?? 0.08;
+    const d = stages.map(st => Math.hypot(x - st.at[0], (y - st.at[1]) * 1.5));
+    const under = stages.map((st, i) => Math.max(0, Math.min(1, (near(st) * 1.5 - d[i]) / (near(st) * 0.5))));
+    return stages.map((st, i) => {
+        const far = st.far ?? 520, k = Math.max(0, Math.min(1, (d[i] - near(st)) / (far - near(st))));
+        const others = Math.max(0, ...under.filter((_, j) => j !== i));
+        return { src: st.music, gain: Math.max(floor(st), (1 - k) ** 1.6 * (1 - others)) };
     }).sort((a, b) => b.gain - a.gain);
 }
 

src/engine/render.js

@@ -14,6 +14,8 @@ import { drawCerbottana } from './cerbottana-render.js';
 import { drawCorsa } from './corsa.js';
 import { drawCondor } from './condor-render.js';
 import { drawCampana } from './campana-render.js';
+import { drawBruciate } from './bruciate-render.js';
+import { drawFlipper } from './flipper-render.js';
 import { drawPoker } from './poker-render.js';
 import { drawViaggio } from './viaggio.js';
 import { drawIncanto } from './incanto.js';
@@ -164,6 +166,12 @@ function drawSprite(ctx, { atlas, img }, frame, x, y, scale, facing, size = 1) {
 }
 
 export function render(ctx, game, { hover, spots, debug, time = performance.now() } = {}) {
+    // Il flipper copre tutto il canvas: evitare di dipingere e illuminare anche la strada nascosta sotto.
+    if (game.closeup && game.story.closeups?.[game.closeup.id]?.type === 'flipper') {
+        drawCloseup(ctx, game, time);
+        if (debug) drawDebug(ctx, game, debug);
+        return;
+    }
     const scene = game.scene, s = game.state, backdrop = game.backdrop(), bg = backgrounds.get(backdrop);
     if (!bg && backdrop) loadBackground(backdrop);
     ctx.imageSmoothingEnabled = false;
@@ -178,7 +186,8 @@ export function render(ctx, game, { hover, spots, debug, time = performance.now(
     for (const shape of art) if (!shape.top) drawShape(ctx, shape);
     // Andrea e i personaggi della scena, dal più lontano al più vicino.
     const andrea = sprites.get('andrea');
-    const drawAndreaNow = () => andrea ? drawSprite(ctx, andrea, game.pose(), s.x, s.y, game.scaleAt(s.y), s.facing)
+    const party = festa(game, time), drawAndreaNow = () => party ? drawSprite(ctx, party.sheet, party.pose, s.x, s.y, game.scaleAt(s.y), s.facing)
+        : andrea ? drawSprite(ctx, andrea, game.pose(), s.x, s.y, game.scaleAt(s.y), s.facing)
         : drawAndrea(ctx, s.x, s.y, game.scaleAt(s.y), s.facing, game.walking ? game.stride / 6 : null);
     // Durante il risveglio si guarda dagli occhi di Andrea: lui non si vede.
     const pov = game.closeup && game.story.closeups?.[game.closeup.id]?.type === 'risveglio';
@@ -188,6 +197,7 @@ export function render(ctx, game, { hover, spots, debug, time = performance.now(
         if (sheet) queue.push({ y: p.at[1], draw: () => drawSprite(ctx, sheet, game.personPose(p), ...p.at, game.scaleAt(p.at[1]), p.facing ?? 1, p.size) });
     }
     for (const q of queue.sort((a, b) => a.y - b.y)) q.draw();
+    if (!pov) crowdFront(ctx, game, time);
     drawApparitions(ctx, game, time);
     drawPhase(ctx, game);
     drawEffects(ctx, game, time);
@@ -763,6 +773,38 @@ export const EFFECTS = {
         ctx.restore();
     },
 };
+// All'Ingorgo Andrea ha la sua birra (Andrea, 31 ottobre): camminando la tiene davanti al petto, parlando pure; fermo
+// alza il braccio col bicchiere e lo muove a tempo con la folla. Prendere e voltarsi restano quelli di sempre.
+const CHEER = ['cheer_1', 'cheer_2', 'cheer_1', 'cheer_3'];
+export function festa(game, time) {
+    const sheet = sprites.get('andrea_birra'), band = (game.scene.effects ?? []).find(e => e.type === 'crowd' && onNow(e, game));
+    if (!sheet || !band) return null;
+    const pose = game.pose(), beat = Math.floor(time / 60000 * (band.bpm ?? 120)) % CHEER.length;
+    const mine = pose === 'stand' ? CHEER[beat] : pose;
+    return sheet.atlas.frames[mine] ? { sheet, pose: mine } : null;
+}
+// Andrea dentro la folla dell'Ingorgo (Andrea, 31 ottobre: «sembra di volare fra le persone»): sopra di lui, dalla
+// vita in giù, si ridisegna la gente dello sfondo che gli sta davanti. A strisce come l'effetto `crowd`, con lo stesso
+// sobbalzo a tempo (così le teste davanti saltano con le altre) e il bordo in alto a teste, mai dritto.
+export function crowdFront(ctx, game, time, bg = backgrounds.get(game.backdrop())) {
+    const bands = (game.scene.effects ?? []).filter(e => e.type === 'crowd' && onNow(e, game));
+    if (!bg || !bands.length) return;
+    const s = game.state, h = PERSON * game.scaleAt(s.y), k = bg.width / WIDTH, waist = s.y - h * 0.5, half = Math.ceil(h * 0.3);
+    for (const e of bands) {
+        const [ax, ay, aw, ah] = e.area, step = e.step ?? 5, amount = e.amount ?? 3, beats = time / 60000 * (e.bpm ?? 120);
+        for (let x = ax + Math.floor((s.x - half - ax) / step) * step; x < s.x + half; x += step) {
+            if (x < ax || x >= ax + aw) continue;
+            const i = (x - ax) / step, b = (beats / 2 + hash(i * 17 + ay)) % 1, jump = b < 0.5 ? Math.sin(b * Math.PI) : 0;
+            const dy = Math.round(amount * (0.4 + 0.6 * hash(i * 31 + 5)) * jump);
+            // La testa di chi sta davanti: ogni striscia alla sua altezza, e salta col battito.
+            const edge = Math.round(waist - h * 0.14 * hash(i * 7 + 3)) - dy;
+            const from = Math.max(edge, ay), to = Math.min(s.y + 3, ay + ah);
+            if (to <= from) continue;
+            const w = Math.min(step, ax + aw - x);
+            ctx.drawImage(bg, x * k, (from + dy) * k, w * k, (to - from) * k, x, from, w, to - from);
+        }
+    }
+}
 const BACKGROUND_EFFECTS = new Set(['sway', 'clouds', 'cloth', 'leafshadow', 'crowd', ...Object.keys(ambientEffects)]);
 function drawEffects(ctx, game, time, background = false) {
     for (const e of game.scene.effects ?? []) {
@@ -1020,6 +1062,16 @@ function drawCloseup(ctx, game, time) {
         drawCampana(ctx, c, def, backgrounds.get(def.picture));
         return;
     }
+    if (def.type === 'flipper') {
+        for (const src of [def.picture, def.backglass]) if (src && !backgrounds.has(src)) loadBackground(src);
+        drawFlipper(ctx, c, def, backgrounds.get(def.picture), def.backglass && backgrounds.get(def.backglass));
+        return;
+    }
+    if (def.type === 'bruciate') {
+        if (!backgrounds.has(def.picture)) loadBackground(def.picture);
+        drawBruciate(ctx, c, def, backgrounds.get(def.picture));
+        return;
+    }
     if (def.type === 'micro') {
         if (!backgrounds.has(def.picture)) loadBackground(def.picture);
         drawMicro(ctx, c, def, backgrounds.get(def.picture), src => { if (!backgrounds.has(src)) loadBackground(src); return backgrounds.get(src); });

src/engine/soundscape.js

@@ -156,6 +156,31 @@ export class Soundscape {
         else if (kind === 'campana-sasso') { this.tone(1900, 1100, 0.04, 0.05 * strength + 0.02, 0, pan); this.tone(1500, 900, 0.03, 0.03, 0.06, pan); this.noiseSound(0.04, 3000, 0.03, { pan }); }
         else if (kind === 'campana-salto') { this.tone(110, 60, 0.07, 0.07, 0, pan); this.noiseSound(0.05, 500, 0.04, { pan }); }
         else if (kind === 'campana-riga') { this.tone(300, 180, 0.12, 0.05, 0, pan); this.tone(220, 120, 0.16, 0.05, 0.1, pan); }
+        // Le bruciate: il cigolio della manovella, la castagna che scoppietta cuocendo, quella che casca nel fuoco, il sacco.
+        else if (kind === 'bruciate-manovella') { this.tone(420, 380, 0.08, 0.025 * strength, 0, pan); this.noiseSound(0.06, 900, 0.02, { pan }); }
+        else if (kind === 'bruciate-scoppio') { this.noiseSound(0.04, 2600, 0.05 * strength, { pan }); this.tone(900, 500, 0.03, 0.03, 0, pan); }
+        else if (kind === 'bruciate-cade') { this.noiseSound(0.5, 3200, 0.09, { pan }); this.tone(200, 90, 0.12, 0.05, 0, pan); }
+        else if (kind === 'bruciate-sacco') this.noiseSound(0.7, 1100, 0.1, { paper: true, pan });
+        // Il flipper: la molla, il colpo del flipper, il fungo, la sponda elastica, il bersaglio, la corsia, il Palio, il buco.
+        else if (kind === 'flipper-lancio') { this.noiseSound(0.12, 1800, 0.05 * strength, { pan }); this.tone(180, 600, 0.12, 0.05, 0, pan); }
+        else if (kind === 'flipper-flip') { this.tone(240, 120, 0.05, 0.07, 0, pan); this.noiseSound(0.03, 2200, 0.04, { pan }); }
+        else if (kind === 'flipper-fungo') { this.tone(900, 500, 0.06, 0.06 * strength + 0.02, 0, pan); this.tone(1800, 900, 0.04, 0.03, 0, pan); }
+        else if (kind === 'flipper-sponda') { this.tone(520, 260, 0.05, 0.05, 0, pan); this.noiseSound(0.03, 1600, 0.03, { pan }); }
+        else if (kind === 'flipper-bersaglio') { this.tone(1400, 1200, 0.05, 0.05, 0, pan); this.tone(2100, 1800, 0.08, 0.04, 0.05, pan); }
+        else if (kind === 'flipper-corsia') { this.tone(1046, 1046, 0.08, 0.04, 0, pan); this.tone(1318, 1318, 0.1, 0.04, 0.08, pan); }
+        else if (kind === 'flipper-palio') for (const [i, f] of [523, 659, 784, 1046].entries()) this.tone(f, f, 0.14, 0.06, i * 0.1, pan);
+        else if (kind === 'flipper-ponti') for (const [i, f] of [392, 523, 659, 784, 1046, 1318].entries()) this.tone(f, f, 0.16, 0.06, i * 0.08, pan);
+        else if (kind === 'flipper-traguardo') { for (const [i, f] of [523, 659, 784, 1046].entries()) this.tone(f, f, 0.12, 0.06, i * 0.09, pan); for (const [i, f] of [784, 1046, 1318].entries()) this.tone(f, f * 1.01, 0.5, 0.05, 0.4 + i * 0.03, pan); }
+        else if (kind === 'flipper-lock') { this.tone(330, 330, 0.25, 0.06, 0, pan); this.tone(220, 220, 0.4, 0.06, 0.2, pan); this.noiseSound(0.08, 1200, 0.05, { pan }); }
+        else if (kind === 'flipper-jackpot') { for (const [i, f] of [523, 659, 784, 1046, 1318, 1568].entries()) this.tone(f, f, 0.14, 0.06, i * 0.07, pan); for (const [i, f] of [1046, 1318, 1568].entries()) this.tone(f, f * 1.01, 0.7, 0.05, 0.5 + i * 0.04, pan); }
+        else if (kind === 'flipper-super-open') { this.noiseSound(0.45, 1600, 0.04, { pan }); this.tone(180, 1200, 0.65, 0.06, 0, pan); for (const [i, f] of [659, 880, 1318].entries()) this.tone(f, f, 0.18, 0.05, 0.5 + i * 0.12, pan); }
+        else if (kind === 'flipper-super') { for (const [i, f] of [392, 523, 659, 784, 1046, 1318, 1568, 2093].entries()) this.tone(f, f * 1.005, 0.24, 0.055, i * 0.08, pan); for (const [i, f] of [523, 784, 1046].entries()) this.tone(f, f, 0.9, 0.045, 0.65 + i * 0.04, pan); }
+        // Timbri originali della tavola nascosta: botto grave e scintille (la musica è flipper-futuro.mp3, di Andrea).
+        else if (kind === 'flipper-esplosione') { this.noiseSound(1.1, 700, 0.14, { pan }); this.tone(130, 32, 1.2, 0.13, 0, pan); this.tone(90, 1800, 1.6, 0.06, 0.7, pan); }
+        else if (kind === 'flipper-futuro-giro') { this.tone(390, 1560, 0.38, 0.065, 0, pan); this.tone(1174, 1174, 0.25, 0.04, 0.25, pan); }
+        else if (kind === 'flipper-futuro-finale') { this.noiseSound(0.7, 1600, 0.07, { pan }); for (const [i, f] of [196, 294, 494, 740, 988, 1480].entries()) this.tone(f, f, 0.5, 0.055, i * 0.12, pan); }
+        else if (kind === 'flipper-rampa') { this.noiseSound(0.25, 2400, 0.04, { pan }); this.tone(300, 900, 0.3, 0.04, 0, pan); }
+        else if (kind === 'flipper-buco') { this.tone(220, 80, 0.3, 0.06, 0, pan); this.noiseSound(0.2, 600, 0.04, { pan }); }
         else if (kind === 'cerbottana-tosse') { this.noiseSound(0.18, 900, 0.08, { pan }); this.tone(260, 140, 0.12, 0.06, 0.25, pan); this.tone(240, 120, 0.1, 0.05, 0.3, pan); }
         // Le macchinine: il dito che spinge, le ruote sull'asfalto, l'urto di plastica, fuori pista, il traguardo.
         else if (kind === 'micro-spinta') { this.tone(1200, 500, 0.04, 0.04 + strength * 0.04, 0, pan); this.noiseSound(0.04, 2600, 0.04, { pan }); }

src/main.js

@@ -3,6 +3,7 @@ import { story } from './story/story.js';
 import { Game, check, VERBS, VERB_LABELS, checkSave, introText, shuffledCredits, matchPlace, reelPictures, facePicture } from './engine/game.js';
 import { Command } from './engine/command.js';
 import { render, loadAssets, hasBackground, WIDTH, HEIGHT } from './engine/render.js';
+import { cabinetAway } from './engine/flipper-render.js';
 import { readSave, writeSave, clearSave, readAudio, writeAudio, saveFile, saveFileName, readSaveFile } from './engine/storage.js';
 import { Music, trackFor } from './engine/music.js';
 import { Voices } from './engine/voices.js';
@@ -15,6 +16,8 @@ import * as micro from './engine/micro.js';
 import * as cerbottana from './engine/cerbottana.js';
 import * as condor from './engine/condor.js';
 import * as campana from './engine/campana.js';
+import * as bruciate from './engine/bruciate.js';
+import * as flipper from './engine/flipper.js';
 import * as poker from './engine/poker.js';
 import { cardAt as pokerAt } from './engine/poker-render.js';
 import * as basket from './engine/basket.js';
@@ -56,6 +59,7 @@ function showSound() {
     $('effects-volume').value = Math.round(ambience.volume * 100);
 }
 for (const ev of ['pointerdown', 'keydown']) addEventListener(ev, () => { music.unlock(); ambience.unlock(); }, { capture: true });
+addEventListener('pointerdown', e => { if (game?.closeup && 'touch' in game.closeup) game.closeup.touch = e.pointerType !== 'mouse'; }, { capture: true });
 // Il muto zittisce subito anche la voce che sta parlando.
 const toggleMute = () => { if (music.toggle()) voices.stop(); ambience.configure({ muted: music.muted }); saveAudio(); showSound(); };
 $('mute').addEventListener('click', toggleMute);
@@ -329,6 +333,7 @@ $('spots-button').addEventListener('click', showSpots);
 
 // --- Pausa: ferma il gioco; da qui mappa, crediti o ritorno al titolo (la partita resta salvata per «Continua»).
 function openPause() {
+    dropPointers();
     if (!running) return;
     running = false;
     game.closeupCancel();
@@ -395,6 +400,54 @@ addEventListener('pagehide', () => leave(true));
 addEventListener('pageshow', () => leave(document.hidden));
 $('resume').addEventListener('click', closePause);
 $('pause-map').addEventListener('click', () => { closePause(); openMap(); });
+// I comandi di un minigioco (molla, pulsanti, carte, «Come si gioca») sono più alti del pannello dei verbi: con quelli
+// aperti la scena lascia intorno lo spazio che occupano davvero, fasce comprese (--below, misurato), così su uno schermo grande o a schermo
+// intero non finiscono sotto il bordo. Senza comandi vale la riserva del pannello in unità (style.css, #app).
+// La misura cambia la scena solo per differenze grandi: una frase di stato che va a capo (PONTE SX al flipper) non deve
+// ridimensionarla a ogni colpo, che a schermo sembra un piano che salta di qualche pixel (Andrea, 1 novembre). E «Come si
+// gioca» aperto non conta: se lo si apre, la pagina scorre invece di stringere la scena (e poi non torna larga).
+function fitControls() {
+    const app = $('app'), open = !!document.querySelector('#side > section[id$="-controls"]:not([hidden])');
+    if (!app.classList.toggle('controls', open)) { app.style.removeProperty('--below'); return; }
+    // Tutto quello che non è la scena 16:9: le fasce di audio, pausa e uscita e la pulsantiera (dalla larghezza, non
+    // dalla tela, che mentre cambia risoluzione può avere per un attimo un'altezza qualunque).
+    const box = app.getBoundingClientRect(), help = document.querySelector('#side details[id$="-help"][open]');
+    const extra = help ? help.getBoundingClientRect().height - help.querySelector('summary').getBoundingClientRect().height : 0;
+    const below = Math.ceil(box.height - box.width * 9 / 16 - extra), was = parseFloat(app.style.getPropertyValue('--below'));
+    // Cresce subito (niente deve finire sotto il bordo), cala solo per differenze grandi (niente salti a ogni frase).
+    if (!(below <= was + 1 && below >= was - 24)) app.style.setProperty('--below', `${below}px`);
+}
+// «Solo tavola» al flipper (Andrea, 1 novembre): nasconde la pulsantiera, la tavola prende tutta l'altezza; il browser
+// se lo ricorda (sul telefono in orizzontale la pulsantiera del flipper è già nascosta, style.css).
+let tableOnly = (() => { try { return storage?.getItem('regolo-solo-tavola') === '1'; } catch { return false; } })();
+$('table-only').addEventListener('click', e => {
+    tableOnly = !tableOnly;
+    try { storage?.setItem('regolo-solo-tavola', tableOnly ? '1' : '0'); } catch { /* niente memoria: vale per questa volta */ }
+    e.currentTarget.blur();
+});
+// Schermo intero, dove il browser lo permette (su iPhone no: i pulsanti spariscono): dalla Pausa, dal pulsante accanto ai
+// volumi (anche sul titolo) o col tasto F; Esc, il pulsante o F per uscire.
+function toggleFullscreen() {
+    if (!document.fullscreenEnabled) return false;
+    if (document.fullscreenElement) document.exitFullscreen();
+    else document.documentElement.requestFullscreen({ navigationUI: 'hide' }).catch(() => {});
+    return true;
+}
+{
+    const full = $('fullscreen'), hud = $('fullscreen-hud');
+    if (!document.fullscreenEnabled) full.hidden = hud.hidden = true;
+    else {
+        full.addEventListener('click', toggleFullscreen);
+        hud.addEventListener('click', e => { toggleFullscreen(); e.currentTarget.blur(); });
+        document.addEventListener('fullscreenchange', () => {
+            const on = !!document.fullscreenElement;
+            full.textContent = on ? 'Esci da schermo intero' : 'Schermo intero';
+            hud.setAttribute('aria-label', on ? 'Esci da schermo intero' : 'Schermo intero');
+            hud.title = on ? 'Esci da schermo intero (F o Esc)' : 'Schermo intero (F)';
+            hud.setAttribute('aria-pressed', on);
+        });
+    }
+}
 $('to-title').addEventListener('click', () => {
     $('pause').hidden = true;
     music.hold = false;
@@ -482,6 +535,9 @@ function debugKey(e) {
     if (k === 'k') { const text = `[${debugPoints.map(p => `[${p.join(', ')}]`).join(', ')}]`; copy(text); console.log(text); return true; }
     if (k === 'x') { debugPoints.length = 0; return true; }
     if (k === 'g') { debugShown = !debugShown; return true; }
+    // Nel flipper, S: tre giri sulla rampa sinistra e tre sulla destra (due LOCK), così la SUPER SPECIAL al centro è
+    // aperta e si prova subito il Regolo del futuro.
+    if (k === 's' && story.closeups[game?.closeup?.id]?.type === 'flipper' && game.closeup.table !== 'future') { flipper.openSuper(game.closeup); return true; }
     return false;
 }
 const debugView = () => debug && debugShown && game && { mouse, points: debugPoints, help: `Maiusc+clic punto · K copia ${debugPoints.length} · X azzera · G` };
@@ -490,9 +546,22 @@ const debugView = () => debug && debugShown && game && { mouse, points: debugPoi
 const TOUCH_REACH = 22;
 const reachOf = e => e.pointerType === 'touch' || e.pointerType === 'pen' ? TOUCH_REACH * WIDTH / canvas.getBoundingClientRect().width : 0;
 let press = null;
+// Le dita in più sul flipper (oltre a `press`): ognuna lascia il suo flipper quando si alza. Il tasto destro del
+// mouse ha lo stesso pointerId del sinistro: per il flipper vale come un dito a parte ('mouse-right', sempre il
+// flipper di destra), e i due tasti si allineano alla maschera `e.buttons` a ogni evento (syncMouse).
+const extra = new Set(), pointerKey = e => e.button === 2 ? 'mouse-right' : e.pointerId;
+function syncMouse(e) {
+    const left = !!(e.buttons & 1), right = !!(e.buttons & 2);
+    if (right && !extra.has('mouse-right')) { game.closeupAim(scenePoint(e)); if (game.closeupPress('mouse-right')) extra.add('mouse-right'); }
+    if (!right && extra.has('mouse-right')) { extra.delete('mouse-right'); game.closeupRelease('mouse-right'); }
+    if (left && !press) { game.closeupAim(scenePoint(e)); press = { closeup: true, pointerId: e.pointerId, state: game.closeup }; if (!game.skip()) game.closeupPress(e.pointerId); }
+    if (!left && press?.closeup && press.pointerId === e.pointerId) { const state = press.state; press = null; if (game.closeup === state) game.closeupRelease(e.pointerId); }
+}
+// Pausa, finestra che perde il fuoco: niente resta premuto, né nel motore né qui.
+function dropPointers() { press = null; extra.clear(); }
 canvas.addEventListener('pointerdown', e => {
     if (debug && e.shiftKey && e.button === 0) { debugPoint(scenePoint(e)); return; }
-    if (!running || e.button > 0) return;
+    if (!running || (e.button > 0 && !(e.button === 2 && game.closeup && story.closeups[game.closeup.id].type === 'flipper'))) return;
     // Nel primo piano un tocco sfoglia (o salta la battuta): gli oggetti della scena dietro non si toccano.
     if (game.closeup) {
         const type = story.closeups[game.closeup.id].type, deck = CARD_AT[type];
@@ -518,6 +587,13 @@ canvas.addEventListener('pointerdown', e => {
             if (gara.press(game.closeup, e.pointerId)) { press = { gara: e.pointerId }; canvas.setPointerCapture(e.pointerId); }
             return;
         }
+        // Il flipper: un secondo dito comanda l'altro flipper, per conto suo; il tasto destro del mouse quello di destra.
+        if (type === 'flipper' && e.pointerType === 'mouse' && e.button === 2) { syncMouse(e); canvas.setPointerCapture(e.pointerId); return; }
+        if (press?.closeup && type === 'flipper' && !extra.has(pointerKey(e))) {
+            game.closeupAim(scenePoint(e));
+            if (game.closeupPress(pointerKey(e))) { extra.add(pointerKey(e)); canvas.setPointerCapture(e.pointerId); }
+            return;
+        }
         if (press?.closeup) return;
         const aimed = game.closeupAim(scenePoint(e));
         if (['biliardo', 'rinquarto', 'basket', 'micro', 'cerbottana', 'condor'].includes(story.closeups[game.closeup.id].type)) {
@@ -535,6 +611,8 @@ canvas.addEventListener('pointerdown', e => {
     press = { point, reach, long: false, timer: setTimeout(() => { press.long = true; command.clickScene(point, { look: true, reach }); }, LONG_PRESS) };
 });
 canvas.addEventListener('pointerup', e => {
+    if (e.pointerType === 'mouse' && game?.closeup && story.closeups[game.closeup.id].type === 'flipper' && (extra.has('mouse-right') || press?.closeup)) { syncMouse(e); return; }
+    if (extra.has(e.pointerId)) { extra.delete(e.pointerId); game?.closeupRelease(e.pointerId); return; }
     if (!press) return;
     // Scopa: la carta toccata e lasciata sullo stesso punto. Se sta nella presa già scelta, si prende quella; se no
     // si sceglie la prima presa che la contiene (un altro tocco conferma). Trascinando via non succede niente.
@@ -572,12 +650,14 @@ canvas.addEventListener('pointerup', e => {
     press = null;
 });
 canvas.addEventListener('pointercancel', e => {
+    if (extra.has('mouse-right') && e.pointerType === 'mouse') { extra.delete('mouse-right'); game?.closeupCancel('mouse-right'); }
+    if (extra.has(e.pointerId)) { extra.delete(e.pointerId); game?.closeupCancel(e.pointerId); return; }
     if (press?.closeup && e.pointerId !== press.pointerId) return;
     if (press) clearTimeout(press.timer);
     if (!press?.closeup || game?.closeup === press.state) game?.closeupCancel(e.pointerId);
     press = null;
 });
-canvas.addEventListener('lostpointercapture', e => { if (press?.closeup && e.pointerId !== press.pointerId) return; if (press?.closeup || press?.gara !== undefined || press?.card !== undefined || press?.table !== undefined) { press = null; game?.closeupCancel(e.pointerId); } });
+canvas.addEventListener('lostpointercapture', e => { if (extra.has('mouse-right') && e.pointerType === 'mouse' && !(e.buttons & 2)) { extra.delete('mouse-right'); game?.closeupCancel('mouse-right'); } if (extra.has(e.pointerId)) { extra.delete(e.pointerId); game?.closeupCancel(e.pointerId); return; } if (press?.closeup && e.pointerId !== press.pointerId) return; if (press?.closeup || press?.gara !== undefined || press?.card !== undefined || press?.table !== undefined) { press = null; game?.closeupCancel(e.pointerId); } });
 canvas.addEventListener('contextmenu', e => {
     e.preventDefault();
     if (running && !game.closeup) command.clickScene(scenePoint(e), { look: true });
@@ -585,6 +665,9 @@ canvas.addEventListener('contextmenu', e => {
 canvas.addEventListener('pointermove', e => {
     if (!running) return;
     mouse = e.pointerType === 'mouse' ? scenePoint(e) : null;
+    // Un tasto del mouse premuto o lasciato mentre l'altro è giù arriva come pointermove (pulsanti «in accordo»):
+    // al flipper si legge la maschera dei pulsanti e si allineano i due comandi.
+    if (e.pointerType === 'mouse' && e.button >= 0 && game.closeup && story.closeups[game.closeup.id].type === 'flipper') { syncMouse(e); return; }
     // Al biliardo e alle bocce la mira segue il mouse finché un clic (o una regolazione fine) non la fissa: dopo,
     // attraversare il campo per raggiungere la forza, «Tira» o «Lancia» non cambia il colpo. Al tiro dopo torna libera.
     // (Bocce: scoperto girando il video «Come si gioca», la mira finiva a due passi andando verso il cursore.)
@@ -617,6 +700,8 @@ const MINI = {
     cerbottana: { ...cerbottana, back: 'Torna in piazza', label: 'La cerbottana: muovi il mouse o tocca il muro per mirare, tieni premuto per prendere fiato e lascia per sparare; oppure regola il fiato e premi Spara. Frecce per spostare il mirino.' },
     condor: { ...condor, back: 'Torna al campone', label: 'La Condor: muovi il mouse o tocca il campo per mirare, tieni premuto per trattenere il fiato e lascia per sparare; oppure premi Spara. Frecce per spostare il mirino.' },
     campana: { ...campana, back: 'Torna al campone', label: 'La campana: muovi il mouse o tocca la campana per mirare, tieni premuto per la forza e lascia per tirare il sassolino; oppure regola la forza e premi Tira (frecce su e giù per mirare, destra e sinistra per la forza). Ai salti premi, o Spazio, quando la lancetta è nel verde.' },
+    bruciate: { ...bruciate, back: 'Torna alla festa', label: 'Le bruciate: tieni premuto e fai dei giri, col mouse o col dito, per girare la manovella; oppure Spazio o le frecce, una spinta a ogni colpo. Né troppo piano né troppo forte; quando son cotte, Rovescia nel sacco (o Invio).' },
+    flipper: { ...flipper, toggle: true, back: 'Torna in strada', label: 'Il flipper del River: tieni premuto per caricare la molla e lascia per lanciare (o regola la forza e premi Lancia; o tieni premuto Spazio o la freccia giù). In gioco, tieni premuto sulla metà sinistra o destra della scena per alzare il flipper di quel lato, anche con due dita o col tasto destro del mouse; oppure i pulsanti Flipper, le frecce sinistra e destra o i due Shift. La SUPER SPECIAL fa esplodere la festa e apre Il Regolo del futuro: due giri completi su Orbita (35.000), Ponte (50.000) e Spira (65.000), poi colpisci il Regolo mobile per 500.000 e il ritorno al classico senza perdere vite. Perdere l’ultima pallina del multiball riporta al classico consumando una vita. Durante la trasformazione le palline sono al sicuro; comandi invariati.' },
     micro: { ...micro, back: 'Torna dal Chiaru', label: 'La pista col gesso: muovi il mouse o tocca il parcheggio per mirare, tieni premuto per caricare la spinta e lascia; oppure regola la forza e premi Spingi. Frecce o pulsanti Mira per girare.' },
     basket: { ...basket, back: 'Torna in strada', label: 'Fai due tiri: muovi il mouse o tocca per mirare, tieni premuto per caricare la forza, lascia per tirare.' },
     // La gara: niente mira né forza, il pulsante alterna gas e freno (chi non può tenere premuto).
@@ -704,7 +789,7 @@ for (const [id, dir] of [['bocce-left', -1], ['bocce-right', 1]]) {
 // Il freno del GP, tenuto premuto (sul telefono, insieme a Gas e Sterza).
 $('gara-brake').addEventListener('pointerdown', () => { const c = miniState(); if (c) mini().brakeButton?.(c, true); });
 for (const ev of ['pointerup', 'pointerleave', 'pointercancel']) $('gara-brake').addEventListener(ev, () => { const c = miniState(); if (c) mini().brakeButton?.(c, false); });
-addEventListener('blur', () => { if (press?.card !== undefined) press = null; game?.closeupCancel(); });
+addEventListener('blur', () => { dropPointers(); game?.closeupCancel(); });
 
 // --- Verbi.
 for (const verb of VERBS) {
@@ -780,6 +865,8 @@ function updateChoices() {
     }));
 }
 
+// Ai minigiochi lo Shift arriva coi due lati distinti (ShiftLeft, ShiftRight): nel flipper comandano le due palette.
+const keyName = e => e.key === 'Shift' ? e.code : e.key;
 window.addEventListener('keydown', e => {
     if (e.target instanceof HTMLInputElement && e.target.type === 'range' && e.key !== 'Escape') return;
     // Nella ricerca della mappa le lettere si scrivono; Esc prima svuota la casella, poi chiude.
@@ -788,6 +875,8 @@ window.addEventListener('keydown', e => {
         return;
     }
     if (debugKey(e)) return;
+    // F: schermo intero ovunque (nessun gioco usa la F; nella ricerca della mappa si scrive, sopra).
+    if ((e.key === 'f' || e.key === 'F') && !e.ctrlKey && !e.metaKey && !e.altKey && !e.repeat && toggleFullscreen()) { e.preventDefault(); return; }
     if (!$('tutorial').hidden) { if (e.key === 'Escape') closeTutorial(); return; }
     if (!$('credits').hidden) {
         if (e.key === 'Escape') { if (!$('face').hidden) $('face').hidden = true; else $('credits').hidden = true; }
@@ -872,7 +961,7 @@ window.addEventListener('keydown', e => {
             if (e.key === 'Escape') { game.closeupClose(); return; }
             const onButton = ['BUTTON', 'SUMMARY'].includes(e.target.tagName), onControl = onButton && e.target.closest?.('#bocce-controls');
             // Il GP di Fortezza: frecce, Spazio e Invio finché si tengono giù (su un pulsante Spazio e Invio lo premono).
-            if (!(onButton && [' ', 'Enter'].includes(e.key)) && mini().key?.(game.closeup, e.key, true, e.shiftKey)) { e.preventDefault(); return; }
+            if (!(onButton && [' ', 'Enter'].includes(e.key)) && mini().key?.(game.closeup, keyName(e), true, e.shiftKey)) { e.preventDefault(); return; }
             if (onControl && [' ', 'Enter'].includes(e.key)) return;
             const c = game.closeup, m = mini();
             if (['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown'].includes(e.key)) {
@@ -919,7 +1008,7 @@ window.addEventListener('keydown', e => {
 // Alle bocce e al biliardo, lasciando spazio o Invio parte il tiro.
 window.addEventListener('keyup', e => {
     // Il GP di Fortezza tiene conto di ogni tasto per conto suo: lasciarne uno non toglie il gas del dito o degli altri.
-    if (miniState() && mini().key?.(game.closeup, e.key, false)) return;
+    if (miniState() && mini().key?.(game.closeup, keyName(e), false)) return;
     if (running && [' ', 'Enter'].includes(e.key)) game?.closeupRelease();
 });
 
@@ -1046,13 +1135,15 @@ function updateUi() {
         }
     }
     if (mg && !cards) {
-        setAttr($('bocce-controls'), 'aria-label', { rinquarto: 'Comandi dei rinquarti', biliardo: 'Comandi del biliardo', basket: 'Comandi del basket', pesca: 'Comandi della pesca', gara: 'Comandi della gara', micro: 'Comandi delle macchinine', cerbottana: 'Comandi della cerbottana', condor: 'Comandi della Condor', campana: 'Comandi della campana' }[def.type] ?? 'Comandi delle bocce');
+        setAttr($('bocce-controls'), 'aria-label', { rinquarto: 'Comandi dei rinquarti', biliardo: 'Comandi del biliardo', basket: 'Comandi del basket', pesca: 'Comandi della pesca', gara: 'Comandi della gara', micro: 'Comandi delle macchinine', cerbottana: 'Comandi della cerbottana', condor: 'Comandi della Condor', campana: 'Comandi della campana', bruciate: 'Comandi delle bruciate', flipper: 'Comandi del flipper' }[def.type] ?? 'Comandi delle bocce');
         setProp($('panel'), 'hidden', true); setProp($('choices'), 'hidden', true);
         const line = mg.status(c, def.names);
         if ($('bocce-status').textContent !== line) $('bocce-status').textContent = line;
         setValue($('bocce-power'), Math.round(c.power * 100));
         setValue($('bocce-power-value'), `${Math.round(c.power * 100)}%`);
         for (const id of ['bocce-power', 'bocce-left', 'bocce-right']) setProp($(id), 'disabled', !(mg.canAdjust?.(c) ?? mg.canThrow(c)) || (c.holding && !mg.toggle) || !!game.speech);
+        // Al flipper i due pulsanti valgono per tutta la partita, il cursore della molla solo prima del lancio.
+        if (mg.canFlip) for (const id of ['bocce-left', 'bocce-right']) setProp($(id), 'disabled', !mg.canFlip(c) || !!game.speech);
         setProp($('bocce-throw'), 'disabled', !(mg.canPress?.(c) ?? mg.canThrow(c)) || (c.holding && !mg.toggle) || !!game.speech);
         // Il GP di Fortezza: niente forza, e i due pulsanti di mira diventano lo sterzo (si tengono premuti).
         // Nel GP di Fortezza il cursore della forza diventa la sensibilità dello sterzo col dito (ricordata).
@@ -1060,9 +1151,9 @@ function updateUi() {
         // Ai rinquarti la forza è sempre piena: il cursore non serve. Nella guida semplice del GP (alla bona e seria) si
         // usa solo il gas: niente sensibilità, sterzo, freno né riquadro dello swipe.
         const easy = def.type === 'gara' && gara.simple(c);
-        setProp(powerLabel, 'hidden', def.type === 'rinquarto' || def.type === 'condor' || easy);
-        for (const id of ['bocce-left', 'bocce-right']) setProp($(id), 'hidden', easy || def.type === 'campana');
-        const powerName = def.type === 'gara' ? 'Sensibilità ' : def.type === 'cerbottana' ? 'Fiato ' : 'Forza ';
+        setProp(powerLabel, 'hidden', def.type === 'rinquarto' || def.type === 'condor' || def.type === 'bruciate' || easy);
+        for (const id of ['bocce-left', 'bocce-right']) setProp($(id), 'hidden', easy || def.type === 'campana' || def.type === 'bruciate');
+        const powerName = def.type === 'gara' ? 'Sensibilità ' : def.type === 'cerbottana' ? 'Fiato ' : def.type === 'flipper' ? 'Molla ' : 'Forza ';
         if (powerLabel.firstChild.nodeValue !== powerName) powerLabel.firstChild.nodeValue = powerName;
         setAttr($('bocce-power'), 'aria-label', def.type === 'gara' ? 'Sensibilità dello sterzo col dito' : 'Forza del lancio');
         setProp($('gara-pad'), 'hidden', def.type !== 'gara' || easy);
@@ -1070,8 +1161,8 @@ function updateUi() {
             c.sensLoaded = true;
             try { const v = localStorage.getItem(GARA_SENS); if (v !== null) gara.setPower(c, Number(v) / 100); } catch { /* si resta al valore di partenza */ }
         }
-        setText($('bocce-left'), def.type === 'gara' ? '← Sterza' : '← Mira');
-        setText($('bocce-right'), def.type === 'gara' ? 'Sterza →' : 'Mira →');
+        setText($('bocce-left'), def.type === 'gara' ? '← Sterza' : def.type === 'flipper' ? '← Flipper' : '← Mira');
+        setText($('bocce-right'), def.type === 'gara' ? 'Sterza →' : def.type === 'flipper' ? 'Flipper →' : 'Mira →');
         setProp($('gara-brake'), 'hidden', def.type !== 'gara' || easy);
         $('bocce-throw').classList.toggle('hold', easy);
         setProp($('gara-brake'), 'disabled', !(mg.canAdjust?.(c) ?? false) || !!game.speech);
@@ -1083,6 +1174,8 @@ function updateUi() {
         setProp($('cerbottana-help'), 'hidden', def.type !== 'cerbottana');
         setProp($('condor-help'), 'hidden', def.type !== 'condor');
         setProp($('campana-help'), 'hidden', def.type !== 'campana');
+        setProp($('bruciate-help'), 'hidden', def.type !== 'bruciate');
+        setProp($('flipper-help'), 'hidden', def.type !== 'flipper');
         setProp($('basket-help'), 'hidden', def.type !== 'basket');
         setProp($('pesca-help'), 'hidden', def.type !== 'pesca');
         setProp($('gara-help'), 'hidden', def.type !== 'gara');
@@ -1114,8 +1207,16 @@ function updateUi() {
     canvas.classList.toggle('torch', !!torch);
     canvas.classList.toggle('bocce', !!mg);
     // Biliardo e GP di Fortezza: audio, pausa e uscita fuori dal quadro (al GP la pista passa negli angoli).
-    $('stage').classList.toggle('biliardo', !!c && ['biliardo', 'rinquarto', 'gara', 'micro', 'cerbottana', 'condor', 'campana'].includes(story.closeups[c.id].type));
+    $('stage').classList.toggle('biliardo', !!c && ['biliardo', 'rinquarto', 'gara', 'micro', 'cerbottana', 'condor', 'campana', 'flipper'].includes(story.closeups[c.id].type));
     $('stage').classList.toggle('briscola', !!cards);
+    const pinball = story.closeups[c?.id]?.type === 'flipper';
+    // Si gioca col dito? Dallo schermo all'apertura, poi da ogni tocco (pointerdown): la scritta della molla è per il dito.
+    if (pinball && c.touch === undefined) c.touch = matchMedia('(hover: none)').matches;
+    $('app').classList.toggle('flipper', pinball);
+    $('app').classList.toggle('table-only', pinball && tableOnly);
+    setProp($('table-only'), 'hidden', !pinball);
+    setText($('table-only'), tableOnly ? 'Pulsantiera' : 'Solo tavola');
+    fitControls();
     setAttr(canvas, 'aria-label', torch ? 'Fessura: sposta la luce con mouse, dito o frecce. Invio cerca il prossimo dettaglio; Esc esce.' : mg ? mg.label : "La scena dell'avventura");
     // La pagina che comincia a girare fa il suo fruscio.
     const step = game.closeup?.step ?? null;
@@ -1143,7 +1244,7 @@ function frame(now) {
     const searching = game?.closeup?.id === 'fessura';
     music.duck = searching ? game.closeup.found >= 2 ? 0.05 : 0.25 : game?.state.flags.occhi_regolo ? 0.12 : voices.playing ? 0.45 : 1;
     music.update(trackFor(story, { screen, scene: game?.state.scene, phase: game?.phase(), closeup: game?.closeup?.id,
-        at: game && [game.state.x, game.state.y], ok: cond => !!game && check(cond, game.state) }), dt);
+        table: game?.closeup?.table, at: game && [game.state.x, game.state.y], ok: cond => !!game && check(cond, game.state) }), dt);
     // Un minuto senza toccare niente, a gioco fermo: pausa da sola.
     if (running && now - idleSince > IDLE_PAUSE && !game.speech && !game.walking && !game.queue.length) openPause();
     ambience.configure({ active: screen === 'game' && running && !document.hidden && $('credits').hidden, muted: music.muted, duck: voices.playing ? 0.4 : 1 });
@@ -1153,6 +1254,15 @@ function frame(now) {
     const still = game && !running && `${game.state.scene}|${hasBackground(game.backdrop())}`;
     if (game && (!still || still !== drawnStill)) {
         if (running) game.update(dt);
+        // Il tavolo del flipper ha superfici e luci continue; gli altri ambienti restano in pixel art.
+        const pinballHD = game.closeup && story.closeups[game.closeup.id].type === 'flipper';
+        const sceneScale = pinballHD ? 2 : 1;
+        if (canvas.width !== WIDTH * sceneScale) {
+            canvas.width = WIDTH * sceneScale; canvas.height = HEIGHT * sceneScale;
+            canvas.classList.toggle('pinball-hd', !!pinballHD);
+            if (!pinballHD) cabinetAway(canvas);
+        }
+        ctx.setTransform(sceneScale, 0, 0, sceneScale, 0, 0);
         render(ctx, game, { hover: debug && hoverTarget ? game.hotspot(hoverTarget) : null, spots: running && now < spotsUntil, debug: debugView() });
         // Cambiando scena, un attimo di nero che sfuma: la dissolvenza dei vecchi giochi, invece del taglio netto.
         if (game.state.scene !== fadeScene) { if (fadeScene) fade = 1; fadeScene = game.state.scene; }

src/story/piloti.js

@@ -23,6 +23,9 @@ export const piloti = [
         casco: 'assets/closeups/gp/casco-tozzino.png', helmet: '#131c3c', stripe: '#f4f4f4' },
     // Yuri de' Motori (Juri Lascialfari, consenso del 28 ottobre) col suo Yamaha Spy bianco e rosso, il «Mazinga Spy» (foto di Andrea).
     { id: 'yuri', name: 'Yuri de\' Motori', bike: 'il Mazinga Spy', motore: 3, testa: 5, color: '#f0f0ee', trim: '#d8302a', moto: 'assets/closeups/gp/spy.png', face: 'assets/closeups/gp/yuri.png', consenso: '2026-10-28' },
+    // Il Boccino (Gabriele Chiesi, consenso del 31 ottobre) col suo Piaggio NRG bianco e rosso col numero 1 (foto di
+    // Andrea); il ritratto di Codex dalla sua foto. In curva prudente (Andrea, 31 ottobre). [DA ANDREA: il motore]
+    { id: 'boccino', name: 'Il Boccino', bike: 'l\'NRG numero 1', motore: 3, testa: 5, color: '#f4f4f2', trim: '#d8302a', helmet: '#d8302a', stripe: '#f4f4f2', moto: 'assets/closeups/gp/nrg.png', face: 'assets/closeups/gp/boccino.png', consenso: '2026-10-31' },
     // Il Gianno (il Giannini, consenso del 28 ottobre) col suo Piaggio Typhoon rosso e nero (foto di Andrea).
     { id: 'gianno', name: 'Il Gianno', bike: 'il Typhoon', motore: 3, testa: 3, color: '#9e1b22', trim: '#151515', moto: 'assets/closeups/gp/typhoon.png', face: 'assets/closeups/gp/gianno.png', consenso: '2026-10-28' },
     // La Brauda (Giody Brunetti, consenso del 28 ottobre) col suo Aprilia Rally nero (foto di Andrea). [DA ANDREA: motore e testa]

src/story/story.js

@@ -93,7 +93,7 @@ export const story = {
     // col manifesto in piazza e si spegne uscendo dal centro. [DA ANDREA: le battute sono provvisorie]
     zones: [
         {
-            flag: 'ingorgo', scenes: ['piazza', 'via_antica_posta', 'piazzetta_comune', 'antica_posta_alta', 'piazzetta'],
+            flag: 'ingorgo', scenes: ['piazza', 'via_antica_posta', 'piazzetta_comune', 'antica_posta_alta', 'piazzetta', 'via_calimara', 'via_cipriani'],
             exitsOnly: true, // alla festa si clicca solo per spostarsi (Andrea)
             leave: [
                 { say: 'Mi stropiccio gli occhi. La musica non c\'è più: è di nuovo maggio.' },
@@ -360,6 +360,30 @@ export const story = {
             draw: [],
             quit: [{ say: 'Il gesso lo lascio lì. Ci giocherà qualche bambino, che è più in allenamento di me.' }],
         },
+        // Il flipper del River (Andrea, 31 ottobre: «una tavola bellissima, con San Piero dentro»): la tavola di Codex,
+        // fisica e parti meccaniche in flipper.js. [DA ANDREA: le battute sono provvisorie]
+        flipper: {
+            // Le musiche di Andrea (Suno, 1 novembre): la classica, e quella del Regolo del futuro dopo la SUPER SPECIAL.
+            type: 'flipper', music: 'assets/audio/flipper.mp3', tableMusic: { future: 'assets/audio/flipper-futuro.mp3' },
+            picture: 'assets/closeups/river-flipper.png',
+            backglass: 'assets/closeups/river-flipper-tabellone.png', // il fondale luminoso del tabellone (Codex: Trebbio, Fortezza, Regolo, fuochi)
+            names: { player: 'Andrea', cpu: 'il flipper' },
+            win: [{ say: 'Traguardo! Se c\'era la classifica, oggi ci mettevo le mie iniziali.' }, { set: 'flipper_vinto' }],
+            lose: [{ say: 'Tre palline, e tutte nella Sieve. Il flipper del River non perdona.' }],
+            draw: [],
+            quit: [{ say: 'Lascio la pallina lì. Tanto il River non chiude.' }],
+        },
+        // Le bruciate della Smarronata, 1993: la manovella del cilindro sul fuoco, coi volontari della Misericordia
+        // (Andrea, 31 ottobre: «a manovella, a mano»). [DA ANDREA: le battute sono provvisorie]
+        bruciate: {
+            type: 'bruciate',
+            picture: 'assets/closeups/smarronata-bruciatore.png',
+            names: { player: 'Andrea', cpu: 'i volontari' },
+            win: [{ say: 'Bruciate coi fiocchi! Mezza Smarronata le mangia grazie a me.' }, { say: 'Bravo, figliolo! Se ti va, l\'anno prossimo la manovella è tua.', who: 'volontari', pose: 'give' }, { set: 'bruciate_fatte' }],
+            lose: [{ say: 'Un po\' crude, un po\' carbone... Le mangio io, va\'.' }, { say: 'Ci vuole il polso, figliolo. Il polso e la pazienza.', who: 'volontari', pose: 'explain' }],
+            draw: [],
+            quit: [{ say: 'Vi rendo la manovella. Mi fumano anche gli occhi.' }],
+        },
         // Il manifesto dell'Ingorgo, ingrandito (Andrea, 30 ottobre: «se mi avvicino compaia ingrandito, e poi parta
         // l'Ingorgo se ci clicco»). [DA ANDREA: il manifesto vero; questo è di Codex, provvisorio]
         manifesto_ingorgo: {
@@ -520,6 +544,7 @@ export const story = {
         // Andrea col pallone, per «Fai due tiri» (foglio di Codex dal suo sprite): non parla, lo disegna basket-render.
         andrea_basket: { name: 'Andrea', sprite: 'assets/characters/andrea-basket.json' },
         andrea_pesca: { name: 'Andrea', sprite: 'assets/characters/andrea-pesca.json' },
+        andrea_birra: { name: 'Andrea', sprite: 'assets/characters/andrea-birra.json' }, // all'Ingorgo, con la birra
         // Quattro ragazzi inventati (sprite di Codex, idea di Andrea del 27 ottobre): nessuna persona reale.
         pescatori: { name: 'I ragazzi delle canne', color: '#b8f08a', sprite: 'assets/characters/pescatori.json' },
         // La gente della Smarronata del 1993 (Andrea, 31 ottobre): tutti inventati, vestiti come nei fotogrammi del video.
@@ -1240,6 +1265,19 @@ export const story = {
             name: 'Via Pietro Cipriani',
             map: [22, 64],
             background: 'assets/scenes/via-cipriani.png',
+            backdrops: [{ when: 'ingorgo', src: 'assets/scenes/ingorgo-via-cipriani.png' }], // Codex, la notte dell'Ingorgo (31 ottobre)
+            // All'Ingorgo anche l'inizio di Via Cipriani (Andrea, 31 ottobre): la console sul campo da basket, le casse in
+            // cima alle scale, i laser rossi e lo strobo, e giù la gente che poga (la folla che salta, forte davanti).
+            // La hardcore techno di Andrea (Suno, 31 ottobre) alla console del campo; da lontano la house della Piazza e la tecno.
+            effects: [{ type: 'crowd', phase: 'ingorgo', area: [0, 235, 640, 55], bpm: 180, amount: 3 }, { type: 'crowd', phase: 'ingorgo', area: [0, 290, 640, 70], bpm: 180, amount: 6 },
+                { type: 'lasers', phase: 'ingorgo', at: [300, 160], count: 9, color: '255,40,40', len: 440 },
+                { type: 'stagelights', phase: 'ingorgo', from: [[262, 152], [338, 152]], wash: [300, 172, 160], bpm: 180, beams: 2, strobe: 8, pulse: 0.1, colors: ['255,40,40', '255,255,255', '255,90,40'] },
+                { type: 'floorspots', phase: 'ingorgo', area: [40, 240, 560, 110], bpm: 180, count: 7, colors: ['255,40,40', '255,255,255', '255,90,40'] }],
+            stages: [
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-hardcore.mp3', at: [300, 250], near: 150, far: 800 },
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-house.mp3', at: [140, 60], far: 700 },
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-techno.mp3', at: [-250, 100], far: 800 },
+            ],
             walk: [[40, 360], [40, 320], [60, 280], [100, 272], [150, 276], [300, 300], [360, 318], [640, 345], [640, 360]],
             depth: [[272, 0.45], [360, 1.15]],
             entry: [300, 345],
@@ -1591,6 +1629,20 @@ export const story = {
             name: 'Via Calimara',
             map: [36, 58],
             background: 'assets/scenes/via-calimara.png',
+            backdrops: [{ when: 'ingorgo', src: 'assets/scenes/ingorgo-via-calimara.png' }], // Codex, la notte dell'Ingorgo (31 ottobre)
+            // All'Ingorgo anche Via Calimara (Andrea, 31 ottobre): la console nel giardino sotto i cedri, con la palla a
+            // specchi appesa al ramo, e la strada piena fino in fondo, con la folla che salta (Andrea: «mi raccomando»).
+            // La musica anni '90 di Andrea (Suno, 31 ottobre) alla console del giardino; da lontano la house della Piazza
+            // e il latino del Comune.
+            effects: [{ type: 'crowd', phase: 'ingorgo', area: [0, 190, 640, 75], bpm: 130, amount: 3 }, { type: 'crowd', phase: 'ingorgo', area: [0, 265, 640, 95], bpm: 130, amount: 5 },
+                { type: 'mirrorball', phase: 'ingorgo', at: [170, 123], hang: 96, from: [104, 178], surfaces: [[0, 40, 300, 140], [0, 190, 640, 170], [560, 90, 80, 110]], bpm: 130, count: 64 },
+                { type: 'stagelights', phase: 'ingorgo', from: [[54, 168], [154, 168]], wash: [104, 185, 150], bpm: 130, beams: 2, strobe: 4, pulse: 0.08, colors: ['255,90,180', '255,170,60', '255,220,120', '200,90,255'] },
+                { type: 'floorspots', phase: 'ingorgo', area: [40, 220, 560, 130], bpm: 130, count: 7, colors: ['255,90,180', '255,170,60', '255,220,120', '200,90,255'] }],
+            stages: [
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-anni90.mp3', at: [104, 230], near: 150, far: 800 },
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-house.mp3', at: [365, 60], far: 700 },
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-latino.mp3', at: [-300, 250], far: 800 },
+            ],
             walk: [[0, 360], [0, 318], [330, 206], [400, 206], [560, 300], [600, 360]],
             depth: [[206, 0.3], [360, 1.15]],
             entry: [300, 350],
@@ -1625,10 +1677,13 @@ export const story = {
             entry: [140, 340],
             hotspots: [
                 {
-                    id: 'river', name: 'il River', box: [60, 128, 190, 110], at: [160, 320], face: 'up',
+                    // Un clic sul River entra e va al flipper (Andrea: «Usa» o «Apri» non si capiva).
+                    id: 'river', name: 'il River: dentro c\'è il flipper', box: [60, 128, 190, 110], at: [160, 320], face: 'up', default: 'open',
                     actions: {
                         look: [{ say: 'Il River, il bar della rotonda. Fuori gli ombrelloni, dentro i flipper e le figurine.' }],
-                        open: [{ say: 'Un ghiacciolo ci starebbe. Ma prima il palio, poi i ghiaccioli.' }],
+                        // Dentro, il flipper (Andrea, 31 ottobre): si entra e si sceglie come giocarlo.
+                        open: [{ say: 'Un ghiacciolo ci starebbe. Ma prima... il flipper.' }, { dialogue: 'flipper' }],
+                        use: [{ say: 'Dentro, in fondo, fra le figurine: il flipper. Con San Piero dipinto sulla tavola.' }, { dialogue: 'flipper' }],
                     },
                 },
                 {
@@ -1901,11 +1956,13 @@ export const story = {
                 { type: 'pixelspots', phase: 'ingorgo', area: [130, 242, 490, 108], bpm: 122, count: 5, size: 20, colors: ['155,65,255', '65,110,255'] },
             ],
             stages: [
-                { when: 'ingorgo', music: 'assets/audio/ingorgo-underground.mp3', at: [565, 235] },
+                // Giù a destra, sul marciapiede sotto il giardinetto, si arriva sotto la console: lì solo l'underground.
+                { when: 'ingorgo', music: 'assets/audio/ingorgo-underground.mp3', at: [565, 235], near: 190 },
                 { when: 'ingorgo', music: 'assets/audio/ingorgo-techno.mp3', at: [270, 120], far: 600 },
                 { when: 'ingorgo', music: 'assets/audio/ingorgo-house.mp3', at: [240, 640], far: 750 },
             ],
-            walk: [[0, 360], [0, 322], [190, 226], [283, 222], [470, 360]],
+            // Col marciapiede di destra, fra le catenelle e il giardinetto, fino in fondo (Andrea, 31 ottobre).
+            walk: [[0, 360], [0, 322], [190, 226], [283, 222], [350, 236], [452, 272], [640, 335], [640, 360]],
             depth: [[222, 0.35], [360, 1.15]],
             entry: [240, 350],
             hotspots: [
@@ -3169,8 +3226,16 @@ export const story = {
                     id: 'zio_mario', name: 'lo zio Mario', box: [418, 206, 46, 124], at: [362, 334], face: 'right', default: 'look', when: '!indizio_regolo',
                     actions: {
                         look: [{ say: 'Lo zio Mario. Guarda il muro, guarda la macchina, e si gratta la testa sotto il berretto.' }],
-                        // Il primo scambio con lo zio (Andrea, 29 ottobre).
-                        talk: [{ say: 'Zio, hai problemi?' }, { say: 'I problemi io gli avevo quando andavo a scuola!', who: 'zio_mario', pose: 'laugh' }],
+                        // Il primo scambio con lo zio (Andrea, 29 ottobre); «Siamo a cavallo al ciuco», «Menomale tu ci sei te» e
+                        // «Alla terza tu capisci subito» sono di Andrea (31 ottobre). [DA ANDREA: la domanda sulla Ghiacciomobile]
+                        talk: [
+                            { say: 'Zio, hai problemi?' },
+                            { say: 'I problemi io gli avevo quando andavo a scuola!', who: 'zio_mario', pose: 'laugh' },
+                            { say: 'E con la Ghiacciomobile nel muro, come si fa?' },
+                            { say: 'Siamo a cavallo al ciuco!', who: 'zio_mario', pose: 'explain' },
+                            { say: 'Menomale tu ci sei te, Zio!' },
+                            { say: 'Alla terza tu capisci subito, al volo!', who: 'zio_mario', pose: 'laugh' },
+                        ],
                     },
                 },
             ],
@@ -3661,6 +3726,11 @@ export const story = {
                             { say: 'No, dormo!', who: 'zio_mario', pose: 'laugh' },
                             { say: 'Zio, a me mi garba Michael Jackson!' },
                             { say: 'Mai col gesso!', who: 'zio_mario', pose: 'laugh' },
+                            // Il posto lontanissimo dello zio (Andrea, 31 ottobre).
+                            { say: 'Sai, Zio? Son stato in California!' },
+                            { say: 'E dov\'è?', who: 'zio_mario', pose: 'think' },
+                            { say: 'In America!' },
+                            { say: 'Ahhh... sopra Firenzola!', who: 'zio_mario', pose: 'point' },
                         ],
                     },
                 },
@@ -3734,7 +3804,8 @@ export const story = {
                     id: 'bruciatore', name: 'il cilindro delle bruciate', box: [192, 188, 68, 54], at: [226, 262], face: 'up',
                     actions: {
                         look: [{ say: 'Il cilindro delle bruciate: si gira la manovella sopra il fuoco, e le castagne ci ballano dentro.' }],
-                        use: [{ say: 'Si gira piano, sennò le bruciate si bruciano davvero.' }],
+                        // Il minigioco delle bruciate: la manovella si gira coi volontari (Andrea, 31 ottobre).
+                        use: [{ say: 'Posso girare io la manovella?' }, { dialogue: 'volontari' }],
                         take: [{ say: 'Una bruciata calda, presa al volo. Scotta! Ma è buonissima.' }],
                     },
                 },
@@ -3763,11 +3834,7 @@ export const story = {
                     id: 'volontari', name: 'i volontari della Misericordia', box: [130, 148, 97, 114], at: [200, 272], face: 'left', default: 'talk',
                     actions: {
                         look: [{ say: 'I volontari della Misericordia, alle bruciate: uno rimescola, l\'altro riempie i cartocci.' }],
-                        talk: [
-                            { say: 'Che Iddio ve ne renda merito!! A voi e agli alpini!' },
-                            { say: 'E a te, figliolo. To\', un cartoccio: son belle calde.', who: 'volontari', pose: 'give' },
-                            { say: 'Scottano! Ma son buonissime.' },
-                        ],
+                        talk: [{ dialogue: 'volontari' }],
                     },
                 },
                 {
@@ -4237,6 +4304,30 @@ export const story = {
         },
         // Il BaronDeDuke nella discesa verso la polisportiva: le mutande perse a poker, e il Muro del Sanpierino sul
         // telefonino (Andrea, 31 ottobre: lui è il webmaster di sanpiero50037.it).
+        // I volontari della Misericordia alle bruciate della Smarronata, 1993: il ringraziamento di Andrea e la manovella
+        // (il minigioco delle bruciate, Andrea, 31 ottobre). [DA ANDREA: le battute sono provvisorie]
+        volontari: {
+            nodes: {
+                start: { options: [
+                    { text: 'Che Iddio ve ne renda merito!! A voi e agli alpini!', then: [
+                        { say: 'E a te, figliolo. To\', un cartoccio: son belle calde.', who: 'volontari', pose: 'give' },
+                        { say: 'Scottano! Ma son buonissime.' },
+                    ] },
+                    { text: 'Vi do una mano alla manovella?', next: 'livello', then: [
+                        { say: 'Su, giovanotto, che noi s\'ha le braccia stanche!', who: 'volontari', pose: 'talk' },
+                        { say: 'Si gira sempre uguale: piano piano sotto si bruciano, a furia volan nel fuoco. Quando son cotte, nel sacco.', who: 'volontari', pose: 'explain' },
+                        { say: 'Come te la senti?', who: 'volontari', pose: 'talk' },
+                    ] },
+                    { text: 'Buon lavoro!', next: 'end' },
+                ] },
+                livello: { options: [
+                    { text: 'Alla bona.', next: 'end', then: [{ say: 'Alla bona: ti si guarda noi, e se si bruciano un si dice a nessuno.', who: 'volontari', pose: 'talk' }, { closeup: 'bruciate', level: 'bona' }] },
+                    { text: 'Seria.', next: 'end', then: [{ say: 'Seria: la gente è in fila, e il cartoccio lo vole bello pieno.', who: 'volontari', pose: 'explain' }, { closeup: 'bruciate', level: 'seria' }] },
+                    { text: 'A fassi male.', next: 'end', then: [{ say: 'A fassi male? Allora ci si mette anche il fuoco forte.', who: 'volontari', pose: 'talk' }, { closeup: 'bruciate', level: 'male' }] },
+                    { text: 'No, dopo.', next: 'start' },
+                ] },
+            },
+        },
         barondeduke: {
             nodes: {
                 start: { options: [
@@ -4365,6 +4456,19 @@ export const story = {
             },
         },
         // Da solo al campo del Circolo: Andrea decide quanto farsi male.
+        // Il flipper del River: Andrea da solo davanti alla tavola, sceglie il livello. [DA ANDREA: battute provvisorie]
+        flipper: {
+            nodes: {
+                start: {
+                    options: [
+                        { text: 'Una partita alla bona, tanto per sentire la molla.', next: 'end', then: [{ say: 'Sessantamila punti e sono contento.' }, { closeup: 'flipper', level: 'bona' }] },
+                        { text: 'Una partita seria.', next: 'end', then: [{ say: 'Centoventimila. Come quando ci lasciavo le cinquecento lire.' }, { closeup: 'flipper', level: 'seria' }] },
+                        { text: 'A fassi male.', next: 'end', then: [{ say: 'Duecentomila. Il record del River, o quasi.' }, { closeup: 'flipper', level: 'male' }] },
+                        { text: 'Un\'altra volta.', next: 'end' },
+                    ],
+                },
+            },
+        },
         basket: {
             nodes: {
                 start: {

src/version.js

@@ -1,5 +1,5 @@
 // La versione del gioco: la cambia scripts/bump.sh, insieme a package.json.
-export const VERSION = '0.1.63';
+export const VERSION = '0.1.73';
 
 // Immagini, musiche e voci con ?v=<versione>: a ogni versione l'indirizzo cambia e il browser le riscarica,
 // mentre fra una versione e l'altra le tiene in cache a lungo (nginx.conf).

style.css

@@ -20,10 +20,28 @@ html, body { margin: 0; height: 100%; background: var(--bg); color: var(--ink);
 button, input { font-family: var(--font); }
 body { line-height: 1.5; }
 body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-highlight-color: transparent; }
-#app { width: min(100vw, 1280px, calc((100dvh - 250px) * 16 / 9)); min-width: min(100vw, 320px); margin-block: auto; display: flex; flex-direction: column; padding: env(safe-area-inset-top) 0 env(safe-area-inset-bottom); }
+/* Il gioco è largo quanto può: tutta la finestra (fino a 2560px: a schermo intero su un monitor grande), oppure quanto ci sta in altezza con il pannello sotto la
+   scena 16:9. Il pannello (frase, poi verbi e inventario o le risposte di un dialogo) è alto --side-h unità --u, dove --u
+   è un centesimo della larghezza del gioco (1cqw) fra 8,75px e 25,6px: tutto il pannello cresce e cala col gioco, non con
+   la finestra, e la riserva in altezza è esatta (prima erano 250px fissi, un centinaio di troppo, che in una finestra
+   1040×590 costavano un terzo della scena). I due calc sono i due regimi di --u: proporzionale, e al minimo. */
+#app { --u: clamp(8.75px, 1cqw, 25.6px); --side-h: 13.3; container-type: inline-size;
+  width: min(100vw, 2560px, calc(100dvh / (9 / 16 + var(--side-h) / 100)), calc((100dvh - var(--side-h) * 8.75px) * 16 / 9));
+  min-width: min(100vw, 320px); margin-block: auto; display: flex; flex-direction: column; padding: env(safe-area-inset-top) 0 env(safe-area-inset-bottom); }
+
+/* Coi comandi di un minigioco aperti (main.js, fitControls) la scena lascia intorno il loro spazio vero, --below; ma non
+   scende sotto i 700px (nelle finestre basse si scorre un poco per arrivare ai comandi, come prima). */
+@media (min-width: 601px) and (min-height: 521px) {
+  #app.controls { width: min(100vw, 2560px, calc(100dvh / (9 / 16 + var(--side-h) / 100)), calc((100dvh - var(--side-h) * 8.75px) * 16 / 9),
+    max(calc((100dvh - var(--below, 0px)) * 16 / 9), 700px)); }
+  /* «Solo tavola» (Andrea): la pulsantiera del flipper nascosta, la tavola a tutta altezza. */
+  #app.controls.table-only { width: min(100vw, 2560px, calc((100dvh - var(--below, 88px)) * 16 / 9)); }
+  #app.table-only #side { display: none; }
+}
 
 #stage { position: relative; width: 100%; aspect-ratio: 16 / 9; background: #000; user-select: none; touch-action: manipulation; }
 #scene { width: 100%; height: 100%; display: block; image-rendering: pixelated; cursor: crosshair; }
+#scene.pinball-hd { image-rendering: auto; }
 #scene.torch { touch-action: none; }
 #scene.bocce { touch-action: none; }
 #scopa-controls, #tressette-controls { background: #242b28; padding: 10px 14px; border-top: 2px solid #897b57; font-size: 11px; line-height: 1.7; }
@@ -46,7 +64,7 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 #poker-controls summary, #briscola-controls summary { cursor: pointer; padding: 10px 0; }
 #poker-controls p, #briscola-controls p { max-width: 76em; }
 #bocce-controls { background: #242b28; padding: 10px 14px; border-top: 2px solid #897b57; font-size: 11px; }
-#bocce-status { color: #f3dcac; margin: 0 0 10px; line-height: 1.5; min-height: 1.5em; }
+#bocce-status { color: #f3dcac; margin: 0 0 10px; line-height: 1.5; min-height: 3em; } /* due righe: la scena non salta quando va a capo */
 .bocce-adjust { display: flex; align-items: center; justify-content: center; gap: 12px; }
 .bocce-adjust label { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; justify-content: space-between; min-width: 120px; max-width: 280px; flex: 1; }
 #bocce-power { width: 100%; accent-color: #b9d392; min-height: 32px; margin: 0; }
@@ -62,23 +80,24 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 /* La guida semplice del GP: il Gas si tiene premuto col pollice, più alto. */
 #bocce-throw.hold { min-height: 72px; font-size: 14px; }
 .bocce-adjust button:disabled { opacity: .4; cursor: default; }
-#bocce-help, #biliardo-help, #basket-help, #pesca-help, #gara-help, #rinquarto-help, #micro-help, #cerbottana-help, #condor-help, #campana-help { margin-top: 9px; color: #c5c6b6; font-size: 10px; }
-#bocce-help summary, #biliardo-help summary, #basket-help summary, #pesca-help summary, #gara-help summary, #rinquarto-help summary, #micro-help summary, #cerbottana-help, #condor-help summary, #campana-help summary { cursor: pointer; padding: 6px 0; }
-#bocce-help p, #biliardo-help p, #basket-help p, #pesca-help p, #gara-help p, #rinquarto-help p, #micro-help p, #cerbottana-help, #condor-help p, #campana-help p { max-width: 76em; line-height: 1.7; }
+#bocce-left, #bocce-right { touch-action: none; }
+#bocce-help, #biliardo-help, #basket-help, #pesca-help, #gara-help, #rinquarto-help, #micro-help, #cerbottana-help, #condor-help, #campana-help, #bruciate-help, #flipper-help { margin-top: 9px; color: #c5c6b6; font-size: 10px; }
+#bocce-help summary, #biliardo-help summary, #basket-help summary, #pesca-help summary, #gara-help summary, #rinquarto-help summary, #micro-help summary, #cerbottana-help, #condor-help summary, #campana-help summary, #bruciate-help summary, #flipper-help summary { cursor: pointer; padding: 6px 0; }
+#bocce-help p, #biliardo-help p, #basket-help p, #pesca-help p, #gara-help p, #rinquarto-help p, #micro-help p, #cerbottana-help, #condor-help p, #campana-help p, #bruciate-help p, #flipper-help p { max-width: 76em; line-height: 1.7; }
 @media (max-width: 600px), (orientation: landscape) and (max-height: 520px) {
   #bocce-controls { padding: 8px; font-size: 10px; overflow-y: auto; min-height: 0; }
   .bocce-adjust { flex-wrap: wrap; gap: 6px; }
   .bocce-adjust label { order: -1; flex-basis: 100%; max-width: none; }
   .bocce-adjust button { flex: 1; font-size: 9px; padding: 6px; }
   #bocce-throw { flex-basis: 100%; }
-  #bocce-help, #biliardo-help, #basket-help, #pesca-help, #gara-help, #rinquarto-help, #micro-help, #cerbottana-help, #condor-help, #campana-help { font-size: 9px; }
+  #bocce-help, #biliardo-help, #basket-help, #pesca-help, #gara-help, #rinquarto-help, #micro-help, #cerbottana-help, #condor-help, #campana-help, #bruciate-help, #flipper-help { font-size: 9px; }
 }
 .effects-control { display: flex; align-items: center; justify-content: center; flex-wrap: wrap; gap: 10px; margin-bottom: 12px; font-size: clamp(9px, 1.2vw, 13px); }
 #effects-volume { width: 130px; accent-color: var(--accent); }
 
 /* max-content: vicino al bordo destro il fumetto non si stringe a colonna (lo spazio dopo `left` non conta). */
 #speech { position: absolute; left: 0; top: 0; width: max-content; max-width: 46%; transform: translate(-50%, -100%); pointer-events: none;
-  font-size: clamp(10.08px, 1.66vw, 18.72px); font-weight: bold; line-height: 1.2; text-align: center;
+  font-size: calc(1.4625 * var(--u)); font-weight: bold; line-height: 1.2; text-align: center;
   text-shadow: 2px 0 #000, -2px 0 #000, 0 2px #000, 0 -2px #000, 2px 2px #000, -2px -2px #000; }
 #speech:empty { display: none; }
 #speech { z-index: 3; }
@@ -87,7 +106,7 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 #muro { position: absolute; left: 0; top: 0; width: 1067px; height: 600px; border: 0; z-index: 1; background: #f7e1c0;
   transform: scale(var(--muro-scale, 0.6)); transform-origin: 0 0; }
 /* Il primo piano del libro si chiude da qui (o con Esc). */
-#closeup-close { position: absolute; right: 10px; bottom: 10px; z-index: 2; font: bold clamp(10px, 1.5vw, 15px) var(--font);
+#closeup-close { position: absolute; right: 10px; bottom: 10px; z-index: 2; font: bold calc(1.17 * var(--u)) var(--font);
   padding: .45em 1.2em; border-radius: 6px; border: 0; cursor: pointer; color: var(--bg); background: var(--accent); }
 /* Al biliardo audio, pausa e uscita hanno spazio proprio: nessun comando copre biglie o punteggio. */
 #stage.biliardo { padding-top: 44px; aspect-ratio: auto; background: #17110c; }
@@ -102,24 +121,29 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
   background: rgba(27, 20, 32, .62); border-radius: 18px; }
 #mute { width: 30px; height: 30px; padding: 0; font: bold 12.96px var(--font); color: var(--accent); background: none; border: 0; cursor: pointer; }
 #mute[aria-pressed="true"] { color: var(--dim); text-decoration: line-through; }
-#volume, #voice-volume { width: clamp(50px, 9vw, 100px); accent-color: var(--accent); cursor: pointer; }
+#volume, #voice-volume { width: calc(7.8 * var(--u)); accent-color: var(--accent); cursor: pointer; }
 .sound-label { margin-left: 4px; font-size: 9px; color: var(--accent); }
+#fullscreen-hud { width: 30px; height: 30px; padding: 0; font: bold 17px system-ui, sans-serif; line-height: 1; color: var(--accent); background: none; border: 0; cursor: pointer; }
+#fullscreen-hud[aria-pressed="true"] { color: var(--blue); }
 
-#sentence { min-height: 1.8em; padding: .25em .6em; text-align: center; color: var(--blue); font-size: clamp(10.8px, 1.44vw, 15.84px); font-weight: bold; background: var(--panel); }
+/* La frase: una riga sola, alta sempre uguale (2,5 --u); una frase lunghissima finisce coi puntini invece di spostare la scena. */
+#sentence { height: calc(2.5 * var(--u)); line-height: 1.5; padding: .25em .6em; text-align: center; color: var(--blue); font-size: calc(1.2375 * var(--u)); font-weight: bold; background: var(--panel);
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 
-#panel { display: grid; grid-template-columns: minmax(0, 1.1fr) minmax(0, 1fr); gap: 8px; padding: 8px; background: var(--panel); }
+/* Verbi e inventario: alti sempre uguale (10,8 --u, dove stanno anche quattro risposte di dialogo: vedi #choices). */
+#panel { display: grid; grid-template-columns: minmax(0, 1.1fr) minmax(0, 1fr); gap: calc(.625 * var(--u)); padding: calc(.625 * var(--u)); height: calc(10.8 * var(--u)); background: var(--panel); }
 /* Otto verbi su due righe piene, quattro per riga. */
-#verbs { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 4px; align-content: start; }
+#verbs { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: calc(.3125 * var(--u)); align-content: stretch; }
 #verbs button, #inventory button { font: inherit; color: var(--dim); background: #3a2d42; border: 2px solid #4b3a55; border-radius: 4px;
-  padding: .35em .2em; font-size: clamp(9.36px, 1.22vw, 13.68px); font-weight: bold; cursor: pointer; }
+  padding: .35em .2em; font-size: calc(1.069 * var(--u)); font-weight: bold; cursor: pointer; }
 #verbs button:hover, #inventory button:hover { color: var(--ink); }
 #verbs button[aria-pressed="true"] { color: var(--bg); background: var(--accent); border-color: var(--accent); }
-#inventory { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); grid-auto-rows: minmax(2.4em, auto); gap: 4px; align-content: start;
-  min-height: 5.4em; padding: 4px; background: #231a29; border: 2px solid #4b3a55; border-radius: 4px;
+#inventory { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); grid-auto-rows: minmax(2.4em, auto); gap: calc(.3125 * var(--u)); align-content: start;
+  min-height: 0; padding: calc(.3125 * var(--u)); background: #231a29; border: 2px solid #4b3a55; border-radius: 4px;
   /* L'inventario non allunga mai il pannello: è alto quanto i verbi, e se gli oggetti sono tanti si scorre. */
   contain: size; overflow-y: auto; overscroll-behavior: contain; scrollbar-width: thin; scrollbar-color: #6a557a transparent; }
 #inventory:empty::before { content: 'Inventario'; grid-column: 1 / -1; align-self: center; text-align: center; color: var(--dim); opacity: .45;
-  font-size: clamp(9.36px, 1.22vw, 13.68px); font-weight: bold; letter-spacing: .08em; }
+  font-size: calc(1.069 * var(--u)); font-weight: bold; letter-spacing: .08em; }
 #inventory button { display: flex; align-items: center; gap: .35em; justify-content: center; color: var(--ink); }
 #inventory button { min-width: 0; overflow: hidden; }
 #inventory button span.long { min-width: 0; font-size: .72em; line-height: 1.15; text-align: left; }
@@ -128,8 +152,14 @@ body { display: flex; justify-content: center; overflow-x: hidden; -webkit-tap-h
 #inventory img { width: 1.9em; height: 1.9em; flex: none; image-rendering: pixelated; }
 
 /* Il carattere sta sull'elenco, non sulle righe: il rientro in em segue il carattere. «1. » nel carattere pixel è largo tre caratteri e mezzo. */
-#choices { margin: 0; padding: 10px 14px 12px 3.6em; background: var(--panel); min-height: 6.5em; font-size: clamp(10.8px, 1.44vw, 15.84px); }
-#choices li { padding: .25em 0; font-weight: bold; color: var(--dim); cursor: pointer; }
+/* Le risposte: alte quanto il pannello dei verbi, così la scena non si muove quando parte un dialogo. Quattro risposte ci
+   stanno al carattere pieno; da cinque in su il carattere cala (e se mai non bastasse, si scorre). */
+#choices { margin: 0; padding: calc(.78 * var(--u)) calc(1.1 * var(--u)) calc(.94 * var(--u)) 3.6em; background: var(--panel); height: calc(10.8 * var(--u));
+  overflow-y: auto; scrollbar-width: thin; font-size: calc(1.2375 * var(--u)); line-height: 1.4; }
+#choices li { padding: .2em 0; font-weight: bold; color: var(--dim); cursor: pointer; }
+#choices:has(li:nth-child(5)) { font-size: calc(.96 * var(--u)); line-height: 1.25; }
+#choices:has(li:nth-child(5)) li { padding: .15em 0; }
+#choices:has(li:nth-child(7)) { font-size: calc(.72 * var(--u)); }
 #choices li:hover, #choices li:focus { color: var(--accent); outline: none; }
 
 .overlay { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: .6em;
@@ -221,10 +251,11 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
 /* Mappa: la pianta del paese a gradini, i posti visti come cartellini, le strade come linee. */
 /* In alto a sinistra: Pausa e Mappa. */
 #corner { position: absolute; top: 6px; left: 6px; z-index: 2; display: flex; gap: 6px; }
-#map-button, #pause-button, #notebook-button, #spots-button, #back-button { font: bold clamp(8.64px, 1.15vw, 11.52px) var(--font); padding: .35em .8em;
+#map-button, #pause-button, #notebook-button, #spots-button, #back-button, #table-only { font: bold calc(.9 * var(--u)) var(--font); padding: .35em .8em;
   color: var(--accent); background: rgba(27, 20, 32, .62); border: 0; border-radius: 18px; cursor: pointer; }
 #back-button { color: #1b1420; background: #9fd0ff; }
-#pause { z-index: 3; background: rgba(15, 10, 20, .9); }
+/* Con molti pulsanti la Pausa può essere più alta della scena: «safe» la fa partire dall'alto e scorrere, invece di tagliare il titolo. */
+#pause { z-index: 3; background: rgba(15, 10, 20, .9); justify-content: safe center; }
 /* Il player dei video «Come si gioca»: sopra a tutto, il video grande quanto può. */
 #tutorial { position: fixed; inset: 0; z-index: 20; background: rgba(10, 8, 14, .97); padding: 8px; }
 #tutorial video { max-width: min(100%, 1100px); max-height: calc(100dvh - 9em); background: #000; }
@@ -321,6 +352,9 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
   #pause { position: fixed; inset: 0; z-index: 10; overflow-y: auto; background: rgba(15, 10, 20, .97); } }
 /* Schermi stretti: il carattere a pixel è largo, i verbi vanno sopra l'inventario e su due righe da quattro. */
 @media (max-width: 600px) {
+  #sentence { height: auto; min-height: 1.8em; white-space: normal; }
+  #panel, #choices { height: auto; }
+  #choices { min-height: 6.5em; }
   #panel { grid-template-columns: 1fr; gap: 6px; padding: 6px; }
   #verbs button { font-size: 9px; padding: .7em .1em; }
   #inventory { height: 7.6em; }
@@ -333,13 +367,20 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
   #stage.biliardo { width: min(calc((100dvh - 90px) * 16 / 9), 68vw); }
   #app.presenta { justify-content: center; }
   #app.presenta #stage.biliardo { width: min(calc((100dvh - 44px) * 16 / 9), 100vw); }
+  /* Il flipper sul telefono (Andrea, 1 novembre): pollice sinistro sulla metà sinistra della scena, destro sulla destra,
+     al centro la molla. La scena prende tutta la larghezza e la pulsantiera sparisce: punti e palline sono sulla tavola. */
+  #app.flipper { justify-content: center; }
+  #app.flipper #side, #app.flipper #table-only { display: none; }
+  #app.flipper #stage.biliardo { width: min(calc((100dvh - 44px) * 16 / 9), 100vw); }
+  #app.flipper #stage.biliardo #closeup-close { position: absolute; top: 6px; bottom: auto; left: 86px; right: auto; margin: 0; min-height: 0; height: 30px; padding: 0 .9em; font-size: 10px; }
   #stage.briscola { width: min(calc((100dvh - 90px) * 16 / 9), 68vw); }
   #briscola-controls, #tressette-controls, #scopa-controls, #poker-controls { overflow-y: auto; min-height: 0; padding: 8px; font-size: 9px; }
   /* Nella colonna stretta accanto al tavolo: carte e segni su due colonne, parole che vanno a capo. */
   .card-hand-many button, .card-buttons button { flex-basis: 40%; overflow-wrap: anywhere; }
   .card-hand { flex-direction: column; gap: 4px; }
   #side { flex: 1; min-width: 0; display: flex; flex-direction: column; background: var(--panel); }
-  #sentence { font-size: 10.08px; }
+  #sentence { height: auto; min-height: 1.8em; white-space: normal; font-size: 10.08px; }
+  #panel, #choices { height: auto; }
   /* Il fumetto: più largo e più piccolo, sennò una battuta lunga diventa una colonna alta quanto la scena. */
   #speech { max-width: 72%; font-size: 11px; }
   #panel { grid-template-columns: 1fr; grid-template-rows: auto minmax(0, 1fr); flex: 1; min-height: 0; gap: 6px; padding: 6px; }
@@ -356,6 +397,7 @@ body.full #sound { position: fixed; z-index: 13; top: max(8px, env(safe-area-ins
   .buttons { gap: 6px; margin-top: .2em; }
   .buttons button { font-size: 10px; padding: .45em 1em; }
   .pause-buttons { min-width: 12em; }
+  #pause .hint { display: none; }
   /* Mappa: schede più piccole, ne stanno cinque o sei per riga. */
   #map-board button { width: 68px; }
   #map-board button img { width: 60px; }

tests/ambient.browser.mjs

@@ -3,6 +3,7 @@
 // npm run browser:effects — immagini in /tmp/regolo-effects (oppure $OUT).
 import { chromium } from 'playwright';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import assert from 'node:assert/strict';
 
@@ -11,7 +12,7 @@ mkdirSync(out, { recursive: true });
 const server = await staticServer(), port = server.port;
 let browser;
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     const page = await browser.newPage({ viewport: { width: 640, height: 360 } });
     const errors = [];
     page.on('pageerror', e => errors.push(e.message));

tests/biliardo.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-biliardo';
 mkdirSync(out, { recursive: true });
@@ -64,7 +65,7 @@ async function checkArtwork(page, name) {
 }
 
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     for (const [name, mobile, viewport] of [
         ['desktop', false, { width: 1280, height: 860 }],
         ['touch', true, { width: 844, height: 390 }],

tests/briscola.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = '/tmp/regolo-shots'; mkdirSync(out, { recursive: true });
 const server = await staticServer(), errors = [];
@@ -51,7 +52,7 @@ async function artwork(page) {
     for (const [name, png] of Object.entries(pictures)) writeFileSync(`${out}/briscola-${name}.png`, Buffer.from(png, 'base64'));
 }
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     const scenarios = ['mouse', 'touch', 'keyboard'].flatMap(mode => [
         { name: `desktop-${mode}`, mode, viewport: { width: 1280, height: 860 } },
         { name: `telefono-${mode}`, mode, viewport: { width: 390, height: 844 } },

tests/browser.mjs

@@ -1,8 +1,11 @@
 // Prova nel browser vero (Chromium headless con swiftshader): titolo, partita giocata con clic veri
 // fino alla fine, salvataggio e impaginazione su telefono. Schermate in $OUT (predefinito: /tmp/regolo-shots).
-// npm run browser
+// npm run browser: le tre parti (--parte=principale, minigiochi, telefoni) girano insieme come processi separati, ognuna
+// col suo server e il suo Chromium; la prova passa quasi tutto il tempo ad aspettare animazioni in tempo reale, e così le
+// attese si sovrappongono. Una parte sola: node tests/browser.mjs --parte=minigiochi (--media-only: solo multimedia).
 import { chromium } from 'playwright';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 import { mkdirSync, readFileSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { solution, route } from '../src/story/solution.js';
@@ -12,14 +15,31 @@ import { checkMultimedia } from './multimedia.browser.mjs';
 
 const OUT = process.env.OUT ?? '/tmp/regolo-shots';
 mkdirSync(OUT, { recursive: true });
+const PARTI = ['principale', 'minigiochi', 'telefoni'];
+const PARTE = process.argv.find(a => a.startsWith('--parte='))?.slice('--parte='.length);
+if (PARTE && !PARTI.includes(PARTE)) { console.error(`parte sconosciuta: ${PARTE} (${PARTI.join(', ')})`); process.exit(2); }
+if (!PARTE && !process.argv.includes('--media-only')) {
+    const { spawn } = await import('node:child_process');
+    const t0 = Date.now();
+    const esiti = await Promise.all(PARTI.map(parte => new Promise(resolve => {
+        const p = spawn(process.execPath, [process.argv[1], `--parte=${parte}`], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let resto = '';
+        const riga = chunk => { const righe = (resto + chunk).split('\n'); resto = righe.pop(); for (const r of righe) console.log(`[${parte}] ${r}`); };
+        p.stdout.on('data', riga); p.stderr.on('data', riga);
+        p.on('close', code => { if (resto) console.log(`[${parte}] ${resto}`); resolve({ parte, code, s: Math.round((Date.now() - t0) / 1000) }); });
+    })));
+    for (const e of esiti) console.log(`${e.code === 0 ? 'OK  ' : 'FAIL'} ${e.parte} (${e.s} s)`);
+    process.exit(esiti.every(e => e.code === 0) ? 0 : 1);
+}
 const server = await staticServer(), PORT = server.port;
-const browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+const browser = await chromium.launch({ args: ARGS });
 const errors = [];
 
 async function open(viewport, query = '') {
     const page = await browser.newPage({ viewport, acceptDownloads: true });
     page.on('pageerror', e => errors.push(e.message));
-    page.on('console', m => m.type() === 'error' && errors.push(m.text()));
+    // ERR_NETWORK_CHANGED è il PC che cambia rete a metà prova (Docker che crea o toglie una rete): non è il gioco.
+    page.on('console', m => m.type() === 'error' && !m.text().includes('ERR_NETWORK_CHANGED') && errors.push(m.text()));
     for (let i = 0; i < 50; i++) {
         try { await page.goto(`http://127.0.0.1:${PORT}/${query}`); break; } catch { await page.waitForTimeout(100); }
     }
@@ -49,332 +69,8 @@ const hotspotCenter = async (page, id) => {
     return c;
 };
 
-try {
-    await checkMultimedia(browser, PORT, OUT, errors);
-    if (!process.argv.includes('--media-only')) {
-    const page = await open({ width: 1280, height: 860 });
-    // Il cartello d'apertura, poi da solo il titolo.
-    assert.match(await page.textContent('#splash'), /Manzolo\s*\(Poca\)\s*Art\s*Presents/);
-    assert.ok(await page.isHidden('#title'), 'il titolo aspetta la fine del cartello');
-    // Il gioco parte con un import() dinamico, che l'evento load della pagina non aspetta.
-    await page.waitForFunction(() => window.jingle, null, { timeout: 10000 });
-    assert.match(await page.evaluate(() => jingle.src), /assets\/audio\/cartello\.mp3\?v=\d+\.\d+\.\d+$/, 'la musichetta del cartello');
-    assert.equal(await page.evaluate(() => music.want), null, 'la musica del titolo aspetta il titolo');
-    await page.waitForTimeout(2800);
-    await page.screenshot({ path: `${OUT}/00-cartello.png` });
-    // Il titolo arriva sotto il cartello mentre sfuma: in nessun momento si vede la scena nuda.
-    await page.waitForSelector('#title:not([hidden])', { timeout: 8000 });
-    assert.ok(await page.isVisible('#splash'), 'il titolo compare quando il cartello è ancora sopra');
-    await page.waitForTimeout(350);
-    await page.screenshot({ path: `${OUT}/00b-dissolvenza.png` });
-    await page.waitForSelector('#splash', { state: 'hidden', timeout: 3000 });
-    // Senza un gesto il browser può bloccare la musichetta (succede online su un sito mai visto, non in locale): allora
-    // il cartello aspetta un tocco, con l'invito a toccare, e solo dopo parte coi suoi tempi.
-    {
-        const muto = await chromium.launch(), p = await muto.newPage();
-        await p.goto(`http://127.0.0.1:${PORT}/`);
-        await p.waitForTimeout(800);
-        if (await p.evaluate(() => document.getElementById('splash').classList.contains('wait'))) {
-            assert.ok(await p.isVisible('#splash .splash-hint'), 'l\'invito a toccare');
-            await p.waitForTimeout(5500);
-            assert.ok(await p.isHidden('#title'), 'il cartello aspetta il tocco');
-            await p.click('#splash');
-            assert.ok(await p.isHidden('#splash .splash-hint'));
-            await p.waitForSelector('#title:not([hidden])', { timeout: 8000 });
-            console.log('Cartello senza suono permesso: aspetta il tocco, poi parte.');
-        } else console.log('(questo Chromium lascia suonare senza gesto: il caso bloccato non si prova qui)');
-        await muto.close();
-    }
-    await page.screenshot({ path: `${OUT}/01-titolo.png` });
-    assert.match(await page.textContent('#title .version'), /^v\d+\.\d+\.\d+$/, 'la versione nell\'angolo del titolo');
-    // Col codice lento ad arrivare (rete vera) il cartello aspetta il titolo: non sfuma prima per conto suo.
-    {
-        const slow = await browser.newPage({ viewport: { width: 1280, height: 860 } });
-        // Misura al momento dell'apparizione: il polling di Playwright può arrivare dopo
-        // diversi fotogrammi su una macchina occupata, quando la dissolvenza è già in corso.
-        await slow.addInitScript(() => {
-            const observer = new MutationObserver(() => {
-                const title = document.getElementById('title'), splash = document.getElementById('splash');
-                if (title && !title.hidden && splash) {
-                    window.titleRevealOpacity = Number(getComputedStyle(splash).opacity);
-                    observer.disconnect();
-                }
-            });
-            observer.observe(document, { subtree: true, childList: true, attributes: true, attributeFilter: ['hidden'] });
-        });
-        await slow.route('**/src/main.js', async route => { await new Promise(r => setTimeout(r, 2000)); await route.continue(); });
-        await slow.goto(`http://127.0.0.1:${PORT}/`);
-        await slow.waitForSelector('#splash');
-        await slow.waitForTimeout(300);
-        if (await slow.evaluate(() => document.getElementById('splash').classList.contains('wait'))) await slow.click('#splash');
-        await slow.waitForSelector('#title:not([hidden])', { timeout: 12000 });
-        const opacity = await slow.evaluate(() => window.titleRevealOpacity);
-        assert.ok(opacity > 0.9, `il cartello era già sfumato (${opacity}) quando è comparso il titolo`);
-        await slow.close();
-    }
-    // I crediti dal titolo: si aprono, mostrano i nomi, Esc li chiude.
-    await page.click('#title .open-credits');
-    assert.match(await page.textContent('#credits'), /Ringraziamenti\s*Al Lele/, 'la dedica al Lele viene per prima');
-    assert.match(await page.textContent('#credits'), /Baldoria \(Yuri Baldi\)/);
-    assert.match(await page.textContent('#credits'), /Francesco Bacci/);
-    // I nomi col ritratto: si tocca il nome, compare il volto; un altro tocco lo chiude.
-    await page.click('#credits .credit-face >> text=Mariano');
-    assert.ok(await page.isVisible('#face img'));
-    await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
-    await page.screenshot({ path: `${OUT}/01d-ritratto.png` });
-    await page.click('#face');
-    assert.ok(await page.isHidden('#face'));
-    // Il carosello: tutte le immagini (due giri), scorre da solo, si ferma sotto il mouse, le frecce lo spingono di una
-    // foto, un tocco su una foto la mostra grande col nome del posto.
-    {
-        const track = page.locator('#credits-reel .track');
-        assert.equal(await track.locator('img').count(), reelPictures(story).length * 2, 'ogni sfondo e ogni ritratto, due giri');
-        await page.mouse.move(5, 5);
-        const x0 = await track.evaluate(t => t.scrollLeft);
-        await page.waitForTimeout(600);
-        const x1 = await track.evaluate(t => t.scrollLeft);
-        assert.ok(x1 > x0, `il carosello scorre da solo (${x0} → ${x1})`);
-        await track.hover({ position: { x: 20, y: 20 } });
-        const x2 = await track.evaluate(t => t.scrollLeft);
-        await page.waitForTimeout(500);
-        assert.equal(await track.evaluate(t => t.scrollLeft), x2, 'sotto il mouse si ferma');
-        await page.click('#credits-reel .arrow.next');
-        await page.waitForTimeout(800);
-        const x3 = await track.evaluate(t => t.scrollLeft);
-        assert.ok(x3 - x2 > 150, `la freccia spinge di una foto (${x2} → ${x3})`);
-        const third = track.locator('img').nth(2);
-        const name = await third.getAttribute('alt');
-        await third.click();
-        assert.ok(await page.isVisible('#face img.scene'), 'la foto si vede grande');
-        assert.equal(await page.textContent('#face figcaption'), name);
-        await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
-        await page.screenshot({ path: `${OUT}/01e-carosello-zoom.png` });
-        await page.keyboard.press('Escape');
-        assert.ok(await page.isHidden('#face'), 'Esc chiude la foto grande, non i crediti');
-        assert.ok(await page.isVisible('#credits'));
-    }
-    const onTop = await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
-        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; });
-    assert.ok(onTop, 'i crediti stanno sopra il titolo, non dietro');
-    await page.screenshot({ path: `${OUT}/01c-crediti.png` });
-    // L'elenco può scorrere; la dedica e il pulsante Chiudi devono restare dentro lo schermo.
-    const fitsCredits = await page.evaluate(() => { const c = document.getElementById('credits').getBoundingClientRect(), b = document.getElementById('close-credits').getBoundingClientRect(); return b.bottom <= c.bottom && b.top >= c.top; });
-    assert.ok(fitsCredits, 'il pulsante Chiudi dei crediti è in vista');
-    await page.keyboard.press('Escape');
-    assert.ok(await page.isHidden('#credits'), 'Esc chiude i crediti');
-    await page.click('#new-game');
-    // Il rione: quattro scelte; la Pieve cambia la riga dell'introduzione e resta nella partita.
-    await page.waitForSelector('#rione:not([hidden])');
-    assert.equal(await page.locator('#rione-buttons button').count(), 4);
-    await page.screenshot({ path: `${OUT}/01a-rione.png` });
-    assert.equal(await page.locator('#rione-buttons button:disabled').count(), 3, 'per ora gli altri tre rioni sono chiusi');
-    await page.click('#rione [data-rione="campomigliaio"]');
-    // L'introduzione: una riga per clic, poi comincia la partita.
-    await page.waitForSelector('#intro:not([hidden])');
-    for (let i = 0; i < 2; i++) await page.click('#intro', { position: { x: 40, y: 40 } });
-    assert.match(await page.textContent('#intro-text'), /Campomigliaio, i blu/, 'la riga del rione scelto');
-    await page.screenshot({ path: `${OUT}/01b-intro.png` });
-    for (let i = 0; i < 10 && await page.isVisible('#intro'); i++) await page.click('#intro', { position: { x: 40, y: 40 } });
-    assert.ok(await page.isHidden('#intro'), 'l\'introduzione non finisce');
-    await page.waitForFunction(() => game.speech);
-    // La prima battuta ha la sua voce, e sotto la voce la musica si abbassa.
-    await page.waitForFunction(() => voices.playing, null, { timeout: 5000 });
-    assert.match(await page.evaluate(() => voices.audio.src), /assets\/voices\/andrea-[0-9a-f]+\.mp3\?v=\d+\.\d+\.\d+$/);
-    await page.waitForFunction(() => music.duck === 0.45, null, { timeout: 2000 });
-    await page.screenshot({ path: `${OUT}/02-inizio.png` });
-    assert.ok(await page.evaluate(() => game.state.flags['rione:campomigliaio']), 'il rione resta nella partita');
-    const fits = async p => p.evaluate(() => document.querySelector('#panel').getBoundingClientRect().bottom <= innerHeight);
-    assert.ok(await fits(page), 'verbi e inventario fuori dallo schermo');
-    await settle(page);
-
-    // Doppio clic su un punto della scena: Andrea ci va di corsa.
-    const r = await page.locator('#scene').boundingBox();
-    await page.mouse.dblclick(r.x + 300 / 640 * r.width, r.y + 330 / 360 * r.height);
-    assert.ok(await page.evaluate(() => game.hurry), 'il doppio clic fa correre');
-    await settle(page);
-    // «?» mostra per qualche secondo cosa si può toccare.
-    await page.click('#spots-button');
-    await page.screenshot({ path: `${OUT}/02c-punti.png` });
-    // Inventario pieno (16 oggetti di prova): resta alto quanto i verbi, dentro lo schermo, si scorre e mostra l'ultimo preso.
-    await page.evaluate(() => {
-        const items = game.story.items, kinds = ['chiave_oratorio', 'libro', 'squama'];
-        for (let i = 1; i <= 16; i++) { items['prova' + i] = { name: 'prova ' + i, icon: items[kinds[i % 3]].icon }; game.state.inventory.push('prova' + i); }
-    });
-    await page.waitForTimeout(150);
-    const inv = await page.evaluate(() => { const e = document.getElementById('inventory'), r = e.getBoundingClientRect(), last = e.lastElementChild.getBoundingClientRect();
-        return { inside: r.bottom <= innerHeight, scrolls: e.scrollHeight > e.clientHeight, lastVisible: last.bottom <= r.bottom + 1 && last.top >= r.top - 1 }; });
-    assert.deepEqual(inv, { inside: true, scrolls: true, lastVisible: true }, 'inventario pieno');
-    await page.screenshot({ path: `${OUT}/02d-inventario-pieno.png` });
-    await page.evaluate(() => { game.state.inventory = game.state.inventory.filter(i => !i.startsWith('prova')); for (let i = 1; i <= 16; i++) delete game.story.items['prova' + i]; });
-    // Pausa: Esc o il pulsante fermano il gioco; Riprendi torna dov'eri; il titolo offre «Continua».
-    await page.keyboard.press('Escape');
-    await page.waitForSelector('#pause:not([hidden])');
-    await page.screenshot({ path: `${OUT}/02b-pausa.png` });
-    // Salva su file: si scarica la partita; dal titolo «Carica» la riapre anche senza il salvataggio del browser.
-    const [download] = await Promise.all([page.waitForEvent('download'), page.click('#save-file')]);
-    assert.match(download.suggestedFilename(), /^regolo-\d{4}-\d\d-\d\d-\d{4}\.json$/);
-    const savedFile = `${OUT}/partita.json`;
-    await download.saveAs(savedFile);
-    const before = await page.evaluate(() => game.snapshot());
-    await page.click('#to-title');
-    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
-    await page.setInputFiles('#load-file', { name: 'altro.json', mimeType: 'application/json', buffer: Buffer.from('{"ciao":1}') });
-    await page.waitForSelector('#load-error:not([hidden])');
-    assert.ok(await page.isVisible('#title'), 'un file sbagliato lascia il titolo dov\'è');
-    // Una scena che non esiste: rifiutato, e il salvataggio del browser resta com'era.
-    await page.evaluate(() => localStorage.setItem('leggenda-regolo-save', '{"scene":"piazza","resta":true}'));
-    const lost = JSON.parse(readFileSync(savedFile, 'utf8'));
-    lost.state.scene = 'luna';
-    await page.setInputFiles('#load-file', { name: 'luna.json', mimeType: 'application/json', buffer: Buffer.from(JSON.stringify(lost)) });
-    await page.waitForFunction(() => /non torna/.test(document.getElementById('load-error').textContent));
-    assert.ok(await page.isVisible('#title'));
-    assert.equal(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')).resta), true, 'il salvataggio del browser non è toccato');
-    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
-    await page.setInputFiles('#load-file', savedFile);
-    await page.waitForSelector('#title', { state: 'hidden' });
-    assert.deepEqual(await page.evaluate(() => game.snapshot()), before, 'la partita caricata è quella salvata');
-    assert.ok(await page.evaluate(() => !!localStorage.getItem('leggenda-regolo-save')), 'e diventa quella di «Continua»');
-    await page.keyboard.press('Escape');
-    await page.waitForSelector('#pause:not([hidden])');
-    await page.click('#resume');
-    assert.ok(await page.isHidden('#pause'));
-    await page.click('#pause-button');
-    await page.click('#to-title');
-    await page.waitForSelector('#continue:not([hidden])');
-    await page.click('#continue');
-    await settle(page);
-    // Musica: dopo il primo clic suona il brano del paese; muto e volume si ricordano.
-    // Il brano cambia al fotogramma dopo «Continua»: si aspetta quello, senza indovinare i tempi.
-    const playing = await page.waitForFunction(() => music.current?.src.endsWith('paese.mp3'), null, { timeout: 3000 }).then(() => true, () => false);
-    assert.ok(playing, 'musica del paese: ' + await page.evaluate(() => music.current?.src));
-    await page.click('#mute');
-    await page.locator('#volume').fill('30');
-    await page.locator('#voice-volume').fill('70');
-    assert.deepEqual(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-audio'))), { volume: 0.3, muted: false, voices: 0.7, effects: 0.45 });
-    assert.equal(await page.evaluate(() => voices.volume), 0.7);
-    // Sul telefono si passa a un'altra app: la pagina diventa nascosta, la musica si ferma subito e la partita va in
-    // pausa; tornando la musica riparte solo con Riprendi (la pausa la tiene ferma).
-    const hide = hidden => page.evaluate(h => { Object.defineProperty(document, 'hidden', { value: h, configurable: true }); document.dispatchEvent(new Event('visibilitychange')); }, hidden);
-    await hide(true);
-    assert.equal(await page.evaluate(() => ambience.nodes.size), 0, 'nascosta la pagina, gli effetti si fermano subito');
-    assert.ok(await page.evaluate(() => music.current.audio.paused), 'nascosta la pagina, la musica è ferma');
-    assert.ok(await page.isVisible('#pause'), 'e la partita è in pausa');
-    await hide(false);
-    await page.click('#resume');
-    await page.waitForFunction(() => !music.current.audio.paused, null, { timeout: 5000 });
-
-    for (const [verb, target, item] of solution) {
-        if (verb === 'choose') {
-            await page.locator('#choices li', { hasText: target }).click();
-        } else {
-            const smart = await page.evaluate(([v, t]) => game.defaultVerb(t) === v, [verb, target]);
-            if (item) {
-                await page.click(`#verbs [data-verb="${verb}"]`);
-                await page.click(`#inventory [data-item="${item}"]`);
-            } else if (!smart) await page.click(`#verbs [data-verb="${verb}"]`);
-            // Un oggetto dell'inventario su un altro (cedrata col ghiacciolo) si clicca nell'inventario, non nella scena.
-            if (await page.evaluate(t => !!game.story.items[t], target)) await page.click(`#inventory [data-item="${target}"]`);
-            else await clickScene(page, await hotspotCenter(page, target));
-        }
-        await page.waitForTimeout(80);
-        if (verb === 'talk') await page.screenshot({ path: `${OUT}/03-dialogo.png` });
-        // La torcia nella fessura: il palio illuminato e i due occhi gialli, prima che spariscano.
-        if (target === 'fessura' && item) {
-            await page.waitForFunction(() => game.closeup?.id === 'fessura', null, { timeout: 30000 });
-            for (let i = 0; i < 3; i++) {
-                const at = await page.evaluate(i => game.story.closeups.fessura.targets[i].at, i);
-                const box = await page.locator('#scene').boundingBox();
-                await page.mouse.move(box.x + at[0] / 640 * box.width, box.y + at[1] / 360 * box.height);
-                await page.waitForFunction(() => game.closeup?.step === 'reveal');
-                await page.screenshot({ path: `${OUT}/05b-fessura-${i}.png` });
-                for (let n = 0; n < 200; n++) {
-                    if (await page.evaluate(i => game.closeup.found > i, i)) break;
-                    if (await page.evaluate(() => !!game.speech)) await page.keyboard.press('Space');
-                    await page.waitForTimeout(30);
-                }
-                assert.equal(await page.evaluate(() => game.closeup.found), i + 1);
-            }
-            await page.click('#closeup-close');
-        }
-        await settle(page);
-        if (target === 'cosa_luccicante') await page.screenshot({ path: `${OUT}/04-squama.png` });
-        if (target === 'su_fortezza') await page.screenshot({ path: `${OUT}/05-fortezza.png` });
-    }
-    await page.waitForSelector('#ending:not([hidden])');
-    await page.screenshot({ path: `${OUT}/06-fine.png` });
-    await page.click('#ending .open-credits');
-    assert.ok(await page.isVisible('#credits'), 'crediti anche dalla fine');
-    assert.ok(await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
-        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; }), 'i crediti stanno sopra la fine');
-    await page.click('#close-credits');
-    assert.ok(await page.isHidden('#credits'));
-    const saved = await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')));
-    assert.ok(saved.ended && saved.inventory.includes('squama'), 'salvataggio finale');
-
-    // Una partita a metà riprende da dove era rimasta.
-    await page.click('#restart');
-    await settle(page);
-    for (const [, exit] of route('piazza', 'trebbio')) {
-        await clickScene(page, await hotspotCenter(page, exit));
-        await settle(page);
-    }
-    await page.click('#verbs [data-verb="talk"]');
-    await clickScene(page, await hotspotCenter(page, 'torre'));
-    await page.locator('#choices li', { hasText: 'bloccato' }).click();
-    await page.waitForFunction(() => game.speech?.who === 'castello');
-    await page.waitForTimeout(100);
-    await page.screenshot({ path: `${OUT}/07-trebbio.png` });
-    await settle(page);
-    await page.locator('#choices li', { hasText: 'pace' }).click();
-    await settle(page);
-    await page.reload();
-    await page.waitForSelector('#continue:not([hidden])');
-    await page.click('#continue');
-    assert.equal(await page.evaluate(() => game.state.scene), 'trebbio');
-    await settle(page);
-    // Il taccuino (N): la tappa di adesso in evidenza, Esc lo chiude.
-    await page.keyboard.press('n');
-    assert.ok(await page.isVisible('#notebook'));
-    assert.ok((await page.textContent('#notebook-list li.now')).length > 10, 'c\'è l\'obiettivo di adesso');
-    await page.screenshot({ path: `${OUT}/07a-taccuino.png` });
-    await page.keyboard.press('Escape');
-    assert.ok(await page.isHidden('#notebook'));
-    // La mappa: dal Trebbio alla Piazza con due clic; i posti mai visti (la Pieve) non ci sono.
-    await page.click('#map-button');
-    assert.equal(await page.locator('#map-board button[data-scene="pieve"]').count(), 0, 'la Pieve non è ancora vista');
-    assert.ok(await page.isVisible('#map-board button.here[data-scene="trebbio"]'));
-    await page.screenshot({ path: `${OUT}/07b-mappa.png` });
-    // La ricerca: scrivendo restano solo i posti giusti; una «p» nella casella non chiude la mappa; Invio ci va.
-    await page.fill('#map-search', 'xyz');
-    assert.ok(await page.isVisible('#map-none'), 'nessun posto: lo dice');
-    await page.fill('#map-search', '');
-    await page.click('#map-search');
-    await page.keyboard.type('piazza col'); // «piaz» da solo trova anche la Piazzetta Cambray Digny
-    assert.ok(await page.isVisible('#map'), 'scrivere «p» nella ricerca non chiude la mappa');
-    assert.ok(await page.isHidden('#map-none'));
-    const shown = await page.locator('#map-board button:visible').evaluateAll(bs => bs.map(b => b.dataset.scene));
-    assert.deepEqual(shown, ['piazza']);
-    await page.screenshot({ path: `${OUT}/07c-mappa-ricerca.png` });
-    await page.keyboard.press('Enter');
-    assert.ok(await page.isHidden('#map'));
-    assert.equal(await page.evaluate(() => game.state.scene), 'piazza');
-    // Con tutti i posti visti e la finestra piccola la mappa si scorre: filtrando da in fondo, i posti trovati si vedono
-    // (prima la mappa restava lunga quanto quella intera, scorsa su un fondo vuoto).
-    await page.setViewportSize({ width: 560, height: 340 });
-    await page.evaluate(() => { for (const id of Object.keys(game.story.scenes)) game.state.flags['visto:' + id] = true; });
-    await page.click('#map-button');
-    assert.ok(await page.evaluate(() => { const s = document.getElementById('map-scroll'); s.scrollTop = s.scrollHeight; return s.scrollTop > 0; }), 'la mappa piena si scorre');
-    await page.fill('#map-search', 'campo');
-    const found = await page.evaluate(() => {
-        const s = document.getElementById('map-scroll'), r = s.getBoundingClientRect();
-        const c = [...document.querySelectorAll('#map-board button')].find(b => !b.hidden && !b.parentElement.hidden).getBoundingClientRect();
-        return { inside: c.top >= r.top && c.bottom <= r.bottom, scrollTop: s.scrollTop, h: s.scrollHeight, ch: s.clientHeight, top: c.top - r.top, q: document.getElementById('map-search').value };
-    });
-    assert.ok(found.inside, `filtrando, il primo posto trovato non si vede: ${JSON.stringify(found)}`);
-    await page.screenshot({ path: `${OUT}/07d-mappa-ricerca-piccola.png` });
-    await page.click('#close-map');
-    await page.setViewportSize({ width: 1280, height: 860 });
-
+// Le parti che aprono una pagina propria (col suo salvataggio), ognuna nel suo processo (vedi in cima).
+async function minigiochi() {
     // Il libro dell'oratorio: preso, il primo piano; si sfoglia coi clic veri, «FINE» senza che nessuno lo dica,
     // Esc chiude; dall'inventario «Apri» lo riapre e il pulsante Chiudi lo chiude. Intanto la scena dietro non risponde.
     {
@@ -551,10 +247,36 @@ try {
         await b.waitForFunction(() => game.speech?.text.startsWith('Lasci a metà?'), null, { timeout: 5000 });
         await b.close();
     }
+}
 
+async function telefoni() {
+    // La finestra di Andrea (1040×590: Firefox con le sue barre su un portatile): la scena era larga 604 px con 100 px
+    // vuoti sotto, ora prende l'altezza; i verbi stanno nei pulsanti; un dialogo a quattro risposte e uno a cinque
+    // non muovono la scena e stanno nel pannello.
+    {
+        const win = await open({ width: 1040, height: 590 });
+        await win.click('#splash'); await win.click('#new-game'); await win.click('#rione [data-rione="campomigliaio"]'); await win.click('#skip-intro');
+        await settle(win);
+        const box = async () => { const r = await win.locator('#stage').boundingBox(); return [r.x, r.y, r.width, r.height].map(Math.round); };
+        const b0 = await box();
+        assert.ok(b0[2] >= 820 && b0[1] >= 0, `a 1040×590 la scena è larga ${b0[2]} px e comincia a ${b0[1]}`);
+        assert.ok(await win.evaluate(() => document.documentElement.scrollHeight <= innerHeight), 'la pagina scorre a 1040×590');
+        assert.ok(await win.evaluate(() => [...document.querySelectorAll('#verbs button')].every(b => b.scrollWidth <= b.clientWidth + 1 && b.scrollHeight <= b.clientHeight + 1)), 'verbi tagliati a 1040×590');
+        for (const id of ['giocatore_carte', 'arcu']) {
+            await win.evaluate(id => { game.dialogue = { id, node: 'start' }; }, id);
+            await win.waitForFunction(() => !document.getElementById('choices').hidden);
+            const n = await win.evaluate(() => game.options().length);
+            assert.deepEqual(await box(), b0, `la scena si muove col dialogo ${id}`);
+            assert.ok(await win.evaluate(() => { const c = document.getElementById('choices'); return c.scrollHeight <= c.clientHeight + 1; }), `le ${n} risposte di ${id} non stanno nel pannello`);
+            if (id === 'arcu') await win.screenshot({ path: `${OUT}/11-finestra-1040-dialogo.png` });
+            await win.evaluate(() => { game.dialogue = null; });
+        }
+        await win.screenshot({ path: `${OUT}/11-finestra-1040.png` });
+        await win.close();
+    }
     const phone = await open({ width: 390, height: 844 });
     await phone.click('#splash'); // un clic salta il cartello
-    assert.ok(await phone.isVisible('#title'), 'il clic sul cartello porta al titolo');
+    assert.ok(await phone.waitForSelector('#title:not([hidden])', { timeout: 5000 }).then(() => true, () => false), 'il clic sul cartello porta al titolo');
     await phone.click('#new-game');
     await phone.click('#rione [data-rione="campomigliaio"]');
     await phone.click('#skip-intro');
@@ -619,9 +341,361 @@ try {
     await dbg.waitForTimeout(200);
     assert.deepEqual(await dbg.evaluate(() => [game.state.x, game.state.y]), start, 'Maiusc+clic non muove Andrea');
     await dbg.screenshot({ path: `${OUT}/10-debug.png` });
+}
+
+try {
+    if (process.argv.includes('--media-only')) await checkMultimedia(browser, PORT, OUT, errors);
+    else if (PARTE === 'minigiochi') { await minigiochi(); console.log('Browser OK: libro, bocce, tiri, pesca, biliardo.'); }
+    else if (PARTE === 'telefoni') { await checkMultimedia(browser, PORT, OUT, errors); await telefoni(); console.log('Browser OK: telefoni e debug.'); }
+    else {
+    const page = await open({ width: 1280, height: 860 });
+    // Il cartello d'apertura, poi da solo il titolo.
+    assert.match(await page.textContent('#splash'), /Manzolo\s*\(Poca\)\s*Art\s*Presents/);
+    assert.ok(await page.isHidden('#title'), 'il titolo aspetta la fine del cartello');
+    // Il gioco parte con un import() dinamico, che l'evento load della pagina non aspetta.
+    await page.waitForFunction(() => window.jingle, null, { timeout: 10000 });
+    assert.match(await page.evaluate(() => jingle.src), /assets\/audio\/cartello\.mp3\?v=\d+\.\d+\.\d+$/, 'la musichetta del cartello');
+    assert.equal(await page.evaluate(() => music.want), null, 'la musica del titolo aspetta il titolo');
+    await page.waitForTimeout(2800);
+    await page.screenshot({ path: `${OUT}/00-cartello.png` });
+    // Il titolo arriva sotto il cartello mentre sfuma: in nessun momento si vede la scena nuda.
+    await page.waitForSelector('#title:not([hidden])', { timeout: 8000 });
+    assert.ok(await page.isVisible('#splash'), 'il titolo compare quando il cartello è ancora sopra');
+    await page.waitForTimeout(350);
+    await page.screenshot({ path: `${OUT}/00b-dissolvenza.png` });
+    await page.waitForSelector('#splash', { state: 'hidden', timeout: 3000 });
+    // Senza un gesto il browser può bloccare la musichetta (succede online su un sito mai visto, non in locale): allora
+    // il cartello aspetta un tocco, con l'invito a toccare, e solo dopo parte coi suoi tempi.
+    {
+        const muto = await chromium.launch(), p = await muto.newPage();
+        await p.goto(`http://127.0.0.1:${PORT}/`);
+        await p.waitForTimeout(800);
+        if (await p.evaluate(() => document.getElementById('splash').classList.contains('wait'))) {
+            assert.ok(await p.isVisible('#splash .splash-hint'), 'l\'invito a toccare');
+            await p.waitForTimeout(5500);
+            assert.ok(await p.isHidden('#title'), 'il cartello aspetta il tocco');
+            await p.click('#splash');
+            assert.ok(await p.isHidden('#splash .splash-hint'));
+            await p.waitForSelector('#title:not([hidden])', { timeout: 8000 });
+            console.log('Cartello senza suono permesso: aspetta il tocco, poi parte.');
+        } else console.log('(questo Chromium lascia suonare senza gesto: il caso bloccato non si prova qui)');
+        await muto.close();
+    }
+    await page.screenshot({ path: `${OUT}/01-titolo.png` });
+    assert.match(await page.textContent('#title .version'), /^v\d+\.\d+\.\d+$/, 'la versione nell\'angolo del titolo');
+    // Col codice lento ad arrivare (rete vera) il cartello aspetta il titolo: non sfuma prima per conto suo.
+    {
+        const slow = await browser.newPage({ viewport: { width: 1280, height: 860 } });
+        // Misura al momento dell'apparizione: il polling di Playwright può arrivare dopo
+        // diversi fotogrammi su una macchina occupata, quando la dissolvenza è già in corso.
+        await slow.addInitScript(() => {
+            const observer = new MutationObserver(() => {
+                const title = document.getElementById('title'), splash = document.getElementById('splash');
+                if (title && !title.hidden && splash) {
+                    window.titleRevealOpacity = Number(getComputedStyle(splash).opacity);
+                    observer.disconnect();
+                }
+            });
+            observer.observe(document, { subtree: true, childList: true, attributes: true, attributeFilter: ['hidden'] });
+        });
+        await slow.route('**/src/main.js', async route => { await new Promise(r => setTimeout(r, 2000)); await route.continue(); });
+        await slow.goto(`http://127.0.0.1:${PORT}/`);
+        await slow.waitForSelector('#splash');
+        await slow.waitForTimeout(300);
+        if (await slow.evaluate(() => document.getElementById('splash').classList.contains('wait'))) await slow.click('#splash');
+        await slow.waitForSelector('#title:not([hidden])', { timeout: 12000 });
+        const opacity = await slow.evaluate(() => window.titleRevealOpacity);
+        assert.ok(opacity > 0.9, `il cartello era già sfumato (${opacity}) quando è comparso il titolo`);
+        await slow.close();
+    }
+    // I crediti dal titolo: si aprono, mostrano i nomi, Esc li chiude.
+    await page.click('#title .open-credits');
+    assert.match(await page.textContent('#credits'), /Ringraziamenti\s*Al Lele/, 'la dedica al Lele viene per prima');
+    assert.match(await page.textContent('#credits'), /Baldoria \(Yuri Baldi\)/);
+    assert.match(await page.textContent('#credits'), /Francesco Bacci/);
+    // I nomi col ritratto: si tocca il nome, compare il volto; un altro tocco lo chiude.
+    await page.click('#credits .credit-face >> text=Mariano');
+    assert.ok(await page.isVisible('#face img'));
+    await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
+    await page.screenshot({ path: `${OUT}/01d-ritratto.png` });
+    await page.click('#face');
+    assert.ok(await page.isHidden('#face'));
+    // Il carosello: tutte le immagini (due giri), scorre da solo, si ferma sotto il mouse, le frecce lo spingono di una
+    // foto, un tocco su una foto la mostra grande col nome del posto.
+    {
+        const track = page.locator('#credits-reel .track');
+        assert.equal(await track.locator('img').count(), reelPictures(story).length * 2, 'ogni sfondo e ogni ritratto, due giri');
+        await page.mouse.move(5, 5);
+        const x0 = await track.evaluate(t => t.scrollLeft);
+        await page.waitForTimeout(600);
+        const x1 = await track.evaluate(t => t.scrollLeft);
+        assert.ok(x1 > x0, `il carosello scorre da solo (${x0} → ${x1})`);
+        await track.hover({ position: { x: 20, y: 20 } });
+        const x2 = await track.evaluate(t => t.scrollLeft);
+        await page.waitForTimeout(500);
+        assert.equal(await track.evaluate(t => t.scrollLeft), x2, 'sotto il mouse si ferma');
+        await page.click('#credits-reel .arrow.next');
+        await page.waitForTimeout(800);
+        const x3 = await track.evaluate(t => t.scrollLeft);
+        assert.ok(x3 - x2 > 150, `la freccia spinge di una foto (${x2} → ${x3})`);
+        const third = track.locator('img').nth(2);
+        const name = await third.getAttribute('alt');
+        await third.click();
+        assert.ok(await page.isVisible('#face img.scene'), 'la foto si vede grande');
+        assert.equal(await page.textContent('#face figcaption'), name);
+        await page.waitForFunction(() => document.querySelector('#face img').naturalWidth > 0, null, { timeout: 5000 });
+        await page.screenshot({ path: `${OUT}/01e-carosello-zoom.png` });
+        await page.keyboard.press('Escape');
+        assert.ok(await page.isHidden('#face'), 'Esc chiude la foto grande, non i crediti');
+        assert.ok(await page.isVisible('#credits'));
+    }
+    const onTop = await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
+        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; });
+    assert.ok(onTop, 'i crediti stanno sopra il titolo, non dietro');
+    await page.screenshot({ path: `${OUT}/01c-crediti.png` });
+    // L'elenco può scorrere; la dedica e il pulsante Chiudi devono restare dentro lo schermo.
+    const fitsCredits = await page.evaluate(() => { const c = document.getElementById('credits').getBoundingClientRect(), b = document.getElementById('close-credits').getBoundingClientRect(); return b.bottom <= c.bottom && b.top >= c.top; });
+    assert.ok(fitsCredits, 'il pulsante Chiudi dei crediti è in vista');
+    await page.keyboard.press('Escape');
+    assert.ok(await page.isHidden('#credits'), 'Esc chiude i crediti');
+    await page.click('#new-game');
+    // Il rione: quattro scelte; la Pieve cambia la riga dell'introduzione e resta nella partita.
+    await page.waitForSelector('#rione:not([hidden])');
+    assert.equal(await page.locator('#rione-buttons button').count(), 4);
+    await page.screenshot({ path: `${OUT}/01a-rione.png` });
+    assert.equal(await page.locator('#rione-buttons button:disabled').count(), 3, 'per ora gli altri tre rioni sono chiusi');
+    await page.click('#rione [data-rione="campomigliaio"]');
+    // L'introduzione: una riga per clic, poi comincia la partita.
+    await page.waitForSelector('#intro:not([hidden])');
+    for (let i = 0; i < 2; i++) await page.click('#intro', { position: { x: 40, y: 40 } });
+    assert.match(await page.textContent('#intro-text'), /Campomigliaio, i blu/, 'la riga del rione scelto');
+    await page.screenshot({ path: `${OUT}/01b-intro.png` });
+    for (let i = 0; i < 10 && await page.isVisible('#intro'); i++) await page.click('#intro', { position: { x: 40, y: 40 } });
+    assert.ok(await page.isHidden('#intro'), 'l\'introduzione non finisce');
+    await page.waitForFunction(() => game.speech);
+    // La prima battuta ha la sua voce, e sotto la voce la musica si abbassa.
+    await page.waitForFunction(() => voices.playing, null, { timeout: 5000 });
+    assert.match(await page.evaluate(() => voices.audio.src), /assets\/voices\/andrea-[0-9a-f]+\.mp3\?v=\d+\.\d+\.\d+$/);
+    await page.waitForFunction(() => music.duck === 0.45, null, { timeout: 2000 });
+    await page.screenshot({ path: `${OUT}/02-inizio.png` });
+    assert.ok(await page.evaluate(() => game.state.flags['rione:campomigliaio']), 'il rione resta nella partita');
+    const fits = async p => p.evaluate(() => document.querySelector('#panel').getBoundingClientRect().bottom <= innerHeight);
+    assert.ok(await fits(page), 'verbi e inventario fuori dallo schermo');
+    await settle(page);
+
+    // Doppio clic su un punto della scena: Andrea ci va di corsa.
+    const r = await page.locator('#scene').boundingBox();
+    await page.mouse.dblclick(r.x + 300 / 640 * r.width, r.y + 330 / 360 * r.height);
+    assert.ok(await page.evaluate(() => game.hurry), 'il doppio clic fa correre');
+    await settle(page);
+    // «?» mostra per qualche secondo cosa si può toccare.
+    await page.click('#spots-button');
+    await page.screenshot({ path: `${OUT}/02c-punti.png` });
+    // Inventario pieno (16 oggetti di prova): resta alto quanto i verbi, dentro lo schermo, si scorre e mostra l'ultimo preso.
+    await page.evaluate(() => {
+        const items = game.story.items, kinds = ['chiave_oratorio', 'libro', 'squama'];
+        for (let i = 1; i <= 16; i++) { items['prova' + i] = { name: 'prova ' + i, icon: items[kinds[i % 3]].icon }; game.state.inventory.push('prova' + i); }
+    });
+    await page.waitForTimeout(150);
+    const inv = await page.evaluate(() => { const e = document.getElementById('inventory'), r = e.getBoundingClientRect(), last = e.lastElementChild.getBoundingClientRect();
+        return { inside: r.bottom <= innerHeight, scrolls: e.scrollHeight > e.clientHeight, lastVisible: last.bottom <= r.bottom + 1 && last.top >= r.top - 1 }; });
+    assert.deepEqual(inv, { inside: true, scrolls: true, lastVisible: true }, 'inventario pieno');
+    await page.screenshot({ path: `${OUT}/02d-inventario-pieno.png` });
+    await page.evaluate(() => { game.state.inventory = game.state.inventory.filter(i => !i.startsWith('prova')); for (let i = 1; i <= 16; i++) delete game.story.items['prova' + i]; });
+    // Il gioco prende la finestra: a 1280×860 la scena non si ferma più ai 1084 px di una riserva fissa di 250 px sotto,
+    // la pagina non scorre e i verbi stanno interi nei pulsanti (la finestra di Andrea, 1040×590, è provata più sotto).
+    const stage0 = await page.locator('#stage').boundingBox();
+    assert.ok(stage0.width >= 1200, `a 1280×860 la scena è larga ${stage0.width} px`);
+    assert.ok(await page.evaluate(() => document.documentElement.scrollHeight <= innerHeight), 'la pagina scorre in verticale a 1280×860');
+    assert.ok(await page.evaluate(() => [...document.querySelectorAll('#verbs button')].every(b => b.scrollWidth <= b.clientWidth + 1 && b.scrollHeight <= b.clientHeight + 1)), 'verbi tagliati a 1280×860');
+    // Su uno schermo grande (1920×1080, a schermo intero) il gioco non si ferma più a 1280 px: prende tutta l'altezza.
+    await page.setViewportSize({ width: 1920, height: 1080 });
+    await page.waitForFunction(() => document.getElementById('stage').getBoundingClientRect().width > 1500);
+    assert.ok(await page.evaluate(() => document.documentElement.scrollHeight <= innerHeight && document.getElementById('app').getBoundingClientRect().height >= innerHeight - 2), 'a 1920×1080 il gioco prende tutta l\'altezza, senza scorrere');
+    await page.setViewportSize({ width: 1280, height: 860 });
+    // Schermo intero: il pulsante accanto ai volumi e il tasto F, per entrare e per uscire.
+    if (await page.evaluate(() => document.fullscreenEnabled)) {
+        await page.click('#fullscreen-hud');
+        await page.waitForFunction(() => !!document.fullscreenElement && document.getElementById('fullscreen-hud').getAttribute('aria-pressed') === 'true');
+        await page.keyboard.press('f');
+        await page.waitForFunction(() => !document.fullscreenElement);
+        await page.keyboard.press('F');
+        await page.waitForFunction(() => !!document.fullscreenElement);
+        await page.click('#fullscreen-hud');
+        await page.waitForFunction(() => !document.fullscreenElement && document.getElementById('fullscreen-hud').getAttribute('aria-pressed') === 'false');
+    } else assert.ok(await page.evaluate(() => document.getElementById('fullscreen-hud').hidden), 'senza schermo intero il pulsante sparisce');
+    // Pausa: Esc o il pulsante fermano il gioco; Riprendi torna dov'eri; il titolo offre «Continua».
+    await page.keyboard.press('Escape');
+    await page.waitForSelector('#pause:not([hidden])');
+    await page.screenshot({ path: `${OUT}/02b-pausa.png` });
+    assert.equal(await page.evaluate(() => document.getElementById('fullscreen').hidden), await page.evaluate(() => !document.fullscreenEnabled), 'il pulsante Schermo intero c\'è se il browser lo permette');
+    // Salva su file: si scarica la partita; dal titolo «Carica» la riapre anche senza il salvataggio del browser.
+    const [download] = await Promise.all([page.waitForEvent('download'), page.click('#save-file')]);
+    assert.match(download.suggestedFilename(), /^regolo-\d{4}-\d\d-\d\d-\d{4}\.json$/);
+    const savedFile = `${OUT}/partita.json`;
+    await download.saveAs(savedFile);
+    const before = await page.evaluate(() => game.snapshot());
+    await page.click('#to-title');
+    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
+    await page.setInputFiles('#load-file', { name: 'altro.json', mimeType: 'application/json', buffer: Buffer.from('{"ciao":1}') });
+    await page.waitForSelector('#load-error:not([hidden])');
+    assert.ok(await page.isVisible('#title'), 'un file sbagliato lascia il titolo dov\'è');
+    // Una scena che non esiste: rifiutato, e il salvataggio del browser resta com'era.
+    await page.evaluate(() => localStorage.setItem('leggenda-regolo-save', '{"scene":"piazza","resta":true}'));
+    const lost = JSON.parse(readFileSync(savedFile, 'utf8'));
+    lost.state.scene = 'luna';
+    await page.setInputFiles('#load-file', { name: 'luna.json', mimeType: 'application/json', buffer: Buffer.from(JSON.stringify(lost)) });
+    await page.waitForFunction(() => /non torna/.test(document.getElementById('load-error').textContent));
+    assert.ok(await page.isVisible('#title'));
+    assert.equal(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')).resta), true, 'il salvataggio del browser non è toccato');
+    await page.evaluate(() => localStorage.removeItem('leggenda-regolo-save'));
+    await page.setInputFiles('#load-file', savedFile);
+    await page.waitForSelector('#title', { state: 'hidden' });
+    assert.deepEqual(await page.evaluate(() => game.snapshot()), before, 'la partita caricata è quella salvata');
+    assert.ok(await page.evaluate(() => !!localStorage.getItem('leggenda-regolo-save')), 'e diventa quella di «Continua»');
+    await page.keyboard.press('Escape');
+    await page.waitForSelector('#pause:not([hidden])');
+    await page.click('#resume');
+    assert.ok(await page.isHidden('#pause'));
+    await page.click('#pause-button');
+    await page.click('#to-title');
+    await page.waitForSelector('#continue:not([hidden])');
+    await page.click('#continue');
+    await settle(page);
+    // Musica: dopo il primo clic suona il brano del paese; muto e volume si ricordano.
+    // Il brano cambia al fotogramma dopo «Continua»: si aspetta quello, senza indovinare i tempi.
+    const playing = await page.waitForFunction(() => music.current?.src.endsWith('paese.mp3'), null, { timeout: 3000 }).then(() => true, () => false);
+    assert.ok(playing, 'musica del paese: ' + await page.evaluate(() => music.current?.src));
+    await page.click('#mute');
+    await page.locator('#volume').fill('30');
+    await page.locator('#voice-volume').fill('70');
+    assert.deepEqual(await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-audio'))), { volume: 0.3, muted: false, voices: 0.7, effects: 0.45 });
+    assert.equal(await page.evaluate(() => voices.volume), 0.7);
+    // Sul telefono si passa a un'altra app: la pagina diventa nascosta, la musica si ferma subito e la partita va in
+    // pausa; tornando la musica riparte solo con Riprendi (la pausa la tiene ferma).
+    const hide = hidden => page.evaluate(h => { Object.defineProperty(document, 'hidden', { value: h, configurable: true }); document.dispatchEvent(new Event('visibilitychange')); }, hidden);
+    await hide(true);
+    assert.equal(await page.evaluate(() => ambience.nodes.size), 0, 'nascosta la pagina, gli effetti si fermano subito');
+    assert.ok(await page.evaluate(() => music.current.audio.paused), 'nascosta la pagina, la musica è ferma');
+    assert.ok(await page.isVisible('#pause'), 'e la partita è in pausa');
+    await hide(false);
+    await page.click('#resume');
+    await page.waitForFunction(() => !music.current.audio.paused, null, { timeout: 5000 });
+
+    for (const [verb, target, item] of solution) {
+        if (verb === 'choose') {
+            await page.locator('#choices li', { hasText: target }).click();
+        } else {
+            const smart = await page.evaluate(([v, t]) => game.defaultVerb(t) === v, [verb, target]);
+            if (item) {
+                await page.click(`#verbs [data-verb="${verb}"]`);
+                await page.click(`#inventory [data-item="${item}"]`);
+            } else if (!smart) await page.click(`#verbs [data-verb="${verb}"]`);
+            // Un oggetto dell'inventario su un altro (cedrata col ghiacciolo) si clicca nell'inventario, non nella scena.
+            if (await page.evaluate(t => !!game.story.items[t], target)) await page.click(`#inventory [data-item="${target}"]`);
+            else await clickScene(page, await hotspotCenter(page, target));
+        }
+        await page.waitForTimeout(80);
+        if (verb === 'talk') await page.screenshot({ path: `${OUT}/03-dialogo.png` });
+        // La torcia nella fessura: il palio illuminato e i due occhi gialli, prima che spariscano.
+        if (target === 'fessura' && item) {
+            await page.waitForFunction(() => game.closeup?.id === 'fessura', null, { timeout: 30000 });
+            for (let i = 0; i < 3; i++) {
+                const at = await page.evaluate(i => game.story.closeups.fessura.targets[i].at, i);
+                const box = await page.locator('#scene').boundingBox();
+                await page.mouse.move(box.x + at[0] / 640 * box.width, box.y + at[1] / 360 * box.height);
+                await page.waitForFunction(() => game.closeup?.step === 'reveal');
+                await page.screenshot({ path: `${OUT}/05b-fessura-${i}.png` });
+                for (const fine = Date.now() + 30000; Date.now() < fine;) { // con la macchina carica la rivelazione dura di più
+                    if (await page.evaluate(i => game.closeup.found > i, i)) break;
+                    if (await page.evaluate(() => !!game.speech)) await page.keyboard.press('Space');
+                    await page.waitForTimeout(30);
+                }
+                assert.equal(await page.evaluate(() => game.closeup.found), i + 1);
+            }
+            await page.click('#closeup-close');
+        }
+        await settle(page);
+        if (target === 'cosa_luccicante') await page.screenshot({ path: `${OUT}/04-squama.png` });
+        if (target === 'su_fortezza') await page.screenshot({ path: `${OUT}/05-fortezza.png` });
+    }
+    await page.waitForSelector('#ending:not([hidden])');
+    await page.screenshot({ path: `${OUT}/06-fine.png` });
+    await page.click('#ending .open-credits');
+    assert.ok(await page.isVisible('#credits'), 'crediti anche dalla fine');
+    assert.ok(await page.evaluate(() => { const r = document.getElementById('close-credits').getBoundingClientRect();
+        return document.elementFromPoint(r.x + r.width / 2, r.y + r.height / 2)?.id === 'close-credits'; }), 'i crediti stanno sopra la fine');
+    await page.click('#close-credits');
+    assert.ok(await page.isHidden('#credits'));
+    const saved = await page.evaluate(() => JSON.parse(localStorage.getItem('leggenda-regolo-save')));
+    assert.ok(saved.ended && saved.inventory.includes('squama'), 'salvataggio finale');
+
+    // Una partita a metà riprende da dove era rimasta.
+    await page.click('#restart');
+    await settle(page);
+    for (const [, exit] of route('piazza', 'trebbio')) {
+        await clickScene(page, await hotspotCenter(page, exit));
+        await settle(page);
+    }
+    await page.click('#verbs [data-verb="talk"]');
+    await clickScene(page, await hotspotCenter(page, 'torre'));
+    await page.locator('#choices li', { hasText: 'bloccato' }).click();
+    await page.waitForFunction(() => game.speech?.who === 'castello');
+    await page.waitForTimeout(100);
+    await page.screenshot({ path: `${OUT}/07-trebbio.png` });
+    await settle(page);
+    await page.locator('#choices li', { hasText: 'pace' }).click();
+    await settle(page);
+    await page.reload();
+    await page.waitForSelector('#continue:not([hidden])');
+    await page.click('#continue');
+    assert.equal(await page.evaluate(() => game.state.scene), 'trebbio');
+    await settle(page);
+    // Il taccuino (N): la tappa di adesso in evidenza, Esc lo chiude.
+    await page.keyboard.press('n');
+    assert.ok(await page.isVisible('#notebook'));
+    assert.ok((await page.textContent('#notebook-list li.now')).length > 10, 'c\'è l\'obiettivo di adesso');
+    await page.screenshot({ path: `${OUT}/07a-taccuino.png` });
+    await page.keyboard.press('Escape');
+    assert.ok(await page.isHidden('#notebook'));
+    // La mappa: dal Trebbio alla Piazza con due clic; i posti mai visti (la Pieve) non ci sono.
+    await page.click('#map-button');
+    assert.equal(await page.locator('#map-board button[data-scene="pieve"]').count(), 0, 'la Pieve non è ancora vista');
+    assert.ok(await page.isVisible('#map-board button.here[data-scene="trebbio"]'));
+    await page.screenshot({ path: `${OUT}/07b-mappa.png` });
+    // La ricerca: scrivendo restano solo i posti giusti; una «p» nella casella non chiude la mappa; Invio ci va.
+    await page.fill('#map-search', 'xyz');
+    assert.ok(await page.isVisible('#map-none'), 'nessun posto: lo dice');
+    await page.fill('#map-search', '');
+    await page.click('#map-search');
+    await page.keyboard.type('piazza col'); // «piaz» da solo trova anche la Piazzetta Cambray Digny
+    assert.ok(await page.isVisible('#map'), 'scrivere «p» nella ricerca non chiude la mappa');
+    assert.ok(await page.isHidden('#map-none'));
+    const shown = await page.locator('#map-board button:visible').evaluateAll(bs => bs.map(b => b.dataset.scene));
+    assert.deepEqual(shown, ['piazza']);
+    await page.screenshot({ path: `${OUT}/07c-mappa-ricerca.png` });
+    await page.keyboard.press('Enter');
+    assert.ok(await page.isHidden('#map'));
+    assert.equal(await page.evaluate(() => game.state.scene), 'piazza');
+    // Con tutti i posti visti e la finestra piccola la mappa si scorre: filtrando da in fondo, i posti trovati si vedono
+    // (prima la mappa restava lunga quanto quella intera, scorsa su un fondo vuoto).
+    await page.setViewportSize({ width: 560, height: 340 });
+    await page.evaluate(() => { for (const id of Object.keys(game.story.scenes)) game.state.flags['visto:' + id] = true; });
+    await page.click('#map-button');
+    assert.ok(await page.evaluate(() => { const s = document.getElementById('map-scroll'); s.scrollTop = s.scrollHeight; return s.scrollTop > 0; }), 'la mappa piena si scorre');
+    await page.fill('#map-search', 'campo');
+    const found = await page.evaluate(() => {
+        const s = document.getElementById('map-scroll'), r = s.getBoundingClientRect();
+        const c = [...document.querySelectorAll('#map-board button')].find(b => !b.hidden && !b.parentElement.hidden).getBoundingClientRect();
+        return { inside: c.top >= r.top && c.bottom <= r.bottom, scrollTop: s.scrollTop, h: s.scrollHeight, ch: s.clientHeight, top: c.top - r.top, q: document.getElementById('map-search').value };
+    });
+    assert.ok(found.inside, `filtrando, il primo posto trovato non si vede: ${JSON.stringify(found)}`);
+    await page.screenshot({ path: `${OUT}/07d-mappa-ricerca-piccola.png` });
+    await page.click('#close-map');
+    await page.setViewportSize({ width: 1280, height: 860 });
 
     assert.deepEqual(errors, [], 'errori nella console');
-    console.log(`Browser OK: soluzione completa, ripresa del salvataggio, telefono. Schermate in ${OUT}`);
+    console.log(`Browser OK: soluzione completa, ripresa del salvataggio. Schermate in ${OUT}`);
     }
     assert.deepEqual(errors, [], 'errori nella console');
 } finally {

tests/bruciate.browser.mjs

@@ -0,0 +1,68 @@
+// Le bruciate nel browser vero: dai volontari della Smarronata, la manovella girata col mouse e col dito, il sacco.
+// npm run browser:bruciate — schermate in /tmp/regolo-bruciate.
+import { chromium } from 'playwright';
+import { mkdirSync } from 'node:fs';
+import assert from 'node:assert/strict';
+import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
+
+const out = process.env.OUT ?? '/tmp/regolo-bruciate';
+mkdirSync(out, { recursive: true });
+const server = await staticServer();
+let browser;
+const errors = [];
+try {
+    browser = await chromium.launch({ args: ARGS });
+    for (const [name, mobile, viewport] of [['desktop', false, { width: 1280, height: 860 }], ['touch', true, { width: 844, height: 390 }]]) {
+        const page = await browser.newPage({ viewport, hasTouch: mobile, isMobile: mobile });
+        page.on('pageerror', e => errors.push(e.message));
+        await page.goto(`http://127.0.0.1:${server.port}/`);
+        await page.click('#splash'); await page.click('#new-game'); await page.click('#rione [data-rione="campomigliaio"]'); await page.click('#skip-intro');
+        await page.evaluate(async () => {
+            const { settle } = await import('/tests/helpers.mjs');
+            settle(game); game.go('smarronata_1993'); settle(game);
+            game.act('talk', 'volontari'); settle(game);
+            game.choose(game.options().findIndex(o => o.text === 'Vi do una mano alla manovella?')); settle(game);
+            game.choose(game.options().findIndex(o => o.text === 'Alla bona.')); settle(game);
+        });
+        await page.waitForSelector('#bocce-controls:not([hidden])');
+        await page.waitForFunction(async () => (await import('/src/engine/render.js')).hasBackground('assets/closeups/smarronata-bruciatore.png'));
+        assert.equal(await page.locator('#bocce-throw').textContent(), 'Rovescia nel sacco');
+        assert.ok(await page.locator('#bruciate-help').isVisible());
+        assert.ok(!(await page.locator('#bocce-left').isVisible()), 'niente pulsanti Mira');
+        assert.ok(!(await page.locator('#bocce-power').isVisible()), 'niente forza');
+        await page.screenshot({ path: `${out}/${name}-ferma.png` });
+        const box = await page.locator('#scene').boundingBox(), P = (x, y) => [box.x + x / 640 * box.width, box.y + y / 360 * box.height];
+        // I giri attorno alla manovella: col mouse tenendo premuto, col dito trascinando (eventi di puntatore veri).
+        const loops = async (turns, steps = 16) => {
+            const at = i => { const a = i / steps * Math.PI * 2; return P(506 + Math.cos(a) * 40, 190 + Math.sin(a) * 40); };
+            if (mobile) {
+                const cdp = await page.context().newCDPSession(page), touch = (type, [x, y]) => cdp.send('Input.dispatchTouchEvent', { type, touchPoints: type === 'touchEnd' ? [] : [{ x, y }] });
+                await touch('touchStart', at(0));
+                for (let i = 1; i <= turns * steps; i++) await touch('touchMove', at(i));
+                await touch('touchEnd', at(0));
+            } else {
+                await page.mouse.move(...at(0)); await page.mouse.down();
+                for (let i = 1; i <= turns * steps; i++) await page.mouse.move(...at(i));
+                await page.mouse.up();
+            }
+        };
+        await loops(3);
+        const turned = await page.evaluate(() => Math.abs(game.closeup.drum));
+        assert.ok(turned > 6, `il cilindro ha girato: ${turned.toFixed(1)} rad`);
+        await page.screenshot({ path: `${out}/${name}-gira.png` });
+        // Il resto della cottura lo si fa fare al gioco a velocità giusta (le schermate con swiftshader sono lente).
+        await page.evaluate(() => { const c = game.closeup; c.speed = 4.5; for (const k of c.chestnuts) k.cook = 1.05; c.t = Math.max(c.t, 5); });
+        await page.waitForFunction(() => !document.querySelector('#bocce-throw').disabled);
+        await page.screenshot({ path: `${out}/${name}-cotte.png` });
+        if (mobile) await page.locator('#bocce-throw').tap(); else await page.locator('#bocce-throw').click();
+        await page.waitForFunction(() => game.closeup?.step === 'result', null, { timeout: 10000 });
+        assert.match(await page.locator('#bocce-status').textContent(), /bruciate buone su 18/);
+        await page.screenshot({ path: `${out}/${name}-sacco.png` });
+        await page.locator('#closeup-close').click();
+        await page.waitForFunction(() => game.state.flags.bruciate_fatte);
+        await page.close();
+    }
+    assert.deepEqual(errors, []);
+    console.log(`ok: schermate in ${out}`);
+} finally { await browser?.close(); server.kill(); }

tests/bruciate.test.mjs

@@ -0,0 +1,130 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as m from '../src/engine/bruciate.js';
+import { drawBruciate } from '../src/engine/bruciate-render.js';
+import { Game } from '../src/engine/game.js';
+import { story } from '../src/story/story.js';
+import { settle } from './helpers.mjs';
+
+// Gira la manovella tenendola, a `w` radianti al secondo, finché le castagne non paiono cotte (o per `secs` secondi).
+function crank(c, w, { secs = 60, until = 1.2 } = {}) {
+    c.grab ??= { pointerId: 1, heading: null, last: null };
+    for (let i = 0; i < secs * 60 && c.step === 'turn' && m.doneness(c) < until; i++) { c.pending = w / 60; m.update(c, 1 / 60); }
+}
+function pourAndWait(c) {
+    assert.ok(m.shoot(c), 'si rovescia nel sacco');
+    for (let i = 0; i < 200 && c.step === 'pour'; i++) m.update(c, 1 / 60);
+    assert.equal(c.step, 'result');
+    return c.result;
+}
+
+test('girando a modo le bruciate vengono tutte buone, nel tempo del livello', () => {
+    for (const level of ['bona', 'seria', 'male']) {
+        const c = m.newBruciate(42, { level });
+        crank(c, 4.5);
+        assert.ok(c.t > 6 && c.t < m.LEVELS[level].time, `${level}: cotte in ${c.t.toFixed(1)} s`);
+        const r = pourAndWait(c);
+        assert.equal(r.winner, 'player', `${level}: ${JSON.stringify(r)}`);
+        assert.equal(r.spilled, 0);
+    }
+});
+
+test('ferme sul fuoco: quelle di sotto carbone, quelle di sopra crude', () => {
+    const c = m.newBruciate(42, { level: 'seria' });
+    crank(c, 0);
+    const r = pourAndWait(c);
+    assert.equal(r.winner, 'cpu');
+    assert.ok(r.burnt > 0 && r.raw > 0, JSON.stringify(r));
+    assert.match(m.status(c), /Ne servivano 15/);
+});
+
+test('troppo forte è una centrifuga: le castagne volano nel fuoco', () => {
+    const c = m.newBruciate(42, { level: 'seria' });
+    crank(c, 12, { secs: 4, until: 9 });
+    assert.ok(c.chestnuts.some(k => k.out), 'qualcuna è volata fuori');
+    assert.ok(c.flying.length > 0);
+    assert.match(c.line, /centrifuga|fuoco/);
+    assert.ok(c.events.some(e => e.kind === 'bruciate-cade'));
+    assert.equal(m.speedWord(c), 'troppo forte');
+});
+
+test('rovesciarle troppo presto: crude; e il pulsante aspetta i primi secondi', () => {
+    const c = m.newBruciate(42, { level: 'bona' });
+    assert.ok(!m.canThrow(c) && !m.shoot(c), 'appena cominciato non si rovescia');
+    crank(c, 4.5, { until: 0.4 });
+    const r = pourAndWait(c);
+    assert.equal(r.winner, 'cpu'); assert.ok(r.raw > 10);
+});
+
+test('il gesto: i giri, grandi o piccoli e dovunque, fanno girare il cilindro; una riga dritta no', () => {
+    const circles = (c, cx, cy, radius, turns, secs) => {
+        assert.ok(m.press(c, 7));
+        const steps = Math.round(secs * 60);
+        for (let i = 0; i <= steps; i++) {
+            const a = i / steps * turns * Math.PI * 2;
+            m.aimScreen(c, [cx + Math.cos(a) * radius, cy + Math.sin(a) * radius]);
+            m.update(c, 1 / 60);
+        }
+    };
+    for (const [x, y, r] of [[506, 190, 30], [200, 300, 80], [320, 180, 15]]) {
+        const c = m.newBruciate(1);
+        m.aimScreen(c, [x + r, y]);
+        circles(c, x, y, r, 2, 2);
+        assert.ok(Math.abs(c.speed) > 4 && Math.abs(c.speed) < 9, `giri di raggio ${r}: ${c.speed.toFixed(2)} rad/s`);
+        assert.ok(Math.abs(c.drum) > 6);
+        // Lasciata la manovella, il cilindro rallenta da sé.
+        assert.ok(m.release(c, 7));
+        const w = Math.abs(c.speed);
+        for (let i = 0; i < 60; i++) m.update(c, 1 / 60);
+        assert.ok(Math.abs(c.speed) < w * 0.5);
+    }
+    const c = m.newBruciate(1);
+    m.aimScreen(c, [100, 200]); m.press(c, 1);
+    for (let i = 0; i < 120; i++) { m.aimScreen(c, [100 + i * 3, 200]); m.update(c, 1 / 60); }
+    assert.ok(Math.abs(c.speed) < 0.2, 'trascinare dritto non gira');
+    assert.ok(!m.release(c, 99), 'un altro dito non lascia la manovella');
+});
+
+test('senza gesto: Spazio e le frecce danno una spinta, Invio rovescia', () => {
+    const c = m.newBruciate(3);
+    assert.ok(m.key(c, ' ', true));
+    assert.ok(Math.abs(c.speed) >= m.PUSH);
+    assert.ok(m.key(c, 'ArrowRight', true)); assert.ok(Math.abs(c.speed) >= m.PUSH * 1.5);
+    assert.ok(m.key(c, ' ', false), 'anche lasciando il tasto, il tasto è suo');
+    assert.ok(!m.key(c, 'x', true));
+    for (let i = 0; i < 60 * m.MIN_POUR + 2; i++) m.update(c, 1 / 60);
+    m.key(c, 'Enter', true);
+    assert.equal(c.step, 'pour');
+});
+
+test('il disegno delle bruciate non cambia lo stato', () => {
+    const calls = [], ctx = new Proxy({}, { get: (o, k) => k in o ? o[k] : (...args) => calls.push([k, ...args]) });
+    const c = m.newBruciate(7, { level: 'bona' }), bg = {};
+    const draw = () => { const before = structuredClone(c); drawBruciate(ctx, c, story.closeups.bruciate, bg); assert.deepEqual(c, before); };
+    draw();
+    assert.ok(calls.some(([op, img]) => op === 'drawImage' && img === bg));
+    assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'GIRA!'), 'da fermo, l\'invito a girare');
+    assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'COTTURA'));
+    crank(c, 12, { secs: 2, until: 9 }); draw();
+    crank(c, 4.5); pourAndWait(c); calls.length = 0; draw();
+    assert.ok(calls.some(([op, t]) => op === 'fillText' && /BRUCIATE/.test(t)));
+});
+
+test('alla Smarronata: dai volontari, «Vi do una mano alla manovella?», il livello e le bruciate', () => {
+    const g = new Game(story); g.go('smarronata_1993'); settle(g);
+    g.act('talk', 'volontari'); settle(g);
+    assert.ok(g.options().some(o => o.text.startsWith('Che Iddio ve ne renda merito')), 'il ringraziamento resta');
+    g.choose(g.options().findIndex(o => o.text === 'Vi do una mano alla manovella?')); settle(g);
+    g.choose(g.options().findIndex(o => o.text === 'Seria.')); settle(g);
+    assert.equal(g.closeup?.id, 'bruciate'); assert.equal(g.closeup.level, 'seria');
+    crank(g.closeup, 4.5); pourAndWait(g.closeup);
+    g.closeupClose(); settle(g);
+    assert.ok(g.state.flags.bruciate_fatte);
+    // Anche usando il cilindro si chiede la manovella; uscendo prima, la battuta di chi lascia.
+    g.act('use', 'bruciatore'); settle(g);
+    g.choose(g.options().findIndex(o => o.text === 'Vi do una mano alla manovella?')); settle(g);
+    g.choose(g.options().findIndex(o => o.text === 'Alla bona.')); settle(g);
+    assert.equal(g.closeup?.id, 'bruciate');
+    g.closeupClose();
+    assert.equal(g.queue[0]?.say, story.closeups.bruciate.quit[0].say);
+});

tests/campana.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-campana';
 mkdirSync(out, { recursive: true });
@@ -11,7 +12,7 @@ const server = await staticServer();
 let browser;
 const errors = [];
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     for (const [name, mobile, viewport] of [['desktop', false, { width: 1280, height: 860 }], ['touch', true, { width: 844, height: 390 }]]) {
         const page = await browser.newPage({ viewport, hasTouch: mobile, isMobile: mobile });
         page.on('pageerror', e => errors.push(e.message));

tests/cerbottana.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-cerbottana';
 mkdirSync(out, { recursive: true });
@@ -11,7 +12,7 @@ const server = await staticServer();
 let browser;
 const errors = [];
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     for (const [name, mobile, viewport] of [['desktop', false, { width: 1280, height: 860 }], ['touch', true, { width: 844, height: 390 }]]) {
         const page = await browser.newPage({ viewport, hasTouch: mobile, isMobile: mobile });
         page.on('pageerror', e => errors.push(e.message));

tests/chromium.mjs

@@ -0,0 +1,11 @@
+// Come si apre Chromium nelle prove nel browser (solo da node: helpers.mjs lo carica anche la pagina).
+// Con una scheda video (/dev/dri o /dev/nvidia0, anche nei contenitori lanciati con --gpus) si disegna lì: una
+// schermata costa ~45 ms invece di ~600 con swiftshader, e le prove girano 5-10 volte più in fretta. Senza, swiftshader.
+// REGOLO_GPU=0 forza swiftshader, REGOLO_GPU=1 la scheda video.
+import { existsSync } from 'node:fs';
+
+export const GPU = process.env.REGOLO_GPU ? process.env.REGOLO_GPU === '1' : ['/dev/dri/renderD128', '/dev/nvidia0'].some(existsSync);
+const AUTOPLAY = '--autoplay-policy=no-user-gesture-required';
+// Sempre sul processore: la prova del peso (peso.browser.mjs) misura così gli effetti, come su un telefono lento.
+export const SWIFTSHADER = [AUTOPLAY, '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'];
+export const ARGS = GPU ? [AUTOPLAY, '--use-gl=angle', '--use-angle=gl-egl', '--ignore-gpu-blocklist', '--enable-gpu-rasterization'] : SWIFTSHADER;

tests/condor.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-condor';
 mkdirSync(out, { recursive: true });
@@ -11,7 +12,7 @@ const server = await staticServer();
 let browser;
 const errors = [];
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     for (const [name, mobile, viewport] of [['desktop', false, { width: 1280, height: 860 }], ['touch', true, { width: 844, height: 390 }]]) {
         const page = await browser.newPage({ viewport, hasTouch: mobile, isMobile: mobile });
         page.on('pageerror', e => errors.push(e.message));

tests/flipper-art.test.mjs

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { newFlipper, futureLayout } from '../src/engine/flipper.js';
+import { flipperScene } from '../src/engine/flipper-art.js';
+
+test('il backglass segue i luoghi attraversati, senza modificare la partita', () => {
+    const c = newFlipper(91);
+    assert.equal(flipperScene(c), 'regolo');
+    for (const [x, y, scene] of [[403, 70, 'regolo'], [297, 90, 'rioni'], [220, 168, 'pieve'], [416, 180, 'trebbio'], [290, 135, 'fortezza'], [320, 202, 'regolo'], [320, 290, 'sieve']]) {
+        Object.assign(c.ball, { waiting: false, x, y });
+        const before = structuredClone(c);
+        assert.equal(flipperScene(c), scene, `zona ${x}, ${y}`);
+        assert.deepEqual(c, before);
+    }
+    for (const [id, scene] of [['sinistra', 'fortezza'], ['destra', 'trebbio'], ['super', 'cosmo'], ['orbita', 'cosmo'], ['ponte', 'fortezza'], ['spira', 'spira']]) {
+        c.ball.ramp = { id };
+        assert.equal(flipperScene(c), scene);
+    }
+    c.regolo.hit = 0.2;
+    assert.equal(flipperScene(c), 'regolo', 'il colpo al Regolo ha precedenza sulle rampe');
+});
+
+test('palline in attesa o trattenute non attivano immagini, il multiball ha una priorità stabile', () => {
+    const c = newFlipper(92);
+    c.extraBalls = [{ ...structuredClone(c.ball), x: 210, y: 170, waiting: false, releaseAt: c.sim + 2 }];
+    assert.equal(flipperScene(c), 'regolo');
+    Object.assign(c.ball, { waiting: false, ramp: { id: 'destra' } });
+    Object.assign(c.extraBalls[0], { releaseAt: 0, ramp: { id: 'sinistra' } });
+    const first = flipperScene(c);
+    [c.ball, c.extraBalls[0]] = [c.extraBalls[0], c.ball];
+    assert.equal(flipperScene(c), first);
+    c.ball = null; c.extraBalls = []; c.step = 'result';
+    assert.equal(flipperScene(c), 'regolo');
+    Object.assign(c, futureLayout(), { table: 'future' });
+    assert.equal(flipperScene(c), 'cosmo');
+});

tests/flipper.browser.mjs

@@ -0,0 +1,279 @@
+// Il flipper del River nel browser vero: dal bar, la molla col mouse e col dito, i flipper con due dita sulla scena,
+// coi pulsanti e con le frecce, la pausa che lascia tutto, il risultato. npm run browser:flipper — schermate in
+// /tmp/regolo-flipper.
+import { chromium } from 'playwright';
+import { mkdirSync } from 'node:fs';
+import assert from 'node:assert/strict';
+import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
+
+const out = process.env.OUT ?? '/tmp/regolo-flipper';
+mkdirSync(out, { recursive: true });
+const server = await staticServer();
+let browser;
+const errors = [];
+try {
+    browser = await chromium.launch({ args: ARGS });
+    for (const [name, mobile, viewport] of [['desktop', false, { width: 1280, height: 860 }], ['touch', true, { width: 844, height: 390 }]]) {
+        const page = await browser.newPage({ viewport, hasTouch: mobile, isMobile: mobile });
+        page.on('pageerror', e => errors.push(e.message));
+        await page.goto(`http://127.0.0.1:${server.port}/`);
+        await page.click('#splash'); await page.click('#new-game'); await page.click('#rione [data-rione="campomigliaio"]'); await page.click('#skip-intro');
+        await page.evaluate(async () => {
+            const { settle } = await import('/tests/helpers.mjs');
+            settle(game); game.go('via_provinciale'); settle(game);
+            game.act('use', 'river'); settle(game);
+            game.choose(game.options().findIndex(o => o.text.startsWith('Una partita alla bona'))); settle(game);
+        });
+        await page.waitForSelector('#bocce-controls:not([hidden])', { state: 'attached' });
+        await page.waitForFunction(async () => (await import('/src/engine/render.js')).hasBackground('assets/closeups/river-flipper.png'));
+        // Aspetta che finisca la dissolvenza d'ingresso: le immagini devono mostrare i colori della tavola.
+        const readyAt = await page.evaluate(() => game.closeup.visual.time);
+        await page.waitForFunction(t => game.closeup.visual.time > t + 1, readyAt);
+        assert.equal(await page.locator('#scene').getAttribute('width'), '1280', 'il flipper usa la risoluzione doppia');
+        assert.equal(await page.locator('#bocce-throw').textContent(), 'Lancia');
+        if (!mobile) {
+            // «Solo tavola»: la pulsantiera sparisce e la tavola si allarga; ripremuto, torna tutto com'era.
+            const before = (await page.locator('#scene').boundingBox()).width;
+            await page.click('#table-only');
+            await page.waitForFunction(() => getComputedStyle(document.getElementById('side')).display === 'none');
+            await page.waitForFunction(w => document.getElementById('scene').getBoundingClientRect().width > w + 50, before);
+            assert.equal(await page.locator('#table-only').textContent(), 'Pulsantiera');
+            await page.click('#table-only');
+            await page.waitForFunction(() => getComputedStyle(document.getElementById('side')).display !== 'none');
+            assert.ok(await page.locator('#flipper-help').isVisible());
+            assert.equal(await page.locator('#bocce-left').textContent(), '← Flipper');
+            assert.ok(!(await page.locator('#bocce-left').isDisabled()), 'i pulsanti dei flipper sono attivi anche prima del lancio');
+        } else {
+            // Sul telefono in orizzontale (Andrea): niente pulsantiera, la scena larga sotto i due pollici.
+            assert.ok(!(await page.locator('#side').isVisible()), 'sul telefono la pulsantiera del flipper sparisce');
+            const w = (await page.locator('#scene').boundingBox()).width;
+            assert.ok(w > viewport.width * 0.6, `sul telefono la scena del flipper è larga ${w} px`);
+        }
+        await page.screenshot({ path: `${out}/${name}-tavola.png` });
+        // «TIENI PREMUTO QUI» per la molla solo col dito (Andrea): sul computer la tavola non la dice.
+        assert.equal(await page.evaluate(() => !!game.closeup.touch), mobile, 'la scritta della molla solo sul telefono');
+        const box = await page.locator('#scene').boundingBox(), P = (x, y) => [box.x + x / 640 * box.width, box.y + y / 360 * box.height];
+        if (!mobile) await page.screenshot({ path: `${out}/desktop-dettaglio.png`, clip: { x: P(200, 0)[0], y: box.y, width: 248 / 640 * box.width, height: box.height } });
+        // Le apparizioni seguono zone vere del campo e cambiano effettivamente i pixel del backglass.
+        if (!mobile) {
+            await page.evaluate(() => {
+                window.artState = structuredClone(game.closeup); window.artUpdate = game.update;
+                game.update = () => {};
+            });
+            const pictures = new Set();
+            for (const [x, y, scene] of [[403, 70, 'regolo'], [290, 135, 'fortezza'], [416, 180, 'trebbio'], [220, 168, 'pieve'], [297, 90, 'rioni'], [320, 290, 'sieve']]) {
+                const result = await page.evaluate(async ({ x, y }) => {
+                    const { render } = await import('/src/engine/render.js');
+                    const { flipperScene } = await import('/src/engine/flipper-art.js');
+                    const c = game.closeup, ctx = document.querySelector('#scene').getContext('2d');
+                    Object.assign(c.ball, { x, y, waiting: false, releaseAt: 0, ramp: null });
+                    for (let i = 0; i < 4; i++) { c.visual.time += 0.4; render(ctx, game, { time: performance.now() }); }
+                    const pixels = ctx.getImageData(48, 476, 300, 176).data;
+                    let signature = 0;
+                    for (let i = 0; i < pixels.length; i++) signature = (Math.imul(signature, 31) + pixels[i]) | 0;
+                    return { scene: flipperScene(c), signature };
+                }, { x, y });
+                assert.equal(result.scene, scene); pictures.add(result.signature);
+                await page.screenshot({ path: `${out}/desktop-visione-${scene}.png` });
+            }
+            assert.equal(pictures.size, 6, 'sei illustrazioni diverse nel display');
+            await page.evaluate(() => {
+                Object.assign(game.closeup, window.artState); game.update = window.artUpdate;
+                delete window.artState; delete window.artUpdate;
+            });
+        }
+        const cdp = mobile ? await page.context().newCDPSession(page) : null;
+        const touch = (type, points) => cdp.send('Input.dispatchTouchEvent', { type, touchPoints: points.map(([x, y]) => ({ x, y })) });
+        // La molla: tenendo premuto sulla scena, col mouse e col dito.
+        if (mobile) {
+            await touch('touchStart', [P(320, 320)]); // al centro: la molla
+            await page.waitForFunction(() => game.closeup.holding && game.closeup.power > 0.3, null, { polling: 'raf' });
+            await touch('touchEnd', []);
+        } else {
+            // Da tastiera con la freccia giù (il mouse tiene la molla come il dito, provato sul telefono).
+            await page.keyboard.down('ArrowDown');
+            await page.waitForFunction(() => game.closeup.holding && game.closeup.power > 0.3, null, { polling: 'raf' });
+            await page.keyboard.up('ArrowDown');
+        }
+        await page.waitForFunction(() => game.closeup && !game.closeup.ball?.waiting, null, { timeout: 5000 });
+        // Due dita sulla scena: sinistra, poi anche destra, poi si alza la sinistra e la destra resta su.
+        if (mobile) {
+            await touch('touchStart', [P(250, 200)]);
+            await page.waitForFunction(() => game.closeup.flippers.left.held.length > 0);
+            await touch('touchStart', [P(250, 200), P(400, 200)]);
+            await page.waitForFunction(() => game.closeup.flippers.right.held.length > 0 && game.closeup.flippers.left.held.length > 0, null, { timeout: 3000 });
+            await page.screenshot({ path: `${out}/${name}-flipper.png` });
+            await touch('touchEnd', [P(400, 200)]);
+            await page.waitForFunction(() => game.closeup.flippers.left.held.length === 0 && game.closeup.flippers.right.held.length > 0, null, { timeout: 3000 });
+            await touch('touchEnd', []);
+            await page.waitForFunction(() => game.closeup.flippers.right.held.length === 0);
+        } else {
+            await page.mouse.move(...P(400, 200)); await page.mouse.down();
+            await page.waitForFunction(() => game.closeup.flippers.right.held.length > 0);
+            await page.mouse.down({ button: 'right' });
+            await page.waitForFunction(() => game.closeup.flippers.right.held.length > 1, null, { timeout: 3000 });
+            await page.screenshot({ path: `${out}/${name}-flipper.png` });
+            await page.mouse.up(); await page.mouse.up({ button: 'right' });
+            await page.waitForFunction(() => game.closeup.flippers.right.held.length === 0);
+            await page.keyboard.down('ArrowLeft');
+            await page.waitForFunction(() => game.closeup.flippers.left.held.length > 0);
+            // La pausa lascia tutto: tornando, il flipper è giù anche se il tasto era premuto.
+            await page.click('#pause-button');
+            await page.waitForFunction(() => game.closeup.flippers.left.held.length === 0);
+            await page.keyboard.up('ArrowLeft');
+            await page.click('#resume');
+            await page.waitForFunction(() => document.querySelector('#pause').hidden);
+            // I due Shift: il sinistro alza la paletta sinistra, il destro la destra.
+            await page.keyboard.down('ShiftRight');
+            await page.waitForFunction(() => game.closeup.flippers.right.held.includes('key-ShiftRight') && !game.closeup.flippers.left.held.length);
+            await page.keyboard.down('ShiftLeft');
+            await page.waitForFunction(() => game.closeup.flippers.left.held.includes('key-ShiftLeft'));
+            await page.keyboard.up('ShiftRight'); await page.keyboard.up('ShiftLeft');
+            await page.waitForFunction(() => !game.closeup.flippers.left.held.length && !game.closeup.flippers.right.held.length);
+        }
+        // Il traguardo aggiunge una pallina e lascia continuare la partita.
+        const reward = await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js'), c = game.closeup;
+            m.cancel(c); if (m.waiting(c)) m.launch(c, 0.8);
+            c.balls = 1; c.score = c.skill.goal - m.SCORE.bumper; c.saveUntil = 0;
+            const b = c.bumpers[0]; b.touching = false;
+            Object.assign(c.ball, { x: b.x, y: b.y + b.r + 6, vx: 0, vy: -200, waiting: false, ramp: null });
+            m.update(c, 0.05);
+            return { balls: c.balls, step: c.step, winner: c.result?.winner };
+        });
+        assert.deepEqual(reward, { balls: 2, step: 'play', winner: 'player' });
+        await page.waitForFunction(() => document.querySelector('#bocce-status').textContent.includes('pallina premio vinta'));
+        await page.screenshot({ path: `${out}/${name}-premio.png` });
+        // Una sequenza reale di rampe, con il motore: primo lock, secondo lock, rampa centrale e tre palline.
+        await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js');
+            Object.assign(game.closeup, m.newFlipper(73, { level: 'bona' }));
+            window.pinballShot = id => {
+                const c = game.closeup, r = c.ramps.find(r => r.id === id);
+                if (m.waiting(c)) m.launch(c, 0.8);
+                Object.assign(c.ball, { x: r.path[0][0], y: r.mouth[0][1] + 14, vx: 0, vy: -470, ramp: null });
+                let entered = false;
+                for (let i = 0; i < 1000; i++) { m.update(c, m.STEP); if (c.ball?.ramp) entered = true; else if (entered) return; }
+                throw new Error(`rampa ${id} non completata`);
+            };
+            for (let i = 0; i < 3; i++) window.pinballShot('sinistra');
+        });
+        assert.equal(await page.evaluate(() => game.closeup.locks.length), 1);
+        await page.screenshot({ path: `${out}/${name}-lock.png` });
+        await page.evaluate(async () => {
+            for (let i = 0; i < 3; i++) window.pinballShot('destra');
+            const m = await import('/src/engine/flipper.js');
+            for (let i = 0; i < 4; i++) m.update(game.closeup, 0.2);
+        });
+        assert.equal(await page.evaluate(() => game.closeup.special), 'super');
+        await page.screenshot({ path: `${out}/${name}-super.png` });
+        const multi = await page.evaluate(async () => {
+            window.pinballShot('super');
+            const m = await import('/src/engine/flipper.js'), c = game.closeup;
+            window.pinballResume = game.update.bind(game); game.update = () => {};
+            window.pinballClassic = structuredClone(c); window.pinballClassic.transform = null;
+            (await import('/src/engine/render.js')).render(document.querySelector('#scene').getContext('2d'), game, { time: performance.now() });
+            m.update(c, 0.25); m.update(c, 0.2);
+            window.pinballExplosion = structuredClone(c);
+            return { balls: m.activeBalls(c).length, locks: c.locks.length, reserve: c.balls };
+        });
+        assert.deepEqual(multi, { balls: 3, locks: 0, reserve: 5 });
+        await page.screenshot({ path: `${out}/${name}-esplosione.png` });
+        await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js');
+            for (let i = 0; i < 6; i++) m.update(game.closeup, 0.25);
+        });
+        await page.screenshot({ path: `${out}/${name}-trasformazione.png` });
+        await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js');
+            for (let i = 0; i < 6; i++) m.update(game.closeup, 0.25);
+            window.pinballFuture = structuredClone(game.closeup);
+        });
+        assert.equal(await page.evaluate(() => game.closeup.table), 'future');
+        await page.screenshot({ path: `${out}/${name}-futuro.png` });
+        await page.screenshot({ path: `${out}/${name}-multiball.png` });
+        // Anche nel nuovo campo: due dita indipendenti, i due Shift e la pausa vera dell'applicazione.
+        if (mobile) {
+            await touch('touchStart', [P(250, 200), P(400, 200)]);
+            await page.waitForFunction(() => game.closeup.flippers.left.held.length && game.closeup.flippers.right.held.length);
+            await touch('touchEnd', []);
+        } else {
+            await page.keyboard.down('ShiftLeft'); await page.keyboard.down('ShiftRight');
+            await page.waitForFunction(() => game.closeup.flippers.left.held.length && game.closeup.flippers.right.held.length);
+        }
+        await page.evaluate(() => { game.update = window.pinballResume; });
+        await page.click('#pause-button');
+        const paused = await page.evaluate(() => ({ sim: game.closeup.sim, hits: game.closeup.future.hits, score: game.closeup.score }));
+        await page.waitForTimeout(250);
+        assert.deepEqual(await page.evaluate(() => ({ sim: game.closeup.sim, hits: game.closeup.future.hits, score: game.closeup.score })), paused);
+        assert.ok(await page.evaluate(() => !game.closeup.flippers.left.held.length && !game.closeup.flippers.right.held.length));
+        if (!mobile) { await page.keyboard.up('ShiftLeft'); await page.keyboard.up('ShiftRight'); }
+        await page.click('#resume');
+        await page.evaluate(() => { game.update = () => {}; Object.assign(game.closeup, structuredClone(window.pinballFuture)); });
+        // Stessa lettura sincrona dei pixel per classico, detonazione/trasformazione e futuro. Si svuota prima
+        // l'arretrato precedente; in gioco si riportano in alto solo le palline prossime alla buca per misurare
+        // tutti i 150 fotogrammi con tre palline, senza finire accidentalmente sul campo classico.
+        for (const mode of ['classico', 'esplosione', 'futuro']) {
+            const backlog = await page.evaluate(async mode => {
+                const m = await import('/src/engine/flipper.js'), r = await import('/src/engine/render.js'), c = game.closeup;
+                Object.assign(c, structuredClone(mode === 'classico' ? window.pinballClassic : mode === 'esplosione' ? window.pinballExplosion : window.pinballFuture));
+                const ctx = document.querySelector('#scene').getContext('2d');
+                r.render(ctx, game, { time: performance.now() }); ctx.getImageData(0, 0, 4, 4);
+                for (let i = 0; i < 150; i++) {
+                    if (mode !== 'esplosione') for (const [k, b] of m.activeBalls(c).entries()) {
+                        b.releaseAt = 0;
+                        if (b.y > 295) Object.assign(b, { x: 260 + k * 55, y: 200, vx: 20, vy: -150, ramp: null });
+                    }
+                    m.update(c, 1 / 60); r.render(ctx, game, { time: performance.now() });
+                }
+                const t = performance.now(); ctx.getImageData(0, 0, 4, 4); const ms = Math.round(performance.now() - t);
+                if (mode === 'futuro' && c.table !== 'future') throw new Error('misura uscita dal futuro');
+                return ms;
+            }, mode);
+            console.log(`${name}: arretrato grafico ${mode} dopo 150 fotogrammi ${backlog} ms`);
+            assert.ok(backlog < 1500, `${mode}: arretrato grafico ${backlog} ms`);
+        }
+        // Percorsi veri fino al finale: la schermata mostra sigilli caricati e il bersaglio mobile da colpire.
+        await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js'), c = game.closeup;
+            Object.assign(c, structuredClone(window.pinballFuture));
+            for (const b of c.extraBalls) b.releaseAt = c.sim + 1000;
+            for (const id of ['orbita', 'ponte', 'spira']) for (let i = 0; i < 2; i++) window.pinballShot(id);
+        });
+        assert.deepEqual(await page.evaluate(() => game.closeup.future.hits), { orbita: 2, ponte: 2, spira: 2 });
+        await page.screenshot({ path: `${out}/${name}-sigilli.png` });
+        await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js'), c = game.closeup;
+            Object.assign(c.ball, { x: 320 + Math.sin((c.sim + m.STEP) * 1.6) * 24, y: c.regolo.y + c.regolo.r + 4, vx: 0, vy: -250, ramp: null, contacts: [] });
+            m.update(c, m.STEP);
+        });
+        assert.equal(await page.evaluate(() => game.closeup.table), 'classic');
+        await page.evaluate(async () => {
+            (await import('/src/engine/render.js')).render(document.querySelector('#scene').getContext('2d'), game, { time: performance.now() });
+            const m = await import('/src/engine/flipper.js'); m.update(game.closeup, 0.25); m.update(game.closeup, 0.25);
+        });
+        await page.screenshot({ path: `${out}/${name}-ritorno.png` });
+        await page.waitForFunction(() => document.querySelector('#scene').style.backgroundImage.startsWith('url('));
+        await page.evaluate(() => { game.update = window.pinballResume; for (const key of ['pinballResume', 'pinballShot', 'pinballClassic', 'pinballExplosion', 'pinballFuture']) delete window[key]; });
+        // Si consumano le palline rimaste, compresa quella vinta, per arrivare al risultato reale.
+        const finalScore = await page.evaluate(async () => {
+            const m = await import('/src/engine/flipper.js'), c = game.closeup;
+            for (let i = 0; i < 12 && c.step === 'play'; i++) {
+                if (m.waiting(c)) m.launch(c, 0.8);
+                c.saveUntil = 0;
+                for (const ball of m.activeBalls(c)) Object.assign(ball, { x: 320, y: 348, vx: 0, vy: 300, ramp: null, releaseAt: 0 }); m.update(c, 0.1);
+            }
+            return c.score;
+        });
+        await page.waitForFunction(() => document.querySelector('#bocce-throw').textContent === 'Finita');
+        assert.ok((await page.locator('#bocce-status').textContent()).includes(`${finalScore} punti`));
+        await page.screenshot({ path: `${out}/${name}-fine.png` });
+        if (mobile) await page.locator('#closeup-close').click(); else await page.keyboard.press('Enter'); // Invio chiude il risultato
+        await page.waitForFunction(() => game.state.flags.flipper_vinto && !game.closeup);
+        await page.waitForFunction(() => document.querySelector('#scene').width === 640 && !document.querySelector('#scene').style.backgroundImage);
+        await page.close();
+    }
+    assert.deepEqual(errors, []);
+    console.log(`ok: schermate in ${out}`);
+} finally { await browser?.close(); server.kill(); }

tests/flipper.test.mjs

@@ -0,0 +1,595 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as m from '../src/engine/flipper.js';
+import { drawFlipper } from '../src/engine/flipper-render.js';
+import { Game } from '../src/engine/game.js';
+import { story } from '../src/story/story.js';
+import { settle } from './helpers.mjs';
+import { existsSync } from 'node:fs';
+
+const run = (c, secs) => { for (let i = 0; i < secs * 60; i++) m.update(c, 1 / 60); };
+const put = (c, ball) => Object.assign(c.ball, ball);
+// Osserva il percorso fino all'uscita, senza includere il tiro successivo sulla tavola.
+function ride(c, initial) {
+    put(c, initial);
+    let frames = 0, top = Infinity;
+    for (let i = 0; i < 4 / m.STEP; i++) {
+        m.update(c, m.STEP);
+        if (c.ball?.ramp) { frames++; top = Math.min(top, c.ball.y); }
+        else if (frames) return { frames, top, exit: { ...c.ball } };
+    }
+    assert.fail('la pallina non ha completato o abbandonato la rampa entro quattro secondi');
+}
+// Il giocatore automatico: alza il flipper quando la pallina gli scende addosso, come un umano attento.
+function autoplay(c, secs = 600) {
+    for (let i = 0; i < secs * 60 && c.step === 'play'; i++) {
+        if (m.waiting(c)) m.launch(c, 0.75);
+        const b = c.ball;
+        for (const side of ['left', 'right']) {
+            const [px, py] = m.PIVOT[side], dir = side === 'left' ? 1 : -1, rel = (b ? b.x - px : 0) * dir;
+            const near = b && !b.waiting && b.vy > 0 && b.y > py - 34 && b.y < py + 14 && rel > -6 && rel < 44;
+            if (near !== c.flippers[side].held.includes('ai')) m.hold(c, side, 'ai', near);
+        }
+        m.update(c, 1 / 60);
+    }
+}
+
+test('la tavola: tutto sta dentro il campo, le corsie coprono tutta la larghezza sotto l\'arco, i funghi sui dischi del disegno', () => {
+    const c = m.newFlipper(1);
+    for (const w of c.walls) for (const [x, y] of [w.a, w.b]) assert.ok(x >= m.FIELD.x0 && x <= m.FIELD.x1 && y >= m.FIELD.y0 && y <= m.FIELD.y1, `${w.a}-${w.b}`);
+    // I tre dischi dipinti da Codex (misurati sull'immagine): i funghi ci stanno sopra, a meno di 3 pixel.
+    for (const [b, [x, y]] of c.bumpers.map((b, i) => [b, [[281, 120], [360, 120], [320, 153]][i]])) assert.ok(Math.hypot(b.x - x, b.y - y) < 3);
+    assert.equal(c.lanes.length, 4); assert.deepEqual(c.lanes.map(l => l.rione), m.RIONI);
+    assert.equal(c.lanes[0].x0, m.FIELD.x0); assert.equal(c.lanes[3].x1, m.LANE.x0);
+    for (let i = 1; i < 4; i++) assert.equal(c.lanes[i].x0, c.lanes[i - 1].x1, 'corsie contigue');
+    assert.equal(c.targets.length, 6); assert.equal(c.balls, m.BALLS);
+    assert.ok(m.waiting(c) && m.canThrow(c) && c.ball.x > m.LANE.x0, 'la pallina aspetta sulla molla');
+});
+
+test('il lancio: anche la molla più fiacca arriva in campo, quella forte fa il giro dell\'arco; la ricaduta si rilancia', () => {
+    for (const level of ['bona', 'male']) for (const power of [0, 0.5, 1]) {
+        const c = m.newFlipper(2, { level }); assert.ok(m.launch(c, power)); assert.ok(!m.waiting(c));
+        let top = 999, out = false;
+        for (let i = 0; i < 180; i++) { m.update(c, 1 / 60); top = Math.min(top, c.ball?.y ?? 999); if (c.ball && c.ball.x < m.LANE.x0 - 30) out = true; }
+        assert.ok(top < 50, `${level} forza ${power}: in cima (${top.toFixed(0)})`);
+        assert.ok(out, `${level} forza ${power}: entrata in campo`);
+    }
+    // Una pallina ricaduta nella corsia si assesta e si rilancia, senza perderla.
+    const d = m.newFlipper(3, { level: 'bona' }); m.launch(d, 0.5); put(d, { x: 440, y: 200, vx: 0, vy: 50 }); run(d, 3);
+    assert.ok(m.waiting(d) && d.balls === m.BALLS, 'tornata sulla molla, nessuna pallina persa');
+});
+
+test('la pallina persa: tre palline, poi il risultato; il salvataggio vale una volta sola e non dipende dal fotogramma', () => {
+    const c = m.newFlipper(4, { level: 'seria' });
+    for (let n = 3; n >= 1; n--) {
+        assert.equal(c.balls, n);
+        m.launch(c, 0.9); c.saveUntil = 0; // niente salvataggio: si prova sotto
+        put(c, { x: 320, y: 320, vx: 0, vy: 200 }); run(c, 1);
+    }
+    assert.equal(c.step, 'result'); assert.equal(c.result.winner, 'cpu'); assert.ok(!m.canThrow(c));
+    assert.match(m.status(c), /Ne servivano 120000/);
+    const d = m.newFlipper(5, { level: 'bona' });
+    m.launch(d, 0.9); assert.ok(m.saveLeft(d) > 7); put(d, { x: 320, y: 320, vx: 0, vy: 200 }); run(d, 1);
+    assert.ok(m.waiting(d) && d.balls === 3, 'salvata: la pallina torna sulla molla');
+    assert.match(d.line ?? '', /SALVATA/);
+    m.launch(d, 0.9); assert.equal(m.saveLeft(d), 0); put(d, { x: 320, y: 320, vx: 0, vy: 200 }); run(d, 1);
+    assert.equal(d.balls, 2, 'la seconda volta è persa davvero');
+    // Lo stesso quarto di secondo, a passi piccoli o in un fotogramma solo: stesso esito (Codex).
+    for (const dts of [[1 / 240, 60], [1 / 60, 15], [0.25, 1]]) {
+        const e = m.newFlipper(6, { level: 'seria' }); m.launch(e, 0.8); e.sim = 2.9; e.saveUntil = 3; put(e, { x: 320, y: 344, vx: 0, vy: 100 });
+        for (let i = 0; i < dts[1]; i++) m.update(e, dts[0]);
+        assert.equal(e.balls, 3, `salvata con passi da ${dts[0]}`);
+    }
+});
+
+test('il flipper alzato rimanda su la pallina, anche a tutta velocità (niente attraversamenti); abbassato la lascia scendere', () => {
+    const up = m.newFlipper(6, { level: 'seria' }); m.launch(up, 0.9);
+    put(up, { x: 300, y: 300, vx: 0, vy: 150 }); m.hold(up, 'left', 'test', true);
+    let best = 0; for (let i = 0; i < 60; i++) { m.update(up, 1 / 60); best = Math.min(best, up.ball?.vy ?? 0); }
+    assert.ok(best < -250, `tirata su (vy ${best.toFixed(0)})`);
+    assert.ok(up.events.some(e => e.kind === 'flipper-flip'));
+    // Il caso riprodotto da Codex: pallina a 980 px/s sulla punta del flipper che si alza.
+    const fast = m.newFlipper(6, { level: 'seria' }); m.launch(fast, 0.9);
+    put(fast, { x: 313.438, y: 323.71, vx: -469.837, vy: 860.031 }); m.hold(fast, 'left', 'test', true);
+    m.update(fast, m.STEP);
+    assert.ok(fast.ball.vy < 0 && fast.ball.y < 324, `respinta, non passata sotto (y ${fast.ball.y.toFixed(1)}, vy ${fast.ball.vy.toFixed(0)})`);
+    const down = m.newFlipper(6, { level: 'seria' }); m.launch(down, 0.9);
+    put(down, { x: 300, y: 300, vx: 0, vy: 150 }); down.saveUntil = 0; run(down, 2);
+    assert.equal(down.balls, 2, 'senza flipper, giù nella Sieve');
+});
+
+test('funghi, bersagli, Regolo e corsie fanno punti solo a un urto nuovo; le quattro corsie insieme il Palio', () => {
+    const c = m.newFlipper(7, { level: 'bona' }); m.launch(c, 0.9);
+    const b = c.bumpers[0];
+    put(c, { x: b.x, y: b.y + b.r + 6, vx: 0, vy: -200 }); m.update(c, 1 / 60); m.update(c, 1 / 60);
+    assert.equal(c.score, m.SCORE.bumper); assert.ok(c.ball.vy > 0 && b.hit > 0, 'respinta');
+    assert.ok(c.events.some(e => e.kind === 'flipper-fungo'));
+    // La pallina appoggiata sul Regolo (Codex: 240.000 punti in un secondo): non conta.
+    c.score = 0; put(c, { x: c.regolo.x, y: c.regolo.y - c.regolo.r - m.R, vx: 0, vy: 0 });
+    for (let i = 0; i < 240; i++) m.update(c, m.STEP);
+    assert.equal(c.score, 0, 'il contatto che dura non fa punti');
+    put(c, { x: c.regolo.x, y: c.regolo.y + 12, vx: 0, vy: -200 }); m.update(c, 1 / 60); m.update(c, 1 / 60);
+    assert.equal(c.score, m.SCORE.regolo);
+    c.score = 0;
+    for (const t of c.targets.filter(k => k.bank === 'pieve')) { const before = c.score; put(c, { x: t.a[0] + 10, y: (t.a[1] + t.b[1]) / 2, vx: -300, vy: 0 }); m.update(c, 1 / 60); m.update(c, 1 / 60); assert.ok(c.score > before, `caduto il ${t.i}`); }
+    assert.equal(c.score, 3 * m.SCORE.target + m.SCORE.bank);
+    assert.ok(c.targets.filter(k => k.bank === 'pieve').every(t => t.down), 'la fila resta giù un attimo');
+    put(c, { x: 260, y: 230, vx: 0, vy: 0 }); run(c, 1);
+    assert.ok(c.targets.filter(k => k.bank === 'pieve').every(t => !t.down), 'poi si rialza');
+    assert.ok([c.line, ...c.lines].some(l => /PIEVE/.test(l ?? '')), 'la scritta della Pieve (in coda dietro al Regolo)');
+    // Le corsie: contano attraversando la riga, anche fuori centro (Codex: a x=287 non si accendeva).
+    c.score = 0;
+    for (const [i, x] of [[0, 230], [1, 287], [2, 335], [3, 420]]) {
+        put(c, { x, y: c.lanes[i].y - 3, vx: 0, vy: 150 }); run(c, 0.1);
+        assert.ok(c.lanes[i].lit || c.lanes.every(k => !k.lit), c.lanes[i].rione);
+    }
+    assert.ok(c.score >= 4 * m.SCORE.lane + m.SCORE.palio, `corsie e Palio (${c.score}; in più, al massimo, un fungo sfiorato)`);
+    assert.ok([c.line, ...c.lines].some(l => /PALIO/.test(l ?? ''))); assert.ok(c.lanes.every(l => !l.lit), 'si rispegne per un altro giro');
+    // In salita non conta.
+    put(c, { x: 287, y: c.lanes[1].y + 6, vx: 0, vy: -150 }); m.update(c, 1 / 60); m.update(c, 1 / 60);
+    assert.ok(!c.lanes[1].lit);
+});
+
+test('comandi: la molla si carica al centro e si lancia lasciando, ai lati le palette anche prima del lancio; annullare non lancia; due dita, pulsanti e tasti', () => {
+    const c = m.newFlipper(8, { level: 'bona' });
+    // A pallina ferma i lati alzano le palette, il centro carica la molla.
+    m.aimScreen(c, [120, 300]); assert.ok(m.press(c, 5)); assert.ok(c.flippers.left.held.includes(5) && !c.holding, 'a sinistra, la paletta');
+    m.aimScreen(c, [520, 300]); assert.ok(m.press(c, 6)); assert.ok(c.flippers.right.held.includes(6) && !c.holding, 'a destra, la paletta');
+    m.release(c, 5); m.release(c, 6); assert.ok(m.waiting(c));
+    m.aimScreen(c, [320, 320]); assert.ok(m.press(c, 1)); run(c, 0.6);
+    assert.ok(c.holding && c.power > 0.4 && c.power < 0.6, `molla a ${c.power.toFixed(2)}`);
+    assert.ok(!m.release(c, 2), 'un altro dito non lancia');
+    m.cancel(c, 1); assert.ok(m.waiting(c) && !c.holding, 'annullata la carica: niente lancio');
+    m.aimScreen(c, [300, 320]); m.press(c, 1); run(c, 0.6); assert.ok(m.release(c, 1)); assert.ok(!m.waiting(c));
+    m.aimScreen(c, [250, 200]); assert.ok(m.press(c, 3)); assert.ok(c.flippers.left.held.includes(3));
+    m.aimScreen(c, [400, 200]); assert.ok(m.press(c, 4)); assert.ok(c.flippers.right.held.includes(4));
+    assert.ok(m.release(c, 3)); assert.ok(!c.flippers.left.held.length && c.flippers.right.held.includes(4));
+    m.cancel(c); assert.ok(!c.flippers.right.held.length, 'annullare tutto (pausa) lascia i flipper');
+    // I pulsanti e le frecce; il pulsante da tastiera dà un colpo breve che la fisica vede.
+    assert.ok(m.turn(c, -1, 'button')); assert.ok(c.flippers.left.held.length); assert.ok(m.stopTurn(c, 'button')); assert.ok(!c.flippers.left.held.length);
+    m.turn(c, 1, 'click'); m.stopTurn(c, 'click'); assert.ok(c.flippers.right.held.includes('click'));
+    const a0 = c.flippers.right.angle; run(c, 0.1); assert.notEqual(c.flippers.right.angle, a0, 'il flipper si è mosso'); run(c, 0.3); assert.ok(!c.flippers.right.held.length);
+    assert.ok(m.key(c, 'ArrowRight', true)); assert.ok(c.flippers.right.held.length); m.key(c, 'ArrowRight', false); assert.ok(!c.flippers.right.held.length);
+    assert.ok(m.key(c, 'ShiftLeft', true)); assert.ok(c.flippers.left.held.includes('key-ShiftLeft') && !c.flippers.right.held.length);
+    m.key(c, 'ShiftRight', true); assert.ok(c.flippers.right.held.includes('key-ShiftRight'));
+    m.key(c, 'ShiftLeft', false); m.key(c, 'ShiftRight', false); assert.ok(!c.flippers.left.held.length && !c.flippers.right.held.length);
+    assert.ok(!m.key(c, 'x', true));
+    assert.ok(!m.setPower(c, 0.3), 'in gioco il cursore della molla non vale');
+    // Spazio: carica e lancia; Invio: lancia con la forza del cursore; a partita finita i tasti non sono suoi.
+    const d = m.newFlipper(9); assert.ok(m.key(d, ' ', true)); run(d, 0.3); assert.ok(d.holding); m.key(d, ' ', false); assert.ok(!m.waiting(d));
+    const g = m.newFlipper(11); assert.ok(m.key(g, 'ArrowDown', true)); run(g, 0.3); assert.ok(g.holding, 'anche la freccia giù carica la molla'); m.key(g, 'ArrowDown', false); assert.ok(!m.waiting(g));
+    const e = m.newFlipper(10); assert.ok(m.setPower(e, 0.5)); assert.equal(m.button(e), 'Lancia'); m.key(e, 'Enter', true); assert.ok(!m.waiting(e)); assert.equal(m.button(e), 'In gioco…');
+    e.step = 'result'; e.result = { winner: 'cpu', score: 0, goal: 120000 }; assert.ok(!m.key(e, ' ', true) && !m.key(e, 'Enter', true));
+});
+
+test('il traguardo è acquisito appena raggiunto: anche uscendo prima, si vince; la trattenuta sul flipper non viene scossa', () => {
+    const c = m.newFlipper(11, { level: 'bona' }); m.launch(c, 0.9);
+    c.score = c.skill.goal - 100; put(c, { x: c.regolo.x, y: c.regolo.y + 12, vx: 0, vy: -200 }); m.update(c, 1 / 60); m.update(c, 1 / 60);
+    assert.ok(c.result && c.result.winner === 'player' && c.step === 'play', 'traguardo fatto, si continua');
+    assert.match(m.status(c), /record/);
+    const g = new Game(story); g.go('via_provinciale'); settle(g);
+    g.act('use', 'river'); settle(g); g.choose(g.options().findIndex(o => o.text.startsWith('Una partita alla bona'))); settle(g);
+    g.closeup.score = 70000; g.closeup.result = { winner: 'player', score: 70000, goal: 60000 };
+    g.closeupClose(); settle(g);
+    assert.ok(g.state.flags.flipper_vinto, 'uscito dopo il traguardo: vinto');
+    // La pallina trattenuta sul flipper alzato resta lì (niente scossa): è una mossa del giocatore.
+    const h = m.newFlipper(12, { level: 'bona' }); m.launch(h, 0.9); m.hold(h, 'left', 't', true); run(h, 0.5);
+    put(h, { x: 296, y: 300, vx: 0, vy: 0 }); run(h, 4);
+    assert.ok(h.ball && !h.ball.waiting && h.ball.y > 280 && h.ball.x < 320, `ancora sul flipper (${h.ball?.x.toFixed(0)}, ${h.ball?.y.toFixed(0)})`);
+});
+
+test('il traguardo assegna una sola pallina premio, utilizzabile anche se si era all\'ultima, a tutti i livelli', () => {
+    for (const level of Object.keys(m.LEVELS)) for (const missing of [m.SCORE.bumper, 500]) {
+        const c = m.newFlipper(85, { level }); m.launch(c, 0.8);
+        c.balls = 1; c.score = c.skill.goal - missing;
+        const currentBall = c.ball, b = c.bumpers[0];
+        put(c, { x: b.x, y: b.y + b.r + 6, vx: 0, vy: -200 }); run(c, 0.05);
+        assert.equal(c.balls, 2, `${level}: una pallina in più, raggiungendo o superando la soglia`);
+        assert.equal(c.ball, currentBall, 'il tiro in corso prosegue');
+        assert.equal(c.step, 'play'); assert.equal(c.result.winner, 'player');
+        assert.equal(c.line, 'TRAGUARDO!'); assert.equal(c.lines[0], 'PALLINA +1');
+        assert.match(m.status(c), /pallina premio vinta/);
+        put(c, { x: c.regolo.x, y: c.regolo.y + 12, vx: 0, vy: -200 }); run(c, 0.05);
+        assert.ok(c.score > c.skill.goal); assert.equal(c.balls, 2, 'altri punti non assegnano altri premi');
+        c.saveUntil = 0; put(c, { x: 320, y: 342, vx: 0, vy: 300, ramp: null }); run(c, 0.1);
+        assert.equal(c.balls, 1); assert.ok(m.waiting(c), 'persa l\'ultima originale, si può lanciare la pallina premio');
+        m.launch(c, 0.8); c.saveUntil = 0;
+        put(c, { x: 320, y: 342, vx: 0, vy: 300 }); run(c, 0.1);
+        assert.equal(c.balls, 0); assert.equal(c.step, 'result'); assert.equal(c.result.winner, 'player');
+    }
+});
+
+test('i ponti: imboccati forte si sale, si passa sopra la tavola e si scende nella corsia di ritorno; piano si ricasca; di traverso no; tutti e due di fila, i PONTI', () => {
+    const c = m.newFlipper(13, { level: 'bona' }); m.launch(c, 0.9); c.score = 0;
+    const { frames: onRamp, top, exit } = ride(c, { x: 273, y: 240, vx: 0, vy: -470 });
+    assert.ok(onRamp > 20, 'è salita sul ponte'); assert.ok(top < 40, 'fin sopra la tavola');
+    assert.ok(exit && exit.x > 400 && exit.x < 420, `scesa nella corsia di ritorno di destra (${exit?.x.toFixed(0)})`);
+    assert.equal(c.score, m.SCORE.ramp); assert.equal(c.line, 'PONTE SX'); assert.deepEqual(c.lines, ['+15000']); assert.ok(c.ramps[0].lit > 0);
+    assert.ok(c.events.some(e => e.kind === 'flipper-rampa'));
+    // Mentre è sul ponte i flipper rispondono lo stesso (Codex: restavano congelati).
+    const f = m.newFlipper(13, { level: 'bona' }); m.launch(f, 0.9); put(f, { x: 273, y: 240, vx: 0, vy: -470 }); run(f, 0.3);
+    assert.ok(f.ball.ramp, 'sul ponte'); m.turn(f, -1, 'click'); run(f, 0.1);
+    assert.ok(f.flippers.left.angle < 0.3, `il flipper si è alzato (${f.flippers.left.angle.toFixed(2)})`);
+    // Il secondo ponte subito dopo: i PONTI, col bonus.
+    ride(c, { x: 367, y: 240, vx: 0, vy: -470, ramp: null });
+    assert.equal(c.score, 2 * m.SCORE.ramp + m.SCORE.ponti, `i ponti (${c.score})`);
+    assert.ok([c.line, ...c.lines].some(l => l === 'I PONTI!') && [c.line, ...c.lines].some(l => /BONUS/.test(l ?? '')));
+    assert.equal(c.lastRamp, null, 'la combo è spesa');
+    // Troppo piano: sale un po', non ce la fa, ricasca dall'imbocco senza punti.
+    const d = m.newFlipper(14, { level: 'bona' }); m.launch(d, 0.9); d.score = 0;
+    put(d, { x: 273, y: 240, vx: 0, vy: -280 }); let climbed = false; for (let i = 0; i < 300; i++) { m.update(d, 1 / 60); if (d.ball.ramp) climbed = true; }
+    assert.ok(climbed, 'è salita'); assert.ok(!d.ball.ramp && d.ball.y > 226, 'ricaduta'); assert.ok(d.score < m.SCORE.ramp, 'niente punti del ponte');
+    // Di traverso (Codex: sfiorando l'imbocco quasi in orizzontale saliva lo stesso): no.
+    const e = m.newFlipper(15, { level: 'bona' }); m.launch(e, 0.9); e.score = 0;
+    put(e, { x: 273, y: 226.1, vx: 500, vy: -30 }); run(e, 0.5);
+    assert.ok(!e.ball.ramp && e.score < m.SCORE.ramp, 'non è salita');
+    // La combo scade dopo dodici secondi, e si azzera perdendo la pallina.
+    const g = m.newFlipper(16, { level: 'bona' }); m.launch(g, 0.9); g.lastRamp = { id: 'sinistra', at: g.sim }; put(g, { x: 320, y: 200, vx: 0, vy: 0 });
+    run(g, 13); assert.equal(g.lastRamp, null, 'scaduta');
+    g.lastRamp = { id: 'sinistra', at: g.sim }; g.saveUntil = 0; put(g, { x: 320, y: 342, vx: 0, vy: 300, waiting: false }); run(g, 1);
+    assert.equal(g.balls, 2); assert.equal(g.lastRamp, null, 'azzerata con la pallina persa');
+});
+
+test('le rampe centrali si prendono con tiri obliqui dalle palette e anche fuori centro, a tutti i livelli', () => {
+    for (const level of Object.keys(m.LEVELS)) for (const [index, side] of [[0, -1], [1, 1]]) {
+        const c = m.newFlipper(81, { level }); m.launch(c, 0.8);
+        ride(c, { x: 320 + side * 20, y: 290, vx: side * 90, vy: -460 });
+        assert.equal(c.score, m.SCORE.ramp, `${level}: tiro obliquo dalla zona delle palette, lato ${side}`);
+        assert.ok(c.ramps[index].lit > 0);
+        for (const offset of [-12, 12]) {
+            const d = m.newFlipper(82, { level }); m.launch(d, 0.8);
+            const r = d.ramps[index];
+            ride(d, { x: r.path[0][0] + offset, y: r.mouth[0][1] + 1, vx: 0, vy: -330 });
+            assert.equal(d.score, m.SCORE.ramp, `${level}: basta un colpo medio, decentrato di ${offset}`);
+        }
+        const e = m.newFlipper(83, { level }); m.launch(e, 0.8);
+        const r = e.ramps[index];
+        put(e, { x: r.mouth[0][0] + m.R - 1, y: r.mouth[0][1] + 1, vx: 0, vy: -330 }); run(e, 0.05);
+        assert.equal(e.ball.ramp, null, 'fuori dalla bocca disegnata la pallina non viene catturata');
+    }
+});
+
+test('le uscite laterali sono più strette: i tiri vicini rientrano verso le palette, quelli esterni si perdono ancora', () => {
+    for (const [x, safe] of [[218, true], [419, true], [207, false], [426, false]]) {
+        const c = m.newFlipper(84); m.launch(c, 0.8); c.saveUntil = 0;
+        put(c, { x, y: 250, vx: 0, vy: 100 });
+        let lower = null;
+        for (let i = 0; i < 2 / m.STEP && c.balls === 3; i++) {
+            m.update(c, m.STEP);
+            if (!lower && c.ball?.y >= 300) lower = { x: c.ball.x };
+        }
+        assert.ok(lower, `la pallina ${x} non resta incastrata nella corsia`);
+        if (safe) assert.ok(lower.x > 250 && lower.x < 390, `${x} torna verso le palette (${lower.x})`);
+        else { assert.equal(lower.x, x, 'la corsia esterna resta aperta'); assert.equal(c.balls, 2); }
+    }
+});
+
+test('gli effetti: ogni colpo lascia il suo segno (anello, scintille, punti che volano, coriandoli, luci sui ponti, scossa), e dopo un po\' sparisce', () => {
+    const c = m.newFlipper(17, { level: 'bona' }); m.launch(c, 0.9);
+    const kinds = () => c.fx.map(f => f.kind);
+    const b = c.bumpers[0]; put(c, { x: b.x, y: b.y + b.r + 6, vx: 0, vy: -200 }); run(c, 0.05);
+    assert.ok(kinds().includes('ring') && kinds().includes('pop') && kinds().includes('spark'), `fungo: ${kinds()}`);
+    assert.equal(c.fx.find(f => f.kind === 'pop').text, '+1000');
+    c.fx.length = 0; c.score = c.skill.goal - 100; put(c, { x: c.regolo.x, y: c.regolo.y + 12, vx: 0, vy: -200 }); run(c, 0.05);
+    assert.ok(kinds().includes('burst') && kinds().includes('wash') && kinds().includes('shake'), `traguardo: ${kinds()}`);
+    c.fx.length = 0; ride(c, { x: 273, y: 240, vx: 0, vy: -470 });
+    assert.ok(kinds().includes('chase'), `ponte: ${kinds()}`);
+    assert.ok(c.trail.length > 5, 'la cometa');
+    const ball = c.ball; c.ball = null; run(c, m.FX_LIFE + 0.1); c.ball = ball;
+    assert.equal(c.fx.length, 0, 'spariti');
+    // Disegnarli non cambia niente.
+    const calls = [], gradient = { addColorStop() {} };
+    const ctx = new Proxy({}, { get: (o, k) => k in o ? o[k] : (...args) => { calls.push([k, ...args]); return gradient; }, set: (o, k, v) => { o[k] = v; return true; } });
+    put(c, { x: 273, y: 240, vx: 0, vy: -470 }); run(c, 0.4); c.fx.push({ kind: 'burst', x: 320, y: 100, t: c.visual.time, big: true }, { kind: 'shake', x: 0, y: 0, t: c.visual.time });
+    const before = structuredClone(c); drawFlipper(ctx, c, story.closeups.flipper, {}); assert.deepEqual(c, before);
+    assert.ok(calls.some(([op]) => op === 'translate'), 'la scossa sposta la scena');
+});
+
+function rampShot(c, id) {
+    if (m.waiting(c)) m.launch(c, 0.8);
+    const r = c.ramps.find(r => r.id === id);
+    return ride(c, { x: r.path[0][0], y: r.mouth[0][1] + 14, vx: 0, vy: -470, ramp: null, waiting: false });
+}
+function doubleLock(c) { for (const id of ['sinistra', 'destra']) for (let n = 0; n < 3; n++) rampShot(c, id); }
+
+test('due LOCK aprono la SUPER SPECIAL: jackpot, pallina premio e multiball reale a tre, in ogni ordine', () => {
+    for (const level of Object.keys(m.LEVELS)) for (const ids of [['sinistra', 'destra'], ['destra', 'sinistra']]) {
+        const c = m.newFlipper(21, { level }); m.launch(c, 0.9);
+        const superRamp = c.ramps.find(r => r.id === 'super');
+        assert.ok(!m.rampOpen(c, superRamp));
+        rampShot(c, ids[0]); assert.equal(c.rampRun.count, 1);
+        rampShot(c, ids[0]); assert.equal(c.rampRun.count, 2);
+        rampShot(c, ids[0]);
+        assert.equal(c.locks.length, 1); assert.equal(c.locks[0].rampId, ids[0]);
+        assert.equal(c.special, ids[1]); assert.ok(m.waiting(c)); assert.equal(c.balls, 3);
+        const lockedBall = c.locks[0].ball;
+        rampShot(c, ids[0]); assert.equal(c.locks.length, 1, 'una rampa occupata non produce altri lock');
+        const score = c.score; rampShot(c, ids[1]);
+        assert.equal(c.score - score, m.SCORE.ramp + m.SCORE.jackpot, 'SPECIAL paga una volta e avvia il secondo lock');
+        assert.equal(c.locks[0].ball, lockedBall); assert.equal(c.rampRun.count, 1);
+        const afterSpecial = c.score; rampShot(c, ids[1]);
+        assert.equal(c.score - afterSpecial, m.SCORE.ramp, 'niente jackpot ripetuti durante la carica');
+        rampShot(c, ids[1]);
+        assert.equal(c.locks.length, 2); assert.equal(c.special, 'super'); assert.ok(m.rampOpen(c, superRamp));
+        assert.ok(m.waiting(c)); assert.equal(c.extraBalls.length, 0);
+        const before = c.score, reserve = c.balls, hadGoal = !!c.result;
+        rampShot(c, 'super');
+        assert.equal(c.score - before, m.SCORE.super);
+        assert.equal(c.balls, reserve + 1 + (hadGoal ? 0 : 1), 'premio SUPER, più il traguardo se appena superato');
+        assert.equal(c.locks.length, 0); assert.equal(c.special, null);
+        assert.equal(m.activeBalls(c).length, 3); assert.ok(m.multiball(c));
+        assert.equal(new Set(m.activeBalls(c)).size, 3, 'tre palline distinte');
+        assert.ok(c.events.some(e => e.kind === 'flipper-super'));
+        assert.ok(c.transform, 'la SUPER avvia la trasformazione');
+        run(c, m.FUTURE.duration);
+        assert.equal(c.table, 'future');
+        const lives = c.balls;
+        for (const b of m.activeBalls(c)) b.releaseAt = 0;
+        // Metti tutte le palline sotto il campo nello stesso passo: la vita si scala una volta soltanto.
+        for (const ball of m.activeBalls(c)) Object.assign(ball, { x: 320, y: 348, vx: 0, vy: 300, ramp: null, waiting: false, releaseAt: 0 });
+        c.saveUntil = 0; m.update(c, m.STEP);
+        assert.equal(c.balls, lives - 1); assert.equal(c.extraBalls.length, 0); assert.ok(m.waiting(c));
+        assert.equal(c.table, 'classic', 'persa l’ultima si torna al River');
+    }
+});
+
+test('la finestra LOCK scade in simulazione, cambiare rampa interrompe la serie e la SUPER chiusa non cattura', () => {
+    const c = m.newFlipper(22); m.launch(c, 0.8);
+    put(c, { x: 320, y: 233, vx: 0, vy: -400 }); run(c, 0.02);
+    assert.equal(c.ball.ramp, null, 'la rampa centrale chiusa non esiste nella fisica');
+    rampShot(c, 'sinistra'); rampShot(c, 'sinistra');
+    c.ball.waiting = true; run(c, m.RAMP.lockWindow + 0.1);
+    assert.equal(c.rampRun.count, 0); rampShot(c, 'sinistra'); assert.equal(c.rampRun.count, 1);
+    rampShot(c, 'destra'); assert.equal(c.rampRun.id, 'destra'); assert.equal(c.rampRun.count, 1);
+    c.saveUntil = 0; put(c, { x: 320, y: 348, vx: 0, vy: 300, ramp: null }); m.update(c, m.STEP);
+    assert.equal(c.rampRun.count, 0);
+});
+
+test('la trasformazione protegge le tre palline, poi le libera sfalsate verso le palette', () => {
+    for (const level of Object.keys(m.LEVELS)) {
+        const c = m.newFlipper(77, { level }); doubleLock(c); rampShot(c, 'super');
+        const before = m.activeBalls(c).map(b => [b.x, b.y]), score = c.score, lives = c.balls;
+        run(c, 0.8); assert.deepEqual(m.activeBalls(c).map(b => [b.x, b.y]), before);
+        assert.equal(c.score, score); assert.equal(c.balls, lives);
+        run(c, m.FUTURE.duration - 0.8);
+        assert.equal(c.table, 'future'); assert.equal(c.transform, null);
+        const main = c.ball, delayed = c.extraBalls.at(-1), position = [delayed.x, delayed.y];
+        assert.ok(delayed.releaseAt > c.sim);
+        run(c, 0.2); assert.deepEqual([delayed.x, delayed.y], position);
+        // Isola la prima pallina per verificare il recupero dalla paletta, senza alterare la geometria.
+        const d = structuredClone(c); d.extraBalls = [];
+        let recovered = false;
+        for (let i = 0; i < 480; i++) {
+            if (d.ball.x > 284 && d.ball.y > 300) m.hold(d, 'left', 'test', true);
+            m.update(d, m.STEP);
+            if (d.ball.vy < -250) { recovered = true; break; }
+        }
+        assert.ok(recovered, `${level}: prima pallina ripresa dalla paletta`);
+        run(c, 1); assert.notDeepEqual([delayed.x, delayed.y], position);
+        assert.ok(Number.isFinite(main.x));
+    }
+});
+
+test('perdere una sostitutiva restituisce un lock alla volta senza consumare vite; la SUPER si richiude', () => {
+    const c = m.newFlipper(23, { level: 'male' }); doubleLock(c);
+    const lives = c.balls;
+    for (const remaining of [1, 0]) {
+        m.launch(c, 0.8); c.saveUntil = 0;
+        put(c, { x: 320, y: 348, vx: 0, vy: 300, ramp: null }); m.update(c, m.STEP);
+        assert.equal(c.locks.length, remaining); assert.equal(c.balls, lives); assert.ok(m.waiting(c));
+        assert.notEqual(c.special, 'super'); assert.equal(c.superOpenedAt, null);
+    }
+    assert.equal(c.special, null); assert.equal(c.specialPaid, false);
+});
+
+test('il multiball ha contatti indipendenti, urti fra palline e palette che avanzano una sola volta', () => {
+    const c = m.newFlipper(24); doubleLock(c); rampShot(c, 'super'); run(c, m.FUTURE.duration);
+    for (const b of m.activeBalls(c)) b.releaseAt = 0;
+    const single = m.newFlipper(24); m.hold(single, 'left', 'test', true); m.hold(c, 'left', 'test', true);
+    m.update(single, m.STEP); m.update(c, m.STEP);
+    assert.ok(Math.abs(c.flippers.left.angle - single.flippers.left.angle) < 1e-10);
+    const [a, b, spare] = m.activeBalls(c), bumper = c.bumpers[0];
+    spare.waiting = true;
+    Object.assign(a, { x: bumper.x, y: bumper.y + bumper.r + 4, vx: 0, vy: -200, ramp: null, contacts: [] });
+    Object.assign(b, { x: bumper.x, y: bumper.y - bumper.r - 4, vx: 0, vy: 200, ramp: null, contacts: [] });
+    const score = c.score; m.update(c, m.STEP);
+    assert.equal(c.score - score, m.SCORE.bumper * 2, 'due urti sullo stesso fungo contano separatamente');
+    Object.assign(a, { x: 310, y: 275, vx: 100, vy: 0 });
+    Object.assign(b, { x: 318, y: 275, vx: -100, vy: 0 });
+    m.update(c, m.STEP); assert.ok(a.vx < 0 && b.vx > 0, 'le palline si respingono');
+    const lives = c.balls;
+    Object.assign(a, { x: 320, y: 348, vx: 0, vy: 300 }); m.update(c, m.STEP);
+    assert.equal(c.balls, lives); assert.equal(m.activeBalls(c).length, 2);
+});
+
+test('i bersagli alzano il jackpot fino a x3 e la valvola impedisce il rientro sulla molla', () => {
+    const c = m.newFlipper(25); m.launch(c, 0.8);
+    for (const bank of ['pieve', 'torre']) for (let i = 0; i < 3; i++) {
+        const t = c.targets.find(t => t.bank === bank && t.i === i), dir = bank === 'pieve' ? -1 : 1;
+        put(c, { x: t.a[0] - dir * 5, y: (t.a[1] + t.b[1]) / 2, vx: dir * 200, vy: 0, ramp: null }); run(c, 0.02);
+    }
+    assert.equal(c.jackpotX, 3); doubleLock(c);
+    const before = c.score; rampShot(c, 'super'); assert.equal(c.score - before, m.SCORE.super * 3);
+    for (const [x, y] of [[434, 52], [438, 52], [441, 56]]) {
+        const d = m.newFlipper(26); m.launch(d, 0.8);
+        put(d, { x, y, vx: 0, vy: 240, inPlay: true });
+        let enteredShooter = false;
+        for (let i = 0; i < 240; i++) { m.update(d, m.STEP); if (d.ball.x > m.LANE.x0 + m.R && d.ball.y > 76) enteredShooter = true; }
+        assert.ok(!enteredShooter, `valvola chiusa per il ritorno a x=${x}`);
+    }
+});
+
+test('giocando con attenzione, alla bona si arriva al traguardo; nessuna partita si incastra', () => {
+    let won = 0;
+    for (let seed = 1; seed <= 8; seed++) {
+        const c = m.newFlipper(seed * 7919, { level: 'bona' });
+        autoplay(c);
+        assert.equal(c.step, 'result', `seme ${seed}: finita`);
+        if (c.result.winner === 'player') won++;
+    }
+    assert.ok(won >= 5, `vinte ${won} su 8`);
+});
+
+test('il disegno del flipper non cambia lo stato; il tabellone dice l\'esito giusto e le cifre corrono', async () => {
+    const calls = [], gradient = { addColorStop() {} };
+    const ctx = new Proxy({}, { get: (o, k) => k in o ? o[k] : (...args) => { calls.push([k, ...args]); return gradient; }, set: (o, k, v) => { o[k] = v; return true; } });
+    const c = m.newFlipper(11, { level: 'bona' }), bg = {};
+    const draw = () => { const before = structuredClone(c); drawFlipper(ctx, c, story.closeups.flipper, bg); assert.deepEqual(c, before); };
+    draw(); assert.ok(calls.some(([op, img]) => op === 'drawImage' && img === bg));
+    assert.ok(calls.filter(([op]) => op === 'arc').every(([, , , r]) => r > 0), 'anche viti e inserti piccoli hanno raggi validi per Canvas');
+    for (const r of c.ramps.filter(r => r.id !== 'super')) {
+        const x = (r.mouth[0][0] + r.mouth[1][0]) / 2;
+        assert.ok(calls.some(([op, line, tx, ty]) => op === 'fillText' && line === (r.id === 'sinistra' ? 'FORTEZZA' : 'TREBBIO') && tx === x && ty > r.mouth[0][1]), 'la targhetta indica l\'imbocco dal basso');
+    }
+    assert.ok(calls.some(([op, line]) => op === 'fillText' && line === 'MANCANO 60.000'), 'quanto manca al traguardo, nella riga in basso');
+    assert.ok(existsSync(new URL('../' + story.closeups.flipper.backglass, import.meta.url)), 'il fondale del tabellone esiste');
+    const glass = {}; drawFlipper(ctx, c, story.closeups.flipper, bg, glass); assert.ok(calls.some(([op, img, x, y, w, h]) => op === 'drawImage' && img === glass ), 'il fondale sul fianco');
+    m.launch(c, 0.8); run(c, 1); calls.length = 0; draw();
+    assert.ok(calls.some(([op, line]) => op === 'fillText' && line === 'PUNTEGGIO'), 'il nuovo display del punteggio');
+    c.step = 'result'; c.result = { winner: 'player', score: 70000, goal: 60000 }; calls.length = 0; draw();
+    assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'TRAGUARDO FATTO!'));
+    // Perdendo, il tabellone dice FINITA (Codex: diceva «traguardo ok» anche a zero punti).
+    const l = m.newFlipper(12, { level: 'bona' }); l.step = 'result'; l.ball = null; l.result = { winner: 'cpu', score: 0, goal: 60000 }; calls.length = 0;
+    drawFlipper(ctx, l, story.closeups.flipper, bg);
+    assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'FINE PARTITA'));
+    // Le cifre che corrono: in mezzo secondo da dove erano a dove devono arrivare, a scatti di dieci.
+    const { shownScore } = await import('../src/engine/flipper-render.js');
+    const d = { from: 1000, to: 51000, t0: 10 };
+    assert.equal(shownScore(d, 10), 1000); assert.equal(shownScore(d, 10.25) % 10, 0); assert.ok(shownScore(d, 10.25) > 20000 && shownScore(d, 10.25) < 30000); assert.equal(shownScore(d, 10.5), 51000);
+});
+
+test('al River: un clic sul bar (o «Usa», «Apri»), il livello, la partita; uscendo senza traguardo, la battuta di chi lascia', () => {
+    const g = new Game(story); g.go('via_provinciale'); settle(g);
+    assert.equal(g.hotspot('river').default, 'open');
+    const [bx, by, bw, bh] = g.hotspot('river').box;
+    assert.equal(g.hotspotAt([bx + bw / 2, by + bh / 2])?.id, 'river', 'il River si clicca');
+    g.act('use', 'river'); settle(g);
+    assert.ok(g.options().some(o => o.text === 'Una partita seria.'));
+    g.choose(g.options().findIndex(o => o.text === 'Una partita seria.')); settle(g);
+    assert.equal(g.closeup?.id, 'flipper'); assert.equal(g.closeup.level, 'seria');
+    g.closeupClose();
+    assert.equal(g.queue[0]?.say, story.closeups.flipper.quit[0].say);
+    settle(g);
+    g.act('open', 'river'); settle(g);
+    g.choose(g.options().findIndex(o => o.text === 'A fassi male.')); settle(g);
+    assert.equal(g.closeup?.level, 'male');
+});
+
+test('dietro la Pieve non c\'è più il canale che portava dritto all\'uscita sinistra (Andrea: «a sinistra esce troppo facile»)', () => {
+    const c = m.newFlipper(31); m.launch(c, 0.8); c.saveUntil = 0;
+    // Una pallina che scivola lungo la parete sinistra, sopra la Pieve: viene rimandata in campo, non nel canale.
+    put(c, { x: 205, y: 120, vx: 0, vy: 150, ramp: null });
+    let inChannel = false;
+    for (let i = 0; i < 120; i++) { m.update(c, 1 / 60); if (c.ball.x < 210 && c.ball.y > 146 && c.ball.y < 198) inChannel = true; }
+    assert.ok(!inChannel, 'mai fra la parete e il dorso dei bersagli');
+    assert.ok(c.ball.x > 210 || c.ball.y < 146, `in campo (${Math.round(c.ball.x)}, ${Math.round(c.ball.y)})`);
+});
+
+function inFuture(level = 'seria') {
+    const c = m.newFlipper(96, { level }); doubleLock(c); rampShot(c, 'super'); run(c, m.FUTURE.duration);
+    // Gli altri tiri restano parcheggiati mentre si misura un percorso alla volta.
+    for (const b of c.extraBalls) b.releaseAt = c.sim + 1000;
+    c.ball.releaseAt = 0; return c;
+}
+
+test('il futuro è un altro campo: tre giri reali, quote, punti e sigilli solo a percorso completo', () => {
+    for (const level of Object.keys(m.LEVELS)) {
+        const c = inFuture(level), old = m.layout();
+        assert.notDeepEqual(c.walls, old.walls); assert.notDeepEqual(c.bumpers, old.bumpers);
+        assert.equal(c.targets.length, 0); assert.equal(c.lanes.length, 0);
+        for (const w of c.walls) for (const [x, y] of [w.a, w.b]) assert.ok(x >= 200 && x <= 448 && y >= 5 && y <= 336);
+        for (const r of c.ramps) {
+            const score = c.score;
+            for (let n = 1; n <= 3; n++) {
+                const result = rampShot(c, r.id);
+                assert.ok(result.frames > 50); assert.ok(result.top < r.mouth[0][1] - 40);
+                assert.equal(c.score - score, r.points * n); assert.equal(c.future.hits[r.id], Math.min(n, 2));
+                assert.ok(result.exit.x === 229 || result.exit.x === 411, 'ritorno nelle corsie interne');
+            }
+            // Un ingresso debole sulla salita ricade e non carica il sigillo.
+            const d = inFuture(level), rd = d.ramps.find(k => k.id === r.id), points = d.score;
+            const result = ride(d, { x: rd.path[0][0], y: rd.mouth[0][1] + 1, vx: 0, vy: -270, ramp: null });
+            assert.equal(d.future.hits[r.id], 0); assert.equal(d.score, points); assert.ok(result.exit.y >= rd.mouth[0][1]);
+        }
+        const score = c.score, lives = c.balls;
+        const nextX = 320 + Math.sin((c.sim + m.STEP) * 1.6) * 24;
+        put(c, { x: nextX, y: c.regolo.y + c.regolo.r + 4, vx: 0, vy: -250, ramp: null, contacts: [] });
+        m.update(c, m.STEP);
+        assert.equal(c.table, 'classic'); assert.equal(c.score, score + m.FUTURE.finale);
+        assert.equal(c.balls, lives); assert.ok(m.waiting(c)); assert.equal(c.extraBalls.length, 0);
+        assert.deepEqual(c.ramps.map(r => r.id), ['sinistra', 'destra', 'super']);
+        doubleLock(c); rampShot(c, 'super'); assert.ok(c.transform, 'il viaggio è ripetibile');
+    }
+});
+
+test('nel futuro il Regolo si muove, gli urti e la molla funzionano, niente finale prima dei sigilli', () => {
+    const c = inFuture(), x = c.regolo.x;
+    c.ball.waiting = true; run(c, 0.5); assert.notEqual(c.regolo.x, x);
+    assert.ok(m.key(c, ' ', true)); run(c, 0.4); m.key(c, ' ', false); assert.ok(!m.waiting(c));
+    // Un respingente devia davvero la pallina.
+    const b = c.bumpers[0], score = c.score;
+    put(c, { x: b.x, y: b.y + b.r + 4, vx: 0, vy: -200, contacts: [] }); m.update(c, m.STEP);
+    assert.ok(c.ball.vy > 0); assert.equal(c.score, score + m.SCORE.bumper);
+    put(c, { x: c.regolo.x, y: c.regolo.y + c.regolo.r + 4, vx: 0, vy: -200, contacts: [] }); m.update(c, m.STEP);
+    assert.equal(c.table, 'future'); assert.equal(c.score, score + m.SCORE.bumper + m.SCORE.regolo);
+});
+
+test('futuro e trasformazione sono serializzabili; annullare e disegnare non fanno avanzare la partita', () => {
+    for (const transforming of [false, true]) {
+        const c = inFuture(); if (transforming) { doubleLockAfterReturn(c); }
+        m.hold(c, 'left', 'touch', true); m.cancel(c);
+        const saved = JSON.parse(JSON.stringify(c));
+        const calls = [], gradient = { addColorStop() {} };
+        const ctx = new Proxy({}, { get: (o, k) => k in o ? o[k] : (...args) => { calls.push([k, ...args]); return gradient; }, set: (o, k, v) => { o[k] = v; return true; } });
+        for (let i = 0; i < 10; i++) drawFlipper(ctx, c, story.closeups.flipper, {});
+        assert.deepEqual(JSON.parse(JSON.stringify(c)), saved, 'disegno e pausa non consumano tempo');
+        assert.ok(!c.flippers.left.held.length);
+        run(c, 0.5); run(saved, 0.5);
+        assert.deepEqual(JSON.parse(JSON.stringify(c)), saved, 'ripresa identica dopo il passaggio JSON');
+    }
+});
+function doubleLockAfterReturn(c) {
+    for (const b of m.activeBalls(c)) Object.assign(b, { x: 320, y: 348, vx: 0, vy: 300, ramp: null, releaseAt: 0 });
+    m.update(c, m.STEP); doubleLock(c); rampShot(c, 'super');
+}
+
+test('il ball save nel futuro salva una sola volta, conserva campo e sigilli, poi torna al classico', () => {
+    const c = inFuture(); c.extraBalls = []; c.future.hits.ponte = 1;
+    c.saveUntil = c.sim + 2; const lives = c.balls;
+    put(c, { x: 320, y: 348, vx: 0, vy: 300, ramp: null }); m.update(c, m.STEP);
+    assert.equal(c.table, 'future'); assert.equal(c.balls, lives); assert.ok(m.waiting(c)); assert.equal(c.future.hits.ponte, 1);
+    m.launch(c, 0.7); assert.equal(m.saveLeft(c), 0);
+    put(c, { x: 320, y: 348, vx: 0, vy: 300, ramp: null }); m.update(c, m.STEP);
+    assert.equal(c.table, 'classic'); assert.equal(c.balls, lives - 1);
+});
+
+test('i tre percorsi del futuro sono raggiungibili con il colpo fisico della paletta', () => {
+    for (const [id, x, y] of [['orbita', 288, 300], ['ponte', 290, 306], ['spira', 308, 320]]) {
+        const c = m.newFlipper(9);
+        Object.assign(c, m.futureLayout(), { table: 'future', future: { hits: { orbita: 0, ponte: 0, spira: 0 } } });
+        m.launch(c, 0.8); c.saveUntil = 0;
+        put(c, { x, y, vx: 0, vy: 180, inPlay: true }); m.hold(c, 'left', 'test', true);
+        let entered = null;
+        for (let i = 0; i < 160; i++) { m.update(c, m.STEP); if (c.ball?.ramp) { entered = c.ball.ramp.id; break; } }
+        assert.equal(entered, id, 'il tiro parte dalla paletta, non dall’imbocco');
+    }
+});
+
+test('salvare l’avventura durante il futuro conserva il checkpoint, come negli altri minigiochi', () => {
+    const g = new Game(story); g.go('via_provinciale'); settle(g);
+    g.act('use', 'river'); settle(g); g.choose(g.options().findIndex(o => o.text.startsWith('Una partita alla bona'))); settle(g);
+    const checkpoint = structuredClone(g.checkpoint);
+    Object.assign(g.closeup, inFuture('bona'));
+    const before = structuredClone(g.closeup), save = JSON.parse(JSON.stringify(g.savable()));
+    assert.deepEqual(save, checkpoint); assert.deepEqual(g.closeup, before, 'salvare non consuma sigilli o palline');
+    const loaded = new Game(story, { state: save });
+    assert.equal(loaded.state.scene, 'via_provinciale'); assert.equal(loaded.closeup, null);
+    g.closeupCancel(); assert.equal(g.closeup.table, 'future');
+    g.closeupClose(); settle(g); assert.ok(g.state.flags.flipper_vinto, 'il traguardo resta acquisito uscendo dal futuro');
+});
+
+test('per provare, openSuper fa davvero i due LOCK e apre la SUPER SPECIAL (main.js, ?debug, tasto S)', () => {
+    const c = m.newFlipper(73, { level: 'bona' });
+    assert.ok(m.openSuper(c));
+    assert.equal(c.special, 'super'); assert.equal(c.locks.length, 2); assert.equal(c.table, 'classic');
+});

tests/gara.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-gara';
 mkdirSync(out, { recursive: true });
@@ -12,7 +13,7 @@ let browser;
 const errors = [];
 
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     for (const [name, mobile, viewport, level] of [
         ['touch', true, { width: 844, height: 390 }, 'seria'],
         ['portrait', true, { width: 390, height: 844 }, 'bona'],

tests/ingorgo.browser.mjs

@@ -5,6 +5,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-ingorgo';
 mkdirSync(out, { recursive: true });
@@ -12,7 +13,7 @@ const server = await staticServer();
 let browser;
 const errors = [];
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     const page = await browser.newPage({ viewport: { width: 1280, height: 860 } });
     page.on('pageerror', e => { errors.push(e.message); console.log('ERR', e.message); });
     await page.goto(`http://127.0.0.1:${server.port}/`);

tests/ingorgo.test.mjs

@@ -6,6 +6,7 @@ import { newIncanto, updateIncanto, drawIncanto, whiteness, T } from '../src/eng
 import { Game, check, POSTER_READY } from '../src/engine/game.js';
 import { story } from '../src/story/story.js';
 import { settle } from './helpers.mjs';
+import { inside as inPolygon, findPath } from '../src/engine/geometry.js';
 import { render } from '../src/engine/render.js';
 
 const ZONE = story.zones.find(z => z.flag === 'ingorgo');
@@ -36,6 +37,18 @@ test('la miscela delle console: vicino a una si sente quella, fra due tutte e du
     assert.deepEqual(on.map(t => t.src), ['a.mp3', 'b.mp3']);
 });
 
+test('sotto una console si sente la sola musica di quella: in cima a Via dell\'Antica Posta, il marciapiede sotto l\'underground', () => {
+    const sc = story.scenes.antica_posta_alta, ok = cond => cond === 'ingorgo';
+    const spot = [620, 350];
+    assert.ok(inPolygon(sc.walk, spot) && findPath(sc.walk, sc.entry, spot), 'ci si arriva a piedi');
+    const under = trackFor(story, { screen: 'game', scene: 'antica_posta_alta', at: spot, ok });
+    assert.equal(under[0].src, 'assets/audio/ingorgo-underground.mp3'); assert.equal(under[0].gain, 1);
+    for (const t of under.slice(1)) assert.ok(t.gain <= 0.1, `${t.src} solo un filo: ${t.gain.toFixed(2)}`);
+    // A metà della strada, invece, la miscela resta.
+    const mid = trackFor(story, { screen: 'game', scene: 'antica_posta_alta', at: [240, 300], ok });
+    assert.ok(mid.filter(t => t.gain > 0.15).length >= 2);
+});
+
 test('la musica suona più brani insieme e li fa sfumare quando si cambia piazza', () => {
     globalThis.Audio = class { constructor(src) { this.src = src; this.volume = 0; this.paused = true; } play() { this.paused = false; return Promise.resolve(); } pause() { this.paused = true; } };
     const m = new Music({ volume: 0.5 });
@@ -82,9 +95,9 @@ test('dal manifesto in piazza all\'Ingorgo: la battuta, l\'effetto, la festa; us
         const track = trackFor(story, { screen: 'game', scene, at: [g.state.x, g.state.y], ok: c => check(c, g.state) });
         assert.ok(Array.isArray(track) && track.length >= 2, `${scene}: più console insieme`);
     }
-    g.go('via_cipriani'); settle(g);
+    g.go('via_massorondinaio'); settle(g);
     assert.ok(!g.state.flags.ingorgo, 'fuori dalla zona la festa sparisce');
-    assert.equal(g.backdrop(), story.scenes.via_cipriani.background);
+    assert.equal(g.backdrop(), story.scenes.via_massorondinaio.background);
 });
 
 test('chiudendo l\'effetto prima del lampo, la festa arriva lo stesso', () => {
@@ -137,7 +150,7 @@ test('alla festa le luci da palco si muovono, e solo alla festa', () => {
             const frame = time => { ops.length = 0; render(ctx, g, { time }); return JSON.stringify(ops.filter(([op]) => op === 'lineTo' || op === 'fillRect')); };
             assert.notEqual(frame(1000), frame(1700), `${scene}: le luci si muovono`);
         }
-        g.go('via_cipriani'); settle(g); g.go('piazza'); settle(g);
+        g.go('via_massorondinaio'); settle(g); g.go('piazza'); settle(g);
         ops.length = 0; render(ctx, g, { time: 1000 });
         assert.ok(!ops.some(([op, x, y]) => op === 'moveTo' && x === 116 && y === 146), 'di giorno niente teste mobili');
     } finally { delete globalThis.Image; }
@@ -155,6 +168,36 @@ test('le musiche e gli sfondi della festa esistono', () => {
     for (const f of files) assert.ok(existsSync(new URL('../' + f, import.meta.url)), `manca ${f}`);
 });
 
+test('all\'Ingorgo Andrea ha la birra: il foglio coi passi, il braccio alzato a tempo e la battuta', async () => {
+    const { readFileSync } = await import('node:fs');
+    const atlas = JSON.parse(readFileSync(new URL('../assets/characters/andrea-birra.json', import.meta.url)));
+    for (const f of ['walk_1', 'walk_2', 'walk_3', 'walk_4', 'cheer_1', 'cheer_2', 'cheer_3', 'talk']) assert.ok(atlas.frames[f], f);
+    assert.equal(story.characters.andrea_birra.sprite, 'assets/characters/andrea-birra.json');
+    const { festa } = await import('../src/engine/render.js');
+    const g = new Game(story); g.go('piazza'); settle(g);
+    assert.equal(festa(g, 0), null, 'senza la festa (e senza il foglio caricato) Andrea è quello di sempre');
+});
+
+test('alla festa Andrea sta dentro la folla: dalla vita in giù la gente dello sfondo gli passa davanti', async () => {
+    const { crowdFront } = await import('../src/engine/render.js');
+    const g = new Game(story); g.go('piazzetta', [330, 320]); settle(g);
+    const calls = [], ctx = { drawImage: (...a) => calls.push(a) }, bg = { width: 1280 };
+    crowdFront(ctx, g, 0, bg);
+    assert.equal(calls.length, 0, 'di giorno, senza la festa, niente');
+    g.state.flags.ingorgo = true;
+    const { x, y } = g.state, h = 62 * g.scaleAt(y);
+    for (const time of [0, 250, 500]) {
+        calls.length = 0; crowdFront(ctx, g, time, bg);
+        assert.ok(calls.length > 3, 'strisce di folla sopra Andrea');
+        for (const [img, , , , , dx, dy, dw, dh] of calls) {
+            assert.equal(img, bg);
+            assert.ok(dx + dw > x - h * 0.4 && dx < x + h * 0.4, 'solo davanti a lui');
+            assert.ok(dy >= y - h * 0.75 && dy + dh <= y + 3, 'dalla vita in giù, fino ai piedi');
+        }
+        assert.ok(new Set(calls.map(c => c[6])).size > 1, 'il bordo in alto a teste, mai dritto');
+    }
+});
+
 test('alla festa la folla dipinta salta a tempo: l\'effetto crowd in tutte e cinque le scene, dietro piano e davanti forte', async () => {
     const { EFFECTS } = await import('../src/engine/render.js');
     assert.equal(typeof EFFECTS.crowd, 'function');

tests/micro.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-micro';
 mkdirSync(out, { recursive: true });
@@ -12,7 +13,7 @@ let browser;
 const errors = [];
 
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     for (const [name, mobile, viewport] of [
         ['desktop', false, { width: 1280, height: 860 }],
         ['touch', true, { width: 844, height: 390 }],

tests/multimedia.browser.mjs

@@ -84,7 +84,7 @@ export async function checkMultimedia(browser, port, out, errors) {
             else await page.mouse.move(...await at(target));
             await page.waitForFunction(() => game.closeup?.step === 'reveal');
             await page.screenshot({ path: `${out}/media-torcia-${mobile ? 'telefono' : 'desktop'}-${i}.png` });
-            for (let n = 0; n < 200; n++) {
+            for (const fine = Date.now() + 30000; Date.now() < fine;) { // con la macchina carica la rivelazione dura di più
                 if (await page.evaluate(i => game.closeup.found > i, i)) break;
                 if (await page.evaluate(() => !!game.speech)) await page.keyboard.press('Space');
                 await page.waitForTimeout(25);
@@ -97,6 +97,8 @@ export async function checkMultimedia(browser, port, out, errors) {
         await settle();
         await page.waitForSelector('#ending:not([hidden])');
         assert.ok(await page.evaluate(() => game.checkpoint.ended));
+        // Il vento sfuma in un attimo: con la scheda video la prova ci arriva prima che abbia finito.
+        await page.waitForFunction(() => ambience.nodes.size === 0, null, { timeout: 3000 }).catch(() => {});
         assert.equal(await page.evaluate(() => ambience.nodes.size), 0, 'alla fine non resta il vento della fessura');
         // Misura il segnale realmente prodotto da Web Audio: udibile, finito, senza saturazione.
         if (!mobile) {

tests/music.test.mjs

@@ -24,6 +24,15 @@ test('il brano giusto per titolo, fine e scena', () => {
     assert.equal(trackFor({ ...s, scenes: { ...s.scenes, i: { indoor: true } } }, { screen: 'game', scene: 'i', phase: sera }), 'g.mp3');
 });
 
+test('il flipper del River ha la sua musica, e un\'altra la tavola del futuro', () => {
+    const track = trackFor(story, { screen: 'game', scene: 'river', closeup: 'flipper' });
+    assert.equal(track, 'assets/audio/flipper.mp3');
+    assert.equal(trackFor(story, { screen: 'game', scene: 'river', closeup: 'flipper', table: 'classic' }), track);
+    const future = trackFor(story, { screen: 'game', scene: 'river', closeup: 'flipper', table: 'future' });
+    assert.equal(future, 'assets/audio/flipper-futuro.mp3', 'il Regolo del futuro ha la sua musica');
+    for (const f of [track, future]) assert.ok(existsSync(f), f);
+});
+
 test('volume e muto', () => {
     const m = new Music({ volume: 0.5, muted: true });
     assert.equal(m.setVolume(1.4), 1);

tests/peso.browser.mjs

@@ -0,0 +1,106 @@
+// Il peso della grafica (Andrea, 1 novembre 2026: «prima senza GPU scoprivamo anche gli effetti troppo pesanti»): le
+// altre prove disegnano sulla scheda video e un effetto pesante non le rallenta più. Questa usa sempre swiftshader, il
+// disegno sul processore, come un telefono lento: nel gioco vero, in ogni scena nelle tre fasi e in ogni primo piano,
+// lascia girare il gioco e misura i fotogrammi al secondo e l'arretrato grafico (il disegno chiesto e non ancora fatto).
+// node tests/peso.browser.mjs (PESO_TUTTI=1 stampa ogni misura).
+//
+// Come si misura, e perché così (vedi la memoria «effetti leggeri»): mai leggere i pixel della tela del gioco, perché
+// dopo qualche lettura Chrome la passa al processore e la misura cambia ciò che misura; l'arretrato si cronometra
+// leggendo una tela nuova, abbastanza grande da stare anche lei sulla grafica, che deve aspettare tutto il disegno
+// in coda prima della sua. Tarata il 1° novembre 2026 sul PC di Andrea: una scena normale, a immagini caricate, pochi ms
+// di arretrato e 60 fotogrammi; un ctx.filter blur a tutto schermo 816 ms e 34, quaranta tratti larghi trasparenti 718 ms
+// e 36, trenta veli trasparenti a tutto schermo 374 ms e 45.
+import { chromium } from 'playwright';
+import assert from 'node:assert/strict';
+import { staticServer } from './helpers.mjs';
+import { SWIFTSHADER } from './chromium.mjs';
+
+const MAX_BACKLOG = 500, MIN_FPS = 30; // la scena più cara, pieve_interno di pomeriggio, fino a 355 ms sotto carico // ms di arretrato dopo un secondo di gioco; fotogrammi al secondo
+const server = await staticServer();
+let browser;
+const errors = [], slow = [], rows = [];
+try {
+    browser = await chromium.launch({ args: SWIFTSHADER });
+    const page = await browser.newPage({ viewport: { width: 1280, height: 860 } });
+    page.on('pageerror', e => errors.push(e.message));
+    await page.goto(`http://127.0.0.1:${server.port}/`);
+    await page.click('#splash'); await page.click('#new-game'); await page.click('#rione [data-rione="campomigliaio"]'); await page.click('#skip-intro');
+    await page.evaluate(async () => {
+        const { settle } = await import('/tests/helpers.mjs');
+        settle(game);
+        const probe = () => {
+            const c = document.createElement('canvas'); c.width = 640; c.height = 360;
+            const g = c.getContext('2d'); g.fillRect(0, 0, 9, 9);
+            const t = performance.now(); g.getImageData(0, 0, 1, 1); return performance.now() - t;
+        };
+        window.peso = async () => {
+            // Prima si lascia smaltire l'arretrato di prima, compreso il caricamento delle immagini alla prima visita di una
+            // scena (che costa una volta sola e non è un effetto): finché la lettura non torna svelta, al più due secondi.
+            await new Promise(r => setTimeout(r, 150));
+            for (let i = 0; i < 20 && probe() > 30; i++) await new Promise(r => setTimeout(r, 100));
+            let n = 0; const t0 = performance.now();
+            await new Promise(done => { const tick = () => { n++; if (performance.now() - t0 < 800) requestAnimationFrame(tick); else done(); }; requestAnimationFrame(tick); });
+            const backlog = Math.round(probe());
+            return { fps: Math.round(n * 1000 / (performance.now() - t0)), backlog };
+        };
+    });
+    // Una misura storta per un attimo di carico del PC (le altre prove girano insieme) si ripete dopo un secondo di
+    // respiro: boccia solo se è pesante due volte.
+    const measure = async label => {
+        let m = await page.evaluate(() => peso());
+        const heavy = m => m.backlog > MAX_BACKLOG || m.fps < MIN_FPS;
+        if (heavy(m)) { await page.waitForTimeout(1000); m = await page.evaluate(() => peso()); }
+        rows.push({ label, ...m });
+        if (heavy(m)) slow.push(`${label}: ${m.fps} fotogrammi al secondo, arretrato ${m.backlog} ms`);
+        if (process.env.PESO_TUTTI) console.log(`${String(m.fps).padStart(3)} fps ${String(m.backlog).padStart(5)} ms  ${label}`);
+    };
+    // Le scene, nelle tre fasi (le condizioni delle fasi come in ambient.browser.mjs). Prima un giro in tutte, perché la
+    // prima visita paga il caricamento delle immagini, che non è un effetto.
+    const scenes = await page.evaluate(() => Object.keys(game.story.scenes));
+    for (const id of scenes) {
+        await page.evaluate(id => { const sc = game.story.scenes[id]; game.state.scene = id; [game.state.x, game.state.y] = sc.entry; }, id);
+        await page.waitForTimeout(120);
+    }
+    for (const [phase, flags] of [['pomeriggio', {}], ['tramonto', { indizio_regolo: true }], ['sera', { casetta_aperta: true }]]) {
+        for (const id of scenes) {
+            await page.evaluate(({ id, flags }) => {
+                const g = game, sc = g.story.scenes[id];
+                Object.assign(g.state.flags, flags);
+                g.state.scene = id; [g.state.x, g.state.y] = sc.entry; g.enteredAt = g.time;
+            }, { id, flags });
+            await measure(`${id} (${phase})`);
+            await page.evaluate(flags => { for (const k of Object.keys(flags)) delete game.state.flags[k]; }, flags);
+        }
+    }
+    // I primi piani, aperti come li apre la storia; il flipper anche con la pallina in gioco e nel Regolo del futuro.
+    const closeups = await page.evaluate(() => Object.keys(game.story.closeups));
+    for (const id of closeups) {
+        const opened = await page.evaluate(id => {
+            game.state.scene = 'piazza';
+            try { game.run({ closeup: id }); } catch (e) { return String(e); }
+            return true;
+        }, id);
+        if (opened !== true) { console.log(`${id}: non si apre da solo (${opened})`); continue; }
+        await measure(`primo piano ${id}`);
+        if (await page.evaluate(() => game.story.closeups[game.closeup.id].type === 'flipper')) {
+            await page.evaluate(async () => { const m = await import('/src/engine/flipper.js'); m.launch(game.closeup, 0.8); });
+            await measure(`primo piano ${id} (in gioco)`);
+            const future = await page.evaluate(async () => {
+                const m = await import('/src/engine/flipper.js');
+                if (!m.futureLayout) return false;
+                Object.assign(game.closeup, m.futureLayout(), { table: 'future', future: { hits: { orbita: 0, ponte: 0, spira: 0 } } });
+                return true;
+            });
+            if (future) await measure(`primo piano ${id} (Regolo del futuro)`);
+        }
+        await page.evaluate(() => { game.closeup = null; game.queue.length = 0; game.speech = null; });
+    }
+    const worst = [...rows].sort((a, b) => b.backlog - a.backlog).slice(0, 4).map(r => `${r.label} ${r.backlog} ms`).join(', ');
+    console.log(`Peso della grafica con swiftshader: ${rows.length} misure; gli arretrati più alti: ${worst}`);
+    assert.deepEqual(slow, [], `troppo pesanti con swiftshader (soglie: ${MAX_BACKLOG} ms, ${MIN_FPS} fotogrammi al secondo)`);
+    assert.deepEqual(errors, []);
+    console.log('Prova del peso: OK');
+} finally {
+    await browser?.close();
+    server.kill();
+}

tests/risveglio.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-risveglio';
 mkdirSync(out, { recursive: true });
@@ -11,7 +12,7 @@ const server = await staticServer();
 let browser;
 const errors = [];
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     // Sul computer la versione con la sfocatura vera, sul telefono (touch) quella leggera senza filtri.
     for (const mobile of [false, true]) {
     const page = await browser.newPage(mobile ? { viewport: { width: 844, height: 390 }, hasTouch: true, isMobile: true } : { viewport: { width: 1280, height: 860 } });

tests/scopa.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = '/tmp/regolo-shots'; mkdirSync(out, { recursive: true });
 const server = await staticServer(), errors = [];
@@ -44,7 +45,7 @@ async function wait(page) {
     });
 }
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     const scenarios = [
         { name: 'desktop-mouse', mode: 'mouse', viewport: { width: 1280, height: 860 }, full: true },
         { name: 'telefono-touch', mode: 'touch', viewport: { width: 390, height: 844 } },

tests/smarronata.browser.mjs

@@ -4,6 +4,7 @@ import { chromium } from 'playwright';
 import { mkdirSync } from 'node:fs';
 import assert from 'node:assert/strict';
 import { staticServer } from './helpers.mjs';
+import { ARGS } from './chromium.mjs';
 
 const out = process.env.OUT ?? '/tmp/regolo-smarronata';
 mkdirSync(out, { recursive: true });
@@ -11,7 +12,7 @@ const server = await staticServer();
 let browser;
 const errors = [];
 try {
-    browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
+    browser = await chromium.launch({ args: ARGS });
     const page = await browser.newPage({ viewport: { width: 1280, height: 860 } });
     page.on('pageerror', e => { errors.push(e.message); console.log('ERR', e.message); });
     await page.goto(`http://127.0.0.1:${server.port}/`);