/* Craftermind — foglio di stile minimo. Niente fronzoli: serve a rendere il
   gioco leggibile abbastanza da poterci giocare e capire se funziona. */

/* Monocraft: font a pixel in stile Minecraft (SIL OFL, vedi font/LEGGIMI.md).
   È monospaziato e disegnato su una griglia: va reso a misure intere, se no
   i pixel finiscono a cavallo di mezza unità e le lettere sfarfallano. */
@font-face {
  font-family: "Monocraft";
  src: url("font/Monocraft.ttf") format("truetype");
  font-weight: 400; font-style: normal; font-display: swap;
}
@font-face {
  font-family: "Monocraft";
  src: url("font/Monocraft-Bold.ttf") format("truetype");
  font-weight: 600 700; font-style: normal; font-display: swap;
}

:root {
  --fondo:      #15171b;
  --pannello:   #21242b;
  --incasso:    #191b20;
  --bordo:      #343945;
  --testo:      #dde1e8;
  --tenue:      #8c94a3;
  --accento:    #6aa9e9;
  --verde:      #4f9d3a;
  --giallo:     #c9a227;
  --grigio:     #5a5a5a;
  /* lo slot del banco da lavoro, ridisegnato in CSS invece che con la sua
     texture: fondo grigio e smusso a due toni, buio in alto a sinistra e luce
     in basso a destra. Senza immagine il fondo resta libero di colorarsi col
     responso del tentativo, che è tutto quello che ci serve dalla cella. */
  --slot:       #8b8b8b;
  --slot-buio:  #373737;
  --slot-luce:  #ffffff;
  --smusso:     2px;
  --cella:      84px;
  --mini:       26px;
  --pal-cella:  52px;
}

* { box-sizing: border-box; }

/* Le regole su id (#round, #lampo) batterebbero il display:none dell'attributo
   hidden dello user-agent: qui lo rimettiamo al suo posto. */
[hidden] { display: none !important; }

body {
  margin: 0;
  padding: 24px;
  background: var(--fondo);
  color: var(--testo);
  font: 16px/1.5 "Monocraft", ui-monospace, "SF Mono", Menlo, monospace;
  text-transform: lowercase;
}

h1 { font-size: 30px; margin: 0 0 4px; }
h2 { font-size: 18px; margin: 28px 0 12px; font-weight: 600; }
h3 { font-size: 12px; margin: 0 0 10px; color: var(--tenue);
     letter-spacing: 1px; font-weight: 600; }

button {
  font: inherit; text-transform: inherit;
  color: var(--testo); background: var(--pannello);
  border: 1px solid var(--bordo);
  padding: 9px 16px; cursor: pointer;
}
button:hover:not(:disabled) { border-color: var(--accento); }
button:disabled { opacity: .4; cursor: default; }
button.primario { background: var(--accento); border-color: var(--accento); color: #0d1117;
                  font-weight: 600; }
button.primario:hover:not(:disabled) { filter: brightness(1.12); }

/* -------------------------------------------------------------- celle ---- */

/* Le caselle del banco, della palette e della cronologia sono lo stesso
   oggetto: lo slot della crafting table. Lo smusso lo disegna il bordo (due
   lati scuri, due chiari) e non cambia mai; a cambiare è solo lo sfondo, così
   la cella può dare il responso restando riconoscibile come slot. */
.cella, .pal, .mini div, .casella {
  background: var(--slot);
  border: var(--smusso) solid;
  border-color: var(--slot-buio) var(--slot-luce) var(--slot-luce) var(--slot-buio);
}

/* uno slot che sta per conto suo: lo usa l'obiettivo, che non è una griglia
   ma ha bisogno della stessa cornice. */
.casella {
  --smusso: 4px; width: 72px; height: 72px;
  display: flex; align-items: center; justify-content: center;
}

/* l'evidenziazione di Minecraft: un velo bianco sul fondo. L'ombra interna si
   ferma dentro il bordo, quindi lo smusso non viene sporcato, e passa sopra
   qualunque colore la cella stia mostrando. */
