"""Genera le slide 1080x1440 di un carosello e le rasterizza con Chrome headless.

Le misure qui dentro sono quelle vere del template, non riscalate: i mockup in
`mockup/` sono le stesse slide ridotte a 340px per guardarle affiancate.

    python3 slide.py            genera il post 1 (Draftosaurus) in ../out/
"""
import html as _html
import math
import os
import re
import subprocess
import sys

QUI = os.path.dirname(os.path.abspath(__file__))
BASE = os.path.dirname(QUI)
FONT = os.path.join(BASE, "font")
FOTO = os.path.join(BASE, "foto")
SCATOLE = os.path.join(BASE, "scatole", "pronte")
OUT = os.path.join(BASE, "out", "post")
HTML = os.path.join(BASE, "out", "html")
CHROME = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"

CSS = """
*{box-sizing:border-box;margin:0;padding:0}
html,body{width:1080px;height:1440px;background:#000;overflow:hidden}
body{font-family:Inter,system-ui,sans-serif;-webkit-font-smoothing:antialiased}
.post{width:1080px;height:1440px;position:relative;overflow:hidden;background:#000;
      display:flex;flex-direction:column}
.post img{width:100%;height:100%;object-fit:cover;display:block}
.et{font-size:32px;font-weight:600;letter-spacing:.06em;text-transform:uppercase;color:#E0A340;line-height:1}
.corpo{font-size:48px;line-height:66px;color:#fff;margin-top:30px}

/* copertina */
.cop .foto{height:1140px;flex:none;position:relative;overflow:hidden}
.cop .sf{position:absolute;left:0;right:0;bottom:0;height:40%;
    background:linear-gradient(to top,rgba(0,0,0,.93),rgba(0,0,0,.74) 28%,rgba(0,0,0,.3) 62%,rgba(0,0,0,0))}
.cop .tit{position:absolute;left:64px;right:64px;bottom:26px;
    font-family:'Bebas Neue',sans-serif;font-size:136px;line-height:.86;color:#fff;letter-spacing:.014em}
.cop .tit.due{font-size:120px}
.cop .banda{flex:1;background:#000;padding:0 64px;display:flex;flex-direction:column}
.cop .zc{flex:1;display:flex;align-items:center}
.cred{font-size:30px;color:#8d8d8d;line-height:1.35} .cred b{color:#c9c9c9;font-weight:600}
.cop .bd{flex:none;border-top:2px solid #383838;padding:44px 0}

/* le tre colonne, identiche ovunque compaiano */
.dati3{display:flex} .dati3>span{text-align:center;position:relative;flex:1 1 auto}
/* Larghezze a contenuto, non fisse. Prima erano 25/32/43%, misurate sul caso
   peggiore ("Impegnativo" piu' una durata a forbice). Quando quel caso non
   c'era, Durata e Peso restavano larghe e mezze vuote mentre GIOCATORI, che ha
   l'etichetta piu' lunga delle tre, stava stretta: si vedeva, e Paolo l'ha
   segnalato il 2026-09-04 guardando post2_1. Con flex:1 1 auto ogni cella parte
   dalla larghezza del suo contenuto e lo spazio che avanza si divide in tre
   parti uguali, quindi tutte e tre hanno la stessa aria. Il nowrap
   sull'etichetta e' necessario: senza, "GIOCATORI" puo' andare a capo e la
   misura salta. I filetti non stanno piu' nello stesso punto da un post
   all'altro, ed e' voluto. */
.dati3>span:not(:last-child)::after{content:"";position:absolute;right:0;top:6px;bottom:3px;width:2px;background:#383838}
.k{display:block;font-size:30px;letter-spacing:.13em;text-transform:uppercase;color:#E0A340;font-weight:700;line-height:1;white-space:nowrap}
.v{display:block;font-size:54px;font-weight:600;color:#fff;margin-top:14px;line-height:1.15;white-space:nowrap}
.tr{margin:0 .10em}

/* foto sopra, testo sotto */
.fs .foto{height:810px;flex:none;position:relative;overflow:hidden}
.fs .sf{position:absolute;left:0;right:0;bottom:0;height:300px;
    background:linear-gradient(to top,#000 0%,rgba(0,0,0,.72) 34%,rgba(0,0,0,0) 100%)}
.fs .testo{flex:1;padding:0 60px 70px;margin-top:-70px;display:flex;flex-direction:column;justify-content:flex-end}

/* testo sopra, foto sotto */
.ts .testo{flex:none;min-height:680px;padding:44px 60px 0;z-index:2}
.ts .foto{flex:1;position:relative;overflow:hidden;margin-top:-60px}
.ts .sf{position:absolute;left:0;right:0;top:0;height:300px;
    background:linear-gradient(to bottom,#000 0%,rgba(0,0,0,.72) 34%,rgba(0,0,0,0) 100%);z-index:1}

/* la scatola */
.sc{padding:0 60px}
.sc .occh{font-size:32px;letter-spacing:.16em;text-transform:uppercase;color:#E0A340;font-weight:700;margin-top:44px}
.sc .box{width:100%;height:550px;margin-top:44px;display:flex;align-items:center;justify-content:center;flex:none}
.sc .box img{max-width:100%;max-height:100%;object-fit:contain;width:auto;height:auto;
    filter:drop-shadow(0 26px 44px rgba(0,0,0,.95))}
.sc .lab{font-size:28px;letter-spacing:.12em;text-transform:uppercase;color:#8d8d8d;font-weight:600}
.sc .ed{font-size:46px;font-weight:600;color:#fff;line-height:1.15;margin-top:12px}
.sc .bl{margin-top:70px}
.tag{display:inline-block;border:3px solid #5a5a5a;border-radius:100px;padding:10px 22px;
    font-size:29px;color:#d4d4d4;margin:12px 9px 0 0}
.tagA{border-color:#8a6a33;color:#E0A340}
.sc .dati3{border-top:2px solid #383838;padding-top:44px;margin-top:auto;margin-bottom:44px}

/* chiusura */
.ch .foto{height:700px;flex:none;position:relative;overflow:hidden}
.ch .sf{position:absolute;left:0;right:0;bottom:0;height:280px;
    background:linear-gradient(to top,#000 0%,rgba(0,0,0,.7) 40%,rgba(0,0,0,0) 100%)}
.ch .sotto{flex:1;padding:0 60px 80px;margin-top:-60px;display:flex;flex-direction:column;justify-content:flex-end}
.ch .filetto{width:120px;height:5px;background:#E0A340}
.ch .dom{font-family:'Bebas Neue',sans-serif;font-size:104px;line-height:110px;color:#fff;margin-top:44px}
.ch .grigia{font-size:34px;color:#8d8d8d;margin-top:44px;line-height:1.35}
.ch .invito{font-size:34px;color:#E0A340;font-weight:600;margin-top:27px}

/* quanto dura davvero */
.dv{padding:0 60px}
.dv .occh{font-size:32px;letter-spacing:.16em;text-transform:uppercase;color:#E0A340;font-weight:700;margin-top:44px}
.dv .strillo{font-family:'Bebas Neue',sans-serif;font-size:96px;line-height:.94;color:#fff;margin-top:34px}
.dv .graf{position:relative;height:640px;margin-top:auto;display:flex;align-items:flex-end;gap:40px}
.dv .col{flex:1;display:flex;flex-direction:column;justify-content:flex-end;align-items:center}
.dv .num{font-family:'Bebas Neue',sans-serif;font-size:84px;line-height:1;color:#8d8d8d;margin-bottom:16px;white-space:nowrap}
.dv .num.top{color:#E0A340}
.dv .num .h{font-family:Inter,system-ui,sans-serif;font-size:50px;font-weight:600;
    vertical-align:baseline;margin:0 .1em 0 .04em}
.dv .num .min{font-size:40px;vertical-align:top;margin-left:.02em}
.dv .barra{width:100%;max-width:230px;background:#7a6740;border-radius:8px 8px 0 0}
.dv .barra.top{background:#E0A340}
.dv .soglia{position:absolute;left:0;right:0;border-top:4px dashed #6a6a6a;z-index:2}
.dv .fascia{position:absolute;left:0;right:0;z-index:2;background:rgba(255,255,255,.06);
    border-top:4px dashed #6a6a6a;border-bottom:4px dashed #6a6a6a}
.dv .righe{display:flex;gap:40px;margin-top:22px}
.dv .righe span{flex:1;text-align:center;font-size:34px;color:#8d8d8d}
.dv .nota{border-top:2px solid #383838;padding-top:36px;margin-top:56px;margin-bottom:44px;
    font-size:30px;color:#8d8d8d;line-height:1.4}
"""


# --- controlli automatici ---------------------------------------------------
# Regole decise con Paolo e sbagliate piu' di una volta a mano. Stanno qui e non
# in un promemoria perche' un promemoria non ferma niente.

VOI = ("vostro", "vostra", "vostri", "vostre", " voi ", "scrivetelo", "taggatelo",
       "avete", "siete", "potete", "vi serve")


def _controlla(testo, dove):
    """Si da' sempre del tu, mai del voi. Vedi la memoria del progetto."""
    b = testo.lower()
    for v in VOI:
        if v in b:
            raise ValueError(f"{dove}: c'e' un \"{v.strip()}\", ma si da' del tu")
    return testo


def _controlla_domanda(dom):
    """Un "qual e' il tuo <sostantivo>?" nudo non chiede niente di preciso: "qual e'
    il tuo cinghiale?" non si sa cosa voglia. Serve almeno una parola che qualifichi,
    "preferito" oppure "da sette giocatori". Due parole bastano."""
    piatta = re.sub(r"[?!.]+$", "", dom.replace("<br>", " ").lower().strip())
    m = re.match(r"qual è (?:il tuo|la tua)\s+(.*)", piatta)
    if m and len(m.group(1).split()) < 2:
        raise ValueError(f"domanda troppo secca: \"{piatta}?\" "
                         "(un sostantivo da solo non dice cosa rispondere)")
    return _controlla(dom, "domanda di chiusura")


def _dati3(giocatori, durata, peso):
    # Il trattino lungo va staccato dai numeri, chiesto da Paolo. Vale per tutte e
    # due le colonne che ne hanno uno: Giocatori ("1-4") e Durata ("30-120'"). Fino
    # al 2026-09-09 lo si faceva solo su Giocatori, e sulla Durata il trattino
    # restava appiccicato ai numeri.
    stacca = lambda t: t.replace("–", '<span class="tr">–</span>')
    g, durata = stacca(giocatori), stacca(durata)
    return ('<div class="dati3">'
            f'<span><span class="k">Giocatori</span><span class="v">{g}</span></span>'
            f'<span><span class="k">Durata</span><span class="v">{durata}</span></span>'
            f'<span><span class="k">Peso</span><span class="v">{peso}</span></span></div>')


def copertina(foto, titolo, credits, dati):
    due = " due" if "<br>" in titolo else ""
    return (f'<div class="post cop"><div class="foto"><img src="{foto}"><div class="sf"></div>'
            f'<div class="tit{due}">{titolo}</div></div>'
            f'<div class="banda"><div class="zc"><div class="cred">{credits}</div></div>'
            f'<div class="bd">{_dati3(*dati)}</div></div></div>')


def foto_sopra(foto, occhiello, testo):
    _controlla(testo, "slide cos'è")
    return (f'<div class="post fs"><div class="foto"><img src="{foto}"><div class="sf"></div></div>'
            f'<div class="testo"><div class="et">{occhiello}</div>'
            f'<div class="corpo">{testo}</div></div></div>')


def testo_sopra(foto, occhiello, testo):
    _controlla(testo, "slide come gira")
    return (f'<div class="post ts"><div class="testo"><div class="et">{occhiello}</div>'
            f'<div class="corpo">{testo}</div></div>'
            f'<div class="foto"><div class="sf"></div><img src="{foto}"></div></div>')


def scatola(img, colonne, blocchi, dati):
    """colonne: lista di (etichetta, valore) affiancate. blocchi: (etichetta, [tag], ambra)."""
    c = "".join(f'<div style="flex:{"1" if i == 0 else "0 0 42%"}">'
                f'<div class="lab">{e}</div><div class="ed">{v}</div></div>'
                for i, (e, v) in enumerate(colonne))
    b = "".join(f'<div class="bl"><div class="lab">{e}</div><div>'
                + "".join(f'<span class="tag{" tagA" if amb else ""}">{t}</span>' for t in tags)
                + '</div></div>' for e, tags, amb in blocchi)
    return (f'<div class="post sc"><div class="occh">La scatola</div>'
            f'<div class="box"><img src="{img}"></div>'
            f'<div class="bl" style="display:flex">{c}</div>{b}{_dati3(*dati)}</div>')


def chiusura(foto, domanda, grigia, invito, stile_foto=""):
    """stile_foto: css inline sull'<img>, per spostare il ritaglio.

    La foto e' tagliata da `object-fit:cover`, che di suo tiene il centro e
    butta via sopra e sotto in parti uguali. Quando il soggetto sta in alto,
    come la mangiatoia di Wingspan, con "object-position:top" si taglia solo da
    sotto. Chiesto da Paolo il 2026-09-02: i dadi in cima erano mozzati.
    """
    _controlla_domanda(domanda); _controlla(grigia, "riga grigia"); _controlla(invito, "invito")
    return (f'<div class="post ch"><div class="foto"><img src="{foto}" style="{stile_foto}"><div class="sf"></div></div>'
            f'<div class="sotto"><div class="filetto"></div><div class="dom">{domanda}</div>'
            f'<div class="grigia">{grigia}</div>'
            f'<div class="invito">{invito}</div></div></div>')


QUANTI = {1: "da solo", 2: "in due", 3: "in tre", 4: "in quattro",
          5: "in cinque", 6: "in sei", 7: "in sette", 8: "in otto"}


def _ore(minuti, tag=True):
    """Sopra l'ora si scrive "1h 50′", non "110′".

    Chiesto da Paolo il 2026-09-01: "110′ e' difficile per noi umani trasportarlo
    immediatamente al volo in ore". Vale **solo su questa slide**: nella riga dei
    dati della copertina e della slide della scatola resta la durata com'e'
    stampata sulla scatola.

    Con tag=False torna il testo nudo, per la legenda: li' gli apici non servono,
    e messi col font-size del grafico venivano piu' grandi del testo intorno.
    """
    def h(t): return f'<span class="h">{t}</span>' if tag else t
    def ap(t): return f'<span class="min">{t}</span>' if tag else t
    if minuti < 60:
        return f"{minuti}{ap(chr(8242))}"
    ore, resto = divmod(minuti, 60)
    if not resto:
        return f"{ore}{h('h')}"
    return f"{ore}{h('h')} {resto}{ap(chr(8242))}"


def _intervallo(a, b):
    """La riga della legenda, testo semplice. Sotto l'ora l'apice va solo in
    fondo: "30-45′", non "30′-45′"."""
    if a == b:
        return _ore(a, tag=False)
    if b < 60:
        return f"{a}\u2013{b}\u2032"
    return f"{_ore(a, tag=False)}\u2013{_ore(b, tag=False)}"


def _arrotonda(minuti):
    """Precisione a scaletta: piu' il numero e' grande, piu' grosso e' il passo.

    Fino a 30 minuti il valore esatto, perche' su un gioco corto arrotondare
    cancella differenze vere (Draftosaurus fa 8, 12 e 15). Poi ai 5 fino all'ora,
    ai 10 fino alle due ore (nessuno dice "una partita da 65 minuti"), ai 15
    sopra le due ore, dove i valori cadono su 120, 135, 150 e si leggono come ore
    e quarti.

    **Ai 15 e non ai 20**: col passo da 20 Brass fa 140 in tre e 140 in quattro,
    le due colonne vengono uguali e la slide non dice piu' niente. Coi 15 restano
    135 e 150.

    Si arrotonda con floor(x + 0.5) e non con round(), che in Python pareggia al
    pari: round(10.5) fa 10, quindi 105 minuti sarebbero diventati 100 e 115
    invece 120.
    """
    if minuti <= 30:
        return minuti
    passo = 5 if minuti <= 60 else (10 if minuti <= 120 else 15)
    return math.floor(minuti / passo + 0.5) * passo


SCARTO_MINIMO = 10      # minuti
SCARTO_MINIMO_QUOTA = 0.20


def merita_durata(stats, min_scatola, max_scatola, min_partite=3):
    """La slide della durata va messa solo quando ha qualcosa da dire.

    Se tutte le colonne stanno dentro a quello che promette la scatola, il
    grafico ripete l'informazione che sta gia' nella riga "Durata" della
    copertina e della slide della scatola. Deciso con Paolo il 2026-09-01
    guardando Century, che dichiara 30-45 e al tavolo fa 29, 30, 40 e 40.

    Serve uno scarto **sia in percentuale sia in minuti**: la sola percentuale
    fa passare i giochi corti, dove Draftosaurus a 8 minuti contro 15 dichiarati
    e' il 47% ma sono sette minuti di differenza e nessuno se ne accorge.

    Restituisce la frase del perche', oppure None se non vale la pena.
    """
    righe = [(g, _arrotonda(p["durataMediana"]), p["partite"])
             for g, p in ((p["giocatori"], p) for p in stats) if p["partite"] >= min_partite]
    if len(righe) < 2:
        return None

    valori = [m for _, m, _ in righe]
    sopra = max(valori) - max_scatola
    sotto = min_scatola - min(valori)
    if sopra >= SCARTO_MINIMO and sopra >= max_scatola * SCARTO_MINIMO_QUOTA:
        return f"{QUANTI[max(g for g, m, _ in righe if m == max(valori))]} ci vogliono {sopra} minuti in piu' del massimo dichiarato"
    if sotto >= SCARTO_MINIMO and sotto >= min_scatola * SCARTO_MINIMO_QUOTA:
        return f"{QUANTI[min(g for g, m, _ in righe if m == min(valori))]} ci vogliono {sotto} minuti in meno del minimo dichiarato"
    return None


def durata(stats, min_scatola, max_scatola, strillo="Al nostro tavolo",
           accento="alta", min_partite=3, nota=None):
    """Istogramma della durata reale, una colonna per numero di giocatori.

    stats: la lista `partiteStats.perGiocatori` del portale, che arriva gia'
    ripulita (via i doppioni, le partite senza durata, i solitari, le durate
    impossibili). Si usa la **mediana**, mai la media: una serata andata per le
    lunghe sposta la media e non la mediana. Le configurazioni con meno di
    `min_partite` partite non entrano, perche' una colonna costruita su due
    partite non dice niente.

    La durata della scatola e' una riga tratteggiata che attraversa il grafico:
    dove una colonna la buca, il gioco dura piu' di quanto promette. Per un
    intervallo si prende il massimo, che e' la promessa vera. L'etichetta della
    riga sta in legenda sotto il titolo e non dentro al grafico, dove sembrava
    l'etichetta della prima colonna.
    """
    righe = [(p["giocatori"], _arrotonda(p["durataMediana"]), p["partite"])
             for p in stats if p["partite"] >= min_partite]
    if len(righe) < 2:
        raise ValueError(f"servono almeno due configurazioni con {min_partite}+ partite, "
                         f"ce ne sono {len(righe)}")
    righe.sort()

    # La scatola che dichiara "90-115" non sta dicendo che il gioco e' variabile a
    # caso: quasi sempre sta dicendo che in due dura novanta e in cinque centoquindici.
    # Verificato sull'archivio il 2026-09-02, su 50 giochi con la forbice doppia: la
    # configurazione con meno giocatori sta piu' vicina al minimo dichiarato che al
    # massimo in 30 casi su 50, e l'errore medio scende da 24,7 a 19,1 minuti. Quindi
    # il riferimento non e' una riga sul massimo, e' tutta la forbice: si sfora solo
    # uscendo di sopra o di sotto.

    # Quale colonna va in ambra. Di solito la piu' alta, perche' l'accento serve a
    # dire dove il gioco si allunga. Su un gioco che invece si accorcia il fatto sta
    # dalla parte opposta: Cryptid dichiara 30-50 e in tre finisce in 11 minuti, e
    # illuminare la colonna alta punterebbe il dito sulla cosa meno interessante.
    if accento not in ("alta", "bassa"):
        raise ValueError('accento va "alta" oppure "bassa"')
    if accento == "alta":
        # a parita' la piu' a destra: due colonne ambra tolgono all'accento il suo
        # lavoro, e capita quando l'arrotondamento pareggia due valori vicini
        estremo = max(m for _, m, _ in righe)
        accesa = max(g for g, m, _ in righe if m == estremo)
    else:
        estremo = min(m for _, m, _ in righe)
        accesa = min(g for g, m, _ in righe if m == estremo)
    scala = max(max(m for _, m, _ in righe), max_scatola)            # cosi' la riga della scatola sta sempre dentro
    alt = lambda m: round(m / scala * 640)

    colonne = "".join(
        f'<div class="col"><div class="num{" top" if g == accesa else ""}">{_ore(m)}</div>'
        f'<div class="barra{" top" if g == accesa else ""}" style="height:{alt(m)}px"></div></div>'
        for g, m, _ in righe)
    etichette = "".join(f'<span>{QUANTI[g]}</span>' for g, _, _ in righe)

    dichiarata = _intervallo(min_scatola, max_scatola)
    if min_scatola == max_scatola:
        riferimento = f'<div class="soglia" style="bottom:{alt(min_scatola)}px"></div>'
        parola = "La riga tratteggiata"
    else:
        basso, alto = alt(min_scatola), alt(max_scatola)
        riferimento = (f'<div class="fascia" style="bottom:{basso}px;'
                       f'height:{alto - basso}px"></div>')
        parola = "La fascia tratteggiata"
    considerate = sum(n for _, _, n in righe)
    if nota is None:
        # a capo voluto: cosi' la seconda frase sta tutta su una riga sola
        nota = (f"Mediana delle nostre {considerate} partite.<br>"
                f"{parola} è {dichiarata}, quello che dice la scatola.")
    _controlla(nota, "nota della durata")

    return (f'<div class="post dv"><div class="occh">Quanto dura davvero</div>'
            f'<div class="strillo">{strillo}</div>'
            f'<div class="graf">{riferimento}{colonne}</div>'
            f'<div class="righe">{etichette}</div>'
            f'<div class="nota">{nota}</div></div>')

