Versione 0.1.18

Sfondi di Codex: Via del Pignone dalla foto di Andrea, con sul muro a destra il murale di Cistola (Davide Poggi,
«il talento di via del Pignone», consenso confermato da Andrea) alla maniera di quelli di Maradona, maglia a strisce
bianche e rosse; Via Provinciale e Piazzetta Cambray Digny da Street View (in IMMAGINI.md: da rifare prima di
pubblicarle su Pages). Il giro come il paese vero: rotonda della farmacia → Via Provinciale → Pieve, e a destra
Via del Pignone → Piazzetta → a sinistra Via de' Medici, a diritto la Piazza. Dalla Piazza, a sinistra, ora si va
in Piazzetta (non più al Comune né direttamente in Via de' Medici). Battute provvisorie e voci.

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

Dockerfile

@@ -13,6 +13,8 @@ COPY assets/voices /usr/share/nginx/html/assets/voices
 COPY assets/credits /usr/share/nginx/html/assets/credits
 COPY assets/effects /usr/share/nginx/html/assets/effects
 COPY assets/closeups /usr/share/nginx/html/assets/closeups
+COPY assets/favicon /usr/share/nginx/html/assets/favicon
+COPY assets/video /usr/share/nginx/html/assets/video
 
 # Le immagini e i font citati da index.html e style.css prendono ?v=<versione>, come quelli caricati dal codice.
 RUN cd /usr/share/nginx/html \

LICENSE

@@ -0,0 +1,71 @@
+Licenze de «La Leggenda del Regolo»
+
+Il progetto è un gioco gratuito e non commerciale. Ha due parti con licenze diverse: il codice, e tutto il resto.
+
+================================================================================
+1. IL CODICE: licenza MIT
+================================================================================
+
+Vale per tutto ciò che sta fuori dalle cartelle assets/, docs/ e video/: i sorgenti in src/, i test, gli strumenti
+in tools/, gli script, index.html, style.css, i file di configurazione.
+
+MIT License
+
+Copyright (c) 2026 Andrea Manzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+================================================================================
+2. LA STORIA, LA GRAFICA, LA MUSICA: Creative Commons BY-NC-SA 4.0
+================================================================================
+
+Vale per la storia e i dialoghi (src/story/), i documenti in docs/, gli sfondi, i primi piani, le icone e gli sprite
+dei personaggi inventati (assets/scenes, assets/closeups, assets/icons, assets/effects, assets/favicon, e in
+assets/characters quelli che non ritraggono persone vere), le musiche composte e sintetizzate dagli script in tools/
+(assets/audio/biliardo.mp3, carte.mp3, bocce.mp3, pieve.mp3, cartello.mp3) e i video «Come si gioca» (assets/video).
+
+© 2026 Andrea Manzi. Si possono copiare, ridistribuire e rielaborare citando l'autore, per scopi non commerciali,
+e distribuendo le opere derivate con la stessa licenza. Testo completo: https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Gli sfondi sono stati disegnati con strumenti di generazione di immagini (OpenAI) a partire da fotografie di San
+Piero a Sieve, quasi tutte di Andrea Manzi; la provenienza di ognuno è registrata in docs/IMMAGINI.md (la foto
+dell'interno della Pieve è di Mariano Mirannalti, citato nei Ringraziamenti).
+
+================================================================================
+3. ECCEZIONI: cose che NON si possono riusare, o che hanno una licenza propria
+================================================================================
+
+a) Le persone vere. I ritratti in pixel nei Ringraziamenti (assets/credits/) e gli sprite dei personaggi ispirati a
+   persone vere (vecchietti, Mariano, l'Ing. Tozzi, il Tozzino, il BaronDeDuke, l'Arcu, Fra Peppino e gli altri
+   indicati nei commenti di src/story/story.js) sono pubblicati con il consenso delle persone ritratte, SOLO per
+   questo gioco: tutti i diritti riservati, non si possono riusare altrove. Lo stesso vale per i nomi e i ricordi
+   delle persone del paese che compaiono nella storia.
+
+b) La fotografia del palio del 2007 (assets/closeups/palio-2007.jpg) ritrae il quadro dipinto dai ragazzi delle
+   scuole medie di San Piero a Sieve: tutti i diritti riservati agli autori, pubblicata qui per il gioco.
+
+c) Le musiche di Andrea Manzi generate con Suno (assets/audio/titolo.mp3, paese.mp3, sera.mp3, fortezza.mp3,
+   ricordi.mp3) si usano alle condizioni d'uso di Suno e non sono coperte dalla licenza Creative Commons.
+
+d) Le voci dei personaggi (assets/voices/) e la voce narrante dei video (assets/video/) sono sintetizzate con
+   XTTS-v2 di Coqui, distribuito con la Coqui Public Model License (https://coqui.ai/cpml, testo in
+   docs/LICENZA-CPML.txt): i file audio che ne derivano si possono usare SOLO per scopi non commerciali.
+
+e) Il carattere Press Start 2P di CodeMan38 (assets/fonts/) è distribuito con la SIL Open Font License 1.1: il testo
+   della licenza è in assets/fonts/OFL-press-start-2p.txt.
+
+f) L'aneddoto della Torre dello Scoronconcolo riprende, riformulati, i fatti della voce «Michele del Tavolaccino»
+   di Wikipedia in italiano (CC BY-SA 4.0): https://it.wikipedia.org/wiki/Michele_del_Tavolaccino
+
+Monkey Island e La storia infinita sono citati come ricordi: i marchi e le opere restano dei rispettivi titolari.

Makefile

@@ -23,7 +23,7 @@ DST         ?= assets/scenes/$(notdir $(SRC))
 CROP        ?=
 COLORS      ?= 64
 
-.PHONY: help serve open test browser verify bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
+.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-logs clean distclean
 
 ## ------------------------------------------------------------ sviluppo
@@ -50,7 +50,10 @@ test: ## Test della logica, della storia, della soluzione completa e del generat
 browser: ## Partita completa nel browser con Playwright
 	$(NODE) tests/browser.mjs
 
-verify: test browser ## Tutti i controlli
+verify: test browser check-public ## Tutti i controlli
+
+check-public: ## Prima di pubblicare: niente prompt, fogli grezzi, segreti o nomi della rete di casa (tutta la storia)
+	bash scripts/check-public.sh
 
 bump: ## Nuova versione (PARTE=patch|minor|major): verifica, commit e tag v<versione>; poi make deploy
 	scripts/bump.sh $(or $(PARTE),patch)

README.md

@@ -1,81 +1,66 @@
 # La Leggenda del Regolo
 
-Avventura grafica punta-e-clicca ambientata a San Piero a Sieve, nella settimana del Palio della Fortezza del 2007.
-Il palio, il quadro dipinto dai ragazzi delle medie, è sparito: un ragazzo del paese deve ritrovarlo prima della festa.
+Un'avventura grafica punta-e-clicca, nello spirito delle avventure anni '90, ambientata a **San Piero a Sieve**
+(Mugello) nella settimana del **Palio della Fortezza del 2007**. Il palio, il quadro dipinto dai ragazzi delle
+medie, è sparito: Andrea, un ragazzo del paese, deve ritrovarlo prima della festa, fra vecchietti che litigano
+sulle due leggende del Regolo, il serpente della Fortezza, e un paese disegnato dalle fotografie vere.
 
 *Al Lele, che mi ha fatto conoscere Monkey Island.*
 
-Progetto in fase di ideazione: il documento di progetto è in [`docs/PROGETTO.md`](docs/PROGETTO.md).
-Per ora c'è un prototipo del motore con due scene di prova e grafica provvisoria.
+Si gioca online su **https://50037.manzolo.it** (50037 è il CAP di San Piero), nel browser, anche dal telefono.
+È gratuito e non commerciale.
 
-## Generare sfondi dalle fotografie
+## Cosa c'è
 
-Il generatore Python è `tools/genera.py`; istruzioni e prompt delle due nuove vedute
-sono descritti in [`docs/GENERAZIONE_SFONDI.md`](docs/GENERAZIONE_SFONDI.md).
-Lavora sulle foto di **San Piero a Sieve**, conserva i master a 1536×864 e permette
-di prepararne copie a 640×360 per il gioco.
-
-```zsh
-python3 tools/genera.py --dry-run   # elenco delle foto, nessuna API e nessun file scritto
-```
-
-## Voci dei personaggi
-
-Ogni battuta ha la sua voce, generata con XTTS-v2 sulla GPU (licenza solo non commerciale): un mp3 per battuta in
-`assets/voices/`, la voce di ogni personaggio in `tools/voci.json` (castello e leone con altezza ed eco proprie).
-
-```zsh
-make voci                    # solo le battute nuove o cambiate; i file che non servono più si tolgono
-make voci RIFAI='Ci sei?'    # ritenta una battuta storpiata (XTTS è casuale: di solito il secondo tentativo va)
-make voci-elenco             # cosa manca, senza generare
-```
-
-Il test `tests/voices.test.mjs` fallisce se una battuta non ha la sua voce: dopo aver cambiato un testo, `make voci`.
+- **Il primo capitolo**, dal pomeriggio alla sera: 38 scene, i dialoghi a scelte, l'inventario, la mappa del
+  paese, il taccuino, il salvataggio automatico (e su file, per portarlo su un altro dispositivo).
+- **Le voci** di tutti i personaggi, in toscano, e le **musiche**.
+- **I giochi del paese**: la briscola, il tressette ai 21 e la scopa all'oratorio (con le carte toscane o le
+  napoletane), le bocce al pallaio e il biliardo a cinque birilli al circolo, ognuno con tre livelli e un video
+  «Come si gioca».
+- **Il paese vero**: gli sfondi sono disegnati dalle fotografie di San Piero; i personaggi, con il loro
+  consenso, da persone vere.
 
 ## Giocare in locale
 
-```zsh
-python3 -m http.server 8000   # poi http://localhost:8000
-```
-
-Clic = azione più sensata (parla, guarda, vai); clic destro o pressione lunga = guarda; un verbo scelto vale per il
-clic successivo. Spazio salta la battuta, i numeri scelgono nel dialogo, Esc annulla il verbo.
-
-Il libro dell'oratorio si apre e si sfoglia con clic o tocco; Esc lo chiude. Nella fessura della Fortezza,
-la torcia segue mouse o dito (anche trascinando): si cercano i dettagli tenendo brevemente la luce su di essi.
-Si possono usare anche le frecce, oppure Invio per cercare il prossimo dettaglio. «Torna fuori» permette di
-riprovare; dopo il ritrovamento, «Continua» conclude il capitolo.
-Il volume dei suoni ambientali e del fruscio delle pagine si regola in **Pausa → Ambiente ed effetti**.
-
-Al biliardo del Circolo 4 Maggio, clic o tocco fissa la mira; regola la forza e premi **Tira**.
-Le frecce ← → affinano la direzione, con Maiusc per passi ancora più piccoli. La guida usa la stessa fisica
-del tiro: mostra sponde, primo contatto e direzioni iniziali dopo l'urto (azzurro per l'avversaria, giallo
-per la propria biglia). Tenendo premuto sul tavolo o Spazio si carica il colpo, con la mira bloccata.
-
-## In Docker
+Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES.
 
 ```zsh
-make up     # http://localhost:8080 (DOCKER_PORT=… per cambiarla)
-make down
+python3 -m http.server 8000     # poi http://localhost:8000
 ```
 
