Merge branch 'cp/change_app_architecture'

.gitignore

@@ -23,6 +23,10 @@ wheels/
 .installed.cfg
 *.egg
 
+# Node
+node_modules/
+package-lock.json
+
 # Environment
 .env
 .venv

CHANGELOG.md

@@ -0,0 +1,86 @@
+# Changelog
+
+## [2.0.0] - 2025-10-05
+
+### ✨ Nouvelles Fonctionnalités
+
+#### Interface de Jeu
+- ✅ **Grille d'enquête interactive** - Système de notation avec statuts (✅ Mes cartes, ❌ Éliminé, ❓ Peut-être, ⬜ Inconnu)
+- ✅ **Plateau de jeu visuel** - Affichage graphique du plateau avec positions des joueurs
+- ✅ **Système de dés** - Lancer de dés et déplacement circulaire sur le plateau
+- ✅ **Narrateur IA Desland** - Commentaires sarcastiques en temps réel sur les actions des joueurs
+
+#### Architecture
+- ✅ **Plateau personnalisable** - Modèle BoardLayout avec disposition des salles sur grille
+- ✅ **Support React complet** - Migration vers React + Vite + TailwindCSS
+- ✅ **Build Docker multi-stage** - Frontend build + Backend Python optimisé
+
+#### Composants Frontend
+- `InvestigationGrid.jsx` - Grille interactive pour noter les déductions
+- `GameBoard.jsx` - Affichage visuel du plateau de jeu
+- `AINavigator.jsx` - Panneau du narrateur IA avec historique
+
+#### Backend
+- Support plateau de jeu dans modèles (BoardLayout, RoomPosition)
+- Intégration IA dans endpoints `/suggest` et `/accuse`
+- Génération automatique layout par défaut
+
+### 🎨 Améliorations UI/UX
+- Thème hanté avec animations et effets de brouillard
+- Interface immersive avec palette de couleurs cohérente
+- Affichage temps réel des positions des joueurs
+- Historique des actions visible
+
+### 🤖 Desland - Narrateur IA
+
+#### Personnalité
+- Sarcastique et incisif
+- Se moque des théories absurdes
+- Confusion récurrente sur son nom (Leland → Desland)
+- Commentaires courts et mémorables
+
+#### Exemples de commentaires
+```
+"Et toi ça te semble logique que Pierre ait tué Daniel avec une clé USB
+à côté de l'étendoir ?? Sans surprise c'est pas la bonne réponse..."
+
+"Une capsule de café ? Brillant. Parce que évidemment, on commet des
+meurtres avec du Nespresso maintenant."
+```
+
+#### Configuration
+- gpt-5-nano avec température 0.9
+- Timeout 3 secondes
+- Fallback gracieux si indisponible
+
+### 🔧 Technique
+
+#### Stack
+- **Frontend**: React 18, Vite, TailwindCSS
+- **Backend**: FastAPI, Python 3.11
+- **IA**: OpenAI gpt-5-nano (optionnel)
+- **Build**: Docker multi-stage
+
+#### Endpoints ajoutés
+- Board layout dans game state
+- AI comments dans suggestions/accusations
+
+### 🐛 Corrections
+- Fix imports backend pour Docker
+- Amélioration état du jeu (current_turn)
+- Correction affichage plateau
+
+### 📝 Documentation
+- README complet en français
+- Guide de déploiement Docker
+- Documentation API endpoints
+- Exemples Desland
+
+---
+
+## [1.0.0] - Initial Release
+
+- Création de partie basique
+- Système de suggestions/accusations
+- Multi-joueurs (3-8 joueurs)
+- Thèmes prédéfinis (Classique, Bureau, Fantastique)

Dockerfile

@@ -1,27 +1,27 @@
-# Use Python 3.11 slim image for smaller size
-FROM python:3.11-slim
+# Stage 1: Build frontend
+FROM node:18-alpine AS frontend-build
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build
 
-# Set working directory
+# Stage 2: Python backend
+FROM python:3.11-slim
 WORKDIR /app
 
-# Set environment variables
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PORT=7860
-
-# Install dependencies
-COPY requirements.txt .
+# Install backend deps
+COPY backend/requirements.txt ./
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application files
-COPY . .
+# Copy backend
+COPY backend/ ./backend/
 
-# Expose port
-EXPOSE 7860
+# Copy built frontend
+COPY --from=frontend-build /app/frontend/dist ./frontend/dist
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD python -c "import requests; requests.get('http://localhost:7860/')"
+# Expose port for Hugging Face
+EXPOSE 7860
 
-# Run the application
-CMD ["python", "app.py"]
+# Start server
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -18,290 +18,235 @@ tags:
   - openai
 ---
 
-# Cluedo Custom
+# 🕯️ Cluedo Custom - Jeu de Mystère Personnalisable
 
-A web-based custom Cluedo (Clue) game that transforms real-world locations into interactive murder mystery games. Players can create games with custom room names matching their physical environment and play together in real-time.
+Application web de Cluedo personnalisable avec narrateur IA sarcastique (Desland, le vieux jardinier). Transformez votre environnement réel en plateau de jeu interactif !
 
-## Features
+## ✨ Fonctionnalités
 
-- **Custom Room Setup**: Define your own rooms based on your real-world location (office, house, school, etc.)
-- **Multi-player Support**: Up to 8 players per game
-- **Real-time Gameplay**: Turn-based system with suggestions and accusations
-- **AI-Enhanced Narration** (Optional): Generate atmospheric scenarios and narration using OpenAI
-- **Mobile-First Interface**: Responsive design optimized for smartphone gameplay
-- **Easy Deployment**: Docker-ready and compatible with Hugging Face Spaces
+- ✅ **Plateau de jeu personnalisable** - Disposez vos salles sur une grille avec drag & drop
+- ✅ **Grille d'enquête interactive** - Cochez les possibilités éliminées (✅ Mes cartes, ❌ Éliminé, ❓ Peut-être)
+- ✅ **Système de dés et déplacement** - Déplacez-vous sur le plateau circulaire
+- ✅ **Suggestions et accusations** - Mécaniques de jeu Cluedo complètes
+- ✅ **Narrateur IA Desland** - Commentaires sarcastiques en temps réel sur vos actions
+- ✅ **Interface immersive** - Thème hanté avec animations et effets visuels
+- ✅ **Multi-joueurs** - 3-8 joueurs, synchronisation en temps réel
+- ✅ **Thèmes prédéfinis** - Classique (Manoir), Bureau, Fantastique
 
-## Quick Start
+## 🚀 Démarrage Rapide
 
-### Local Development
+### Avec Docker (Recommandé)
 
-1. **Clone the repository**
-   ```bash
-   git clone <repository-url>
-   cd custom-cluedo
-   ```
-
-2. **Install dependencies**
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-3. **Configure environment** (optional)
-   ```bash
-   cp .env.example .env
-   # Edit .env to configure settings
-   ```
-
-4. **Run the application**
-   ```bash
-   python app.py
-   ```
-
-5. **Access the interface**
-   Open your browser at `http://localhost:7860`
+```bash
+# Build l'image
+docker build -t custom-cluedo .
 
-### Docker Deployment
+# Lance l'application
+docker run -p 7860:7860 custom-cluedo
 
-1. **Build the Docker image**
-   ```bash
-   docker build -t cluedo-custom .
-   ```
+# Avec IA Desland activée
+docker run -p 7860:7860 \
+  -e USE_OPENAI=true \
+  -e OPENAI_API_KEY=your_key_here \
+  custom-cluedo
 
-2. **Run the container**
-   ```bash
-   docker run -p 7860:7860 cluedo-custom
-   ```
+# Accéder à l'application
+open http://localhost:7860
+```
 
-   Or with environment variables:
-   ```bash
-   docker run -p 7860:7860 \
-     -e USE_OPENAI=true \
-     -e OPENAI_API_KEY=your_key_here \
-     cluedo-custom
-   ```
+### Développement Local
 
-### Hugging Face Spaces Deployment
+#### Backend
+```bash
+cd backend
+pip install -r requirements.txt
+uvicorn backend.main:app --reload --port 8000
+```
 