def durata_da_portale(bgg_id, strillo, min_scatola=None, max_scatola=None, **kw):
    """Scorciatoia per i post: legge `partiteStats` dal portale e monta la slide.

    Il portale ha aggiunto `partiteStats` il 2026-09-02, quindi i JSON gia' in
    `cache_api/` da prima non ce l'hanno: la prima lettura va forzata.

    `min_scatola` e `max_scatola` servono a **scavalcare la durata del portale**,
    che viene da BGG e ogni tanto e' sbagliata. Su Barrage il portale dice 90-180,
    DungeonDice 60-120 e Cranio Creations, che il gioco lo produce, dice 120
    secchi: vince l'editore, e su questa slide la differenza cambia tutto perche'
    decide se lo scarto esiste. Su Scythe era successo il contrario, il portale
    dava 115-115 e la scatola 90-115.

    **Non si sceglie la lettura che fa comparire la slide**: si sceglie la fonte
    piu' vicina alla scatola, e poi si guarda cosa dice `merita_durata`.
    """
    from portale import dati_gioco
    d = dati_gioco(bgg_id)
    st = (d.get("partiteStats") or {}).get("perGiocatori")
    if not st:
        d = dati_gioco(bgg_id, usa_cache=False)
        st = (d.get("partiteStats") or {}).get("perGiocatori") or []
    lo = d["minPlaytime"] if min_scatola is None else min_scatola
    hi = d["maxPlaytime"] if max_scatola is None else max_scatola
    return durata(st, lo, hi, strillo=strillo, **kw)


# Sulla slide "cos'e'" il testo cresce verso l'alto, e la foto sopra e'
# `position:relative`: dall'ottava riga in su l'occhiello "Cos'e'" finisce
# dietro la foto e sparisce dalla slide. Trovato su Wingspan Pocket il
# 2026-09-09, dopo che era gia' uscito cosi' altrove.
MAX_RIGHE = {"fs": 7, "ts": 7}

# La sonda si misura solo a font caricati: se si misura subito, Chrome ha
# ancora il ripiego di sistema, che e' piu' stretto, e conta una riga in meno.
SONDA = ("<script>document.fonts.ready.then(function(){var c="
         "document.querySelector('.corpo');if(c)document.title="
         "'righe:'+Math.round(c.offsetHeight/66);});</script>")


def _chrome(html, *extra):
    return subprocess.run([CHROME, "--headless", "--disable-gpu", "--hide-scrollbars",
                           "--force-device-scale-factor=1", "--window-size=1080,1440",
                           "--virtual-time-budget=4000", *extra, f"file://{html}"],
                          check=True, capture_output=True, text=True).stdout


def righe(html):
    """Quante righe occupa il corpo del testo, chiesto a Chrome."""
    m = re.search(r"<title>righe:(\d+)</title>", _chrome(html, "--dump-dom"))
    if not m:
        raise ValueError(f"{html}: la sonda non ha risposto, righe non misurate")
    return int(m.group(1))


def pagina(corpo):
    return ('<!doctype html><html lang="it"><head><meta charset="utf-8">'
            f'<link rel="stylesheet" href="{FONT}/locale.css">'
            f'<style>{CSS}</style></head><body>{corpo}{SONDA}</body></html>')


def rasterizza(slides, cartella, prefisso):
    """Scrive un html per slide e lo fotografa a 1080x1440. Ritorna i png prodotti."""
    os.makedirs(cartella, exist_ok=True)
    os.makedirs(HTML, exist_ok=True)
    fatti = []
    for i, corpo in enumerate(slides, 1):
        h = os.path.join(HTML, f"{prefisso}_{i}.html")   # l'html e' un passaggio, non un risultato
        p = os.path.join(cartella, f"{prefisso}_{i}.png")
        with open(h, "w", encoding="utf-8") as f:
            f.write(pagina(corpo))
        for classe, massimo in MAX_RIGHE.items():
            if f'class="post {classe}"' in corpo:
                n = righe(h)
                if n > massimo:
                    raise ValueError(f"{prefisso}_{i}: il testo sta su {n} righe, "
                                     f"il massimo e' {massimo}. Va accorciato.")
        _chrome(h, f"--screenshot={p}")
        fatti.append(p)
    return fatti


# --- i post ------------------------------------------------------------------

POST = {}

POST["post1"] = [   # Draftosaurus, mercoledi 2 settembre
    copertina(f"{FOTO}/Drafto_1.jpg", "DRAFTOSAURUS",
              "Antoine Bauza e altri · 2019 · <b>Ghenos Games</b>", ("2–5", "15′", "Leggero")),
    foto_sopra(f"{FOTO}/Drafto_2.jpg", "Cos'è",
               "I dinosauri sono stati clonati, e a qualcuno è venuto in mente di aprirci uno zoo. "
               "Peschi sei dinosauri dal sacchetto, ne sistemi uno nei tuoi recinti e passi gli altri "
               "al vicino. Ogni recinto paga in modo diverso: due uguali, tutti diversi, uno solo."),
    testo_sopra(f"{FOTO}/Drafto_0.jpg", "Come gira",
                "Il dado passa di mano a ogni turno e dice a tutti dove sono obbligati a piazzare: "
                "solo nella foresta, solo a destra del fiume, solo in un recinto vuoto. "
                "Un quarto d'ora e sei alla fine, e di solito se ne fa subito un'altra."),
    scatola(f"{SCATOLE}/scatola_ita.png",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft", "Lancio di dadi", "Collezione set"], False),
             ("Di cosa parla", ["Animali", "Preistoria"], True)], ("2–5", "15′", "Leggero")),
    chiusura(f"{FOTO}/Drafto_3.jpg", "Qual è<br>il tuo filler<br>preferito?",
             "Il gioco corto che riempie il buco: prima che arrivi la pizza, o l'ultimo prima di andare a dormire.",
             "Scrivilo qui sotto, me li segno tutti."),
]

DIXIT = ("3–6", "30′", "Leggero")
POST["post2"] = [   # Dixit, venerdi 4 settembre
    copertina(f"{FOTO}/Dixit_cop.jpg", "DIXIT",
              "Jean-Louis Roubira · 2008 · <b>Asmodee Italia</b>", DIXIT),
    foto_sopra(f"{FOTO}/Dixit_cose.jpg", "Cos'è",
               "Ottantaquattro carte illustrate che non vogliono dire niente di preciso. A turno uno fa "
               "il narratore: guarda una sua carta e dice una frase, una parola, anche solo un suono. "
               "Gli altri scelgono dalla propria mano la carta che più ci somiglia, si mescola tutto e si vota."),
    testo_sopra(f"{FOTO}/Dixit_gira.jpg", "Come gira",
                "Se la tua carta la indovinano tutti non prendi niente, e se non la indovina nessuno "
                "neanche. Devi essere chiaro con qualcuno e oscuro con qualcun altro, ed è lì che la "
                "partita si decide. Mezz'ora, e si arriva a trenta punti."),
    scatola(f"{SCATOLE}/scatola_dixit.png",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Racconto", "Votazione", "Indizi asimmetrici"], False),
             ("Di cosa parla", ["Party", "Carte"], True)], DIXIT),
    chiusura(f"{FOTO}/Dixit_fine.jpg", "Chi porteresti<br>a questo<br>tavolo?",
             "Dixit funziona anche con chi non ha mai giocato a niente: bastano le figure e un po' di faccia tosta.",
             "Taggalo qui sotto."),
]

WISTAR = ("1–4", "90′", "Impegnativo")
POST["post3"] = [   # Ratti di Wistar, lunedi 7 settembre
    copertina(f"{FOTO}/Wistar_cop.jpg", "RATTI DI WISTAR",
              "Danilo Sabia e Simone Luciani · 2023 · <b>Cranio Creations</b>", WISTAR),
    foto_sopra(f"{FOTO}/Wistar_cose.jpg", "Cos'è",
               "I topi del laboratorio sono diventati intelligenti e sono scappati. Adesso vivono in "
               "una tana sotto una fattoria, e a ogni round mandano squadre di sopra a rubare legno, "
               "metallo e le idee lasciate in giro dagli umani."),
    testo_sopra(f"{FOTO}/Wistar_gira.jpg", "Come gira",
                "Alla prima partita ti concentri sulla tana: nuove stanze, nuovi topi da sbloccare. "
                "Poi si contano i punti e scopri che ha vinto chi ha giocato le carte. E non tante "
                "carte: quelle che vanno in combo fra loro. Chi trascura quella parte resta indietro, "
                "ogni volta."),
    scatola(f"{SCATOLE}/scatola_wistar.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Gestione mano", "Contratti"], False),
             ("Di cosa parla", ["Animali"], True)], WISTAR),
    durata_da_portale(387780, "In due è<br>un altro gioco"),
    chiusura(f"{FOTO}/Wistar_fine.jpg", "Quante partite<br>servono per<br>giudicare<br>un gioco?",
             "Qui alla prima costruisci la tana, e solo al conteggio scopri che i punti stavano nelle carte.",
             "Scrivi il numero qui sotto."),
]

CRYPTID = ("3–5", "30–50′", "Medio")
POST["post4"] = [   # Cryptid, venerdi 11 settembre
    copertina(f"{FOTO}/Cryptid_cop.jpg", "CRYPTID",
              "Hal Duncan e Ruth Veevers · 2018 · <b>Studio Supernova</b>", CRYPTID),
    foto_sopra(f"{FOTO}/Cryptid_cose.jpg", "Cos'è",
               "Da qualche parte su una mappa di esagoni c'è la tana di una bestia. Ognuno ha un "
               "indizio suo, e da solo non basta: la tana sta nell'unico esagono che li soddisfa "
               "tutti. Nel tuo turno o interroghi qualcuno, o vai a cercare."),
    testo_sopra(f"{FOTO}/Cryptid_gira.jpg", "Come gira",
                "Come in ogni deduttivo, dal Cluedo in poi, non basta ricordarsi il proprio indizio: "
                "devi ricostruire anche quelli degli altri. E ogni domanda che fai ne regala un pezzo, "
                "perché quando qualcuno dice di no un cubetto lo piazzi anche tu. Leggi male il tuo e "
                "salta la partita a tutti."),
    scatola(f"{SCATOLE}/scatola_cryptid.png",
            [("Edizione italiana", "Studio Supernova"), ("Testo nel gioco", "Italiano")],
            [("Come funziona", ["Deduzione", "Griglia esagonale", "Plancia modulare"], False),
             ("Di cosa parla", ["Deduttivo"], True)], CRYPTID),
    durata_da_portale(246784, "In tre finisce<br>in un lampo", accento="bassa"),
    chiusura(f"{FOTO}/Cryptid_fine.jpg", "Qual è il deduttivo<br>che non reggi?",
             "C'è chi li adora e chi dopo dieci minuti guarda il telefono. Vie di mezzo non ne ho mai viste.",
             "Scrivi il titolo qui sotto."),
]

ORA = ("1–4", "60–180′", "Cinghiale")
POST["post5"] = [   # Ora et Labora, lunedi 14 settembre
    copertina(f"{FOTO}/Ora_cop.jpg", "ORA ET LABORA",
              "Uwe Rosenberg · 2011 · <b>Uplay Edizioni</b>", ORA),
    foto_sopra(f"{FOTO}/Ora_cose.jpg", "Cos'è",
               "Sei a capo di un monastero medievale e produci di tutto, dalla torba ai libri. Le "
               "merci stanno su una ruota che a ogni giro le fa crescere per tutti: prendere presto "
               "rende poco, aspettare rende di più, ma se aspetti troppo passa un altro e svuota il mucchio."),
    testo_sopra(f"{FOTO}/Ora_gira.jpg", "Come gira",
                "Gli edifici sono sempre gli stessi e escono sempre nello stesso ordine, partita dopo "
                "partita. Chi li conosce pianifica dal primo turno. E siccome quelli degli altri si "
                "possono usare pagando l'affitto, ogni tanto conviene costruire quello che non ti "
                "serve, solo perché lo vorranno tutti."),
    scatola(f"{SCATOLE}/scatola_ora.png",
            [("Edizione italiana", "Uplay Edizioni"), ("Testo nel gioco", "Quasi niente")],
            [("Come funziona", ["Piazzamento lavoratori", "Costruzione reti", "Plancia modulare"], False),
             ("Di cosa parla", ["Economia", "Medievale", "Religione"], True)], ORA),
    chiusura(f"{FOTO}/Ora_fine.jpg", "Qual è il tuo<br>Rosenberg<br>preferito?",
             "Agricola, Le Havre, Patchwork, Caverna: ne ha fatti talmente tanti che ognuno ha il suo.",
             "Scrivilo qui sotto."),
]

BTC = ("3–7", "30′", "Leggero")
POST["post6"] = [   # Between Two Cities, mercoledi 16 settembre
    copertina(f"{FOTO}/Btc_cop.jpg", "BETWEEN TWO CITIES",
              "Ben Rosset e Matthew O'Malley · 2015 · <b>Ghenos Games</b>", BTC),
    foto_sopra(f"{FOTO}/Btc_cose.jpg", "Cos'è",
               "Nessuno costruisce una città sua. Ne costruisci una col vicino di destra e una con "
               "quello di sinistra, quindi ne hai due e nessuna delle due è solo tua. Si pescano "
               "tessere, se ne tiene una, si passa il resto, e con ogni vicino si decide insieme dove va."),
    testo_sopra(f"{FOTO}/Btc_gira.jpg", "Come gira",
                "A fine partita conti solo la peggiore delle tue due città, quindi non puoi curarne "
                "una e lasciare indietro l'altra. E se sei alla prima partita il vicino ti aiuta per "
                "forza: quella città è anche sua. Le tessere poi si scelgono tutti insieme, quindi "
                "anche in sette la partita scorre senza tempi morti."),
    scatola(f"{SCATOLE}/scatola_btc.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft", "Piazzamento tessere", "Azioni simultanee"], False),
             ("Di cosa parla", ["Costruzione città", "Negoziazione"], True)], BTC),
    chiusura(f"{FOTO}/Btc_fine.jpg", "Qual è il tuo gioco<br>da sette<br>giocatori?",
             "Sopra i cinque quasi tutto si pianta. Questo va in parallelo, quindi non si aspetta nessuno.",
             "Scrivilo qui sotto."),
]

XIDIT = ("3–5", "90′", "Medio")
POST["post7"] = [   # Lords of Xidit, venerdi 18 settembre
    copertina(f"{FOTO}/Xidit_cop.jpg", "LORDS OF XIDIT",
              "Régis Bonnessée · 2014 · <b>Asterion Press</b>", XIDIT),
    foto_sopra(f"{FOTO}/Xidit_cose.jpg", "Cos'è",
               "Un regno fantasy invaso dai mostri e cinque eroi che lo attraversano. A ogni round "
               "programmi in segreto le tue sei mosse, e poi si eseguono tutte insieme: prima la "
               "mossa uno di tutti, poi la due, e così via."),
    testo_sopra(f"{FOTO}/Xidit_gira.jpg", "Come gira",
                "Chi arriva primo sul mostro se lo prende, e chi passa un turno dopo non lo trova "
                "più: si pianifica guardando dove sono gli altri. Alla fine però non serve essere "
                "forti in tutto. Si contano reputazione, oro e influenza una alla volta, e ogni "
                "volta l'ultimo viene eliminato."),
    scatola(f"{SCATOLE}/scatola_xidit.png",
            [("Edizione italiana", "Asterion Press"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Programmazione mosse", "Azioni simultanee", "Maggioranza"], False),
             ("Di cosa parla", ["Fantasy"], True)], XIDIT),
    chiusura(f"{FOTO}/Xidit_fine.jpg", "Qual è il tuo gioco<br>di programmazione<br>preferito?",
             "Quelli dove pianifichi tutto in anticipo e poi guardi il disastro senza poterci fare niente.",
             "Scrivilo qui sotto."),
]

POZ = ("2–4", "30–45′", "Leggero")
POST["post8"] = [   # Pozioni Esplosive, lunedi 21 settembre
    copertina(f"{FOTO}/Poz_cop.jpg", "POZIONI ESPLOSIVE",
              "Andrea Crespi e altri · 2015 · <b>Ghenos Games</b>", POZ),
    foto_sopra(f"{FOTO}/Poz_cose.jpg", "Cos'è",
               "Un dispenser pieno di biglie. Al tuo turno ne prendi una sola e le altre scivolano "
               "giù: se scivolando due dello stesso colore si toccano, prendi anche quelle. Le biglie "
               "riempiono le pozioni, e ogni pozione finita vale punti."),
    testo_sopra(f"{FOTO}/Poz_gira.jpg", "Come gira",
                "Sembra un gioco per bambini, e a sei anni lo giocano davvero: prendi le biglie e "
                "riempi le pozioni. Ma chi si ferma lì non vince mai. Ogni pozione completata ha un "
                "potere, e la partita la porta a casa chi li incatena uno nell'altro nello stesso "
                "turno. Si può anche prendere un paio di punti negativi per sfilare la biglia che "
                "serve e lasciarsi la colonna sistemata per il giro dopo."),
    scatola(f"{SCATOLE}/scatola_poz.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Collezione set", "Draft aperto", "Riconoscimento schemi"], False),
             ("Di cosa parla", ["Fantasy", "Puzzle"], True)], POZ),
    chiusura(f"{FOTO}/Poz_fine.jpg", "Qual è il tuo<br>puzzle game<br>preferito?",
             "Quelli dove alla fine conta solo trovare l'incastro giusto, e il tema è quasi una scusa.",
             "Scrivilo qui sotto."),
]

TERR = ("2–4", "120′", "Impegnativo")
POST["post9"] = [   # Terramara, mercoledi 23 settembre
    copertina(f"{FOTO}/Terr_cop.jpg", "TERRAMARA",
              "Acchittocca e altri · 2019 · <b>Tesla Games</b>", TERR),
    foto_sopra(f"{FOTO}/Terr_cose.jpg", "Cos'è",
               "Le terramare erano villaggi veri, nella pianura padana dell'età del bronzo, e qui "
               "sei a capo di uno di quei clan. Devi crescere: nuovi territori, più forza militare, "
               "i tuoi piazzati sugli spazi azione. E se vai dove c'è già un altro, di forza te ne "
               "serve più di lui."),
    testo_sopra(f"{FOTO}/Terr_gira.jpg", "Come gira",
                "Le aree di lavoro cambiano con le epoche, e un lavoratore lo puoi mandare fin da "
                "subito in quelle che arriveranno dopo: fai un'azione più forte, ma quello lì non "
                "torna a casa a fine round. E senza le carte giuste non si va da nessuna parte: le "
                "risorse si fanno apposta per comprarle."),
    scatola(f"{SCATOLE}/scatola_terr.jpg",
            [("Edizione italiana", "Tesla Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Plancia modulare", "Asimmetria"], False),
             ("Di cosa parla", ["Antichità"], True)], TERR),
    chiusura(f"{FOTO}/Terr_fine.jpg", "Qual è il tuo gioco<br>italiano<br>preferito?",
             "Acchittocca, Gigli, Brasini: in Italia si progettano gestionali da vent'anni, e in giro non si sa abbastanza.",
             "Scrivilo qui sotto."),
]