#griglia.attiva .cella:hover, .pal:hover {
  box-shadow: inset 0 0 0 99px rgba(255, 255, 255, .3);
}

/* ------------------------------------------------------------- inizio ---- */

#inizio, #istruzioni { max-width: 660px; margin: 5vh auto; }
#inizio #difficolta { margin-bottom: 26px; }
#testata { display: flex; align-items: center; gap: 46px; margin-bottom: 30px; }
#testata h1 { font-size: 52px; margin: 0; }
#istruzioni .regole { margin-bottom: 8px; }
#istruzioni > button { margin-top: 26px; }

/* Il bottone delle istruzioni è il ricettario di Minecraft: la texture del
   pulsante «recipe book» del banco da lavoro, ingrandita a blocchi. */
#vai-istruzioni {
  width: 70px; height: 63px; padding: 0;
  border: none; background: none;
  background-image: url("icons/recipe_book_button.png");
  background-size: 100% 100%; background-repeat: no-repeat;
  image-rendering: pixelated;
}
#vai-istruzioni:hover:not(:disabled) {
  background-image: url("icons/recipe_book_button_highlighted.png");
}
#vai-istruzioni .etichetta {
  position: absolute; width: 1px; height: 1px; overflow: hidden;
  clip-path: inset(50%); white-space: nowrap;
}
.regole { padding-left: 20px; margin: 0; color: var(--tenue); }
.regole li { margin-bottom: 9px; }
.regole b { color: var(--testo); font-weight: 600; }
/* le tre parole sono scritte col colore che poi vedranno sulla cella: non un
   verde «da testo», proprio quello dell'indizio */
/* col selettore semplice perderebbero contro «.regole b», che è più
   specifico e le ridipinge di bianco: vanno qualificate anche loro */
.regole .k-verde  { color: var(--verde); }
.regole .k-giallo { color: var(--giallo); }
.regole .k-grigio { color: var(--grigio); }

#difficolta { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; }
.scelta { padding: 16px 10px; text-align: center; }
.scelta .nome { font-weight: 600; font-size: 16px; }
#punteggio-info { color: var(--tenue); }
#punteggio-info p { margin: 0 0 12px; }
#punteggio-info b { color: var(--testo); font-weight: 600; }
table.punti { border-collapse: collapse; margin: 10px 0 12px; font-variant-numeric: tabular-nums; }
table.punti th, table.punti td { border: 1px solid var(--bordo); padding: 4px 11px;
                                 text-align: center; font-weight: 400; }
table.punti th { color: var(--tenue); text-align: right; }
table.punti tr:last-child td { color: var(--testo); font-weight: 600; }
.record { display: flex; flex-direction: column; align-items: center; gap: 2px;
          margin: 0; }

/* -------------------------------------------------------------- round ---- */

#round { display: grid; grid-template-columns: auto minmax(360px, 1fr) auto;
         gap: 28px; align-items: start; max-width: 1400px; margin: 0 auto; }

#banco { display: flex; flex-direction: column; align-items: center; gap: 14px; }

/* la colonna di sinistra: prima il punteggio, poi i tentativi */
#col-cronologia { display: flex; flex-direction: column; align-items: center; gap: 26px; }

/* obiettivo */
#obiettivo { display: flex; flex-direction: column; align-items: center; gap: 8px; }
#obiettivo img { width: 84%; height: 84%; image-rendering: auto; }
#obiettivo .nome { font-size: 21px; font-weight: 600; }
#obiettivo .quanti { color: var(--tenue); font-size: 14px; font-weight: 400; }

/* griglia del banco */
/* relative perché il lampo si appoggia qui: va centrato sul banco, non sulla
   finestra, se no scivola a destra o a sinistra a seconda di quanto è larga
   la palette, che cambia con la difficoltà */
#zona-griglia { position: relative;
                display: flex; flex-direction: column; align-items: center; gap: 8px; }
/* il banco vive nudo sulla pagina: gli slot si disegnano da soli la loro
   cornice, una seconda scatola intorno sarebbe solo rumore */