-## Struttura
+Oppure `make up` (Docker, su http://localhost:8080). Non aprire `index.html` con `file://`: i moduli vogliono HTTP.
 
-- `src/engine/`: motore senza storia (`game.js` logica e coda delle azioni, `geometry.js` area calpestabile e
-  percorsi, `command.js` verbi e clic, `render.js` disegno, `storage.js` salvataggio);
-- `src/story/`: la storia come dati (`story.js`) e la sua soluzione completa (`solution.js`);
-- `src/main.js`: collega tutto alla pagina;
-- `assets/scenes/`: sfondi a 640×360, preparati con `tools/prepare_background.py` dagli originali in `assets/raw/`.
-- `assets/characters/`: fogli dei personaggi, tagliati con `tools/slice_sprites.py` e allineati con
-  `tools/prepare_character.py` (istruzioni in testa al file).
+## Come è fatto
 
-## Test
+- `src/engine/`: il motore (camminata con i percorsi, verbi e clic intelligente, dialoghi, inventario,
+  salvataggi, musica, voci, suoni d'ambiente sintetizzati, effetti animati) e i minigiochi
+  (`bocce.js`, `biliardo.js`, `briscola.js`, `tressette.js`, `scopa.js`, ognuno col suo `*-render.js`).
+- `src/story/`: la storia è dati, non codice: scene, oggetti, personaggi, dialoghi, soluzione (`solution.js`).
+- `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.
+- `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
-npm test          # logica, storia coerente, soluzione percorsa dall'inizio alla fine
-npm install && npx playwright install chromium-headless-shell
-npm run browser   # partita completa con clic veri in Chromium, salvataggio, telefono
-npm run browser -- --media-only  # libro, torcia e audio: controllo mirato desktop/telefono
-npm run browser:biliardo  # mira e tiro con mouse/touch, desktop e telefono; schermate in /tmp/regolo-biliardo
+make verify        # sintassi, test, prova nel browser: quello che gira prima di ogni versione
+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)
 ```
 
+## Chi ha fatto cosa
+
+Un gioco di Andrea Manzi (Manzolo). Idee, ricordi, foto e volti: gli amici di San Piero, nei Ringraziamenti del
+gioco. Programmazione con Claude e Codex; sfondi dalle fotografie di Andrea con gli strumenti di generazione di
+immagini; musiche di Andrea con Suno e, per i giochi, sintetizzate da script; voci con XTTS-v2; carattere Press
+Start 2P.
+
+## Licenze
+
+Il codice è MIT; storia, grafica e musiche sintetizzate sono Creative Commons BY-NC-SA 4.0; le persone vere
+ritratte, la foto del palio, le musiche di Suno e le voci XTTS (solo uso non commerciale) hanno le loro
+condizioni. Tutto in [`LICENSE`](LICENSE).

assets/characters/betino.json

@@ -0,0 +1,14 @@
+{
+ "image": "betino.png",
+ "height": 104,
+ "frames": {
+  "idle": {
+   "x": 0,
+   "y": 0,
+   "w": 161,
+   "h": 104,
+   "ax": 80.5,
+   "ay": 104
+  }
+ }
+}

assets/characters/ghiacciomobile.json

@@ -0,0 +1,14 @@
+{
+ "image": "ghiacciomobile.png",
+ "height": 144,
+ "frames": {
+  "idle": {
+   "x": 0,
+   "y": 0,
+   "w": 324,
+   "h": 144,
+   "ax": 162,
+   "ay": 144
+  }
+ }
+}

assets/characters/giocatore-carte.json

@@ -0,0 +1,38 @@
+{
+ "image": "giocatore-carte.png",
+ "height": 100,
+ "frames": {
+  "sit": {
+   "x": 0,
+   "y": 0,
+   "w": 67,
+   "h": 100,
+   "ax": 25.7,
+   "ay": 100
+  },
+  "talk": {
+   "x": 69,
+   "y": 0,
+   "w": 68,
+   "h": 100,
+   "ax": 27.6,
+   "ay": 100
+  },
+  "laugh": {
+   "x": 139,
+   "y": 0,
+   "w": 72,
+   "h": 99,
+   "ax": 19.3,
+   "ay": 99
+  },
+  "shuffle": {
+   "x": 213,
+   "y": 0,
+   "w": 67,
+   "h": 97,
+   "ax": 25.2,
+   "ay": 97
+  }
+ }
+}

assets/voices/index.json

@@ -47,6 +47,26 @@
   "file": "andrea-dacb32e5c6.mp3",
   "sec": 4.01
  },
+ "andrea|La Torre dello Scoronconcolo. Era una vecchia torre di guardia, già in disuso nel Cinquecento.": {
+  "file": "andrea-536c525f5c.mp3",
+  "sec": 6.64
+ },
+ "andrea|Ci si rifugiò Michele del Tavolaccino, detto Scoronconcolo, sanpierino: nel 1537 aiutò Lorenzino de' Medici ad ammazzare il duca Alessandro.": {
+  "file": "andrea-37eaf3e803.mp3",
+  "sec": 11.82
+ },
+ "andrea|Nel 1539 finì sulle galere dell'ordine gerosolimitano, in guerra contro i Turchi. Altro che Palio.": {
+  "file": "andrea-5f4c4fca29.mp3",
+  "sec": 8.04
+ },
+ "andrea|Da quassù non ci arrivo. E poi, di nascondigli in quella torre, ce n'è già stato uno di troppo.": {
+  "file": "andrea-f60ba3ee31.mp3",
+  "sec": 7.38
+ },
+ "andrea|Una torre in tasca? Nemmeno lo Scoronconcolo ci è riuscito.": {
+  "file": "andrea-938fbd1326.mp3",
+  "sec": 4.59
+ },
  "andrea|Il bar della piazza. Chi c'era dietro il bancone nel 2007? Questo lo sa solo Andrea.": {
   "file": "andrea-4b733def4f.mp3",
   "sec": 7.27
@@ -287,26 +307,6 @@
   "file": "andrea-68a845881b.mp3",
   "sec": 1.94
  },
- "andrea|Fra Peppino da Gricignano, col saio e i sandali. Sul sagrato sembra nato lì.": {
-  "file": "andrea-97d75e2a9d.mp3",
-  "sec": 5.38
- },
- "andrea|Buongiorno, Fra Peppino!": {
-  "file": "andrea-94988dc8c6.mp3",
-  "sec": 1.74
- },
- "fra_peppino|Pace e bene, figliolo. Cerchi qualcosa?": {
-  "file": "fra_peppino-651c4d95ab.mp3",
-  "sec": 3.72
- },
- "andrea|Il palio. È sparito.": {
-  "file": "andrea-c9c068f507.mp3",
-  "sec": 2.39
- },
- "fra_peppino|Le cose sparite, prima o poi, tornano. Come le pecorelle.": {
-  "file": "fra_peppino-8b3d0a5b8f.mp3",
-  "sec": 4.47
- },
  "andrea|La Pieve di San Pietro. Il mio rione: noi bianchi.": {
   "file": "andrea-43fd5c2b27.mp3",
   "sec": 4.46
@@ -467,6 +467,10 @@
   "file": "andrea-f798fa755d.mp3",
   "sec": 4.9
  },
+ "andrea|Ha già mescolato. Mi sa che aspettava proprio un pollo di passaggio.": {
+  "file": "andrea-71f3bff8a0.mp3",
+  "sec": 5.09
+ },
  "andrea|Una gomma da masticare ancora incartata, persa davanti al palco. Qualcuno ha perso l'appetito.": {
   "file": "andrea-f2ea95922d.mp3",
   "sec": 6.54
@@ -519,6 +523,26 @@
   "file": "andrea-43d3435d61.mp3",
   "sec": 2.99
  },
+ "andrea|Fra Peppino da Gricignano, col saio e i sandali. Qui al Bosco ai Frati è a casa sua: è un convento di francescani.": {
+  "file": "andrea-6797d70153.mp3",
+  "sec": 8.45
+ },
+ "andrea|Buongiorno, Fra Peppino!": {
+  "file": "andrea-94988dc8c6.mp3",
+  "sec": 1.74
+ },
+ "fra_peppino|Pace e bene, figliolo. Cerchi qualcosa?": {
+  "file": "fra_peppino-651c4d95ab.mp3",
+  "sec": 3.72
+ },
+ "andrea|Il palio. È sparito.": {
+  "file": "andrea-c9c068f507.mp3",
+  "sec": 2.39
+ },
+ "fra_peppino|Le cose sparite, prima o poi, tornano. Come le pecorelle.": {
+  "file": "fra_peppino-8b3d0a5b8f.mp3",
+  "sec": 4.47
+ },
  "andrea|Il convento del Bosco ai Frati, in mezzo al bosco. Qui si viene a cercare il fresco e il silenzio.": {
   "file": "andrea-486c980f52.mp3",
   "sec": 7.48
@@ -603,6 +627,34 @@
   "file": "andrea-e24cb31cbf.mp3",
   "sec": 2.62
  },
+ "andrea|Cartelli per la Pieve, per la stazione, per Firenze. Per il palio, nessuno.": {
+  "file": "andrea-60f39f0dd7.mp3",
+  "sec": 6.48
+ },
+ "andrea|Cistola. Il talento di via del Pignone.": {
+  "file": "andrea-2b47355c2c.mp3",
+  "sec": 3.81
+ },
+ "andrea|Col dieci, come i grandi. Se c'è un muro che se lo merita, è questo.": {
+  "file": "andrea-1bd111f29d.mp3",
+  "sec": 5.59
+ },
+ "andrea|Ciao Cistola! ...Almeno dipinto stai fermo ad ascoltarmi.": {
+  "file": "andrea-0e558e54fe.mp3",
+  "sec": 4.18
+ },
+ "andrea|Le mura della Fortezza medicea, mezze coperte dall'edera. Ne hanno viste più di me.": {
+  "file": "andrea-7b3b36edc6.mp3",
+  "sec": 5.93
+ },
+ "andrea|Una casetta piccina, appoggiata alle mura come un gatto al sole.": {
+  "file": "andrea-c3279de3ab.mp3",
+  "sec": 3.93
+ },
+ "andrea|Chiusa. E poi non è casa mia.": {
+  "file": "andrea-7fd73fbb77.mp3",
+  "sec": 2.66
+ },
  "andrea|L'area feste. D'estate ci montano la pista da ballo, le tavolate e lo stand della pasta.": {
   "file": "andrea-a942b2723e.mp3",
   "sec": 6.77
@@ -919,6 +971,22 @@
   "file": "andrea-00f2e70a4d.mp3",
   "sec": 2.95
  },
+ "andrea|Nessuno ha mai capito davvero il tuo immenso valore.": {
+  "file": "andrea-3e85200509.mp3",
+  "sec": 2.93
+ },
+ "andrea|O via, lascialo riposare. A pedalare oggi ci penso io.": {
+  "file": "andrea-34aad1ffe3.mp3",
+  "sec": 4.81
+ },
+ "andrea|La Ghiacciomobile nera. Hai visto cose che noi poveri umani non potremmo neppur lontanamente immaginare.": {
+  "file": "andrea-7be29434e0.mp3",
+  "sec": 7.25
+ },
+ "andrea|Con questo sole, di ghiaccio c'è rimasto giusto il nome. Vo a piedi.": {
+  "file": "andrea-def44809bc.mp3",
+  "sec": 5.08
+ },
  "andrea|Il circolino: il Circolo SMS di Campomigliaio. Un'istituzione, qui i volontari hanno sempre fatto miracoli.": {
   "file": "andrea-90bbad0de0.mp3",
   "sec": 9.59
@@ -1499,6 +1567,98 @@
   "file": "andrea-60cdae2e35.mp3",
   "sec": 5.1
  },
+ "andrea|Mi ricordi come avete fatto quella volta a tornare illesi dopo aver lasciato una fiancata a Campolungo?": {
+  "file": "andrea-2acf574bfa.mp3",
+  "sec": 5.36
+ },
+ "andrea|Riposa, Ghiacciomobile.": {
+  "file": "andrea-c79d2d1c81.mp3",
+  "sec": 2.19
+ },
+ "andrea|Ho sentito dire dal Trappola che pensavi di poter attraversare i muri. Ti stimo tanto.": {
+  "file": "andrea-6c6e2fd461.mp3",
+  "sec": 5.69
+ },
+ "andrea|Una briscola?": {
+  "file": "andrea-d2f285f610.mp3",
+  "sec": 1.04
+ },
+ "andrea|Rivincita a briscola?": {
+  "file": "andrea-6807209a9e.mp3",
+  "sec": 1.37
+ },
+ "andrea|Una scopa?": {
+  "file": "andrea-d8dfb86266.mp3",
+  "sec": 0.65
+ },
+ "andrea|Un tressette ai 21?": {
+  "file": "andrea-4fbe84fada.mp3",
+  "sec": 1.66
+ },
+ "andrea|Ora cerco il palio. A dopo.": {
+  "file": "andrea-6e63dafda1.mp3",
+  "sec": 2.61
+ },
+ "giocatore_carte|Gnamo. In due, senza soci e senza scuse.": {
+  "file": "giocatore_carte-1523994a6c.mp3",
+  "sec": 3.78
+ },
+ "giocatore_carte|Il tavolo è qui. Il coraggio ce lo metti te.": {
+  "file": "giocatore_carte-8dfadb4acc.mp3",
+  "sec": 3.4
+ },
+ "giocatore_carte|Ai undici. E occhio al settebello: quello è sempre mio.": {
+  "file": "giocatore_carte-af54c11857.mp3",
+  "sec": 4.27
+ },
+ "giocatore_carte|Ci vuole quattro: chiamo quei due che giocano qui dietro. Uno ti fa da socio.": {
+  "file": "giocatore_carte-3e2671e35e.mp3",
+  "sec": 4.88
+ },
+ "andrea|Con le toscane.": {
+  "file": "andrea-e8599cc8b6.mp3",
+  "sec": 1.03
+ },
+ "andrea|Con le napoletane.": {
+  "file": "andrea-be276497e3.mp3",
+  "sec": 1.09
+ },
+ "andrea|Ci ripenso.": {
+  "file": "andrea-b851b9ed26.mp3",
+  "sec": 0.8
+ },
+ "giocatore_carte|Brao. Gobbo, donna e regio, come Dio comanda. Come la vuoi?": {
+  "file": "giocatore_carte-89686f55a0.mp3",
+  "sec": 6.14
+ },
+ "giocatore_carte|Le napoletane? Le tengo per i villeggianti. Come la vuoi?": {
+  "file": "giocatore_carte-4f39bc172d.mp3",
+  "sec": 5.13
+ },
+ "andrea|Alla bona.": {
+  "file": "andrea-67afa54e05.mp3",
+  "sec": 0.69
+ },
+ "andrea|Seria.": {
+  "file": "andrea-f6ef96032e.mp3",
+  "sec": 0.58
+ },
+ "andrea|A fassi male.": {
+  "file": "andrea-f52137b691.mp3",
+  "sec": 0.78
+ },
+ "giocatore_carte|Alla bona. I carichi li regalo, oggi.": {
+  "file": "giocatore_carte-43e76cf11b.mp3",
+  "sec": 3.43
+ },
+ "giocatore_carte|Allora posa il gomito e guarda le carte.": {
+  "file": "giocatore_carte-f1f219bd1c.mp3",
+  "sec": 2.51
+ },
+ "giocatore_carte|Io le conto tutte. Anche quelle che butti via per sbaglio.": {
+  "file": "giocatore_carte-12f97003ec.mp3",
+  "sec": 4.19
+ },
  "andrea|Una Fanta.": {
   "file": "andrea-8927b87738.mp3",
   "sec": 0.65
@@ -1827,18 +1987,6 @@
   "file": "mariano-1c9cd0c325.mp3",
   "sec": 5.96
  },
- "andrea|Alla bona.": {
-  "file": "andrea-67afa54e05.mp3",
-  "sec": 0.69
- },
- "andrea|Seria.": {
-  "file": "andrea-f6ef96032e.mp3",
-  "sec": 0.58
- },
- "andrea|A fassi male.": {
-  "file": "andrea-f52137b691.mp3",
-  "sec": 0.78
- },
  "mariano|Alla bona: tiro con gli occhi chiusi.": {
   "file": "mariano-b1b1ca273b.mp3",
   "sec": 2.2
@@ -1995,6 +2143,38 @@
   "file": "castello-dc8a873d86.mp3",
   "sec": 4.36
  },
+ "giocatore_carte|Oh, bravo! Ora però rimescolo io.": {
+  "file": "giocatore_carte-a8846bfa7b.mp3",
+  "sec": 2.9
+ },
+ "giocatore_carte|I carichi portali qui, mica alla stazione! Rivincita quando vuoi.": {
+  "file": "giocatore_carte-6ce98bce81.mp3",
+  "sec": 4.72
+ },
+ "giocatore_carte|Sessanta pari. Un si litiga nemmeno sul conto!": {
+  "file": "giocatore_carte-13af2e2331.mp3",
+  "sec": 3.86
+ },
+ "giocatore_carte|Vai, ti tengo il posto. Le carte mica scappano.": {
+  "file": "giocatore_carte-729b3344da.mp3",
+  "sec": 3.3
+ },
+ "giocatore_carte|Ventuno per primi. Bella coppia, voi due!": {
+  "file": "giocatore_carte-3215efd9dd.mp3",
+  "sec": 3.51
+ },
+ "giocatore_carte|Ventuno! Il tressette è un'arte: si studia da piccini.": {
+  "file": "giocatore_carte-5dbd39a25f.mp3",
+  "sec": 4.44
+ },
+ "giocatore_carte|Settebello, primiera e pure le scope. Oggi l'hai vista bene.": {
+  "file": "giocatore_carte-9a43eb8b2c.mp3",
+  "sec": 5.54
+ },
+ "giocatore_carte|Undici! Il settebello lo sento arrivare da lontano.": {
+  "file": "giocatore_carte-445e962a1b.mp3",
+  "sec": 4.1
+ },
  "mariano|Aspetta, ci vuole il metro...": {
   "file": "mariano-e8b4ebf3d9.mp3",
   "sec": 1.62

docs/BRISCOLA.md

@@ -0,0 +1,137 @@
+# Briscola all’oratorio
+
+Implementazione del 26 ottobre 2026. ES modules statici, nessun build step.
+
+## Partita e comandi
+
+Il giocatore di carte è un personaggio inventato e provvisorio, seduto a destra alle tavolate
+dell’oratorio: **[DA ANDREA: chi è]**. Il dialogo offre «Alla bona», «Seria», «A fassi male»;
+dopo una partita conclusa offre la rivincita. `briscola_vinta` ricorda una vittoria e
+`briscola_giocata` abilita la rivincita anche dopo sconfitta o patta. Nessuno dei due flag
+serve alla soluzione dell’avventura.
+
+Un clic o tocco su una carta la gioca al rilascio sullo stesso bersaglio. Nessuna carica.
+Le frecce e 1–2–3 scelgono, Invio gioca, Esc esce. I tre pulsanti con nome e seme
+offrono bersagli aggiuntivi e accesso tramite Tab. I comandi di tiro degli altri minigiochi
+rimangono separati; in `MINIGAMES` pressione, rilascio, annullamento e mira sono opzionali.
+
+Mazzo da 40 carte, 120 punti, distribuzione alternata e mazziere deterministico dal seed.
+La briscola è in fondo al mazzo e compresa nel contatore. Chi prende pesca prima e riapre;
+non esiste obbligo di seme. La presa resta visibile 1,25 secondi. Solo dopo la ventesima
+presa si contano tutte le carte, una ogni 0,35 secondi, mostrando carta ingrandita,
+incremento e totale. A 60–60 il risultato è patta. Il risultato resta fino all’uscita.
+
+## Avversari e taratura
+
+`observation` espone soltanto la propria mano, le carte pubbliche, i conteggi e l’eventuale
+briscola pescata dall’altro. Non passa la mano avversaria, l’ordine del mazzo o il seed della
+distribuzione. «Alla bona» sceglie casualmente; «Seria» scarta lisci, conserva briscole e
+prende carichi con quelle piccole. «A fassi male» ricostruisce le carte non viste, confronta
+le mosse su 40 distribuzioni possibili e simula seguiti giocati con buon senso. Sono ipotesi,
+non la distribuzione effettiva. A mazzo finito il complemento delle carte pubbliche e della
+propria mano identifica l’altra mano: da quel momento usa minimax esatto fino alla fine.
+
+Comando riproducibile: `node tools/calibrate_briscola.mjs 1000`.
+Semi `Math.imul(i, 2654435761) >>> 0`, i da 1 a 1000, stessi mazzi per ogni livello.
+Andrea usa sempre `attentive`, l’euristica di riferimento; dà le carte 496 volte su 1000.
+
+| Livello | Vittorie Andrea | Vittorie avversario | Patte | Punti medi Andrea |
+| --- | ---: | ---: | ---: | ---: |
+| Alla bona | 847 (84,7%) | 144 (14,4%) | 9 (0,9%) | 79,159 |
+| Seria | 481 (48,1%) | 494 (49,4%) | 25 (2,5%) | 59,952 |
+| A fassi male | 359 (35,9%) | 621 (62,1%) | 20 (2,0%) | 55,628 |
+
+Queste percentuali misurano il confronto con quell’automatismo, non con giocatori umani.
+
+## Revisione di Codex (26 ottobre, i tre giochi insieme)
+
+Regole promosse. Corretti: uscendo durante il conteggio si perdeva una vittoria già fatta (ora il risultato è
+deciso all'ultima presa e il conteggio lo mostra soltanto) e, per tutti e tre i giochi, l'esito che non finiva
+nel salvataggio se dal risultato si tornava al titolo; Spazio sui pulsanti come negli altri giochi; la briscola e
+la carta in tavola dette anche a parole; l'aiuto coi nomi di tutti e due i mazzi; «Rivincita a briscola?».
+Proposta non fatta: i seguiti campionati di «A fassi male» col finale esatto, e l'obiettivo vittoria invece dei punti.
+
+## Grafica e audio
+
+Due mazzi, scelti nel dialogo («Con le toscane» / «Con le napoletane»): stesse regole e stessi id, cambiano
+nomi e disegni (`DECKS` e `DECK_CARDS` in `briscola.js`; la scelta è il flag `carte_napoletane`).
+
+- **Toscane** (predefinite): semi francesi cuori, mattoni, fiori, picche; figure gobbo, donna e regio (il regio
+  sempre con la corona). Numerali senza numeri, semi disposti come nel mazzo vero e capovolti nella metà bassa;
+  figure intere col seme e la lettera (G, D, R) in alto a sinistra. Riferimento: `assets/raw/carte/toscane-riferimento.png`.
+- **Napoletane**: monete, coppe, lame ricurve incrociate, bastoni nodosi; fante, cavallo e re. Valore nell’angolo
+  e seme scritto per non affidarsi solo al colore.
+
+Tutto disegnato via canvas, in pixel art originale.
+I bersagli della mano sono 84×120 pixel a 640×360. Dorso con serpentello coronato e cornice
+simmetrica; tavolino di legno e panno, mano avversaria coperta, mazzo e mucchietti delle prese.
+
+Sprite generato con lo **strumento immagini integrato**, poi preparato con
+`slice_sprites.py --alpha --fixed-grid --cols 2 --rows 2` e `prepare_character.py`.
+Pose: `sit`, `talk`, `laugh`, `shuffle`. Foglio originale in
+`assets/raw/giocatore-carte-sheet.png`; prompt completo in
+`prompts/personaggi/giocatore-carte-sheet.txt` (entrambi esclusi da git).
+
+Effetti Web Audio `card-slide`, `card-tap`, `card-shuffle`, collegati allo stesso volume,
+muto e pausa degli altri effetti. Il colpo accompagna l’arrivo della carta dopo lo scorrimento.
+13 nuove battute XTTS (4 Andrea, 9 giocatore), con indice e durate aggiornati.
+Per generarle senza GPU/rete, `tools/voci_xtts.py` accetta `XTTS_DEVICE=cpu` e
+`XTTS_MODEL_DIR` con la cartella del modello già scaricato; le impostazioni predefinite
+rimangono quelle del progetto. Non è stata verificata all’ascolto la pronuncia delle nuove voci.
+
+## Verifica e limiti della sessione
+
+**`npm test`: passato.** Regole, determinismo, conservazione delle 40 carte e dei 120 punti,
+pescata, ultima briscola, fine mazzo, patta, livelli, accesso negato ai dati nascosti,
+minimax confrontato con un oracolo esaustivo, renderer puro, input geometrico,
+dialoghi/flag/rivincita e audio. Passano anche i test precedenti e la soluzione completa.
+
+`npm run browser` e `npm run browser:briscola` sono stati lanciati ma **bloccati dall’ambiente**:
+`PermissionError: [Errno 1] Operation not permitted` alla creazione del socket del server.
+Anche l’avvio isolato di Chromium fallisce con `sandbox_host_linux.cc:41`,
+`shutdown: Operation not permitted`. Non è stato possibile verificare l’interfaccia reale
+con Playwright né produrre schermate desktop/telefono.
+
+Il test `tests/briscola.browser.mjs` è pronto: partite complete con mouse, touch e tastiera
+su desktop e telefono verticale, più touch orizzontale; pausa, muto, gesto annullato,
+conteggio, risultato e rivincita. Accelera solo le attese tramite `game.update`, senza
+giocare carte di Andrea direttamente nel motore. Salva in `/tmp/regolo-shots/briscola-*.png`.
+Le misure Web Audio dei tre nuovi suoni sono comprese nel collaudo browser multimedia.
+
+Anteprime **offline, non schermate browser**, prodotte e ispezionate nella sessione:
+
+- `/tmp/regolo-shots/briscola-offline-carte.png`
+- `/tmp/regolo-shots/briscola-offline-tavolo.png`
+- `/tmp/regolo-shots/briscola-offline-risultato.png`
+
+## File
+
+Nuovi: `src/engine/briscola.js`, `src/engine/briscola-render.js`,
+`assets/characters/giocatore-carte.png`, `assets/characters/giocatore-carte.json`,
+`tests/briscola.test.mjs`, `tests/briscola-render.test.mjs`, `tests/briscola.browser.mjs`,
+`tools/calibrate_briscola.mjs`, questo documento e 13 MP3 elencati qui sotto.
+
+Modificati: `src/engine/game.js`, `src/engine/render.js`, `src/engine/soundscape.js`,
+`src/main.js`, `src/story/story.js`, `index.html`, `style.css`, `package.json`,
+`tests/story.test.mjs`, `tests/multimedia.test.mjs`, `tests/multimedia.browser.mjs`,
+`tools/voci.json`, `tools/voci_xtts.py`, `assets/voices/index.json`.
+
+Nuovi file in `assets/voices/`:
+
+```text
+andrea-6e63dafda1.mp3
+andrea-71f3bff8a0.mp3
+andrea-b851b9ed26.mp3
+andrea-d2f285f610.mp3
+giocatore_carte-12f97003ec.mp3
+giocatore_carte-13af2e2331.mp3
+giocatore_carte-43e76cf11b.mp3
+giocatore_carte-6ce98bce81.mp3
+giocatore_carte-729b3344da.mp3
+giocatore_carte-8dfadb4acc.mp3
+giocatore_carte-9c07caaab4.mp3
+giocatore_carte-a8846bfa7b.mp3
+giocatore_carte-f1f219bd1c.mp3
+```
+
+`docs/STATO.md` invariato. Nessun commit, tag o push.

docs/IMMAGINI.md

@@ -27,6 +27,8 @@ ne è un'opera derivata. Le foto scattate da Andrea non hanno problemi; quelle p
 | `bosco-ai-frati.png` | Codex | `bosco-ai-frati.png` | [DA ANDREA] sembra una foto da Wikipedia/Wikimedia: verificare licenza | ? |
 | `campeggio.png` | Codex | `campeggio-ingresso.png` | [DA ANDREA] probabilmente dal sito del campeggio | ? |
 | `polisportiva-*.png`, `ponte-sieve.png`, `area-feste.png`, `via-provinciale.png`, `comune-asilo.png`, `giardini-poste.png`, `stazione.png` | Codex | foto omonime in `assets/raw/foto/` | Andrea (EXIF, 23 ottobre 2026) | sì |
+| `via-del-pignone.png` | Codex | `via-del-pignone.png` (murale: `riferimenti/cistola.png`, `murale-maradona.png`) | Andrea | sì (Cistola consenziente) |
+| `provinciale-pignone.png`, `piazzetta-cambray-digny.png` | Codex | screenshot di Google Street View | Google | **no**: da rifare con foto di Andrea |
 | `cardetole.png` | Codex | `cardetole.jpg` | Andrea (EXIF) | **da decidere**: è la casa vera di Andrea, pubblicarla dice dove abita |
 | `pieve-interno.png` | Codex | `pieve-interno.png` | Mariano Mirannalti (mandata ad Andrea su WhatsApp) | sì, se Mariano è d'accordo; citarlo nei crediti |
 | `panorama-intro.png` | Codex | `altre/panorama-intro.png` | da internet (screenshot con l'icona di Google Lens) | **no**, finché non si sostituisce |

docs/LICENZA-CPML.txt

@@ -0,0 +1,84 @@
+# Coqui Public Model License 1.0.0
+https://coqui.ai/cpml.txt
+
+
+This license allows only non-commercial use of a machine learning model and its outputs.
+
+
+## Acceptance
+
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+
+## Licenses
+
+
+The licensor grants you a copyright license to do everything you might do with the model that would otherwise infringe the licensor's copyright in it, for any non-commercial purpose. The licensor grants you a patent license that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the model in the form provided by 
+the licensor, for any non-commercial purpose.
+
+
+## Non-commercial Purpose
+
+
+Non-commercial purposes include any of the following uses of the model or its output, but only so far as you do not receive any direct or indirect payment arising from the use of the model or its output.
+
+
+### Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious
+observance. 
+
+
+### Use by commercial or for-profit entities for testing, evaluation, or non-commercial research and development. Use of the model to train other models for commercial use is not a non-commercial purpose. 
+
+
+### Use by any charitable organization for charitable purposes, or for testing or evaluation. Use for revenue-generating activity, including projects directly funded by government grants, is not a non-commercial purpose.
+
+
+## Notices
+
+
+You must ensure that anyone who gets a copy of any part of the model, or any modification of the model, or their output, from you also gets a copy of these terms or the URL for them above.
+
+
+## No Other Rights
+
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+
+## Patent Defense
+
+
+If you make any written claim that the model infringes or contributes to infringement of any patent, your licenses for the model granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+
+## Violations
+
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the model or its output that is not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 30 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+
+## No Liability
+
+
+***As far as the law allows, the model and its output come as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the model or its output, under any kind of legal claim. If this provision is not enforceable in your jurisdiction, your licenses are void.***
+
+
+## Definitions
+
+
+The **licensor** is the individual or entity offering these terms, and the **model** is the model the licensor makes available under these terms, including any documentation or similar information about the model.
+
+
+**You** refers to the individual or entity agreeing to these terms.
+
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+
+**Your licenses** are all the licenses granted to you under these terms.
+
+
+**Use** means anything you do with the model or its output requiring one of your licenses.

docs/SCOPA.md

@@ -0,0 +1,45 @@
+# Scopa agli 11
+
+All'oratorio, dal giocatore di carte: «Una scopa?». In due, Andrea contro il giocatore di carte, con le toscane o
+le napoletane (stessa scelta della briscola). Motore `src/engine/scopa.js` (Claude), tavolo `src/engine/scopa-render.js`.
+
+## Regole
+
+- Valori: Asso 1, poi i numeri, gobbo (fante) 8, donna (cavallo) 9, regio (re) 10.
+- Quattro carte in tavola (con tre o quattro re si rimescola), tre a testa; finite le tre, se ne danno altre tre.
+  Gioca per primo chi non fa le carte; il mazziere cambia a ogni smazzata.
+- Una carta prende quella dello stesso valore (se ce n'è più d'una si sceglie quale); se non c'è, un gruppo di carte
+  che somma il suo valore (più gruppi: si sceglie). Se la presa c'è, è obbligatoria. Se no, la carta resta in tavola.
+- **Scopa**: chi pulisce la tavola fa un punto; non vale con l'ultima carta della smazzata.
+- A fine smazzata le carte in tavola vanno all'ultimo che ha preso. Un punto per: **carte** (più di 20), **mattoni**
+  (con le napoletane i denari, più di 5), **settebello** (il 7 di mattoni o di denari), **primiera** (la carta
+  migliore di ogni seme: 7 = 21, 6 = 18, Asso = 16, 5 = 15, 4 = 14, 3 = 13, 2 = 12, figure 10; senza un seme non
+  si fa), e uno per scopa. A pari, il punto non va a nessuno.
+- Si va **agli 11**, contati a fine smazzata: vince chi ne ha di più; pari (o nessuno agli 11), un'altra smazzata.
+
+## Avversari
+
+- «Alla bona»: una mossa a caso fra quelle possibili.
+- «Seria»: sceglie la mossa che vale di più (settebello, mattoni, carte, scope, e la primiera per quanto migliora la
+  propria: un 6 di un seme dove si ha solo una figura vale più di uno dove si ha già il 7) e teme a occhio di
+  lasciare una scopa.
+- «A fassi male»: come «Seria», ma conta le carte non viste per stimare se l'altro può fare scopa, non lascia 7 in
+  tavola e, a mazzo finito (le carte dell'altro sono proprio quelle non viste), calcola il finale esatto fino al
+  conteggio.
+
+Taratura (`node tools/calibrate_scopa.mjs 300`, Andrea che gioca come «A fassi male»): Andrea vince 96% contro
+«Alla bona», 76% contro «Seria», 50% contro «A fassi male»; circa quattro smazzate a partita.
+
+## Revisione di Codex (26 ottobre, i tre giochi insieme)
+
+Regole promosse (valori, presa obbligatoria, precedenza della carta uguale, scopa non all'ultima, residui
+all'ultimo, maggioranze e pari, primiera, re in tavola, agli 11). Corretti: frecce e Invio che potevano prendere la
+presa sbagliata (ora il fuoco segue la scelta); il tocco sulla tavola che agiva alla pressione e non bastava con
+prese sovrapposte (ora al rilascio: il primo tocco sceglie, il secondo conferma); primiera valutata a occhio;
+finali sbagliati a mazzo finito; la tavola descritta a parole; aiuto con i valori della primiera e i pari.
+
+## Prove
+
+`npm test` (`tests/scopa.test.mjs`) e `npm run browser:scopa`: partita intera col mouse, una smazzata col tocco
+(telefono e orizzontale) e con la tastiera; in ogni caso una presa da scegliere fra due (toccando la tavola, con
+un pulsante o con frecce e Invio). Schermate in `/tmp/regolo-shots/scopa-*.png`.

docs/STATO.md

@@ -18,6 +18,17 @@ Online su 50037.manzolo.it tutto fino agli effetti ambientali di Codex. Aperto,
 
 ## Dove siamo arrivati
 
+- **Briscola all'oratorio (26 ottobre)**: alle tavolate siede «Il giocatore di carte» (segnaposto, [DA ANDREA: chi è],
+  sprite e battute provvisorie di Codex). Parlandoci si sceglie il mazzo (toscane o napoletane) e il livello
+  («Alla bona», «Seria», «A fassi male»), poi briscola a due fedele alle regole, conteggio delle prese a fine
+  partita e rivincita. Facoltativa: nessun flag serve alla soluzione. Motore `src/engine/briscola.js` (Claude),
+  disegno `briscola-render.js` (Codex), dettagli e taratura in `docs/BRISCOLA.md`. Prova: `npm run browser:briscola`.
+  **Tressette ai 21** (stesso giocatore, «Un tressette ai 21?»): in quattro a coppie, busso/striscio/volo e accuse,
+  motore e tavolo di Claude, regole e taratura in `docs/TRESSETTE.md`, prova `npm run browser:tressette`.
+  **Scopa agli 11** («Una scopa?»): carte, mattoni (o denari), settebello, primiera e scope, presa a scelta fra
+  più possibili; `docs/SCOPA.md`, prova `npm run browser:scopa`. Con la scopa i giochi di carte sono finiti
+  (decisione di Andrea, 26 ottobre). Tressette rivisto dopo la revisione critica di Codex (in `docs/TRESSETTE.md`).
+
 - **Multimedia (25 ottobre, modifiche locali)**: il libro sfogliabile già presente conserva immagini, battute e
   riapertura dall'inventario; il fruscio ora segue il volume degli effetti, non quello delle voci.
   Nuovi paesaggi sonori sintetizzati con Web Audio (`src/engine/soundscape.js`, profili in
@@ -188,6 +199,11 @@ I prompt fissi (stile, scene, foglio sprite) sono in `prompts/STILE.md`, escluso
   sfondi da foto prese da internet (`docs/IMMAGINI.md`), Cardetole (dice dove abita Andrea).
 - Vecchietta e vecchietto sono in gioco sulla panchina della Piazza (`assets/characters/`, da
   `assets/raw/vecchiett?-sheet.png`): consenso delle persone ritratte confermato da Andrea il 2026-10-23; mancano i loro nomi.
+- Via Provinciale (dalla rotonda verso la Pieve) → a destra Via del Pignone → in cima Piazzetta Cambray Digny, che porta
+  in Piazza (a sinistra, dove prima c'era l'uscita per il Comune) e in Via de' Medici. Battute provvisorie sul murale.
+  Via del Pignone (sfondo di Codex da `assets/raw/foto/via-del-pignone.png`): sul muro di destra il
+  murale di Cistola (Davide Poggi), «il talento di via del Pignone», alla maniera dei murali di Maradona a Napoli
+  (volto da `assets/raw/riferimenti/cistola.png`). Consenso di Davide confermato da Andrea il 2026-10-27.
 - Andrea rifatto dalla sua foto del 2007 (`assets/raw/andrea-sheet-prova-2.png`; il vecchio foglio resta in `andrea-sheet.png`).
 - Strada del campeggio (poi Bosco ai Frati) e strada della scuola: per ora battute, scene da fare con le foto di Andrea.
 

docs/TRESSETTE.md

@@ -0,0 +1,62 @@
+# Tressette ai 21
+
+All'oratorio, dal giocatore di carte: «Un tressette ai 21?». Quattro al tavolo, a coppie: Andrea e il socio
+(di fronte) contro il giocatore di carte e l'altro. [DA ANDREA: chi sono il socio e l'altro.]
+Motore `src/engine/tressette.js` (Claude), disegno `src/engine/tressette-render.js` con le carte della briscola.
+
+## Regole
+
+- Mazzo da 40, toscane o napoletane (stessa scelta e stesso flag `carte_napoletane` della briscola). Dieci carte a testa.
+- Si gira verso destra (antiorario); esce chi sta a destra del mazziere, e il mazzo passa a destra a ogni smazzata.
+- Obbligo di rispondere al seme. Prende la più alta del seme di uscita: 3, 2, Asso, regio, donna, gobbo, 7, 6, 5, 4.
+- Punti in terzi: Asso 3 terzi, 3, 2 e figure 1 terzo; l'ultima presa 1 punto. 35 terzi per smazzata, i terzi
+  avanzati si perdono: le due coppie fanno sempre 11 punti in tutto.
+- **Accuse**, dette da ognuno al proprio turno giocando la prima carta della smazzata: napoletana (Asso, 2 e 3
+  dello stesso seme) 3 punti; tre Assi, tre 2 o tre 3 fanno 3 punti (dicendo il seme che manca), quattro fanno 4.
+  Restano scritte in alto per tutta la smazzata: Andrea sa quel che sanno gli avversari.
+- **Segni**, solo di chi esce: busso (prendi con la migliore e ritornamelo; si può sempre), striscio (ne ho
+  altre), volo (era l'ultima). Volo e striscio sono onesti: il gioco rifiuta quelli falsi. Si sentono: due nocche
+  sul tavolo, la carta strusciata, la carta lasciata cadere.
+- Si va **ai 21**, presa per presa: il punteggio in alto conta accuse e punti interi già presi, e la coppia che
+  arriva a 21 per prima è fuori e ha vinto, anche a metà smazzata (le accuse contano alla fine della presa in cui
+  si dicono). Il risultato è subito definitivo: uscire dal riepilogo non lo cancella. Il riepilogo di fine
+  smazzata resta finché Andrea non va avanti.
+
+Scelte da confermare con Andrea: «fuori» automatico ai 21 (al tavolo vero bisogna chiamarsi fuori, e se si
+sbaglia si perde); nessun «cappotto»; nessuna napoletana lunga; segni ammessi anche alla prima presa.
+
+## Avversari
+
+- «Alla bona»: una carta a caso fra quelle buone, nessun segno.
+- «Seria»: gioca a regola (carico al socio quando prende di sicuro, presa sicura con la carta più bassa, scarta
+  quel che costa meno, segni onesti) ma non conta: un 3 uscito per lui può essere ancora in giro.
+- «A fassi male»: conta le carte uscite, capisce chi ha finito un seme (anche da chi vola), ricorda le accuse,
+  risponde al busso del socio prendendo con la migliore e poi gli ritorna il seme. Il socio di Andrea gioca sempre così.
+- Tutti: il carico al socio che prende di sicuro, ma senza buttarci il 3 o il 2; a parità di lunghezza si esce dal
+  seme con meno punti da esporre (niente Asso scoperto).
+
+Taratura (`node tools/calibrate_tressette.mjs 300`, Andrea che gioca come il socio): Andrea e il socio vincono
+87% contro «Alla bona», 61% contro «Seria», 48% contro «A fassi male»; circa tre smazzate a partita.
+
+## Revisione di Codex (26 ottobre)
+
+Revisione critica sul primo giro. Corretti: vittoria persa uscendo dal riepilogo; accuse tutte pubbliche prima
+della prima carta; il seme mancante del tris noto all'IA ma non ad Andrea; striscio troppo stretto e busso con
+un requisito inventato; il socio che non rispondeva al busso, sprecava il 3 su una presa già sua o usciva
+d'Asso scoperto; il volo non letto da «A fassi male»; tastiera che poteva giocare la carta sbagliata; il
+riepilogo che ripartiva da solo dopo sette secondi; la tavola descritta a parole per chi non vede il disegno.
+Restano proposte (non fatte): una tabella di tavolo accessibile completa e la taratura contro una versione
+precedente dell'IA.
+
+Seconda revisione (i tre giochi insieme). Corretti: con le accuse tutte e due le coppie potevano arrivare ai 21 e
+vinceva sempre Andrea (ora esce chi arriva per primo, anche con un'accusa, nel momento in cui la dice); il socio
+che teneva il 2 anche quando caricarlo voleva dire vincere subito (l'IA vede ora punteggio e terzi del tabellone);
+Invio su un pulsante che giocava la carta col fuoco invece di quella scelta; il pannello delle accuse che usciva
+dal tavolo; le convenzioni del tavolo scritte anche nel «Come si gioca». Per tutti e tre i giochi l'esito vale e
+si salva appena deciso (anche tornando al titolo dalla schermata del risultato).
+
+## Prove
+
+`npm test` (`tests/tressette.test.mjs`) e `npm run browser:tressette`: partita intera ai 21 col mouse, una smazzata
+col tocco (telefono e orizzontale) e con la tastiera, segni con pulsanti e tasti B, S, V, carta che non risponde
+al seme rifiutata. Schermate in `/tmp/regolo-shots/tressette-*.png`.

index.html

@@ -4,6 +4,11 @@
 <meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
 <meta name="theme-color" content="#1b1420"><meta name="description" content="La Leggenda del Regolo: un'avventura punta-e-clicca a San Piero a Sieve, durante il Palio della Fortezza del 2007.">
 <title>La Leggenda del Regolo</title>
+<!-- Il Regolino (tools/favicon.py, disegnato da Codex pixel per pixel) -->
+<link rel="icon" href="assets/favicon/favicon.ico" sizes="16x16 32x32 48x48">
+<link rel="icon" type="image/png" sizes="32x32" href="assets/favicon/favicon-32.png">
+<link rel="icon" type="image/png" sizes="192x192" href="assets/favicon/icon-192.png">
+<link rel="apple-touch-icon" href="assets/favicon/apple-touch-icon.png">
 <link rel="stylesheet" href="style.css">
 </head>
 <body>
@@ -28,6 +33,7 @@
       <p class="splash-name">Manzolo</p>
       <p class="splash-art"><span>(Poca)</span> Art</p>
       <p class="splash-present">Presents</p>
+      <p class="splash-hint">Tocca per cominciare</p>
     </section>
     <section id="title" class="overlay" hidden>
       <h1>La Leggenda<br>del <span>Regolo</span></h1>
@@ -86,6 +92,11 @@
       <p class="hint">La partita è salvata: dal titolo si riprende con «Continua». Con «Salva su file» la porti su un altro dispositivo e la apri con «Carica».</p>
       <p class="version"></p>
     </section>
+    <section id="tutorial" class="overlay" hidden aria-labelledby="tutorial-title">
+      <h2 id="tutorial-title">Come si gioca</h2>
+      <video id="tutorial-video" controls playsinline preload="metadata"></video>
+      <div class="buttons"><button id="tutorial-close">Torna al gioco</button></div>
+    </section>
     <section id="credits" class="overlay" hidden aria-label="Ringraziamenti">
       <h2>Ringraziamenti</h2>
       <p class="dedication credits-dedication">Al Lele, che mi ha fatto conoscere Monkey Island.</p>
@@ -103,6 +114,82 @@
     <div id="inventory" aria-label="Inventario"></div>
   </div>
   <ol id="choices" hidden></ol>
+  <section id="scopa-controls" hidden aria-label="Comandi della scopa">
+    <p id="scopa-status" role="status"></p>
+    <div class="card-hand" aria-label="La mano di Andrea">
+      <button id="scopa-card-0" type="button"></button>
+      <button id="scopa-card-1" type="button"></button>
+      <button id="scopa-card-2" type="button"></button>
+    </div>
+    <div id="scopa-options" class="card-buttons" hidden aria-label="Quale presa"></div>
+    <button id="scopa-next" type="button" hidden>Prossima smazzata</button>
+    <details><summary>Come si gioca</summary>
+      <button class="tutorial-open" type="button" data-tutorial="scopa" hidden>Guarda il video</button>
+      <p>Si gioca una carta: se in tavola ce n’è una dello stesso valore la prendi; se no prendi le carte che sommano
+      il suo valore. Se la presa c’è, è obbligatoria; se sono più d’una, scegli tu. Asso 1, gobbo 8, donna 9, regio 10.
+      Chi pulisce la tavola fa scopa (non con l’ultima carta). Quel che resta alla fine va all’ultimo che ha preso.</p>
+      <p>A fine smazzata un punto per: più carte, più mattoni (con le napoletane i denari), il settebello (il 7 di
+      mattoni o di denari), la primiera, e uno per ogni scopa. A pari, il punto non va a nessuno.</p>
+      <p>Primiera: si somma la carta migliore di ogni seme (7 = 21, 6 = 18, Asso = 16, 5 = 15, 4 = 14, 3 = 13, 2 = 12,
+      figure 10); chi non ha almeno una carta per seme non la fa. Si va agli 11, contati a fine smazzata: vince chi ne
+      ha di più; pari, se ne fa un’altra.</p>
+    </details>
+  </section>
+  <section id="tressette-controls" hidden aria-label="Comandi del tressette">
+    <p id="tressette-status" role="status"></p>
+    <div class="card-buttons" aria-label="Segni per il socio, solo quando esci">
+      <button id="tressette-busso" type="button">Busso</button>
+      <button id="tressette-striscio" type="button">Striscio</button>
+      <button id="tressette-volo" type="button">Volo</button>
+      <button id="tressette-next" type="button" hidden>Prossima smazzata</button>
+    </div>
+    <div class="card-hand-many" aria-label="La mano di Andrea">
+      <button id="tressette-card-0" type="button"></button>
+      <button id="tressette-card-1" type="button"></button>
+      <button id="tressette-card-2" type="button"></button>
+      <button id="tressette-card-3" type="button"></button>
+      <button id="tressette-card-4" type="button"></button>
+      <button id="tressette-card-5" type="button"></button>
+      <button id="tressette-card-6" type="button"></button>
+      <button id="tressette-card-7" type="button"></button>
+      <button id="tressette-card-8" type="button"></button>
+      <button id="tressette-card-9" type="button"></button>
+    </div>
+    <details><summary>Come si gioca</summary>
+      <button class="tutorial-open" type="button" data-tutorial="tressette" hidden>Guarda il video</button>
+      <p>In quattro, a coppie: Andrea e il socio di fronte contro gli altri due. Si gira verso destra.
+      Chi esce gioca quel che vuole, gli altri devono rispondere al seme se ce l’hanno. Prende la carta più alta
+      del seme di uscita: 3, 2, Asso, regio, donna, gobbo, 7, 6, 5, 4. Chi prende esce.</p>
+      <p>L’Asso vale un punto; 3, 2 e figure un terzo di punto; l’ultima presa un punto. Si va ai 21: la coppia che
+      ci arriva per prima è fuori e ha vinto, anche a metà smazzata.</p>
+      <p>Accuse, dette da ognuno giocando la sua prima carta: napoletana (Asso, 2 e 3 dello stesso seme) 3 punti;
+      tre Assi, tre 2 o tre 3 fanno 3 punti (si dice il seme che manca), quattro fanno 4.</p>
+      <p>Convenzioni di questo tavolo: il «fuori» ai 21 è automatico (un’accusa o una presa che ci porta fa vincere
+      subito); niente cappotto; i segni valgono anche alla prima presa.</p>
+      <p>Segni, solo di chi esce: <b>busso</b> (prendi con la migliore e ritornami il seme),
+      <b>striscio</b> (di questo seme ne ho altre), <b>volo</b> (era l’ultima). Prima scegli il segno, poi la carta.
+      Tastiera: B, S, V; frecce e 1–0 scelgono, Invio gioca, Esc lascia il tavolo.</p>
+    </details>
+  </section>
+  <section id="briscola-controls" hidden aria-label="Comandi della briscola">
+    <p id="briscola-status" role="status"></p>
+    <div class="card-hand" aria-label="La mano di Andrea">
+      <button id="briscola-card-0" type="button"></button>
+      <button id="briscola-card-1" type="button"></button>
+      <button id="briscola-card-2" type="button"></button>
+    </div>
+    <details><summary>Come si gioca</summary>
+      <button class="tutorial-open" type="button" data-tutorial="briscola" hidden>Guarda il video</button>
+      <p>Tocca una carta sul tavolo o il suo nome qui sotto per giocarla. Frecce o 1–2–3 scelgono; Invio gioca.
+      Esc lascia il tavolo. Vince chi fa almeno 61 punti; 60 a 60 è patta.</p>
+      <p>Non sei obbligato a rispondere al seme. Prende la briscola più alta, oppure la carta più alta del seme
+      di uscita. Ordine: Asso, 3, regio (re), donna (cavallo), gobbo (fante), 7, 6, 5, 4, 2.
+      Asso 11 punti, 3 dieci, regio 4, donna 3, gobbo 2; le altre zero. Fra parentesi i nomi delle napoletane.</p>
+      <p>Chi prende pesca per primo e poi esce. La briscola scoperta è l’ultima carta del mazzo;
+      il contatore la comprende. Finito il mazzo, si giocano le carte rimaste e si contano le prese.
+      Durante la partita i punti non si dicono!</p>
+    </details>
+  </section>
   <section id="bocce-controls" hidden aria-label="Comandi delle bocce">
     <p id="bocce-status" role="status"></p>
     <div class="bocce-adjust">
@@ -114,6 +201,7 @@
       <button id="bocce-throw" type="button">Lancia</button>
     </div>
     <details id="bocce-help"><summary>Come si gioca</summary>
+      <button class="tutorial-open" type="button" data-tutorial="bocce" hidden>Guarda il video</button>
       <p>Tocca il campo o il dettaglio del pallino per mirare. Regola la forza, poi premi Lancia.
       Il cerchio azzurro indica dove si fermerebbe la boccia senza urti.</p>
       <p>Puoi anche tenere premuto sul campo o Spazio e rilasciare per tirare.
@@ -122,6 +210,7 @@
       Vince chi fa più punti nella mano.</p>
     </details>
     <details id="biliardo-help" hidden><summary>Come si gioca</summary>
+      <button class="tutorial-open" type="button" data-tutorial="biliardo" hidden>Guarda il video</button>
       <p>Clic o tocco sul tavolo fissa la mira: puoi spostarti sui comandi senza cambiarla.
       La linea tratteggiata segue la tua biglia fino al primo urto, comprese le sponde; il cerchio vuoto indica
       il punto di contatto. Dopo l’urto, la freccia azzurra mostra la direzione dell’avversaria, quella gialla

nginx.conf

@@ -26,6 +26,8 @@ server {
         audio/mpeg mp3;
         image/svg+xml svg;
         image/x-icon ico;
+        image/jpeg jpg jpeg;
+        video/mp4 mp4;
         font/woff2 woff2;
     }
 
@@ -37,7 +39,7 @@ server {
     location ~* \.(css|js|mjs|json)$ {
         add_header Cache-Control "no-cache";
     }
-    location ~* \.(png|webp|mp3|woff2)$ {
+    location ~* \.(png|webp|jpg|mp3|mp4|woff2|ico)$ {
         add_header Cache-Control $media_cache;
     }
     location = /index.html {

package.json

@@ -1,12 +1,15 @@
 {
   "name": "leggenda-del-regolo",
-  "version": "0.1.9",
+  "version": "0.1.18",
   "private": true,
   "type": "module",
   "scripts": {
     "test": "node --test tests/*.test.mjs",
     "browser": "node tests/browser.mjs",
     "browser:biliardo": "node tests/biliardo.browser.mjs",
+    "browser:tressette": "node tests/tressette.browser.mjs",
+    "browser:scopa": "node tests/scopa.browser.mjs",
+    "browser:briscola": "node tests/briscola.browser.mjs",
     "browser:effects": "node tests/ambient.browser.mjs",
     "serve": "python3 -m http.server 8000"
   },

scripts/check-public.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# Prima di pubblicare: niente prompt, fogli grezzi, log di Codex, segreti o nomi della rete di casa.
+# Guarda tutti i percorsi raggiungibili da tutti i ref (la storia intera, non solo HEAD) e il testo di HEAD.
+# `--self-test` costruisce un repo usa e getta, inietta un prompt e un host .lan e pretende che siano rifiutati:
+# un controllo che non fallisce mai non prova niente.
+set -euo pipefail
+ROOT=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
+
+FORBIDDEN_PATHS='(^|/)(PROMPT[A-Z_]*\.md|prompts/|assets/raw/|assets/generated/|codex[a-z.-]*\.log|deploy\.local\.mk)'
+FORBIDDEN_PATHS+='|(^|/)\.env$|(^|/)id_(rsa|ed25519|ecdsa)(\.pub)?$|\.(pem|key|p12|pfx)$'
+FORBIDDEN_TEXT='[a-z0-9-]+\.lan([^a-z0-9.-]|$)|192\.168\.[0-9]+\.[0-9]+|BEGIN (RSA|OPENSSH|EC|DSA) PRIVATE KEY'
+
+scan_repo() {
+    local repo=$1 rc=0 hits
+    hits=$(git -C "$repo" rev-list --all --objects | awk 'NF>1{print $2}' | sort -u | grep -E "$FORBIDDEN_PATHS" || true)
+    if [[ -n $hits ]]; then
+        echo "FAIL: percorsi vietati nella storia (va riscritta, non basta cancellarli):"
+        echo "$hits" | head -40 | sed 's/^/  /'
+        rc=1
+    fi
+    hits=$(git -C "$repo" grep -nIE "$FORBIDDEN_TEXT" HEAD -- . ':!scripts/check-public.sh' 2>/dev/null | sed 's/^HEAD://' || true)
+    if [[ -n $hits ]]; then
+        echo "FAIL: testo vietato in HEAD:"
+        echo "$hits" | head -20 | sed 's/^/  /'
+        rc=1
+    fi
+    [[ $rc -eq 0 ]] && echo "PASS: niente prompt, fogli grezzi, segreti o host privati in $repo (tutti i ref)"
+    return $rc
+}
+
+self_test() {
+    local tmp
+    tmp=$(mktemp -d /tmp/check-public.XXXXXX)
+    trap 'rm -rf -- "$tmp"' RETURN
+    local -a g=(git -C "$tmp" -c user.name=check -c user.email=check@example.invalid -c commit.gpgsign=false)
+    git init -q "$tmp"
+    printf '# pulito\n' > "$tmp/README.md"
+    "${g[@]}" add README.md && "${g[@]}" commit -qm pulito
+    scan_repo "$tmp" >/dev/null || { echo 'self-test FAIL: un repo pulito deve passare'; return 1; }
+    mkdir -p "$tmp/prompts" && printf 'foto di famiglia\n' > "$tmp/prompts/character_x.md"
+    "${g[@]}" add prompts && "${g[@]}" commit -qm 'prompt iniettato'
+    "${g[@]}" rm -rq prompts && "${g[@]}" commit -qm 'cancellato (resta nella storia)'
+    if scan_repo "$tmp" >/dev/null 2>&1; then echo 'self-test FAIL: un prompt nella storia deve essere rifiutato'; return 1; fi
+    rm -rf "$tmp/.git" && git init -q "$tmp" && printf 'DEPLOY_HOST = root@casa.lan\n' > "$tmp/README.md"
+    "${g[@]}" add README.md && "${g[@]}" commit -qm 'host privato'
+    if scan_repo "$tmp" >/dev/null 2>&1; then echo 'self-test FAIL: un host .lan deve essere rifiutato'; return 1; fi
+    echo 'self-test PASS: repo pulito accettato, prompt nella storia e host .lan rifiutati'
+}
+
+[[ ${1:-} == --self-test ]] && { self_test; exit; }
+scan_repo "$ROOT"

src/engine/briscola-render.js

@@ -0,0 +1,309 @@
+import { canPlay, cardName, counted, countRows, PLAY_TIME, TRICK_HOLD, TRICK_TIME } from './briscola.js';
+import { text, panel } from './bocce-render.js';
+
+// Una carta in volo da un rettangolo [x, y, w, h] a un altro, con k da 0 a 1 (parte svelta, arriva piano).
+// La usano anche tressette e scopa.
+export function flight(from, to, k) {
+    const e = 1 - (1 - Math.min(1, Math.max(0, k))) ** 3;
+    return from.map((v, i) => v + (to[i] - v) * e);
+}
+// Coordinate condivise da disegno e hit test: bersagli larghi anche sul telefono.
+export const HAND = { x: 176, y: 230, gap: 102, w: 84, h: 120 };
+export function cardAt(c, [x, y]) {
+    if (!canPlay(c)) return -1;
+    return c.hands.player.findIndex((_, i) => x >= HAND.x + i * HAND.gap && x < HAND.x + i * HAND.gap + HAND.w && y >= HAND.y && y < HAND.y + HAND.h);
+}
+const ink = '#38271f', paper = '#fff0cd', gold = '#dba32b', red = '#aa4034', blue = '#386a89', green = '#487348';
+function rect(ctx, x, y, w, h, color) { ctx.fillStyle = color; ctx.fillRect(x, y, w, h); }
+function poly(ctx, points, color) {
+    ctx.fillStyle = color; ctx.beginPath(); points.forEach(([x, y], i) => i ? ctx.lineTo(x, y) : ctx.moveTo(x, y)); ctx.closePath(); ctx.fill();
+}
+// Simboli originali: moneta incisa, calice, lama ricurva e bastone coi nodi.
+function suit(ctx, name, x, y) {
+    ctx.save(); ctx.translate(x, y);
+    if (name === 'denari') {
+        rect(ctx, -4, -3, 8, 6, ink); rect(ctx, -3, -4, 6, 8, ink);
+        rect(ctx, -3, -2, 6, 4, gold); rect(ctx, -2, -3, 4, 6, gold);
+        rect(ctx, -2, -2, 1, 4, '#ffe58c'); rect(ctx, 0, -1, 2, 2, '#9e6b25');
+    } else if (name === 'coppe') {
+        rect(ctx, -4, -4, 8, 2, ink); rect(ctx, -3, -2, 6, 3, gold);
+        rect(ctx, -2, 0, 4, 2, red); rect(ctx, -1, 2, 2, 2, ink);
+        rect(ctx, -3, 4, 6, 1, gold); rect(ctx, -3, -3, 6, 1, '#ffdd70');
+    } else if (name === 'spade') {
+        poly(ctx, [[-4,5],[-3,1],[0,-1],[2,-5],[4,-6],[3,-1],[-1,3],[-2,6]], ink);
+        rect(ctx, 1, -3, 2, 3, '#9eb3ba'); rect(ctx, -1, 0, 2, 2, '#c9d8d6');
+        rect(ctx, -5, 3, 5, 1, gold); rect(ctx, -4, 5, 2, 2, red);
+    } else {
+        poly(ctx, [[-3,6],[-4,4],[-1,-1],[0,-6],[3,-5],[3,-2],[0,3],[-1,6]], ink);
+        rect(ctx, 0, -4, 2, 5, '#94632e'); rect(ctx, -2, 1, 2, 4, '#ae7a39');
+        rect(ctx, 2, -3, 2, 2, gold); rect(ctx, -3, 2, 2, 2, gold); rect(ctx, 3, -5, 2, 1, green);
+    }
+    ctx.restore();
+}
+function regolo(ctx) {
+    // Cornice simmetrica e un piccolo re sorridente, avvolto nelle proprie spire.
+    rect(ctx, 3, 3, 36, 54, blue); rect(ctx, 5, 5, 32, 50, gold); rect(ctx, 6, 6, 30, 48, '#203e44');
+    for (let y = 9; y < 54; y += 6) for (const x of [8, 32]) rect(ctx, x, y, 2, 2, '#63867c');
+    poly(ctx, [[15,32],[28,32],[32,36],[32,43],[28,47],[14,47],[10,43],[10,37]], ink);
+    poly(ctx, [[15,34],[27,34],[30,37],[30,42],[27,45],[15,45],[12,42],[12,38]], green);
+    poly(ctx, [[17,37],[26,37],[28,39],[27,41],[16,41],[15,39]], '#203e44');
+    rect(ctx, 14, 42, 13, 2, '#a3bc72'); rect(ctx, 16, 36, 11, 1, '#a3bc72');
+    poly(ctx, [[19,25],[25,25],[25,33],[23,36],[18,36],[17,33],[20,32]], green);
+    rect(ctx, 20, 28, 2, 6, '#d0cd83');
+    poly(ctx, [[15,16],[27,16],[30,19],[30,25],[27,29],[15,29],[12,25],[12,20]], ink);
+    poly(ctx, [[16,17],[26,17],[29,20],[29,24],[26,27],[16,27],[13,24],[13,21]], '#94b365');
+    rect(ctx, 15, 19, 4, 4, paper); rect(ctx, 23, 19, 4, 4, paper);
+    rect(ctx, 17, 20, 2, 3, ink); rect(ctx, 23, 20, 2, 3, ink);
+    rect(ctx, 18, 25, 6, 1, ink); rect(ctx, 16, 24, 2, 1, ink); rect(ctx, 24, 24, 2, 1, ink);
+    rect(ctx, 17, 12, 9, 4, gold); for (const x of [17, 21, 25]) rect(ctx, x, 9, 1, 4, '#ffe396');
+    rect(ctx, 21, 13, 1, 2, red);
+    for (const x of [15, 25]) { rect(ctx, x, 50, 2, 2, gold); rect(ctx, x + 1, 49, 1, 4, gold); }
+}
+function figure(ctx, rank, name) {
+    // Figure intere: fante in tunica, cavaliere a cavallo, re con corona e manto.
+    const king = rank === 'Re', horse = rank === 'Cavallo', y = horse ? 15 : 17;
+    if (horse) {
+        poly(ctx, [[8,36],[12,29],[27,30],[30,23],[35,23],[37,29],[32,33],[31,41],[12,41]], ink);
+        rect(ctx, 11, 33, 20, 7, '#b78044'); rect(ctx, 30, 26, 4, 8, '#c79c60');
+        rect(ctx, 12, 40, 3, 10, ink); rect(ctx, 27, 39, 3, 11, ink);
+        rect(ctx, 15, 40, 2, 8, '#a36b3c'); rect(ctx, 32, 27, 1, 1, paper);
+    }
+    if (king) poly(ctx, [[15,24],[29,24],[33,48],[10,48]], red);
+    poly(ctx, [[19,y],[25,y],[27,y+2],[28,y+4],[26,y+5],[26,y+8],[20,y+9],[17,y+6],[17,y+2]], ink);
+    poly(ctx, [[20,y+1],[25,y+1],[25,y+3],[27,y+4],[25,y+5],[25,y+7],[21,y+8],[19,y+5]], '#eab578');
+    rect(ctx, 18, y + 1, 2, 4, '#86502d'); rect(ctx, 20, y + 1, 4, 1, '#ffe0a2');
+    rect(ctx, 24, y + 2, 1, 2, ink); rect(ctx, 24, y + 6, 3, 1, ink);
+    rect(ctx, 17, y - 2, 10, 3, king ? gold : blue);
+    if (king) for (const x of [17, 21, 25]) rect(ctx, x, y - 5, 2, 4, gold);
+    else rect(ctx, 18, y - 5, 2, 4, red);
+    poly(ctx, [[18,y+9],[26,y+9],[29,y+12],[27,y+19],[29,y+24],[15,y+24],[17,y+19],[15,y+12]], ink);
+    poly(ctx, [[19,y+10],[25,y+10],[27,y+12],[25,y+19],[27,y+22],[17,y+22],[19,y+18],[17,y+12]], horse ? red : blue);
+    rect(ctx, 18, y + 10, 3, 10, king ? gold : '#6291a5'); rect(ctx, 17, y + 19, 11, 2, gold);
+    rect(ctx, 23, y + 11, 1, 6, paper); rect(ctx, 23, y + 19, 2, 2, ink);
+    rect(ctx, 12, y + 11, 4, 3, '#eab578'); rect(ctx, 28, y + 10, 4, 4, '#eab578');
+    if (!horse) {
+        poly(ctx, [[17,y+24],[21,y+24],[20,y+32],[16,y+32]], ink);
+        poly(ctx, [[23,y+24],[27,y+24],[29,y+32],[25,y+32]], ink);
+        rect(ctx, 18, y + 24, 2, 5, '#b9884f'); rect(ctx, 24, y + 24, 2, 4, '#b9884f');
+        rect(ctx, 15, y + 32, 6, 2, red); rect(ctx, 24, y + 32, 6, 2, red);
+    }
+    suit(ctx, name, 10, 24);
+    if (king) { rect(ctx, 32, 22, 1, 24, gold); rect(ctx, 31, 20, 3, 3, gold); }
+}
+const PIPS = {
+    Asso: [[21,32]], 2: [[21,22],[21,42]], 3: [[21,20],[21,32],[21,44]],
+    4: [[13,23],[29,23],[13,41],[29,41]],
+    5: [[13,21],[29,21],[21,32],[13,43],[29,43]],
+    6: [[13,20],[29,20],[13,32],[29,32],[13,44],[29,44]],
+    7: [[13,19],[29,19],[13,32],[29,32],[13,45],[29,45],[21,32]],
+};
+// Le toscane hanno semi francesi, nessun indice sulle numerali e figure intere.
+const TUSCAN_COLORS = {
+    cuori:   { cloth: '#326447', light: '#65936a', cloak: '#ab393b', ground: '#bc7760' },
+    mattoni: { cloth: '#a93832', light: '#d56a46', cloak: '#315f7e', ground: '#b3a05b' },
+    fiori:   { cloth: '#315e85', light: '#6995ac', cloak: '#bc842e', ground: '#829968' },
+    picche:  { cloth: '#755079', light: '#ac7d9a', cloak: '#376b66', ground: '#9e8271' },
+};
+const TUSCAN_PIPS = {
+    Asso: [[21,30]], 2: [[21,17],[21,43]], 3: [[21,15],[21,30],[21,45]],
+    4: [[12,16],[30,16],[12,44],[30,44]],
+    5: [[12,16],[30,16],[21,30],[12,44],[30,44]],
+    6: [[12,15],[30,15],[12,30],[30,30],[12,45],[30,45]],
+    7: [[10,14],[32,14],[21,22],[10,30],[32,30],[10,46],[32,46]],
+};
+function tuscanSuit(ctx, name, x, y, inverted = false) {
+    ctx.save(); ctx.translate(x, y);
+    if (inverted) ctx.scale(1, -1);
+    const color = name === 'cuori' || name === 'mattoni' ? '#c12f35' : '#202326';
+    // Sagome a gradini sulla griglia: nessuna sfumatura nei semi.
+    if (name === 'cuori') {
+        poly(ctx, [[-4,-4],[-1,-4],[0,-3],[1,-4],[4,-4],[5,-3],[5,0],[4,1],[4,2],[3,2],[3,3],[2,3],[2,4],[1,4],[1,5],[0,6],[-1,5],[-1,4],[-2,4],[-2,3],[-3,3],[-3,2],[-4,2],[-4,1],[-5,0],[-5,-3]], color);
+    } else if (name === 'mattoni') {
+        poly(ctx, [[0,-6],[1,-4],[2,-3],[3,-2],[5,0],[3,2],[2,3],[1,4],[0,6],[-1,4],[-2,3],[-3,2],[-5,0],[-3,-2],[-2,-3],[-1,-4]], color);
+    } else if (name === 'fiori') {
+        poly(ctx, [[-2,-5],[2,-5],[3,-4],[3,-2],[2,-1],[4,-2],[6,0],[6,2],[4,4],[2,4],[1,3],[1,4],[3,6],[-3,6],[-1,4],[-1,3],[-2,4],[-4,4],[-6,2],[-6,0],[-4,-2],[-2,-1],[-3,-2],[-3,-4]], color);
+    } else {
+        poly(ctx, [[0,-6],[1,-5],[1,-4],[3,-2],[5,0],[5,3],[3,4],[1,3],[1,4],[3,6],[-3,6],[-1,4],[-1,3],[-3,4],[-5,3],[-5,0],[-3,-2],[-1,-4],[-1,-5]], color);
+    }
+    ctx.restore();
+}
+function tuscanFigure(ctx, rank, name) {
+    const p = TUSCAN_COLORS[name], skin = '#e9b785', shade = '#bf805d', trim = '#e0b957';
+    const queen = rank === 'Donna', king = rank === 'Regio';
+    // Cornice sottile, terreno e silhouette originali, disegnati su una griglia 42×60.
+    rect(ctx, 3, 3, 36, 54, '#b6a48a'); rect(ctx, 3.5, 3.5, 35, 53, paper);
+    poly(ctx, [[4,51],[14,49],[26,50],[38,48],[38,56],[4,56]], p.ground);
+    if (queen) {
+        // Dama di profilo: diadema, manica a sbuffo, gonna a ventaglio e fazzoletto.
+        poly(ctx, [[21,11],[27,11],[29,14],[28,22],[31,26],[27,29],[19,24],[18,18]], ink);
+        poly(ctx, [[22,12],[26,12],[27,15],[25,19],[22,21],[20,18],[19,17],[21,16]], skin);
+        rect(ctx, 23, 12, 4, 2, '#70452c'); rect(ctx, 26, 14, 2, 7, '#70452c');
+        rect(ctx, 21, 15, 1, 1, ink); rect(ctx, 20, 18, 2, 1, shade);
+        poly(ctx, [[21,12],[21,10],[23,11],[24,9],[25,11],[27,10],[27,13]], trim);
+        rect(ctx, 24, 10, 1, 1, '#c12f35');
+        poly(ctx, [[21,21],[26,20],[30,24],[28,31],[31,39],[37,54],[12,54],[15,43],[18,33],[17,26]], ink);
+        poly(ctx, [[22,22],[26,21],[28,24],[26,31],[29,39],[35,53],[14,53],[17,42],[20,32],[19,26]], p.cloth);
+        poly(ctx, [[21,32],[25,32],[25,40],[31,52],[23,51],[19,46]], p.light);
+        poly(ctx, [[26,34],[29,41],[33,51],[30,48],[27,43]], trim);
+        poly(ctx, [[19,35],[18,45],[16,52],[20,52],[21,49],[19,47]], p.cloak);
+        poly(ctx, [[18,23],[22,25],[20,29],[16,31],[12,29],[13,26]], '#d8dfd7');
+        rect(ctx, 17, 25, 4, 2, '#94a7ad');
+        poly(ctx, [[14,28],[16,30],[12,33],[9,32],[10,30]], skin);
+        poly(ctx, [[9,31],[12,32],[10,35],[8,35],[6,40],[6,35]], '#fcf7df');
+        rect(ctx, 8, 34, 1, 3, '#94a7ad');
+        poly(ctx, [[20,29],[26,29],[27,31],[20,33],[18,32]], trim);
+        rect(ctx, 22, 23, 1, 3, trim); rect(ctx, 16, 54, 7, 1, ink);
+    } else if (king) {
+        // Regio anziano: corona sempre visibile, barba bianca e bordi d'ermellino.
+        poly(ctx, [[15,23],[27,22],[32,27],[36,54],[9,54],[11,31]], ink);
+        poly(ctx, [[15,24],[27,23],[30,28],[34,53],[11,53],[13,31]], p.cloak);
+        poly(ctx, [[18,27],[25,27],[27,52],[16,52]], p.cloth);
+        rect(ctx, 20, 33, 3, 18, p.light); rect(ctx, 16, 48, 11, 2, trim);
+        poly(ctx, [[15,24],[18,25],[16,34],[15,45],[12,52],[11,51],[13,33]], '#f6edcf');
+        poly(ctx, [[26,24],[28,25],[29,35],[32,51],[29,52],[26,35],[24,27]], '#f6edcf');
+        for (const [x,y] of [[14,29],[13,37],[12,46],[27,29],[28,38],[30,47]]) rect(ctx, x, y, 1, 2, ink);
+        poly(ctx, [[17,13],[24,12],[27,16],[26,23],[23,28],[18,26],[15,21],[15,16]], '#b9bfbb');
+        poly(ctx, [[18,14],[24,14],[25,17],[27,19],[24,20],[24,22],[19,22],[17,18]], skin);
+        rect(ctx, 23, 16, 1, 2, ink); rect(ctx, 18, 16, 1, 2, shade);
+        poly(ctx, [[16,18],[19,21],[22,20],[25,21],[24,25],[21,28],[18,25],[16,23]], '#f7f0d7');
+        rect(ctx, 21, 22, 3, 1, '#9ba8a3'); rect(ctx, 18, 22, 1, 3, '#c6cdc0');
+        poly(ctx, [[16,14],[15,8],[17,8],[18,11],[20,10],[20,7],[22,7],[22,10],[24,11],[25,8],[27,8],[26,14]], ink);
+        poly(ctx, [[17,13],[16,9],[17,9],[18,12],[21,11],[21,8],[22,12],[25,12],[26,9],[25,13]], trim);
+        rect(ctx, 17, 13, 9, 2, trim); rect(ctx, 21, 13, 2, 1, '#c12f35');
+        rect(ctx, 33, 23, 1, 30, '#9b6a29'); rect(ctx, 33, 24, 1, 27, trim);
+        poly(ctx, [[33,19],[35,21],[35,23],[33,25],[31,23],[31,21]], trim);
+        rect(ctx, 33, 21, 1, 2, '#fff1ae'); rect(ctx, 31, 32, 4, 3, skin);
+        rect(ctx, 10, 33, 4, 3, skin); rect(ctx, 15, 53, 6, 2, ink); rect(ctx, 24, 53, 6, 2, ink);
+    } else {
+        // Gobbo giovane, senza corona: berretto morbido, mantello corto e mazza.
+        poly(ctx, [[15,23],[26,22],[31,27],[33,39],[27,43],[11,40],[10,28]], ink);
+        poly(ctx, [[15,24],[25,23],[29,27],[31,38],[27,41],[12,39],[12,28]], p.cloak);
+        poly(ctx, [[18,37],[23,38],[21,48],[20,53],[15,53],[17,46]], ink);
+        poly(ctx, [[24,37],[28,37],[28,46],[31,53],[26,53],[23,46]], ink);
+        rect(ctx, 18, 41, 2, 9, '#d3ad60'); rect(ctx, 25, 41, 2, 6, '#d3ad60');
+        rect(ctx, 16, 50, 4, 4, '#744531'); rect(ctx, 27, 50, 3, 4, '#744531');
+        rect(ctx, 13, 54, 7, 1, ink); rect(ctx, 26, 54, 7, 1, ink);
+        poly(ctx, [[17,12],[24,12],[27,16],[26,23],[22,25],[17,22],[15,18]], '#70452c');
+        poly(ctx, [[19,14],[24,14],[24,16],[26,18],[24,19],[24,21],[21,23],[18,20]], skin);
+        rect(ctx, 23, 16, 1, 2, ink); rect(ctx, 23, 20, 2, 1, shade);
+        rect(ctx, 17, 15, 2, 7, '#70452c'); rect(ctx, 16, 19, 2, 5, '#70452c');
+        poly(ctx, [[16,14],[17,11],[21,10],[25,11],[26,14],[28,15],[16,15]], p.cloth);
+        rect(ctx, 18, 13, 8, 1, p.light);
+        poly(ctx, [[18,24],[24,23],[27,27],[25,33],[28,40],[15,40],[17,33],[15,27]], ink);
+        poly(ctx, [[19,25],[23,24],[25,27],[23,33],[26,39],[17,39],[19,33],[17,27]], p.cloth);
+        rect(ctx, 20, 26, 2, 7, p.light); rect(ctx, 16, 34, 10, 2, trim);
+        poly(ctx, [[18,23],[21,25],[20,29],[17,25]], '#f6edcf');
+        rect(ctx, 21, 34, 2, 2, ink);
+        poly(ctx, [[10,27],[13,29],[12,33],[9,34],[8,32]], skin);
+        poly(ctx, [[27,28],[30,30],[28,34],[25,35],[24,33],[27,32]], skin);
+        poly(ctx, [[7,30],[9,30],[9,46],[11,50],[11,53],[6,53],[6,49],[7,46]], ink);
+        rect(ctx, 8, 33, 1, 17, '#ae783a'); rect(ctx, 7, 49, 3, 3, trim);
+        rect(ctx, 7, 31, 3, 2, skin);
+    }
+    ctx.save(); ctx.translate(9, 8); ctx.scale(0.65, 0.65); tuscanSuit(ctx, name, 0, 0); ctx.restore();
+    text(ctx, queen ? 'D' : king ? 'R' : 'G', 7, 16, 4, ink);
+}
+function tuscanCard(ctx, card) {
+    // Angoli arrotondati a gradini e un solo bordo sottile; nessuna scritta al piede.
+    const outline = [[2,0],[40,0],[42,2],[42,58],[40,60],[2,60],[0,58],[0,2]];
+    ctx.save(); ctx.translate(1, 2); poly(ctx, outline, '#15231d'); ctx.restore();
+    poly(ctx, outline, '#89765f');
+    poly(ctx, [[2,1],[40,1],[41,2],[41,58],[40,59],[2,59],[1,58],[1,2]], paper);
+    if (TUSCAN_PIPS[card.rank]) {
+        for (const [x, y] of TUSCAN_PIPS[card.rank]) tuscanSuit(ctx, card.suit, x, y, y > 30);
+    } else tuscanFigure(ctx, card.rank, card.suit);
+}
+export function drawCard(ctx, card, x, y, w = 84, h = 120, back = false) {
+    ctx.save(); ctx.translate(Math.round(x), Math.round(y)); ctx.scale(w / 42, h / 60);
+    if (!back && TUSCAN_COLORS[card.suit]) { tuscanCard(ctx, card); ctx.restore(); return; }
+    rect(ctx, 1, 2, 42, 60, '#15231d'); rect(ctx, 0, 0, 42, 60, ink);
+    rect(ctx, 1, 1, 40, 58, '#c5a576'); rect(ctx, 2, 2, 38, 56, paper);
+    if (back) regolo(ctx);
+    else {
+        const rank = { Asso: 'A', Fante: 'F', Cavallo: 'C', Re: 'R', Gobbo: 'G', Donna: 'D', Regio: 'R' }[card.rank] ?? card.rank;
+        text(ctx, rank, 4, 7, 6, ink); suit(ctx, card.suit, 34, 8);
+        if (PIPS[card.rank]) {
+            for (const [px, py] of PIPS[card.rank]) {
+                // Una lama per simbolo: le coppie si allungano e s'incrociano al centro.
+                if (card.suit === 'spade' && (px === 13 || px === 29)) {
+                    ctx.save(); ctx.translate(px === 13 ? 18 : 24, py); ctx.scale(px === 13 ? 1.8 : -1.8, 1);
+                    suit(ctx, card.suit, 0, 0); ctx.restore();
+                } else suit(ctx, card.suit, px, py);
+            }
+        } else figure(ctx, card.rank, card.suit);
+        text(ctx, card.suit.toUpperCase(), 21, 55, 3.7, ink, 'center');
+    }
+    ctx.restore();
+}
+function countTable(ctx, c, names) {
+    panel(ctx, 12, 32, 616, 318);
+    const rows = countRows(c), shown = rows.slice(0, c.count), totals = counted(c);
+    for (const [side, who] of ['player', 'cpu'].entries()) {
+        const x = 25 + side * 310;
+        text(ctx, names[who], x, 48, 7);
+        const cards = shown.filter(p => p.who === who);
+        cards.forEach(({ card }, i) => {
+            const cx = x + (i % 8) * 36, cy = 64 + Math.floor(i / 8) * 49;
+            drawCard(ctx, card, cx, cy, 30, 40);
+            text(ctx, '+' + card.points, cx + 15, cy + 44, 5, '#ffe09b', 'center');
+        });
+        text(ctx, `${totals[who]} punti`, x, 321, 10, '#ffe09b');
+    }
+    const last = shown.at(-1);
+    if (c.step === 'count' && last) {
+        panel(ctx, 270, 115, 100, 140); drawCard(ctx, last.card, 278, 123);
+    }
+    text(ctx, c.step === 'result' ? c.result.winner ? `Vince ${names[c.result.winner]}!` : '60 a 60. Patta!' : last ? `${cardName(last.card)}: ${last.card.points} punti` : 'Si contano tutte le carte…', 320, 339, 6, paper, 'center');
+}
+// Il tavolino dell'oratorio: legno, panno verde e il titolo. Lo usa anche il tressette.
+export function drawTable(ctx, title) {
+    rect(ctx, 0, 0, 640, 360, '#573720');
+    for (let y = 0; y < 360; y += 24) {
+        rect(ctx, 0, y, 640, 2, '#38271e');
+        for (let x = 0; x < 640; x += 53) rect(ctx, x + y % 17, y + 6, 29, 1, '#72462a');
+    }
+    rect(ctx, 17, 27, 606, 329, '#b28949'); rect(ctx, 20, 30, 600, 323, '#234c40');
+    for (let i = 0; i < 600; i++) rect(ctx, 23 + (i * 73) % 590, 33 + (i * 41) % 315, 1, 1, '#2a5143');
+    text(ctx, title, 320, 15, 9, '#ffe0a0', 'center');
+}
+export function drawBriscola(ctx, c, def) {
+    ctx.save(); ctx.imageSmoothingEnabled = false;
+    drawTable(ctx, 'BRISCOLA ALL’ORATORIO');
+    if (c.step === 'count' || c.step === 'result') { countTable(ctx, c, def.names); ctx.restore(); return; }
+    text(ctx, def.names.cpu, 320, 38, 6, paper, 'center');
+    c.hands.cpu.forEach((_, i) => drawCard(ctx, null, 229 + i * 62, 49, 52, 74, true));
+    // La briscola sporge sotto il mazzo, girata di traverso: più di metà resta scoperta, anche l'asso che ha
+    // un seme solo nel mezzo (le toscane non hanno numeri negli angoli).
+    if (c.stock.length) {
+        ctx.save(); ctx.translate(154, 150); ctx.rotate(Math.PI / 2);
+        drawCard(ctx, c.trumpCard, 0, 0, 64, 92); ctx.restore();
+        if (c.stock.length > 1) {
+            for (let i = Math.min(5, Math.ceil(c.stock.length / 7)); i >= 0; i--)
+                drawCard(ctx, null, 38 + i, 116 - i, 58, 83, true);
+        }
+    }
+    text(ctx, `Mazzo: ${c.stock.length}`, 34, 243, 7);
+    text(ctx, 'Briscola:', 34, 263, 7); // a 6 punti la B sembra una D
+    text(ctx, c.trump.toUpperCase(), 34, 278, 7, '#ffe09b');
+    for (const [i, who] of ['cpu', 'player'].entries()) {
+        const y = 74 + i * 183;
+        if (c.taken[who].length) for (let n = 0; n < Math.min(4, c.taken[who].length / 2); n++) drawCard(ctx, null, 526 + n * 2, y - n * 2, 42, 60, true);
+        text(ctx, 'Prese', 550, y + 72, 6, paper, 'center');
+    }
+    c.table.forEach((p, i) => {
+        // La carta vola dalla mano di chi la gioca; finita la presa, tutte e due volano sulle prese di chi ha preso.
+        const spot = [242 + i * 86, 130, 64, 92];
+        const hand = p.who === 'player' ? [HAND.x + (p.from ?? 1) * HAND.gap, HAND.y, HAND.w, HAND.h] : [229 + (p.from ?? 1) * 62, 49, 52, 74];
+        let r = spot;
+        if (i === c.table.length - 1 && c.step === 'play' || c.step === 'trick' && i === 1 && c.t < PLAY_TIME) r = flight(hand, spot, c.t / PLAY_TIME);
+        if (c.step === 'trick' && c.t > TRICK_HOLD) r = flight(spot, [526, c.last.winner === 'cpu' ? 74 : 257, 42, 60], (c.t - TRICK_HOLD) / (TRICK_TIME - TRICK_HOLD - 0.05));
+        drawCard(ctx, p.card, ...r);
+    });
+    c.hands.player.forEach((card, i) => {
+        const x = HAND.x + i * HAND.gap;
+        if (canPlay(c) && c.selected === i) rect(ctx, x - 3, HAND.y - 3, HAND.w + 6, HAND.h + 6, '#ffdb76');
+        drawCard(ctx, card, x, HAND.y, HAND.w, HAND.h);
+        text(ctx, String(i + 1), x + HAND.w / 2, 221, 7, '#fff0cd', 'center');
+    });
+    ctx.restore();
+}

src/engine/briscola.js

@@ -0,0 +1,206 @@
+// Briscola in due: regole e avversari senza DOM. Le carte sono immutabili, lo stato è serializzabile.
+// Due mazzi, stesse regole, stessi id: cambiano solo nomi e disegni (scelti nel dialogo, idea di Andrea).
+// Toscane: semi francesi (i quadri in Toscana sono «mattoni»), figure gobbo, donna e regio.
+export const DECKS = {
+    toscane: { suits: ['cuori', 'mattoni', 'fiori', 'picche'], ranks: ['Asso', '2', '3', '4', '5', '6', '7', 'Gobbo', 'Donna', 'Regio'] },
+    napoletane: { suits: ['denari', 'coppe', 'spade', 'bastoni'], ranks: ['Asso', '2', '3', '4', '5', '6', '7', 'Fante', 'Cavallo', 'Re'] },
+};
+export const LEVELS = ['bona', 'seria', 'male'];
+// I tempi delle animazioni (briscola-render.js): la carta vola dalla mano al tavolo; la presa resta ferma un attimo e
+// poi vola sul mucchietto di chi ha preso (Andrea: «non si capisce quando vengono buttate le carte»).
+export const PLAY_TIME = 0.3, TRICK_HOLD = 0.85, TRICK_TIME = 1.4;
+const VALUES = [11, 0, 10, 0, 0, 0, 0, 2, 3, 4];
+const ORDER = [9, 0, 8, 1, 2, 3, 4, 5, 6, 7];
+const build = ({ suits, ranks }) => Object.freeze(suits.flatMap((suit, s) => ranks.map((rank, r) =>
+    Object.freeze({ id: s * 10 + r, suit, rank, points: VALUES[r], strength: ORDER[r] }))));
+export const DECK_CARDS = Object.fromEntries(Object.entries(DECKS).map(([name, deck]) => [name, build(deck)]));
+export const CARDS = DECK_CARDS.toscane, SUITS = DECKS.toscane.suits;
+export const other = who => who === 'player' ? 'cpu' : 'player';
+export const cardName = card => `${card.rank} di ${card.suit}`;
+export const points = cards => cards.reduce((n, card) => n + card.points, 0);
+function rng(seed) { let n = seed >>> 0; return () => ((n = (Math.imul(n, 1664525) + 1013904223) >>> 0) / 4294967296); }
+function shuffle(cards, random) {
+    for (let i = cards.length - 1; i > 0; i--) { const j = Math.floor(random() * (i + 1)); [cards[i], cards[j]] = [cards[j], cards[i]]; }
+    return cards;
+}
+// Il secondo vince solo con una briscola o con una carta più alta dello stesso seme.
+export function beats(second, first, trump) {
+    return second.suit === first.suit ? second.strength > first.strength : second.suit === trump;
+}
+export function trickWinner(table, trump) {
+    return beats(table[1].card, table[0].card, trump) ? table[1].who : table[0].who;
+}
+export function result(taken) {
+    const player = points(taken.player), cpu = points(taken.cpu);
+    return { player, cpu, winner: player === cpu ? null : player > cpu ? 'player' : 'cpu' };
+}
+export function newBriscola(seed = Date.now() >>> 0, { level = 'seria', deck = 'toscane' } = {}) {
+    if (!DECKS[deck]) deck = 'toscane';
+    const random = rng(seed), dealer = random() < 0.5 ? 'player' : 'cpu';
+    const stock = shuffle([...DECK_CARDS[deck]], random), hands = { player: [], cpu: [] };
+    // Distribuzione alternata, a partire da chi è di mano.
+    for (let i = 0; i < 3; i++) for (const who of [other(dealer), dealer]) hands[who].push(stock.shift());
+    const trumpCard = stock.shift(); stock.push(trumpCard);
+    return { step: 'play', t: 0, age: 0, level: LEVELS.includes(level) ? level : 'seria', deck, dealer,
+        hands, stock, trumpCard, trump: trumpCard.suit, current: other(dealer), table: [],
+        taken: { player: [], cpu: [] }, history: [], selected: 0, last: null, drawnTrump: null,
+        aiSeed: (seed ^ 0x9e3779b9) >>> 0, events: [{ kind: 'card-shuffle' }], count: 0 };
+}
+export const canPlay = c => c.step === 'play' && c.current === 'player';
+export function select(c, index) {
+    if (!canPlay(c) || !Number.isInteger(index) || !c.hands.player[index]) return false;
+    c.selected = index; return true;
+}
+export function nudge(c, direction) {
+    return select(c, (c.selected + direction + c.hands.player.length) % c.hands.player.length);
+}
+export function play(c, index = c.selected, who = 'player') {
+    if (c.step !== 'play' || c.current !== who || !Number.isInteger(index) || !c.hands[who][index]) return false;
+    const [card] = c.hands[who].splice(index, 1);
+    c.table.push({ who, card, from: index }); c.t = 0; // `from`: da dove parte la carta nel disegno
+    c.selected = Math.min(c.selected, Math.max(0, c.hands.player.length - 1));
+    c.events.push({ kind: 'card-slide' }); c.landing = true;
+    if (c.table.length === 2) {
+        c.step = 'trick'; c.last = { winner: trickWinner(c.table, c.trump), cards: c.table.map(p => p.card) };
+    } else c.current = other(who);
+    return true;
+}
+export function collect(c) {
+    if (c.step !== 'trick') return false;
+    const winner = c.last.winner;
+    c.taken[winner].push(...c.last.cards);
+    c.history.push({ winner, cards: [...c.last.cards] }); c.table = [];
+    // Chi prende pesca per primo. La briscola scoperta è davvero l'ultima carta.
+    for (const who of [winner, other(winner)]) if (c.stock.length) {
+        const card = c.stock.shift(); c.hands[who].push(card);
+        if (card.id === c.trumpCard.id) c.drawnTrump = who;
+    }
+    c.current = winner; c.t = 0; c.events.push({ kind: 'card-slide' });
+    c.step = c.hands.player.length ? 'play' : 'count';
+    // Il risultato è deciso all'ultima presa: il conteggio carta per carta lo mostra soltanto.
+    if (c.step === 'count') c.result = result(c.taken);
+    return true;
+}
+// La sola porta d'ingresso dell'IA: copie di informazioni pubbliche e della PROPRIA mano.
+// Mai il mazzo, la mano avversaria o il seed della distribuzione.
+export function observation(c, who = 'cpu') {
+    return { who, deck: c.deck, hand: [...c.hands[who]], opponentCount: c.hands[other(who)].length,
+        table: c.table.map(p => ({ ...p })), played: c.history.flatMap(t => t.cards),
+        ownPoints: points(c.taken[who]), otherPoints: points(c.taken[other(who)]),
+        remaining: c.stock.length, trump: c.trump, trumpCard: c.trumpCard,
+        knownOpponent: c.drawnTrump === other(who) && !c.history.some(t => t.cards.some(a => a.id === c.trumpCard.id))
+            && !c.table.some(p => p.card.id === c.trumpCard.id) ? [c.trumpCard] : [] };
+}
+export function unseen(v) {
+    const seen = new Set([...v.hand, ...v.played, ...v.table.map(p => p.card)].map(a => a.id));
+    if (v.remaining) seen.add(v.trumpCard.id);
+    return DECK_CARDS[v.deck ?? 'toscane'].filter(a => !seen.has(a.id));
+}
+// Giocatore attento di riferimento: scarta i lisci, conserva le briscole e prende i carichi.
+export function attentive(v) {
+    const lead = v.table[0]?.card;
+    const cost = a => a.points * 2 + (a.suit === v.trump ? 10 + a.strength : a.strength * 0.15);
+    const sorted = v.hand.map((a, i) => ({ a, i })).sort((a, b) => cost(a.a) - cost(b.a));
+    if (lead) {
+        const wins = sorted.filter(({ a }) => beats(a, lead, v.trump));
+        const take = wins.find(({ a }) => a.suit !== v.trump || lead.points + a.points >= 8 || !v.remaining);
+        if (take) return take.i;
+    }
+    return sorted[0].i;
+}
+// Finale a informazione completa: minimax esatto, nessuna euristica né campionamento.
+// Massimizza i punti finali (quindi anche vittoria/patta), con memoizzazione per i sottogiochi.
+export function perfect(hand, enemy, table, trump, who, memo = new Map()) {
+    const solve = (own, opp, lead, turn) => {
+        if (!own.length && !opp.length && !lead.length) return 0;
+        const key = `${own.map(a => a.id)}|${opp.map(a => a.id)}|${lead.map(p => p.who + p.card.id)}|${turn}`;
+        if (memo.has(key)) return memo.get(key);
+        const mine = turn === who, choices = mine ? own : opp;
+        let best = mine ? -Infinity : Infinity;
+        choices.forEach((card, i) => {
+            const next = choices.filter((_, j) => i !== j), a = mine ? next : own, b = mine ? opp : next;
+            const pair = [...lead, { who: turn, card }];
+            let value;
+            if (pair.length === 2) {
+                const winner = trickWinner(pair, trump);
+                value = (winner === who ? 1 : -1) * points(pair.map(p => p.card)) + solve(a, b, [], winner);
+            } else value = solve(a, b, pair, other(turn));
+            best = mine ? Math.max(best, value) : Math.min(best, value);
+        });
+        memo.set(key, best); return best;
+    };
+    return hand.map((card, i) => {
+        const own = hand.filter((_, j) => i !== j), pair = [...table, { who, card }];
+        if (pair.length === 1) return solve(own, enemy, pair, other(who));
+        const winner = trickWinner(pair, trump);
+        return (winner === who ? 1 : -1) * points(pair.map(p => p.card)) + solve(own, enemy, [], winner);
+    });
+}
+const bestIndex = scores => scores.indexOf(Math.max(...scores));
+
+// «A fassi male»: mondi possibili compatibili con le carte uscite, mai la distribuzione vera.
+// Stesse distribuzioni campionate per tutte le mosse, entrambi giocano attenti nei seguiti.
+// Taratura: 1000 partite/livello, seed imul(1..1000, 2654435761), tools/calibrate_briscola.mjs.
+// Vittorie di Andrea attento: bona 84,7%, seria 48,1%, male 35,9%; patte 0,9%, 2,5%, 2,0%.
+// Mazziere Andrea in 496/1000 partite. È una misura contro questa euristica, non contro persone.
+export function chooseCard(v, level = 'seria', seed = 1) {
+    const random = rng(seed);
+    if (level === 'bona') return Math.floor(random() * v.hand.length);
+    if (level !== 'male') return attentive(v);
+    const unknown = unseen(v);
+    if (!v.remaining) return bestIndex(perfect(v.hand, unknown, v.table, v.trump, v.who));
+    const totals = v.hand.map(() => 0), known = new Set(v.knownOpponent.map(a => a.id));
+    for (let sample = 0; sample < 40; sample++) {
+        const pool = shuffle(unknown.filter(a => !known.has(a.id)), random);
+        const enemy = [...v.knownOpponent, ...pool.splice(0, v.opponentCount - known.size)];
+        const stock = [...pool, v.trumpCard];
+        for (let move = 0; move < v.hand.length; move++) {
+            const hands = { [v.who]: [...v.hand], [other(v.who)]: [...enemy] };
+            let table = [...v.table], turn = v.who, deck = [...stock], delta = 0, first = true;
+            while (hands.player.length || hands.cpu.length || table.length) {
+                const idx = first ? move : attentive({ hand: hands[turn], table, trump: v.trump, remaining: deck.length });
+                first = false;
+                const [card] = hands[turn].splice(idx, 1); table.push({ who: turn, card });
+                if (table.length === 1) { turn = other(turn); continue; }
+                turn = trickWinner(table, v.trump);
+                delta += (turn === v.who ? 1 : -1) * points(table.map(p => p.card)); table = [];
+                for (const who of [turn, other(turn)]) if (deck.length) hands[who].push(deck.shift());
+            }
+            totals[move] += delta;
+        }
+    }
+    return bestIndex(totals);
+}
+export function update(c, dt) {
+    if (!Number.isFinite(dt) || dt < 0 || c.step === 'result') return;
+    c.t += dt;
+    if (c.landing && c.t >= PLAY_TIME) { c.events.push({ kind: 'card-tap' }); c.landing = false; }
+    if (c.step === 'trick' && c.t >= TRICK_TIME) collect(c);
+    else if (c.step === 'count') {
+        // Una carta ogni 0,35 s; i totali crescono solo ora, alla fine della partita.
+        c.count = Math.min(40, Math.floor(c.t / 0.35));
+        if (c.count === 40) { c.result = result(c.taken); c.step = 'result'; }
+    } else if (c.step === 'play' && c.current === 'cpu' && c.t >= 0.7) {
+        c.aiSeed = (Math.imul(c.aiSeed, 1664525) + 1013904223) >>> 0;
+        play(c, chooseCard(observation(c), c.level, c.aiSeed), 'cpu');
+    }
+}
+export function countRows(c) {
+    return ['player', 'cpu'].flatMap(who => c.taken[who].map(card => ({ who, card })));
+}
+export function counted(c) {
+    const totals = { player: 0, cpu: 0 };
+    for (const p of countRows(c).slice(0, c.count)) totals[p.who] += p.card.points;
+    return totals;
+}
+export function status(c, names = { player: 'Andrea', cpu: 'Il giocatore' }) {
+    if (c.step === 'result') return `${c.result.winner ? 'Vince ' + names[c.result.winner] : 'Patta'}! ${c.result.player} a ${c.result.cpu}.`;
+    if (c.step === 'count') {
+        const last = countRows(c)[c.count - 1];
+        return last ? `${names[last.who]}: ${cardName(last.card)}, +${last.card.points}. Totale: ${counted(c)[last.who]}.` : 'Si contano le prese, una carta alla volta…';
+    }
+    if (c.step === 'trick') return `Prende ${names[c.last.winner]}.`;
+    // A parole anche quel che si vede sul tavolo: la briscola e la carta già giocata.
+    const table = `Briscola: ${c.trump}.${c.table.length ? ` In tavola: ${cardName(c.table[0].card)}.` : ''}`;
+    return c.current === 'player' ? `${table} Tocca una carta per giocarla. Frecce o 1–2–3 scelgono, Invio gioca.` : `${table} ${names.cpu} sceglie…`;
+}

src/engine/game.js

@@ -3,9 +3,15 @@
 import { findPath, dist, inBox, boxDistance, nearestInside } from './geometry.js';
 import * as bocce from './bocce.js';
 import * as biliardo from './biliardo.js';
+import * as briscola from './briscola.js';
+import * as tressette from './tressette.js';
+import * as scopa from './scopa.js';
 
-// I minigiochi in primo piano: stessi comandi (mira, pressione, rilascio), motori diversi.
+// I minigiochi in primo piano: comandi opzionali per il tiro o per la scelta di una carta.
 export const MINIGAMES = {
+    briscola: { create: (seed, level, deck) => briscola.newBriscola(seed, { level, deck }), update: briscola.update, play: briscola.play },
+    tressette: { create: (seed, level, deck) => tressette.newTressette(seed, { level, deck }), update: tressette.update, play: tressette.play },
+    scopa: { create: (seed, level, deck) => scopa.newScopa(seed, { level, deck }), update: scopa.update, play: scopa.play },
     bocce: { create: (seed, level) => bocce.newBocce(seed, { level }), update: bocce.update, press: bocce.press, release: bocce.release, cancel: bocce.cancel, aim: bocce.aimScreen },
     biliardo: { create: (seed, level) => biliardo.newBiliardo(seed, { level }), update: biliardo.update, press: biliardo.press, release: biliardo.release, cancel: biliardo.cancel, aim: biliardo.aimScreen },
 };
@@ -245,6 +251,20 @@ export class Game {
     }
 
     // Chiuso il libro si torna alla scena, e gli effetti che seguivano il primo piano ripartono.
+    outcome(def, c) { return def[c.result.winner === 'player' ? 'win' : c.result.winner === 'cpu' ? 'lose' : 'draw'] ?? []; }
+    // Appena il risultato di un minigioco è deciso, i suoi flag (vittoria, partita giocata) valgono e si salvano:
+    // anche tornando al titolo dalla schermata del risultato, senza passare dall'uscita. Una volta sola.
+    settle(c) {
+        const def = this.story.closeups?.[c.id];
+        if (!c.result || c.settled || !def) return false;
+        c.settled = true;
+        for (const e of this.outcome(def, c)) {
+            if (e.set) { this.state.flags[e.set] = true; if (this.checkpoint) this.checkpoint.flags[e.set] = true; }
+            if (e.unset) { delete this.state.flags[e.unset]; if (this.checkpoint) delete this.checkpoint.flags[e.unset]; }
+        }
+        if (this.checkpoint) this.onSave(this.checkpoint);
+        return true;
+    }
     closeupClose() {
         const c = this.closeup;
         if (!c) return false;
@@ -255,9 +275,11 @@ export class Game {
             if (c.step === 'done') this.queue.unshift(...def.complete);
             return true;
         }
-        // Bocce e biliardo: a partita finita, la battuta di chi ha vinto; uscendo prima, quella di chi lascia.
+        // I minigiochi: a partita finita (risultato deciso, anche se il conteggio si sta ancora mostrando) la battuta
+        // di chi ha vinto; uscendo prima, quella di chi lascia.
         if (MINIGAMES[def?.type]) {
-            this.queue.unshift(...(c.step === 'result' ? def[c.result?.winner === 'player' ? 'win' : c.result?.winner === 'cpu' ? 'lose' : 'draw'] ?? [] : def.quit ?? []));
+            this.settle(c);
+            this.queue.unshift(...(c.result ? this.outcome(def, c) : def.quit ?? []));
             return true;
         }
         // Chi è arrivato all'ultima pagina, chiudendo, la commenta (`closing`).
@@ -267,16 +289,17 @@ export class Game {
 
     // Bocce e biliardo: si tiene premuto per caricare la forza e si lascia per tirare (mouse, dito o spazio).
     minigame() { const c = this.closeup; return c ? MINIGAMES[this.story.closeups[c.id].type] ?? null : null; }
-    closeupPress() { const m = this.minigame(); return !!m && !this.speech && m.press(this.closeup); }
-    closeupRelease() { const m = this.minigame(); return !!m && m.release(this.closeup); }
-    closeupCancel() { const m = this.minigame(); return !!m && m.cancel(this.closeup); }
+    closeupPress() { const m = this.minigame(); return !!m && !this.speech && !!m.press?.(this.closeup); }
+    closeupRelease() { return !!this.minigame()?.release?.(this.closeup); }
+    closeupCancel() { return !!this.minigame()?.cancel?.(this.closeup); }
+    closeupPlay(index) { return !this.speech && !!this.minigame()?.play?.(this.closeup, index); }
 
     // Solo luce, nessun clic sugli oggetti dietro al primo piano. Il progresso è transitorio:
     // uscire o ricaricare durante la ricerca permette di ripeterla, senza anticipare il finale.
     closeupAim([x, y]) {
         const c = this.closeup;
         const m = this.minigame();
-        if (m) return m.aim(c, [x, y]);
+        if (m) return !!m.aim?.(c, [x, y]);
         if (!c || this.story.closeups[c.id].type !== 'torch' || !Number.isFinite(x) || !Number.isFinite(y)) return false;
         c.beam = [Math.max(70, Math.min(570, x)), Math.max(65, Math.min(295, y))];
         return true;
@@ -402,6 +425,7 @@ export class Game {
             const m = this.minigame();
             if (m) {
                 m.update(c, dt);
+                this.settle(c);
                 // Il risultato resta leggibile finché il giocatore non esce.
                 return;
             }
@@ -440,7 +464,9 @@ export class Game {
             const type = this.story.closeups[e.closeup].type;
             this.closeup = type === 'torch' ? { id: e.closeup, step: 'search', t: 0, age: 0, found: 0, dwell: 0, beam: [320, 180] }
                 // `level`: «Alla bona», «Seria» o «A fassi male», scelto nel dialogo con l'avversario.
-                : MINIGAMES[type] ? { id: e.closeup, ...MINIGAMES[type].create(Math.floor(Math.random() * 4294967296), e.level) }
+                // `decks`: il mazzo da usare quando il suo flag è acceso (briscola: le napoletane al posto delle toscane).
+                : MINIGAMES[type] ? { id: e.closeup, ...MINIGAMES[type].create(Math.floor(Math.random() * 4294967296), e.level,
+                    Object.keys(this.story.closeups[e.closeup].decks ?? {}).find(d => s.flags[this.story.closeups[e.closeup].decks[d]])) }
                 : { id: e.closeup, step: 'cover', t: 0, age: 0 };
         }
         else throw new Error('Effetto sconosciuto: ' + JSON.stringify(e));

src/engine/music.js

@@ -8,11 +8,13 @@ import { versioned } from '../version.js';
 // d'apertura nessuno: lì suona la sua musichetta, una volta sola (main.js).
 // Quale brano: quello della scena se ce l'ha; altrimenti, all'aperto, quello della fase del giorno (la sera ha il suo);
 // altrimenti quello generale del paese.
-export function trackFor(story, { screen, scene, phase }) {
+// Un primo piano con la sua musica (i tavoli da carte, col valzer) la porta con sé finché resta aperto.
+export function trackFor(story, { screen, scene, phase, closeup }) {
     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 sc = story.scenes[scene];
     return sc?.music ?? (sc?.indoor ? null : phase?.music) ?? m.game ?? null;
 }

src/engine/render.js

@@ -5,6 +5,9 @@ import { ambientEffects, ambientHash } from './ambient.js';
 import { drawTorch } from './torch.js';
 import { drawBocce } from './bocce-render.js';
 import { drawBiliardo } from './biliardo-render.js';
+import { drawBriscola } from './briscola-render.js';
+import { drawTressette } from './tressette-render.js';
+import { drawScopa } from './scopa-render.js';
 import { versioned } from '../version.js';
 export const WIDTH = 640, HEIGHT = 360;
 
@@ -666,6 +669,9 @@ const twoLines = title => { const i = title.lastIndexOf(' '); return i > 0 ? [ti
 function drawCloseup(ctx, game, time) {
     const c = game.closeup, def = game.story.closeups?.[c.id];
     if (!def) return;
+    if (def.type === 'briscola') { drawBriscola(ctx, c, def); return; }
+    if (def.type === 'tressette') { drawTressette(ctx, c, def); return; }
+    if (def.type === 'scopa') { drawScopa(ctx, c, def); return; }
     if (def.type === 'torch') {
         if (!backgrounds.has(def.picture)) loadBackground(def.picture);
         drawTorch(ctx, c, def, backgrounds.get(def.picture));

src/engine/scopa-render.js

@@ -0,0 +1,97 @@
+import { canPlay, TARGET, PLAY_TIME, TAKE_HOLD, TAKE_TIME } from './scopa.js';
+import { drawCard, drawTable, flight } from './briscola-render.js';
+import { text, panel } from './bocce-render.js';
+
+// Coordinate condivise da disegno e tocco: la mano di Andrea (grande) e le carte in tavola.
+export const HAND = { y: 262, w: 64, h: 92, gap: 72 };
+export const handX = (n, i) => Math.round(320 - (n * HAND.gap - 8) / 2 + i * HAND.gap);
+const TABLE = { w: 42, h: 60, gap: 47, row: 8 };
+export function tableXY(n, i) {
+    const row = Math.floor(i / TABLE.row), inRow = Math.min(TABLE.row, n - row * TABLE.row);
+    return [Math.round(320 - (inRow * TABLE.gap - 5) / 2 + (i % TABLE.row) * TABLE.gap), n > TABLE.row ? 104 + row * 66 : 132];
+}
+export function cardAt(c, [x, y]) {
+    if (!canPlay(c)) return -1;
+    return c.hands.player.findIndex((_, i) => x >= handX(c.hands.player.length, i) && x < handX(c.hands.player.length, i) + HAND.w && y >= HAND.y - 8 && y < HAND.y + HAND.h);
+}
+export function tableAt(c, [x, y]) {
+    return c.table.findIndex((_, i) => { const [tx, ty] = tableXY(c.table.length, i); return x >= tx && x < tx + TABLE.w && y >= ty && y < ty + TABLE.h; });
+}
+const gold = '#ffe09b', paper = '#fff0cd', mine = '#9fe3ff', theirs = '#ffb0a3';
+const frame = (ctx, x, y, w, h, color = '#ffdb76') => { ctx.fillStyle = color; ctx.fillRect(x - 2, y - 2, w + 4, h + 4); };
+
+function board(ctx, c, names) {
+    // Un giocatore per riga: i nomi lunghi non si accavallano.
+    panel(ctx, 26, 34, 150, 50);
+    for (const [who, y, color] of [['player', 45, mine], ['cpu', 59, theirs]]) {
+        text(ctx, names[who], 34, y, 7, color); text(ctx, String(c.score[who]), 168, y, 7, color, 'right');
+    }
+    text(ctx, `Smazzata ${c.round} · ai ${TARGET}`, 101, 74, 5, paper, 'center');
+    // Il mazzo a sinistra, le prese a destra con le scope.
+    if (c.stock.length) for (let i = Math.min(4, Math.ceil(c.stock.length / 8)); i >= 0; i--) drawCard(ctx, null, 40 + i, 150 - i, 42, 60, true);
+    text(ctx, `Mazzo: ${c.stock.length}`, 61, 222, 6, paper, 'center');
+    for (const [who, y] of [['cpu', 92], ['player', 196]]) {
+        if (c.taken[who].length) for (let i = 0; i < Math.min(4, c.taken[who].length / 4); i++) drawCard(ctx, null, 560 + i, y - i, 42, 60, true);
+        if (c.scope[who]) text(ctx, `Scope: ${c.scope[who]}`, 581, y + 70, 6, gold, 'center');
+    }
+}
+const PILE = { cpu: 92, player: 196 };
+function table(ctx, c) {
+    // Durante una presa la tavola resta com'era (le carte prese al loro posto, incorniciate) finché non volano via.
+    const take = c.step === 'take' && c.last.captured.length, shown = take ? c.last.before : c.table;
+    const marked = new Set((take ? c.last.captured : c.step === 'choose' ? c.choice.options[c.choice.selected] : []).map(a => a.id));
+    const fly = take && c.t > TAKE_HOLD ? (c.t - TAKE_HOLD) / (TAKE_TIME - TAKE_HOLD - 0.05) : 0;
+    const pile = take ? [560, PILE[c.last.who], 42, 60] : null;
+    // Da dove parte la carta giocata: la mano di Andrea o quella coperta del giocatore.
+    const hand = c.step === 'take' && (c.last.who === 'player'
+        ? [handX(c.hands.player.length + 1, c.last.from), HAND.y, HAND.w, HAND.h]
+        : [320 - ((c.hands.cpu.length + 1) * 48 - 6) / 2 + c.last.from * 48, 38, 42, 60]);
+    const arrive = Math.min(1, c.t / PLAY_TIME);
+    shown.forEach((card, i) => {
+        const [x, y] = tableXY(shown.length, i);
+        let r = [x, y, TABLE.w, TABLE.h];
+        if (c.step === 'take' && !take && card.id === c.last.card.id) r = flight(hand, r, arrive);
+        if (fly && marked.has(card.id)) r = flight(r, pile, fly);
+        else if (marked.has(card.id)) frame(ctx, x, y, TABLE.w, TABLE.h);
+        drawCard(ctx, card, ...r);
+    });
+    if (take) {
+        let r = flight(hand, [299, 200, TABLE.w, TABLE.h], arrive);
+        if (fly) r = flight(r, pile, fly);
+        drawCard(ctx, c.last.card, ...r);
+        if (c.last.scopa) { panel(ctx, 260, 98, 120, 22); text(ctx, 'SCOPA!', 320, 109, 9, gold, 'center'); }
+    }
+}
+function hands(ctx, c) {
+    c.hands.cpu.forEach((_, i) => drawCard(ctx, null, 320 - (c.hands.cpu.length * 48 - 6) / 2 + i * 48, 38, 42, 60, true));
+    const n = c.hands.player.length, playing = canPlay(c) || c.step === 'choose';
+    c.hands.player.forEach((card, i) => {
+        const x = handX(n, i), chosen = c.step === 'choose' ? c.choice.index === i : canPlay(c) && c.selected === i;
+        const up = chosen ? 8 : 0;
+        if (chosen && playing) frame(ctx, x, HAND.y - up, HAND.w, HAND.h);
+        drawCard(ctx, card, x, HAND.y - up, HAND.w, HAND.h);
+    });
+}
+function summary(ctx, c, names, title) {
+    const s = c.summary;
+    panel(ctx, 140, 80, 360, 200);
+    text(ctx, title, 320, 96, 8, gold, 'center');
+    text(ctx, names.player, 380, 116, 6, mine, 'center'); text(ctx, names.cpu, 455, 116, 6, theirs, 'center');
+    s.rows.forEach((r, i) => {
+        const y = 136 + i * 20, show = v => r.key === 'settebello' ? (v ? 'sì' : '—') : String(v);
+        text(ctx, r.label, 160, y, 7, paper);
+        text(ctx, show(r.player) + (r.winner === 'player' ? ' +1' : ''), 380, y, 7, r.winner === 'player' ? gold : paper, 'center');
+        text(ctx, show(r.cpu) + (r.winner === 'cpu' ? ' +1' : ''), 455, y, 7, r.winner === 'cpu' ? gold : paper, 'center');
+    });
+    text(ctx, `Smazzata: ${s.points.player} a ${s.points.cpu}. Siamo ${c.score.player} a ${c.score.cpu}`, 320, 246, 7, paper, 'center');
+    text(ctx, c.step === 'result' ? 'Esc o Invio per tornare all’oratorio' : 'Invio o un tocco per la prossima smazzata', 320, 266, 5, paper, 'center');
+}
+export function drawScopa(ctx, c, def) {
+    const names = def?.names ?? { player: 'Andrea', cpu: 'Il giocatore' };
+    ctx.save(); ctx.imageSmoothingEnabled = false;
+    drawTable(ctx, 'SCOPA ALL’ORATORIO');
+    board(ctx, c, names); table(ctx, c); hands(ctx, c);
+    if (c.step === 'smazzata') summary(ctx, c, names, `Fine della smazzata ${c.round}`);
+    if (c.step === 'result') summary(ctx, c, names, c.result.winner === 'player' ? 'Hai vinto!' : `Vince ${names.cpu}`);
+    ctx.restore();
+}

src/engine/scopa.js

@@ -0,0 +1,255 @@
+// Scopa in due, ai 11: regole e avversari senza DOM, come la briscola. Carte, mattoni (o denari), settebello,
+// primiera e scope. Con le toscane il seme «buono» è mattoni, con le napoletane denari.
+import { DECKS, cardName } from './briscola.js';
+
+export { cardName };
+export const LEVELS = ['bona', 'seria', 'male'];
+export const TARGET = 11;
+// I tempi delle animazioni (scopa-render.js): la carta vola dalla mano; le carte prese restano ferme un attimo e poi
+// volano sul mucchietto di chi ha preso.
+export const PLAY_TIME = 0.3, TAKE_HOLD = 0.75, TAKE_TIME = 1.35;
+export const COIN = { toscane: 'mattoni', napoletane: 'denari' };
+// Valore per le prese: Asso 1, poi i numeri, figure 8, 9 e 10. Primiera: 7 vale 21, 6 18, Asso 16, 5 15, 4 14,
+// 3 13, 2 12, le figure 10.
+const PRIME = [16, 12, 13, 14, 15, 18, 21, 10, 10, 10];
+const build = ({ suits, ranks }) => Object.freeze(suits.flatMap((suit, s) => ranks.map((rank, r) =>
+    Object.freeze({ id: s * 10 + r, suit, rank, value: r + 1, prime: PRIME[r] }))));
+export const DECK_CARDS = Object.fromEntries(Object.entries(DECKS).map(([name, deck]) => [name, build(deck)]));
+export const other = who => who === 'player' ? 'cpu' : 'player';
+const lcg = n => (Math.imul(n, 1664525) + 1013904223) >>> 0;
+function rng(seed) { let n = seed >>> 0; return () => (n = lcg(n)) / 4294967296; }
+function shuffle(cards, random) {
+    for (let i = cards.length - 1; i > 0; i--) { const j = Math.floor(random() * (i + 1)); [cards[i], cards[j]] = [cards[j], cards[i]]; }
+    return cards;
+}
+
+// Le prese possibili con `card`: se in tavola c'è una carta dello stesso valore si prende quella (una sola, a
+// scelta se sono più d'una); altrimenti ogni gruppo di carte che somma il suo valore. Se una presa c'è, è obbligatoria.
+export function captures(table, card) {
+    const same = table.filter(a => a.value === card.value);
+    if (same.length) return same.map(a => [a]);
+    const out = [];
+    for (let mask = 1; mask < 1 << table.length; mask++) {
+        const pick = table.filter((_, i) => mask & 1 << i);
+        if (pick.length > 1 && pick.reduce((n, a) => n + a.value, 0) === card.value) out.push(pick);
+    }
+    return out;
+}
+const isSettebello = (card, deck) => card.suit === COIN[deck] && card.value === 7;
+// Primiera: la carta migliore di ogni seme; chi non ha tutti e quattro i semi non la fa.
+export function primiera(cards, deck) {
+    const suits = DECKS[deck].suits;
+    if (!suits.every(s => cards.some(a => a.suit === s))) return 0;
+    return suits.reduce((n, s) => n + Math.max(...cards.filter(a => a.suit === s).map(a => a.prime)), 0);
+}
+// I punti di una smazzata: carte (più di 20), mattoni o denari (più di 5), settebello, primiera, una per scopa.
+export function tally(taken, scope, deck) {
+    const coin = COIN[deck], rows = [], who = (a, b) => a > b ? 'player' : b > a ? 'cpu' : null;
+    const count = w => taken[w].length, coins = w => taken[w].filter(a => a.suit === coin).length, prime = w => primiera(taken[w], deck);
+    rows.push({ key: 'carte', label: 'Carte', player: count('player'), cpu: count('cpu'), winner: who(count('player'), count('cpu')) });
+    rows.push({ key: 'coin', label: coin === 'mattoni' ? 'Mattoni' : 'Denari', player: coins('player'), cpu: coins('cpu'), winner: who(coins('player'), coins('cpu')) });
+    const seven = taken.player.some(a => isSettebello(a, deck)) ? 'player' : 'cpu';
+    rows.push({ key: 'settebello', label: 'Settebello', player: +(seven === 'player'), cpu: +(seven === 'cpu'), winner: seven });
+    rows.push({ key: 'primiera', label: 'Primiera', player: prime('player'), cpu: prime('cpu'), winner: who(prime('player'), prime('cpu')) });
+    const points = { player: 0, cpu: 0 };
+    for (const r of rows) if (r.winner) points[r.winner]++;
+    rows.push({ key: 'scope', label: 'Scope', player: scope.player, cpu: scope.cpu, winner: null });
+    points.player += scope.player; points.cpu += scope.cpu;
+    return { rows, points };
+}
+
+function deal(c) {
+    // Con tre o quattro re in tavola si rimescola.
+    let stock;
+    do { c.seed = lcg(c.seed); stock = shuffle([...DECK_CARDS[c.deck]], rng(c.seed)); }
+    while (stock.slice(0, 4).filter(a => a.value === 10).length >= 3);
+    c.table = stock.splice(0, 4); c.stock = stock;
+    c.hands = { player: [], cpu: [] }; c.taken = { player: [], cpu: [] }; c.scope = { player: 0, cpu: 0 };
+    c.current = other(c.dealer); c.lastTaker = null; c.round++;
+    refill(c); c.events.push({ kind: 'card-shuffle' });
+}
+// Tre carte a testa, prima a chi gioca per primo.
+function refill(c) {
+    for (let i = 0; i < 3; i++) for (const who of [other(c.dealer), c.dealer]) c.hands[who].push(c.stock.shift());
+    c.step = 'play'; c.t = 0; c.selected = 0; c.choice = null;
+}
+export function newScopa(seed = Date.now() >>> 0, { level = 'seria', deck = 'toscane' } = {}) {
+    const c = { level: LEVELS.includes(level) ? level : 'seria', deck: DECKS[deck] ? deck : 'toscane', score: { player: 0, cpu: 0 },
+        round: 0, seed: seed >>> 0, aiSeed: (seed ^ 0x27d4eb2f) >>> 0, age: 0, events: [], last: null, summary: null };
+    c.dealer = rng(seed)() < 0.5 ? 'player' : 'cpu';
+    deal(c); return c;
+}
+export const canPlay = c => c.step === 'play' && c.current === 'player';
+export function select(c, index) {
+    if (c.step === 'choose' && Number.isInteger(index) && c.choice.options[index]) { c.choice.selected = index; return true; }
+    if (!canPlay(c) || !Number.isInteger(index) || !c.hands.player[index]) return false;
+    c.selected = index; return true;
+}
+export function nudge(c, direction) {
+    if (c.step === 'choose') { const n = c.choice.options.length; return select(c, (c.choice.selected + direction + n) % n); }
+    const n = c.hands.player.length;
+    return select(c, (c.selected + direction + n) % n);
+}
+// Andrea gioca una carta: se le prese possibili sono più d'una, sceglie lui quale (passo «choose»).
+export function play(c, index = c.selected, who = 'player', option = null) {
+    if (c.step !== 'play' || c.current !== who || !Number.isInteger(index) || !c.hands[who][index]) return false;
+    const options = captures(c.table, c.hands[who][index]);
+    if (options.length > 1 && option === null) {
+        if (who !== 'player') return false;
+        c.step = 'choose'; c.choice = { index, options, selected: 0 }; return true;
+    }
+    return execute(c, who, index, options.length ? options[option ?? 0] : null);
+}
+export function take(c, k = c.choice?.selected) {
+    if (c.step !== 'choose' || !c.choice.options[k]) return false;
+    const { index, options } = c.choice; c.step = 'play'; c.choice = null;
+    return execute(c, 'player', index, options[k]);
+}
+export function cancel(c) { if (c.step !== 'choose') return false; c.step = 'play'; c.choice = null; return true; }
+function execute(c, who, index, captured) {
+    if (!captured && captures(c.table, c.hands[who][index]).length) return false;
+    const before = [...c.table], [card] = c.hands[who].splice(index, 1);
+    if (captured) {
+        const ids = new Set(captured.map(a => a.id));
+        c.table = c.table.filter(a => !ids.has(a.id)); c.taken[who].push(card, ...captured); c.lastTaker = who;
+    } else c.table.push(card);
+    // L'ultima carta della smazzata non fa scopa.
+    const lastPlay = !c.stock.length && !c.hands.player.length && !c.hands.cpu.length;
+    const scopa = !!captured && !c.table.length && !lastPlay;
+    if (scopa) c.scope[who]++;
+    // `from` e `before` servono al disegno: da dove parte la carta e com'era la tavola prima della presa.
+    c.last = { who, card, captured: captured ?? [], scopa, from: index, before };
+    c.events.push({ kind: captured ? 'card-tap' : 'card-slide', who }, ...(scopa ? [{ kind: 'card-busso', who }] : []));
+    c.step = 'take'; c.t = 0;
+    if (who === 'player') c.selected = Math.min(c.selected, Math.max(0, c.hands.player.length - 1));
+    return true;
+}
+function after(c) {
+    c.current = other(c.last.who); c.t = 0; c.step = 'play';
+    if (c.hands.player.length || c.hands.cpu.length) return;
+    if (c.stock.length) { refill(c); return; }
+    // Fine smazzata: quel che resta in tavola va all'ultimo che ha preso.
+    if (c.lastTaker) c.taken[c.lastTaker].push(...c.table);
+    c.table = [];
+    const t = tally(c.taken, c.scope, c.deck);
+    c.score.player += t.points.player; c.score.cpu += t.points.cpu;
+    c.summary = { ...t, score: { ...c.score } }; c.t = 0;
+    // Il risultato è subito definitivo: uscire dal riepilogo non può cancellare una vittoria.
+    if (finished(c)) { c.step = 'result'; c.result = { winner: c.score.player > c.score.cpu ? 'player' : 'cpu', ...c.score }; }
+    else c.step = 'smazzata';
+}
+// Si va agli 11, contati a fine smazzata: vince chi ne ha di più; pari (o nessuno agli 11), se ne fa un'altra.
+export const finished = c => Math.max(c.score.player, c.score.cpu) >= TARGET && c.score.player !== c.score.cpu;
+// Dopo il riepilogo (resta finché Andrea non va avanti) si fa la smazzata dopo.
+export function advance(c) {
+    if (c.step !== 'smazzata') return false;
+    c.dealer = other(c.dealer); deal(c);
+    return true;
+}
+
+// La sola porta d'ingresso dell'avversario: la sua mano, la tavola e le carte prese (si son viste tutte).
+export function observation(c, who = 'cpu') {
+    return { who, deck: c.deck, hand: [...c.hands[who]], table: [...c.table], taken: { player: [...c.taken.player], cpu: [...c.taken.cpu] },
+        opponentCount: c.hands[other(who)].length, stock: c.stock.length, scope: { ...c.scope }, lastTaker: c.lastTaker };
+}
+// Le carte che non si sono viste: in mano all'altro o nel mazzo.
+export function unseen(v) {
+    const seen = new Set([...v.hand, ...v.table, ...v.taken.player, ...v.taken.cpu].map(a => a.id));
+    return DECK_CARDS[v.deck].filter(a => !seen.has(a.id));
+}
+// Quanto vale una mossa: le carte prese (settebello, sette, mattoni, primiera, scopa) meno il rischio di lasciare
+// una scopa all'altro. «Seria» il rischio lo stima a occhio; «A fassi male» conta quante carte di quel valore
+// possono essere ancora in mano all'altro.
+export function score(v, card, captured, counting) {
+    const coin = COIN[v.deck], last = !v.stock && v.hand.length === 1 && !v.opponentCount;
+    const left = captured ? v.table.filter(a => !captured.includes(a)) : [...v.table, card];
+    // La primiera vale per quanto migliora la propria: un 7 di un seme dove si ha già un 7 non aggiunge niente,
+    // la prima carta di un seme che manca aggiunge parecchio.
+    const mine = v.taken[v.who] ?? [], best = suit => Math.max(0, ...mine.filter(a => a.suit === suit).map(a => a.prime));
+    const prime = a => Math.max(0, a.prime - best(a.suit)) / 4 + (best(a.suit) ? 0 : 1);
+    const worth = a => 1 + (a.suit === coin ? 1.5 : 0) + (isSettebello(a, v.deck) ? 12 : 0) + prime(a);
+    let value = captured ? [card, ...captured].reduce((n, a) => n + worth(a), 0) + (!left.length && !last ? 20 : 0) : -worth(card) * 0.6;
+    const sum = left.reduce((n, a) => n + a.value, 0);
+    if (left.length && sum <= 10 && v.opponentCount) {
+        let p = 0.5;
+        if (counting) {
+            const pool = unseen(v), same = pool.filter(a => a.value === sum).length;
+            p = pool.length ? 1 - (1 - same / pool.length) ** v.opponentCount : 0;
+        }
+        value -= p * 20;
+    }
+    // Lasciare in tavola un 7 o il settebello vuol dire regalarli.
+    value -= left.filter(a => a.value === 7).length * (counting ? 1.5 : 0) + (left.some(a => isSettebello(a, v.deck)) ? 6 : 0);
+    return value;
+}
+export function moves(v) {
+    return v.hand.flatMap((card, index) => {
+        const opts = captures(v.table, card);
+        return opts.length ? opts.map((captured, option) => ({ index, option, captured })) : [{ index, option: null, captured: null }];
+    });
+}
+// «Alla bona» gioca a caso; «Seria» e «A fassi male» scelgono la mossa che vale di più.
+// Taratura (tools/calibrate_scopa.mjs, 300 partite): Andrea vince 96% contro «Alla bona», 76% contro «Seria», 50% contro «A fassi male».
+// A mazzo finito le carte dell'altro sono proprio quelle non viste: si calcola il finale esatto, fino al conteggio
+// (carte, mattoni, settebello, primiera, scope, e la tavola all'ultimo che prende).
+export function endgame(v) {
+    const me = v.who, them = other(me), memo = new Map();
+    const final = (taken, scope, table, last) => {
+        const all = { player: [...taken.player], cpu: [...taken.cpu] };
+        if (last) all[last].push(...table);
+        const t = tally(all, scope, v.deck);
+        return t.points[me] - t.points[them];
+    };
+    const solve = (hands, table, taken, scope, last, turn) => {
+        if (!hands.player.length && !hands.cpu.length) return final(taken, scope, table, last);
+        const key = `${turn}|${hands[me].map(a => a.id)}|${hands[them].map(a => a.id)}|${table.map(a => a.id).sort()}|${last}|${taken.player.length}|${scope.player}${scope.cpu}`;
+        if (memo.has(key)) return memo.get(key);
+        let best = turn === me ? -Infinity : Infinity;
+        for (const m of moves({ hand: hands[turn], table })) {
+            const r = step(hands, table, taken, scope, last, turn, m);
+            const value = solve(...r);
+            best = turn === me ? Math.max(best, value) : Math.min(best, value);
+        }
+        memo.set(key, best); return best;
+    };
+    const step = (hands, table, taken, scope, last, turn, m) => {
+        const card = hands[turn][m.index], rest = { ...hands, [turn]: hands[turn].filter((_, i) => i !== m.index) };
+        if (!m.captured) return [rest, [...table, card], taken, scope, last, other(turn)];
+        const ids = new Set(m.captured.map(a => a.id)), left = table.filter(a => !ids.has(a.id));
+        const end = !rest.player.length && !rest.cpu.length;
+        return [rest, left, { ...taken, [turn]: [...taken[turn], card, ...m.captured] },
+            !left.length && !end ? { ...scope, [turn]: scope[turn] + 1 } : scope, turn, other(turn)];
+    };
+    const hands = { [me]: v.hand, [them]: unseen(v) };
+    const start = [hands, v.table, v.taken, v.scope ?? { player: 0, cpu: 0 }, v.lastTaker ?? null, me];
+    return moves(v).map(m => ({ m, value: solve(...step(...start, m)) })).reduce((a, b) => b.value > a.value ? b : a).m;
+}
+export function choose(v, level = 'seria', seed = 1) {
+    const all = moves(v);
+    if (level === 'bona') return all[Math.floor(rng(seed)() * all.length)];
+    const counting = level === 'male';
+    if (counting && !v.stock && unseen(v).length === v.opponentCount) return endgame(v);
+    return all.reduce((a, b) => score(v, v.hand[b.index], b.captured, counting) > score(v, v.hand[a.index], a.captured, counting) ? b : a);
+}
+export function update(c, dt) {
+    if (!Number.isFinite(dt) || dt < 0 || c.step === 'result') return;
+    c.t += dt;
+    if (c.step === 'take' && c.t >= (c.last.captured.length ? TAKE_TIME : PLAY_TIME * 2)) after(c);
+    else if (c.step === 'play' && c.current === 'cpu' && c.t >= 0.75) {
+        c.aiSeed = lcg(c.aiSeed);
+        const m = choose(observation(c, 'cpu'), c.level, c.aiSeed);
+        play(c, m.index, 'cpu', m.option);
+    }
+}
+export function status(c, names = { player: 'Andrea', cpu: 'Il giocatore' }) {
+    if (c.step === 'result') return `${c.result.winner === 'player' ? 'Hai vinto' : `Vince ${names.cpu}`}, ${c.score.player} a ${c.score.cpu}!`;
+    if (c.step === 'smazzata') return `Smazzata finita: siamo ${c.score.player} a ${c.score.cpu}. Invio per continuare.`;
+    if (c.step === 'choose') return 'Più prese possibili: scegli quale (frecce o tocca una carta in tavola), Invio prende.';
+    if (c.step === 'take') {
+        const l = c.last;
+        return l.scopa ? `Scopa di ${names[l.who]}!` : l.captured.length ? `${names[l.who]} prende con ${cardName(l.card)}.` : `${names[l.who]} posa ${cardName(l.card)}.`;
+    }
+    // A parole anche la tavola, per chi non vede il disegno.
+    const table = `In tavola: ${c.table.map(cardName).join(', ') || 'niente'}.`;
+    return c.current === 'player' ? `${table} Tocca una carta per giocarla. Frecce o 1–2–3 scelgono, Invio gioca.` : `${table} ${names.cpu} pensa…`;
+}