SIN = ("2–4", "30–45′", "Medio")
POST["post10"] = [   # Azul: Le vetrate di Sintra, venerdi 25 settembre
    copertina(f"{FOTO}/Sin_cop.jpg", "AZUL<br>LE VETRATE DI SINTRA",
              "Michael Kiesling · 2018 · <b>Ghenos Games</b>", SIN),
    foto_sopra(f"{FOTO}/Sin_cose.jpg", "Cos'è",
               "È una variante di Azul e la meccanica di presa è la stessa. Al centro del tavolo "
               "ci sono dei vassoi con quattro lastre di vetro ciascuno: prendi tutte quelle di un "
               "colore da un vassoio solo, e le altre di quel vassoio finiscono in mezzo al tavolo, "
               "dove chi viene dopo può servirsi."),
    testo_sopra(f"{FOTO}/Sin_gira.jpg", "Come gira",
                "Le lastre prese vanno tutte su una vetrata sola, e quelle che non ci stanno "
                "diventano vetro rotto, cioè punti persi. Dove puoi lavorare lo dice il vetraio: la "
                "sua vetrata e quelle alla sua destra, mai a sinistra. Lui avanza a ogni "
                "piazzamento, e riportarlo indietro costa un turno intero."),
    scatola(f"{SCATOLE}/scatola_sin.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft aperto", "Piazzamento tessere", "Creazione schemi"], False),
             ("Di cosa parla", ["Astratto", "Puzzle", "Rinascimento"], True)], SIN),
    # Niente slide della durata, tolta il 2026-09-03. Il portale dà mediana 60' in
    # quattro, ma quel 60 sono tre partite del 2020 registrate a spanne, tutte
    # "60" tondi. L'unica partita recente in quattro è del 2025 e dura 33', cioè
    # dentro la scatola. Le singole partite si leggono da
    # /api/partite/{utente}?gioco={bggId}, che partiteStats da solo non mostra.
    chiusura(f"{FOTO}/Sin_fine.jpg", "Quale versione<br>di Azul<br>preferisci?",
             "Ne sono usciti parecchi, e ognuno cambia il modo in cui piazzi le tessere.",
             "Scrivilo qui sotto."),
]

BRA = ("2–4", "60–120′", "Cinghiale")

POST["post11"] = [   # Brass: Birmingham, lunedi 19 ottobre (spostato dal 30/9 per Masterland)
    copertina(f"{FOTO}/Brass_cop.jpg", "BRASS<br>BIRMINGHAM",
              "Martin Wallace e altri · 2018 · <b>Ghenos Games</b>", BRA),
    foto_sopra(f"{FOTO}/Brass_cose.jpg", "Cos'è",
               "Sei un imprenditore della rivoluzione industriale. Attorno a Birmingham costruisci "
               "miniere, ferriere, cotonifici e birrifici, e li colleghi con canali e ferrovie. Le "
               "carte dicono dove costruire, e un edificio rende solo se lo fai fruttare vendendo. "
               "Per vendere serve birra."),
    testo_sopra(f"{FOTO}/Brass_gira.jpg", "Come gira",
                "Il carbone e il ferro degli altri li usi senza comprarli dal mercato, ma ogni "
                "volta che lo fai avvantaggi chi li ha costruiti. Il prestito ti dà trenta "
                "sterline e ti costa tre livelli di rendita a ogni round: se non li recuperi in "
                "fretta, quelle trenta sterline te le sei già rimangiate. E le vendite conviene "
                "farle tutte in un colpo solo."),
    scatola(f"{SCATOLE}/scatola_brass.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Costruzione di reti", "Carte multiuso", "Prestiti", "Mercato"], False),
             ("Di cosa parla", ["Economia", "Industria", "Treni"], True)], BRA),
    durata_da_portale(224517, "Mezz'ora in più<br>di quanto promette"),
    chiusura(f"{FOTO}/Brass_fine.jpg", "Qual è il gioco<br>che per te vale<br>il primo posto?",
             "Su BoardGameGeek è primo in classifica dal 2023. Ma la classifica che conta è quella del tuo tavolo.",
             "Scrivi il tuo numero uno qui sotto."),
]

CENT = ("2–5", "30–45′", "Leggero")

POST["post12"] = [   # Century: La via delle spezie, mercoledi 30 settembre
    copertina(f"{FOTO}/Cent_cop.jpg", "CENTURY<br>LA VIA DELLE SPEZIE",
              "Emerson Matsuuchi · 2017 · <b>Asmodee Italia</b>", CENT),
    foto_sopra(f"{FOTO}/Cent_cose.jpg", "Cos'è",
               "Sei un mercante sulla via delle spezie: curcuma, zafferano, cardamomo e "
               "cannella, in ordine di valore. Le carte ti danno spezie, te le scambiano o "
               "migliorano quelle che hai. Compri e commerci per soddisfare le richieste dei "
               "mercanti, ed è così che fai punti."),
    testo_sopra(f"{FOTO}/Cent_gira.jpg", "Come gira",
                "Non è un solitario, e chi lo gioca così perde. Guarda le risorse degli "
                "avversari e capisci a quale carta punteggio mirano, se no raccogli per una che "
                "ti soffiano un turno prima. E quella che va in combo con le tue prendila subito: "
                "dopo può non esserci più."),
    scatola(f"{SCATOLE}/scatola_cent.png",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Costruzione mazzo", "Draft aperto", "Gestione della mano"], False),
             ("Di cosa parla", ["Economia", "Medievale"], True)], CENT),
    chiusura(f"{FOTO}/Cent_fine.jpg", "Quale deck building<br>non ti stanchi mai<br>di giocare?",
             "Quello che rimetti sul tavolo anche dopo cinquanta partite.",
             "Scrivilo qui sotto."),
]

QUAD = ("2–4", "30–60′", "Medio")

POST["post13"] = [   # Quadropolis, venerdi 2 ottobre
    copertina(f"{FOTO}/Quad_cop.jpg", "QUADROPOLIS",
              "François Gandon · 2016 · <b>Asmodee Italia</b>", QUAD),
    foto_sopra(f"{FOTO}/Quad_cose.jpg", "Cos'è",
               "Costruisci la tua città su una griglia. Al centro del tavolo c'è il cantiere, "
               "un'altra griglia piena di edifici: per prenderne uno appoggi un architetto "
               "numerato a bordo di una riga o di una colonna. Quel numero dice quale edificio ti "
               "porti via, e dove sei obbligato a metterlo."),
    testo_sopra(f"{FOTO}/Quad_gira.jpg", "Come gira",
                "Il problema non è farsi rubare la tessera, che spesso resta lì. È arrivarci: "
                "ogni architetto piazzato chiude quel lato, e l'urbanista blocca la riga e la "
                "colonna dell'ultima presa. Si finisce per pianificare l'ordine: cosa prendere "
                "prima, e da che parte."),
    scatola(f"{SCATOLE}/scatola_quad.jpg",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Piazzamento tessere"], False),
             ("Di cosa parla", ["Costruzione città", "Ambiente"], True)], QUAD),
    chiusura(f"{FOTO}/Quad_fine.jpg", "Qual è il gioco bello<br>che giochi<br>troppo poco?",
             "Quello che ti piace ogni volta e poi resta sullo scaffale per mesi.",
             "Scrivilo qui sotto."),
]

NOCT = ("1–4", "30′", "Leggero")

POST["post14"] = [   # Noctiluca, lunedi 5 ottobre
    copertina(f"{FOTO}/Noct_cop.jpg", "NOCTILUCA",
              "Shem Phillips · 2019 · <b>Asmodee Italia</b>", NOCT),
    foto_sopra(f"{FOTO}/Noct_cose.jpg", "Cos'è",
               "Le noctiluca sono creature luminose in fondo a un lago, e sul tabellone sono dadi "
               "colorati. Metti un pescatore su una sponda, scegli una fila e dici un numero da "
               "uno a sei: prendi tutti i dadi che lo mostrano. Vanno nelle giare, che si "
               "riempiono per colore."),
    testo_sopra(f"{FOTO}/Noct_gira.jpg", "Come gira",
                "Ogni giara consegnata ti dà un gettone di uno dei tre tipi, e alla fine ogni "
                "tipo premia chi ne ha di più. Quindi non basta la tua carta segreta: guarda cosa "
                "stanno accumulando gli altri e vai a prenderti la maggioranza dove non se "
                "l'aspettano."),
    scatola(f"{SCATOLE}/scatola_noct.png",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Collezione set"], False),
             ("Di cosa parla", ["Astratto", "Dadi"], True)], NOCT),
    chiusura(f"{FOTO}/Noct_fine.jpg", "Qual è il gioco<br>che hai comprato<br>solo per la grafica?",
             "Quello che sul tavolo fa girare la testa a tutti, prima ancora di sapere come si gioca.",
             "Scrivilo qui sotto."),
]

SCY = ("1–5", "90–115′", "Impegnativo")

POST["post15"] = [   # Scythe, mercoledi 7 ottobre
    copertina(f"{FOTO}/Scy_cop.jpg", "SCYTHE",
              "Jamey Stegmaier · 2016 · <b>Ghenos Games</b>", SCY),
    foto_sopra(f"{FOTO}/Scy_cose.jpg", "Cos'è",
               "Sembra un wargame ed è un gestionale. Ogni fazione ha la sua plancia divisa in "
               "quattro zone, ognuna con due azioni: metti il segnalino su una zona, fai quella in "
               "alto e, se te la puoi pagare, anche quella sotto. Mai la stessa zona due turni di "
               "fila. Produci, sposti operai, schieri i mech."),
    testo_sopra(f"{FOTO}/Scy_gira.jpg", "Come gira",
                "Il potere della fazione va sfruttato sempre: in un gioco asimmetrico chi non usa "
                "il suo resta indietro. Poi servono le migliorie sulla plancia e i bonus che "
                "scattano quando i vicini fanno certe azioni: da lì in poi guadagni anche quando "
                "non tocca a te."),
    scatola(f"{SCATOLE}/scatola_scy.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Asimmetria tra giocatori", "Draft di azioni"], False),
             ("Di cosa parla", ["Sci-Fi", "Economia", "Combattimento"], True)], SCY),
    chiusura(f"{FOTO}/Scy_fine.jpg", "Sei del team<br>miniature<br>o del team meeple?",
             "Il german di solito è cubetti e meeple di legno, le miniature stanno dall'altra parte. Scythe li mette insieme.",
             "Dimmi da che parte stai."),
]

PIGS = ("2–6", "30–45′", "Medio")

POST["post16"] = [   # Happy Pigs, venerdi 9 ottobre
    copertina(f"{FOTO}/Pigs_cop.jpg", "HAPPY PIGS",
              "Kuraki Mura · 2013 · <b>Uplay Edizioni</b>", PIGS),
    foto_sopra(f"{FOTO}/Pigs_cose.jpg", "Cos'è",
               "Sei un allevatore di maiali e vince chi finisce con più soldi. Ogni round la "
               "carta della stagione dice quante volte si potrà fare ciascuna azione: comprare, "
               "far crescere, far accoppiare, vendere. Poi tutti scelgono in segreto, e chi ha "
               "scelto uguale si divide gli usi."),
    testo_sopra(f"{FOTO}/Pigs_gira.jpg", "Come gira",
                "L'azione è una sola per turno, quindi conta chi la sceglie insieme a te. Guarda "
                "la fattoria degli altri: se sono appena stati al mercato non ci tornano subito, "
                "e allora ci vado io. Se stanno per far accoppiare i maiali, valuta di "
                "lasciarglielo fare."),
    scatola(f"{SCATOLE}/scatola_pigs.jpg",
            [("Edizione italiana", "Uplay Edizioni"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Azioni simultanee"], False),
             ("Di cosa parla", ["Agricoltura", "Animali", "Economia"], True)], PIGS),
    chiusura(f"{FOTO}/Pigs_fine.jpg", "Qual è il gioco<br>che vorresti<br>veder ristampato?",
             "Quello che oggi si trova solo usato, a prezzi da collezione.",
             "Scrivilo qui sotto."),
]

HARM = ("1–4", "30–45′", "Medio")

POST["post17"] = [   # Harmonies, lunedi 12 ottobre
    copertina(f"{FOTO}/Harm_cop.jpg", "HARMONIES",
              "Johan Benvenuto · 2024 · <b>Asmodee Italia</b>", HARM),
    foto_sopra(f"{FOTO}/Harm_cose.jpg", "Cos'è",
               "Costruisci un paesaggio su una plancia a esagoni. Al centro ci sono cinque gruppi "
               "da tre dischetti di legno: ne prendi un gruppo intero e lo sistemi da te uno alla "
               "volta. Alberi sopra il marrone, montagne fino a tre. Le carte animale dicono quali "
               "disposizioni valgono punti."),
    testo_sopra(f"{FOTO}/Harm_gira.jpg", "Come gira",
                "I punti arrivano da due parti: le carte animale e il tuo paesaggio. Chi guarda "
                "solo le carte finisce con una plancia a caso, chi guarda solo la plancia si "
                "ritrova animali che non ci stanno. La carta giusta è quella che sta bene dove "
                "stai già costruendo."),
    scatola(f"{SCATOLE}/scatola_harm.jpg",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Creazione schemi", "Piazzamento tessere"], False),
             ("Di cosa parla", ["Ambiente", "Animali"], True)], HARM),
    chiusura(f"{FOTO}/Harm_fine.jpg", "Quale gioco<br>facile da spiegare<br>ti fa ancora pensare?",
             "Regole in un minuto, e poi passi il turno a chiederti dove mettere il pezzo.",
             "Scrivilo qui sotto."),
]

TM = ("1–5", "120′", "Impegnativo")

POST["post18"] = [   # Terraforming Mars, mercoledi 14 ottobre
    copertina(f"{FOTO}/Tm_cop.jpg", "TERRAFORMING MARS",
              "Jacob Fryxelius · 2016 · <b>Ghenos Games</b>", TM),
    foto_sopra(f"{FOTO}/Tm_cose.jpg", "Cos'è",
               "Sei una corporazione che deve rendere Marte abitabile. Tre parametri devono "
               "salire insieme: temperatura, ossigeno e oceani. A ogni turno giochi carte "
               "progetto, e ne esistono duecento: alzano un parametro, ti danno produzione, ti "
               "fanno piazzare città e foreste."),
    testo_sopra(f"{FOTO}/Tm_gira.jpg", "Come gira",
                "Si vince su due fronti: le foreste e le città sulla mappa, e le carte giocate al "
                "momento giusto. Non esiste la carta forte, esiste quella giusta adesso: quella "
                "che chiede quattro gradi, pescata al primo round, la paghi fino alla fine."),
    scatola(f"{SCATOLE}/scatola_tm.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Su tutte le carte")],
            [("Come funziona", ["Gestione della mano", "Piazzamento tessere"], False),
             ("Di cosa parla", ["Sci-Fi", "Terraformazione"], True)], TM),
    # min_partite=5 esclude la colonna dei due giocatori: sono quattro partite, e
    # le due vecchie (180' nel 2020, 148' nel 2021) tengono su una mediana di 139'
    # che le due recenti smentiscono (112' e 102'). Le altre tre colonne hanno
    # nove-undici partite ciascuna e non si muovono guardando solo il recente.
    durata_da_portale(167791, "Non cambia<br>con quanti si è", min_partite=5),
    chiusura(f"{FOTO}/Tm_fine.jpg", "Hai mai \u201cpimpato\u201d<br>un gioco con<br>materiali in 3D?",
             "Queste tessere non stanno nella scatola: sono state stampate in 3D.",
             "Raccontamelo qui sotto."),
]

FAR = ("2–6", "15–30′", "Leggero")

POST["post19"] = [   # Faraway, venerdi 16 ottobre
    copertina(f"{FOTO}/Far_cop.jpg", "FARAWAY",
              "Corentin Lebrat e Johannes Goupy · 2023 · <b>GateOnGames</b>", FAR),
    foto_sopra(f"{FOTO}/Far_cose.jpg", "Cos'è",
               "Otto turni, otto carte. A ogni turno tutti scelgono in segreto una carta e la "
               "mettono in fila, da sinistra a destra. Ogni carta chiede simboli o regioni per "
               "valere punti. Ma alla fine si conta al contrario, dall'ultima giocata alla prima, "
               "e ogni carta vede soltanto quelle giocate dopo di lei."),
    testo_sopra(f"{FOTO}/Far_gira.jpg", "Come gira",
                "Le otto carte si giocano da sinistra a destra e si contano da destra a sinistra: "
                "i requisiti di una carta li soddisfi con quelle che giochi dopo, non con quelle "
                "che hai già. È l'unica cosa da capire, e c'è chi alla terza partita ancora "
                "sbaglia."),
    scatola(f"{SCATOLE}/scatola_far_bgg.jpg",
            [("Edizione italiana", "GateOnGames"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft aperto", "Azioni simultanee"], False),
             ("Di cosa parla", ["Carte", "Fantasy"], True)], FAR),
    chiusura(f"{FOTO}/Far_fine.jpg", "Qual è il gioco leggero<br>che non ti entra<br>in testa?",
             "Ce n'è sempre uno: pesa meno di quelli che giochi di solito, e proprio non lo digerisci.",
             "Scrivilo qui sotto."),
]

ESD = ("1–4", "90–120′", "Cinghiale")

POST["post20"] = [   # Esdra e Neemia, lunedi 19 ottobre
    copertina(f"{FOTO}/Esd_cop.jpg", "ESDRA E NEEMIA",
              "Shem Phillips e S J Macdonald · 2024 · <b>Chur Games</b>", ESD),
    foto_sopra(f"{FOTO}/Esd_cose.jpg", "Cos'è",
               "Gerusalemme, quinto secolo avanti Cristo: le mura sono a terra. Ogni turno giochi "
               "una carta personaggio: offerte al tempio, macerie da togliere, mura e porte da "
               "tirare su, Torah da insegnare. E intanto migliori la tua plancia personale."),
    testo_sopra(f"{FOTO}/Esd_gira.jpg", "Come gira",
                "Certi lavoratori, una volta piazzati, non tornano più indietro. Chi non ne "
                "rimette in circolo si ritrova a metà partita senza braccia: ognuno in più va "
                "sfamato, ma può anche essere messo a produrre il cibo che sfama gli altri."),
    scatola(f"{SCATOLE}/scatola_esd.jpg",
            [("Edizione italiana", "Chur Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Combo"], False),
             ("Di cosa parla", ["Antichità", "Religione"], True)], ESD),
    durata_da_portale(386368, "In quattro<br>sono quasi tre ore"),
    chiusura(f"{FOTO}/Esd_fine.jpg", "Qual è il cinghiale<br>che rimetteresti<br>sul tavolo domani?",
             "Quelli da una serata intera, che tiri fuori solo quando sai di avere tempo.",
             "Scrivilo qui sotto, me li segno tutti."),
]

WING = ("1–5", "40–70′", "Medio")

POST["post21"] = [   # Wingspan, mercoledi 21 ottobre
    copertina(f"{FOTO}/Wing_cop.jpg", "WINGSPAN",
              "Elizabeth Hargrave · 2019 · <b>Ghenos Games</b>", WING),
    foto_sopra(f"{FOTO}/Wing_cose.jpg", "Cos'è",
               "Ogni carta è un uccello vero, con la sua apertura alare e la sua abilità. Quattro "
               "round, e a ogni round un cubo azione in meno: giochi uccelli nei tre habitat, "
               "prendi cibo dalla mangiatoia a dadi, deponi uova, peschi carte. Ogni uccello in "
               "fila rende più forte l'azione di quella fila."),
    testo_sopra(f"{FOTO}/Wing_gira.jpg", "Come gira",
                "Aspettare la carta giusta non funziona: le tre scoperte le prende chi arriva "
                "prima di te, e quello che peschi dal mazzo te lo tieni. Si guarda cosa chiedono "
                "gli obiettivi di questa partita e ci si costruisce sopra con quello che passa."),
    scatola(f"{SCATOLE}/scatola_wing.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Su tutte le carte")],
            [("Come funziona", ["Gestione della mano", "Draft aperto"], False),
             ("Di cosa parla", ["Animali", "Carte"], True)], WING),
    durata_da_portale(266192, "In cinque<br>sfora di mezz'ora"),
    chiusura(f"{FOTO}/Wing_fine.jpg", "Qual è il gioco<br>che ti rilassa anche<br>mentre lo perdi?",
             "Quello dove non devi spremere il cervello e la serata scorre lo stesso.",
             "Scrivilo qui sotto, me li segno tutti.",
             stile_foto="object-position:top"),
]