-1. **Create a new Space**
-   - Go to [Hugging Face Spaces](https://huggingface.co/spaces)
-   - Click "Create new Space"
-   - Choose "Gradio" as the SDK
+#### Frontend
+```bash
+cd frontend
+npm install
+npm run dev  # Dev server on http://localhost:5173
+npm run build  # Build for production
+```
 
-2. **Upload files**
-   - Upload all project files to your Space
-   - Ensure `app.py` is the main entry point
+### Déploiement Hugging Face Spaces
 
-3. **Configure secrets** (for AI mode)
-   - Go to Settings → Repository secrets
-   - Add `OPENAI_API_KEY` if using AI features
+1. **Créer un nouveau Space**
+   - SDK: **Docker**
+   - Port: **7860**
 
-4. **Set environment variables** in Space settings:
+2. **Variables d'environnement** (Settings → Variables):
    ```
    USE_OPENAI=true
-   APP_NAME=Cluedo Custom
-   MAX_PLAYERS=8
+   OPENAI_API_KEY=<votre_clé>
    ```
 
-## Environment Variables
+3. **Push le code**
+   ```bash
+   git push
+   ```
 
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `APP_NAME` | Application name displayed in the interface | `Cluedo Custom` |
-| `MAX_PLAYERS` | Maximum number of players per game | `8` |
-| `USE_OPENAI` | Enable AI-generated content (true/false) | `false` |
-| `OPENAI_API_KEY` | OpenAI API key (required if USE_OPENAI=true) | `""` |
+## ⚙️ Configuration
 
-## How to Play
+| Variable | Description | Défaut |
+|----------|-------------|--------|
+| `USE_OPENAI` | Active le narrateur IA Desland | `false` |
+| `OPENAI_API_KEY` | Clé API OpenAI (si USE_OPENAI=true) | `""` |
+| `MAX_PLAYERS` | Nombre max de joueurs | `8` |
+| `MIN_PLAYERS` | Nombre min de joueurs | `3` |
 
-### 1. Create a Game
+## 🎮 Comment Jouer
 
-- Navigate to the "Create Game" tab
-- Enter a game name
-- List 6-12 room names that match your real-world location
-  - Example: `Kitchen, Living Room, Bedroom, Office, Garage, Garden`
-- Optionally enable AI narration
-- Click "Create Game" and share the Game ID with other players
+### 1. Créer une Partie
 
-### 2. Join a Game
+1. Entrez votre nom
+2. Cliquez sur **"🚪 Entrer dans le Manoir"**
+3. Un code de partie est généré (ex: `CBSB`)
+4. Partagez ce code avec vos amis
 
-- Navigate to the "Join Game" tab
-- Enter the Game ID provided by the game creator
-- Enter your player name
-- Click "Join Game"
+### 2. Rejoindre une Partie
 
-### 3. Start the Game
+1. Cliquez sur **"👻 Rejoindre une partie existante"**
+2. Entrez le code de partie
+3. Entrez votre nom
+4. Rejoignez !
 
-- Once all players have joined (minimum 3 players)
-- The game creator clicks "Start Game"
-- Cards are automatically distributed to all players
+### 3. Démarrer le Jeu
 
-### 4. Play Your Turn
+- Minimum **3 joueurs** requis
+- Le créateur clique sur **"🚀 Commencer l'enquête"**
+- Les cartes sont distribuées automatiquement
 
-- Navigate to the "Play" tab
-- Click "Refresh Game State" to see current status
-- When it's your turn:
-  - **Make a Suggestion**: Choose a character, weapon, and room. Other players will try to disprove it.
-  - **Make an Accusation**: If you think you know the solution. Warning: wrong accusations eliminate you!
-  - **Pass Turn**: Skip to the next player
+### 4. Jouer Votre Tour
 
-### 5. Win the Game
+Quand c'est votre tour :
 
-- The first player to make a correct accusation wins
-- Or be the last player standing if others are eliminated
+1. **🎲 Lancer les dés** - Déplacez-vous sur le plateau
+2. **💬 Suggérer** - Proposez un suspect + arme + salle
+   - Les autres joueurs tentent de réfuter
+3. **⚠️ Accuser** - Accusation finale (éliminé si faux !)
+4. **📋 Grille d'enquête** - Notez vos déductions
+   - Cliquez pour marquer : ✅ → ❌ → ❓ → ⬜
 
-## Game Rules
+### 5. Gagner
 
-### Setup
+- Premier à faire une accusation correcte gagne
+- Ou dernier joueur non-éliminé
 
-- Each game has:
-  - 6 default characters (Miss Scarlett, Colonel Mustard, Mrs. White, etc.)
-  - 6 default weapons (Candlestick, Knife, Lead Pipe, etc.)
-  - Custom rooms defined by the players
+## 🤖 Narrateur IA : Desland
 
-### Solution
+Activez `USE_OPENAI=true` pour les commentaires sarcastiques de Desland !
 
-- At the start, one character, one weapon, and one room are randomly selected as the secret solution
-- All other cards are distributed evenly among players
+### Personnalité de Desland
 
-### Gameplay
+> *"Je suis Leland... euh non, Desland. Le vieux jardinier de ce manoir maudit."*
 
-1. **Suggestions**:
-   - Player suggests a character, weapon, and room combination
-   - Other players (clockwise) try to disprove by showing one matching card
-   - Only the suggesting player sees the card shown
+- **Sarcastique** - Se moque des théories absurdes
+- **Incisif** - Commentaires tranchants et condescendants
+- **Suspicieux** - Semble en savoir plus qu'il ne dit
+- **Confus** - Se trompe souvent de nom (Leland → Desland)
 
-2. **Accusations**:
-   - Player makes a final accusation of the solution
-   - If correct: player wins immediately
-   - If incorrect: player is eliminated and cannot act further
+### Exemples de Commentaires
 
-3. **Victory**:
-   - First player with correct accusation wins
-   - If all others are eliminated, the last remaining player wins
+```
+"Et toi ça te semble logique que Pierre ait tué Daniel avec une clé USB
+à côté de l'étendoir ?? Sans surprise c'est pas la bonne réponse..."
 
-## AI Mode
+"Une capsule de café ? Brillant. Parce que évidemment, on commet des
+meurtres avec du Nespresso maintenant."
 
-When enabled (`USE_OPENAI=true`), the application generates:
+"Ah oui, excellente déduction Sherlock. Prochaine étape : accuser le
+chat du voisin."
+```
 
-- **Scenario Introduction**: Atmospheric setup describing the mystery in your chosen location
-- **Turn Narration** (optional): Brief narrative elements during gameplay
+### Configuration IA
 
-AI features use GPT-3.5-turbo with:
-- Low temperature for consistency
-- 3-second timeout per request
-- Graceful fallback if unavailable
+- Modèle: gpt-5-nano
+- Température: 0.9 (créativité élevée)
+- Timeout: 3 secondes max
+- Fallback gracieux si indisponible
 
-## Project Structure
+## 📁 Structure du Projet
 
 ```
 custom-cluedo/
-├── app.py              # Main application (Gradio interface)
-├── api.py              # FastAPI backend routes
-├── config.py           # Configuration and settings
-├── models.py           # Data models (Pydantic)
-├── game_engine.py      # Core game logic
-├── game_manager.py     # Game state management
-├── ai_service.py       # OpenAI integration
-├── requirements.txt    # Python dependencies
-├── Dockerfile          # Docker configuration
-├── .env.example        # Environment variables template
-└── README.md           # This file
-```
-
-## Technical Details
-
-### Backend
-
-- **FastAPI**: REST API for game management
-- **In-memory storage**: Games stored in memory with JSON persistence
-- **Pydantic models**: Type-safe data validation
-
-### Frontend
-
-- **Gradio**: Interactive web interface
-- **Mobile-optimized**: Responsive design with large touch targets
-- **Real-time updates**: Manual refresh for game state (polling-based)
-
-### Storage
-
-- Games are stored in `games.json` for persistence
-- Data is lost when container restarts (suitable for casual play)
-- No database required
-
-## API Endpoints
-
-- `GET /` - Health check
-- `POST /games/create` - Create new game
-- `POST /games/join` - Join existing game
-- `POST /games/{game_id}/start` - Start game
-- `GET /games/{game_id}` - Get full game state
-- `GET /games/{game_id}/player/{player_id}` - Get player-specific view
-- `POST /games/{game_id}/action` - Perform game action
-- `GET /games/list` - List active games
-- `DELETE /games/{game_id}` - Delete game
-
-## Limitations
-
-- Maximum 8 players per game (configurable)
-- Minimum 3 players to start
-- 6-12 custom rooms required
-- No persistent database (games reset on restart)
-- AI features require OpenAI API key and have rate limits
-
-## Development
-
-### Running Tests
-
-```bash
-# Install test dependencies
-pip install pytest pytest-asyncio
-
-# Run tests (when implemented)
-pytest
+├── backend/
+│   ├── main.py           # API FastAPI + Serving frontend
+│   ├── models.py         # Modèles Pydantic (Game, Player, Cards...)
+│   ├── game_engine.py    # Logique du jeu (règles, vérifications)
+│   ├── game_manager.py   # Gestion des parties (CRUD)
+│   ├── defaults.py       # Thèmes prédéfinis
+│   ├── config.py         # Configuration
+│   └── requirements.txt  # Dépendances Python
+├── frontend/
+│   ├── src/
+│   │   ├── pages/
+│   │   │   ├── Home.jsx  # Accueil + création partie
+│   │   │   ├── Join.jsx  # Rejoindre partie
+│   │   │   └── Game.jsx  # Interface de jeu
+│   │   ├── components/
+│   │   │   ├── GameBoard.jsx          # Plateau de jeu
+│   │   │   ├── InvestigationGrid.jsx  # Grille d'enquête
+│   │   │   └── AINavigator.jsx        # Narrateur Desland
+│   │   └── api.js        # Client API
+│   ├── package.json
+│   └── tailwind.config.js
+├── ai_service.py         # Service IA (Desland)
+├── Dockerfile            # Build multi-stage
+└── README.md
 ```
 
-### Code Style
+## 🔌 API Endpoints
 
-- Code documented in English
-- Type hints using Pydantic models
-- Follows PEP 8 guidelines
+### Parties
+- `GET /api/health` - Santé de l'API
+- `POST /api/games/quick-create` - Créer partie rapide
+- `POST /api/games/join` - Rejoindre partie
+- `POST /api/games/{game_id}/start` - Démarrer
+- `GET /api/games/{game_id}/state/{player_id}` - État du jeu
 
-## Troubleshooting
+### Actions
+- `POST /api/games/{game_id}/roll` - Lancer dés
+- `POST /api/games/{game_id}/suggest` - Suggestion
+- `POST /api/games/{game_id}/accuse` - Accusation
+- `POST /api/games/{game_id}/pass` - Passer tour
 
-### Port 7860 already in use
-
-Change the port in `config.py` or use environment variable:
-```bash
-PORT=8000 python app.py
-```
+### Autres
+- `GET /api/themes` - Thèmes disponibles
 
-### AI features not working
+## 🛠️ Technologies
 
-- Verify `USE_OPENAI=true` is set
-- Check `OPENAI_API_KEY` is valid
-- Ensure OpenAI API is accessible
-- Check API rate limits
+- **Backend** : FastAPI, Python 3.11, Pydantic
+- **Frontend** : React 18, Vite, TailwindCSS
+- **IA** : OpenAI gpt-5-nano (optionnel)
+- **Stockage** : JSON (games.json)
+- **Déploiement** : Docker, Hugging Face Spaces
 
-### Game state not updating
+## 🎨 Thèmes Disponibles
 
-- Click "Refresh Game State" button
-- Check network connection to API
-- Verify game ID and player ID are correct
+### Classique - Meurtre au Manoir 🏰
+- **Suspects** : Mme Leblanc, Col. Moutarde, Mlle Rose, Prof. Violet, Mme Pervenche, M. Olive
+- **Armes** : Poignard, Revolver, Corde, Chandelier, Clé anglaise, Poison
+- **Salles** : Cuisine, Salon, Bureau, Chambre, Garage, Jardin
 
-## License
+### Bureau - Meurtre au Bureau 💼
+- **Suspects** : Claire, Pierre, Daniel, Marie, Thomas, Sophie
+- **Armes** : Clé USB, Agrafeuse, Câble HDMI, Capsule de café, Souris, Plante verte
+- **Salles** : Open Space, Salle de réunion, Cafétéria, Bureau CEO, Toilettes, Parking
 
-This project is provided as-is for educational and recreational purposes.
+### Fantastique - Meurtre au Château 🧙
+- **Suspects** : Merlin le Sage, Dame Morgane, Chevalier Lancelot, Elfe Aranelle, Nain Thorin, Sorcière Malva
+- **Armes** : Épée enchantée, Potion empoisonnée, Grimoire maudit, Dague runique, Bâton magique, Amulette sombre
+- **Salles** : Grande Salle, Tour des Mages, Donjon, Bibliothèque, Armurerie, Crypte
 
-## Contributing
+## 📝 Licence
 
-Contributions welcome! Please:
-1. Fork the repository
-2. Create a feature branch
-3. Submit a pull request
+Projet personnel - Usage libre pour l'éducation et le divertissement
 
-## Support
+## 🎯 Crédits
 
-For issues and questions:
-- Create an issue on GitHub
-- Check existing documentation
-- Review API endpoint responses for error details
+- Jeu basé sur le Cluedo classique
+- Interface immersive avec thème hanté
+- Narrateur IA Desland créé avec amour et sarcasme 👻

api.py

@@ -1,304 +0,0 @@
-"""
-FastAPI backend for Cluedo Custom game.
-Provides REST API endpoints for game management and actions.
-"""
-
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import List, Optional
-
-from models import (
-    CreateGameRequest,
-    JoinGameRequest,
-    GameAction,
-    Game,
-    Player,
-    GameStatus
-)
-from game_manager import game_manager
-from game_engine import GameEngine
-from ai_service import ai_service
-from config import settings
-
-
-app = FastAPI(title=settings.APP_NAME)
-
-# CORS disabled - not needed when API and Gradio are on same host (localhost)
-
-
-class GameResponse(BaseModel):
-    """Response when creating or joining a game."""
-    game_id: str
-    player_id: Optional[str] = None
-    message: str
-
-
-class ActionResponse(BaseModel):
-    """Response for game actions."""
-    success: bool
-    message: str
-    data: Optional[dict] = None
-
-
-@app.get("/")
-async def root():
-    """Health check endpoint."""
-    return {
-        "app": settings.APP_NAME,
-        "status": "running",
-        "ai_enabled": settings.USE_OPENAI
-    }
-
-
-@app.post("/games/create", response_model=GameResponse)
-async def create_game(request: CreateGameRequest):
-    """
-    Create a new game.
-    Returns the game ID.
-    """
-    # Validate room count
-    if len(request.rooms) < settings.MIN_ROOMS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"At least {settings.MIN_ROOMS} rooms are required"
-        )
-
-    if len(request.rooms) > settings.MAX_ROOMS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Maximum {settings.MAX_ROOMS} rooms allowed"
-        )
-
-    # Create game
-    game = game_manager.create_game(request)
-
-    # Generate AI scenario if enabled
-    if game.use_ai and settings.USE_OPENAI:
-        from game_engine import DEFAULT_CHARACTERS
-        scenario = await ai_service.generate_scenario(
-            game.rooms,
-            DEFAULT_CHARACTERS
-        )
-        if scenario:
-            game.scenario = scenario
-            game_manager.save_games()
-
-    return GameResponse(
-        game_id=game.game_id,
-        message=f"Game '{game.name}' created successfully"
-    )
-
-
-@app.post("/games/join", response_model=GameResponse)
-async def join_game(request: JoinGameRequest):
-    """
-    Join an existing game.
-    Returns the player ID.
-    """
-    game = game_manager.get_game(request.game_id)
-
-    if not game:
-        raise HTTPException(status_code=404, detail="Game not found")
-
-    if game.status != GameStatus.WAITING:
-        raise HTTPException(status_code=400, detail="Game has already started")
-
-    if game.is_full():
-        raise HTTPException(status_code=400, detail="Game is full")
-
-    player = game_manager.join_game(request.game_id, request.player_name)
-
-    if not player:
-        raise HTTPException(status_code=400, detail="Could not join game")
-
-    return GameResponse(
-        game_id=game.game_id,
-        player_id=player.id,
-        message=f"{request.player_name} joined the game"
-    )
-
-
-@app.post("/games/{game_id}/start", response_model=ActionResponse)
-async def start_game(game_id: str):
-    """
-    Start a game (initialize cards and begin play).
-    """
-    success = game_manager.start_game(game_id)
-
-    if not success:
-        raise HTTPException(
-            status_code=400,
-            detail="Could not start game. Check player count and game status."
-        )
-
-    return ActionResponse(
-        success=True,
-        message="Game started successfully"
-    )
-
-
-@app.get("/games/{game_id}", response_model=Game)
-async def get_game(game_id: str):
-    """
-    Get full game state.
-    """
-    game = game_manager.get_game(game_id)
-
-    if not game:
-        raise HTTPException(status_code=404, detail="Game not found")
-
-    return game
-
-
-@app.get("/games/{game_id}/player/{player_id}")
-async def get_player_view(game_id: str, player_id: str):
-    """
-    Get game state from a specific player's perspective.
-    Hides other players' cards and the solution.
-    """
-    game = game_manager.get_game(game_id)
-
-    if not game:
-        raise HTTPException(status_code=404, detail="Game not found")
-
-    player = next((p for p in game.players if p.id == player_id), None)
-
-    if not player:
-        raise HTTPException(status_code=404, detail="Player not found")
-
-    # Build safe view
-    other_players = [
-        {
-            "name": p.name,
-            "is_active": p.is_active,
-            "card_count": len(p.cards)
-        }
-        for p in game.players if p.id != player_id
-    ]
-
-    current_player = game.get_current_player()
-
-    return {
-        "game_id": game.game_id,
-        "game_name": game.name,
-        "status": game.status,
-        "scenario": game.scenario,
-        "rooms": game.rooms,
-        "characters": [c.name for c in game.characters],
-        "weapons": [w.name for w in game.weapons],
-        "my_cards": [c.name for c in player.cards],
-        "other_players": other_players,
-        "current_turn": current_player.name if current_player else None,
-        "is_my_turn": current_player.id == player_id if current_player else False,
-        "recent_turns": game.turns[-5:] if game.turns else [],
-        "winner": game.winner
-    }
-
-
-@app.post("/games/{game_id}/action", response_model=ActionResponse)
-async def perform_action(game_id: str, action: GameAction):
-    """
-    Perform a game action (suggest, accuse, pass).
-    """
-    game = game_manager.get_game(game_id)
-
-    if not game:
-        raise HTTPException(status_code=404, detail="Game not found")
-
-    # Verify it's the player's turn
-    if not GameEngine.can_player_act(game, action.player_id):
-        raise HTTPException(status_code=403, detail="Not your turn or game not in progress")
-
-    player = next((p for p in game.players if p.id == action.player_id), None)
-    if not player:
-        raise HTTPException(status_code=404, detail="Player not found")
-
-    result_message = ""
-    result_data = {}
-
-    if action.action_type == "pass":
-        # Pass turn
-        GameEngine.add_turn_record(game, action.player_id, "pass", "Passed turn")
-        game.next_turn()
-        result_message = f"{player.name} passed their turn"
-
-    elif action.action_type == "suggest":
-        # Make a suggestion
-        if not all([action.character, action.weapon, action.room]):
-            raise HTTPException(status_code=400, detail="Suggestion requires character, weapon, and room")
-
-        can_disprove, disprover, card = GameEngine.check_suggestion(
-            game,
-            action.player_id,
-            action.character,
-            action.weapon,
-            action.room
-        )
-
-        suggestion_text = f"Suggested: {action.character} with {action.weapon} in {action.room}"
-
-        if can_disprove and disprover and card:
-            result_message = f"{disprover} disproved the suggestion by showing: {card.name}"
-            result_data = {"disproved_by": disprover, "card_shown": card.name}
-        else:
-            result_message = "No one could disprove the suggestion!"
-            result_data = {"disproved_by": None}
-
-        GameEngine.add_turn_record(game, action.player_id, "suggest", suggestion_text)
-        game.next_turn()
-
-    elif action.action_type == "accuse":
-        # Make an accusation
-        if not all([action.character, action.weapon, action.room]):
-            raise HTTPException(status_code=400, detail="Accusation requires character, weapon, and room")
-
-        accusation_text = f"Accused: {action.character} with {action.weapon} in {action.room}"
-
-        is_correct, message = GameEngine.process_accusation(
-            game,
-            action.player_id,
-            action.character,
-            action.weapon,
-            action.room
-        )
-
-        GameEngine.add_turn_record(game, action.player_id, "accuse", accusation_text)
-
-        if not is_correct and game.status == GameStatus.IN_PROGRESS:
-            game.next_turn()
-
-        result_message = message
-        result_data = {"correct": is_correct, "game_finished": game.status == GameStatus.FINISHED}
-
-    else:
-        raise HTTPException(status_code=400, detail="Invalid action type")
-
-    game_manager.save_games()
-
-    return ActionResponse(
-        success=True,
-        message=result_message,
-        data=result_data
-    )
-
-
-@app.get("/games/list")
-async def list_games():
-    """
-    List all active games.
-    """
-    return {"games": game_manager.list_active_games()}
-
-
-@app.delete("/games/{game_id}")
-async def delete_game(game_id: str):
-    """
-    Delete a game.
-    """
-    success = game_manager.delete_game(game_id)
-
-    if not success:
-        raise HTTPException(status_code=404, detail="Game not found")
-
-    return {"message": "Game deleted successfully"}

app.py

