# CSS

CSS décrit **l'apparence** d'une page : couleurs, tailles, espacements, disposition. Il s'applique à un contenu écrit en [HTML](/web/html), sans le modifier.

## Le problème

La page du classement fonctionne, mais elle a l'apparence par défaut du navigateur : texte noir sur fond blanc, tableau sans bordure, tout collé au bord gauche.

On veut la mettre en forme **sans toucher au fichier HTML**. C'est la même séparation que dans le jeu : changer la couleur d'une case ne devrait pas obliger à modifier les règles.

## La notion

### Une règle

```css
.scores th {
  text-align: left;
  color: #8a8f98;
}
```

| Morceau | Nom | Rôle |
| --- | --- | --- |
| `.scores th` | Sélecteur | À quels éléments la règle s'applique |
| `text-align` | Propriété | Ce qu'on règle |
| `left` | Valeur | Comment on le règle |
| `propriété: valeur;` | Déclaration | Une ligne entre les accolades |

### Relier le CSS à la page

Dans le `<head>` du fichier HTML :

```html
<link rel="stylesheet" href="style.css" />
```

Un fichier CSS séparé sert à toutes les pages du site. Modifier une couleur se fait à un seul endroit.

## Les sélecteurs

| Sélecteur | Cible |
| --- | --- |
| `h1` | Toutes les balises `<h1>` |
| `.scores` | Les éléments qui ont `class="scores"` |
| `#player` | L'élément qui a `id="player"` |
| `.scores td` | Les `<td>` situés **dans** un élément `.scores` |
| `nav > a` | Les `<a>` enfants directs de `<nav>` |
| `a:hover` | Un lien survolé par la souris |
| `tr:nth-child(even)` | Une ligne sur deux |
| `h1, h2` | Les `<h1>` et les `<h2>` |

En pratique, on vise presque toujours des **classes**. Elles ne dépendent ni de la balise ni de la position dans la page.

## La cascade

Quand deux règles visent le même élément et la même propriété, laquelle gagne ? C'est la question centrale de CSS, et la source de la plupart des « pourquoi mon style ne s'applique pas ».

<Mermaid
  chart={`flowchart TB
    q1{Une règle est plus précise ?} -- oui --> r1[La plus précise gagne]
    q1 -- non, même précision --> r2[La dernière écrite gagne]`}
/>

La précision, ou **spécificité**, suit cet ordre :

| Sélecteur | Précision |
| --- | --- |
| `#player` | La plus forte |
| `.scores`, `a:hover` | Moyenne |
| `td`, `h1` | La plus faible |

```css
td { color: gray; }
.first td { color: gold; }
```

Les cellules de la ligne `first` sont dorées, quel que soit l'ordre des deux règles : la seconde est plus précise.

Deux conséquences pratiques : rester sur des classes garde toutes les règles au même niveau, donc prévisibles ; et `!important`, qui force une déclaration à gagner, est le signe qu'on a perdu le fil.

### L'héritage

Certaines propriétés passent d'un élément à ses descendants : la couleur du texte, la police, la taille des caractères. Les régler sur `body` les règle pour toute la page. Les marges, bordures et fonds ne s'héritent pas.

## Le modèle de boîte

Chaque élément est un rectangle, fait de quatre couches.

<Mermaid
  chart={`flowchart TB
    subgraph margin [margin, l'espace avec les voisins]
      subgraph border [border, la bordure]
        subgraph padding [padding, l'espace intérieur]
          content[content<br/>le texte ou l'image]
        end
      end
    end`}
/>

```css
.card {
  width: 300px;
  padding: 16px;
  border: 1px solid #2a2e37;
  margin: 24px;
}
```

Par défaut, `width` ne compte que le contenu : la boîte ci-dessus occuperait 334 pixels de large. On change ce comportement une fois pour toutes, en haut du fichier :

```css
* {
  box-sizing: border-box;
}
```

`width` inclut alors le `padding` et la bordure. C'est ce que tout le monde attend.

## Les unités

| Unité | Sens | Usage |
| --- | --- | --- |
| `px` | Pixel | Bordures, petits détails |
| `rem` | Multiple de la taille de texte de base, 16 px en général | Tailles de texte, espacements |
| `%` | Part de l'élément parent | Largeurs |
| `vw`, `vh` | Part de la largeur ou de la hauteur de la fenêtre | Éléments en plein écran |
| `fr` | Part de l'espace restant, dans une grille | Colonnes |

Préférer `rem` à `px` pour le texte : la page respecte alors la taille choisie par l'utilisateur dans son navigateur.

## Disposer les éléments

Par défaut, les blocs s'empilent de haut en bas. Deux outils changent cela.

### Flexbox : sur une ligne

Pour aligner des éléments sur **un axe** : un menu, une barre d'outils.

```css
header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  gap: 1rem;
}
```

| Propriété | Rôle |
| --- | --- |
| `display: flex` | Les enfants se placent côte à côte |
| `justify-content` | Répartition le long de l'axe : `flex-start`, `center`, `space-between` |
| `align-items` | Alignement dans l'autre sens |
| `gap` | Espace entre les éléments |
| `flex-direction: column` | Empile au lieu d'aligner |

### Grid : en lignes et colonnes