SAG = ("1–4", "30–45′", "Leggero")

POST["post22"] = [   # Sagrada, venerdi 23 ottobre
    copertina(f"{FOTO}/Sag_cop.jpg", "SAGRADA",
              "Adrian Adamescu e Daryl Andrews · 2017 · <b>Cranio Creations</b>", SAG),
    foto_sopra(f"{FOTO}/Sag_cose.jpg", "Cos'è",
               "Costruisci una vetrata piazzando dadi colorati in una griglia. Due regole: mai "
               "due dadi dello stesso colore o valore attaccati in orizzontale o in verticale, e "
               "la vetrata che hai scelto impone dove va il rosso e dove va il quattro. Dieci "
               "round, e ogni casella vuota è un punto in meno."),
    testo_sopra(f"{FOTO}/Sag_gira.jpg", "Come gira",
                "Prima o poi resti incastrato: nessuno dei dadi in tavola entra da nessuna parte. "
                "Per questo ci sono gli utensili, tre a caso a inizio partita: uno scambia un "
                "dado, uno lo rilancia. Chi non li usa finisce con la vetrata bucata."),
    scatola(f"{SCATOLE}/scatola_sag2.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Solo sugli utensili")],
            [("Come funziona", ["Riempimento griglia", "Draft aperto"], False),
             ("Di cosa parla", ["Astratto", "Dadi"], True)], SAG),
    chiusura(f"{FOTO}/Sag_fine.jpg", "Azul<br>o Sagrada?",
             "I due astratti che finiscono sempre sullo stesso scaffale. Chi li ha giocati tutti e due di solito non ha dubbi.",
             "Dimmi la tua qui sotto.",
             stile_foto="object-position:bottom"),
]

GAH = ("2–4", "60–120′", "Impegnativo")

POST["post23"] = [   # Grand Austria Hotel, lunedi 26 ottobre
    copertina(f"{FOTO}/Gah_cop.jpg", "GRAND AUSTRIA HOTEL",
              "Simone Luciani e Virginio Gigli · 2015 · <b>Asmodee Italia</b>", GAH),
    foto_sopra(f"{FOTO}/Gah_cose.jpg", "Cos'è",
               "Gestisci un hotel a Vienna. I clienti si siedono al caffè e ordinano strudel, "
               "torte, vino o caffè; quando li hai serviti li mandi in camera, che però devi aver "
               "preparato prima. I dadi si tirano e si smistano su sei azioni: più dadi ci sono "
               "su un'azione, più quell'azione è forte."),
    testo_sopra(f"{FOTO}/Gah_gira.jpg", "Come gira",
                "Non ti chiedi mai cosa fare: prendi un cliente, gli procuri quello che ordina, "
                "gli prepari la camera, lo mandi a dormire, e ricominci. È il tracciato "
                "dell'imperatore a rompere il giro, perché al terzo, al quinto e al settimo round "
                "ti chiede il conto."),
    scatola(f"{SCATOLE}/scatola_gah.jpg",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft di azioni", "Lancio di dadi"], False),
             ("Di cosa parla", ["Economia", "Hotel"], True)], GAH),
    chiusura(f"{FOTO}/Gah_fine.jpg", "Qual è il gioco<br>pesante che spieghi<br>più facilmente?",
             "Quello con la scatola che spaventa e le regole che invece entrano subito.",
             "Scrivilo qui sotto, me li segno tutti."),
]

SKB = ("1–4", "45–60′", "Medio")

POST["post24"] = [   # Skara Brae, mercoledi 28 ottobre
    copertina(f"{FOTO}/Skb_cop.jpg", "SKARA BRAE",
              "Shem Phillips · 2025 · <b>Chur Games</b>", SKB),
    foto_sopra(f"{FOTO}/Skb_cose.jpg", "Cos'è",
               "Un villaggio neolitico nelle isole Orcadi. A ogni round prendi a turno una carta "
               "dal tavolo e la infili sotto la tua plancia: i cittadini producono, i tetti "
               "proteggono, le pietre danno punti. Poi piazzi i lavoratori sulle tue tessere, che "
               "si girano e diventano più forti."),
    testo_sopra(f"{FOTO}/Skb_gira.jpg", "Come gira",
                "Qui accumulare è un errore. Se produci più del necessario, a fine round ti resta "
                "immondizia: occupa il magazzino, alla fine toglie punti, e per liberartene devi "
                "spendere azioni. Chi arriva dai Rosenberg ci mette due partite a smettere."),
    scatola(f"{SCATOLE}/scatola_skb.png",
            [("Edizione italiana", "Chur Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft aperto", "Concatenazioni"], False),
             ("Di cosa parla", ["Preistoria", "Carte"], True)], SKB),
    chiusura(f"{FOTO}/Skb_fine.jpg", "Qual è il tuo<br>solitario di gruppo<br>preferito?",
             "Quelli dove ognuno gioca sulla sua plancia e ci si guarda solo alla fine. C'è chi li detesta e chi cerca solo quelli.",
             "Scrivilo qui sotto, me li segno tutti."),
]

KD = ("2–4", "15–25′", "Leggero")

POST["post25"] = [   # Kingdomino, venerdi 30 ottobre
    copertina(f"{FOTO}/Kd_cop.jpg", "KINGDOMINO",
              "Bruno Cathala · 2016 · <b>Blue Orange</b>", KD),
    foto_sopra(f"{FOTO}/Kd_cose.jpg", "Cos'è",
               "Costruisci un regno di cinque caselle per cinque con tessere da domino. Ogni "
               "tessera ha due terreni e va attaccata a un terreno uguale. Alla fine ogni zona "
               "vale le sue caselle moltiplicate per le corone che ci stanno sopra: una zona "
               "enorme senza corone vale zero."),
    testo_sopra(f"{FOTO}/Kd_gira.jpg", "Come gira",
                "Non esiste la tessera forte in assoluto. Quella con due corone, se apre un "
                "terreno che nel tuo regno non c'è ancora, vale poco. Quella scarsa attaccata a "
                "un'area già larga vale il doppio. Si guarda il regno, non la tessera."),
    scatola(f"{SCATOLE}/scatola_kd.png",
            [("Edizione italiana", "Blue Orange"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento tessere", "Draft aperto"], False),
             ("Di cosa parla", ["Medievale", "Astratto"], True)], KD),
    chiusura(f"{FOTO}/Kd_fine.jpg", "Qual è il gioco<br>che dai a chi<br>non ha mai giocato?",
             "Quello che tiri fuori quando a tavola c'è qualcuno che di giochi conosce solo il Monopoli.",
             "Scrivilo qui sotto, me li segno tutti."),
]

BAR = ("1–4", "120′", "Cinghiale")

POST["post26"] = [   # Barrage, lunedi 2 novembre
    copertina(f"{FOTO}/Bar_cop.jpg", "BARRAGE",
              "Tommaso Battista e Simone Luciani · 2019 · <b>Cranio Creations</b>", BAR),
    foto_sopra(f"{FOTO}/Bar_cose.jpg", "Cos'è",
               "Dighe idroelettriche. L'acqua scende dalla montagna e segue i fiumi; tu costruisci "
               "una diga per fermarla, una condotta per portarla dove vuoi e una centrale per "
               "trasformarla in energia. Servono tutte e tre le cose insieme, altrimenti non "
               "produci niente. Cinque round."),
    testo_sopra(f"{FOTO}/Bar_gira.jpg", "Come gira",
                "L'acqua che non fermi tu scende a chi sta sotto. Se un avversario mette una diga "
                "sopra la tua e devia il fiume, a metà partita resti a secco. O ti piazzi sotto "
                "qualcuno e vivi di quello che si lascia sfuggire, o paghi di più e ti metti "
                "davanti a lui."),
    scatola(f"{SCATOLE}/scatola_bar.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Reti"], False),
             ("Di cosa parla", ["Industria", "Ambiente"], True)], BAR),
    durata_da_portale(251247, "In due<br>un'ora e mezza",
                      min_scatola=120, max_scatola=120, accento="bassa"),
    chiusura(f"{FOTO}/Bar_fine.jpg", "Quale gioco hai<br>comprato anche se<br>non ne vinci una?",
             "Quello che ti ha stracciato alla prima partita, e anche alla seconda, e tu lo hai voluto lo stesso.",
             "Scrivilo qui sotto, me li segno tutti."),
]

ISLE = ("2–5", "30–50′", "Medio")

POST["post27"] = [   # Isle of Skye, mercoledi 4 novembre
    copertina(f"{FOTO}/Isle_cop.jpg", "ISLE OF SKYE<br>AGLI ALBORI DEL REGNO",
              "Alexander Pfister e Andreas Pelikan · 2015 · <b>uplay.it edizioni</b>", ISLE),
    foto_sopra(f"{FOTO}/Isle_cose.jpg", "Cos'è",
               "Piazzamento tessere che devono combaciare, montagna con montagna e lago con lago, "
               "senza il vincolo delle strade. Ma non si pescano dal sacchetto: ogni round ne "
               "peschi tre, ne butti una, e alle altre due il prezzo lo dai tu, in segreto. Poi si "
               "compra e si vende."),
    testo_sopra(f"{FOTO}/Isle_gira.jpg", "Come gira",
                "Il gioco sta tutto nel prezzo che dai. Se lo fai basso, la tessera che ti serviva "
                "te la portano via. Se lo fai alto quei soldi restano bloccati lì e a te non ne "
                "restano per comprare dagli altri. E gli obiettivi cambiano a ogni partita, quindi "
                "la tessera che oggi vale tutto la prossima volta non vale niente: chi lo tratta "
                "come un Carcassonne dove si pesca e si piazza non vince mai."),
    scatola(f"{SCATOLE}/scatola_isle.jpg",
            [("Edizione italiana", "uplay.it edizioni"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Asta a lotti multipli", "Io divido tu scegli",
                                "Piazzamento tessere"], False),
             ("Di cosa parla", ["Medioevo", "Scozia"], True)], ISLE),
    durata_da_portale(176494, "In cinque<br>il doppio del massimo", min_partite=5,
                      nota="Mediana delle nostre 22 partite, quasi sempre con l'espansione "
                           "Journeyman attaccata.<br>La fascia tratteggiata è 30–50′, quello "
                           "che dice la scatola."),
    chiusura(f"{FOTO}/Isle_fine.jpg", "Qual è il gioco<br>che sembra semplice<br>e poi non lo è?",
             "Le regole le spieghi in cinque minuti, e poi ti accorgi che la partita la decide tutt'altro.",
             "Scrivilo qui sotto."),
]

REV = ("1–4", "90–120′", "Impegnativo")

POST["post28"] = [   # Revive, venerdi 6 novembre
    copertina(f"{FOTO}/Rev_cop.jpg", "REVIVE",
              "Eilif Svensson, Kristian Østby e altri · 2022 · <b>Ghenos Games</b>", REV),
    foto_sopra(f"{FOTO}/Rev_cose.jpg", "Cos'è",
               "Il mondo è finito sotto il ghiaccio e tu esci dall'ibernazione secoli dopo. La "
               "mappa è tutta coperta: giri una tessera per volta, costruisci, mandi la tua gente "
               "nei luoghi rimasti e tiri fuori gli artefatti di prima. Ogni azione lontano da "
               "casa si paga in cibo."),
    testo_sopra(f"{FOTO}/Rev_gira.jpg", "Come gira",
                "Di ogni carta si può usare la parte superiore o quella inferiore, e bisogna "
                "saper scegliere. Poi ci sono le quattro tessere obiettivo, ai quattro angoli "
                "della mappa, e tu parti dal centro. Raggiungerle tutte è impossibile: chi ci "
                "prova va a zig-zag e non ne attiva neanche una. Ne scegli due al primo turno, "
                "quelle che la tua tribù sa fare, e non ti sposti più."),
    scatola(f"{SCATOLE}/scatola_rev.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Griglia esagonale", "Costruzione mappa", "Combo"], False),
             ("Di cosa parla", ["Sci-Fi", "Esplorazione"], True)], REV),
    chiusura(f"{FOTO}/Rev_fine.jpg", "Qual è il gioco<br>che occupa più tavolo<br>di quanto ne hai?",
             "Quello che apri e ti accorgi che le plance non ci stanno, e qualcuno finisce a giocare sulle ginocchia.",
             "Scrivilo qui sotto."),
]

WSP = ("1–5", "25–35′", "Leggero")

POST["post29"] = [   # Wingspan Pocket, mercoledi 9 settembre, anteprima: in Italia non e' ancora uscito
    copertina(f"{FOTO}/WsP_cop.jpg", "WINGSPAN<br>POCKET",
              "Elizabeth Hargrave · 2026 · <b>Stonemaier Games</b>", WSP),
    foto_sopra(f"{FOTO}/WsP_cose.jpg", "Cos'è",
               "Al tuo turno puoi pescare due carte, giocare un uccello o deporre fino a tre uova. "
               "Poi si attiva tutto il tuo stormo, da sinistra a destra: ogni uccello giocato fino "
               "a quel momento attiverà la propria abilità speciale."),
    testo_sopra(f"{FOTO}/WsP_gira.jpg", "Come gira",
                "Di uccelli ne giochi sei, su una fila sola invece delle tre del Wingspan grande. "
                "Sei carte, quindi vanno bilanciate: certe ti danno cibo e pescate, certe fanno "
                "punti. Solo del primo tipo e non vinci, solo del secondo e non hai di che "
                "giocarle."),
    scatola(f"{SCATOLE}/scatola_wingspanpocket.png",
            [("Edizione italiana", "Ghenos, annunciata"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Draft aperto", "Gestione della mano"], False),
             ("Di cosa parla", ["Animali", "Carte"], True)], WSP),
    chiusura(f"{FOTO}/WsP_fine.jpg", "Qual è il gioco<br>che aspetti di più<br>quest'anno?",
             "Quello che hai già segnato e che in negozio non c'è ancora.",
             "Scrivilo qui sotto."),
]

PAL = ("1–4", "90–120′", "Impegnativo")

POST["post30"] = [   # Paladini del Regno Occidentale, data da fissare
    copertina(f"{FOTO}/Pal_cop.jpg", "PALADINI<br>DEL REGNO OCCIDENTALE",
              "S J Macdonald e Shem Phillips · 2019 · <b>Fever Games</b>", PAL),
    foto_sopra(f"{FOTO}/Pal_cose.jpg", "Cos'è",
               "Ogni round arruoli un paladino, che per quel giro ti porta operai e un potere "
               "suo. Con quegli operai o fai crescere il tuo dominio, o esci: alzi mura, presidi "
               "avamposti, converti o attacchi i forestieri. Forza, fede e influenza aprono le "
               "azioni e alla fine sono punti."),
    testo_sopra(f"{FOTO}/Pal_gira.jpg", "Come gira",
                "Qui una mossa buona non basta: le azioni vanno concatenate, e le risorse giuste "
                "devono già esserci nel round giusto. La prima cosa da sistemare è la plancia, "
                "perché ogni officina che sposti è un operaio in meno da usare ogni volta."),
    scatola(f"{SCATOLE}/scatola_paladini.png",
            [("Edizione italiana", "Fever Games, 2019"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Piazzamento lavoratori", "Draft aperto"], False),
             ("Di cosa parla", ["Medioevo"], True)], PAL),
    durata_da_portale(266810, "In quattro<br>mezz'ora in più",
                      min_scatola=90, max_scatola=120, accento="alta"),
    chiusura(f"{FOTO}/Pal_fine.jpg", "Qual è il gioco<br>che ti stuzzica<br>di più il cervello?",
             "Quello che ti obbliga a pensare due mosse avanti, e ti lascia sfinito e contento.",
             "Scrivilo qui sotto, me li segno tutti."),
]


C5 = ("1–4", "30′", "Leggero")

POST["post31"] = [   # 5x5 City, data da fissare. In Italia non e' mai uscito.
    copertina(f"{FOTO}/C5_cop.jpg", "5×5 CITY",
              "Hisashi Hayashi · 2018 · <b>OKAZU Brand</b>", C5),
    foto_sopra(f"{FOTO}/C5_cose.jpg", "Cos'è",
               "Costruisci la tua città su venticinque lotti. Una carta li divide in dodici "
               "quartieri, e a ogni giro tocca a uno solo: le tessere che peschi le metti lì, "
               "che ti servano o no. Quella che non serve la giri e diventa un parco. I punti "
               "li danno le carte edificio."),
    testo_sopra(f"{FOTO}/C5_gira.jpg", "Come gira",
                "Le tessere escono per tutti e si sceglie a giro: il primo di mano ha scelta, "
                "l'ultimo prende quello che resta. Più di così non si comanda, e il gioco sta "
                "tutto lì: prendere quelle che servono al quartiere che tocca in quel round."),
    scatola(f"{SCATOLE}/scatola_5x5city.jpg",
            [("Edizione italiana", "Non esiste"), ("Testo nel gioco", "Sulle carte punteggio")],
            [("Come funziona", ["Piazzamento tessere"], False),
             ("Di cosa parla", ["Costruzione città"], True)], C5),
    chiusura(f"{FOTO}/C5_fine.jpg", "Qual è il gioco<br>che ti sei portato<br>a casa da un viaggio?",
             "Quello comprato in vacanza, che in Italia non si trova.",
             "Scrivilo qui sotto, me li segno tutti."),
]


AUT = ("1–4", "90–150′", "Cinghiale")

POST["post32"] = [   # Autobahn, data da fissare. La scatola e' di un amico.
    copertina(f"{FOTO}/Aut_cop.jpg", "AUTOBAHN",
              "Fabio Lopiano e Nestore Mangone · 2022 · <b>Cranio Creations</b>", AUT),
    foto_sopra(f"{FOTO}/Aut_cose.jpg", "Cos'è",
               "Dirigi le autostrade tedesche dal 1946. In mano hai una carta per ogni strada: "
               "ne giochi una per turno, e il colore dice dove costruisci o carichi i camion. "
               "Chi costruisce mette impiegati negli uffici, e alla fine chi è salito nel "
               "palazzo moltiplica."),
    testo_sopra(f"{FOTO}/Aut_gira.jpg", "Come gira",
                "Qui si vince non sprecando azioni. La strada giusta, il camion carico e la "
                "carta del colore giusto devono capitare insieme, e prendere merce e portarla "
                "dall'altra parte sembra semplice finché non conti i turni che hai buttato via."),
    scatola(f"{SCATOLE}/scatola_autobahn.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Raccolta e consegna", "Reti"], False),
             ("Di cosa parla", ["Economia", "Trasporti"], True)], AUT),
    chiusura(f"{FOTO}/Aut_fine.jpg", "Qual è il gioco<br>che giochi solo<br>a casa di qualcun altro?",
             "Quello che non hai, e che trovi sempre sul tavolo di un amico.",
             "Scrivilo qui sotto, me li segno tutti."),
]


BLO = ("2–4", "20′", "Leggero")

