Chessistics/docs/GDD_prototype.md

# Chessistics — Game Design Document (Prototype)

> "Et si la logistique etait contrainte par les echecs ?"

**Version** : 0.3 — Prototype
**Scope** : 3 niveaux jouables, mecaniques de base uniquement

---

## 1. Vision

Chessistics est un jeu de logistique ou le joueur construit des chaines de transport sur un damier. Les unites de transport sont des pieces d'echecs : chacune fait un unique aller-retour entre deux cases, selon ses regles de mouvement. Le joueur assemble des pieces bout a bout pour former des convois qui acheminent des cargaisons des productions vers les demandes.

Chaque piece est un **maillon de convoyeur**. La strategie est dans la composition des chaines : quelles pieces, ou, dans quel ordre. Les contraintes de mouvement des echecs creent des puzzles de routage emergents — le joueur n'a pas a les "resoudre" explicitement, il developpe une intuition pour les forces de chaque piece.

**Core loop** :

```
OBSERVER la situation (productions, demandes, terrain, pieces disponibles)
    |
PLACER des pieces sur le plateau (point de depart + point d'arrivee)
    |
LANCER la simulation — les pieces font leurs allers-retours,
les colis se transmettent automatiquement entre pieces adjacentes
    |
    +---> Le debit est insuffisant ? Observer les goulets, reorganiser
    +---> Le debit est atteint ? Optimiser ou niveau suivant
```

**Ce qui distingue Chessistics** :
- La logistique (macro) : le joueur compose des chaines, choisit sa flotte, gere l'espace
- Le puzzle chess (micro) : les contraintes de mouvement creent des enigmes de couverture et d'espacement emergentes
- Le systeme de transfert automatique + statut social elimine toute programmation — le joueur pense reseau, pas code

---

## 2. Le plateau

### 2.1 La grille

Le plateau est un damier avec des cases claires et sombres alternees. Chaque case est identifiee par des coordonnees (colonne, ligne) : a1, b2, etc.

**Taille par niveau** :
- Niveaux tutoriels : 4x4 a 6x6
- Niveaux standard (post-proto) : 8x8+

### 2.2 Types de cases

| Case | Visuel | Effet |
|------|--------|-------|
| **Case claire** | Carre clair du damier | Traversable normalement |
| **Case sombre** | Carre sombre du damier | Traversable (les Fous sont limites a une couleur) |
| **Mur** | Case barree, gris fonce | Bloque toutes les pieces sauf le Cavalier (qui saute) |
| **Production** | Icone ressource + nom (ex: "Scierie") | Produit 1 cargaison tous les N coups. Donne automatiquement a une piece adjacente disponible. |
| **Demande** | Icone cible + nom (ex: "Depot") + jauge | Recoit la cargaison d'une piece adjacente qui arrive avec un colis compatible. |

### 2.3 Cargaison

Pour le prototype, deux types de cargaison (le niveau 3 en utilise deux, les niveaux 1-2 un seul) :
- **Bois** (icone buche, couleur brune)
- **Pierre** (icone bloc, couleur grise)

Une piece ne peut porter qu'**une cargaison a la fois**.

---

## 3. Les pieces

### 3.1 Concept fondamental : 1 piece = 1 maillon

Chaque piece fait un **unique mouvement** en aller-retour perpetuel entre deux cases :

```
Coup 1: [Depart] ═══► [Arrivee]    (transporte le colis si elle en a un)
Coup 2: [Depart] ◄═══ [Arrivee]    (revient a vide ou avec un colis)
Coup 3: [Depart] ═══► [Arrivee]    (repart)
...a l'infini
```

Le joueur place une piece en choisissant :
1. Sa **case de depart**
2. Sa **case d'arrivee** (parmi les cases atteignables en 1 mouvement legal)

C'est tout. Pas de programmation, pas de route multi-etapes. La piece fait l'aller-retour automatiquement.

### 3.2 Pieces disponibles dans le prototype

3 types, niveau unique :

#### Tour (niveau II)

```
        X
        X
  X X [Tour] X X
        X
        X
```

