feat: improve app UI

ARCHITECTURE_V3.md

@@ -59,13 +59,13 @@ Suspects: ["Mme Leblanc", "Col. Moutarde", "Mlle Rose", "Prof. Violet", "Mme Per
 │  [Plateau avec positions]           │
 │                                     │
 ├─────────────────────────────────────┤
-│  Vos cartes: [🃏] [🃏] [🃏]         │
+│  Vos cartes: [🃏] [🃏] [🃏]        │
 ├─────────────────────────────────────┤
 │  Tour de: Alice                     │
 │  [🎲 Lancer dés] ou [⏭️ Passer]    │
 │                                     │
 │  Si déplacé:                        │
-│  [💭 Suggérer] [⚡ Accuser]         │
+│  [💭 Suggérer] [⚡ Accuser]        │
 └─────────────────────────────────────┘
 ```
 

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,1274 +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,
-    narrative_tone: str,
-    custom_prompt: str,
-    rooms_text: str,
-    weapons_text: str,
-    suspects_text: str,
-    use_ai: bool
-):
-    """
-    Create a new game with custom elements.
-    """
-    if not game_name or not rooms_text:
-        return "❌ Fournissez un titre d'enquête et une liste de lieux", ""
-
-    # Parse inputs (comma or newline separated)
-    rooms = [r.strip() for r in rooms_text.replace("\n", ",").split(",") if r.strip()]
-    weapons = [w.strip() for w in weapons_text.replace("\n", ",").split(",") if w.strip()]
-    suspects = [s.strip() for s in suspects_text.replace("\n", ",").split(",") if s.strip()]
-
-    # Validation
-    if len(rooms) < settings.MIN_ROOMS:
-        return f"❌ Il faut au moins {settings.MIN_ROOMS} lieux", ""
-
-    if len(rooms) > settings.MAX_ROOMS:
-        return f"❌ Maximum {settings.MAX_ROOMS} lieux autorisés", ""
-
-    if len(weapons) < 3:
-        return "❌ Il faut au moins 3 armes", ""
-
-    if len(suspects) < 3:
-        return "❌ Il faut au moins 3 suspects", ""
-
-    try:
-        if IS_HUGGINGFACE:
-            from game_manager import game_manager
-            from models import CreateGameRequest
-
-            request = CreateGameRequest(
-                game_name=game_name,
-                narrative_tone=narrative_tone,
-                custom_prompt=custom_prompt if custom_prompt else None,
-                rooms=rooms,
-                custom_weapons=weapons,
-                custom_suspects=suspects,
-                use_ai=use_ai
-            )
-            game = game_manager.create_game(request)
-
-            # Generate AI scenario if enabled
-            if game.use_ai and settings.USE_OPENAI:
-                from ai_service import ai_service
-                import asyncio
-
-                try:
-                    scenario = asyncio.run(
-                        ai_service.generate_scenario(
-                            game.rooms,
-                            game.custom_suspects,
-                            game.narrative_tone
-                        )
-                    )
-                    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 !\n\n"
-                f"🔑 Code d'Enquête : **{game.game_id}**\n\n"
-                f"📤 Partagez ce code avec les autres joueurs\n"
-                f"ℹ️ Minimum {settings.MIN_PLAYERS} joueurs requis pour démarrer",
-                game.game_id,
-            )
-        else:
-            # HTTP API call (local mode)
-            response = requests.post(
-                f"{API_BASE}/games/create",
-                json={
-                    "game_name": game_name,
-                    "narrative_tone": narrative_tone,
-                    "custom_prompt": custom_prompt if custom_prompt else None,
-                    "rooms": rooms,
-                    "custom_weapons": weapons,
-                    "custom_suspects": suspects,
-                    "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 !\n\n"
-                    f"🔑 Code : **{data['game_id']}**\n\n"
-                    f"📤 Partagez ce code\n"
-                    f"ℹ️ Min. {settings.MIN_PLAYERS} joueurs",
-                    data["game_id"],
-                )
-            else:
-                return f"❌ Erreur : {response.json().get('detail', 'Erreur inconnue')}", ""
-
-    except Exception as e:
-        return f"❌ Erreur : {str(e)}", ""
-
-
-def join_game(game_id: str, player_name: str):
-    """
-    Join an existing game.
-    """
-    if not game_id or not player_name:
-        return "❌ Fournissez le code d'enquête et votre nom !"
-
-    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 "❌ Enquête introuvable !"
-
-            if game.status != GameStatus.WAITING:
-                return "❌ La partie a déjà commencé !"
-
-            if game.is_full():
-                return "❌ Partie complète (maximum 8 joueurs) !"
-
-            player = game_manager.join_game(game_id, player_name)
-            if not player:
-                return "❌ 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 !\n\n"
-                f"👋 Bienvenue, {player_name} !\n\n"
-                f"⏳ Attendez que le créateur démarre la partie\n"
-                f"📖 Consultez l'onglet 🔎 Enquêter pour voir l'état"
-            )
-        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 f"❌ Impossible de démarrer ! Minimum {settings.MIN_PLAYERS} joueurs requis."
-
-            game = game_manager.get_game(game_id)
-
-            return (
-                f"🎬 L'ENQUÊTE COMMENCE !\n\n"
-                f"🃏 Les cartes ont été distribuées\n"
-                f"🎲 Tous les joueurs démarrent dans : {game.rooms[0] if game.rooms else '(aucun lieu)'}\n"
-                f"🔍 À vous de découvrir qui a commis le crime, avec quelle arme et dans quel lieu !\n\n"
-                f"➡️ Allez dans l'onglet 🔎 Enquêter pour commencer à jouer"
-            )
-        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"🎬 L'ENQUÊTE COMMENCE !\n\n"
-                    f"🃏 Les cartes ont été distribuées\n"
-                    f"🔍 À vous de découvrir qui a commis le crime !\n\n"
-                    f"➡️ Allez dans l'onglet 🔎 Enquêter pour commencer"
-                )
-            else:
-                return f"❌ Erreur : {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
-            all_players = [
-                {
-                    "name": p.name,
-                    "is_active": p.is_active,
-                    "card_count": len(p.cards),
-                    "position": p.current_room_index
-                }
-                for p in game.players
-            ]
-
-            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],
-                "my_position": player.current_room_index,
-                "all_players": all_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']} ═══\n")
-
-        status_map = {
-            "waiting": "⏳ En attente de joueurs...",
-            "in_progress": "🎲 Partie en cours",
-            "finished": "🏆 Partie terminée",
-        }
-        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")
-
-        # Show player's current position if game started
-        if data.get("my_position") is not None and data["rooms"]:
-            current_room = data["rooms"][data["my_position"]]
-            output.append(f"\n📍 VOTRE POSITION : **{current_room}**")
-
-        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━━━ 🏠 PLATEAU DE JEU (Circuit) ━━━")
-        # Show rooms with player positions in circuit order
-        rooms_display = []
-        for idx, room in enumerate(data["rooms"]):
-            players_here = [p["name"] for p in data.get("all_players", []) if p.get("position") == idx]
-
-            # Visual indicator
-            if players_here:
-                icon = "👥"
-                player_names = ', '.join(players_here)
-                rooms_display.append(f"  {idx+1}. {icon} **{room}** → {player_names}")
-            else:
-                icon = "🚪"
-                rooms_display.append(f"  {idx+1}. {icon} {room}")
-
-        output.extend(rooms_display)
-        output.append(f"  └─→ Circuit fermé (retour à {data['rooms'][0]})")
-
-        output.append(f"\n━━━ ℹ️ ÉLÉMENTS DU JEU ━━━")
-        output.append(f"👤 Suspects : {', '.join(data['characters'])}")
-        output.append(f"🔪 Armes : {', '.join(data['weapons'])}")
-
-        output.append(f"\n━━━ 👥 JOUEURS ━━━")
-        for player in data.get("all_players", []):
-            status_icon = "✅" if player["is_active"] else "❌"
-            position = data["rooms"][player["position"]] if player.get("position") is not None else "?"
-            output.append(
-                f"  {status_icon} {player['name']} - {position} ({player['card_count']} cartes)"
-            )
-
-        if data["current_turn"]:
-            turn_marker = (
-                "👉 C'EST VOTRE TOUR !" 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🏆🏆🏆 VAINQUEUR : {data['winner']} 🏆🏆🏆"
-            )
-
-        if data["recent_turns"]:
-            output.append(f"\n━━━ 📰 HISTORIQUE (5 dernières actions) ━━━")
-            for turn in data["recent_turns"][-5:]:
-                output.append(f"  • {turn['player_name']}: {turn['action']}")
-                if turn.get("details"):
-                    output.append(f"    ↪ {turn['details']}")
-                if turn.get("ai_comment"):
-                    output.append(f"    🗣️ Desland: {turn['ai_comment']}")
-
-        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 "❌ Vous n'êtes pas dans une enquête"
-
-    if not all([character, weapon, room]):
-        return "❌ Choisissez un suspect, une arme et un lieu"
-
-    try:
-        if IS_HUGGINGFACE:
-            from game_manager import game_manager
-            from game_engine import GameEngine
-            from ai_service import ai_service
-            import asyncio
-
-            game = game_manager.get_game(state.game_id)
-            if not game:
-                return "❌ Enquête introuvable"
-
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Ce n'est pas votre tour !"
-
-            # Check if player is in the correct room
-            can_suggest, error_msg = GameEngine.can_make_suggestion(game, state.player_id, room)
-            if not can_suggest:
-                return f"❌ {error_msg}"
-
-            player = next((p for p in game.players if p.id == state.player_id), None)
-            if not player:
-                return "❌ Joueur introuvable"
-
-            # Process suggestion
-            can_disprove, disprover, card = GameEngine.check_suggestion(
-                game, state.player_id, character, weapon, room
-            )
-
-            suggestion_text = f"{character} avec {weapon} dans {room}"
-
-            # Generate AI comment if enabled
-            ai_comment = None
-            if game.use_ai and settings.USE_OPENAI:
-                try:
-                    ai_comment = asyncio.run(
-                        ai_service.generate_suggestion_comment(
-                            player.name,
-                            character,
-                            weapon,
-                            room,
-                            can_disprove,
-                            game.narrative_tone
-                        )
-                    )
-                except:
-                    pass
-
-            # Build response message
-            if can_disprove and disprover and card:
-                message = f"💭 {disprover} réfute en montrant : **{card.name}**"
-            else:
-                message = "💭 Personne ne peut réfuter cette suggestion !"
-
-            # Add AI comment if available
-            if ai_comment:
-                message += f"\n\n🗣️ **Desland** : {ai_comment}"
-
-            GameEngine.add_turn_record(
-                game, state.player_id, "suggest", suggestion_text, ai_comment
-            )
-            game.next_turn()
-            game_manager.save_games()
-
-            message += "\n\n➡️ Notez cette information dans votre feuille d'enquête !"
-            return 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": "suggest",
-                    "character": character,
-                    "weapon": weapon,
-                    "room": room,
-                },
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                return data.get("message", "Suggestion effectuée")
-            else:
-                return f"❌ Erreur : {response.json().get('detail', 'Erreur inconnue')}"
-
-    except Exception as e:
-        return f"❌ 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 "❌ Choisissez un suspect, une arme et un lieu"
-
-    try:
-        if IS_HUGGINGFACE:
-            from game_manager import game_manager
-            from game_engine import GameEngine
-            from models import GameStatus
-            from ai_service import ai_service
-            import asyncio
-
-            game = game_manager.get_game(state.game_id)
-            if not game:
-                return "❌ Enquête introuvable"
-
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Ce n'est pas votre tour !"
-
-            player = next((p for p in game.players if p.id == state.player_id), None)
-            if not player:
-                return "❌ Joueur introuvable"
-
-            accusation_text = f"{character} avec {weapon} dans {room}"
-
-            is_correct, message = GameEngine.process_accusation(
-                game, state.player_id, character, weapon, room
-            )
-
-            # Generate AI comment if enabled
-            ai_comment = None
-            if game.use_ai and settings.USE_OPENAI:
-                try:
-                    ai_comment = asyncio.run(
-                        ai_service.generate_accusation_comment(
-                            player.name,
-                            character,
-                            weapon,
-                            room,
-                            is_correct,
-                            game.narrative_tone
-                        )
-                    )
-                except:
-                    pass
-
-            GameEngine.add_turn_record(game, state.player_id, "accuse", accusation_text, ai_comment)
-
-            if not is_correct and game.status == GameStatus.IN_PROGRESS:
-                game.next_turn()
-
-            game_manager.save_games()
-
-            # Build response
-            if is_correct:
-                response = f"🎉🏆 {message} 🎉🏆\n\nVous avez résolu le mystère !"
-            else:
-                response = f"💀 {message}\n\nVous avez été éliminé !\nVous pouvez toujours aider en réfutant les théories des autres."
-
-            if ai_comment:
-                response += f"\n\n🗣️ **Desland** : {ai_comment}"
-
-            return response
-
-        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()
-                return data.get("message", "Accusation effectuée")
-            else:
-                return f"❌ Erreur : {response.json().get('detail', 'Erreur inconnue')}"
-
-    except Exception as e:
-        return f"❌ Erreur : {str(e)}"
-
-
-def roll_and_move():
-    """
-    Roll dice and move the player.
-    """
-    if not state.game_id or not state.player_id:
-        return "❌ Vous n'êtes pas dans une enquête"
-
-    try:
-        if IS_HUGGINGFACE:
-            from game_manager import game_manager
-            from game_engine import GameEngine
-
-            game = game_manager.get_game(state.game_id)
-            if not game:
-                return "❌ Enquête introuvable"
-
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Ce n'est pas votre tour !"
-
-            # Roll dice
-            dice_roll = GameEngine.roll_dice()
-
-            # Move player
-            success, message, new_room_index = GameEngine.move_player(
-                game, state.player_id, dice_roll
-            )
-
-            if not success:
-                return f"❌ {message}"
-
-            # Record turn
-            GameEngine.add_turn_record(game, state.player_id, "move", message)
-            game_manager.save_games()
-
-            current_room = game.rooms[new_room_index]
-            return f"🎲 {message}\n\n📍 Vous êtes maintenant dans : **{current_room}**\n\nVous pouvez faire une suggestion dans cette pièce ou passer votre tour."
-
-        else:
-            # HTTP API (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": "move"
-                },
-                timeout=5,
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                return data.get("message", "Déplacé avec succès")
-            else:
-                return f"❌ Erreur : {response.json().get('detail', 'Erreur inconnue')}"
-
-    except Exception as e:
-        return f"❌ Erreur : {str(e)}"
-
-
-def pass_turn():
-    """
-    Pass the current turn.
-    """
-    if not state.game_id or not state.player_id:
-        return "❌ Vous n'êtes pas dans une enquête"
-
-    try:
-        if IS_HUGGINGFACE:
-            from game_manager import game_manager
-            from game_engine import GameEngine
-
-            game = game_manager.get_game(state.game_id)
-            if not game:
-                return "❌ Enquête introuvable"
-
-            if not GameEngine.can_player_act(game, state.player_id):
-                return "❌ Ce n'est pas votre tour !"
-
-            # Pass turn
-            GameEngine.add_turn_record(game, state.player_id, "pass", "Tour passé")
-            game.next_turn()
-            game_manager.save_games()
-
-            next_player = game.get_current_player()
-            return f"✅ Tour passé !\n\n➡️ C'est maintenant au tour de {next_player.name if next_player else 'quelqu\'un'}."
-
-        else:
-            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:
-                return "✅ Tour passé !"
-            else:
-                return f"❌ Erreur : {response.json().get('detail', 'Erreur inconnue')}"
-
-    except Exception as e:
-        return f"❌ 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("### 🎮 Créer Votre Enquête Personnalisée")
-            gr.Markdown("*Créez votre propre manoir, vos suspects et vos armes...*")
-
-            with gr.Group():
-                game_name_input = gr.Textbox(
-                    label="🎭 Titre de l'enquête",
-                    placeholder="Meurtre au Coworking",
-                    info="Donnez un titre à votre affaire",
-                )
-
-                from models import NarrativeTone
-                narrative_tone_dropdown = gr.Dropdown(
-                    label="🎨 Tonalité narrative",
-                    choices=[tone.value for tone in NarrativeTone],
-                    value=NarrativeTone.SERIOUS.value,
-                    info="Choisissez l'ambiance du jeu",
-                )
-
-                custom_prompt_input = gr.Textbox(
-                    label="✍️ Prompt personnalisé (optionnel)",
-                    placeholder="Style Agatha Christie avec humour noir...",
-                    lines=2,
-                    info="Personnalisez le style narratif de l'IA",
-                )
-
-            with gr.Group():
-                gr.Markdown("#### 🏠 Configuration du Plateau")
-                gr.Markdown("**Important** : L'ordre des pièces définit le plateau de jeu (circuit circulaire)")
-
-                rooms_input = gr.Textbox(
-                    label=f"🚪 Lieux ({settings.MIN_ROOMS}-{settings.MAX_ROOMS}) - DANS L'ORDRE",
-                    placeholder="Cuisine, Toit, Salle serveurs, Cafétéria, Bureau, Salle de réunion",
-                    lines=5,
-                    info="⚠️ L'ORDRE EST IMPORTANT ! Les joueurs se déplaceront dans cet ordre (circuit). Une ligne = une pièce.",
-                )
-
-                gr.Markdown(
-                    """
-                    💡 **Exemple de circuit** :
-                    ```
-                    1. Cuisine (départ)
-                    2. Salon
-                    3. Bureau
-                    4. Chambre
-                    5. Garage
-                    6. Jardin
-                    → retour à Cuisine (circuit fermé)
-                    ```
-                    Les joueurs avancent dans cet ordre selon les dés.
-                    """
-                )
-
-            with gr.Group():
-                gr.Markdown("#### 🎭 Éléments du Mystère")
-
-                suspects_input = gr.Textbox(
-                    label="👤 Suspects (min. 3)",
-                    placeholder="Claire, Pierre, Daniel, Marie, Thomas, Sophie",
-                    lines=2,
-                    info="Qui pourrait être le coupable ?",
-                )
-
-                weapons_input = gr.Textbox(
-                    label="🔪 Armes (min. 3)",
-                    placeholder="Clé USB, Capsule de café, Câble HDMI, Agrafeuse, Souris d'ordinateur, Plante verte",
-                    lines=2,
-                    info="Quelle arme a été utilisée ?",
-                )
-
-            use_ai_checkbox = gr.Checkbox(
-                label="🤖 Activer le Narrateur IA - Desland (le jardinier sarcastique)",
-                value=False,
-                visible=settings.USE_OPENAI,
-                info="Desland commente vos actions avec sarcasme et suspicion...",
-            )
-
-            create_btn = gr.Button(
-                "🎬 Créer l'Enquête", variant="primary", size="lg"
-            )
-            create_output = gr.Textbox(
-                label="📋 Résultat", lines=5, show_copy_button=True
-            )
-            game_id_display = gr.Textbox(
-                label="🔑 Code d'Enquête (à partager)",
-                interactive=False,
-                show_copy_button=True,
-            )
-
-            create_btn.click(
-                create_game,
-                inputs=[
-                    game_name_input,
-                    narrative_tone_dropdown,
-                    custom_prompt_input,
-                    rooms_input,
-                    weapons_input,
-                    suspects_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 de Jeu")
-            gr.Markdown("*Lancez les dés, déplacez-vous, et menez l'enquête...*")
-
-            with gr.Group():
-                refresh_btn = gr.Button(
-                    "🔄 Actualiser le Dossier", size="lg", variant="secondary"
-                )
-                game_view = gr.Textbox(
-                    label="🗂️ État de la Partie",
-                    lines=20,
-                    max_lines=30,
-                    show_copy_button=True,
-                    info="Cliquez sur Actualiser pour voir l'état actuel",
-                )
-
-                refresh_btn.click(get_player_view, outputs=game_view)
-
-            gr.Markdown("---")
-            gr.Markdown("### 🎲 Votre Tour")
-            gr.Markdown("**Étape 1 :** Lancez les dés pour vous déplacer")
-
-            with gr.Group():
-                roll_btn = gr.Button(
-                    "🎲 Lancer les Dés", variant="primary", size="lg"
-                )
-                move_output = gr.Textbox(
-                    label="📍 Déplacement", lines=3
-                )
-
-                roll_btn.click(roll_and_move, outputs=move_output)
-
-            gr.Markdown("---")
-            gr.Markdown("### 💭 Faire une Suggestion")
-            gr.Markdown("**Étape 2 :** Faites une suggestion *dans la pièce où vous êtes*")
-
-            with gr.Group():
-                with gr.Row():
-                    suggest_character = gr.Dropdown(
-                        label="👤 Suspect",
-                        choices=[],  # Will be populated from game
-                        info="Qui est le coupable ?",
-                    )
-                    suggest_weapon = gr.Dropdown(
-                        label="🔪 Arme",
-                        choices=[],  # Will be populated from game
-                        info="Quelle arme ?",
-                    )
-                    suggest_room = gr.Dropdown(
-                        label="🚪 Lieu",
-                        choices=[],  # Will be populated from game
-                        info="Dans quel lieu ?",
-                    )
-
-                suggest_btn = gr.Button(
-                    "💭 Faire la Suggestion", variant="primary", size="lg"
-                )
-                suggest_output = gr.Textbox(
-                    label="🗨️ Résultat", lines=5, 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(
-                "⚠️ **ATTENTION :** Une fausse accusation vous élimine !"
-            )
-
-            with gr.Group():
-                with gr.Row():
-                    accuse_character = gr.Dropdown(
-                        label="👤 Le Coupable",
-                        choices=[],
-                        info="Qui ?",
-                    )
-                    accuse_weapon = gr.Dropdown(
-                        label="🔪 L'Arme",
-                        choices=[],
-                        info="Avec quoi ?",
-                    )
-                    accuse_room = gr.Dropdown(
-                        label="🚪 Le Lieu",
-                        choices=[],
-                        info="Où ?",
-                    )
-
-                accuse_btn = gr.Button(
-                    "⚡ ACCUSER", variant="stop", size="lg"
-                )
-                accuse_output = gr.Textbox(
-                    label="⚖️ Verdict", lines=5, 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
-
-    # Note: We're always in HUGGINGFACE mode (direct backend calls)
-    # No need for FastAPI server
-
-    # Create and launch Gradio interface
-    demo = create_gradio_interface()
-
-    # Launch on available port
-    demo.launch(
-        server_name="127.0.0.1",
-        server_port=7862,
-        share=False,
-        show_error=True,
-    )

backend/game_engine.py

@@ -5,7 +5,7 @@ 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
 
 

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:

backend/main.py

@@ -11,10 +11,10 @@ from pydantic import BaseModel
 from typing import Optional, List
 import os
 
-from models import CreateGameRequest, GameStatus
-from game_manager import game_manager
-from game_engine import GameEngine
-from defaults import get_default_game_config, DEFAULT_THEMES
+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")
 

config.py

@@ -1,37 +0,0 @@
-"""
-Configuration module for Cluedo Custom application.
-Loads environment variables and provides application settings.
-"""
-
-import os
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-
-class Settings:
-    """Application settings loaded from environment variables."""
-
-    # Application settings
-    APP_NAME: str = os.getenv("APP_NAME", "Cluedo Custom")
-    MAX_PLAYERS: int = int(os.getenv("MAX_PLAYERS", "8"))
-
-    # AI settings
-    USE_OPENAI: bool = os.getenv("USE_OPENAI", "false").lower() == "true"
-    OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
-
-    # Game settings
-    MIN_PLAYERS: int = 3
-    MIN_ROOMS: int = 6
-    MAX_ROOMS: int = 12
-
-    # Server settings
-    HOST: str = "0.0.0.0"
-    PORT: int = 7860
-
-    # Game data file
-    GAMES_FILE: str = "games.json"
-
-
-settings = Settings()

frontend/src/App.jsx

@@ -6,13 +6,11 @@ import Game from './pages/Game'
 function App() {
   return (
     <BrowserRouter>
-      <div className="min-h-screen bg-gradient-to-br from-dark-950 via-dark-900 to-dark-950">
-        <Routes>
-          <Route path="/" element={<Home />} />
-          <Route path="/join" element={<Join />} />
-          <Route path="/game/:gameId/:playerId" element={<Game />} />
-        </Routes>
-      </div>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/join" element={<Join />} />
+        <Route path="/game/:gameId/:playerId" element={<Game />} />
+      </Routes>
     </BrowserRouter>
   )
 }

frontend/src/pages/Game.jsx

@@ -107,8 +107,8 @@ function Game() {
 
   if (loading) {
     return (
-      <div className="min-h-screen flex items-center justify-center">
-        <div className="text-accent-400 text-xl">Chargement...</div>
+      <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>
     )
   }
@@ -118,43 +118,52 @@ function Game() {
   const canStart = me?.is_creator && gameState.status === 'waiting' && gameState.players.length >= 3
 
   return (
-    <div className="min-h-screen p-4">
-      <div className="max-w-6xl mx-auto space-y-6">
+    <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-dark-800 p-6 rounded-lg border border-dark-700">
+        <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-3xl font-bold text-accent-400">🔍 Partie {gameState.game_code}</h1>
-              <p className="text-dark-300">Joueur: {me?.name}</p>
+              <h1 className="text-4xl font-bold text-haunted-blood mb-1 animate-flicker drop-shadow-[0_0_10px_rgba(139,0,0,0.5)]">
+                🏰 Manoir {gameState.game_code}
+              </h1>
+              <p className="text-haunted-fog/80">👤 {me?.name} {me?.is_eliminated && '💀 (Éliminé)'}</p>
             </div>
             <div className="text-right">
-              <p className="text-dark-300">Status: {gameState.status === 'waiting' ? '⏳ En attente' : gameState.status === 'playing' ? '🎮 En cours' : '🏆 Terminée'}</p>
-              <p className="text-dark-400 text-sm">{gameState.players.length} joueurs</p>
+              <p className="text-haunted-fog">
+                {gameState.status === 'waiting' ? '⏳ En attente des âmes' :
+                 gameState.status === 'playing' ? '🎮 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-green-600 hover:bg-green-700 disabled:bg-dark-600 text-white font-semibold rounded-lg"
+              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"
             >
-              🚀 Démarrer la partie
+              🚀 Commencer l'enquête
             </button>
           )}
         </div>
 
         <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
           {/* Plateau */}
-          <div className="bg-dark-800 p-6 rounded-lg border border-dark-700">
-            <h2 className="text-xl font-bold text-accent-400 mb-4">🏰 Plateau</h2>
+          <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">🏰 Les Pièces du Manoir</h2>
             <div className="space-y-2">
               {gameState.board?.rooms.map((room, idx) => (
-                <div key={idx} className="bg-dark-700 p-3 rounded">
-                  <div className="font-semibold text-white">{room.name}</div>
-                  <div className="text-sm text-dark-300">
-                    Joueurs: {room.player_ids.map(id =>
+                <div key={idx} className="bg-black/40 p-3 rounded border border-haunted-shadow hover:border-haunted-blood/50 transition-all">
+                  <div className="font-semibold text-haunted-fog">{room.name}</div>
+                  <div className="text-sm text-haunted-fog/60">
+                    👥 {room.player_ids.map(id =>
                       gameState.players.find(p => p.id === id)?.name || id
-                    ).join(', ') || 'Aucun'}
+                    ).join(', ') || 'Aucune âme'}
                   </div>
                 </div>
               ))}
@@ -162,14 +171,14 @@ function Game() {
           </div>
 
           {/* Mes cartes */}
-          <div className="bg-dark-800 p-6 rounded-lg border border-dark-700">
-            <h2 className="text-xl font-bold text-accent-400 mb-4">🃏 Mes cartes</h2>
+          <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">
               {me?.cards.map((card, idx) => (
-                <div key={idx} className="bg-dark-700 px-4 py-2 rounded text-white">
+                <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 === 'suspect' && '👤 '}
                   {card.type === 'weapon' && '🔪 '}
-                  {card.type === 'room' && '🏠 '}
+                  {card.type === 'room' && '🏚️ '}
                   {card.name}
                 </div>
               ))}
@@ -179,9 +188,9 @@ function Game() {
 
         {/* Actions */}
         {gameState.status === 'playing' && (
-          <div className="bg-dark-800 p-6 rounded-lg border border-dark-700">
-            <h2 className="text-xl font-bold text-accent-400 mb-4">
-              {isMyTurn ? '⚡ À votre tour !' : '⏳ Tour de ' + gameState.players.find(p => p.id === gameState.current_player_id)?.name}
+          <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">
+              {isMyTurn ? '⚡ À vous de jouer !' : '⏳ ' + gameState.players.find(p => p.id === gameState.current_player_id)?.name + ' enquête...'}
             </h2>
 
             {isMyTurn && (
@@ -191,14 +200,14 @@ function Game() {
                     <button
                       onClick={handleRollDice}
                       disabled={actionLoading}
-                      className="px-6 py-3 bg-accent-600 hover:bg-accent-700 disabled:bg-dark-600 text-white font-semibold rounded-lg"
+                      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-dark-600 hover:bg-dark-500 text-white font-semibold rounded-lg"
+                      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>
@@ -207,11 +216,11 @@ function Game() {
                   <div className="space-y-4">
                     <div className="grid grid-cols-3 gap-4">
                       <div>
-                        <label className="block text-sm text-dark-300 mb-2">Suspect</label>
+                        <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-dark-700 text-white rounded border border-dark-600"
+                          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.board?.suspects.map((s, i) => (
@@ -220,11 +229,11 @@ function Game() {
                         </select>
                       </div>
                       <div>
-                        <label className="block text-sm text-dark-300 mb-2">Arme</label>
+                        <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-dark-700 text-white rounded border border-dark-600"
+                          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.board?.weapons.map((w, i) => (
@@ -233,11 +242,11 @@ function Game() {
                         </select>
                       </div>
                       <div>
-                        <label className="block text-sm text-dark-300 mb-2">Pièce</label>
+                        <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-dark-700 text-white rounded border border-dark-600"
+                          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.board?.rooms.map((r, i) => (
@@ -250,21 +259,21 @@ function Game() {
                       <button
                         onClick={handleSuggestion}
                         disabled={actionLoading}
-                        className="px-6 py-3 bg-blue-600 hover:bg-blue-700 disabled:bg-dark-600 text-white font-semibold rounded-lg"
+                        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-red-600 hover:bg-red-700 disabled:bg-dark-600 text-white font-semibold rounded-lg"
+                        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>
                       <button
                         onClick={handlePassTurn}
                         disabled={actionLoading}
-                        className="px-6 py-3 bg-dark-600 hover:bg-dark-500 text-white font-semibold rounded-lg"
+                        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>
@@ -277,11 +286,11 @@ function Game() {
         )}
 
         {/* Historique */}
-        <div className="bg-dark-800 p-6 rounded-lg border border-dark-700">
-          <h2 className="text-xl font-bold text-accent-400 mb-4">📜 Historique</h2>
-          <div className="space-y-2">
+        <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.history?.slice(-10).reverse().map((event, idx) => (
-              <div key={idx} className="text-dark-300 text-sm border-l-2 border-accent-600 pl-3 py-1">
+              <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">
                 {event}
               </div>
             ))}

frontend/src/pages/Home.jsx

@@ -26,16 +26,26 @@ function Home() {
   }
 
   return (
-    <div className="min-h-screen flex items-center justify-center p-4">
-      <div className="max-w-md w-full space-y-8 bg-dark-800 p-8 rounded-lg shadow-2xl border border-dark-700">
+    <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-accent-400 mb-2">🔍 Cluedo Custom</h1>
-          <p className="text-dark-300">Créez votre partie et invitez vos amis</p>
+          <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-dark-200 mb-2">
+            <label className="block text-sm font-medium text-haunted-fog mb-2">
               Votre nom
             </label>
             <input
@@ -43,32 +53,32 @@ function Home() {
               value={playerName}
               onChange={(e) => setPlayerName(e.target.value)}
               onKeyPress={(e) => e.key === 'Enter' && handleCreateGame()}
-              placeholder="Entrez votre nom"
-              className="w-full px-4 py-3 bg-dark-700 border border-dark-600 rounded-lg text-white placeholder-dark-400 focus:outline-none focus:ring-2 focus:ring-accent-500"
+              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-accent-600 hover:bg-accent-700 disabled:bg-dark-600 text-white font-semibold rounded-lg transition-colors"
+            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...' : '🎮 Créer une partie'}
+            {loading ? '🕯️ Création...' : '🚪 Entrer dans le Manoir'}
           </button>
 
           <div className="text-center pt-4">
             <button
               onClick={() => navigate('/join')}
-              className="text-accent-400 hover:text-accent-300 underline"
+              className="text-haunted-fog/70 hover:text-haunted-blood underline transition-colors"
             >
-              Rejoindre une partie existante
+              👻 Rejoindre une partie existante
             </button>
           </div>
         </div>
 
-        <div className="mt-8 pt-6 border-t border-dark-700 text-center text-sm text-dark-400">
-          <p>Thème par défaut : Manoir Classique</p>
-          <p className="mt-1">3-6 joueurs recommandés</p>
+        <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>

frontend/src/pages/Join.jsx

@@ -27,30 +27,39 @@ function Join() {
   }
 
   return (
-    <div className="min-h-screen flex items-center justify-center p-4">
-      <div className="max-w-md w-full space-y-8 bg-dark-800 p-8 rounded-lg shadow-2xl border border-dark-700">
+    <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-4xl font-bold text-accent-400 mb-2">🚪 Rejoindre une partie</h1>
-          <p className="text-dark-300">Entrez le code partagé par votre hôte</p>
+          <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-dark-200 mb-2">
-              Code de partie
+            <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="Ex: ABC4"
+              placeholder="?????"
               maxLength={4}
-              className="w-full px-4 py-3 bg-dark-700 border border-dark-600 rounded-lg text-white text-center text-2xl font-mono placeholder-dark-400 focus:outline-none focus:ring-2 focus:ring-accent-500 uppercase"
+              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-dark-200 mb-2">
+            <label className="block text-sm font-medium text-haunted-fog mb-2">
               Votre nom
             </label>
             <input
@@ -58,25 +67,25 @@ function Join() {
               value={playerName}
               onChange={(e) => setPlayerName(e.target.value)}
               onKeyPress={(e) => e.key === 'Enter' && handleJoinGame()}
-              placeholder="Entrez votre nom"
-              className="w-full px-4 py-3 bg-dark-700 border border-dark-600 rounded-lg text-white placeholder-dark-400 focus:outline-none focus:ring-2 focus:ring-accent-500"
+              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-accent-600 hover:bg-accent-700 disabled:bg-dark-600 text-white font-semibold rounded-lg transition-colors"
+            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...' : '✅ Rejoindre'}
+            {loading ? '🕯️ Connexion...' : '🚪 Entrer dans le Manoir'}
           </button>
 
           <div className="text-center pt-4">
             <button
               onClick={() => navigate('/')}
-              className="text-accent-400 hover:text-accent-300 underline"
+              className="text-haunted-fog/70 hover:text-haunted-blood underline transition-colors"
             >
-              ← Retour à l'accueil
+              ← Retourner dans les ténèbres
             </button>
           </div>
         </div>

frontend/tailwind.config.js

@@ -32,6 +32,45 @@ export default {
           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' },
+        },
       },
     },
   },

game_engine.py

@@ -1,294 +0,0 @@
-"""
-Game engine for Cluedo Custom.
-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 datetime import datetime
-
-
-# Default character names (fallback if no custom suspects provided)
-DEFAULT_CHARACTERS = [
-    "Miss Scarlett",
-    "Colonel Mustard",
-    "Mrs. White",
-    "Reverend Green",
-    "Mrs. Peacock",
-    "Professor Plum"
-]
-
-# Default weapon names (fallback if no custom weapons provided)
-DEFAULT_WEAPONS = [
-    "Candlestick",
-    "Knife",
-    "Lead Pipe",
-    "Revolver",
-    "Rope",
-    "Wrench"
-]
-
-
-class GameEngine:
-    """Core game logic engine for Cluedo Custom."""
-
-    @staticmethod
-    def initialize_game(game: Game) -> Game:
-        """
-        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 suspects
-        ]
-
-        # Create weapon cards
-        game.weapons = [
-            Card(name=name, card_type=CardType.WEAPON)
-            for name in weapons
-        ]
-
-        # Create room cards
-        game.room_cards = [
-            Card(name=room, card_type=CardType.ROOM)
-            for room in game.rooms
-        ]
-
-        # Select solution (one of each type)
-        solution_character = random.choice(game.characters)
-        solution_weapon = random.choice(game.weapons)
-        solution_room = random.choice(game.room_cards)
-
-        game.solution = Solution(
-            character=solution_character,
-            weapon=solution_weapon,
-            room=solution_room
-        )
-
-        # Remaining cards to distribute
-        remaining_cards = []
-        remaining_cards.extend([c for c in game.characters if c.name != solution_character.name])
-        remaining_cards.extend([w for w in game.weapons if w.name != solution_weapon.name])
-        remaining_cards.extend([r for r in game.room_cards if r.name != solution_room.name])
-
-        # Shuffle and distribute
-        random.shuffle(remaining_cards)
-        GameEngine._distribute_cards(game, remaining_cards)
-
-        # Set game status to in progress
-        game.status = GameStatus.IN_PROGRESS
-        game.current_player_index = 0
-
-        return game
-
-    @staticmethod
-    def _distribute_cards(game: Game, cards: List[Card]):
-        """
-        Distribute cards evenly among all players.
-        """
-        num_players = len(game.players)
-        if num_players == 0:
-            return
-
-        for i, card in enumerate(cards):
-            player_index = i % num_players
-            game.players[player_index].cards.append(card)
-
-    @staticmethod
-    def check_suggestion(
-        game: Game,
-        player_id: str,
-        character: str,
-        weapon: str,
-        room: str
-    ) -> Tuple[bool, Optional[str], Optional[Card]]:
-        """
-        Process a player's suggestion.
-        Returns (can_disprove, disprover_name, card_shown).
-
-        Starting with the next player clockwise, check if anyone can disprove
-        the suggestion by showing one matching card.
-        """
-        player_index = next(
-            (i for i, p in enumerate(game.players) if p.id == player_id),
-            None
-        )
-        if player_index is None:
-            return False, None, None
-
-        num_players = len(game.players)
-
-        # Check other players clockwise
-        for offset in range(1, num_players):
-            check_index = (player_index + offset) % num_players
-            checker = game.players[check_index]
-
-            # Find matching cards
-            matching_cards = [
-                card for card in checker.cards
-                if card.name in [character, weapon, room]
-            ]
-
-            if matching_cards:
-                # Show one random matching card
-                card_to_show = random.choice(matching_cards)
-                return True, checker.name, card_to_show
-
-        # No one can disprove
-        return False, None, None
-
-    @staticmethod
-    def check_accusation(
-        game: Game,
-        character: str,
-        weapon: str,
-        room: str
-    ) -> bool:
-        """
-        Check if an accusation is correct.
-        Returns True if the accusation matches the solution.
-        """
-        if not game.solution:
-            return False
-
-        return (
-            game.solution.character.name == character and
-            game.solution.weapon.name == weapon and
-            game.solution.room.name == room
-        )
-
-    @staticmethod
-    def process_accusation(
-        game: Game,
-        player_id: str,
-        character: str,
-        weapon: str,
-        room: str
-    ) -> Tuple[bool, str]:
-        """
-        Process a player's accusation.
-        Returns (is_correct, message).
-
-        If correct, player wins.
-        If incorrect, player is eliminated from the game.
-        """
-        player = next((p for p in game.players if p.id == player_id), None)
-        if not player:
-            return False, "Player not found"
-
-        is_correct = GameEngine.check_accusation(game, character, weapon, room)
-
-        if is_correct:
-            game.winner = player.name
-            game.status = GameStatus.FINISHED
-            return True, f"{player.name} wins! The accusation was correct."
-        else:
-            # Eliminate player
-            player.is_active = False
-
-            # Check if only one or no players remain active
-            active_players = [p for p in game.players if p.is_active]
-            if len(active_players) <= 1:
-                game.status = GameStatus.FINISHED
-                if active_players:
-                    game.winner = active_players[0].name
-                    return False, f"{player.name}'s accusation was wrong. {game.winner} wins by elimination!"
-                else:
-                    return False, "All players eliminated. Game over!"
-
-            return False, f"{player.name}'s accusation was wrong and is eliminated from the game."
-
-    @staticmethod
-    def add_turn_record(
-        game: Game,
-        player_id: str,
-        action: str,
-        details: Optional[str] = None,
-        ai_comment: Optional[str] = None
-    ):
-        """Add a turn record to the game history."""
-        from models import Turn
-
-        player = next((p for p in game.players if p.id == player_id), None)
-        if not player:
-            return
-
-        turn = Turn(
-            player_id=player_id,
-            player_name=player.name,
-            action=action,
-            details=details,
-            ai_comment=ai_comment,
-            timestamp=datetime.now().isoformat()
-        )
-        game.turns.append(turn)
-
-    @staticmethod
-    def get_player_card_names(player: Player) -> List[str]:
-        """Get list of card names for a player."""
-        return [card.name for card in player.cards]
-
-    @staticmethod
-    def can_player_act(game: Game, player_id: str) -> bool:
-        """Check if it's the player's turn and they can act."""
-        current_player = game.get_current_player()
-        if not current_player:
-            return False
-
-        return (
-            current_player.id == player_id and
-            current_player.is_active and
-            game.status == GameStatus.IN_PROGRESS
-        )
-
-    @staticmethod
-    def roll_dice() -> int:
-        """Roll two dice and return the sum (2-12)."""
-        return random.randint(1, 6) + random.randint(1, 6)
-
-    @staticmethod
-    def move_player(game: Game, player_id: str, dice_roll: int) -> Tuple[bool, str, int]:
-        """
-        Move a player on the board based on dice roll.
-        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
-
-        # Calculate new position (circular movement)
-        new_room_index = (player.current_room_index + dice_roll) % num_rooms
-        old_room = game.rooms[player.current_room_index]
-        new_room = game.rooms[new_room_index]
-
-        player.current_room_index = new_room_index
-
-        message = f"🎲 Dés: {dice_roll} | {old_room} → {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

@@ -1,151 +0,0 @@
-"""
-Game manager for handling multiple concurrent games.
-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
-
-
-class GameManager:
-    """Manages multiple game instances in memory."""
-
-    def __init__(self):
-        self.games: Dict[str, Game] = {}
-        self.load_games()
-
-    def create_game(self, request: CreateGameRequest) -> Game:
-        """
-        Create a new game instance.
-        """
-        game_id = Game.generate_game_id()
-
-        # Ensure unique game ID
-        while game_id in self.games:
-            game_id = Game.generate_game_id()
-
-        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,
-            max_players=settings.MAX_PLAYERS
-        )
-
-        self.games[game_id] = game
-        self.save_games()
-
-        return game
-
-    def get_game(self, game_id: str) -> Optional[Game]:
-        """Retrieve a game by ID."""
-        return self.games.get(game_id)
-
-    def join_game(self, game_id: str, player_name: str) -> Optional[Player]:
-        """
-        Add a player to an existing game.
-        Returns the player if successful, None otherwise.
-        """
-        game = self.get_game(game_id)
-
-        if not game:
-            return None
-
-        if game.status != GameStatus.WAITING:
-            return None  # Can't join a game in progress
-
-        if game.is_full():
-            return None  # Game is full
-
-        player = game.add_player(player_name)
-        self.save_games()
-
-        return player
-
-    def start_game(self, game_id: str) -> bool:
-        """
-        Start a game (initialize cards and solution).
-        Returns True if successful.
-        """
-        game = self.get_game(game_id)
-
-        if not game:
-            return False
-
-        if game.status != GameStatus.WAITING:
-            return False  # Game already started
-
-        if len(game.players) < settings.MIN_PLAYERS:
-            return False  # Not enough players
-
-        # Initialize the game
-        GameEngine.initialize_game(game)
-        self.save_games()
-
-        return True
-
-    def list_active_games(self) -> List[Dict]:
-        """
-        List all active games (waiting or in progress).
-        Returns simplified game info for listing.
-        """
-        active_games = []
-
-        for game in self.games.values():
-            if game.status in [GameStatus.WAITING, GameStatus.IN_PROGRESS]:
-                active_games.append({
-                    "game_id": game.game_id,
-                    "name": game.name,
-                    "status": game.status,
-                    "players": len(game.players),
-                    "max_players": game.max_players,
-                })
-
-        return active_games
-
-    def delete_game(self, game_id: str) -> bool:
-        """Delete a game from memory."""
-        if game_id in self.games:
-            del self.games[game_id]
-            self.save_games()
-            return True
-        return False
-
-    def save_games(self):
-        """Persist games to JSON file."""
-        try:
-            games_data = {
-                game_id: game.model_dump()
-                for game_id, game in self.games.items()
-            }
-
-            with open(settings.GAMES_FILE, 'w') as f:
-                json.dump(games_data, f, indent=2)
-        except Exception as e:
-            print(f"Error saving games: {e}")
-
-    def load_games(self):
-        """Load games from JSON file if it exists."""
-        if not os.path.exists(settings.GAMES_FILE):
-            return
-
-        try:
-            with open(settings.GAMES_FILE, 'r') as f:
-                games_data = json.load(f)
-
-            for game_id, game_dict in games_data.items():
-                self.games[game_id] = Game(**game_dict)
-        except Exception as e:
-            print(f"Error loading games: {e}")
-
-
-# Global game manager instance
-game_manager = GameManager()

models.py

@@ -1,182 +0,0 @@
-"""
-Data models for Cluedo Custom game.
-Defines the structure of players, cards, and game state.
-"""
-
-from typing import List, Optional, Dict
-from pydantic import BaseModel, Field
-from enum import Enum
-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"
-    WEAPON = "weapon"
-    ROOM = "room"
-
-
-class Card(BaseModel):
-    """Represents a single card in the game."""
-    name: str
-    card_type: CardType
-
-
-class Player(BaseModel):
-    """Represents a player in the game."""
-    id: str
-    name: str
-    cards: List[Card] = Field(default_factory=list)
-    is_active: bool = True
-    current_room_index: int = 0  # Position on the board
-
-
-class GameStatus(str, Enum):
-    """Status of a game."""
-    WAITING = "waiting"  # Waiting for players to join
-    IN_PROGRESS = "in_progress"  # Game is running
-    FINISHED = "finished"  # Game has ended
-
-
-class Turn(BaseModel):
-    """Represents a turn action in the game."""
-    player_id: str
-    player_name: str
-    action: str  # "move", "suggest", "accuse", "pass"
-    details: Optional[str] = None
-    ai_comment: Optional[str] = None  # Desland's sarcastic comment
-    timestamp: str
-
-
-class Solution(BaseModel):
-    """The secret solution to the mystery."""
-    character: Card
-    weapon: Card
-    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 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
-    players: List[Player] = Field(default_factory=list)
-    max_players: int = 8
-    current_player_index: int = 0
-
-    # Cards
-    characters: List[Card] = Field(default_factory=list)
-    weapons: List[Card] = Field(default_factory=list)
-    room_cards: List[Card] = Field(default_factory=list)
-
-    # Solution
-    solution: Optional[Solution] = None
-
-    # Game state
-    turns: List[Turn] = Field(default_factory=list)
-    winner: Optional[str] = None
-
-    # Investigation notes (for UI)
-    investigation_notes: List[InvestigationNote] = Field(default_factory=list)
-
-    # AI-generated content
-    scenario: Optional[str] = None
-
-    @staticmethod
-    def generate_game_id() -> str:
-        """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))
-        # 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
-
-    def get_current_player(self) -> Optional[Player]:
-        """Get the player whose turn it is."""
-        if not self.players:
-            return None
-        return self.players[self.current_player_index]
-
-    def next_turn(self):
-        """Move to the next active player's turn."""
-        if not self.players:
-            return
-
-        # 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."""
-        return len(self.players) >= self.max_players
-
-
-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
-
-
-class JoinGameRequest(BaseModel):
-    """Request to join an existing game."""
-    game_id: str
-    player_name: str
-
-
-class GameAction(BaseModel):
-    """Request to perform a game action."""
-    game_id: str
-    player_id: str
-    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