POST["post33"] = [   # Blokus, data da fissare
    copertina(f"{FOTO}/Blo_cop.jpg", "BLOKUS",
              "Bernard Tavitian · 2000 · <b>Mattel</b>", BLO),
    foto_sopra(f"{FOTO}/Blo_cose.jpg", "Cos'è",
               "Tabellone da venti per venti, ventuno pezzi a testa, tutti diversi. A turno se "
               "ne appoggia uno, con una regola sola: deve toccare un pezzo del tuo colore, e "
               "solo per gli angoli. Si finisce quando non entra più niente, e vince chi ha "
               "lasciato in mano meno caselle."),
    testo_sopra(f"{FOTO}/Blo_gira.jpg", "Come gira",
                "Il pezzo grosso che non sai dove mettere è quello che serve: messo nel punto "
                "giusto chiude all'avversario il lato da cui voleva espandersi. I piccoli si "
                "tengono per la fine, perché saranno gli unici che entrano ancora quando il "
                "tabellone è pieno."),
    scatola(f"{SCATOLE}/scatola_blokus.png",
            [("In Italia lo porta", "Mattel"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento tessere", "Riempimento griglia"], False),
             ("Di cosa parla", ["Astratto"], True)], BLO),
    chiusura(f"{FOTO}/Blo_fine.jpg", "Qual è il gioco<br>dove ti diverti di più<br>a bloccare gli altri?",
             "Quello in cui la mossa più bella non è la tua, è quella che rovina il piano di qualcun altro.",
             "Scrivilo qui sotto, me li segno tutti."),
]


BOO = ("1–4", "80–160′", "Cinghiale")

POST["post34"] = [   # Boonlake, da montare ma non da programmare: la scatola e' di un amico lontano
    copertina(f"{FOTO}/Boo_cop.jpg", "BOONLAKE",
              "Alexander Pfister · 2021 · <b>Cranio Creations</b>", BOO),
    foto_sopra(f"{FOTO}/Boo_cose.jpg", "Cos'è",
               "Arrivi su una terra da colonizzare e la costruisci. Il motore sono sette strisce "
               "di azioni: ne tiri fuori una, quello a sinistra della freccia lo fai tu, quello a "
               "destra lo fanno tutti. E la riga che prendi dice quanti passi fa la tua nave sul "
               "fiume."),
    testo_sopra(f"{FOTO}/Boo_gira.jpg", "Come gira",
                "Le mucche rendono se stanno vicino alle case, e vanno bene anche quelle degli "
                "altri: qui il tabellone affollato conviene a tutti. Chi si costruisce un angolo "
                "suo si ritrova i pezzi ancora sulla plancia, e quelli che restano lì non "
                "diventano mai punti."),
    scatola(f"{SCATOLE}/scatola_boonlake.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Azioni collegate", "Piazzamento tessere"], False),
             ("Di cosa parla", ["Esplorazione", "Economia"], True)], BOO),
    chiusura(f"{FOTO}/Boo_fine.jpg", "Qual è il gioco bello<br>che da te non torna<br>mai sul tavolo?",
             "Quello che ti è piaciuto e che poi, per un motivo o per l'altro, non rivede la luce.",
             "Scrivilo qui sotto, me li segno tutti."),
]


FLO = ("1–5", "60–180′", "Impegnativo")

POST["post35"] = [   # Florenza X Anniversario, data da fissare
    copertina(f"{FOTO}/Flo_cop.jpg", "FLORENZA",
              "Stefano Groppi · 2020 · <b>GateOnGames</b>", FLO),
    foto_sopra(f"{FOTO}/Flo_cose.jpg", "Cos'è",
               "Sei una delle grandi famiglie fiorentine. Sette round, tre familiari a giro: li "
               "mandi a costruire e ad attivare gli edifici del rione, al mercato per quel che "
               "manca, e a ingaggiare gli artisti che faranno le opere d'arte. Vince il mecenate "
               "più prestigioso."),
    testo_sopra(f"{FOTO}/Flo_gira.jpg", "Come gira",
                "Le azioni si prenotano e si pagano dopo, e nel frattempo l'edificio che ti "
                "produceva la pietra se l'è preso un altro. Quando succede si va al mercato: "
                "costa di più, ma costa sempre meno dell'opera lasciata a metà, che sono punti "
                "in meno."),
    scatola(f"{SCATOLE}/scatola_florenza.jpg",
            [("Edizione italiana", "GateOnGames"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Piazzamento lavoratori", "Punti segreti"], False),
             ("Di cosa parla", ["Rinascimento", "Costruzione città"], True)], FLO),
    chiusura(f"{FOTO}/Flo_fine.jpg", "Qual è il tuo gioco<br>da cinque giocatori?",
             "Quello che regge il tavolo largo senza diventare una serata intera.",
             "Scrivilo qui sotto, me li segno tutti."),
]


TZOLKIN = ("2–4", "90′", "Impegnativo")
# PARCHEGGIATO l'8 settembre 2026: le slide reggono, le foto no. Paolo le rifa'.
# Cosa serve e' scritto in dati/foto_da_rifare.md. Non si programma finche' non
# ci sono le foto nuove e la scatola dell'edizione italiana.
POST["post36"] = [   # Tzolk'in: Il Calendario Maya, in attesa di foto nuove
    copertina(f"{FOTO}/Tzolkin_cop.jpg", "TZOLK'IN",
              "Simone Luciani e Daniele Tascini · 2012 · <b>Cranio Creations</b>", TZOLKIN),
    foto_sopra(f"{FOTO}/Tzolkin_cose.jpg", "Cos'è",
               "Il tabellone si monta con i rivetti: sei ingranaggi di cartone, uno grande al "
               "centro e cinque agganciati intorno, e fra i denti stanno in piedi i lavoratori. "
               "La cosa che ribalta tutto è che l'azione non la scegli quando piazzi il "
               "lavoratore, ma quando lo togli."),
    testo_sopra(f"{FOTO}/Tzolkin_gira.jpg", "Come gira",
                "Il mais è sempre poco ed è tutto: sfama i lavoratori quattro volte a partita, "
                "paga le caselle più avanzate degli ingranaggi e paga il piazzarne più di uno "
                "per turno. Ogni lavoratore in più è un'azione in più, e una bocca in più da "
                "riempire."),
    scatola(f"{SCATOLE}/scatola_tzolkin.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Tracciato movimenti", "Ordine di turno"], False),
             ("Di cosa parla", ["Civiltà"], True)], TZOLKIN),
    # La colonna dei due sparisce da sola: una partita sola in sei anni, sotto min_partite.
    durata_da_portale(126163, "In quattro<br>venti minuti<br>in più"),
    chiusura(f"{FOTO}/Tzolkin_fine.jpg", "Qual è il gioco<br>in cui non ti<br>bastano mai<br>le risorse?",
             "Qui il mais è moneta e cibo insieme, e ogni lavoratore in più è una bocca in più da riempire.",
             "Scrivilo qui sotto."),
]