- Se deplace de **1 ou 2 cases** en ligne droite (horizontal ou vertical)
- Ne peut pas traverser les murs ni les autres pieces
- Statut social : **5**

#### Fou (niveau II)

```
  X           X
    X       X
      [Fou]
    X       X
  X           X
```

- Se deplace de **1 ou 2 cases** en diagonale
- Ne peut atteindre que les cases de sa couleur de depart (parite)
- Ne peut pas traverser les murs ni les autres pieces
- Statut social : **3**

#### Cavalier

```
    X   X
  X       X
    [Cav]
  X       X
    X   X
```

- Se deplace en **L** (2+1 ou 1+2 cases)
- **Saute par-dessus** les murs et les autres pieces
- Statut social : **3**

> A statut egal (Fou et Cavalier = 3), la piece la plus proche de la production a la priorite. Si egalite parfaite, la piece la plus anciennement placee a la priorite.

### 3.3 Occupation et blocage

- Chaque piece **occupe sa case actuelle** (depart ou arrivee selon le coup)
- Une piece bloque le passage des autres pieces (sauf le Cavalier qui saute)
- Deux pieces ne peuvent **jamais** occuper la meme case au meme coup

---

## 4. Systeme de transfert

### 4.1 Le principe

Les colis se transmettent **automatiquement** entre entites adjacentes (4-connecte : haut, bas, gauche, droite). Le joueur ne gere pas les transferts — il gere l'espace.

Les transferts se produisent entre :
- **Production → Piece** : la production donne a une piece adjacente sans colis
- **Piece → Piece** : une piece avec colis donne a une piece adjacente sans colis
- **Piece → Demande** : une piece avec colis compatible donne a une demande adjacente

### 4.2 Quand le transfert a lieu

Un transfert se produit quand, a la **fin d'un coup** (une fois que toutes les pieces ont bouge) :
- Une entite avec colis et une entite sans colis (ou une demande) sont sur des **cases adjacentes** (4-connecte)
- Le colis est compatible (la demande accepte ce type de cargaison)

Le transfert est **instantane** : le colis passe d'une entite a l'autre entre deux coups.

### 4.3 Priorite par statut social

Quand plusieurs transferts sont possibles au meme point, le **statut social** determine l'ordre :

**Regle de don** : parmi les pieces avec colis adjacentes a un meme receveur, celle de **statut le plus eleve donne en premier**.

**Regle de reception** : parmi les pieces sans colis adjacentes a un meme donneur, celle de **statut le plus eleve recoit en premier**.

```
Hierarchie de statut social (proto) :
  Tour      5
  Fou       3
  Cavalier  3
```

**Exemple** :
```
  Tour (colis) ─adjacent─ case vide ─adjacent─ Cavalier (vide)
                                     ─adjacent─ Tour (vide)
```
La Tour avec colis donne. Deux receveurs possibles : Cavalier (3) et Tour (5). La Tour recoit (statut 5 > 3).

### 4.4 Pourquoi c'est un outil de design

Le statut social n'est pas une regle abstraite — c'est un **outil de routage** pour le joueur :

- Aux croisements, le joueur choisit le TYPE de piece pour controler ou va le colis
- Une Tour "capte" un colis avant un Cavalier — le joueur met une Tour sur la route prioritaire
- Un Cavalier sur une route secondaire ne prend que les colis que personne d'autre ne veut

Le joueur n'ecrit pas de logique conditionnelle. Il **compose sa flotte** pour que le flux aille ou il veut.

### 4.5 Le puzzle d'espacement

Les pieces qui ne doivent PAS interagir doivent etre **espacees d'au moins 2 cases**. Sinon un transfert involontaire se produit.

```
PROBLEME — deux chaines trop proches, les colis se melangent :

  ──Tour A──►    ◄──Tour B──    (chaine 1 : bois)
  ──Tour C──►    ◄──Tour D──    (chaine 2 : pierre)
              ↕ adjacentes = transfert involontaire !

SOLUTION — espacer les chaines :

  ──Tour A──►    ◄──Tour B──    (chaine 1)
  .  .  .  .  .  .  .  .        (1 case d'ecart)
  ──Tour C──►    ◄──Tour D──    (chaine 2)
```