Pour une disposition sur **deux axes** : une galerie, une page avec une barre latérale.

```css
.cards {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 1rem;
}
```

Trois colonnes de même largeur. La page d'accueil de la documentation du jeu dispose ses cartes ainsi.

## S'adapter à l'écran

Une **requête média** applique des règles selon la largeur de la fenêtre.

```css
.cards {
  display: grid;
  grid-template-columns: 1fr;
  gap: 1rem;
}

@media (min-width: 640px) {
  .cards {
    grid-template-columns: repeat(3, 1fr);
  }
}
```

Une colonne sur téléphone, trois à partir de 640 pixels. On écrit d'abord le cas du petit écran, puis on enrichit : c'est l'approche *mobile first*.

## Les variables

Une couleur répétée vingt fois dans un fichier est un [nombre magique](/python/bonnes-pratiques/nommage), comme `page == 5` dans le jeu. CSS a des variables.

```css
:root {
  --bg: #14161a;
  --accent: #e0b23c;
}

body {
  background: var(--bg);
}
```

## Le style du classement

Le fichier `web/style.css`, pour la page du cours HTML.

```css
* {
  box-sizing: border-box;
}

:root {
  --bg: #14161a;
  --surface: #1d2026;
  --border: #2a2e37;
  --text: #e8e6e3;
  --muted: #8a8f98;
  --accent: #e0b23c;
}

body {
  margin: 0;
  background: var(--bg);
  color: var(--text);
  font-family: system-ui, sans-serif;
  line-height: 1.5;
}

header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 1rem 1.5rem;
  border-bottom: 1px solid var(--border);
}

header h1 {
  margin: 0;
  font-size: 1.25rem;
}

nav {
  display: flex;
  gap: 1rem;
}

nav a {
  color: var(--muted);
  text-decoration: none;
}

nav a:hover {
  color: var(--accent);
}

main {
  max-width: 40rem;
  margin: 0 auto;
  padding: 1.5rem;
}

.scores {
  width: 100%;
  border-collapse: collapse;
  background: var(--surface);
}

.scores caption {
  padding: 0.5rem 0;
  color: var(--muted);
  text-align: left;
}

.scores th,
.scores td {
  padding: 0.6rem 1rem;
  border-bottom: 1px solid var(--border);
  text-align: left;
}

.scores th {
  color: var(--muted);
  font-weight: 600;
}

.scores .first td {
  color: var(--accent);
  font-weight: 700;
}

footer {
  padding: 1.5rem;
  color: var(--muted);
  text-align: center;
}

@media (max-width: 480px) {
  header {
    flex-direction: column;
    gap: 0.5rem;
  }
}
```

Ce qu'il faut y remarquer :

- toutes les couleurs sont définies une fois, dans `:root` ;
- `max-width` et `margin: 0 auto` centrent le contenu et limitent la longueur des lignes ;
- aucun `id`, aucun `!important` : uniquement des balises et des classes ;
- le fichier HTML n'a pas changé d'une ligne.

## Déboguer

L'inspecteur du navigateur montre, pour l'élément sélectionné, toutes les règles qui s'y appliquent. Celles qui ont perdu la cascade sont barrées. On peut y modifier une valeur et voir le résultat aussitôt.

| Symptôme | Cause fréquente |
| --- | --- |
| La règle n'a aucun effet | Faute dans le sélecteur, ou fichier CSS non chargé |
| La règle est barrée dans l'inspecteur | Une règle plus précise gagne |
| L'élément dépasse de son parent | `box-sizing` absent, largeur fixe en pixels |
| Rien ne bouge après une modification | Le navigateur a gardé l'ancien fichier. Recharger sans le cache |

## Et les outils comme Tailwind ?

Dans la page d'accueil de la documentation du jeu, `introduction.mdx`, les cartes portent des classes comme `grid grid-cols-1 sm:grid-cols-2 gap-4`. C'est Tailwind : une bibliothèque de petites classes toutes faites, chacune équivalente à une ou deux déclarations CSS. `grid` vaut `display: grid`, `gap-4` vaut `gap: 1rem`, et `sm:` correspond à une requête média.

Ces outils ne remplacent pas CSS : ils en sont un raccourci. On ne s'en sert bien qu'en sachant ce qu'ils écrivent à notre place.

## À retenir

- Une règle : un sélecteur, des déclarations.
- En cas de conflit, la règle la plus précise gagne, puis la dernière écrite.
- Viser des classes, éviter `id` et `!important`.
- `box-sizing: border-box` en haut du fichier.
- Flexbox pour une ligne, grid pour une grille.
- Les couleurs et tailles répétées vont dans des variables.

## Exercices

1. Créer `web/style.css` et vérifier que la page change sans avoir touché à `index.html`.
2. Colorer une ligne sur deux du tableau avec `nth-child`.
3. Changer toute la palette en ne modifiant que le bloc `:root`.
4. Ajouter un thème clair avec `@media (prefers-color-scheme: light)`, en redéfinissant seulement les variables.
5. Ajouter au-dessus du tableau trois cartes de statistiques, disposées en grille : une colonne sur téléphone, trois sur grand écran.
6. Écrire deux règles en conflit sur la couleur des cellules, prédire laquelle gagne, puis vérifier dans l'inspecteur.