#griglia {
  display: grid; grid-template-columns: repeat(3, var(--cella));
  grid-auto-rows: var(--cella); gap: 6px;
  touch-action: none; user-select: none;
}
.cella {
  --smusso: 4px;
  display: flex; align-items: center; justify-content: center; cursor: pointer;
}
.cella img { width: 84%; height: 84%; pointer-events: none; }
#griglia.bloccata { pointer-events: none; }

/* colori del feedback: tinta dello sfondo dietro l'icona */
.cella.verde  { background: var(--verde); }
.cella.giallo { background: var(--giallo); }
.cella.grigio { background: var(--grigio); }

/* il lampo che conferma la vittoria: deve essere impossibile confonderlo
   col responso di un tentativo sbagliato */
/* il fondo tagliato in basso alza il testo rispetto al centro del banco senza
   toccare il transform, che serve tutto all'animazione */
#lampo {
  position: absolute; inset: 0 0 80px; display: flex; flex-direction: column; gap: 6px;
  align-items: center; justify-content: center; pointer-events: none; z-index: 50;
  animation: lampo 1600ms ease-out forwards;
}
#lampo .grido {
  font-size: 68px; font-weight: 700; letter-spacing: 1px; color: #7fd873;
  text-shadow: 0 0 34px rgba(0, 0, 0, .9), 0 4px 16px rgba(0, 0, 0, .7);
}
#lampo .conto {
  font-size: 19px; color: var(--testo);
  text-shadow: 0 0 22px rgba(0, 0, 0, .95), 0 2px 10px rgba(0, 0, 0, .8);
}
@keyframes lampo {
  0%   { transform: scale(.75); opacity: 0; }
  10%  { transform: scale(1.05); opacity: 1; }
  75%  { transform: scale(1); opacity: 1; }
  100% { transform: scale(1); opacity: 0; }
}

/* il bottone si stacca dal banco più di quanto faccia il gap della colonna:
   è l'unica azione della schermata e non deve sembrare la quarta riga */
#azioni { display: flex; gap: 10px; margin-top: 18px; }
/* score, record e livello sono tre righe della stessa forma, «etichetta:
   valore», incolonnate e centrate sotto il banco. Il numero dello score resta
   il più grande: è l'unico che cambia mentre si gioca. */
#stato { display: flex; flex-direction: column; align-items: center; gap: 2px;
         color: var(--tenue); font-size: 20px; }
#stato b { color: var(--testo); font-weight: 600; }
#stato span { display: flex; gap: 8px; align-items: baseline; }
#contatori b { font-size: 30px; }

/* cronologia */
#cronologia { display: grid; grid-template-columns: repeat(2, auto); gap: 10px 14px; }
.slot { display: flex; gap: 7px; align-items: flex-start; opacity: .35; }
.slot.pieno { opacity: 1; }
.slot.ultimo .mini { outline: 2px solid var(--accento); outline-offset: 2px; }
.slot .num { color: var(--tenue); font-size: 14px; width: 18px; text-align: right;
             padding-top: 2px; font-variant-numeric: tabular-nums; }
.mini { display: grid; grid-template-columns: repeat(3, var(--mini));
        grid-auto-rows: var(--mini); gap: 3px; }
.mini img { width: 100%; height: 100%; display: block; }
.mini .verde  { background: var(--verde); }
.mini .giallo { background: var(--giallo); }
.mini .grigio { background: var(--grigio); }

/* palette */
#palette { display: grid; gap: 5px;
           grid-template-columns: repeat(var(--lato), var(--pal-cella));
           grid-auto-rows: var(--pal-cella); }
.pal {
  --smusso: 3px;
  display: flex; align-items: center; justify-content: center; cursor: pointer;
}
.pal img { width: 100%; height: 100%; pointer-events: none; }
/* la scelta è uno stato che resta, quindi non può essere il velo del passaggio
   del mouse: le gira intorno, fuori dallo smusso, senza coprirlo */
.pal.scelto { outline: 3px solid var(--accento); }

/* ---------------------------------------------------------------- fine ---- */