Gerer l'espace sur le plateau pour eviter les interferences EST le puzzle. Le joueur doit router ses chaines en tenant compte des contraintes de mouvement (echecs) ET de l'espacement (logistique).

---

## 5. Deroulement d'un coup

### 5.1 Sequence d'un coup

A chaque coup, dans cet ordre :

```
1. MOUVEMENT : toutes les pieces bougent simultanement
   (chaque piece avance de Depart→Arrivee ou de Arrivee→Depart)

2. DETECTION DE COLLISION : si deux pieces sont sur la meme case → erreur

3. TRANSFERTS : tous les transferts automatiques se resolvent
   (productions → pieces, pieces → pieces, pieces → demandes)
   En respectant l'ordre de statut social

4. PRODUCTION : les cases de production generent un colis
   (si elles n'en ont pas deja un en attente)
```

### 5.2 Collisions

Deux pieces ne peuvent pas occuper la meme case au meme coup. Si cela arrive :
- Les deux pieces clignotent en rouge
- La simulation se met en **pause**
- Le joueur doit reorganiser ses pieces (revenir en mode edition)

Les collisions sont le signal que les chaines sont mal agencees. Le joueur doit repenser l'espacement ou le timing (pieces de portees differentes arrivent a des moments differents).

### 5.3 Condition de victoire

Le niveau est reussi quand **toutes les demandes** ont ete satisfaites selon leur objectif.

Chaque demande specifie : "recevoir N colis de type X en Y coups ou moins".

Exemple : "Le Depot Royal demande 3 livraisons de Bois en 30 coups."

Le compteur de coups tourne en temps reel. Le joueur voit sa progression.

---

## 6. Les metriques

A la completion d'un niveau, 3 metriques sont affichees :

| Metrique | Description | Ce que ca mesure |
|----------|-------------|------------------|
| **Pieces** | Nombre de pieces deployees | Economie de flotte |
| **Coups** | Nombre de coups pour atteindre l'objectif | Efficacite du reseau |
| **Espace** | Nombre de cases du plateau utilisees (occupees par une piece au moins 1 coup) | Compacite du reseau |

Chaque metrique a un **histogramme** montrant la distribution des solutions de tous les joueurs.

> **Proto** : histogrammes avec donnees fictives pour tester l'UI.

**Triangle d'optimisation** :
- Moins de pieces = chaines courtes = couverture limitee → plus de coups
- Moins de coups = pieces puissantes ou nombreuses → plus de pieces, plus d'espace
- Moins d'espace = chaines compactes = risque d'interferences → plus difficile a router

**Affichage en jeu** (pendant la simulation) :
```
  Coup: 12/30    Depot Royal: 2/3 Bois ✓    Forge: 0/2 Pierre ✗
```

---

## 7. Interface utilisateur

### 7.1 Ecran de jeu — layout

Le plateau est le centre. L'interface est minimale.

```
+---------------------------------------------------------------+
|  CHESSISTICS        La Scierie Royale           [≡]  [?]  [←] |
+---------------------------------------------------------------+
|                                              |                 |
|                                              |  OBJECTIF        |
|                                              |  Depot Royal     |
|                                              |  3x Bois / 30c  |
|           P L A T E A U                      |                 |
|         (damier interactif)                  |  ─────────       |
|                                              |                 |
|    Les pieces et leurs trajets               |  PIECES          |
|    sont visibles sur le plateau              |  [Tour II]  x3   |
|                                              |  [Fou II]   x1   |
|                                              |  [Cavalier] x1   |
|                                              |                 |
+---------------------------------------------------------------+
|  [▶ PLAY]  [⏩ x2]  [⏸]  [⏹ STOP]     Coup: --      |
+---------------------------------------------------------------+
```

### 7.2 Placement d'une piece

Le flux de placement est en 2 clics :