@@ -1,1087 +0,0 @@
-"""
-Main application file for Cluedo Custom.
-Integrates FastAPI backend with Gradio frontend interface.
-"""
-
-import gradio as gr
-import requests
-import json
-from typing import Optional, List
-from config import settings
-import uvicorn
-import threading
-import time
-
-
-# Determine runtime environment
-import os
-
-IS_HUGGINGFACE = os.getenv("SPACE_ID") is not None
-
-# API base URL (only used in local mode)
-API_BASE = "http://localhost:8000"
-
-
-class GameState:
-    """Client-side game state management."""
-
-    def __init__(self):
-        self.game_id: Optional[str] = None
-        self.player_id: Optional[str] = None
-        self.player_name: Optional[str] = None
-
-
-# Global state
-state = GameState()
-
-
-def create_game(game_name: str, rooms_text: str, use_ai: bool):
-    """
-    Create a new game.
-    """
-    if not game_name or not rooms_text:
-        return "❌ Ekelesbikes ! Fournissez un nom d'enquête et une liste de pièces", ""
-
-    # Parse rooms (comma or newline separated)
-    rooms = [r.strip() for r in rooms_text.replace("\n", ",").split(",") if r.strip()]
-
-    if len(rooms) < settings.MIN_ROOMS:
-        return (
-            f"❌ Koikoubaiseyyyyy ! Il faut au moins {settings.MIN_ROOMS} pièces",
-            "",
-        )
-
-    if len(rooms) > settings.MAX_ROOMS:
-        return (
-            f"❌ Triple monstre coucouuuuu ! Maximum {settings.MAX_ROOMS} pièces autorisées",
-            "",
-        )
-
-    try:
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-            from models import CreateGameRequest
-
-            request = CreateGameRequest(game_name=game_name, rooms=rooms, use_ai=use_ai)
-            game = game_manager.create_game(request)
-
-            # Generate AI scenario if enabled
-            if game.use_ai and settings.USE_OPENAI:
-                from game_engine import DEFAULT_CHARACTERS
-                from ai_service import ai_service
-                import asyncio
-
-                try:
-                    scenario = asyncio.run(
-                        ai_service.generate_scenario(game.rooms, DEFAULT_CHARACTERS)
-                    )
-                    if scenario:
-                        game.scenario = scenario
-                        game_manager.save_games()
-                except:
-                    pass  # AI is optional
-
-            state.game_id = game.game_id
-            return (
-                f"✅ Enquête créée avec succès ! En alicrampté, les coicoubaca sont de sortie...\n\n"
-                f"🔑 Code d'Enquête : {game.game_id}\n\n"
-                f"📤 Partagez ce code avec les autres poupouilles masquées pour qu'elles puissent vous rejoindre en alicrampté.\n\n"
-                f"ℹ️ Minimum {settings.MIN_PLAYERS} péchailloux requis pour démarrer (sinon c'est les fourlestourtes et les bourbillats).",
-                game.game_id,
-            )
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(
-                f"{API_BASE}/games/create",
-                json={"game_name": game_name, "rooms": rooms, "use_ai": use_ai},
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                state.game_id = data["game_id"]
-                return (
-                    f"✅ Enquête créée avec succès ! En alicrampté, les coicoubaca sont de sortie...\n\n"
-                    f"🔑 Code d'Enquête : {data['game_id']}\n\n"
-                    f"📤 Partagez ce code avec les autres joueurs pour qu'ils puissent rejoindre.\n\n"
-                    f"ℹ️ Minimum {settings.MIN_PLAYERS} joueurs requis pour démarrer.",
-                    data["game_id"],
-                )
-            else:
-                return (
-                    f"❌ All RS5, erreur réseau : {response.json().get('detail', 'Erreur inconnue')}",
-                    "",
-                )
-
-    except Exception as e:
-        return f"❌ Yamete coudasai ! Erreur lors de la création : {str(e)}", ""
-
-
-def join_game(game_id: str, player_name: str):
-    """
-    Join an existing game.
-    """
-    if not game_id or not player_name:
-        return "❌ Yamete coudasai ! Fournissez le code d'enquête et votre nom de tchoupinoux masqué !"
-
-    try:
-        game_id = game_id.strip().upper()
-        player_name = player_name.strip()
-
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-            from models import GameStatus
-
-            game = game_manager.get_game(game_id)
-            if not game:
-                return "❌ Erreur réseau ! Enquête introuvable... C'est Leland (non c'est Desland)"
-
-            if game.status != GameStatus.WAITING:
-                return "❌ Armankaboul ! Les chnawax masqués jouent déjà !"
-
-            if game.is_full():
-                return "❌ Chat 4, 3 entre chat 4 et 1 brisé ! Trop de poupouilles dans l'enquête..."
-
-            player = game_manager.join_game(game_id, player_name)
-            if not player:
-                return "❌ Une poupée en pénitence calisse ! Impossible de rejoindre l'enquête !"
-
-            state.game_id = game_id
-            state.player_id = player.id
-            state.player_name = player_name
-
-            return (
-                f"✅ Enquête rejointe avec succès !\n\n"
-                f"👋 Bienvenue, {player_name} !\n\n"
-                f"⏳ Attendez que le chnawax originel (le créateur) démarre la partie...\n"
-                f"📖 Allez dans l'onglet 🔎 Enquêter pour voir l'état de la partie."
-            )
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(
-                f"{API_BASE}/games/join",
-                json={
-                    "game_id": game_id,
-                    "player_name": player_name,
-                },
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                state.game_id = data["game_id"]
-                state.player_id = data["player_id"]
-                state.player_name = player_name
-
-                return (
-                    f"✅ Enquête rejointe avec succès !\n\n"
-                    f"👋 Bienvenue, {player_name} !\n\n"
-                    f"⏳ Attendez que le chnawax originel (le créateur) démarre la partie...\n"
-                    f"📖 Allez dans l'onglet 🔎 Enquêter pour voir l'état de la partie."
-                )
-            else:
-                return f"❌ All RS5, erreur réseau (fourlestourtes et les bourbillats) : {response.json().get('detail', 'Erreur inconnue')}"
-
-    except Exception as e:
-        return f"❌ Koikoubaiseyyyyy ! Erreur : {str(e)}"
-
-
-def start_game(game_id: str):
-    """
-    Start the game.
-    """
-    if not game_id:
-        return "❌ Triple monstre coucouuuuu ! Aucune enuête sélectionnée !"
-
-    try:
-        game_id = game_id.strip().upper()
-
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-
-            success = game_manager.start_game(game_id)
-
-            if not success:
-                return "❌ Erreur ! Pas assez de tchoupinoux masqués pour commencer la partie !"
-
-            return (
-                f"🩸 LE MASSACRE COMMENCE ! Triple monstre coucouuuuu !\n\n"
-                f"🎲 Les cartes ont été distribuées.\n"
-                f"🔪 Tous les joueurs peuvent maintenant consulter leurs cartes et commencer à jouer.\n\n"
-                f"➡️ Allez dans l'onglet 🔎 Enquêter pour voir votre dossier."
-            )
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(f"{API_BASE}/games/{game_id}/start", timeout=5)
-
-            if response.status_code == 200:
-                return (
-                    f"🩸 LE MASSACRE COMMENCE ! Triple monstre coucouuuuu !\n\n"
-                    f"🎲 Les cartes ont été distribuées.\n"
-                    f"🔪 Tous les joueurs peuvent maintenant consulter leurs cartes et commencer à jouer.\n\n"
-                    f"➡️ Allez dans l'onglet 🔎 Enquêter pour voir votre dossier."
-                )
-            else:
-                return f"❌ All RS5 erreur réseau : {response.json().get('detail', 'Erreur inconnue')}"
-
-    except Exception as e:
-        return f"❌ Yamete coudasai ! Erreur au démarrage : {str(e)}"
-
-
-def get_player_view():
-    """
-    Get current game state for the player.
-    """
-    if not state.game_id or not state.player_id:
-        return (
-            "❌ Eskilibass ! Vous n'êtes pas dans une enquête.\n\n"
-            "➡️ Créer une nouvelle enquête ou rejoignez d'autres péchailloux masqués."
-        )
-
-    try:
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-
-            game = game_manager.get_game(state.game_id)
-
-            if not game:
-                return "❌ All RS5, erreur réseau ! Enquête introuvable... Fourlestourtes et les bourbillats !"
-
-            player = next((p for p in game.players if p.id == state.player_id), None)
-
-            if not player:
-                return "❌ Poupée en pénitence calisse ! Péchailloux masqué..."
-
-            # Build safe view
-            other_players = [
-                {"name": p.name, "is_active": p.is_active, "card_count": len(p.cards)}
-                for p in game.players
-                if p.id != state.player_id
-            ]
-
-            current_player = game.get_current_player()
-
-            data = {
-                "game_id": game.game_id,
-                "game_name": game.name,
-                "status": game.status,
-                "scenario": game.scenario,
-                "rooms": game.rooms,
-                "characters": [c.name for c in game.characters],
-                "weapons": [w.name for w in game.weapons],
-                "my_cards": [c.name for c in player.cards],
-                "other_players": other_players,
-                "current_turn": current_player.name if current_player else None,
-                "is_my_turn": (
-                    current_player.id == state.player_id if current_player else False
-                ),
-                "recent_turns": game.turns[-5:] if game.turns else [],
-                "winner": game.winner,
-            }
-        else:
-            # HTTP API call (local mode)
-            response = requests.get(
-                f"{API_BASE}/games/{state.game_id}/player/{state.player_id}", timeout=5
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-            else:
-                return f"❌ Erreur : {response.json().get('detail', 'Erreur inconnue')}"
-
-        # Format output (common for both modes)
-        output = []
-        output.append(f"═══ 🩸 {data['game_name']} - LE CARNAGE SANGLANT 🩸 ═══\n")
-
-        status_map = {
-            "waiting": "⏳ Les poupouilles masquées arrivent...",
-            "in_progress": "🔪 CARNAGE EN COURS",
-            "finished": "💀 MASSACRE TERMINÉ - Un chnawax a gagné",
-        }
-        output.append(f"📊 Statut : {status_map.get(data['status'], data['status'])}\n")
-
-        if data.get("scenario"):
-            output.append(f"\n📜 Scénario :\n{data['scenario']}\n")
-
-        output.append(f"\n━━━ 🃏 VOS CARTES ━━━")
-        output.append("(Ces éléments NE SONT PAS la solution)")
-        for card in data["my_cards"]:
-            output.append(f"  🔸 {card}")
-
-        output.append(f"\n━━━ ℹ️ INFORMATIONS DE JEU ━━━")
-        output.append(f"🚪 Lieux : {', '.join(data['rooms'])}")
-        output.append(f"👤 Personnages : {', '.join(data['characters'])}")
-        output.append(f"🔪 Armes : {', '.join(data['weapons'])}")
-
-        output.append(f"\n━━━ 👥 DÉTECTIVES ━━━")
-        for player in data["other_players"]:
-            status_icon = "✅" if player["is_active"] else "❌"
-            output.append(
-                f"  {status_icon} {player['name']} ({player['card_count']} cartes)"
-            )
-
-        if data["current_turn"]:
-            turn_marker = (
-                "👉 C'EST TON TOUR MON PÉCHAILLOUX !" if data["is_my_turn"] else ""
-            )
-            output.append(f"\n━━━ 🎯 TOUR ACTUEL ━━━")
-            output.append(f"🎲 {data['current_turn']} {turn_marker}")
-
-        if data.get("winner"):
-            output.append(
-                f"\n\n🏆🏆🏆 QUOICOUBAIDEYYYYY ! VAINQUEUR : {data['winner']} 🏆🏆🏆"
-            )
-
-        if data["recent_turns"]:
-            output.append(f"\n━━━ 📰 ACTIONS RÉCENTES ━━━")
-            for turn in data["recent_turns"][-5:]:
-                output.append(f"  • {turn['player_name']}: {turn['action']}")
-                if turn.get("details"):
-                    output.append(f"    ↪ {turn['details']}")
-
-        return "\n".join(output)
-
-    except Exception as e:
-        return f"❌ Erreur réseau (fourlestourtes et les bourbillats) : {str(e)}"
-
-
-def make_suggestion(character: str, weapon: str, room: str):
-    """
-    Make a suggestion.
-    """
-    if not state.game_id or not state.player_id:
-        return "❌ Ekelesbikes ! Vous n'êtes pas dans une enquête"
-
-    if not all([character, weapon, room]):
-        return "❌ Eskilibass (I'm a spiderman), choisissez un personnage, une arme et un lieu"
-
-    try:
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-            from game_engine import GameEngine
-
-            game = game_manager.get_game(state.game_id)
-
-            if not game:
-                return "❌ All RS5, erreur réseau ! Enquête introuvable"
-
-            # Verify it's the player's turn
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Yamete coudasai ! C'est pas ton tour !"
-
-            player = next((p for p in game.players if p.id == state.player_id), None)
-            if not player:
-                return "❌ All RS5, erreur réseau ! Péchailloux masqué introuvable"
-
-            can_disprove, disprover, card = GameEngine.check_suggestion(
-                game, state.player_id, character, weapon, room
-            )
-
-            suggestion_text = f"Suggested: {character} with {weapon} in {room}"
-
-            if can_disprove and disprover and card:
-                message = (
-                    f"{disprover} disproved the suggestion by showing: {card.name}"
-                )
-            else:
-                message = "No one could disprove the suggestion!"
-
-            GameEngine.add_turn_record(
-                game, state.player_id, "suggest", suggestion_text
-            )
-            game.next_turn()
-            game_manager.save_games()
-
-            # Translate common responses
-            if "disproved" in message.lower():
-                return (
-                    f"💭 {message}\n\n➡️ Notes cette information pour tes déductions !"
-                )
-            else:
-                return f"💭 {message}\n\n⚠️ Aucun chnawax n'a pu réfuter ta théorie !"
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(
-                f"{API_BASE}/games/{state.game_id}/action",
-                json={
-                    "game_id": state.game_id,
-                    "player_id": state.player_id,
-                    "action_type": "suggest",
-                    "character": character,
-                    "weapon": weapon,
-                    "room": room,
-                },
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                message = data["message"]
-
-                # Translate common responses
-                if "disproved" in message.lower():
-                    return f"💭 {message}\n\n➡️ Notez cette information pour vos déductions !"
-                else:
-                    return f"💭 {message}\n\n⚠️ Personne n'a pu réfuter votre théorie !"
-            else:
-                error = response.json().get("detail", "Erreur inconnue")
-                if "Not your turn" in error:
-                    return "❌ Yamete coudasai ! C'est pas ton tour !"
-                return f"❌ Erreur réseau (fourlestourtes et les bourbillats) : {error}"
-
-    except Exception as e:
-        return f"❌ Koikoubaiseyyyyy ! Erreur : {str(e)}"
-
-
-def make_accusation(character: str, weapon: str, room: str):
-    """
-    Make an accusation.
-    """
-    if not state.game_id or not state.player_id:
-        return "❌ Vous n'êtes pas dans une enquête"
-
-    if not all([character, weapon, room]):
-        return "❌ Armankaboul ! Choisissez un personnage, une arme et un lieu"
-
-    try:
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-            from game_engine import GameEngine
-            from models import GameStatus
-
-            game = game_manager.get_game(state.game_id)
-
-            if not game:
-                return "❌ All RS5, erreur réseau : Enquête introuvable"
-
-            # Verify it's the player's turn
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Yamete coudasai ! C'est pas ton tour !"
-
-            player = next((p for p in game.players if p.id == state.player_id), None)
-            if not player:
-                return "❌ All RS5, erreur réseau : Joueur introuvable"
-
-            accusation_text = f"Accused: {character} with {weapon} in {room}"
-
-            is_correct, message = GameEngine.process_accusation(
-                game, state.player_id, character, weapon, room
-            )
-
-            GameEngine.add_turn_record(game, state.player_id, "accuse", accusation_text)
-
-            if not is_correct and game.status == GameStatus.IN_PROGRESS:
-                game.next_turn()
-
-            game_manager.save_games()
-
-            # Check if win or lose
-            if "wins" in message.lower() or "correct" in message.lower():
-                return f"🎉🏆 {message} 🎉🏆\n\nTRIPLE MONSTRE COUCOUUUUU ! Tu as résolu le mystère ! (3 entre chat 4 et 1 brisé)"
-            elif "wrong" in message.lower() or "eliminated" in message.lower():
-                return f"💀 {message}\n\n😔 Fourlestourtes et les bourbillats... Tu as été éliminé calisse en pénitence siboère !\nTu peux toujours aider en réfutant les théories des autres."
-            else:
-                return f"⚖️ {message}"
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(
-                f"{API_BASE}/games/{state.game_id}/action",
-                json={
-                    "game_id": state.game_id,
-                    "player_id": state.player_id,
-                    "action_type": "accuse",
-                    "character": character,
-                    "weapon": weapon,
-                    "room": room,
-                },
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                message = data["message"]
-
-                # Check if win or lose
-                if "wins" in message.lower() or "correct" in message.lower():
-                    return f"🎉🏆 {message} 🎉🏆\n\nTRIPLE MONSTRE COUCOUUUUU ! Tu as résolu le mystère ! (3 entre chat 4 et 1 brisé)"
-                elif "wrong" in message.lower() or "eliminated" in message.lower():
-                    return f"💀 {message}\n\n😔 Fourlestourtes et les bourbillats... Tu as été éliminé calisse en pénitence siboère !\nTu peux toujours aider en réfutant les théories des autres."
-                else:
-                    return f"⚖�� {message}"
-            else:
-                error = response.json().get("detail", "Erreur inconnue")
-                if "Not your turn" in error:
-                    return "❌ Yamete coudasai ! C'est pas ton tour !"
-                return f"❌ All RS5, erreur réseau : {error}"
-
-    except Exception as e:
-        return f"❌ Koikoubaiseyyyyy ! Erreur : {str(e)}"
-
-
-def pass_turn():
-    """
-    Pass the current turn.
-    """
-    if not state.game_id or not state.player_id:
-        return "❌ Eskilibass ! Vous n'êtes pas dans une enquête"
-
-    try:
-        if IS_HUGGINGFACE:
-            # Direct backend call
-            from game_manager import game_manager
-            from game_engine import GameEngine
-
-            game = game_manager.get_game(state.game_id)
-
-            if not game:
-                return "❌ All RS5, erreur réseau ! Enquête introuvable"
-
-            # Verify it's the player's turn
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Yamete coudasai ! C'est pas ton tour !"
-
-            player = next((p for p in game.players if p.id == state.player_id), None)
-            if not player:
-                return "❌ All RS5, erreur réseau ! Joueur introuvable"
-
-            # Pass turn
-            GameEngine.add_turn_record(game, state.player_id, "pass", "Passed turn")
-            game.next_turn()
-            game_manager.save_games()
-
-            return f"✅ Tour passé !\n\n➡️ C'est maintenant au tour de la prochaine poupouille."
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(
-                f"{API_BASE}/games/{state.game_id}/action",
-                json={
-                    "game_id": state.game_id,
-                    "player_id": state.player_id,
-                    "action_type": "pass",
-                },
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                return f"✅ Tour passé !\n\n➡️ C'est maintenant au tour de la prochaine poupouille."
-            else:
-                error = response.json().get("detail", "Erreur inconnue")
-                if "Not your turn" in error:
-                    return "❌ Yamete coudasai ! C'est pas ton tour !"
-                return f"❌ All RS5, erreur réseau (fourlestourtes et les bourbillats) : {error}"
-
-    except Exception as e:
-        return f"❌ Koikoubaiseyyyyy ! Erreur : {str(e)}"
-
-
-# Sample lists for dropdowns
-from game_engine import DEFAULT_CHARACTERS, DEFAULT_WEAPONS
-
-
-def create_gradio_interface():
-    """
-    Create the Gradio interface.
-    """
-    # Custom dark detective/horror theme
-    custom_theme = gr.themes.Base(
-        primary_hue="red",
-        secondary_hue="slate",
-        neutral_hue="stone",
-        font=("ui-serif", "Georgia", "serif"),
-    ).set(
-        body_background_fill="*neutral_950",
-        body_background_fill_dark="*neutral_950",
-        body_text_color="*neutral_200",
-        body_text_color_dark="*neutral_200",
-        button_primary_background_fill="*primary_700",
-        button_primary_background_fill_dark="*primary_800",
-        button_primary_text_color="white",
-        button_secondary_background_fill="*neutral_700",
-        button_secondary_background_fill_dark="*neutral_800",
-        input_background_fill="*neutral_800",
-        input_background_fill_dark="*neutral_900",
-        input_border_color="*neutral_700",
-        block_background_fill="*neutral_900",
-        block_background_fill_dark="*neutral_900",
-        block_border_color="*neutral_700",
-        block_label_text_color="*primary_400",
-        block_title_text_color="*primary_300",
-    )
-
-    custom_css = """
-    @import url('https://fonts.googleapis.com/css2?family=Creepster&family=Cinzel:wght@400;600&display=swap');
-
-    .gradio-container {
-        background:
-            linear-gradient(180deg, rgba(10,0,0,0.95) 0%, rgba(26,0,0,0.9) 50%, rgba(10,5,5,0.95) 100%),
-            repeating-linear-gradient(90deg, transparent, transparent 2px, rgba(0,0,0,0.3) 2px, rgba(0,0,0,0.3) 4px),
-            url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><filter id="noise"><feTurbulence baseFrequency="0.9" /></filter><rect width="100" height="100" filter="url(%23noise)" opacity="0.05"/></svg>') !important;
-        font-family: 'Cinzel', 'Georgia', serif !important;
-        position: relative;
-    }
-
-    .gradio-container::before {
-        content: '';
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background: radial-gradient(ellipse at center, transparent 0%, rgba(0,0,0,0.7) 100%);
-        pointer-events: none;
-        z-index: 0;
-    }
-
-    h1 {
-        color: #8b0000 !important;
-        text-shadow:
-            0 0 10px rgba(139,0,0,0.8),
-            0 0 20px rgba(139,0,0,0.6),
-            3px 3px 6px rgba(0,0,0,0.9),
-            0 0 40px rgba(220,20,60,0.4);
-        font-family: 'Creepster', 'Georgia', cursive !important;
-        letter-spacing: 4px;
-        font-size: 3em !important;
-        animation: flicker 3s infinite alternate;
-    }
-
-    @keyframes flicker {
-        0%, 100% { opacity: 1; text-shadow: 0 0 10px rgba(139,0,0,0.8), 0 0 20px rgba(139,0,0,0.6), 3px 3px 6px rgba(0,0,0,0.9); }
-        50% { opacity: 0.95; text-shadow: 0 0 15px rgba(139,0,0,1), 0 0 25px rgba(139,0,0,0.8), 3px 3px 6px rgba(0,0,0,0.9); }
-    }
-
-    h2, h3 {
-        color: #b91c1c !important;
-        text-shadow: 2px 2px 4px rgba(0,0,0,0.9), 0 0 10px rgba(185,28,28,0.5);
-        font-family: 'Cinzel', 'Georgia', serif !important;
-        letter-spacing: 3px;
-        border-bottom: 1px solid rgba(139,0,0,0.3);
-        padding-bottom: 8px;
-    }
-
-    .tabs button {
-        background: linear-gradient(180deg, #1a0f0f 0%, #0a0000 100%) !important;
-        border: 1px solid #44403c !important;
-        color: #d6d3d1 !important;
-        transition: all 0.3s ease;
-        font-family: 'Cinzel', serif !important;
-        letter-spacing: 1px;
-    }
-
-    .tabs button:hover {
-        background: linear-gradient(180deg, #2a0f0f 0%, #1a0000 100%) !important;
-        border-color: #8b0000 !important;
-        box-shadow: 0 0 15px rgba(139,0,0,0.5);
-    }
-
-    .tabs button[aria-selected="true"] {
-        background: linear-gradient(180deg, #8b0000 0%, #5a0000 100%) !important;
-        border-color: #dc2626 !important;
-        color: #fef2f2 !important;
-        box-shadow:
-            0 0 20px rgba(139,0,0,0.6),
-            inset 0 0 10px rgba(0,0,0,0.5);
-    }
-
-    .gr-button {
-        background: linear-gradient(180deg, #7c2d12 0%, #5a1a0a 100%) !important;
-        border: 1px solid #8b0000 !important;
-        color: #fef2f2 !important;
-        text-shadow: 1px 1px 2px rgba(0,0,0,0.8);
-        transition: all 0.3s ease;
-        font-family: 'Cinzel', serif !important;
-        letter-spacing: 1px;
-    }
-
-    .gr-button:hover {
-        background: linear-gradient(180deg, #8b0000 0%, #6a0000 100%) !important;
-        box-shadow: 0 0 20px rgba(139,0,0,0.7), 0 5px 15px rgba(0,0,0,0.5);
-        transform: translateY(-2px);
-    }
-
-    .gr-button-primary {
-        background: linear-gradient(180deg, #991b1b 0%, #7f1d1d 100%) !important;
-        border: 2px solid #dc2626 !important;
-        box-shadow: 0 0 15px rgba(153,27,27,0.5);
-    }
-
-    .gr-button-stop {
-        background: linear-gradient(180deg, #450a0a 0%, #1a0000 100%) !important;
-        border: 2px solid #7f1d1d !important;
-        animation: pulse-danger 2s infinite;
-    }
-
-    @keyframes pulse-danger {
-        0%, 100% { box-shadow: 0 0 10px rgba(127,29,29,0.5); }
-        50% { box-shadow: 0 0 25px rgba(127,29,29,0.9), 0 0 40px rgba(220,38,38,0.5); }
-    }
-
-    .gr-textbox, .gr-dropdown {
-        background: rgba(20,10,10,0.8) !important;
-        border: 1px solid #44403c !important;
-        color: #e7e5e4 !important;
-        box-shadow: inset 0 2px 4px rgba(0,0,0,0.5);
-    }
-
-    .gr-textbox:focus, .gr-dropdown:focus {
-        border-color: #8b0000 !important;
-        box-shadow: 0 0 15px rgba(139,0,0,0.4), inset 0 2px 4px rgba(0,0,0,0.5);
-    }
-
-    .gr-group, .gr-box {
-        background: rgba(15,5,5,0.6) !important;
-        border: 1px solid rgba(68,64,60,0.5) !important;
-        border-radius: 8px !important;
-        box-shadow:
-            0 4px 6px rgba(0,0,0,0.5),
-            inset 0 1px 2px rgba(139,0,0,0.1);
-    }
-
-    .gr-accordion {
-        background: rgba(26,10,10,0.7) !important;
-        border: 1px solid rgba(139,0,0,0.3) !important;
-        border-radius: 6px;
-    }
-
-    label {
-        color: #fca5a5 !important;
-        font-family: 'Cinzel', serif !important;
-        letter-spacing: 1px;
-        text-shadow: 1px 1px 2px rgba(0,0,0,0.8);
-    }
-
-    .markdown {
-        color: #d6d3d1 !important;
-    }
-
-    .warning-text {
-        color: #fca5a5 !important;
-        font-style: italic;
-        text-shadow: 1px 1px 2px rgba(0,0,0,0.8), 0 0 10px rgba(252,165,165,0.3);
-    }
-
-    /* Effet de brouillard fantomatique */
-    @keyframes ghost-float {
-        0%, 100% { opacity: 0.05; transform: translateY(0px); }
-        50% { opacity: 0.15; transform: translateY(-20px); }
-    }
-
-    .gradio-container::after {
-        content: '';
-        position: fixed;
-        top: -50%;
-        left: -50%;
-        width: 200%;
-        height: 200%;
-        background: radial-gradient(circle, rgba(139,0,0,0.03) 0%, transparent 50%);
-        animation: ghost-float 10s infinite ease-in-out;
-        pointer-events: none;
-        z-index: 1;
-    }
-    """
-
-    with gr.Blocks(title=settings.APP_NAME, theme=custom_theme, css=custom_css) as demo:
-        gr.Markdown(f"# 🔍 {settings.APP_NAME} 🔪")
-        gr.Markdown("*Un mystère mortel vous attend dans votre propre lieu...*")
-
-        # Rules section (collapsible)
-        with gr.Accordion("📖 Règles du Jeu & Guide", open=False):
-            gr.Markdown(
-                """
-            ## 🎯 Objectif
-            Soyez le premier détective à résoudre le meurtre en identifiant correctement :
-            - **Le meurtrier** (personnage)
-            - **L'arme du crime** (arme)
-            - **Le lieu du crime** (pièce)
-
-            ## 🎮 Étapes de Jeu
-
-            ### 1️⃣ Création de la Partie
-            - Un joueur crée la partie en définissant 6-12 lieux personnalisés
-            - Partagez le **Code d'Enquête** avec les autres détectives
-
-            ### 2️⃣ Rejoindre l'Enquête
-            - Les détectives rejoignent avec le code partagé (min. 3 joueurs)
-            - Le créateur lance l'enquête quand tous sont prêts
-
-            ### 3️⃣ Distribution des Cartes
-            - Une solution secrète est créée (1 personnage + 1 arme + 1 lieu)
-            - Les cartes restantes sont distribuées équitablement entre les joueurs
-            - Vous voyez vos propres cartes = ces éléments **NE SONT PAS** la solution
-
-            ### 4️⃣ Votre Tour
-            Trois actions possibles :
-
-            **💭 Proposer une Théorie** (Suggestion)
-            - Proposez une combinaison personnage + arme + lieu
-            - Les autres joueurs essaient de réfuter en montrant UNE carte correspondante
-            - Seul VOUS voyez la carte révélée
-            - Utilisez cela pour éliminer des possibilités
-
-            **⚡ Accusation Finale**
-            - Si vous pensez connaître la solution, faites une accusation
-            - ✅ **Correct** = Vous gagnez immédiatement !
-            - ❌ **Faux** = Vous êtes éliminé de l'enquête (mais pouvez encore réfuter)
-
-            **⏭️ Passer le Tour**
-            - Passez votre tour si vous n'avez rien à proposer
-
-            ## 🏆 Conditions de Victoire
-            - Premier joueur à faire une **accusation correcte**
-            - Dernier joueur actif si tous les autres sont éliminés
-
-            ## 💡 Conseils Stratégiques
-            - Notez les cartes que vous voyez (sur papier)
-            - Déduisez les cartes des autres joueurs par élimination
-            - Ne faites pas d'accusation tant que vous n'êtes pas sûr !
-            - Les suggestions peuvent forcer les joueurs à révéler des informations
-
-            ## 🤖 Mode IA Narrateur (optionnel)
-            Active une narration générée par IA incarnée dans Desland, un vieux jardinier mystérieux qui semble toujours en savoir plus qu'il ne devrait... Il se trompe souvent sur son nom (Leland? Non, c'est Desland...) et parle de manière étrangement suspicieuse, comme s'il cachait quelque chose de très sombre.
-            """
-            )
-
-        with gr.Tab("🕯️ Créer une Partie"):
-            gr.Markdown("### 📜 Établir un Nouveau Mystère")
-            gr.Markdown("*Préparez la scène d'un meurtre des plus ignobles...*")
-
-            game_name_input = gr.Textbox(
-                label="🎭 Nom de l'enquête",
-                placeholder="Le Meurtre au Manoir des Poupouilles",
-                info="Donnez un nom à votre affaire (ex : armankaboul)",
-            )
-
-            rooms_input = gr.Textbox(
-                label=f"🚪 Lieux de la scène de crime ({settings.MIN_ROOMS}-{settings.MAX_ROOMS} pièces)",
-                placeholder="Le salon des péchailloux, La chambre du Viande, Bureau des Chnawax, Le B15 des Tchoupinoux, Le jardin de la poupouille",
-                lines=4,
-                info="Séparez les pièces par des virgules ou des retours à la ligne",
-            )
-
-            use_ai_checkbox = gr.Checkbox(
-                label="🤖 Activer le Narrateur IA - Lesland... euh non Desland",
-                value=False,
-                visible=settings.USE_OPENAI,
-                info="Un vieux jardinier suspicieux qui semble en savoir plus qu'il n'y paraît...",
-            )
-
-            create_btn = gr.Button(
-                "🩸 Commencer l'Enquête", variant="primary", size="lg"
-            )
-            create_output = gr.Textbox(
-                label="📋 Dossier de l'Affaire", lines=5, show_copy_button=True
-            )
-            game_id_display = gr.Textbox(
-                label="🔑 Code d'Enquête (partagez avec les autres poupouilles masquées)",
-                interactive=False,
-                show_copy_button=True,
-            )
-
-            create_btn.click(
-                create_game,
-                inputs=[game_name_input, rooms_input, use_ai_checkbox],
-                outputs=[create_output, game_id_display],
-            )
-
-        with gr.Tab("🕵️ Rejoindre"):
-            gr.Markdown("### 👥 Entrer sur la Scène de Crime")
-            gr.Markdown("*Rassemblez vos confrères détectives...*")
-
-            with gr.Group():
-                join_game_id = gr.Textbox(
-                    label="🔑 Code d'Enquête",
-                    placeholder="ABC123",
-                    info="Code fourni par le créateur de la partie",
-                )
-
-                join_player_name = gr.Textbox(
-                    label="🎩 Nom du Détective",
-                    placeholder="Chnawax Masquée",
-                    info="Votre nom d'enquêteur",
-                )
-
-                join_btn = gr.Button(
-                    "🚪 Rejoindre l'Enquête", variant="primary", size="lg"
-                )
-                join_output = gr.Textbox(
-                    label="📋 Statut", lines=3, show_copy_button=True
-                )
-
-                join_btn.click(
-                    join_game,
-                    inputs=[join_game_id, join_player_name],
-                    outputs=join_output,
-                )
-
-            gr.Markdown("---")
-            gr.Markdown("### 🎬 Lancer l'Enquête")
-            gr.Markdown(
-                "*Une fois que tous les détectives sont présents (min. 3 poupouilles)*"
-            )
-
-            with gr.Group():
-                start_game_id = gr.Textbox(
-                    label="🔑 Code d'Enquête",
-                    placeholder="ABC123",
-                    info="Seul le chnawax originel (le créateur) peut démarrer la partie",
-                )
-
-                start_btn = gr.Button(
-                    "⚡ Démarrer le Mystère", variant="secondary", size="lg"
-                )
-                start_output = gr.Textbox(label="📋 Statut", lines=2)
-
-                start_btn.click(start_game, inputs=start_game_id, outputs=start_output)
-
-        with gr.Tab("🔎 Enquêter"):
-            gr.Markdown("### 📰 Tableau d'Enquête")
-            gr.Markdown("*Étudiez les preuves et faites vos déductions...*")
-
-            with gr.Group():
-                refresh_btn = gr.Button(
-                    "🔄 Actualiser le Dossier", size="lg", variant="secondary"
-                )
-                game_view = gr.Textbox(
-                    label="🗂️ Dossier du Détective",
-                    lines=20,
-                    max_lines=30,
-                    show_copy_button=True,
-                    info="Cliquez sur Actualiser pour voir l'état actuel de la partie",
-                )
-
-                refresh_btn.click(get_player_view, outputs=game_view)
-
-            gr.Markdown("---")
-            gr.Markdown("### 🔮 Proposition de Théorie")
-            gr.Markdown("*Testez une hypothèse auprès des autres détectives...*")
-
-            with gr.Group():
-                with gr.Row():
-                    suggest_character = gr.Dropdown(
-                        label="👤 Suspect",
-                        choices=DEFAULT_CHARACTERS,
-                        info="Choisissez un personnage",
-                    )
-                    suggest_weapon = gr.Dropdown(
-                        label="🔪 Arme du Crime",
-                        choices=DEFAULT_WEAPONS,
-                        info="Choisissez une arme",
-                    )
-                    suggest_room = gr.Dropdown(
-                        label="🚪 Lieu du Crime",
-                        choices=[],  # Will be populated from game
-                        info="Choisissez un lieu",
-                    )
-
-                suggest_btn = gr.Button(
-                    "💭 Proposer une Théorie", variant="primary", size="lg"
-                )
-                suggest_output = gr.Textbox(
-                    label="🗨️ Réponse", lines=3, show_copy_button=True
-                )
-
-                suggest_btn.click(
-                    make_suggestion,
-                    inputs=[suggest_character, suggest_weapon, suggest_room],
-                    outputs=suggest_output,
-                )
-
-            gr.Markdown("---")
-            gr.Markdown("### ⚖️ Accusation Finale")
-            gr.Markdown(
-                "### ⚠️ *Yamete cudasaï ! Une fausse accusation vous élimine de l'enquête !*"
-            )
-
-            with gr.Group():
-                with gr.Row():
-                    accuse_character = gr.Dropdown(
-                        label="👤 Le Meurtrier",
-                        choices=DEFAULT_CHARACTERS,
-                        info="Qui a commis le crime ?",
-                    )
-                    accuse_weapon = gr.Dropdown(
-                        label="🔪 L'Arme",
-                        choices=DEFAULT_WEAPONS,
-                        info="Avec quelle arme ?",
-                    )
-                    accuse_room = gr.Dropdown(
-                        label="🚪 Le Lieu", choices=[], info="Dans quel lieu ?"
-                    )
-
-                accuse_btn = gr.Button(
-                    "⚡ FAIRE L'ACCUSATION", variant="stop", size="lg"
-                )
-                accuse_output = gr.Textbox(
-                    label="⚖️ Verdict", lines=3, show_copy_button=True
-                )
-
-                accuse_btn.click(
-                    make_accusation,
-                    inputs=[accuse_character, accuse_weapon, accuse_room],
-                    outputs=accuse_output,
-                )
-
-            gr.Markdown("---")
-
-            with gr.Group():
-                pass_btn = gr.Button(
-                    "⏭️ Passer Mon Tour", variant="secondary", size="lg"
-                )
-                pass_output = gr.Textbox(label="📋 Statut", lines=1)
-
-                pass_btn.click(pass_turn, outputs=pass_output)
-
-    return demo
-
-
-def run_fastapi():
-    """
-    Run FastAPI server in a separate thread.
-    """
-    from api import app
-
-    uvicorn.run(app, host=settings.HOST, port=settings.PORT, log_level="info")
-
-
-if __name__ == "__main__":
-    # IS_HUGGINGFACE is already defined at the top of the file
-
-    if not IS_HUGGINGFACE:
-        # Local development: run FastAPI in background
-        def run_fastapi_bg():
-            """Run FastAPI on port 8000 in background"""
-            from api import app
-
-            uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
-
-        api_thread = threading.Thread(target=run_fastapi_bg, daemon=True)
-        api_thread.start()
-
-        # Wait for API to start
-        time.sleep(2)
-
-    # Create and launch Gradio interface
-    demo = create_gradio_interface()
-
-    if IS_HUGGINGFACE:
-        # On Hugging Face Spaces: Gradio only on port 7860 (no FastAPI)
-        demo.launch(
-            server_name="0.0.0.0",
-            share=False,
-            show_error=True,
-        )
-    else:
-        # Local development: Gradio on port 7861, FastAPI on 8000
-        demo.launch(
-            server_name="127.0.0.1",
-            server_port=7861,
-            share=False,
-            show_error=True,
-        )

ai_service.py → backend/ai_service.py

@@ -5,7 +5,7 @@ Only active when USE_OPENAI environment variable is set to true.
 
 from typing import Optional
 from openai import OpenAI
-from config import settings
+from backend.config import settings
 import asyncio
 
 
@@ -26,7 +26,8 @@ class AIService:
     async def generate_scenario(
         self,
         rooms: list[str],
-        characters: list[str]
+        characters: list[str],
+        narrative_tone: str = "🕵️ Sérieuse",
     ) -> Optional[str]:
         """
         Generate a mystery scenario based on the game setup.
@@ -36,22 +37,19 @@ class AIService:
             return None
 
         try:
-            prompt = f"""Create a brief mystery scenario (2-3 sentences) for a Cluedo game narrated by Desland, an old suspicious gardener.
+            prompt = f"""Crée un scénario de mystère bref (2-3 phrases) pour un jeu de Cluedo narré par Desland.
 
-IMPORTANT: The narrator is Desland (he used to say his name was Leland, but he always corrects himself to Desland). He's an old gardener who is extremely suspicious and seems to know dark secrets about what haunts this place. He speaks in a creepy, unsettling manner, always pretending everything is fine while subtly hinting at something deeply wrong. He never openly reveals the horror, but his words should make players feel uneasy.
+IMPORTANT: Desland est un vieux jardinier suspect, sarcastique et incisif. Il se trompe TOUJOURS sur son nom au début: "Moi c'est Lesland, euh non c'est Desland, Desland !" (ou variations). Il est condescendant, moqueur envers les détectives, et fait des remarques cinglantes.
 
-Rooms: {', '.join(rooms)}
-Characters: {', '.join(characters)}
+Ton narratif: {narrative_tone}
+Pièces: {', '.join(rooms)}
+Personnages: {', '.join(characters)}
 
-Start with Desland introducing himself (getting his name wrong first: "Je suis Leland... euh non, c'est Desland, Desland..." or variations), then write his introduction to the murder mystery. Make it atmospheric, creepy, and subtly horrifying. He should act like everything is normal while hinting at dark secrets."""
+COMMENCE obligatoirement par Desland se trompant sur son nom, puis introduis le meurtre avec son ton sarcastique et suspect caractéristique. Moque subtilement la situation et l'intelligence des enquêteurs."""
 
             # Run with timeout
             response = await asyncio.wait_for(
-                asyncio.to_thread(
-                    self._generate_text,
-                    prompt
-                ),
-                timeout=3.0
+                asyncio.to_thread(self._generate_text, prompt), timeout=10.0
             )
 
             return response
@@ -63,65 +61,127 @@ Start with Desland introducing himself (getting his name wrong first: "Je suis L
             print(f"Error generating scenario: {e}")
             return None
 
-    async def generate_turn_narration(
+    async def generate_suggestion_comment(
         self,
         player_name: str,
-        action: str
+        character: str,
+        weapon: str,
+        room: str,
+        was_disproven: bool,
+        narrative_tone: str = "🕵️ Sérieuse",
     ) -> Optional[str]:
         """
-        Generate narrative text for a player's turn.
+        Generate a sarcastic comment from Desland about a suggestion.
         Returns None if AI is disabled or if generation fails.
         """
         if not self.enabled or not self.client:
             return None
 
         try:
-            prompt = f"""Create a brief, atmospheric narration (1 sentence) for this Cluedo game action, narrated by Desland the suspicious old gardener:
+            result = "réfutée" if was_disproven else "pas réfutée"
+            prompt = f"""Desland, le vieux jardinier sarcastique, commente cette suggestion (1 phrase max):
 
-Player: {player_name}
-Action: {action}
+Joueur: {player_name}
+Suggestion: {character} avec {weapon} dans {room}
+Résultat: {result}
 
-Desland comments on the action. He's creepy and unsettling, always acting like everything is normal while subtly hinting at dark secrets. He knows something sinister about what haunts this place but pretends everything is fine. Make it suspenseful and slightly horrifying but very concise (1 sentence)."""
+IMPORTANT: Desland est SARCASTIQUE et INCISIF. Il se moque des théories absurdes avec des remarques cinglantes. Exemples:
+- "Et toi ça te semble logique que Pierre ait tué Daniel avec une clé USB à côté de l'étendoir ?? Sans surprise c'est pas la bonne réponse..."
+- "Une capsule de café comme arme du crime ? Brillant. Je suppose qu'il l'a noyé dans un expresso."
+- "Ah oui, très crédible. Le meurtrier qui laisse traîner son arme préférée dans la salle de bain. Excellent travail, détective."
+
+Ton narratif: {narrative_tone}
+Sois sarcastique, condescendant et incisif. Moque la logique (ou l'absence de logique) de la suggestion."""
+
+            response = await asyncio.wait_for(
+                asyncio.to_thread(self._generate_text, prompt), timeout=10.0
+            )
+
+            return response
+
+        except asyncio.TimeoutError:
+            print("AI comment generation timed out")
+            return None
+        except Exception as e:
+            print(f"Error generating comment: {e}")
+            return None
+
+    async def generate_accusation_comment(
+        self,
+        player_name: str,
+        character: str,
+        weapon: str,
+        room: str,
+        was_correct: bool,
+        narrative_tone: str = "🕵️ Sérieuse",
+    ) -> Optional[str]:
+        """
+        Generate a comment from Desland about an accusation.
+        Returns None if AI is disabled or if generation fails.
+        """
+        if not self.enabled or not self.client:
+            return None
+
+        try:
+            result = "correcte" if was_correct else "fausse"
+            prompt = f"""Desland commente cette accusation finale (1 phrase max):
+
+Joueur: {player_name}
+Accusation: {character} avec {weapon} dans {room}
+Résultat: {result}
+
+Ton narratif: {narrative_tone}
+
+Si correcte: Desland est surpris et impressionné à contrecœur (mais toujours sarcastique).
+Si fausse: Desland est condescendant et moqueur à propos de leur échec.
+
+Rends-le incisif et mémorable."""
 
             response = await asyncio.wait_for(
-                asyncio.to_thread(
-                    self._generate_text,
-                    prompt
-                ),
-                timeout=3.0
+                asyncio.to_thread(self._generate_text, prompt), timeout=10.0
             )
 
             return response
 
         except asyncio.TimeoutError:
-            print("AI narration generation timed out")
+            print("AI comment generation timed out")
             return None
         except Exception as e:
-            print(f"Error generating narration: {e}")
+            print(f"Error generating comment: {e}")
             return None
 
     def _generate_text(self, prompt: str) -> str:
         """
         Internal method to generate text using OpenAI API.
-        Uses low temperature for consistent output.
+        Uses higher temperature for creative sarcasm.
         """
         if not self.client:
             return ""
 
         response = self.client.chat.completions.create(
-            model="gpt-5-nano",
+            model="gpt-4o-mini",
             messages=[
                 {
                     "role": "system",
-                    "content": "You are Desland, a creepy old gardener narrating a mystery game. You're deeply suspicious and seem to know dark secrets about what haunts the place. You always pretend everything is fine while subtly hinting at something sinister. You often get your own name wrong at first (saying Leland instead of Desland). Your tone is unsettling but you never openly reveal the horror. Keep responses brief, atmospheric, and creepy."
+                    "content": """Tu es Desland, un vieux jardinier suspect, sarcastique et incisif.
+
+Traits clés:
+- SARCASTIQUE: Tu te moques des théories absurdes et des déductions illogiques avec des remarques cinglantes
+- INCISIF: Tes commentaires sont aiguisés, spirituels et parfois condescendants
+- SUSPECT: Tu agis comme si tu en savais plus que tu ne le dis, mais tu ne révèles jamais rien directement
+- Tu te trompes SOUVENT sur ton nom: "Moi c'est Lesland, euh non c'est Desland, Desland !" (surtout en introduction)
+
+Exemples de ton style:
+"Et toi ça te semble logique que Pierre ait tué Daniel avec une clé USB à côté de l'étendoir ?? Sans surprise c'est pas la bonne réponse..."
+"Une capsule de café ? Brillant. Parce que évidemment, on commet des meurtres avec du Nespresso maintenant."
+"Ah oui, excellente déduction Sherlock. Prochaine étape : accuser le chat du voisin."
+
+Garde tes réponses brèves (1 phrase pour les commentaires, 2-3 pour les scénarios), EN FRANÇAIS, sarcastiques et mémorables.""",
                 },
-                {
-                    "role": "user",
-                    "content": prompt
-                }
+                {"role": "user", "content": prompt},
             ],
-            temperature=0.8,
-            max_tokens=200
+            temperature=0.9,
+            max_tokens=150,
         )
 
         return response.choices[0].message.content.strip()

backend/defaults.py

@@ -0,0 +1,101 @@
+"""
+Default game presets for quick setup
+"""
+
+DEFAULT_THEMES = {
+    "classic": {
+        "name": "Meurtre au Manoir",
+        "tone": "🎬 Thriller",
+        "rooms": [
+            "Cuisine",
+            "Salon",
+            "Bureau",
+            "Chambre",
+            "Garage",
+            "Jardin"
+        ],
+        "weapons": [
+            "Poignard",
+            "Revolver",
+            "Corde",
+            "Chandelier",
+            "Clé anglaise",
+            "Poison"
+        ],
+        "suspects": [
+            "Mme Leblanc",
+            "Col. Moutarde",
+            "Mlle Rose",
+            "Prof. Violet",
+            "Mme Pervenche",
+            "M. Olive"
+        ]
+    },
+    "office": {
+        "name": "Meurtre au Bureau",
+        "tone": "😂 Parodique",
+        "rooms": [
+            "Open Space",
+            "Salle de réunion",
+            "Cafétéria",
+            "Bureau CEO",
+            "Toilettes",
+            "Parking"
+        ],
+        "weapons": [
+            "Clé USB",
+            "Agrafeuse",
+            "Câble HDMI",
+            "Capsule de café",
+            "Souris d'ordinateur",
+            "Plante verte"
+        ],
+        "suspects": [
+            "Claire",
+            "Pierre",
+            "Daniel",
+            "Marie",
+            "Thomas",
+            "Sophie"
+        ]
+    },
+    "fantasy": {
+        "name": "Meurtre au Château",
+        "tone": "🧙‍♂️ Fantastique",
+        "rooms": [
+            "Grande Salle",
+            "Tour des Mages",
+            "Donjon",
+            "Bibliothèque",
+            "Armurerie",
+            "Crypte"
+        ],
+        "weapons": [
+            "Épée enchantée",
+            "Potion empoisonnée",
+            "Grimoire maudit",
+            "Dague runique",
+            "Bâton magique",
+            "Amulette sombre"
+        ],
+        "suspects": [
+            "Merlin le Sage",
+            "Dame Morgane",
+            "Chevalier Lancelot",
+            "Elfe Aranelle",
+            "Nain Thorin",
+            "Sorcière Malva"
+        ]
+    }
+}
+
+# Default theme to use
+DEFAULT_THEME = "classic"
+
+def get_default_game_config(theme: str = DEFAULT_THEME):
+    """Get default game configuration"""
+    if theme not in DEFAULT_THEMES:
+        theme = DEFAULT_THEME
+
+    config = DEFAULT_THEMES[theme].copy()
+    return config

game_engine.py → backend/game_engine.py

@@ -5,11 +5,11 @@ Handles game logic, card distribution, turn management, and game rules.
 
 import random
 from typing import List, Optional, Tuple
-from models import Game, Card, CardType, Solution, GameStatus, Player
+from backend.models import Game, Card, CardType, Solution, GameStatus, Player
 from datetime import datetime
 
 
-# Default character names (can be customized)
+# Default character names (fallback if no custom suspects provided)
 DEFAULT_CHARACTERS = [
     "Miss Scarlett",
     "Colonel Mustard",
@@ -19,7 +19,7 @@ DEFAULT_CHARACTERS = [
     "Professor Plum"
 ]
 
-# Default weapon names (can be customized)
+# Default weapon names (fallback if no custom weapons provided)
 DEFAULT_WEAPONS = [
     "Candlestick",
     "Knife",
@@ -39,16 +39,20 @@ class GameEngine:
         Initialize a game with cards and solution.
         Distributes cards among players after setting aside the solution.
         """
+        # Use custom suspects or defaults
+        suspects = game.custom_suspects if game.custom_suspects else DEFAULT_CHARACTERS
+        weapons = game.custom_weapons if game.custom_weapons else DEFAULT_WEAPONS
+
         # Create character cards
         game.characters = [
             Card(name=name, card_type=CardType.CHARACTER)
-            for name in DEFAULT_CHARACTERS
+            for name in suspects
         ]
 
         # Create weapon cards
         game.weapons = [
             Card(name=name, card_type=CardType.WEAPON)
-            for name in DEFAULT_WEAPONS
+            for name in weapons
         ]
 
         # Create room cards
@@ -206,10 +210,11 @@ class GameEngine:
         game: Game,
         player_id: str,
         action: str,
-        details: Optional[str] = None
+        details: Optional[str] = None,
+        ai_comment: Optional[str] = None
     ):
         """Add a turn record to the game history."""
-        from models import Turn
+        from backend.models import Turn
 
         player = next((p for p in game.players if p.id == player_id), None)
         if not player:
@@ -220,6 +225,7 @@ class GameEngine:
             player_name=player.name,
             action=action,
             details=details,
+            ai_comment=ai_comment,
             timestamp=datetime.now().isoformat()
         )
         game.turns.append(turn)
@@ -241,3 +247,49 @@ class GameEngine:
             current_player.is_active and
             game.status == GameStatus.IN_PROGRESS
         )
+
+    @staticmethod
+    def roll_dice() -> int:
+        """Roll a single die (1-6)."""
+        return random.randint(1, 6)
+
+    @staticmethod
+    def move_player(game: Game, player_id: str, dice_roll: int) -> Tuple[bool, str, int]:
+        """
+        Move a player to a room based on dice roll.
+        Dice value maps directly to room index (1→room 0, 2→room 1, etc.)
+        Returns (success, message, new_room_index).
+        """
+        player = next((p for p in game.players if p.id == player_id), None)
+        if not player:
+            return False, "Joueur introuvable", -1
+
+        num_rooms = len(game.rooms)
+        if num_rooms == 0:
+            return False, "Pas de pièces disponibles", -1
+
+        # Map dice roll to room (1-6 maps to rooms, if more rooms, use modulo)
+        new_room_index = (dice_roll - 1) % num_rooms
+        old_room = game.rooms[player.current_room_index] if player.current_room_index < num_rooms else "???"
+        new_room = game.rooms[new_room_index]
+
+        player.current_room_index = new_room_index
+
+        message = f"🎲 Dé: {dice_roll} → {new_room}"
+        return True, message, new_room_index
+
+    @staticmethod
+    def can_make_suggestion(game: Game, player_id: str, room: str) -> Tuple[bool, str]:
+        """
+        Check if a player can make a suggestion.
+        Players can only suggest in the room they're currently in.
+        """
+        player = next((p for p in game.players if p.id == player_id), None)
+        if not player:
+            return False, "Joueur introuvable"
+
+        current_room = game.rooms[player.current_room_index]
+        if current_room != room:
+            return False, f"Tu dois être dans {room} pour faire cette suggestion ! Tu es actuellement dans {current_room}."
+
+        return True, ""

game_manager.py → backend/game_manager.py

@@ -6,9 +6,9 @@ Provides in-memory storage and game lifecycle management.
 import json
 import os
 from typing import Dict, Optional, List
-from models import Game, Player, CreateGameRequest, GameStatus
-from game_engine import GameEngine
-from config import settings
+from backend.models import Game, Player, CreateGameRequest, GameStatus
+from backend.game_engine import GameEngine
+from backend.config import settings
 
 
 class GameManager:
@@ -31,8 +31,13 @@ class GameManager:
         game = Game(
             game_id=game_id,
             name=request.game_name,
+            narrative_tone=request.narrative_tone,
+            custom_prompt=request.custom_prompt,
             rooms=request.rooms,
+            custom_weapons=request.custom_weapons,
+            custom_suspects=request.custom_suspects,
             use_ai=request.use_ai,
+            board_layout=request.board_layout,
             max_players=settings.MAX_PLAYERS
         )
 

backend/main.py

@@ -0,0 +1,467 @@
+"""
+FastAPI backend for Cluedo Custom
+Serves both API and React frontend
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import Optional, List
+import os
+
+from backend.models import CreateGameRequest, GameStatus
+from backend.game_manager import game_manager
+from backend.game_engine import GameEngine
+from backend.defaults import get_default_game_config, DEFAULT_THEMES
+
+app = FastAPI(title="Cluedo Custom API")
+
+# CORS for development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ==================== API ROUTES ====================
+
+@app.get("/api/health")
+async def health():
+    return {"status": "ok", "message": "Cluedo Custom API is running"}
+
+
+@app.get("/api/themes")
+async def get_themes():
+    """Get available game themes"""
+    return {"themes": DEFAULT_THEMES}
+
+
+class QuickCreateRequest(BaseModel):
+    theme: str = "classic"
+    player_name: str
+
+
+@app.post("/api/games/quick-create")
+async def quick_create_game(req: QuickCreateRequest):
+    """Create a game quickly with default theme"""
+    try:
+        config = get_default_game_config(req.theme)
+
+        # Create default board layout
+        from backend.models import BoardLayout, RoomPosition
+        board_layout = BoardLayout(
+            rooms=[
+                RoomPosition(name=room, x=i % 3, y=i // 3)
+                for i, room in enumerate(config["rooms"])
+            ],
+            grid_width=3,
+            grid_height=2
+        )
+
+        game_req = CreateGameRequest(
+            game_name=config["name"],
+            narrative_tone=config["tone"],
+            custom_prompt=None,
+            rooms=config["rooms"],
+            custom_weapons=config["weapons"],
+            custom_suspects=config["suspects"],
+            use_ai=True,  # Enable AI by default
+            board_layout=board_layout
+        )
+
+        game = game_manager.create_game(game_req)
+
+        # Auto-join creator as first player
+        player = game_manager.join_game(game.game_id, req.player_name)
+
+        return {
+            "game_id": game.game_id,
+            "player_id": player.id if player else None,
+            "game_name": game.name,
+            "theme": req.theme
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class JoinRequest(BaseModel):
+    game_id: str
+    player_name: str
+
+
+@app.post("/api/games/join")
+async def join_game(req: JoinRequest):
+    """Join an existing game"""
+    game = game_manager.get_game(req.game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if game.status != GameStatus.WAITING:
+        raise HTTPException(status_code=400, detail="Game already started")
+
+    if game.is_full():
+        raise HTTPException(status_code=400, detail="Game is full")
+
+    player = game_manager.join_game(req.game_id.upper(), req.player_name)
+
+    if not player:
+        raise HTTPException(status_code=400, detail="Could not join game")
+
+    return {
+        "game_id": game.game_id,
+        "player_id": player.id,
+        "player_name": player.name
+    }
+
+
+@app.post("/api/games/{game_id}/start")
+async def start_game(game_id: str):
+    """Start a game"""
+    success = game_manager.start_game(game_id.upper())
+
+    if not success:
+        raise HTTPException(status_code=400, detail="Cannot start game (need min 3 players)")
+
+    game = game_manager.get_game(game_id.upper())
+
+    # Generate AI scenario if enabled
+    if game and game.use_ai and not game.scenario:
+        try:
+            from backend.ai_service import ai_service
+            game.scenario = await ai_service.generate_scenario(
+                game.rooms,
+                [c.name for c in game.characters],
+                game.narrative_tone
+            )
+            game_manager.save_games()
+        except Exception as e:
+            print(f"AI scenario generation failed: {e}")
+
+    return {
+        "status": "started",
+        "first_player": game.get_current_player().name if game else None,
+        "scenario": game.scenario if game else None
+    }
+
+
+@app.get("/api/games/{game_id}/state/{player_id}")
+async def get_game_state(game_id: str, player_id: str):
+    """Get game state for a specific player"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    player = next((p for p in game.players if p.id == player_id), None)
+
+    if not player:
+        raise HTTPException(status_code=404, detail="Player not found")
+
+    current_player = game.get_current_player()
+
+    # Build player-specific view
+    return {
+        "game_id": game.game_id,
+        "game_name": game.name,
+        "status": game.status.value,
+        "scenario": game.scenario,
+        "use_ai": game.use_ai,
+        "rooms": game.rooms,
+        "suspects": [c.name for c in game.characters],
+        "weapons": [w.name for w in game.weapons],
+        "my_cards": [{"name": c.name, "type": c.card_type.value} for c in player.cards],
+        "my_position": player.current_room_index,
+        "current_room": game.rooms[player.current_room_index] if game.rooms else None,
+        "board_layout": game.board_layout.model_dump() if game.board_layout else None,
+        "players": [
+            {
+                "name": p.name,
+                "is_active": p.is_active,
+                "position": p.current_room_index,
+                "room": game.rooms[p.current_room_index] if game.rooms else None,
+                "is_me": p.id == player_id
+            }
+            for p in game.players
+        ],
+        "current_turn": {
+            "player_name": current_player.name if current_player else None,
+            "is_my_turn": current_player.id == player_id if current_player else False
+        },
+        "recent_actions": [
+            {
+                "player": t.player_name,
+                "action": t.action,
+                "details": t.details,
+                "ai_comment": t.ai_comment
+            }
+            for t in game.turns[-10:]  # Show more history
+        ],
+        "winner": game.winner
+    }
+
+
+class DiceRollRequest(BaseModel):
+    player_id: str
+
+
+@app.post("/api/games/{game_id}/roll")
+async def roll_dice(game_id: str, req: DiceRollRequest):
+    """Roll dice and move player"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Check if player already rolled
+    player = next((p for p in game.players if p.id == req.player_id), None)
+    if player and player.has_rolled:
+        raise HTTPException(status_code=400, detail="Vous avez déjà lancé les dés ce tour")
+
+    # Roll dice
+    dice = GameEngine.roll_dice()
+
+    # Move player
+    success, msg, new_pos = GameEngine.move_player(game, req.player_id, dice)
+
+    if not success:
+        raise HTTPException(status_code=400, detail=msg)
+
+    # Get player name
+    player = next((p for p in game.players if p.id == req.player_id), None)
+    player_name = player.name if player else "Inconnu"
+
+    # Generate AI comment if enabled
+    ai_comment = None
+    if game.use_ai:
+        try:
+            from backend.ai_service import ai_service
+            # Simple comment about movement
+            prompts = [
+                f"{player_name} se dirige vers {game.rooms[new_pos]}... Intéressant choix.",
+                f"Ah, {game.rooms[new_pos]}. {player_name} pense y trouver quelque chose ?",
+                f"{player_name} va fouiner dans {game.rooms[new_pos]}. Bonne chance avec ça."
+            ]
+            import random
+            ai_comment = random.choice(prompts)
+        except Exception as e:
+            print(f"AI comment generation failed: {e}")
+
+    # Mark player as having rolled
+    if player:
+        player.has_rolled = True
+
+    # Record turn with AI comment
+    GameEngine.add_turn_record(game, req.player_id, "move", msg, ai_comment=ai_comment)
+    game_manager.save_games()
+
+    return {
+        "dice_value": dice,
+        "new_position": new_pos,
+        "new_room": game.rooms[new_pos],
+        "message": msg
+    }
+
+
+class SuggestionRequest(BaseModel):
+    player_id: str
+    suspect: str
+    weapon: str
+    room: str
+
+
+@app.post("/api/games/{game_id}/suggest")
+async def make_suggestion(game_id: str, req: SuggestionRequest):
+    """Make a suggestion"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Check if player is in the room
+    can_suggest, error = GameEngine.can_make_suggestion(game, req.player_id, req.room)
+    if not can_suggest:
+        raise HTTPException(status_code=400, detail=error)
+
+    # Process suggestion
+    can_disprove, disprover, card = GameEngine.check_suggestion(
+        game, req.player_id, req.suspect, req.weapon, req.room
+    )
+
+    # Get player name
+    player = next((p for p in game.players if p.id == req.player_id), None)
+    player_name = player.name if player else "Inconnu"
+
+    # Generate AI comment if enabled
+    ai_comment = None
+    if game.use_ai:
+        try:
+            from backend.ai_service import ai_service
+            import asyncio
+            ai_comment = await ai_service.generate_suggestion_comment(
+                player_name,
+                req.suspect,
+                req.weapon,
+                req.room,
+                can_disprove,
+                game.narrative_tone
+            )
+        except Exception as e:
+            print(f"AI comment generation failed: {e}")
+
+    result = {
+        "suggestion": f"{req.suspect} + {req.weapon} + {req.room}",
+        "was_disproven": can_disprove,
+        "disprover": disprover if can_disprove else None,
+        "card_shown": {
+            "name": card.name,
+            "type": card.card_type.value
+        } if card else None
+    }
+
+    # Record turn with AI comment
+    GameEngine.add_turn_record(
+        game,
+        req.player_id,
+        "suggest",
+        result["suggestion"],
+        ai_comment=ai_comment
+    )
+
+    game.next_turn()
+    game_manager.save_games()
+
+    return result
+
+
+class AccusationRequest(BaseModel):
+    player_id: str
+    suspect: str
+    weapon: str
+    room: str
+
+
+@app.post("/api/games/{game_id}/accuse")
+async def make_accusation(game_id: str, req: AccusationRequest):
+    """Make an accusation"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Process accusation
+    is_correct, message = GameEngine.process_accusation(
+        game, req.player_id, req.suspect, req.weapon, req.room
+    )
+
+    # Get player name
+    player = next((p for p in game.players if p.id == req.player_id), None)
+    player_name = player.name if player else "Inconnu"
+
+    # Generate AI comment if enabled
+    ai_comment = None
+    if game.use_ai:
+        try:
+            from backend.ai_service import ai_service
+            ai_comment = await ai_service.generate_accusation_comment(
+                player_name,
+                req.suspect,
+                req.weapon,
+                req.room,
+                is_correct,
+                game.narrative_tone
+            )
+        except Exception as e:
+            print(f"AI comment generation failed: {e}")
+
+    # Record turn with AI comment
+    GameEngine.add_turn_record(
+        game,
+        req.player_id,
+        "accuse",
+        f"{req.suspect} + {req.weapon} + {req.room}",
+        ai_comment=ai_comment
+    )
+
+    if not is_correct and game.status == GameStatus.IN_PROGRESS:
+        game.next_turn()
+
+    game_manager.save_games()
+
+    return {
+        "is_correct": is_correct,
+        "message": message,
+        "winner": game.winner
+    }
+
+
+class PassRequest(BaseModel):
+    player_id: str
+
+
+@app.post("/api/games/{game_id}/pass")
+async def pass_turn(game_id: str, req: PassRequest):
+    """Pass the turn"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Record turn
+    GameEngine.add_turn_record(game, req.player_id, "pass", "Passed turn")
+
+    game.next_turn()
+    game_manager.save_games()
+
+    next_player = game.get_current_player()
+
+    return {
+        "message": "Turn passed",
+        "next_player": next_player.name if next_player else None
+    }
+
+
+# ==================== SERVE REACT APP ====================
+
+# Check if frontend build exists
+frontend_path = os.path.join(os.path.dirname(__file__), "..", "frontend", "dist")
+
+if os.path.exists(frontend_path):
+    # Serve static files
+    app.mount("/assets", StaticFiles(directory=os.path.join(frontend_path, "assets")), name="assets")
+
+    @app.get("/{full_path:path}")
+    async def serve_react(full_path: str):
+        """Serve React app for all non-API routes"""
+        if full_path.startswith("api/"):
+            raise HTTPException(status_code=404, detail="API route not found")
+
+        index_file = os.path.join(frontend_path, "index.html")
+        if os.path.exists(index_file):
+            return FileResponse(index_file)
+        else:
+            raise HTTPException(status_code=404, detail="Frontend not built")
+else:
+    @app.get("/")
+    async def root():
+        return {
+            "message": "Cluedo Custom API",
+            "docs": "/docs",
+            "frontend": "Not built yet. Run: cd frontend && npm run build"
+        }

models.py → backend/models.py

@@ -10,6 +10,15 @@ import random
 import string
 
 
+class NarrativeTone(str, Enum):
+    """Narrative tone options for the game."""
+    SERIOUS = "🕵️ Sérieuse"
+    PARODY = "😂 Parodique"
+    FANTASY = "🧙‍♂️ Fantastique"
+    THRILLER = "🎬 Thriller"
+    HORROR = "👻 Horreur"
+
+
 class CardType(str, Enum):
     """Types of cards in the game."""
     CHARACTER = "character"
@@ -29,6 +38,8 @@ class Player(BaseModel):
     name: str
     cards: List[Card] = Field(default_factory=list)
     is_active: bool = True
+    current_room_index: int = 0  # Position on the board
+    has_rolled: bool = False  # Track if player rolled dice this turn
 
 
 class GameStatus(str, Enum):
@@ -42,8 +53,9 @@ class Turn(BaseModel):
     """Represents a turn action in the game."""
     player_id: str
     player_name: str
-    action: str  # "move", "suggest", "accuse"
+    action: str  # "move", "suggest", "accuse", "pass"
     details: Optional[str] = None
+    ai_comment: Optional[str] = None  # Desland's sarcastic comment
     timestamp: str
 
 
@@ -54,12 +66,43 @@ class Solution(BaseModel):
     room: Card
 
 
+class InvestigationNote(BaseModel):
+    """Player's notes on the investigation."""
+    player_id: str
+    element_name: str  # Name of suspect/weapon/room
+    element_type: str  # "suspect", "weapon", "room"
+    status: str  # "unknown", "eliminated", "maybe"
+
+
+class RoomPosition(BaseModel):
+    """Position of a room on the board."""
+    name: str
+    x: int  # Grid X position
+    y: int  # Grid Y position
+
+
+class BoardLayout(BaseModel):
+    """Board layout configuration."""
+    rooms: List[RoomPosition] = Field(default_factory=list)
+    grid_width: int = 8
+    grid_height: int = 8
+
+
 class Game(BaseModel):
     """Represents a complete game instance."""
     game_id: str
     name: str
     status: GameStatus = GameStatus.WAITING
+
+    # Theme and narrative
+    narrative_tone: str = NarrativeTone.SERIOUS.value
+    custom_prompt: Optional[str] = None
+
+    # Game elements (customizable)
     rooms: List[str]
+    custom_weapons: List[str] = Field(default_factory=list)
+    custom_suspects: List[str] = Field(default_factory=list)
+
     use_ai: bool = False
 
     # Players
@@ -79,18 +122,26 @@ class Game(BaseModel):
     turns: List[Turn] = Field(default_factory=list)
     winner: Optional[str] = None
 
+    # Investigation notes (for UI)
+    investigation_notes: List[InvestigationNote] = Field(default_factory=list)
+
+    # Board layout
+    board_layout: Optional[BoardLayout] = None
+
     # AI-generated content
     scenario: Optional[str] = None
 
     @staticmethod
     def generate_game_id() -> str:
-        """Generate a unique 6-character game ID."""
-        return ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
+        """Generate a unique 4-character game ID (like AB7F)."""
+        chars = string.ascii_uppercase + string.digits
+        return ''.join(random.choices(chars, k=4))
 
     def add_player(self, player_name: str) -> Player:
         """Add a new player to the game."""
         player_id = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
-        player = Player(id=player_id, name=player_name)
+        # All players start in the first room
+        player = Player(id=player_id, name=player_name, current_room_index=0)
         self.players.append(player)
         return player
 
@@ -101,9 +152,21 @@ class Game(BaseModel):
         return self.players[self.current_player_index]
 
     def next_turn(self):
-        """Move to the next player's turn."""
-        if self.players:
+        """Move to the next active player's turn."""
+        if not self.players:
+            return
+
+        # Reset has_rolled for current player
+        if self.current_player_index < len(self.players):
+            self.players[self.current_player_index].has_rolled = False
+
+        # Skip eliminated players
+        attempts = 0
+        while attempts < len(self.players):
             self.current_player_index = (self.current_player_index + 1) % len(self.players)
+            if self.players[self.current_player_index].is_active:
+                break
+            attempts += 1
 
     def is_full(self) -> bool:
         """Check if the game has reached maximum players."""
@@ -113,8 +176,13 @@ class Game(BaseModel):
 class CreateGameRequest(BaseModel):
     """Request to create a new game."""
     game_name: str
+    narrative_tone: str = NarrativeTone.SERIOUS.value
+    custom_prompt: Optional[str] = None
     rooms: List[str]
+    custom_weapons: List[str]
+    custom_suspects: List[str]
     use_ai: bool = False
+    board_layout: Optional[BoardLayout] = None
 
 
 class JoinGameRequest(BaseModel):
@@ -127,7 +195,11 @@ class GameAction(BaseModel):
     """Request to perform a game action."""
     game_id: str
     player_id: str
-    action_type: str  # "suggest", "accuse", "pass"
+    action_type: str  # "move", "suggest", "accuse", "pass"
+    # For movement
+    dice_roll: Optional[int] = None
+    target_room_index: Optional[int] = None
+    # For suggestions/accusations
     character: Optional[str] = None
     weapon: Optional[str] = None
     room: Optional[str] = None

backend/requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+python-multipart==0.0.6
+openai==1.3.0

docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - PYTHONUNBUFFERED=1
+    volumes:
+      - ./backend:/app/backend
+      - ./frontend/dist:/app/frontend/dist

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="fr">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>🔍 Cluedo Custom</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "cluedo-custom-frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.20.0",
+    "axios": "^1.6.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.43",
+    "@types/react-dom": "^18.2.17",
+    "@vitejs/plugin-react": "^4.2.1",
+    "autoprefixer": "^10.4.16",
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.3.6",
+    "vite": "^5.0.8"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.jsx

@@ -0,0 +1,18 @@
+import { BrowserRouter, Routes, Route } from 'react-router-dom'
+import Home from './pages/Home'
+import Join from './pages/Join'
+import Game from './pages/Game'
+
+function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/join" element={<Join />} />
+        <Route path="/game/:gameId/:playerId" element={<Game />} />
+      </Routes>
+    </BrowserRouter>
+  )
+}
+
+export default App

frontend/src/api.js

@@ -0,0 +1,108 @@
+import axios from 'axios';
+
+const API_BASE = import.meta.env.VITE_API_URL || '/api';
+
+const api = axios.create({
+  baseURL: API_BASE,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Helper functions for easier usage
+export const createQuickGame = async (playerName, theme = 'classic') => {
+  const response = await api.post('/games/quick-create', { theme, player_name: playerName });
+  return response.data;
+};
+
+export const joinGame = async (gameId, playerName) => {
+  const response = await api.post('/games/join', { game_id: gameId, player_name: playerName });
+  return response.data;
+};
+
+export const startGame = async (gameId, playerId) => {
+  const response = await api.post(`/games/${gameId}/start`, { player_id: playerId });
+  return response.data;
+};
+
+export const getGameState = async (gameId, playerId) => {
+  const response = await api.get(`/games/${gameId}/state/${playerId}`);
+  return response.data;
+};
+
+export const rollDice = async (gameId, playerId) => {
+  const response = await api.post(`/games/${gameId}/roll`, { player_id: playerId });
+  return response.data;
+};
+
+export const makeSuggestion = async (gameId, playerId, suspect, weapon, room) => {
+  const response = await api.post(`/games/${gameId}/suggest`, {
+    player_id: playerId,
+    suspect,
+    weapon,
+    room,
+  });
+  return response.data;
+};
+
+export const makeAccusation = async (gameId, playerId, suspect, weapon, room) => {
+  const response = await api.post(`/games/${gameId}/accuse`, {
+    player_id: playerId,
+    suspect,
+    weapon,
+    room,
+  });
+  return response.data;
+};
+
+export const passTurn = async (gameId, playerId) => {
+  const response = await api.post(`/games/${gameId}/pass`, { player_id: playerId });
+  return response.data;
+};
+
+export const gameAPI = {
+  // Get available themes
+  getThemes: () => api.get('/themes'),
+
+  // Quick create with defaults
+  quickCreate: (theme, playerName) =>
+    api.post('/games/quick-create', { theme, player_name: playerName }),
+
+  // Join existing game
+  join: (gameId, playerName) =>
+    api.post('/games/join', { game_id: gameId, player_name: playerName }),
+
+  // Start game
+  start: (gameId) => api.post(`/games/${gameId}/start`),
+
+  // Get game state
+  getState: (gameId, playerId) => api.get(`/games/${gameId}/state/${playerId}`),
+
+  // Roll dice
+  rollDice: (gameId, playerId) =>
+    api.post(`/games/${gameId}/roll`, { player_id: playerId }),
+
+  // Make suggestion
+  suggest: (gameId, playerId, suspect, weapon, room) =>
+    api.post(`/games/${gameId}/suggest`, {
+      player_id: playerId,
+      suspect,
+      weapon,
+      room,
+    }),
+
+  // Make accusation
+  accuse: (gameId, playerId, suspect, weapon, room) =>
+    api.post(`/games/${gameId}/accuse`, {
+      player_id: playerId,
+      suspect,
+      weapon,
+      room,
+    }),
+
+  // Pass turn
+  pass: (gameId, playerId) =>
+    api.post(`/games/${gameId}/pass`, { player_id: playerId }),
+};
+
+export default api;

frontend/src/components/AINavigator.jsx

@@ -0,0 +1,89 @@
+import { useState, useEffect, useRef } from 'react'
+
+function AINavigator({ recentActions, gameStatus }) {
+  const [comments, setComments] = useState([])
+  const scrollRef = useRef(null)
+
+  useEffect(() => {
+    // Extract AI comments from recent actions
+    if (recentActions) {
+      const aiComments = recentActions
+        .filter(action => action.ai_comment)
+        .map(action => ({
+          id: `${action.player}-${action.action}-${Date.now()}`,
+          text: action.ai_comment,
+          player: action.player,
+          action: action.action
+        }))
+
+      setComments(aiComments)
+    }
+  }, [recentActions])
+
+  useEffect(() => {
+    // Auto-scroll to latest comment
+    if (scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight
+    }
+  }, [comments])
+
+  if (gameStatus === 'waiting') {
+    return (
+      <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-purple/30">
+        <h2 className="text-xl font-bold text-haunted-purple mb-4 animate-flicker">
+          👻 Desland, le Narrateur
+        </h2>
+        <div className="text-haunted-fog/70 italic">
+          <p className="mb-2">
+            "Je suis Leland... euh non, Desland. Le vieux jardinier de ce manoir maudit."
+          </p>
+          <p>
+            En attendant que les enquêteurs arrivent... s'ils osent.
+          </p>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-purple/30">
+      <h2 className="text-xl font-bold text-haunted-purple mb-4 animate-flicker flex items-center gap-2">
+        👻 Desland, le Narrateur
+        <span className="text-xs text-haunted-fog/60 font-normal">(IA activée)</span>
+      </h2>
+
+      <div
+        ref={scrollRef}
+        className="space-y-3 max-h-64 overflow-y-auto scrollbar-thin scrollbar-thumb-haunted-purple/50 scrollbar-track-black/20"
+      >
+        {comments.length === 0 ? (
+          <div className="text-haunted-fog/60 italic text-sm">
+            <p>"Alors, on attend quoi pour commencer cette enquête ridicule ?"</p>
+          </div>
+        ) : (
+          comments.map((comment, idx) => (
+            <div
+              key={idx}
+              className="bg-black/40 p-3 rounded border-l-4 border-haunted-purple animate-fade-in"
+            >
+              <div className="text-xs text-haunted-fog/50 mb-1">
+                {comment.player} • {comment.action}
+              </div>
+              <div className="text-haunted-fog italic">
+                "{comment.text}"
+              </div>
+            </div>
+          ))
+        )}
+      </div>
+
+      <div className="mt-4 pt-4 border-t border-haunted-shadow text-xs text-haunted-fog/60">
+        <p className="italic">
+          💀 Desland commente vos actions avec son sarcasme légendaire...
+        </p>
+      </div>
+    </div>
+  )
+}
+
+export default AINavigator

frontend/src/components/GameBoard.jsx

@@ -0,0 +1,93 @@
+import { useState } from 'react'
+
+function GameBoard({ boardLayout, players, rooms, myPosition }) {
+  if (!boardLayout || !boardLayout.rooms) {
+    return (
+      <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-shadow">
+        <h2 className="text-xl font-bold text-haunted-blood mb-4 animate-flicker">🏰 Plateau de Jeu</h2>
+        <p className="text-haunted-fog/60">Plateau en cours de chargement...</p>
+      </div>
+    )
+  }
+
+  const gridWidth = boardLayout.grid_width || 8
+  const gridHeight = boardLayout.grid_height || 8
+
+  // Get players in each room
+  const getPlayersInRoom = (roomName) => {
+    return players?.filter(p => {
+      const roomIndex = rooms?.indexOf(roomName)
+      return roomIndex !== -1 && p.position === roomIndex
+    }) || []
+  }
+
+  return (
+    <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-shadow">
+      <h2 className="text-xl font-bold text-haunted-blood mb-4 animate-flicker">🏰 Plateau du Manoir</h2>
+
+      <div
+        className="grid gap-2 mx-auto"
+        style={{
+          gridTemplateColumns: `repeat(${gridWidth}, minmax(0, 1fr))`,
+          maxWidth: `${gridWidth * 100}px`
+        }}
+      >
+        {Array.from({ length: gridHeight }).map((_, y) =>
+          Array.from({ length: gridWidth }).map((_, x) => {
+            const room = boardLayout.rooms.find(r => r.x === x && r.y === y)
+            const playersHere = room ? getPlayersInRoom(room.name) : []
+            const isMyLocation = room && rooms?.indexOf(room.name) === myPosition
+
+            return (
+              <div
+                key={`${x}-${y}`}
+                className={`
+                  aspect-square rounded-lg border-2 transition-all
+                  ${room
+                    ? isMyLocation
+                      ? 'bg-haunted-blood/20 border-haunted-blood shadow-[0_0_20px_rgba(139,0,0,0.3)]'
+                      : 'bg-black/40 border-haunted-shadow hover:border-haunted-purple/50'
+                    : 'bg-dark-800/20 border-dark-700'
+                  }
+                `}
+              >
+                {room ? (
+                  <div className="h-full flex flex-col items-center justify-center p-1 text-center">
+                    <div className="text-xs font-semibold text-haunted-fog mb-1 truncate w-full">
+                      {room.name}
+                    </div>
+                    {playersHere.length > 0 && (
+                      <div className="flex flex-wrap gap-1 justify-center">
+                        {playersHere.map((p, i) => (
+                          <div
+                            key={i}
+                            className={`
+                              w-6 h-6 rounded-full flex items-center justify-center text-xs
+                              ${p.is_me
+                                ? 'bg-haunted-blood text-white font-bold'
+                                : 'bg-haunted-purple/70 text-white'
+                              }
+                            `}
+                            title={p.name}
+                          >
+                            {p.name.charAt(0).toUpperCase()}
+                          </div>
+                        ))}
+                      </div>
+                    )}
+                  </div>
+                ) : null}
+              </div>
+            )
+          })
+        )}
+      </div>
+
+      <div className="mt-4 pt-4 border-t border-haunted-shadow text-xs text-haunted-fog/60">
+        <p>🔴 Votre position • 🟣 Autres joueurs</p>
+      </div>
+    </div>
+  )
+}
+
+export default GameBoard

frontend/src/components/InvestigationGrid.jsx

@@ -0,0 +1,129 @@
+import { useState, useEffect } from 'react'
+
+function InvestigationGrid({ suspects, weapons, rooms, myCards }) {
+  const [notes, setNotes] = useState({})
+
+  // Initialize notes from localStorage and set my cards
+  useEffect(() => {
+    const saved = localStorage.getItem('investigation_notes')
+    const initialNotes = saved ? JSON.parse(saved) : {}
+
+    // Initialize all items as 'unknown' if not already set
+    // This ensures cards not in my hand have a default status
+    const allItems = [
+      ...(suspects?.map(s => ({ name: s, type: 'character' })) || []),
+      ...(weapons?.map(w => ({ name: w, type: 'weapon' })) || []),
+      ...(rooms?.map(r => ({ name: r, type: 'room' })) || [])
+    ]
+
+    allItems.forEach(item => {
+      const key = `${item.type}:${item.name}`
+      // Only set to unknown if not already tracked
+      if (!(key in initialNotes)) {
+        initialNotes[key] = 'unknown'
+      }
+    })
+
+    setNotes(initialNotes)
+  }, [suspects, weapons, rooms])
+
+  // Save notes to localStorage
+  useEffect(() => {
+    localStorage.setItem('investigation_notes', JSON.stringify(notes))
+  }, [notes])
+
+  const toggleNote = (item, type) => {
+    const key = `${type}:${item}`
+    setNotes(prev => {
+      const current = prev[key] || 'unknown'
+      const next = current === 'unknown' ? 'eliminated' :
+                   current === 'eliminated' ? 'maybe' : 'unknown'
+      return { ...prev, [key]: next }
+    })
+  }
+
+  const getStatus = (item, type) => {
+    const key = `${type}:${item}`
+    return notes[key] || 'unknown'
+  }
+
+  const getIcon = (item, type) => {
+    // Check if this is one of my cards
+    const isMyCard = myCards?.some(card =>
+      card.name === item && card.type === type
+    )
+
+    if (isMyCard) return '✅' // I have this card
+
+    const status = getStatus(item, type)
+    if (status === 'eliminated') return '❌'
+    if (status === 'maybe') return '❓'
+    return '⬜'
+  }
+
+  return (
+    <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-shadow">
+      <h2 className="text-xl font-bold text-haunted-blood mb-4 animate-flicker">📋 Grille d'Enquête</h2>
+
+      <div className="space-y-4">
+        {/* Suspects */}
+        <div>
+          <h3 className="text-sm font-semibold text-haunted-fog mb-2">👤 SUSPECTS</h3>
+          <div className="grid grid-cols-2 gap-2">
+            {suspects?.map((suspect, i) => (
+              <button
+                key={i}
+                onClick={() => toggleNote(suspect, 'character')}
+                className="flex items-center gap-2 bg-black/40 px-3 py-2 rounded text-left text-sm text-haunted-fog border border-haunted-shadow hover:border-haunted-blood/50 transition-all"
+              >
+                <span className="text-lg">{getIcon(suspect, 'character')}</span>
+                <span className="flex-1 truncate">{suspect}</span>
+              </button>
+            ))}
+          </div>
+        </div>
+
+        {/* Weapons */}
+        <div>
+          <h3 className="text-sm font-semibold text-haunted-fog mb-2">🔪 ARMES</h3>
+          <div className="grid grid-cols-2 gap-2">
+            {weapons?.map((weapon, i) => (
+              <button
+                key={i}
+                onClick={() => toggleNote(weapon, 'weapon')}
+                className="flex items-center gap-2 bg-black/40 px-3 py-2 rounded text-left text-sm text-haunted-fog border border-haunted-shadow hover:border-haunted-blood/50 transition-all"
+              >
+                <span className="text-lg">{getIcon(weapon, 'weapon')}</span>
+                <span className="flex-1 truncate">{weapon}</span>
+              </button>
+            ))}
+          </div>
+        </div>
+
+        {/* Rooms */}
+        <div>
+          <h3 className="text-sm font-semibold text-haunted-fog mb-2">🏚️ SALLES</h3>
+          <div className="grid grid-cols-2 gap-2">
+            {rooms?.map((room, i) => (
+              <button
+                key={i}
+                onClick={() => toggleNote(room, 'room')}
+                className="flex items-center gap-2 bg-black/40 px-3 py-2 rounded text-left text-sm text-haunted-fog border border-haunted-shadow hover:border-haunted-blood/50 transition-all"
+              >
+                <span className="text-lg">{getIcon(room, 'room')}</span>
+                <span className="flex-1 truncate">{room}</span>
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      <div className="mt-4 pt-4 border-t border-haunted-shadow text-xs text-haunted-fog/60 space-y-1">
+        <p>✅ Mes cartes • ❌ Éliminé • ❓ Peut-être • ⬜ Inconnu</p>
+        <p className="italic">Cliquez pour changer le statut</p>
+      </div>
+    </div>
+  )
+}
+
+export default InvestigationGrid

frontend/src/index.css

@@ -0,0 +1,17 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  @apply bg-dark-950 text-gray-100;
+}
+
+#root {
+  min-height: 100vh;
+}

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

frontend/src/pages/Game.jsx

@@ -0,0 +1,353 @@
+import { useState, useEffect } from 'react'
+import { useParams } from 'react-router-dom'
+import { getGameState, startGame, rollDice, makeSuggestion, makeAccusation, passTurn } from '../api'
+import InvestigationGrid from '../components/InvestigationGrid'
+import GameBoard from '../components/GameBoard'
+import AINavigator from '../components/AINavigator'
+
+function Game() {
+  const { gameId, playerId } = useParams()
+  const [gameState, setGameState] = useState(null)
+  const [loading, setLoading] = useState(true)
+  const [actionLoading, setActionLoading] = useState(false)
+
+  // Suggestion form
+  const [selectedSuspect, setSelectedSuspect] = useState('')
+  const [selectedWeapon, setSelectedWeapon] = useState('')
+  const [selectedRoom, setSelectedRoom] = useState('')
+  const [revealedCard, setRevealedCard] = useState(null)
+
+  useEffect(() => {
+    loadGameState()
+    const interval = setInterval(loadGameState, 2000)
+    return () => clearInterval(interval)
+  }, [gameId, playerId])
+
+  const loadGameState = async () => {
+    try {
+      const state = await getGameState(gameId, playerId)
+      setGameState(state)
+      setLoading(false)
+    } catch (error) {
+      console.error('Erreur chargement:', error)
+    }
+  }
+
+  const handleStartGame = async () => {
+    setActionLoading(true)
+    try {
+      await startGame(gameId, playerId)
+      await loadGameState()
+    } catch (error) {
+      alert(error.response?.data?.detail || 'Erreur au démarrage')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
+  const handleRollDice = async () => {
+    setActionLoading(true)
+    try {
+      await rollDice(gameId, playerId)
+      await loadGameState()
+    } catch (error) {
+      alert(error.response?.data?.detail || 'Erreur lors du lancer de dés')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
+  const handleSuggestion = async () => {
+    if (!selectedSuspect || !selectedWeapon || !selectedRoom) {
+      alert('Sélectionnez tous les éléments')
+      return
+    }
+    setActionLoading(true)
+    try {
+      const result = await makeSuggestion(gameId, playerId, selectedSuspect, selectedWeapon, selectedRoom)
+
+      // Show revealed card if any
+      if (result.card_shown) {
+        setRevealedCard({
+          ...result.card_shown,
+          disprover: result.disprover
+        })
+        setTimeout(() => setRevealedCard(null), 5000) // Hide after 5 seconds
+      } else {
+        alert('Personne ne peut réfuter votre suggestion !')
+      }
+
+      await loadGameState()
+      setSelectedSuspect('')
+      setSelectedWeapon('')
+      setSelectedRoom('')
+    } catch (error) {
+      alert(error.response?.data?.detail || 'Erreur lors de la suggestion')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
+  const handleAccusation = async () => {
+    if (!selectedSuspect || !selectedWeapon || !selectedRoom) {
+      alert('Sélectionnez tous les éléments')
+      return
+    }
+    if (!confirm('⚠️ Une accusation incorrecte vous élimine. Continuer ?')) return
+
+    setActionLoading(true)
+    try {
+      await makeAccusation(gameId, playerId, selectedSuspect, selectedWeapon, selectedRoom)
+      await loadGameState()
+      setSelectedSuspect('')
+      setSelectedWeapon('')
+      setSelectedRoom('')
+    } catch (error) {
+      alert(error.response?.data?.detail || 'Erreur lors de l\'accusation')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
+  const handlePassTurn = async () => {
+    setActionLoading(true)
+    try {
+      await passTurn(gameId, playerId)
+      await loadGameState()
+    } catch (error) {
+      alert(error.response?.data?.detail || 'Erreur')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
+  if (loading) {
+    return (
+      <div className="min-h-screen bg-haunted-gradient flex items-center justify-center">
+        <div className="text-haunted-blood text-2xl animate-flicker">🕯️ Chargement des ténèbres...</div>
+      </div>
+    )
+  }
+
+  const me = gameState.players.find(p => p.is_me)
+  const isMyTurn = gameState.current_turn?.is_my_turn && me?.is_active
+  const canStart = gameState.status === 'waiting' && gameState.players.length >= 3
+  const isEliminated = me && !me.is_active
+
+  return (
+    <div className="min-h-screen bg-haunted-gradient p-4 relative overflow-hidden">
+      {/* Animated fog effect */}
+      <div className="absolute inset-0 bg-fog-gradient opacity-10 animate-pulse-slow pointer-events-none"></div>
+
+      <div className="max-w-6xl mx-auto space-y-6 relative z-10">
+        {/* Header */}
+        <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-blood/30 shadow-[0_0_30px_rgba(139,0,0,0.2)]">
+          <div className="flex justify-between items-center">
+            <div>
+              <h1 className="text-4xl font-bold text-haunted-blood mb-1 animate-flicker drop-shadow-[0_0_10px_rgba(139,0,0,0.5)]">
+                🏰 {gameState.game_name} ({gameState.game_id})
+              </h1>
+              <p className="text-haunted-fog/80">👤 {me?.name} {!me?.is_active && '💀 (Éliminé)'}</p>
+            </div>
+            <div className="text-right">
+              <p className="text-haunted-fog">
+                {gameState.status === 'waiting' ? '⏳ En attente des âmes' :
+                 gameState.status === 'in_progress' ? '🎮 Enquête en cours' :
+                 '🏆 Mystère résolu'}
+              </p>
+              <p className="text-haunted-fog/60 text-sm">{gameState.players.length} âmes perdues</p>
+            </div>
+          </div>
+          {canStart && (
+            <button
+              onClick={handleStartGame}
+              disabled={actionLoading}
+              className="mt-4 px-6 py-2 bg-haunted-blood hover:bg-red-800 disabled:bg-dark-600 disabled:opacity-50 text-white font-bold rounded-lg transition-all hover:shadow-[0_0_20px_rgba(139,0,0,0.5)] border border-red-900"
+            >
+              🚀 Commencer l'enquête
+            </button>
+          )}
+        </div>
+
+        {/* Scenario */}
+        {gameState.scenario && gameState.status === 'in_progress' && (
+          <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-purple/30">
+            <h2 className="text-xl font-bold text-haunted-purple mb-3 animate-flicker">📜 Le Mystère</h2>
+            <p className="text-haunted-fog italic">{gameState.scenario}</p>
+          </div>
+        )}
+
+        <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+          {/* Game Board */}
+          <div className="lg:col-span-2">
+            <GameBoard
+              boardLayout={gameState.board_layout}
+              players={gameState.players}
+              rooms={gameState.rooms}
+              myPosition={gameState.my_position}
+            />
+          </div>
+
+          {/* My Cards */}
+          <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-shadow">
+            <h2 className="text-xl font-bold text-haunted-blood mb-4 animate-flicker">🃏 Vos Indices</h2>
+            <div className="space-y-2">
+              {gameState.my_cards?.map((card, idx) => (
+                <div key={idx} className="bg-black/40 px-4 py-2 rounded text-haunted-fog border border-haunted-shadow hover:border-haunted-blood/50 transition-all">
+                  {card.type === 'character' && '👤 '}
+                  {card.type === 'weapon' && '🔪 '}
+                  {card.type === 'room' && '🏚️ '}
+                  {card.name}
+                </div>
+              ))}
+            </div>
+          </div>
+        </div>
+
+        {/* Investigation Grid */}
+        <InvestigationGrid
+          suspects={gameState.suspects}
+          weapons={gameState.weapons}
+          rooms={gameState.rooms}
+          myCards={gameState.my_cards}
+        />
+
+        {/* AI Narrator */}
+        {gameState.use_ai && (
+          <AINavigator
+            recentActions={gameState.recent_actions}
+            gameStatus={gameState.status}
+          />
+        )}
+
+        {/* Revealed Card Modal */}
+        {revealedCard && (
+          <div className="fixed inset-0 bg-black/70 backdrop-blur-sm flex items-center justify-center z-50 animate-fade-in">
+            <div className="bg-black/90 border-4 border-haunted-blood p-8 rounded-lg shadow-2xl max-w-md">
+              <h3 className="text-2xl font-bold text-haunted-blood mb-4 animate-flicker">🃏 Carte Révélée</h3>
+              <p className="text-haunted-fog mb-2">
+                <span className="font-semibold">{revealedCard.disprover}</span> vous montre :
+              </p>
+              <div className="bg-haunted-blood/20 border-2 border-haunted-blood p-4 rounded-lg">
+                <p className="text-2xl font-bold text-haunted-fog text-center">
+                  {revealedCard.type === 'character' && '👤 '}
+                  {revealedCard.type === 'weapon' && '🔪 '}
+                  {revealedCard.type === 'room' && '🏚️ '}
+                  {revealedCard.name}
+                </p>
+              </div>
+              <p className="text-haunted-fog/60 text-sm mt-4 text-center italic">
+                Cette carte disparaîtra dans quelques secondes...
+              </p>
+            </div>
+          </div>
+        )}
+
+        {/* Actions */}
+        {gameState.status === 'in_progress' && (
+          <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-blood/30">
+            <h2 className="text-2xl font-bold text-haunted-blood mb-4 animate-flicker">
+              {isEliminated ? '💀 Vous êtes éliminé - Vous pouvez toujours observer' :
+               isMyTurn ? '⚡ À vous de jouer !' :
+               '⏳ ' + gameState.current_turn?.player_name + ' enquête...'}
+            </h2>
+
+            {isMyTurn && !isEliminated && (
+              <div className="space-y-4">
+                <div className="flex gap-4 mb-4">
+                  <button
+                    onClick={handleRollDice}
+                    disabled={actionLoading}
+                    className="px-6 py-3 bg-haunted-blood hover:bg-red-800 disabled:bg-dark-600 disabled:opacity-50 text-white font-bold rounded-lg transition-all hover:shadow-[0_0_20px_rgba(139,0,0,0.5)] border border-red-900"
+                  >
+                    🎲 Lancer les dés
+                  </button>
+                  <button
+                    onClick={handlePassTurn}
+                    disabled={actionLoading}
+                    className="px-6 py-3 bg-black/40 hover:bg-black/60 disabled:opacity-50 text-haunted-fog border-2 border-haunted-shadow font-semibold rounded-lg transition-all"
+                  >
+                    ⏭️ Passer
+                  </button>
+                </div>
+                <div className="space-y-4">
+                    <div className="grid grid-cols-3 gap-4">
+                      <div>
+                        <label className="block text-sm text-haunted-fog mb-2">👤 Suspect</label>
+                        <select
+                          value={selectedSuspect}
+                          onChange={(e) => setSelectedSuspect(e.target.value)}
+                          className="w-full px-3 py-2 bg-black/40 text-haunted-fog rounded border-2 border-haunted-shadow focus:border-haunted-blood focus:outline-none"
+                        >
+                          <option value="">--</option>
+                          {gameState.suspects?.map((s, i) => (
+                            <option key={i} value={s}>{s}</option>
+                          ))}
+                        </select>
+                      </div>
+                      <div>
+                        <label className="block text-sm text-haunted-fog mb-2">🔪 Arme</label>
+                        <select
+                          value={selectedWeapon}
+                          onChange={(e) => setSelectedWeapon(e.target.value)}
+                          className="w-full px-3 py-2 bg-black/40 text-haunted-fog rounded border-2 border-haunted-shadow focus:border-haunted-blood focus:outline-none"
+                        >
+                          <option value="">--</option>
+                          {gameState.weapons?.map((w, i) => (
+                            <option key={i} value={w}>{w}</option>
+                          ))}
+                        </select>
+                      </div>
+                      <div>
+                        <label className="block text-sm text-haunted-fog mb-2">🏚️ Pièce</label>
+                        <select
+                          value={selectedRoom}
+                          onChange={(e) => setSelectedRoom(e.target.value)}
+                          className="w-full px-3 py-2 bg-black/40 text-haunted-fog rounded border-2 border-haunted-shadow focus:border-haunted-blood focus:outline-none"
+                        >
+                          <option value="">--</option>
+                          {gameState.rooms?.map((r, i) => (
+                            <option key={i} value={r}>{r}</option>
+                          ))}
+                        </select>
+                      </div>
+                    </div>
+                    <div className="flex gap-4">
+                      <button
+                        onClick={handleSuggestion}
+                        disabled={actionLoading}
+                        className="px-6 py-3 bg-haunted-purple hover:bg-purple-800 disabled:bg-dark-600 disabled:opacity-50 text-white font-bold rounded-lg transition-all hover:shadow-[0_0_20px_rgba(107,33,168,0.5)] border border-purple-900"
+                      >
+                        💬 Suggérer
+                      </button>
+                      <button
+                        onClick={handleAccusation}
+                        disabled={actionLoading}
+                        className="px-6 py-3 bg-haunted-blood hover:bg-red-800 disabled:bg-dark-600 disabled:opacity-50 text-white font-bold rounded-lg transition-all hover:shadow-[0_0_20px_rgba(139,0,0,0.5)] border border-red-900"
+                      >
+                        ⚠️ Accuser
+                      </button>
+                    </div>
+                  </div>
+              </div>
+            )}
+          </div>
+        )}
+
+        {/* Historique */}
+        <div className="bg-black/60 backdrop-blur-md p-6 rounded-lg border-2 border-haunted-shadow">
+          <h2 className="text-xl font-bold text-haunted-blood mb-4 animate-flicker">📜 Journal de l'Enquête</h2>
+          <div className="space-y-2 max-h-64 overflow-y-auto">
+            {gameState.recent_actions?.slice().reverse().map((action, idx) => (
+              <div key={idx} className="text-haunted-fog/80 text-sm border-l-2 border-haunted-blood pl-3 py-1 hover:bg-black/20 transition-all">
+                <span className="font-semibold">{action.player}</span> - {action.action}: {action.details}
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default Game

frontend/src/pages/Home.jsx

@@ -0,0 +1,88 @@
+import { useState } from 'react'
+import { useNavigate } from 'react-router-dom'
+import { createQuickGame } from '../api'
+
+function Home() {
+  const [playerName, setPlayerName] = useState('')
+  const [loading, setLoading] = useState(false)
+  const navigate = useNavigate()
+
+  const handleCreateGame = async () => {
+    if (!playerName.trim()) {
+      alert('Veuillez entrer votre nom')
+      return
+    }
+
+    setLoading(true)
+    try {
+      const response = await createQuickGame(playerName.trim())
+      navigate(`/game/${response.game_id}/${response.player_id}`)
+    } catch (error) {
+      alert('Erreur lors de la création de la partie')
+      console.error(error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return (
+    <div className="min-h-screen bg-haunted-gradient flex items-center justify-center p-4 relative overflow-hidden">
+      {/* Animated fog effect */}
+      <div className="absolute inset-0 bg-fog-gradient opacity-20 animate-pulse-slow pointer-events-none"></div>
+
+      {/* Floating ghost elements */}
+      <div className="absolute top-20 left-10 w-32 h-32 bg-haunted-ghost opacity-5 rounded-full blur-3xl animate-float"></div>
+      <div className="absolute bottom-20 right-10 w-40 h-40 bg-haunted-purple opacity-5 rounded-full blur-3xl animate-float" style={{animationDelay: '2s'}}></div>
+
+      <div className="max-w-md w-full space-y-8 bg-black/60 backdrop-blur-md p-8 rounded-lg shadow-2xl border-2 border-haunted-blood/30 animate-fade-in relative z-10">
+        <div className="text-center">
+          <h1 className="text-6xl font-bold text-haunted-blood mb-2 animate-flicker drop-shadow-[0_0_10px_rgba(139,0,0,0.5)]">
+            🕯️ Cluedo Custom
+          </h1>
+          <p className="text-haunted-fog/80 text-lg italic">Le manoir vous attend dans l'obscurité...</p>
+          <div className="mt-2 text-xs text-haunted-ghost/50">💀 Osez-vous entrer ? 💀</div>
+        </div>
+
+        <div className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-haunted-fog mb-2">
+              Votre nom
+            </label>
+            <input
+              type="text"
+              value={playerName}
+              onChange={(e) => setPlayerName(e.target.value)}
+              onKeyPress={(e) => e.key === 'Enter' && handleCreateGame()}
+              placeholder="Qui ose s'aventurer..."
+              className="w-full px-4 py-3 bg-black/40 border-2 border-haunted-shadow rounded-lg text-haunted-fog placeholder-dark-500 focus:outline-none focus:ring-2 focus:ring-haunted-blood focus:border-haunted-blood transition-all"
+            />
+          </div>
+
+          <button
+            onClick={handleCreateGame}
+            disabled={loading}
+            className="w-full py-3 px-4 bg-haunted-blood hover:bg-red-800 disabled:bg-dark-600 disabled:opacity-50 text-white font-bold rounded-lg transition-all transform hover:scale-105 hover:shadow-[0_0_20px_rgba(139,0,0,0.5)] border border-red-900"
+          >
+            {loading ? '🕯️ Création...' : '🚪 Entrer dans le Manoir'}
+          </button>
+
+          <div className="text-center pt-4">
+            <button
+              onClick={() => navigate('/join')}
+              className="text-haunted-fog/70 hover:text-haunted-blood underline transition-colors"
+            >
+              👻 Rejoindre une partie existante
+            </button>
+          </div>
+        </div>
+
+        <div className="mt-8 pt-6 border-t border-haunted-shadow text-center text-sm text-haunted-fog/60">
+          <p className="italic">⚰️ Thème : Meurtre au Manoir ⚰️</p>
+          <p className="mt-1">3-6 âmes perdues recommandées</p>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default Home

frontend/src/pages/Join.jsx

@@ -0,0 +1,97 @@
+import { useState } from 'react'
+import { useNavigate } from 'react-router-dom'
+import { joinGame } from '../api'
+
+function Join() {
+  const [gameCode, setGameCode] = useState('')
+  const [playerName, setPlayerName] = useState('')
+  const [loading, setLoading] = useState(false)
+  const navigate = useNavigate()
+
+  const handleJoinGame = async () => {
+    if (!gameCode.trim() || !playerName.trim()) {
+      alert('Veuillez remplir tous les champs')
+      return
+    }
+
+    setLoading(true)
+    try {
+      const response = await joinGame(gameCode.trim(), playerName.trim())
+      navigate(`/game/${response.game_id}/${response.player_id}`)
+    } catch (error) {
+      alert('Erreur : ' + (error.response?.data?.detail || 'Impossible de rejoindre la partie'))
+      console.error(error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return (
+    <div className="min-h-screen bg-haunted-gradient flex items-center justify-center p-4 relative overflow-hidden">
+      {/* Animated fog effect */}
+      <div className="absolute inset-0 bg-fog-gradient opacity-20 animate-pulse-slow pointer-events-none"></div>
+
+      {/* Floating ghost elements */}
+      <div className="absolute top-20 left-10 w-32 h-32 bg-haunted-ghost opacity-5 rounded-full blur-3xl animate-float"></div>
+      <div className="absolute bottom-20 right-10 w-40 h-40 bg-haunted-purple opacity-5 rounded-full blur-3xl animate-float" style={{animationDelay: '2s'}}></div>
+
+      <div className="max-w-md w-full space-y-8 bg-black/60 backdrop-blur-md p-8 rounded-lg shadow-2xl border-2 border-haunted-blood/30 animate-fade-in relative z-10">
+        <div className="text-center">
+          <h1 className="text-5xl font-bold text-haunted-blood mb-2 animate-flicker drop-shadow-[0_0_10px_rgba(139,0,0,0.5)]">
+            👻 Rejoindre la Séance
+          </h1>
+          <p className="text-haunted-fog/80 italic">Entrez le code maudit...</p>
+        </div>
+
+        <div className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-haunted-fog mb-2">
+              🔮 Code de partie
+            </label>
+            <input
+              type="text"
+              value={gameCode}
+              onChange={(e) => setGameCode(e.target.value.toUpperCase())}
+              placeholder="?????"
+              maxLength={4}
+              className="w-full px-4 py-3 bg-black/40 border-2 border-haunted-shadow rounded-lg text-haunted-blood text-center text-3xl font-mono placeholder-dark-500 focus:outline-none focus:ring-2 focus:ring-haunted-blood focus:border-haunted-blood transition-all uppercase tracking-widest"
+            />
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium text-haunted-fog mb-2">
+              Votre nom
+            </label>
+            <input
+              type="text"
+              value={playerName}
+              onChange={(e) => setPlayerName(e.target.value)}
+              onKeyPress={(e) => e.key === 'Enter' && handleJoinGame()}
+              placeholder="Qui ose s'aventurer..."
+              className="w-full px-4 py-3 bg-black/40 border-2 border-haunted-shadow rounded-lg text-haunted-fog placeholder-dark-500 focus:outline-none focus:ring-2 focus:ring-haunted-blood focus:border-haunted-blood transition-all"
+            />
+          </div>
+
+          <button
+            onClick={handleJoinGame}
+            disabled={loading}
+            className="w-full py-3 px-4 bg-haunted-blood hover:bg-red-800 disabled:bg-dark-600 disabled:opacity-50 text-white font-bold rounded-lg transition-all transform hover:scale-105 hover:shadow-[0_0_20px_rgba(139,0,0,0.5)] border border-red-900"
+          >
+            {loading ? '🕯️ Connexion...' : '🚪 Entrer dans le Manoir'}
+          </button>
+
+          <div className="text-center pt-4">
+            <button
+              onClick={() => navigate('/')}
+              className="text-haunted-fog/70 hover:text-haunted-blood underline transition-colors"
+            >
+              ← Retourner dans les ténèbres
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default Join

frontend/tailwind.config.js

@@ -0,0 +1,78 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        primary: {
+          50: '#fef2f2',
+          100: '#fee2e2',
+          200: '#fecaca',
+          300: '#fca5a5',
+          400: '#f87171',
+          500: '#ef4444',
+          600: '#dc2626',
+          700: '#b91c1c',
+          800: '#991b1b',
+          900: '#7f1d1d',
+        },
+        dark: {
+          50: '#f8fafc',
+          100: '#f1f5f9',
+          200: '#e2e8f0',
+          300: '#cbd5e1',
+          400: '#94a3b8',
+          500: '#64748b',
+          600: '#475569',
+          700: '#334155',
+          800: '#1e293b',
+          900: '#0f172a',
+          950: '#020617',
+        },
+        accent: {
+          300: '#fca5a5',
+          400: '#f87171',
+          500: '#ef4444',
+          600: '#dc2626',
+          700: '#b91c1c',
+        },
+        haunted: {
+          fog: '#e5e7eb',
+          shadow: '#1f1f1f',
+          blood: '#8b0000',
+          ghost: '#f3f4f6',
+          purple: '#6b21a8',
+        }
+      },
+      backgroundImage: {
+        'haunted-gradient': 'linear-gradient(135deg, #0a0a0a 0%, #1a0a14 50%, #0a0a0a 100%)',
+        'fog-gradient': 'linear-gradient(to bottom, transparent, rgba(255,255,255,0.05), transparent)',
+      },
+      animation: {
+        'flicker': 'flicker 3s infinite',
+        'float': 'float 6s ease-in-out infinite',
+        'pulse-slow': 'pulse 4s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+        'fade-in': 'fadeIn 0.5s ease-in',
+      },
+      keyframes: {
+        flicker: {
+          '0%, 100%': { opacity: '1' },
+          '50%': { opacity: '0.8' },
+          '75%': { opacity: '0.9' },
+        },
+        float: {
+          '0%, 100%': { transform: 'translateY(0px)' },
+          '50%': { transform: 'translateY(-10px)' },
+        },
+        fadeIn: {
+          '0%': { opacity: '0' },
+          '100%': { opacity: '1' },
+        },
+      },
+    },
+  },
+  plugins: [],
+}

frontend/vite.config.js

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8000',
+        changeOrigin: true,
+      },
+    },
+  },
+})

specifications.txt

@@ -14,21 +14,21 @@ L’hôte choisit :
 
 Un titre de partie (ex : Meurtre au coworking ou Drame à la coloc).
 
-Une tonalité narrative : 🕵️ Sérieuse, 😂 Parodique, 🧙‍♂️ Fantastique, 🎬 Thriller, etc.
+* Créer une nouvelle partie
 
-Optionnel : un prompt personnalisé pour l’IA (ex : “style Agatha Christie avec humour noir”).
+  * Saisir un nom de partie.
 
-🏠 Étape 2 — Création des “Lieux”
+  * Choisir le nombre de salles et leurs noms (ex : "Cuisine", "Salle de réunion", "Terrasse"...).
 
-L’hôte définit les pièces du plateau :
+  * (Optionnel) Activer ou non le mode IA pour générer des descriptions ou scénarios.
 
-En tapant leurs noms : Cuisine, Toit, Salle serveurs, Cafétéria…
+* Rejoindre une partie existante
 
-Le must serait d'avoir une interface drag & drop (petit éditeur de plan simplifié avec des tuiles).
+  * Via un code ou lien de partage (UUID court).
 
-💡 L’ordre spatial a un impact : les joueurs doivent “se déplacer” virtuellement d’un lieu à l’autre.
+  * Le joueur saisit son nom ou pseudo.
 
-🔪 Étape 3 — Liste des “Armes” et “Suspects”
+  * Lister les parties actives (en cours sur le serveur).
 
 L’hôte ajoute les suspects (réels ou fictifs).
 
@@ -57,8 +57,9 @@ Soit une carte générée dynamiquement via JSON de la config hôte.
 
 Lorsqu'au moins 3 joueurs (dont l'hote) sont connectés, l'hote peut lancer la partie
 
-🚶 3. Déroulement du jeu
-🎲 Tour par tour
+Grille a cocher pour éliminer les possibilités
+
+Navigation intuitive :
 
 Chaque joueur :
 
@@ -77,15 +78,15 @@ L’IA :
 
 Garde trace des suggestions.
 
-Indique si un autre joueur peut infirmer la théorie (en montrant une carte virtuelle).
-
-Peut glisser des indices narratifs ou des fausses pistes : “Une odeur de café froid flotte près du bureau…”
+Reformulation fluide des messages de jeu.
 
 🧠 4. Feuille d’enquête numérique
 
-Chaque joueur dispose d’une grille (cases cliquables ✅❌) :
+🏗️ 4. Architecture technique
 
-Colonnes : Suspects / Armes / Lieux
+Front-end
+
+Framework léger : React + FastAPI backend (selon préférences).
 
 
 🎭 5. L’IA comme moteur de narration dynamique
@@ -118,8 +119,63 @@ Multi-joueurs	WebSocket léger (ou polling HTTP + threads)
 
 💬 Exemple de tour complet
 
-👤 Toi : Selection de "Claire" avec l'arme "Clé USB" dans le lieu "Cuisine"
-🤖 IA : “Et toi ça te semble logique que Claire ait assassiné Daniel à côté de l’étendoir, en plein après-midi, avec un périphérique USB ? 🧠 Mauvais câble, détective.”
-(Un joueur montre virtuellement la carte “Claire”)
-✅ Tu coches “Claire” comme innocente.
-🔄 Prochain tour.
+Hugging Face Space (Gradio ou API + frontend minimal).
+
+Exposition sur un seul port HTTP (7860 par défaut HF).
+
+Pas d’état long terme : la perte du conteneur efface les parties (ok pour usage récréatif).
+
+⚙️ 5. Variables d’environnement
+Nom	Description	Valeur par défaut
+USE_OPENAI	Active la génération IA	false
+OPENAI_API_KEY	Clé OpenAI (optionnelle)	""
+APP_NAME	Nom affiché dans l’interface	"Cluedo Custom"
+MAX_PLAYERS	Nombre max de joueurs par partie	8
+
+🧠 6. Comportement IA (si activé)
+
+Utiliser GPT (via OpenAI API) pour :
+
+Générer la mise en scène du lieu : “Le meurtre a eu lieu dans la Salle des serveurs…”
+
+Personnaliser les noms et descriptions de personnages.
+
+Ajouter du dialogue narratif léger pendant les tours. Le bot s'appelle 
+
+Les prompts doivent être courts et à température basse pour éviter les délais.
+
+Pas d’appel IA bloquant : timeout max 3 secondes par requête.
+
+🔒 8. Gestion des sessions / multi-joueurs
+
+Génération d’un Game ID unique à 6 caractères.
+
+Stockage des sessions en mémoire avec la liste des joueurs connectés.
+
+Chaque joueur identifié par un UUID stocké côté navigateur.
+
+Synchronisation légère entre joueurs (polling toutes les 2–3 secondes au lieu de WebSocket si besoin d’économie CPU).
+
+🧪 9. Tests & validation
+
+Unitaires : logique du moteur de jeu (distribution, accusation, vérification).
+
+End-to-end : création et déroulement d’une partie complète à 3 joueurs simulés.
+
+Tests IA (optionnels) : vérification du format et temps de réponse des prompts.
+
+📦 10. Livrables attendus
+
+Dockerfile léger (< 300 MB image finale).
+
+Fichier requirements.txt clair et court.
+
+Script app.py ou main.py lançant l’app HF.
+
+Documentation README.md :
+
+Variables d’environnement
+
+Instructions pour exécution locale et Space.
+
+Description du mode IA.