#fine { max-width: 560px; margin: 8vh auto; text-align: center; }
#riepilogo { margin: 20px 0; font-size: 16px; color: var(--tenue); }
#riepilogo .grande { display: block; font-size: 44px; color: var(--testo); font-weight: 600;
                     line-height: 1.1; }
/* blocco, non inline-flex: altrimenti il bottone «nuova partita» gli si
   affianca invece di finire sotto */
#svelata { background: var(--pannello); border: 1px solid var(--bordo);
           padding: 18px; margin: 0 auto 24px; width: fit-content; display: flex;
           flex-direction: column; align-items: center; gap: 10px; }
#svelata .mini { --mini: 44px; --smusso: 3px; }
#svelata .risultato { width: 56px; height: 56px; }

/* -------------------------------------------------------------- mobile ---- */

/* Sotto i 1000px le tre colonne del round non ci stanno più in larghezza —
   alla difficoltà più alta ne servirebbero circa 1060 — e diventano una pila
   sola. `display: contents` scioglie le due colonne laterali e il banco: i
   loro pezzi diventano figli diretti di #round e l'ordine in cui si
   incolonnano lo decide `order`. Sopra i 1000px non cambia niente. */
@media (max-width: 1000px) {
  body { padding: 12px; }
  h1 { font-size: 34px; }
  #testata { gap: 20px; margin-bottom: 20px; }
  #testata h1 { font-size: 38px; }
  #inizio, #istruzioni { margin: 2vh auto; }

  /* «appassionato» non sta in un quarto di schermo: due per riga */
  #difficolta { grid-template-columns: repeat(2, 1fr); }

  /* la tabella dei punti ha una colonna per tentativo: se non ci sta, si
     scorre lei invece di allargare tutta la pagina */
  table.punti { display: block; max-width: 100%; overflow-x: auto; }

  #round { display: flex; flex-direction: column; align-items: center;
           gap: 6px; }
  #col-cronologia, #col-palette, #banco { display: contents; }

  /* l'ordine della pila: prima quello che serve a giocare. Il «Craft!» sta
     attaccato al banco e non sotto la palette, se no per premerlo bisogna
     scorrere. Punteggio e tentativi passati scendono in fondo. */
  #obiettivo    { order: 1; }
  #zona-griglia { order: 2; }
  #azioni       { order: 3; }
  #palette      { order: 4; }
  #stato        { order: 5; }
  #cronologia   { order: 6; }

  /* l'obiettivo si corica — icona e nome affiancati costano meno altezza —
     e la sua casella scende a metà della misura del desktop */
  #obiettivo { flex-direction: row; gap: 10px; text-align: left; }
  #obiettivo .casella { --smusso: 3px; width: 42px; height: 42px; }
  #obiettivo .nome { font-size: 16px; }
  #obiettivo .quanti { font-size: 13px; }

  /* Il banco al telefono ha un suo tetto, 52px invece degli 84 del desktop:
     è lui il pezzo grosso, e a schermo pieno deve lasciare posto a
     obiettivo, «Craft!», palette e tentativi. Il tetto conta più della
     misura dello schermo — su un telefono alto una cella grande ci starebbe
     in larghezza ma poi i tentativi finirebbero sotto il bordo — e le due
     misure che seguono servono solo a stringere ancora su uno schermo
     piccolo: un terzo della larghezza utile, e un terzo di quel che resta
     dell'altezza una volta tolti i 440px degli altri pezzi.
     `svh` è l'altezza col minimo di schermo visibile, cioè con le barre del
     browser aperte: è la misura prudente, quella che non promette spazio
     che poi sparisce. La riga in `vh` che la precede serve ai browser che
     non conoscono `svh`; lì a tenere le misure è il tetto. */
  #zona-griglia { width: 100%; }
  #griglia {
    --cella: max(36px, min(52px, calc((100vw - 48px) / 3),
                                calc((100vh - 400px) / 3)));
    --cella: max(36px, min(52px, calc((100vw - 48px) / 3),
                                calc((100svh - 400px) / 3)));
    width: calc(3 * var(--cella) + 12px); max-width: 100%;
    grid-template-columns: repeat(3, minmax(0, 1fr));
    grid-auto-rows: auto;
  }
  .cella { aspect-ratio: 1; }
  #azioni { margin-top: 0; }

  /* La palette è quadrata — «leggenda» è 9×9 — e nelle difficoltà alte è
     lei a decidere se la schermata basta. Invece di tagliarla e farla
     scorrere, qui la cella si fa piccola quanto serve perché ci stia
     tutta: l'altezza che avanza (i 444px sono quello che prendono gli
     altri pezzi, tentativi compresi), meno i vuoti fra una cella e
     l'altra, divisa per il numero di colonne. Restano i due tetti — la
     misura che dà gioco.js e i 40px — perché nelle difficoltà basse la
     palette non si gonfi a riempire lo spazio, e un fondo di 24px sotto
     il quale le icone non sarebbero più riconoscibili: se nemmeno così
     ci sta, allora sì che scorre, ed è il caso degli schermi molto bassi.
     La divisione per `var(--lato)` è CSS recente: se un browser non la
     digerisce, `var()` ripiega sulla sola misura di gioco.js. */
  #palette {
    --pal: max(24px, min(var(--pal-cella), 40px,
              calc((100svh - 444px - 4px * (var(--lato) - 1)) / var(--lato))));
    width: 100%; justify-content: center; gap: 4px;
    max-height: max(160px, calc(100svh - 438px));
    overflow-y: auto; overscroll-behavior: contain;
    grid-template-columns:
      repeat(var(--lato), minmax(0, var(--pal, min(var(--pal-cella), 40px))));
    grid-auto-rows: auto;
  }
  .pal { aspect-ratio: 1; }

  /* il punteggio su una riga sola: misure strette perché «score record
     level» stiano in fila anche su uno schermo da 360px */
  #stato { flex-direction: row; flex-wrap: wrap; justify-content: center;
           gap: 4px 12px; font-size: 14px; }
  #contatori b { font-size: 17px; }
  .record { flex-direction: row; gap: 12px; }

  /* i tentativi in fondo, quattro per riga e in miniatura */
  #cronologia { --mini: 14px; grid-template-columns: repeat(4, auto);
                gap: 8px 10px; justify-content: center; }
  .slot { gap: 5px; }
  .slot .num { font-size: 12px; width: 12px; }

  #lampo { inset: 0 0 30px; }
  #lampo .grido { font-size: 44px; }
  #lampo .conto { font-size: 16px; }
}