1. Le joueur **selectionne un type de piece** dans le panneau de droite
2. Il **clique une case du plateau** → c'est le point de depart. Les cases d'arrivee possibles s'affichent en surbrillance.
3. Il **clique une case en surbrillance** → c'est le point d'arrivee. La piece est placee.
4. Un trait apparait entre depart et arrivee, montrant le trajet.

```
  Placement d'une Tour II :

  1. Clic sur (a1)         2. Cases atteignables      3. Clic sur (c1)
                               en surbrillance

  .  .  .  .               .  .  .  .                .  .  .  .
  .  .  .  .               .  .  .  .                .  .  .  .
  .  .  .  .               [.][.] .  .                .  .  .  .
  [T] .  .  .              [T][■][■] .                [T]══════[·]
                            ^  a1 a2                   a1       c1
                            haut1 haut2 aussi
```

**Interactions** :
- **Clic sur une piece placee** → la selectionne, affiche son trajet, panneau de detail
- **Clic droit sur une piece** → la retire du plateau (retourne dans le stock)
- **Glisser une piece** → deplace son point de depart (recalcule les arrivees possibles)

### 7.3 Visualisation des trajets

Chaque piece placee affiche son trajet sur le plateau :
- **Trait** semi-transparent entre depart et arrivee (couleur unique par piece)
- **Fleches** indiquant le sens du mouvement
- La piece **oscille** visuellement entre ses deux cases pendant la simulation

Quand plusieurs chaines sont en place, le joueur voit le reseau complet :

```
  [S]═══Tour A═══[·]  [·]═══Tour B═══[·]  [·]═══Tour C═══[D]
   Scierie         relais              relais              Depot
```

### 7.4 Panneau de detail (contextuel)

Quand une piece est selectionnee :

```
+---------------------------+
| TOUR A (Tour II)          |
| Trajet: a1 ↔ c1 (2 cases)|
| Statut social: 5          |
| Porte: [Bois]             |
| [Retirer]                 |
+---------------------------+
```

### 7.5 Phases de jeu

**Phase EDIT** (temps arrete)
- Placer, deplacer, retirer des pieces
- Pas de limite de temps
- Les trajets sont visibles comme des traits sur le plateau

**Phase EXEC** (simulation)
- Les pieces font leurs allers-retours simultanement
- Les colis se transmettent automatiquement aux points de contact
- Compteur de coups et progression des objectifs en temps reel
- Controles : pause, step-by-step, vitesse x1/x2/x4, stop (retour a EDIT)
- En cas de collision → pause auto, pieces en erreur surlignees

Le joueur peut arreter la simulation a tout moment, reorganiser, et relancer.

### 7.6 Feedback visuel

**Pieces** :
- Glissement fluide d'une case a l'autre (~0.3s)
- Cavalier : arc leger pendant le saut (~0.4s)
- Cargaison visible sur la piece (petit cube colore au-dessus)
- Piece sans colis = silhouette normale. Piece avec colis = silhouette + cube.

**Transferts** :
- Quand un colis passe d'une piece a l'autre : animation de "lancer-rattraper" entre les deux (le cube glisse d'une piece a l'autre, ~0.2s)
- Flash subtil sur le receveur

**Productions et demandes** :
- Les productions **pulsent** quand elles generent un colis
- Les demandes ont une **jauge** de progression (ex: "2/3")
- Jauge verte = objectif atteint. Jauge rouge = pas encore.

**Erreurs** :
- Collision : flash rouge + shake des deux pieces
- Simulation en pause automatiquement

**Victoire** :
- Toutes les jauges au vert → animation sobre (les trajets scintillent en dore)
- Overlay des metriques + histogrammes

---

## 8. Les 3 niveaux du prototype

### Niveau 1 — "Premier Convoi"

**Intention** : apprendre a placer une piece et voir la chaine fonctionner. Le joueur decouvre que les pieces sont des maillons.

```
  4  .  .  .  .
  3  .  .  .  .
  2  .  .  .  .
  1 [S] .  .  [D]

     a  b  c  d
```