WC = ("1–4", "80′", "Impegnativo")
POST["post37"] = [   # The White Castle, data da fissare
    copertina(f"{FOTO}/Wc_cop.jpg", "THE WHITE CASTLE",
              "Isra C. e Shei S. · 2023 · <b>Devir</b>", WC),
    foto_sopra(f"{FOTO}/Wc_cose.jpg", "Cos'è",
               "Si è al castello di Himeji, ognuno a capo di un clan, e si piazzano i propri "
               "uomini nei giardini, sulle mura e a corte. Il colpo di genio è che i dadi non "
               "sono tuoi: stanno su tre ponti, in comune, e li prendi solo dalle due "
               "estremità: da una parte c'è il più basso, dall'altra il più alto."),
    testo_sopra(f"{FOTO}/Wc_gira.jpg", "Come gira",
                "Le azioni di tutta la partita sono poche, e se quella che scegli non ne attiva "
                "almeno un'altra, meglio ancora due, sei già indietro rispetto a chi fa combo su "
                "combo. Qui si pensa quando tocca a te: il tabellone cambia di continuo e "
                "prepararsi prima non serve."),
    # Un'edizione solo italiana non e' mai esistita: la colonna dice "Edizione" e non
    # "Edizione italiana", perche' la scatola che si trova qui e' la multilingue Devir.
    scatola(f"{SCATOLE}/scatola_whitecastle.png",
            [("Edizione", "Devir, multilingue"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento con dadi", "Draft aperto", "Carte multiuso"], False),
             ("Di cosa parla", ["Medievale"], True)], WC),
    # Niente slide della durata: una sola configurazione arriva a tre partite, e due di
    # quelle tre erano serate di prime volte.
    chiusura(f"{FOTO}/Wc_fine.jpg", "Qual è il gioco<br>che al tuo tavolo<br>blocca tutti<br>a pensare?",
             "La paralisi d'analisi: quando il turno di uno solo blocca tutto il tavolo.",
             "Scrivilo qui sotto."),
]


GIZ = ("2–4", "40–50′", "Medio")
POST["post38"] = [   # Gizmos, data da fissare
    copertina(f"{FOTO}/Giz_cop.jpg", "GIZMOS",
              "Phil Walker-Harding · 2018 · <b>CMON</b>", GIZ),
    foto_sopra(f"{FOTO}/Giz_cose.jpg", "Cos'è",
               "In tavola c'è un generatore pieno di sfere colorate, che ne lascia scivolare "
               "fuori sei: sono le energie da cui si pesca. Al tuo turno fai una cosa sola fra "
               "quattro: prendi un'energia, costruisci un marchingegno pagandolo con le energie "
               "giuste, metti da parte una carta, oppure peschi alla cieca."),
    testo_sopra(f"{FOTO}/Giz_gira.jpg", "Come gira",
                "Non esistono azioni forti e azioni deboli: esiste quella che le tue carte fanno "
                "scattare. Meglio adattarsi alla partita e potenziare poche azioni invece di "
                "prendere ogni bonus che passa: quando poi ne fai una di quelle, in realtà ne "
                "stai facendo sei insieme."),
    # L'edizione italiana e' del 2018 e non si trova piu': la colonna lo dice, cosi' la
    # slide non fa pensare che si compri. La copia di Paolo e' francese.
    scatola(f"{SCATOLE}/scatola_gizmos.png",
            [("Edizione italiana", "Asmodee, esaurita"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Draft aperto", "Sequenza di azioni", "Contratti"], False),
             ("Di cosa parla", ["Sci-fi"], True)], GIZ),
    durata_da_portale(246192, "In due<br>un quarto d'ora<br>in meno", accento="bassa"),
    chiusura(f"{FOTO}/Giz_fine.jpg", "Qual è il gioco<br>dove ti diverti<br>di più a costruire<br>il motore?",
             "Il motore è la catena di carte che si attiva da sola: fai una mossa e ne partono sei.",
             "Scrivilo qui sotto."),
]


# Post unico Viticulture + Tuscany, deciso da Paolo l'8 settembre 2026: il vocale dice
# "il gioco piu' l'espansione e' il gioco completo", e le nostre partite sono tutte con
# Tuscany dal 2020. Quindi i dati in copertina sono quelli dell'espansione (60-150', peso
# 3,25) e non quelli della scatola base.
VIT = ("1–6", "60–150′", "Impegnativo")
POST["post39"] = [   # Viticulture + Tuscany, data da fissare
    copertina(f"{FOTO}/Vit_cop.jpg", "VITICULTURE<br>+ TUSCANY",
              "Jamey Stegmaier e Alan Stone · 2015 · <b>Ghenos Games</b>", VIT),
    foto_sopra(f"{FOTO}/Vit_cose.jpg", "Cos'è",
               "Ogni anno passa per le quattro stagioni: pianti l'uva, la trasformi in vino, "
               "consegni gli ordini e intanto migliori la tua vigna. Chi si alza prima sceglie "
               "le caselle migliori e si porta via i bonus, mentre chi si alza tardi non è detto "
               "che riesca a fare quello che aveva in mente."),
    testo_sopra(f"{FOTO}/Vit_gira.jpg", "Come gira",
                "Il flusso è sempre lo stesso: prendi le carte dell'uva, la pianti, la raccogli, "
                "la trasformi in vino e poi consegni. Non esiste un altro ordine possibile, ed è "
                "per questo che si spiega in cinque minuti. La fretta vera è una sola: fare "
                "lavoratori nuovi fin dall'inizio."),
    testo_sopra(f"{FOTO}/Vit_tuscany.jpg", "L'espansione",
                "Il gioco base dipende troppo da cosa peschi: l'uva sbagliata, un ordine che paga "
                "poco, un visitatore inutile. Tuscany non aggiunge due regole, butta via il "
                "tabellone e ne mette un altro: quattro stagioni invece di due, molte più azioni, "
                "e il traguardo che passa da venti a venticinque punti."),
    scatola(f"{SCATOLE}/scatola_viticulture.png",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Sì, sulle carte")],
            [("Come funziona", ["Piazzamento lavoratori", "Contratti", "Gestione mano"], False),
             ("Di cosa parla", ["Agricoltura"], True)], VIT),
    # Niente slide della durata: le nostre partite sono con Tuscany, che l'editore dichiara
    # 60-150', e i nostri 90, 135 e 120 ci cascano dentro. Non c'e' nessuno scarto da strillare.
    chiusura(f"{FOTO}/Vit_fine.jpg", "Qual è l'espansione<br>senza la quale<br>non giocheresti più<br>al gioco base?",
             "Qui è Tuscany: da sei anni, quando in casa si apre questa scatola, se ne aprono due.",
             "Scrivilo qui sotto."),
]

RC = ("1–4", "80′", "Medio")
POST["post40"] = [   # The Red Cathedral, data da fissare
    copertina(f"{FOTO}/Rc_cop.jpg", "THE RED CATHEDRAL",
              "Isra C. e Shei S. · 2020 · <b>Devir Italia</b>", RC),
    foto_sopra(f"{FOTO}/Rc_cose.jpg", "Cos'è",
               "Si costruisce San Basilio, e la cattedrale è fatta di carte in colonna. Al tuo "
               "turno prenoti una sezione con uno stendardo, ci porti le risorse per finirla, o "
               "vai al mercato: scegli uno dei cinque dadi sulla rondella, lo fai avanzare di "
               "quanto mostra, e prendi quanti sono i dadi dove arriva."),
    testo_sopra(f"{FOTO}/Rc_gira.jpg", "Come gira",
                "Prima cosa: sistemarsi la plancia, così un dado ti fa due cose invece di una. "
                "Seconda: non startene fermo, perché la partita finisce quando qualcuno completa "
                "la sua sesta sezione, e chi resta con la cattedrale a metà resta anche con metà "
                "dei punti."),
    scatola(f"{SCATOLE}/scatola_redcathedral.png",
            [("Edizione italiana", "Devir Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Rondella", "Lancio di dadi", "Maggioranza"], False),
             ("Di cosa parla", ["Medievale"], True)], RC),
    # L'accento sta sulla colonna bassa: in due quaranta contro gli ottanta dichiarati.
    # La frase forte si appoggia alla colonna dei tre, che di partite ne ha otto.
    # Lo strillo non si appoggia alla colonna dei due, che di partite ne ha tre: dice
    # quello che mostra tutto il grafico, e regge sui tre, che di partite ne hanno otto.
    durata_da_portale(227224, "Ottanta minuti<br>solo se siete<br>in quattro", accento="bassa"),
    chiusura(f"{FOTO}/Rc_fine.jpg", "Qual è il gioco<br>che finisce sempre<br>mentre hai ancora<br>da costruire?",
             "Qui la partita la chiude chi finisce per primo, e gli altri restano con la cattedrale a metà.",
             "Scrivilo qui sotto."),
]



YU = ("1", "60′", "Medio")

POST["post41"] = [   # L'Eredita' di Yu, data da fissare. Gioco per un giocatore solo:
                     # niente slide della durata, `merita_durata()` vuole due configurazioni.
    copertina(f"{FOTO}/Yu_cop.jpg", "L’EREDITÀ<br>DI YU",
              "Shem Phillips · 2023 · <b>Tesla Games</b>", YU),
    foto_sopra(f"{FOTO}/Yu_cose.jpg", "Cos’è",
               "Sei Yu il Grande e devi costruire sei sezioni di canale prima che l’Alluvione ti "
               "raggiunga. Le carte popolano ti danno lavoratori colorati, legno, argilla e "
               "provviste: con quelli costruisci il canale, alzi fattorie e capanne e respingi i "
               "barbari."),
    testo_sopra(f"{FOTO}/Yu_gira.jpg", "Come gira",
                "Non è la modalità solitaria di un gioco pensato per quattro: è nato così, e si "
                "sente. E non sono partite staccate: quello che succede in una te la porti nella "
                "prossima, nel bene e nel male, come i livelli di un videogioco che si sblocca "
                "giocando."),
    scatola(f"{SCATOLE}/scatola_yu.jpg",
            [("Edizione italiana", "Tesla Games"), ("Testo nel gioco", "Molto")],
            [("Come funziona", ["Gioco a campagna", "Carte multiuso", "Piazzamento lavoratori"], False),
             ("Di cosa parla", ["Antichità", "Costruzione città"], True)], YU),
    chiusura(f"{FOTO}/Yu_fine.jpg", "Qual è il gioco<br>che tiri fuori<br>quando giochi da solo?",
             "Vale anche la risposta contraria: nessuno, perché per me i giochi sono per stare con gli altri.",
             "Scrivilo qui sotto."),
]


ALT = ("2–5", "60–120′", "Impegnativo")

POST["post42"] = [   # Altiplano, data da fissare. Niente slide della durata:
                     # `merita_durata` dice no, le nostre mediane (92' in tre, 112' in
                     # quattro) cadono dentro i 60-120 dichiarati.
    copertina(f"{FOTO}/Alt_cop.jpg", "ALTIPLANO",
              "Reiner Stockhausen · 2017 · <b>Giochix</b>", ALT),
    foto_sopra(f"{FOTO}/Alt_cose.jpg", "Cos’è",
               "Ognuno ha il suo sacchetto pieno di merci. A ogni round ne peschi alla cieca e "
               "devi decidere come sfruttarle al meglio: al mercato, per costruire edifici e "
               "barche, per scambiarle nelle diverse aree della mappa, per chiudere ordini, oppure "
               "per stiparle in magazzino."),
    testo_sopra(f"{FOTO}/Alt_gira.jpg", "Come gira",
                "Un sacchetto pieno non è ricchezza: più roba ci infili, meno esce quella che ti "
                "serve. Va svuotato, e quello che non deve rientrare si stipa in magazzino. E la "
                "pesca va migliorata subito: chi estrae otto risorse fa più azioni di chi ne pesca "
                "solo quattro."),
    scatola(f"{SCATOLE}/scatola_altiplano.png",
            [("Edizione italiana", "Giochix"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Bag building", "Contratti", "Piazzamento lavoratori"], False),
             ("Di cosa parla", ["Economia", "Ande"], True)], ALT),
    chiusura(f"{FOTO}/Alt_fine.jpg", "Quale altro<br>bag building<br>vale il tavolo?",
             "Da noi è l’unico: il sacchetto al posto del mazzo lo abbiamo visto solo qui.",
             "Scrivilo qui sotto."),
]


CAL = ("1–4", "30–120′", "Impegnativo")

POST["post43"] = [   # Clans of Caledonia, data da fissare. Titolo inglese: la scatola che
                     # fotografiamo e' la Kickstarter di Karma Games, non la Red Glove 2018.
                     # Niente slide della durata: `merita_durata` dice no.
    copertina(f"{FOTO}/Cal_cop.jpg", "CLANS OF<br>CALEDONIA",
              "Juma Al-JouJou · 2017 · <b>Red Glove</b>", CAL),
    foto_sopra(f"{FOTO}/Cal_cose.jpg", "Cos’è",
               "Scozia dell’Ottocento. Ogni giocatore impersona un clan con le sue abilità "
               "uniche, e deve coltivare, allevare, espandersi sul territorio, navigare, "
               "produrre, commerciare al mercato e soddisfare i contratti. Vince chi ne risolve "
               "di più e chi si espande meglio."),
    testo_sopra(f"{FOTO}/Cal_gira.jpg", "Come gira",
                "Non serve produrre tutto. Al mercato i prezzi si muovono con quello che comprano "
                "e vendono gli altri: la merce che ti manca a volte costa meno comprarla che "
                "costruire l’edificio che la fa, e quella schizzata in alto conviene produrla per "
                "rivenderla."),
    scatola(f"{SCATOLE}/scatola_clans.png",
            [("Edizione italiana", "Red Glove"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Mercato", "Contratti", "Griglia esagonale"], False),
             ("Di cosa parla", ["Agricoltura", "Industria"], True)], CAL),
    chiusura(f"{FOTO}/Cal_fine.jpg",
             "Qual è il gioco<br>che hai rigiocato<br>solo per provare<br>un altro personaggio?",
             "Qui ogni clan parte con un potere diverso, e finita la partita viene da chiedersi com’era dall’altra parte.",
             "Scrivilo qui sotto."),
]


ARN = ("1–4", "30–120′", "Medio")

POST["post44"] = [   # Le Rovine Perdute di Arnak, data da fissare. Niente slide della durata:
                     # una sola configurazione con partite a sufficienza (in tre, 4 partite).
    copertina(f"{FOTO}/Arn_cop.jpg", "LE ROVINE<br>PERDUTE DI ARNAK",
              "Mín &amp; Elwen · 2020 · <b>Cranio Creations</b>", ARN),
    foto_sopra(f"{FOTO}/Arn_cose.jpg", "Cos’è",
               "Una spedizione su un’isola mai mappata: due archeologi e un mazzo di carte. Ogni "
               "carta è due cose e ne usi una, un viaggio per mandare un archeologo in un sito "
               "oppure un effetto. Scopri siti, svegli guardiani, e sali sul tracciato ricerca "
               "verso il Tempio Perduto."),
    testo_sopra(f"{FOTO}/Arn_gira.jpg", "Come gira",
                "Tieni d’occhio il tracciato ricerca, dove salgono lente e quaderno: sblocca gli "
                "assistenti e in cima fa punti. Gli assistenti danno azioni extra per esplorare e "
                "comprare carte, con cui esplori ancora e batti i guardiani. Così la macchina si "
                "innesca."),
    scatola(f"{SCATOLE}/scatola_arnak.jpg",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Poco")],
            [("Come funziona", ["Deck building", "Piazzamento lavoratori", "Draft aperto"], False),
             ("Di cosa parla", ["Esplorazione", "Avventura"], True)], ARN),
    chiusura(f"{FOTO}/Arn_fine.jpg", "Qual è il tuo<br>engine building<br>preferito?",
             "Il gioco che parte lento e a ogni turno produce un po’ di più, finché la macchina va da sola.",
             "Scrivilo qui sotto."),
]


PRE = ("1–4", "60–80′", "Medio")

POST["post45"] = [   # Predoni di Scizia, data da fissare. Sei slide: la durata si fa,
                     # in quattro siamo 20 minuti oltre il massimo dichiarato. La riga dei
                     # due giocatori sta su una partita sola e resta fuori (min_partite=3).
    copertina(f"{FOTO}/Pre_cop.jpg", "PREDONI<br>DI SCIZIA",
              "Shem Phillips · 2020 · <b>Fever Games</b>", PRE),
    foto_sopra(f"{FOTO}/Pre_cose.jpg", "Cos’è",
               "Sei a capo di un villaggio scita. A ogni turno piazzi un lavoratore in un luogo e "
               "ne riprendi un altro, e contano tutte e due le mosse. Con cibo e monete recluti "
               "eroi e animali nella truppa, poi vai a razziare gli insediamenti vicini: torni "
               "con bottino, punti e qualche ferita da curare."),
    testo_sopra(f"{FOTO}/Pre_gira.jpg", "Come gira",
                "Il tempismo conta sulle due azioni essenziali: piazzi un lavoratore e ne raccogli "
                "un altro. Mai restare a corto di risorse. Potenzia subito truppa e animali, "
                "cavallo e aquila, e razzia le zone più interessanti. Se un soldato muore, lo "
                "rimpiazzi."),
    scatola(f"{SCATOLE}/scatola_predoni.jpg",
            [("Edizione italiana", "Fever Games, 2021"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Piazzamento lavoratori", "Gestione della mano", "Dadi"], False),
             ("Di cosa parla", ["Antichità", "Razzie"], True)], PRE),
    durata_da_portale(301880, "Gli 80 minuti<br>sono il punto<br>di partenza",
                      min_scatola=60, max_scatola=80, accento="alta"),
    chiusura(f"{FOTO}/Pre_fine.jpg",
             "Qual è il gioco<br>in cui mandi i tuoi pezzi<br>a morire<br>senza rimpianti?",
             "Qui un soldato ferito è un posto libero per uno migliore.",
             "Scrivilo qui sotto."),
]


SHK = ("1–4", "60′", "Medio")

POST["post46"] = [   # Shinkansen Zero-Kei, data da fissare. Niente slide della durata: una sola
                     # configurazione con partite a sufficienza (in tre, 7), e la mediana (58')
                     # sta sotto i 60 dichiarati.
    copertina(f"{FOTO}/Shk_cop.jpg", "SHINKANSEN<br>ZERO-KEI",
              "Isra C. e Shei S. · 2021 · <b>Tesla Games</b>", SHK),
    foto_sopra(f"{FOTO}/Shk_cose.jpg", "Cos’è",
               "Costruisci la linea del primo Shinkansen, fra Tokyo e Osaka, in cinque round che "
               "sono cinque anni. Ogni round aggiungi un vagone al tuo treno, e ogni vagone è "
               "un’azione: prepari terreni, posi binari, alzi stazioni. Binari e stazioni sono di "
               "tutti, e chi usa i tuoi paga te."),
    testo_sopra(f"{FOTO}/Shk_gira.jpg", "Come gira",
                "Pochi round e tantissime cose da tenere d’occhio. Ogni città senza binario vale "
                "meno tre, e rischi di chiudere sotto quanto hai guadagnato. I segnalini olimpici "
                "rendono ogni round e pesano sulle maggioranze. E i vagoni in fila crescente fanno "
                "punti."),
    scatola(f"{SCATOLE}/scatola_shink.jpg",
            [("Edizione italiana", "Tesla Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Costruzione di reti", "Draft aperto", "Maggioranze"], False),
             ("Di cosa parla", ["Treni", "Giappone"], True)], SHK),
    chiusura(f"{FOTO}/Shk_fine.jpg",
             "Qual è il gioco<br>dove costruisci tu<br>e i punti li fa un altro?",
             "Qui binari e stazioni restano sul tabellone e sono di tutti. Chi li usa paga, ma intanto li usa.",
             "Scrivilo qui sotto, me li segno tutti."),
]


IER = ("1–4", "90′", "Impegnativo")

POST["post47"] = [   # Ierusalem Anno Domini, data da fissare. Tema delicato trattato come
                     # ambientazione (regola del 2026-09-10). Niente slide della durata: una sola
                     # configurazione con partite a sufficienza, in quattro, e sta sui 90 dichiarati.
    copertina(f"{FOTO}/Ier_cop.jpg", "IERUSALEM<br>ANNO DOMINI",
              "Carmen García Jiménez · 2023 · <b>Devir</b>", IER),
    foto_sopra(f"{FOTO}/Ier_cose.jpg", "Cos’è",
               "Guidi una delle comunità arrivate a Gerusalemme per la Pasqua, e vuoi che i tuoi "
               "seguaci siedano il più vicino possibile agli apostoli: è la vicinanza che paga. "
               "Giochi una carta sulla tua plancia, attivi il luogo stampato e raccogli pietre, "
               "pane e pesci con i seguaci che hai lì."),
    testo_sopra(f"{FOTO}/Ier_gira.jpg", "Come gira",
                "Porti doni per farti invitare a cena, ascolti parabole, peschi, ti procuri il "
                "pane. Le carte iniziali non bastano: le forti le compri o le guadagni aiutando un "
                "avversario. I seguaci, il più vicino possibile agli apostoli seduti a tavola: "
                "sono punti."),
    scatola(f"{SCATOLE}/scatola_ieru.jpg",
            [("Edizione italiana", "Devir, multilingua"), ("Testo nel gioco", "Sulle tessere")],
            [("Come funziona", ["Deck building", "Piazzamento lavoratori", "Collezione set"], False),
             ("Di cosa parla", ["Antichità"], True)], IER),
    chiusura(f"{FOTO}/Ier_fine.jpg", "Qual è il gestionale<br>che ti ha sorpreso<br>di più quest’anno?",
             "Quello che hai comprato senza aspettarti granché, e adesso torna in tavola.",
             "Scrivilo qui sotto, me li segno tutti."),
]


ERA = ("1–4", "45–60′", "Medio")

POST["post48"] = [   # Era: Il Medioevo, data da fissare. Titolo col sottotitolo, in deroga alla
                     # regola di Caverna: "Era" da solo non si cerca (deciso da Paolo il 2026-09-14).
                     # Niente slide della durata: merita_durata() dice no, le mediane in quattro
                     # sono quattro "60" tondi del periodo in cui si imparava. Cinque slide.
    copertina(f"{FOTO}/Era_cop.jpg", "ERA:<br>IL MEDIOEVO",
              "Matt Leacock · 2019 · <b>Cranio Creations</b>", ERA),
    foto_sopra(f"{FOTO}/Era_cose.jpg", "Cos’è",
               "Ogni round tiri i dadi dietro lo schermo, fino a tre volte. Ogni dado è un abitante "
               "del regno e il colore dice cosa sa fare: chi porta cibo, chi beni, chi cultura, chi "
               "spade. Con i martelli costruisci: muri ed edifici sono pezzi veri, che prendi dalla "
               "riserva e incastri sulla plancia forata."),
    testo_sopra(f"{FOTO}/Era_gira.jpg", "Come gira",
                "Ogni dado è un abitante del tuo regno, e ogni abitante mangia. Più dadi metti al "
                "lavoro, più azioni fai e più costruisci, ma devi sfamarli tutti quanti. E intanto la "
                "partita scappa: contano le mura, gli edifici e le fattorie che riesci a tirare su "
                "prima che finisca."),
    scatola(f"{SCATOLE}/scatola_era.jpg",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Quasi nessuno")],
            [("Come funziona", ["Lancio di dadi", "Costruzione", "Push your luck"], False),
             ("Di cosa parla", ["Medioevo", "Civiltà"], True)], ERA),
    chiusura(f"{FOTO}/Era_fine.jpg", "Qual è il tuo<br>gioco di dadi<br>preferito?",
             "Quelli in cui il tiro decide cosa hai in mano, e la testa decide cosa farci.",
             "Scrivilo qui sotto, me li segno tutti."),
]


CUZ = ("2–4", "90′", "Medio")

POST["post49"] = [   # Cuzco, data da fissare. Niente slide della durata: 2/5/2 partite per
                     # configurazione, e in tre la mediana è 90 come la scatola. Cinque slide.
                     # Non a ridosso di un post su un Azul: la CTA nomina Kiesling.
    copertina(f"{FOTO}/Cuz_cop.jpg", "CUZCO",
              "Michael Kiesling e Wolfgang Kramer · 2018 · <b>dV Giochi</b>", CUZ),
    foto_sopra(f"{FOTO}/Cuz_cose.jpg", "Cos’è",
               "Sei un dignitario inca e il tabellone è un altopiano vuoto. Ogni turno hai sei punti "
               "azione e la prima mossa è obbligata: piazzi una tessera, su una casella libera o "
               "sopra ai terreni già in gioco, e il terreno sale a livelli. Un villaggio lo comanda "
               "chi ha un Inca più in alto, non chi ne ha di più."),
    testo_sopra(f"{FOTO}/Cuz_gira.jpg", "Come gira",
                "Il difficile è ragionare in tre dimensioni: sovrapponendo le tessere il terreno sale "
                "a terrazzamenti, e muovere le pedine là sopra non è immediato. Guarda dove vuoi "
                "arrivare, poi bilancia il turno fra mosse e costruzioni. A fine partita il tavolo è "
                "un territorio tutto in rilievo."),
    scatola(f"{SCATOLE}/scatola_cuzco.jpg",
            [("Edizione italiana", "dV Giochi"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento tessere", "Maggioranze", "Punti azione"], False),
             ("Di cosa parla", ["Inca", "Costruzione città"], True)], CUZ),
    chiusura(f"{FOTO}/Cuz_fine.jpg", "Qual è il tuo preferito<br>fra i giochi di<br>Michael Kiesling?",
             "Michael Kiesling è anche l’autore di Azul.",
             "Scrivilo qui sotto, me li segno tutti."),
]


MP2 = ("2–4", "60–120′", "Impegnativo")

POST["post50"] = [   # Marco Polo II, data da fissare. Nome corto in copertina (regola di Caverna).
                     # Niente slide della durata: merita_durata() dice no. Cinque slide. Tag sulla
                     # foto: @giochiuniti e @mago.baol. Non a ridosso di una CTA da schieramento.
    copertina(f"{FOTO}/Mp2_cop.jpg", "MARCO<br>POLO II",
              "Daniele Tascini e Simone Luciani · 2019 · <b>Giochi Uniti</b>", MP2),
    foto_sopra(f"{FOTO}/Mp2_cose.jpg", "Cos’è",
               "Sei un mercante agli ordini di Kublai Khan e parti da Pechino, non da Venezia: è il "
               "viaggio di ritorno del primo Marco Polo. A ogni round tiri cinque dadi e li posi "
               "sugli spazi azione, e il più basso decide quanto ne ricavi. Ma l’azione che conta è "
               "il viaggio: dove ti fermi pianti un avamposto."),
    testo_sopra(f"{FOTO}/Mp2_gira.jpg", "Come gira",
                "Il lancio è casuale, ma le azioni sono davvero tante e ci si adatta: coi cammelli "
                "rilanci un dado oppure ne compri uno nero, e quel dado in più è l’azione che prima "
                "non potevi fare. Muoviti, che le rendite nascono lì, e sfrutta il tuo personaggio."),
    scatola(f"{SCATOLE}/scatola_marcopolo2.png",
            [("Edizione italiana", "Giochi Uniti"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento dadi", "Contratti", "Movimento su mappa"], False),
             ("Di cosa parla", ["Viaggio", "Commercio"], True)], MP2),
    chiusura(f"{FOTO}/Mp2_fine.jpg", "Meglio questo<br>o il primo<br>Marco Polo?",
             "Il seguito di Sulle Tracce di Marco Polo: stessi autori, stessi dadi, ma si parte da Pechino e si va verso ovest.",
             "Scrivilo qui sotto, me li segno tutti."),
]


RUS = ("2–4", "120′", "Impegnativo")

POST["post51"] = [   # Russian Railroads, data da fissare. Niente slide della durata (nessuna
                     # configurazione con cinque partite). Cinque slide. Scatola non di Paolo:
                     # niente "ce l'ho". Edizione italiana Asterion Press, oggi Asmodee Italia.
    copertina(f"{FOTO}/Rus_cop.jpg", "RUSSIAN<br>RAILROADS",
              "Helmut Ohley e Leonhard Orgler · 2013 · <b>Asterion Press</b>", RUS),
    foto_sopra(f"{FOTO}/Rus_cose.jpg", "Cos’è",
               "Hai una plancia con tre linee ferroviarie, la Transiberiana, la San Pietroburgo e "
               "la Kiev, più un tracciato dell’industria. Al tuo turno fai un’azione sola: uno "
               "spazio libero, i lavoratori che chiede, esegui. I punti si contano a ogni fine "
               "round: quello che costruisci presto te lo paghi a ogni giro."),
    testo_sopra(f"{FOTO}/Rus_gira.jpg", "Come gira",
                "I tracciati sono tre, e provare a portarli avanti tutti quanti vuol dire tenerli "
                "tutti e tre a metà e non arrivare in fondo a nessuno. Decidi dall’inizio quale "
                "migliorare e concentrati lì. Le cose da fare sono tante, le risorse scarseggiano "
                "sempre."),
    scatola(f"{SCATOLE}/scatola_russianrailroads.jpg",
            [("Edizione italiana", "Asterion Press"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Tracciati di sviluppo", "Ordine di turno"], False),
             ("Di cosa parla", ["Treni", "Industria"], True)], RUS),
    chiusura(f"{FOTO}/Rus_fine.jpg", "Qual è il tuo gestionale<br>preferito in cui<br>non puoi fare tutto?",
             "Quello dove le cose da fare sono tante e le risorse non bastano mai.",
             "Scrivilo qui sotto, me li segno tutti."),
]


CAL = ("1–4", "30–45′", "Medio")

POST["post52"] = [   # Calico, mercoledì 14/10. Niente slide della durata finché Valentina non
                     # risponde sulle due partite "Switch" (vedi scheda). Cinque slide. La foto
                     # di copertina è la 00 ritagliata: in alto c'era la scatola col titolo.
    copertina(f"{FOTO}/Cal_cop.jpg", "CALICO",
              "Kevin Russ · 2020 · <b>Little Rocket Games</b>", CAL),
    foto_sopra(f"{FOTO}/Cal_cose.jpg", "Cos’è",
               "Una trapunta da riempire: ventidue esagoni vuoti e ventidue turni per cucirceli "
               "dentro. A ogni turno piazzi una delle due tessere in mano e ne prendi una dal "
               "mercato di tre scoperte. I punti vengono dai bottoni sui gruppi di colore, dai "
               "gatti che attiri e dagli obiettivi."),
    testo_sopra(f"{FOTO}/Cal_gira.jpg", "Come gira",
                "Di ogni tessera ci sono tre copie: quella che ti serve può non uscire, o la prende "
                "un altro. In Carcassonne una tessera la piazzi comunque, qui la trapunta ha i "
                "confini e gli obiettivi in mezzo. Tieniti largo sugli obiettivi e punta pure ai "
                "bottoni."),
    scatola(f"{SCATOLE}/scatola_calico.jpg",
            [("Edizione italiana", "Little Rocket Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento tessere", "Draft aperto", "Collezione set"], False),
             ("Di cosa parla", ["Gatti", "Puzzle"], True)], CAL),
    chiusura(f"{FOTO}/Cal_fine.jpg", "Qual è il tuo<br>piazzamento tessere<br>preferito?",
             "A ogni turno appoggi una tessera, e la mappa, o la trapunta, cresce sotto le tue mani.",
             "Scrivi il titolo qui sotto."),
]


FLA = ("2–4", "30–45′", "Leggero")

POST["post53"] = [   # Flamme Rouge, data da fissare. Niente slide della durata (una sola partita
                     # cronometrata). Cinque slide. Foto del 7 gennaio 2024 con Peloton in tavola:
                     # in copertina, cos'è e come gira inquadrature strette; il gruppo a sei
                     # colori resta solo in chiusura. Non a ridosso di un post su Azul.
    copertina(f"{FOTO}/Fla_cop.jpg", "FLAMME<br>ROUGE",
              "Asger Harding Granerud · 2016 · <b>Ghenos Games</b>", FLA),
    foto_sopra(f"{FOTO}/Fla_cose.jpg", "Cos’è",
               "Una corsa di biciclette sul tavolo: la pista si monta a pezzi, ogni volta diversa, "
               "con salite e discese. Guidi due ciclisti, un Rouleur e uno Sprinteur, e li muovi "
               "con le carte, coperte e scoperte tutte insieme. Scia, fatica e volata sono nelle "
               "regole. Vince chi taglia per primo il traguardo."),
    testo_sopra(f"{FOTO}/Fla_gira.jpg", "Come gira",
                "Non è un gioco per ciclisti, ma di buon senso: chi va in fuga dal primo turno resta "
                "affaticato per tutta la partita. Sfrutti la scia di chi sta davanti, in salita "
                "fatichi di più, chi scatta in volata davanti a tutti poi si stanca. Guarda dov’è il "
                "gruppo: non troppo avanti, non troppo indietro."),
    scatola(f"{SCATOLE}/scatola_flammerouge.jpg",
            [("Edizione italiana", "Ghenos Games"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Movimento programmato", "Gestione della mano", "Azioni simultanee"], False),
             ("Di cosa parla", ["Ciclismo", "Corse"], True)], FLA),
    chiusura(f"{FOTO}/Fla_fine.jpg", "Meglio tirare<br>il gruppo o<br>restare in scia?",
             "Tirare vuol dire stare in testa e prendere il vento per tutti; restare in scia vuol dire farti portare da chi tira, e stancarti molto meno.",
             "Scrivilo qui sotto, me li segno tutti."),
]


FCM = ("2–5", "120–240′", "Cinghiale")

POST["post54"] = [   # Food Chain Magnate, venerdì 2 ottobre (28/9: al posto di Century, per MS Edizioni). Rivisto il 28/9: Come gira a 7 righe, chiusura, scatola piatta italiana da BGG.  Niente slide della durata: le mediane
                     # (120 in due, 155 in tre) stanno dentro la forbice di scatola. Cinque slide.
                     # La 00 (il vassoio con la scritta Food Chain) resta fuori: titolo leggibile.
    copertina(f"{FOTO}/Fcm_cop.jpg", "FOOD CHAIN<br>MAGNATE",
              "Jeroen Doumen e Joris Wiersinga · 2015 · <b>MS Edizioni</b>", FCM),
    foto_sopra(f"{FOTO}/Fcm_cose.jpg", "Cos’è",
               "Gestisci l’azienda e i dipendenti del tuo ristorante: assumi camerieri, pizzaioli, "
               "pubblicitari, addetti alle vendite e fattorini, e ognuno vuole lo stipendio. Tutto "
               "per soddisfare le richieste degli abitanti del quartiere, che vogliono qualcosa solo "
               "dopo che la tua pubblicità li ha convinti."),
    testo_sopra(f"{FOTO}/Fcm_gira.jpg", "Come gira",
                "È una partita a scacchi, e al posto dei pezzi hai pubblicitari, pizzaioli e fattorini, "
                "ognuno con la sua mossa. Devi sapere dal primo turno dove vuoi arrivare e ragionare "
                "almeno due turni avanti: quando ti accorgi di essere indietro, sei già troppo indietro. "
                "E nel turno conviene muoversi per ultimi."),
    scatola(f"{SCATOLE}/scatola_fcm.png",
            [("Edizione italiana", "MS Edizioni"), ("Testo nel gioco", "Poco")],
            [("Come funziona", ["Azioni simultanee", "Rendita", "Mercato"], False),
             ("Di cosa parla", ["Economia", "Industria"], True)], FCM),
    chiusura(f"{FOTO}/Fcm_fine.jpg", "In quale gioco<br>hai capito che partire<br>primi non conviene?",
             "Qui chi gioca per ultimo vede le scelte degli altri, e fa ancora in tempo a cambiare piano.",
             "Dimmi il titolo qui sotto."),
]


SET = ("1–4", "40–160′", "Per esperti")

POST["post55"] = [   # SETI, data da fissare. Riaperto il 2026-09-15 dopo il vocale della seconda
                     # partita: tesi "è un gioco di carte", non più il post negativo del 4/9.
                     # Niente slide della durata: in tre la mediana è 163 su 160, sotto soglia; in
                     # quattro una partita sola (204). Cinque slide. Tag a Cranio: sì (15/9).
    copertina(f"{FOTO}/Set_cop.jpg", "SETI",
              "Tomáš Holek · 2024 · <b>Cranio Creations</b>", SET),
    foto_sopra(f"{FOTO}/Set_cose.jpg", "Cos’è",
               "Guidi un’agenzia spaziale: lanci sonde nel sistema solare, che intanto ruota, le fai "
               "orbitare e atterrare sui pianeti, e punti le antenne verso le stelle in cerca di "
               "segnali. A metà partita compaiono gli alieni, ognuno con regole sue. Tutto con "
               "carte, crediti ed energia, che non bastano mai."),
    testo_sopra(f"{FOTO}/Set_gira.jpg", "Come gira",
                "Le azioni principali costano troppo: le stesse cose le fai con le carte, che in più "
                "danno un bonus. Come in Terraforming Mars, dove nessuno paga un progetto standard "
                "per intero. È un gioco di carte: pescane tante, scarta quelle inutili per farne "
                "risorse, gioca le poche giuste."),
    scatola(f"{SCATOLE}/scatola_seti.jpg",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Carte multiuso", "Rendita", "Maggioranze"], False),
             ("Di cosa parla", ["Spazio", "Fantascienza"], True)], SET),
    chiusura(f"{FOTO}/Set_fine.jpg", "Qual è il gioco<br>che hai capito solo<br>alla seconda partita?",
             "Alla prima ci era sembrato lungo e tutto uguale. Alla seconda abbiamo giocato le carte, e ha cambiato faccia.",
             "Scrivilo qui sotto, me li segno tutti."),
]



ARC = ("1–5", "60–80′", "Medio")

POST["post56"] = [   # Architetti del Regno Occidentale, data da fissare. Niente slide della durata:
                     # mediane 59/59/71 dentro la forbice di scatola. Cinque slide. Le quattro 00
                     # sono tutte le foto che ci sono, nessuna mostra il titolo. Sulla scatola
                     # c'è Fever Games (chiusa nel 2024); in didascalia si tagga @ghenosgames.
    copertina(f"{FOTO}/Arc_cop.jpg", "ARCHITETTI DEL<br>REGNO OCCIDENTALE",
              "S J Macdonald e Shem Phillips · 2018 · <b>Fever Games</b>", ARC),
    foto_sopra(f"{FOTO}/Arc_cose.jpg", "Cos’è",
               "Sei un architetto del re con venti operai. Ogni turno ne piazzi uno in una zona, "
               "dove si aggiunge a quelli che hai già messo lì: più forza lavoro accumuli, più "
               "risorse ti dà quella zona. Con pietra, legno, argilla e marmo costruisci edifici "
               "per il villaggio o alzi la cattedrale del re."),
    testo_sopra(f"{FOTO}/Arc_gira.jpg", "Come gira",
                "Punta tutto sulla forza lavoro delle tue squadre, ma attento agli avversari, che "
                "possono catturartele. I punti si fanno solo in due modi: costruire edifici o salire "
                "sulla cattedrale. Chi riesce a combinare le due cose probabilmente vince. "
                "D’altronde siamo architetti, qualcosa dovremmo costruire."),
    scatola(f"{SCATOLE}/scatola_architetti.png",
            [("Edizione italiana", "Fever Games"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Piazzamento lavoratori", "Cattura dei pezzi", "Contratti"], False),
             ("Di cosa parla", ["Medioevo", "Costruzione di città"], True)], ARC),
    chiusura(f"{FOTO}/Arc_fine.jpg", "Qual è il piazzamento<br>lavoratori che ti ha fatto<br>venire voglia di altri?",
             "Per noi è l’evoluzione di Stone Age: lì più operai piazzavi più dadi tiravi. Qui niente dadi, piazzi tre operai e prendi tre risorse.",
             "Scrivilo qui sotto, me li segno tutti."),
]

CAY = ("2–5", "60–90′", "Medio")

POST["post57"] = [   # Caylus 1303, data da fissare. Mai uscito in italiano: in copertina e sulla
                     # scatola c'è Space Cowboys, l'editore originale. Niente slide della durata
                     # (in quattro 120 su 90, ma tre partite vecchie: la scheda dice di non farla
                     # senza il via libera di Paolo). Cinque slide. Foto 00 / 00b / 02 / 00d.
    copertina(f"{FOTO}/Cay_cop.jpg", "CAYLUS 1303",
              "William Attia · 2019 · <b>Space Cowboys</b>", CAY),
    foto_sopra(f"{FOTO}/Cay_cose.jpg", "Cos’è",
               "Il re vuole un castello, e attorno al cantiere cresce un villaggio: una strada di "
               "edifici che si allunga a ogni giro. A turno mandi un lavoratore in un edificio, poi "
               "tutti si attivano in fila e si fermano al Prevosto: chi sta oltre non produce "
               "niente. Con le risorse costruisci o rifornisci il castello."),
    testo_sopra(f"{FOTO}/Cay_gira.jpg", "Come gira",
                "Un giro alla volta non basta: la mossa la scegli guardando già quello dopo, se no "
                "arrivi sempre tardi di un turno. E l’edificio giusto da costruire è spesso quello "
                "che serve a tutti, non solo a te. Qui distrarsi un attimo si paga."),
    scatola(f"{SCATOLE}/scatola_caylus1303.jpg",
            [("Edizione italiana", "Non esiste"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Piazzamento tessere", "Ordine di turno"], False),
             ("Di cosa parla", ["Medioevo", "Costruzione di città"], True)], CAY),
    chiusura(f"{FOTO}/Cay_fine.jpg", "Quale Caylus<br>preferisci, l’originale<br>o il 1303?",
             "Non è una ristampa, è una riedizione più moderna. I puristi dicono che l’originale è meglio, chi ha giocato a questo dice che l’originale è troppo stretto.",
             "Scrivilo qui sotto, me li segno tutti."),
]

NID = ("2–5", "45′", "Medio")

POST["post58"] = [   # Nidavellir, data da fissare. Sei slide: la durata ci va, la scatola dice 45
                     # secchi e in due la mediana è 29 (merita_durata: 16 minuti in meno), in
                     # cinque 50. I tre giocatori (2 partite) restano fuori da soli. Foto
                     # 00 / 00d / 00c / 00b, la 00 aveva l'EXIF a 180°.
    copertina(f"{FOTO}/Nid_cop.jpg", "NIDAVELLIR",
              "Serge Laget · 2020 · <b>Studio Supernova</b>", NID),
    foto_sopra(f"{FOTO}/Nid_cose.jpg", "Cos’è",
               "Per ogni taverna c’è un’asta nascosta: chi punta di più sceglie per primo il nano "
               "da aggiungere alla propria collezione. E le monete che non usi per vincere l’asta "
               "salgono di valore, sempre di più."),
    testo_sopra(f"{FOTO}/Nid_gira.jpg", "Come gira",
                "I nani sono di cinque clan e ognuno fa punti a modo suo: non vince chi prende le "
                "carte più forti, ma chi trova la sinergia giusta fra i suoi. La moneta alta ti prende "
                "il nano che vuoi, e lo toglie a chi lo sta aspettando. La taverna che non ti "
                "interessa lasciala perdere: la puntata forte sprecata lì ti manca in quella che conta."),
    scatola(f"{SCATOLE}/scatola_nidavellir.png",
            [("Edizione italiana", "Studio Supernova"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Asta a puntata nascosta", "Collezione di set", "Azioni simultanee"], False),
             ("Di cosa parla", ["Fantasy", "Mitologia"], True)], NID),
    durata_da_portale(293014, "In due, mezz’ora.<br>In cinque, cinquanta.", accento="bassa"),
    chiusura(f"{FOTO}/Nid_fine.jpg", "Nei giochi d’asta<br>punti per prendere<br>o per bloccare?",
             "Qui la puntata alta fa tutte e due le cose insieme: ti prende il nano che vuoi e lo toglie a chi lo stava aspettando.",
             "Scrivilo qui sotto, me li segno tutti."),
]

VAL = ("2–5", "45–90′", "Medio")

POST["post59"] = [   # Valparaíso, data da fissare. Niente slide della durata: in due 63 dentro la
                     # forbice, in quattro 120 ma tre partite tutte del 2020, in tre mai giocato.
                     # Cinque slide. Foto 00 / 00b / 00c / 00d, EXIF a posto. Scatola da DungeonDice
                     # (img 24524, prodotto 13159), render con ombra, scontornata.
    copertina(f"{FOTO}/Val_cop.jpg", "VALPARAÍSO",
              "Louis e Stefan Malz · 2018 · <b>Cranio Creations</b>", VAL),
    foto_sopra(f"{FOTO}/Val_cose.jpg", "Cos’è",
               "Cile, 1811: Valparaíso apre al libero commercio. Mandi mercanti nell’entroterra e "
               "una nave oltremare, ma è un gioco di pianificazione: le azioni del round le decidi "
               "tutte prima, in segreto, e cambiare direzione a metà strada costa."),
    testo_sopra(f"{FOTO}/Val_gira.jpg", "Come gira",
                "Quasi ogni azione tocca gli altri: commerciare dove c’è già un mercante avversario "
                "si paga. Pianifichi le tue azioni al buio, poi si scoprono tutte insieme, e da solo "
                "il piano non regge: devi indovinare dove vanno gli altri, perché quel mercato o "
                "quella carta oltremare te li prende chi ci arriva un turno prima. E arrivare "
                "secondo lì costa."),
    scatola(f"{SCATOLE}/scatola_valparaiso.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Azioni programmate", "Azioni simultanee", "Movimento da punto a punto"], False),
             ("Di cosa parla", ["Economia", "Commercio"], True)], VAL),
    chiusura(f"{FOTO}/Val_fine.jpg", "Qual è il tuo gioco<br>di pianificazione<br>segreta preferito?",
             "Qui il piano perfetto pensato da solo è quello che ti fa arrivare secondo.",
             "Scrivilo qui sotto, me li segno tutti."),
]

TTA = ("2–4", "180′", "Cinghiale")

POST["post60"] = [   # Through the Ages, data da fissare. Durata di scatola: 180′ di Cranio (BGG dice
                     # 120, vince l'editore); contro 180 merita_durata non scatta (180 in due, 199 in
                     # tre), quindi niente slide. Cinque slide. Foto 00 / 00b / 00c / 02, 00c e 00d
                     # avevano l'EXIF a 180°.
    copertina(f"{FOTO}/Tta_cop.jpg", "THROUGH<br>THE AGES",
              "Vlaada Chvátil · 2015 · <b>Cranio Creations</b>", TTA),
    foto_sopra(f"{FOTO}/Tta_cose.jpg", "Cos’è",
               "Guidi una civiltà dalle piramidi a Internet. Ogni turno hai poche azioni e le spendi "
               "per prendere carte da una fila che scorre: tecnologie, meraviglie, leader. E tieni "
               "in piedi tutto insieme: cibo, abitanti contenti, scienza, cultura e un esercito che "
               "non resti indietro."),
    testo_sopra(f"{FOTO}/Tta_gira.jpg", "Come gira",
                "Le strade sono tante: prendersi le colonie migliori alle aste, sfruttare i leader "
                "che compaiono secolo dopo secolo, puntare tutto sulla cultura. Una cosa però vale per "
                "tutte: non lasciare mai indietro il militare, anche se non hai voglia di fare guerre. "
                "Chi è più forte di te ti gioca addosso le aggressioni, e non lo tieni su per "
                "attaccare, lo tieni su per non subirle."),
    scatola(f"{SCATOLE}/scatola_tta.png",
            [("Edizione italiana", "Cranio Creations"), ("Testo nel gioco", "Tantissimo")],
            [("Come funziona", ["Punti azione", "Draft aperto", "Rendita"], False),
             ("Di cosa parla", ["Civilizzazione", "Economia"], True)], TTA),
    chiusura(f"{FOTO}/Tta_fine.jpg", "Qual è il gioco<br>che ti porta via<br>un pomeriggio intero?",
             "Senza fartelo pesare. Questo lo tiriamo fuori nei pomeriggi lunghi e piovosi d’autunno: tre ore che volano.",
             "Scrivilo qui sotto, me li segno tutti."),
]

CAV = ("1–7", "30–210′", "Impegnativo")

POST["post61"] = [   # Caverna, data da fissare. Titolo secco "Caverna" (deciso il 9/9), editore
                     # Asmodee Italia. Niente slide della durata: 119 in tre e 150 in quattro stanno
                     # dentro i 30-210. Cinque slide. Foto 00 / 00b / 02 / 00d, EXIF a posto.
    copertina(f"{FOTO}/Cav_cop.jpg", "CAVERNA",
              "Uwe Rosenberg · 2013 · <b>Asmodee Italia</b>", CAV),
    foto_sopra(f"{FOTO}/Cav_cose.jpg", "Cos’è",
               "Una famiglia di nani, dodici round e si finisce lì. Fuori c’è la foresta, da "
               "disboscare per farci prati e campi; dentro la montagna, da scavare in caverne e "
               "stanze da arredare. Piazzi i nani sulle azioni: allevi animali, coltivi, forgi "
               "armi e li mandi in spedizione a cercare tesori."),
    testo_sopra(f"{FOTO}/Cav_gira.jpg", "Come gira",
                "Fare nani è quasi sempre giusto: più nani, più azioni. Il conto arriva al raccolto, "
                "due cibo a testa. Per questo il cibo non si va a raccogliere, si mette in "
                "produzione: animali che si riproducono da soli, ortaggi e grano che rendono ogni "
                "volta. Non è un gioco per chi comincia adesso: c’è troppo da tenere insieme, e in "
                "tre o quattro gira meglio che in sette."),
    scatola(f"{SCATOLE}/scatola_caverna.png",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Poco")],
            [("Come funziona", ["Piazzamento lavoratori", "Piazzamento tessere", "Solitario"], False),
             ("Di cosa parla", ["Agricoltura", "Fantasy"], True)], CAV),
    chiusura(f"{FOTO}/Cav_fine.jpg", "Ma tu di che<br>team sei,<br>Agricola o Caverna?",
             "Chi ha cominciato da Agricola dice che Caverna è brutto, chi ha cominciato da Caverna dice il contrario. Ci sono due fazioni nel mondo.",
             "Scrivilo qui sotto, me li segno tutti."),
]

STO = ("2–4", "60–90′", "Medio")

POST["post62"] = [   # Stone Age, data da fissare. Niente slide della durata: 60/70/75 dentro i 60-90,
                     # i cinque giocatori (3 partite con l'espansione) restano fuori. Cinque slide.
                     # Foto 00 / 00b / 02 / 01, EXIF a posto. La 01 e la 00c inquadrano i gioielli
                     # dell'espansione "Alla meta con stile": in chiusura sono piccoli.
    copertina(f"{FOTO}/Sto_cop.jpg", "STONE AGE",
              "Bernd Brunnhofer · 2008 · <b>Giochi Uniti</b>", STO),
    foto_sopra(f"{FOTO}/Sto_cose.jpg", "Cos’è",
               "Guidi una piccola tribù dell’età della pietra. Ogni turno piazzi i lavoratori nelle "
               "aree del villaggio o nelle zone intorno, bosco, prateria, fiume, cava, e le risorse "
               "che ti porti a casa le decidono i dadi. Con quelle compri carte e costruisci "
               "capanne, e round dopo round la tribù cresce."),
    testo_sopra(f"{FOTO}/Sto_gira.jpg", "Come gira",
                "È l’anello di congiunzione fra i giochi classici di una volta, dove si tirano solo "
                "dadi, e quelli moderni con lavoratori e risorse. Più la tribù cresce, più squadre "
                "puoi mandare in giro insieme: si tira un dado a lavoratore e si somma, e al fiume "
                "uno da solo ti porta l’oro una volta su sei, tre insieme quasi sempre. L’unione fa "
                "la forza, anche coi dadi."),
    scatola(f"{SCATOLE}/scatola_stoneage.png",
            [("Edizione italiana", "Giochi Uniti"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Lancio di dadi", "Collezione di set"], False),
             ("Di cosa parla", ["Preistoria", "Civilizzazione"], True)], STO),
    chiusura(f"{FOTO}/Sto_fine.jpg", "Qual è il gioco<br>che ti ha fatto fare<br>il passo successivo?",
             "Questo è quello che consigliamo a tutti: piazzi lavoratori, raccogli risorse, e intanto tiri i dadi senza doverci pensare troppo.",
             "Scrivilo qui sotto, me li segno tutti."),
]


CLM = ("2–5", "75′", "Medio")

POST["post63"] = [   # Calimala, proposto per lunedi' 21/9. Niente slide della durata: due soli
                     # tavoli. Quattro foto in archivio (00/00b/00c/00d, la 00d arrivata il 18/9
                     # dopo la richiesta di una quarta inquadratura).
    copertina(f"{FOTO}/Clm_cop.jpg", "CALIMALA",
              "Fabio Lopiano · 2017 · <b>Alley Cat Games</b>", CLM),
    foto_sopra(f"{FOTO}/Clm_cose.jpg", "Cos'è",
               "Sei un mercante nella Firenze del Rinascimento. Ogni turno piazzi un disco su "
               "una casella azione e fai le due azioni lì accanto: produci marmo, legno o "
               "mattoni, oppure tessi delle stoffe. Con quei materiali doni ai monumenti della "
               "città, o costruisci negozi, navi e nuovi laboratori."),
    testo_sopra(f"{FOTO}/Clm_gira.jpg", "Come gira",
                "Qui non vince chi produce o costruisce di più. Vince chi porta a casa il "
                "numero giusto di maggioranze, quasi venti in una partita: alcune vanno "
                "lasciate andare apposta, perché inseguirle tutte toglie forza dove conta "
                "davvero. E siccome arrivano in un ordine, si pianifica già dal primo turno su "
                "cosa puntare."),
    scatola(f"{SCATOLE}/scatola_calimala.jpg",
            [("Edizione italiana", "Non esiste"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento lavoratori", "Maggioranza", "Plancia modulare"], False),
             ("Di cosa parla", ["Rinascimento", "Economia"], True)], CLM),
    chiusura(f"{FOTO}/Clm_fine.jpg",
             "Qual è il gioco<br>dove vinci senza<br>essere il più forte<br>in niente?",
             "Qui non conta chi produce di più: contano le maggioranze giuste al momento "
             "giusto, e vincerle tutte è impossibile.",
             "Scrivilo qui sotto."),
]

FSH = ("2–5", "40–60′", "Medio")

POST["post64"] = [   # Forest Shuffle, data da fissare. Sei slide: in tre si scende a 27
                     # minuti contro i 40-60 dichiarati, uno scarto vero (merita_durata).
    copertina(f"{FOTO}/FSH_cop.jpg", "FOREST<br>SHUFFLE",
              "Kosch · 2023 · <b>Asmodee Italia</b>", FSH),
    foto_sopra(f"{FOTO}/FSH_cose.jpg", "Cos'è",
               "Un gioco di carte dove costruisci la tua foresta. Ogni carta è un albero "
               "diverso, che pian piano si riempie di animali, piante e funghi tutto intorno: "
               "lupi, cervi, farfalle, muschio, bacche. Più la foresta cresce, più creature "
               "trovano casa fra i rami, e ogni partita viene diversa dalla precedente."),
    testo_sopra(f"{FOTO}/FSH_gira.jpg", "Come gira",
                "Non tutte le carte usciranno, quindi è difficile scegliere una strategia "
                "fin dall'inizio: bisogna adattarsi a quello che il mazzo offre. E tenere "
                "d'occhio cosa costruiscono gli altri, per contrastarli: la carta che serve "
                "a loro puoi prenderla tu. Le espansioni bilanciano le carte più forti."),
    scatola(f"{SCATOLE}/scatola_forest_shuffle.png",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Italiano")],
            [("Come funziona", ["Collezione set", "Carte multiuso", "Gestione della mano"], False),
             ("Di cosa parla", ["Natura", "Animali"], True)], FSH),
    durata_da_portale(391163, "In tre finisce<br>in mezz'ora"),
    chiusura(f"{FOTO}/FSH_fine.jpg",
             "Qual è il gioco<br>dove ti adatti<br>a quello che<br>esce dal mazzo?",
             "Qui non si sceglie una strategia all'inizio: si cambia partita dopo partita, "
             "carta dopo carta.",
             "Scrivilo qui sotto."),
]

CRU = ("2–4", "30′", "Leggero")

POST["post65"] = [   # Coffee Rush, data da fissare. Sei slide: in quattro ci vogliono 10
                     # minuti in piu' dei 30 dichiarati (scarto minimo per merita_durata).
    copertina(f"{FOTO}/CRU_cop.jpg", "COFFEE<br>RUSH",
              "Euijin Han · 2023 · <b>Asmodee Italia</b>", CRU),
    foto_sopra(f"{FOTO}/CRU_cose.jpg", "Cos'è",
               "Gestisci un bar dove gli ordini arrivano senza sosta. Ti muovi sul bancone "
               "per raccogliere gli ingredienti e servire più clienti possibile, prima che "
               "il tempo scada e ti lascino una brutta recensione. Con gli incassi "
               "migliori il bancone con nuove abilità, per lavorare sempre più in fretta."),
    testo_sopra(f"{FOTO}/CRU_gira.jpg", "Come gira",
                "Capire quale miglioria prendere per prima è fondamentale: serve per fare "
                "più ordini e sbloccarne una seconda. Ogni miglioria si paga con ordini "
                "che sono punti vittoria, quindi conviene fermarsi quando il guadagno non "
                "ripaga più la spesa e non buttare punti a vuoto."),
    scatola(f"{SCATOLE}/scatola_coffee_rush.png",
            [("Edizione italiana", "Asmodee Italia"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Contratti", "Movimento su griglia"], False),
             ("Di cosa parla", ["Economia"], True)], CRU),
    durata_da_portale(377061, "In quattro dura<br>più della scatola"),
    chiusura(f"{FOTO}/CRU_fine.jpg",
             "Qual è il gioco<br>dove il caffè<br>non aspetta<br>nessuno?",
             "Ogni ordine ha un tempo limite: chi non consegna in fretta perde punti, non "
             "solo tempo.",
             "Scrivilo qui sotto."),
]

CRC = ("1–5", "45′", "Medio")

POST["post66"] = [   # Creature Comforts, data da fissare. Sei slide: 45' sulla scatola, da noi
                     # 80' in due, 100' in quattro, 110' in cinque (in tre solo 2 partite, fuori).
                     # Verificato sulle singole partite: dal 2024 le mediane restano 80/105/110.
                     # Scatola: edizione italiana Little Rocket Games, presa dalla pagina
                     # versioni di BGG (pic8603403), non la Cranio di DungeonDice.
    copertina(f"{FOTO}/CRC_cop.jpg", "CREATURE<br>COMFORTS",
              "Roberta Taylor · 2022 · <b>Little Rocket Games</b>", CRC),
    foto_sopra(f"{FOTO}/CRC_cose.jpg", "Cos'è",
               "Sei una famiglia di animali del bosco che si prepara all'inverno. Ogni mese "
               "mandi i tuoi a raccogliere legna, mele e ghiande nella foresta, al fiume e al "
               "mercato, e con quello che torna a casa costruisci i comfort della tana: "
               "trapunta, dispensa, salvadanaio. Vince la più accogliente."),
    testo_sopra(f"{FOTO}/CRC_gira.jpg", "Come gira",
                "Si pianifica tutti insieme, in parallelo, senza tempi morti. Ogni stagione "
                "ha tante zone da visitare, ma non bisogna mai dimenticare che alla fine i "
                "punti li fanno le carte comfort che avrai costruito. E i miglioramenti "
                "presi durante la partita tornano utili: possono svoltarla."),
    scatola(f"{SCATOLE}/scatola_creature_comforts.png",
            [("Edizione italiana", "Little Rocket Games"), ("Testo nel gioco", "Italiano")],
            [("Come funziona", ["Piazzamento lavoratori", "Dadi", "Collezione set"], False),
             ("Di cosa parla", ["Animali", "Stagioni"], True)], CRC),
    durata_da_portale(304051, "Il doppio<br>di quanto promette"),
    chiusura(f"{FOTO}/CRC_fine.jpg",
             "Qual è il gioco<br>che dura il doppio<br>di quello che<br>dice la scatola?",
             "Quarantacinque minuti sulla scatola. Da noi un'ora e venti in due, quasi due "
             "ore in cinque.",
             "Scrivilo qui sotto."),
]


GM2 = ("2–4", "90–120′", "Impegnativo")

POST["post67"] = [   # Glen More II: Chronicles, lunedì 28/9 (aggancio GateOnGames). Cinque slide, niente
                     # durata: in tre e in quattro stiamo dentro alla scatola. Copertina 00e, cos'è 00d,
                     # come gira 00c (la plancia dei clan), chiusura 01 (tavolo intero).
    copertina(f"{FOTO}/GM2_cop.jpg", "GLEN MORE II<br>CHRONICLES",
              "Matthias Cramer · 2019 · <b>GateOnGames</b>", GM2),
    foto_sopra(f"{FOTO}/GM2_cose.jpg", "Cos’è",
               "Sei a capo di un clan scozzese e costruisci il villaggio lungo il fiume, una tessera alla "
               "volta. Le tessere si comprano da una rondella: gioca chi è più indietro, e chi salta avanti "
               "per quella buona poi aspetta. Ogni tessera piazzata attiva se stessa e le vicine: risorse, "
               "whisky, punti."),
    testo_sopra(f"{FOTO}/GM2_gira.jpg", "Come gira",
                "Le Chronicles cambiano le regole, ogni partita gira diversa. Una cosa vale sempre: più "
                "tessere non sono più punti, il villaggio grande alla fine paga. Meglio le tessere che "
                "vanno sopra alle tue: non allargano e attivano le vicine. Resta da un lato del fiume, "
                "strette si attivano più volte."),
    scatola(f"{SCATOLE}/scatola_glen_more_ii.jpg",
            [("Edizione italiana", "GateOnGames"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Piazzamento tessere", "Rondella", "Collezione set"], False),
             ("Di cosa parla", ["Scozia", "Economia"], True)], GM2),
    chiusura(f"{FOTO}/GM2_fine.jpg", "Quale gioco<br>te l’ha fatto scoprire<br>un amico?",
             "Questo ce l’ha fatto conoscere un amico, e appena è tornato disponibile in Italia l’abbiamo comprato.",
             "Raccontamelo qui sotto.", stile_foto="object-position:top"),
]

ML = ("2–4", "15–30′", "Leggero")   # BGG 1,50; scatola 15-30 (fianco della scatola; BGG dice 15-40)
POST["post68"] = [   # Masterland, mercoledì 30/9 (prima del Combo Festival del 3-4/10). Copia mandata dall'autore.
                     # Copertina 00e (partita in corso), cos'è 00b (Prateria), come gira 00c (Inferi),
                     # chiusura 00d. Come gira dal vocale e dal tutorial di Phil; niente durata (4 partite).
    copertina(f"{FOTO}/ML_cop.jpg", "MASTERLAND",
              "Filippo Savini · 2025 · <b>Neverland</b>", ML),
    foto_sopra(f"{FOTO}/ML_cose.jpg", "Cos’è",
               "Un gioco di carte fantasy. Ognuno ha la sua land, Tundra, Altopiano, Inferi o Prateria, con un "
               "potere suo: sopra ci costruisci, cinque posti in tutto, davanti schieri le unità. Le carte si "
               "pagano in oro, sangue e legno. Si attacca per rubare cristalli di vita, e vince l’ultimo che "
               "ne ha."),
    testo_sopra(f"{FOTO}/ML_gira.jpg", "Come gira",
                "I cristalli di vita sono anche moneta: certe carte li chiedono, e quelli che rubi passano a "
                "te. Ogni turno prendi la risorsa che serve alla mano, e scarti quello che non userai. Solo "
                "fortuna con le carte? Non proprio: nei tornei in fondo arrivano sempre i più bravi."),
    scatola(f"{SCATOLE}/scatola_masterland.png",
            [("Edizione italiana", "Neverland"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Gestione della mano", "Punti vittoria come risorsa"], False),
             ("Di cosa parla", ["Fantasy", "Carte"], True)], ML),
    chiusura(f"{FOTO}/ML_fine.jpg", "È più importante<br>l’attacco<br>o la difesa?",
             "Le unità rubano cristalli, le costruzioni li difendono, e sulla land c’è posto solo per cinque.",
             "Dimmi la tua qui sotto."),
]


MCB = ("1–5", "45–90′", "Medio")   # BGG 2,16; scatola 45-90 (portale, BGG, Rio Grande)
POST["post69"] = [   # Moon Colony Bloodbath, lunedì 5/10 al posto di Quadropolis. Copia mandata da Rio Grande Games
                     # (pacco del 29/9). Copertina 00 (plancia con la ruota delle azioni), cos'è 00d (edifici),
                     # come gira 00c (gli eventi), chiusura 00b (i robot). Niente durata: nessuna configurazione a 3 partite.
    copertina(f"{FOTO}/MCB_cop.jpg", "MOON COLONY<br>BLOODBATH",
              "Donald X. Vaccarino · 2025 · <b>Rio Grande Games</b>", MCB),
    foto_sopra(f"{FOTO}/MCB_cose.jpg", "Cos’è",
               "Guidi una colonia sulla Luna. A ogni turno si gira una carta e tutti la risolvono insieme: fai "
               "azioni, giochi carte, raccogli risorse, costruisci edifici. Oppure arriva un evento, e quasi "
               "sempre è una disgrazia che si porta via un po’ di coloni. Vince chi a fine partita ha la colonia "
               "più numerosa."),
    testo_sopra(f"{FOTO}/MCB_gira.jpg", "Come gira",
                "Se qualcosa deve andare storto, andrà storto. All’inizio sembra meno grave di come te l’hanno "
                "spiegato: costruisci, produci, fai girare il motore. Poi gli eventi si accumulano, e se non sei "
                "partito bene la fine è inesorabile. Prendila a ridere: siamo tutti sulla stessa astronave."),
    scatola(f"{SCATOLE}/scatola_moon_colony_bloodbath.jpg",
            [("Edizione inglese", "Rio Grande Games"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Mazzo condiviso", "Azioni simultanee", "Eventi"], False),
             ("Di cosa parla", ["Fantascienza", "Luna"], True)], MCB),
    chiusura(f"{FOTO}/MCB_fine.jpg", "Il gioco dove<br>va tutto storto<br>e ti diverti lo stesso?",
             "Qui a ogni evento si perdono coloni, e tanto vale riderci sopra: siamo tutti sulla stessa astronave.",
             "Dimmelo qui sotto."),
]


PAC = ("2–5", "30–60′", "Medio")   # portale 2 (Medio per un pelo); scatola 30-60 (portale, BGG, Rio Grande)
POST["post70"] = [   # Pacific, data da fissare (non vicino a Moon Colony del 5/10 né a Race). Copia mandata da Rio
                     # Grande Games (pacco del 29/9). Copertina 00 (plancia, Mar dei Coralli), cos'è 00b (California e
                     # Perù), come gira 00c (carte attorno al tappetino), chiusura 00d (segnalini). Niente durata: un tavolo.
    copertina(f"{FOTO}/PAC_cop.jpg", "PACIFIC",
              "Donald X. Vaccarino · 2025 · <b>Rio Grande Games</b>", PAC),
    foto_sopra(f"{FOTO}/PAC_cose.jpg", "Cos’è",
               "Fai soldi sulle coste del Pacifico, dal Giappone al Perù, con alberghi, barche da pesca e "
               "fabbriche, mentre i pesci nuotano da una zona all’altra. Le carte si scoprono tutte insieme, e "
               "ognuno sceglie quale usare: la sua o quella di un altro. Vince chi alla fine ha guadagnato di più."),
    testo_sopra(f"{FOTO}/PAC_gira.jpg", "Come gira",
                "Poca interazione, quasi un solitario di gruppo. Parti dalla tua mano, ma se un altro scopre una "
                "carta migliore la usi tu. I pesci rendono ma scappano, gli alberghi pagano se riesci a metterne "
                "tanti. Le fabbriche tienile per la fine: un bel repulisti di pezzi vale un sacco di soldi."),
    scatola(f"{SCATOLE}/scatola_pacific.jpg",
            [("Edizione inglese", "Rio Grande Games"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Azioni simultanee", "Carte condivise", "Motore di punti"], False),
             ("Di cosa parla", ["Economia", "Oceano Pacifico"], True)], PAC),
    chiusura(f"{FOTO}/PAC_fine.jpg", "In quale gioco<br>copi più spesso<br>il vicino?",
             "Qui puoi prendere la sua carta, e nessuno se ne lamenta.",
             "Raccontamelo qui sotto."),
]

DOOM = ("2–6", "20–45′", "Leggero")   # BGG 1,57; scatola 20-45
POST["post71"] = [   # Doomlings (terza edizione, Remastered 2026), entro il 29/10. Copia mandata dal team Doomlings
                     # (29/9). Copertina 00 (tratti), cos'è 00b (catastrofi), come gira 00c (tratti rossi e viola),
                     # chiusura 00d. Scatola: versione BGG 807248 (pic9674531). CTA da confermare con Paolo.
    copertina(f"{FOTO}/DOOM_cop.jpg", "DOOMLINGS",
              "Justus e Andrew Meyer · 2022 · <b>Doomlings</b>", DOOM),
    foto_sopra(f"{FOTO}/DOOM_cose.jpg", "Cos’è",
               "Guidi una specie di creaturine su un pianeta condannato. A ogni turno giochi davanti a te una "
               "carta tratto: vale punti, e spesso fa qualcosa a te o agli altri. Ogni round si gira un’era che "
               "cambia qualcosa, e fra le ere ci sono tre catastrofi: alla terza il mondo finisce e vince chi ha "
               "più punti."),
    testo_sopra(f"{FOTO}/DOOM_gira.jpg", "Come gira",
                "Ogni carta ha un’abilità sua, e la mano va curata: scarti al momento giusto e poi la rimpolpi. "
                "C’è tanto da tenere d’occhio, i tuoi tratti e quelli degli altri, perché prima o poi ne vorrai "
                "rubare o distruggere qualcuno. Un gradino sopra i giochi di carte dove se ne cala una tanto per."),
    scatola(f"{SCATOLE}/scatola_doomlings.png",
            [("Edizione inglese", "Doomlings"), ("Testo nel gioco", "Sulle carte")],
            [("Come funziona", ["Gestione della mano", "Take that", "Eventi"], False),
             ("Di cosa parla", ["Evoluzione", "Fine del mondo"], True)], DOOM),
    chiusura(f"{FOTO}/DOOM_fine.jpg", "Il gioco di carte<br>che sembra leggero<br>e ti fa pensare?",
             "Qui ogni carta ha un potere suo, e la mano va gestita.",
             "Dimmi il titolo nei commenti."),
]

MF = ("1–4", "5′", "Leggero")   # scatola "5+ min" (BGG 5-10: vince la scatola). Peso: BGG senza voti, Leggero nostro
POST["post72"] = [   # Monster Freeze, data da fissare. Copia mandata da Mana Project Studio (pacco del 30/9),
                     # originale Don't Panic Games. Copertina 00b (tante carte), cos'è 00, come gira 00c, chiusura 00d.
                     # Scatola: render BGG pic9083595 (fronte uguale all'italiana, logo Don't Panic piccolo sul fianco).
    copertina(f"{FOTO}/MF_cop.jpg", "MONSTER<br>FREEZE",
              "kriss · 2025 · <b>Mana Project Studio</b>", MF),
    foto_sopra(f"{FOTO}/MF_cose.jpg", "Cos’è",
               "Un tris da giocare tutti insieme, di corsa e senza turni. Hai tre carte bucate con dei "
               "mostriciattoli colorati: le giri, le capovolgi e le sovrapponi finché dai buchi spuntano tre mostri "
               "dello stesso colore in fila, anche in diagonale. A ogni tris ripeschi, e vince chi ne fa uno per colore."),
    testo_sopra(f"{FOTO}/MF_gira.jpg", "Come gira",
                "Cinque minuti, meno di qualsiasi filler: è poco più di un tris, giusto per riempire un’attesa. Il "
                "bello è la fretta. Devi essere più veloce degli altri: guardi le tre carte che hai in mano, "
                "capisci al volo come incastrarle e decidi se cambiarne una con quella scoperta sul tavolo."),
    scatola(f"{SCATOLE}/scatola_monster_freeze.png",
            [("Edizione italiana", "Mana Project Studio"), ("Testo nel gioco", "Nessuno")],
            [("Come funziona", ["Tempo reale", "Sovrapposizione"], False),
             ("Di cosa parla", ["Mostri", "Party"], True)], MF),
    chiusura(f"{FOTO}/MF_fine.jpg", "Il tuo gioco<br>da cinque minuti?",
             "Quello da tirare fuori in cinque minuti di attesa.",
             "Scrivilo nei commenti."),
]


RFTG = ("2–4", "30–60′", "Medio")   # BGG 2,99 (Medio per un soffio); scatola 30-60 (portale, BGG, DungeonDice)
POST["post73"] = [   # Race for the Galaxy, secondo dei tre Rio Grande (fra Moon Colony e Pacific, che sono tutti e due di
                     # Vaccarino). Seconda edizione inglese, ristampa 2025 (confermato da Paolo il 2/10). Copertina 00d
                     # (pianeti coi cubetti), cos'è 00b (carte azione), come gira 00c, chiusura 00 (gettoni punti).
    copertina(f"{FOTO}/RFTG_cop.jpg", "RACE FOR<br>THE GALAXY",
              "Tom Lehmann · 2007 · <b>Rio Grande Games</b>", RFTG),
    foto_sopra(f"{FOTO}/RFTG_cose.jpg", "Cos’è",
               "Costruisci un impero galattico a colpi di carte. A ogni round tutti scelgono in segreto un’azione: "
               "esplori, sviluppi, colonizzi pianeti, produci merci o le consumi per i punti. Si fanno solo le azioni "
               "scelte, e le fanno tutti. Le carte in mano sono anche i soldi per pagarne altre."),
    testo_sopra(f"{FOTO}/RFTG_gira.jpg", "Come gira",
                "Si chiude nel round in cui qualcuno arriva a dodici carte, quindi lo spazio è poco: bilancia le carte "
                "che migliorano le tue azioni con quelle che fanno punti. Inutile riempirsi di potenziamenti se poi, "
                "quando serve, i punti non arrivano. I simboli all’inizio sono tanti, poi la cosa si supera."),
    scatola(f"{SCATOLE}/scatola_race_for_the_galaxy.jpg",
            [("Edizione inglese", "Rio Grande Games"), ("Testo nel gioco", "Quasi nessuno")],
            [("Come funziona", ["Azioni simultanee", "Carte multiuso", "Gestione della mano"], False),
             ("Di cosa parla", ["Fantascienza", "Spazio"], True)], RFTG),
    chiusura(f"{FOTO}/RFTG_fine.jpg", "Il gioco più vecchio<br>che tiri ancora<br>fuori volentieri?",
             "Questo è del 2007, e non sente per niente gli anni.",
             "Scrivilo qui sotto."),
]


if __name__ == "__main__":
    quale = sys.argv[1] if len(sys.argv) > 1 else "post1"
    for p in rasterizza(POST[quale], OUT, quale):
        print(p)