/* Telefono coricato: la larghezza c'è, l'altezza no. Qui le colonne tornano
   due — il banco a sinistra, palette e tentativi a destra — e per farlo il
   banco e la colonna dei tentativi riprendono la loro scatola: se restassero
   sciolti come in verticale, le righe della griglia sarebbero le stesse per
   tutt'e due le colonne e la destra si allungherebbe a vuoto dietro la
   griglia. La misura della cella la detta l'altezza dello schermo. */
@media (max-width: 1000px) and (orientation: landscape) and (max-height: 560px) {
  #round {
    display: grid; grid-template-columns: auto minmax(0, 1fr);
    grid-template-areas: "banco palette"
                         "banco tentativi";
    align-content: start; justify-items: center; gap: 8px 18px;
  }
  #banco { display: flex; grid-area: banco; gap: 8px; }
  #col-palette { display: block; grid-area: palette; width: 100%; }
  #col-cronologia { display: flex; grid-area: tentativi; gap: 8px;
                    align-self: start; }

  #griglia { --cella: max(40px, min(62px, calc((100vh - 150px) / 3)));
             --cella: max(40px, min(62px, calc((100svh - 150px) / 3)));
             width: calc(3 * var(--cella) + 12px); max-width: none; }
  #palette { --pal: min(var(--pal-cella), 40px);
             max-height: 42vh; max-height: 42svh; }
  #cronologia { --mini: 13px; gap: 6px 8px; }
  #obiettivo .nome { font-size: 15px; }
  #lampo .grido { font-size: 34px; }
}