- Plateau : **4x4**
- S = Scierie (a1, produit du Bois tous les 2 coups)
- D = Depot Royal (d1, objectif : recevoir 3 Bois en 30 coups)
- Pieces disponibles : **3x Tour II**

**Le probleme** :
La Scierie est en a1, le Depot en d1. Distance : 3 cases. Une Tour II ne se deplace que de 2 cases max. **Aucune piece seule ne peut couvrir le trajet.**

Le joueur doit enchainer 2 Tours minimum :
```
  [S]═══Tour A═══[·]───Tour B───[D]
   a1             c1              d1
        (2 cases)     (1 case)
```

Tour A : a1 ↔ c1 (2 cases). Tour B : c1 ↔ d1 (1 case).

Mais c1 est l'arrivee de Tour A ET le depart de Tour B. Les deux pieces se croisent en c1 → le colis se transmet automatiquement.

**Probleme** : Tour A et Tour B ne peuvent pas etre sur c1 au meme coup (collision). Le joueur decouvre que les pieces doivent etre **decalees** :
- Tour A est en a1 → Tour B est en d1 (pas de conflit)
- Tour A avance en c1 → Tour B avance en c1 → **collision !**

**Solution** : Tour A couvre a1↔c1, Tour B couvre **d1↔c1** (meme case mais direction opposee). Coup 1 : A va en c1, B va en c1 → collision. Il faut decaler.

**Vraie solution** : Tour A couvre a1↔b1 (1 case). Tour B couvre b1↔d1 (2 cases). Decales dans le temps, ils ne sont jamais sur b1 en meme temps car A est en b1 quand B est en d1, et inversement.

Ou : Tour A couvre a1↔c1 (2 cases), Tour B couvre c1↔d1 (1 case). Ils ne sont jamais sur c1 ensemble si les arrivees alternent. A verifier dans la simulation.

> **Note de design** : ce premier niveau est volontairement simple en apparence mais contient deja le puzzle fondamental du jeu — l'espacement et le timing des maillons. Si le joueur place naïvement, ca collisionne. Il apprend en observant.

**Objectif pedagogique** :
- Placer une piece (2 clics : depart + arrivee)
- Comprendre qu'une piece = un maillon, pas un convoi complet
- Decouvrir le transfert automatique entre pieces adjacentes
- Premiere rencontre avec le probleme de collision/timing

---

### Niveau 2 — "Deux Clients"

**Intention** : premier choix logistique. Le joueur decide comment organiser 2 chaines a partir d'une seule source.

```
  6  .  .  .  .  .  .
  5  .  .  .  .  . [D2]  Caserne — 2 Bois en 30 coups
  4  .  .  .  .  .  .
  3  .  .  .  .  .  .
  2  .  .  .  .  .  .
  1 [S] .  .  .  . [D1]  Depot Royal — 2 Bois en 30 coups

     a  b  c  d  e  f
```

- Plateau : **6x6**
- S = Scierie (a1, produit du Bois tous les 2 coups)
- D1 = Depot Royal (f1, objectif : 2 Bois en 30 coups)
- D2 = Caserne (f5, objectif : 2 Bois en 30 coups)
- Pieces disponibles : **4x Tour II, 1x Fou II**

**L'enjeu** :
- S→D1 : 5 cases en ligne droite. Faisable avec une chaine de Tours.
- S→D2 : trajet en angle (droite + haut). Plusieurs routes possibles.
- La Scierie ne produit qu'un colis tous les 2 coups. Les deux chaines partagent la meme source.
- Le joueur doit decider : comment repartir les colis entre les deux destinations ?

**Le statut social entre en jeu** :
Si le joueur place une Tour (statut 5) vers D1 et un Fou (statut 3) vers D2, tous deux adjacents a la Scierie → la Tour recoit le colis en priorite. D1 est servie en premier, D2 attend.

Le joueur peut inverser la priorite en mettant le Fou vers D1 et la Tour vers D2.

Ou il espace ses chaines pour que chaque direction ait son propre premier maillon adjacent a la Scierie, et alterne naturellement.

**Le Fou en diagonale** :
Le Fou peut couvrir des trajets diagonaux que les Tours ne peuvent pas. Pour atteindre D2 (f5), une route diagonale via le Fou pourrait etre plus courte. Mais le Fou ne peut atteindre que les cases de sa couleur — le joueur decouvre cette contrainte par l'experimentation.

**Objectif pedagogique** :
- Premiere decision logistique : repartir le flux
- Decouvrir le statut social comme outil de routage
- Decouvrir la contrainte de parite du Fou
- Gerer deux chaines simultanees partageant une source
- **Sensation de "je concois MON reseau"**

---

### Niveau 3 — "Le Col"

**Intention** : un vrai reseau avec terrain, 2 types de cargaison, et le Cavalier comme solution aux obstacles.

```
  6 [D2] .  .  .  . [D1]   Depot Royal — 2 Bois en 40 coups
  5  .  .  #  #  #  .      Forge — 2 Pierre en 40 coups
  4  .  .  #  .  .  .
  3  .  .  #  .  .  .
  2  .  .  .  .  .  .
  1 [S1] .  .  .  . [S2]   Scierie (Bois)
                            Carriere (Pierre)
     a  b  c  d  e  f
```

- Plateau : **6x6**
- S1 = Scierie (a1, Bois, tous les 2 coups)
- S2 = Carriere (f1, Pierre, tous les 2 coups)
- D1 = Depot Royal (f6, objectif : 2 Bois en 40 coups)
- D2 = Forge (a6, objectif : 2 Pierre en 40 coups)
- Murs : c3, c4, c5, d5, e5 (barriere en L)
- Pieces disponibles : **4x Tour II, 1x Fou II, 2x Cavalier**

**L'enjeu logistique** :

Le mur en L coupe le plateau. Les deux routes (S1→D1 et S2→D2) traversent le plateau en diagonale et doivent contourner ou franchir le mur.

**Route S1(Bois) → D1(Depot)** : a1 → f6
- Par le bas : a1→f1→f6. Chaine de Tours le long du bord. Long mais faisable.
- Via le Cavalier : le Cavalier saute le mur. Plus court mais statut social 3, il perd la priorite face aux Tours.

**Route S2(Pierre) → D2(Forge)** : f1 → a6
- Meme probleme en miroir, sens inverse.
- Les deux routes se **croisent** → risque de transferts involontaires !

**Le puzzle de croisement** :
Si les chaines Bois et Pierre passent par les memes cases intermediaires, les colis risquent de partir dans la mauvaise direction. Le joueur doit :
- Soit **espacer** les chaines (routes differentes, chaines separees)
- Soit utiliser le **statut social** pour diriger les colis (une Tour capte avant un Cavalier)
- Soit **decaler temporellement** les chaines (pieces de portees differentes)

**Le Cavalier comme pont** :
Le Cavalier saute le mur en L. Il peut connecter les deux cotes du plateau la ou les Tours et Fous sont bloques. C'est la piece "speciale" de ce niveau — chere en slot mais indispensable pour certaines routes.

**Objectif pedagogique** :
- 2 types de cargaison = flux separes a ne pas melanger
- Le mur force des choix de flotte non triviaux
- Le Cavalier comme outil unique (saut)
- Le puzzle de croisement : gerer les interferences entre chaines
- **Le joueur sent qu'il gere un reseau de transport complet**

---

## 9. Direction artistique (prototype)

Le prototype vise la lisibilite.

**Palette** :
- Damier : beige clair (#F0D9B5) / brun (#B58863)
- Murs : gris fonce (#555555)
- Productions : vert doux avec pulsation
- Demandes : or/jaune avec jauge
- Trajets : couleur unique par piece (bleu, rouge, violet, orange)
- Fond : gris neutre (#2D2D2D)

**Pieces** :
- Silhouettes 2D classiques des pieces d'echecs (vectorielles)
- Couleur correspondant au trajet
- Cargaison = petit cube colore au-dessus (brun = Bois, gris = Pierre)

**Trajets sur le plateau** :
- Trait semi-transparent entre depart et arrivee
- Fleches directionnelles
- Le trait pulse legerement quand la piece est en mouvement

**Animations** :
- Tour/Fou : glissement lineaire (~0.3s)
- Cavalier : arc de saut (~0.4s)
- Transfert de colis : le cube glisse d'une piece a l'autre (~0.2s)
- Collision : flash rouge + shake
- Victoire : trajets scintillent en dore

---

## 10. Choix technique : Godot 4 + C#

### Pourquoi Godot 4

| Critere | Godot 4 | MonoGame |
|---------|---------|----------|
| Licence | MIT (libre) | MIT (libre) |
| Langage | C# (.NET) | C# (.NET) |
| Systeme UI | Nodes Control natifs | A construire from scratch |
| TileMap | Integre | A implementer |
| Tweens | Natifs | A implementer |
| Export | Win, Linux, Mac, Web | Win, Linux, Mac |

### Architecture suggeree

```
Chessistics/
  scenes/
    Main.tscn
    Board/
      Board.tscn             — Le damier
      Cell.tscn              — Une case
    Pieces/
      Piece.tscn             — Scene piece (silhouette + cube cargaison)
      TrajectView.tscn       — Trait visuel du trajet (Line2D)
    UI/
      ObjectivePanel.tscn    — Objectifs + stock de pieces
      DetailPanel.tscn       — Detail piece selectionnee
      ControlBar.tscn        — Play / pause / stop / vitesse
      MetricsOverlay.tscn    — Resultats post-victoire
      LevelSelect.tscn       — Selection de niveau
  scripts/
    Core/
      Board.cs               — Grille, cases, adjacence
      Cell.cs                — Type de case, contenu
      Piece.cs               — Type, statut, mouvement, cargaison
      PieceType.cs           — Enum + regles de mouvement + statut social
      TransferResolver.cs    — Logique de transfert (adjacence, priorite, statut)
      Executor.cs            — Moteur de simulation (coups, collisions, transferts)
    Data/
      Level.cs               — Definition d'un niveau
      LevelLoader.cs         — Chargement JSON
    UI/
      PiecePlacer.cs         — Logique du placement 2 clics
      ControlBar.cs          — Play/pause/stop/vitesse
      ProgressDisplay.cs     — Compteur de coups + progression objectifs
  data/
    levels/
      level_01.json
      level_02.json
      level_03.json
```

### Format d'un niveau (JSON)

```json
{
  "id": 1,
  "name": "Premier Convoi",
  "description": "Acheminez du bois de la scierie au depot.",
  "width": 4,
  "height": 4,
  "productions": [
    { "x": 0, "y": 0, "name": "Scierie", "cargo": "wood", "interval": 2 }
  ],
  "demands": [
    { "x": 3, "y": 0, "name": "Depot Royal", "cargo": "wood", "amount": 3, "deadline": 30 }
  ],
  "walls": [],
  "pieces": [
    { "type": "rook", "level": 2, "count": 3 }
  ]
}
```

---

## 11. Risques et questions ouvertes

| Question | Options | Decision proto |
|----------|---------|----------------|
| Adjacence pour transfert ? | 4-connecte (bords) vs 8-connecte (bords + coins) | **4-connecte** — plus de contrainte = plus de puzzle |
| La piece tourne a vide ? | Oui (aller-retour permanent) vs attend un colis | **Oui, tourne en permanence** — plus visuel, plus simple |
| Collision = erreur stricte ? | Stricte (pause) vs tolerante | **Stricte** — le joueur voit et corrige. Plus simple a implementer. |
| Sources infinies ? | Oui (production periodique sans stock) vs stock limite | **Production periodique infinie** — le proto teste le reseau, pas la gestion de stock |
| Pieces fixes par niveau ? | Fixes (catalogue impose) vs achat libre | **Fixes** — plus facile a designer. L'achat/fabrication est post-proto. |
| Egalite de statut social ? | Proximite > anciennete | **Proximite puis anciennete** — intuitif, pas de regle arbitraire |