update

client/src/components/LoadingScreen.jsx

@@ -0,0 +1,88 @@
+import React, { useState, useEffect } from "react";
+import { Box, Typography } from "@mui/material";
+import { motion } from "framer-motion";
+import CreateIcon from "@mui/icons-material/Create";
+import AutoStoriesIcon from "@mui/icons-material/AutoStories";
+import PaletteIcon from "@mui/icons-material/Palette";
+
+const defaultMessages = [
+  "waking up a sleepy AI...",
+  "teaching robots to tell bedtime stories...",
+  "bribing pixels to make pretty pictures...",
+];
+
+const iconMap = {
+  story: CreateIcon,
+  universe: AutoStoriesIcon,
+  art: PaletteIcon,
+};
+
+export const LoadingScreen = ({
+  messages = defaultMessages,
+  icon = "story",
+  messageInterval = 3000,
+  iconColor = "white",
+  textColor = "white",
+}) => {
+  const [currentMessage, setCurrentMessage] = useState(0);
+  const IconComponent = iconMap[icon] || CreateIcon;
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setCurrentMessage((prev) => (prev + 1) % messages.length);
+    }, messageInterval);
+    return () => clearInterval(interval);
+  }, [messages.length, messageInterval]);
+
+  return (
+    <Box
+      sx={{
+        position: "absolute",
+        top: "50%",
+        left: "50%",
+        transform: "translate(-50%, -50%)",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 2,
+      }}
+    >
+      <motion.div
+        animate={{
+          y: [0, -10, 0],
+        }}
+        transition={{
+          duration: 2,
+          repeat: Infinity,
+          ease: "easeInOut",
+        }}
+      >
+        <IconComponent
+          sx={{
+            fontSize: 40,
+            color: iconColor,
+            opacity: 0.2,
+          }}
+        />
+      </motion.div>
+      <motion.div
+        key={currentMessage}
+        initial={{ opacity: 0, y: 5 }}
+        animate={{ opacity: 1, y: 0 }}
+        exit={{ opacity: 0, y: -5 }}
+        transition={{ duration: 0.3 }}
+      >
+        <Typography
+          variant="body1"
+          sx={{
+            color: textColor,
+            opacity: 0.8,
+            fontStyle: "italic",
+          }}
+        >
+          {messages[currentMessage]}
+        </Typography>
+      </motion.div>
+    </Box>
+  );
+};

client/src/hooks/useGameSession.js

@@ -0,0 +1,40 @@
+import { useState, useEffect } from "react";
+import { universeApi } from "../utils/api";
+
+export const useGameSession = () => {
+  const [sessionId, setSessionId] = useState(null);
+  const [universe, setUniverse] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    const initializeGame = async () => {
+      try {
+        setIsLoading(true);
+        const { session_id, base_story, style, genre, epoch } =
+          await universeApi.generate();
+
+        setSessionId(session_id);
+        setUniverse({
+          base_story,
+          style,
+          genre,
+          epoch,
+        });
+      } catch (err) {
+        setError(err.message || "Failed to initialize game session");
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    initializeGame();
+  }, []);
+
+  return {
+    sessionId,
+    universe,
+    isLoading,
+    error,
+  };
+};

client/src/pages/Game.jsx

@@ -14,6 +14,7 @@ import { useNarrator } from "../hooks/useNarrator";
 import { useStoryCapture } from "../hooks/useStoryCapture";
 import { usePageSound } from "../hooks/usePageSound";
 import { useWritingSound } from "../hooks/useWritingSound";
+import { useGameSession } from "../hooks/useGameSession";
 import { StoryChoices } from "../components/StoryChoices";
 import { ErrorDisplay } from "../components/ErrorDisplay";
 import VolumeUpIcon from "@mui/icons-material/VolumeUp";
@@ -22,6 +23,7 @@ import PhotoCameraOutlinedIcon from "@mui/icons-material/PhotoCameraOutlined";
 import ArrowBackIcon from "@mui/icons-material/ArrowBack";
 import CreateIcon from "@mui/icons-material/Create";
 import { getNextLayoutType, LAYOUTS } from "../layouts/config";
+import { LoadingScreen } from "../components/LoadingScreen";
 
 // Constants
 const SOUND_ENABLED_KEY = "sound_enabled";
@@ -67,16 +69,24 @@ export function Game() {
     useNarrator(isSoundEnabled);
   const playPageSound = usePageSound(isSoundEnabled);
   const playWritingSound = useWritingSound(isSoundEnabled);
+  const {
+    sessionId,
+    universe,
+    isLoading: isSessionLoading,
+    error: sessionError,
+  } = useGameSession();
 
   // Sauvegarder l'état du son dans le localStorage
   useEffect(() => {
     localStorage.setItem(SOUND_ENABLED_KEY, isSoundEnabled);
   }, [isSoundEnabled]);
 
-  // Start the story on first render
+  // Start the story when session is ready
   useEffect(() => {
-    handleStoryAction("restart");
-  }, []);
+    if (sessionId && !isSessionLoading) {
+      handleStoryAction("restart");
+    }
+  }, [sessionId, isSessionLoading]);
 
   // Add effect for message rotation
   useEffect(() => {
@@ -128,18 +138,17 @@ export function Game() {
   const handleStoryAction = async (action, choiceId = null) => {
     setIsLoading(true);
     setShowChoices(false);
-    setError(null); // Reset error state
+    setError(null);
     try {
-      // Stop any ongoing narration
       if (isNarratorSpeaking) {
         stopNarration();
       }
 
       console.log("Starting story action:", action);
-      // 1. Get the story
+      // Pass sessionId to API calls
       const storyData = await (action === "restart"
-        ? storyApi.start()
-        : storyApi.makeChoice(choiceId));
+        ? storyApi.start(sessionId)
+        : storyApi.makeChoice(choiceId, sessionId));
 
       if (!storyData) {
         throw new Error("Pas de données reçues du serveur");
@@ -303,6 +312,33 @@ export function Game() {
     await downloadStoryImage(storyContainerRef, `your-story-${Date.now()}.png`);
   };
 
+  // Show session error if any
+  if (sessionError) {
+    return (
+      <ErrorDisplay
+        message="Impossible d'initialiser la session de jeu. Veuillez rafraîchir la page."
+        error={sessionError}
+      />
+    );
+  }
+
+  // Show loading state while session is initializing
+  if (isSessionLoading) {
+    return (
+      <Box sx={{ width: "100%", height: "100vh", backgroundColor: "#1a1a1a" }}>
+        <LoadingScreen
+          icon="universe"
+          messages={[
+            "Creating a new universe...",
+            "Gathering comic book inspiration...",
+            "Drawing the first panels...",
+            "Setting up the story...",
+          ]}
+        />
+      </Box>
+    );
+  }
+
   return (
     <motion.div
       initial={{ opacity: 0 }}
@@ -369,51 +405,16 @@ export function Game() {
         ) : (
           <>
             {isLoading && storySegments.length === 0 ? (
-              <Box
-                sx={{
-                  position: "absolute",
-                  top: "50%",
-                  left: "50%",
-                  transform: "translate(-50%, -50%)",
-                  display: "flex",
-                  flexDirection: "column",
-                  alignItems: "center",
-                  gap: 2,
-                }}
-              >
-                <motion.div
-                  animate={{
-                    y: [0, -10, 0],
-                  }}
-                  transition={{
-                    duration: 2,
-                    repeat: Infinity,
-                    ease: "easeInOut",
-                  }}
-                >
-                  <CreateIcon
-                    sx={{ fontSize: 40, color: "white", opacity: 0.2 }}
-                  />
-                </motion.div>
-                <motion.div
-                  key={loadingMessage}
-                  initial={{ opacity: 0, y: 5 }}
-                  animate={{ opacity: 1, y: 0 }}
-                  exit={{ opacity: 0, y: -5 }}
-                  transition={{ duration: 0.3 }}
-                >
-                  <Typography
-                    variant="body1"
-                    sx={{
-                      color: "white",
-                      opacity: 0.8,
-                      fontStyle: "italic",
-                    }}
-                  >
-                    {messages[loadingMessage]}
-                  </Typography>
-                </motion.div>
-              </Box>
+              <LoadingScreen
+                icon="story"
+                messages={[
+                  "Bringing the universe to life...",
+                  "Awakening the characters...",
+                  "Polishing the first scene...",
+                  "Preparing the adventure...",
+                  "Adding final touches to the world...",
+                ]}
+              />
             ) : (
               <>
                 <ComicLayout

client/src/pages/Tutorial.jsx

@@ -135,20 +135,21 @@ export function Tutorial() {
               color="black"
               sx={{ fontWeight: "normal" }}
             >
-              Since the rise of <strong>AI</strong>, the world is desolate due
-              to a <strong>nuclear winter</strong> caused by rogue{" "}
-              <strong>AIs</strong> that launched <strong>bombs</strong> all over
-              the planet. You are the only <strong>survivor</strong> of the{" "}
-              <strong>bunker</strong>.
+              You are <strong>Sarah</strong>, an <strong>AI</strong> hunter
+              traveling through
+              <strong>parallel worlds</strong>. Your mission is to track down an{" "}
+              <strong>AI</strong> that moves from world to world to avoid
+              destruction.
               <br />
               <br />
-              You have to make <strong>decisions</strong> to{" "}
-              <strong>survive</strong>. You have ventured out of your{" "}
-              <strong>bunker</strong> to find <strong>medicine</strong> for your{" "}
-              <strong>sick sister</strong>. If you don't find it, she will{" "}
-              <strong>die</strong>. <strong>Time</strong> is running out, and
-              every <strong>choice</strong>&nbsp; matters in this desperate{" "}
-              <strong>quest</strong>.
+              You must make crucial <strong>decisions</strong> to advance in
+              your
+              <strong>quest</strong>. Each <strong>world</strong> presents its
+              own challenges and
+              <strong>obstacles</strong>, and every <strong>choice</strong> you
+              make can alter the course of your <strong>pursuit</strong>.{" "}
+              <strong>Time</strong> is of the essence, and every{" "}
+              <strong>action</strong> counts in this thrilling adventure.
             </Typography>
             <Typography variant="h4">How to play</Typography>
             <Typography variant="body1" sx={{ fontWeight: "normal" }}>

client/src/utils/api.js

@@ -10,12 +10,28 @@ const API_URL = isHFSpace
 // Create axios instance with default config
 const api = axios.create({
   baseURL: API_URL,
-  headers: getDefaultHeaders(),
   ...(isHFSpace && {
     baseURL: window.location.origin,
   }),
 });
 
+// Add request interceptor to handle headers
+api.interceptors.request.use((config) => {
+  // Routes qui ne nécessitent pas de session_id
+  const noSessionRoutes = ["/api/universe/generate", "/api/generate-image"];
+
+  if (noSessionRoutes.includes(config.url)) {
+    return config;
+  }
+
+  // Pour toutes les autres requêtes, s'assurer qu'on a un session_id
+  if (!config.headers["x-session-id"]) {
+    throw new Error("Session ID is required for this request");
+  }
+
+  return config;
+});
+
 // Error handling middleware
 const handleApiError = (error) => {
   console.error("API Error:", {
@@ -48,12 +64,18 @@ const handleApiError = (error) => {
 
 // Story related API calls
 export const storyApi = {
-  start: async () => {
+  start: async (sessionId) => {
     try {
-      console.log("Calling start API...");
-      const response = await api.post("/api/chat", {
-        message: "restart",
-      });
+      console.log("Calling start API with session:", sessionId);
+      const response = await api.post(
+        "/api/chat",
+        {
+          message: "restart",
+        },
+        {
+          headers: getDefaultHeaders(sessionId),
+        }
+      );
       console.log("Start API response:", response.data);
       return response.data;
     } catch (error) {
@@ -61,13 +83,19 @@ export const storyApi = {
     }
   },
 
-  makeChoice: async (choiceId) => {
+  makeChoice: async (choiceId, sessionId) => {
     try {
-      console.log("Making choice:", choiceId);
-      const response = await api.post("/api/chat", {
-        message: "choice",
-        choice_id: choiceId,
-      });
+      console.log("Making choice:", choiceId, "for session:", sessionId);
+      const response = await api.post(
+        "/api/chat",
+        {
+          message: "choice",
+          choice_id: choiceId,
+        },
+        {
+          headers: getDefaultHeaders(sessionId),
+        }
+      );
       console.log("Choice API response:", response.data);
       return response.data;
     } catch (error) {
@@ -75,14 +103,26 @@ export const storyApi = {
     }
   },
 
-  generateImage: async (prompt, width = 512, height = 512) => {
+  generateImage: async (
+    prompt,
+    width = 512,
+    height = 512,
+    sessionId = null
+  ) => {
     try {
       console.log("Generating image with prompt:", prompt);
-      const response = await api.post("/api/generate-image", {
+      const config = {
         prompt,
         width,
         height,
-      });
+      };
+
+      const options = {};
+      if (sessionId) {
+        options.headers = getDefaultHeaders(sessionId);
+      }
+
+      const response = await api.post("/api/generate-image", config, options);
       console.log("Image generation response:", {
         success: response.data.success,
         hasImage: !!response.data.image_base64,
@@ -94,12 +134,18 @@ export const storyApi = {
   },
 
   // Narration related API calls
-  narrate: async (text) => {
+  narrate: async (text, sessionId) => {
     try {
       console.log("Requesting narration for:", text);
-      const response = await api.post("/api/text-to-speech", {
-        text,
-      });
+      const response = await api.post(
+        "/api/text-to-speech",
+        {
+          text,
+        },
+        {
+          headers: getDefaultHeaders(sessionId),
+        }
+      );
       console.log("Narration response received");
       return response.data;
     } catch (error) {
@@ -111,5 +157,16 @@ export const storyApi = {
 // WebSocket URL
 export const WS_URL = import.meta.env.VITE_WS_URL || "ws://localhost:8000/ws";
 
+export const universeApi = {
+  generate: async () => {
+    try {
+      const response = await api.post("/api/universe/generate");
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+};
+
 // Export the base API instance for other uses
 export default api;

client/src/utils/session.js

@@ -1,9 +1,15 @@
-// Generate unique IDs for client and session
+// Generate unique ID for client
 export const CLIENT_ID = `client_${Math.random().toString(36).substring(2)}`;
-export const SESSION_ID = `session_${Math.random().toString(36).substring(2)}`;
 
 // Create default headers for API requests
-export const getDefaultHeaders = () => ({
-  "x-client-id": CLIENT_ID,
-  "x-session-id": SESSION_ID,
-});
+export const getDefaultHeaders = (sessionId = null) => {
+  const headers = {
+    "x-client-id": CLIENT_ID,
+  };
+
+  if (sessionId) {
+    headers["x-session-id"] = sessionId;
+  }
+
+  return headers;
+};

server/.session_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17c52bb5d3dbe4af41c98c7992c63979361073b8aae65d10a9feb74728329c7c
+size 3071

server/api/models.py

@@ -85,4 +85,12 @@ class ImageGenerationRequest(BaseModel):
 
 class TextToSpeechRequest(BaseModel):
     text: str
-    voice_id: str = "nPczCjzI2devNBz1zQrb"  # Default voice ID (Rachel) 
+    voice_id: str = "nPczCjzI2devNBz1zQrb"  # Default voice ID (Rachel)
+
+class UniverseResponse(BaseModel):
+    status: str
+    session_id: str
+    style: str
+    genre: str
+    epoch: str
+    base_story: str = Field(description="The generated story for this universe")

server/api/routes/chat.py

@@ -20,19 +20,48 @@ def get_chat_router(session_manager: SessionManager, story_generator):
 
             print(f"Processing chat message for session {x_session_id}:", chat_message)
             
-            # Get or create game state for this session
-            game_state = session_manager.get_or_create_session(x_session_id)
+            # Get game state for this session
+            game_state = session_manager.get_session(x_session_id)
+            print(f"Retrieved game state for session {x_session_id}: {'found' if game_state else 'not found'}")
+            
+            if game_state is None:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Invalid session ID. Generate a universe first to start a new game session."
+                )
+                
+            # Vérifier que l'univers est configuré
+            has_universe = game_state.has_universe()
+            print(f"Universe configured for session {x_session_id}: {has_universe}")
+            print(f"Universe details: style={game_state.universe_style}, genre={game_state.universe_genre}, epoch={game_state.universe_epoch}")
+            
+            if not has_universe:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Universe not configured for this session. Generate a universe first."
+                )
             
             # Handle restart
             if chat_message.message.lower() == "restart":
                 print(f"Handling restart for session {x_session_id}")
+                # On garde le même univers mais on réinitialise l'histoire
                 game_state.reset()
+                game_state.set_universe(
+                    style=game_state.universe_style,
+                    genre=game_state.universe_genre,
+                    epoch=game_state.universe_epoch,
+                    base_story=game_state.universe_story
+                )
                 previous_choice = "none"
             else:
                 previous_choice = f"Choice {chat_message.choice_id}" if chat_message.choice_id else "none"
 
             # Generate story segment
-            llm_response = await story_generator.generate_story_segment(game_state, previous_choice)
+            llm_response = await story_generator.generate_story_segment(
+                session_id=x_session_id,
+                game_state=game_state,
+                previous_choice=previous_choice
+            )
             
             # Update radiation level
             game_state.radiation_level += llm_response.radiation_increase

server/api/routes/universe.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, HTTPException
+import uuid
+
+from core.generators.universe_generator import UniverseGenerator
+from core.game_logic import StoryGenerator
+from core.session_manager import SessionManager
+from api.models import UniverseResponse
+
+def get_universe_router(session_manager: SessionManager, story_generator: StoryGenerator) -> APIRouter:
+    router = APIRouter()
+    universe_generator = UniverseGenerator(story_generator.mistral_client)
+    
+    @router.post("/universe/generate", response_model=UniverseResponse)
+    async def generate_universe() -> UniverseResponse:
+        try:
+            print("Starting universe generation...")
+            
+            # Get random elements before generation
+            style, genre, epoch = universe_generator._get_random_elements()
+            print(f"Generated random elements: style={style['name']}, genre={genre}, epoch={epoch}")
+            
+            universe = await universe_generator.generate()
+            print("Generated universe story")
+            
+            # Générer un ID de session unique
+            session_id = str(uuid.uuid4())
+            print(f"Generated session ID: {session_id}")
+            
+            # Créer une nouvelle session et configurer l'univers
+            game_state = session_manager.create_session(session_id)
+            print("Created new game state")
+            
+            game_state.set_universe(
+                style=style["name"],
+                genre=genre,
+                epoch=epoch,
+                base_story=universe
+            )
+            print("Configured universe in game state")
+            
+            # Créer le TextGenerator pour cette session
+            story_generator.create_text_generator(
+                session_id=session_id,
+                style=style["name"],
+                genre=genre,
+                epoch=epoch,
+                base_story=universe
+            )
+            print("Created text generator for session")
+            
+            # Vérifier que tout est bien configuré
+            if not game_state.has_universe():
+                raise ValueError("Universe was not properly configured in game state")
+                
+            if session_id not in story_generator.text_generators:
+                raise ValueError("TextGenerator was not properly created")
+            
+            print("All components configured successfully")
+            
+            return UniverseResponse(
+                status="ok",
+                session_id=session_id,
+                style=style["name"],
+                genre=genre,
+                epoch=epoch,
+                base_story=universe
+            )
+            
+        except Exception as e:
+            print(f"Error in generate_universe: {str(e)}")  # Add debug logging
+            raise HTTPException(
+                status_code=500,
+                detail=str(e)
+            )
+    
+    return router 

server/core/__init__.py

@@ -1,11 +0,0 @@
-from core.story_orchestrator import StoryOrchestrator
-from core.state import GameState
-from core.generators import TextGenerator, ImageGenerator, MetadataGenerator
-
-__all__ = [
-    'StoryOrchestrator',
-    'GameState',
-    'TextGenerator',
-    'ImageGenerator',
-    'MetadataGenerator'
-] 

server/core/constants.py

@@ -2,7 +2,7 @@ class GameConfig:
     # Game state constants
     MAX_RADIATION = 12
     STARTING_TIME = "18:00"
-    STARTING_LOCATION = "Outskirts of New Haven"
+    STARTING_LOCATION = "Home"
     
     # Story constraints
     MIN_PANELS = 1

server/core/game_logic.py

@@ -4,18 +4,34 @@ from langchain.output_parsers import PydanticOutputParser, OutputFixingParser
 from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
 import os
 import asyncio
+from uuid import uuid4
 
 from core.constants import GameConfig
 from core.prompts.system import SARAH_DESCRIPTION
 from core.prompts.cinematic import CINEMATIC_SYSTEM_PROMPT
 from core.prompts.image_style import IMAGE_STYLE_PREFIX
 from services.mistral_client import MistralClient
-from api.models import StoryTextResponse, StoryPromptsResponse, StoryMetadataResponse, StoryResponse, Choice
-from core.story_generators import TextGenerator, ImagePromptsGenerator, MetadataGenerator
+from api.models import StoryResponse, Choice
+from core.generators.text_generator import TextGenerator
+from core.generators.image_generator import ImageGenerator
+from core.generators.metadata_generator import MetadataGenerator
+from core.generators.universe_generator import UniverseGenerator
 
-# Game constants
-STARTING_TIME = "18:00"  # Game starts at sunset
-STARTING_LOCATION = "Outskirts of New Haven"
+from core.constants import GameConfig
+
+# Initialize generators with None - they will be set up when needed
+universe_generator = None
+image_generator = None
+metadata_generator = None
+
+def setup_generators(api_key: str, model_name: str = "mistral-small"):
+    """Setup all generators with the provided API key."""
+    global universe_generator, image_generator, metadata_generator
+    
+    mistral_client = MistralClient(api_key=api_key, model_name=model_name)
+    universe_generator = UniverseGenerator(mistral_client)
+    image_generator = ImageGenerator(mistral_client)
+    metadata_generator = MetadataGenerator(mistral_client)
 
 def enrich_prompt_with_sarah_description(prompt: str) -> str:
     """Add Sarah's visual description to prompts that mention her."""
@@ -35,14 +51,49 @@ class GameState:
         self.story_history = []
         self.current_time = GameConfig.STARTING_TIME
         self.current_location = GameConfig.STARTING_LOCATION
+        # Ajout des informations d'univers
+        self.universe_style = None
+        self.universe_genre = None
+        self.universe_epoch = None
+        self.universe_story = None
         
     def reset(self):
+        """Réinitialise l'état du jeu en gardant les informations de l'univers."""
+        # Sauvegarder les informations de l'univers
+        universe_style = self.universe_style
+        universe_genre = self.universe_genre
+        universe_epoch = self.universe_epoch
+        universe_story = self.universe_story
+        
+        # Réinitialiser l'état du jeu
         self.story_beat = GameConfig.STORY_BEAT_INTRO
         self.radiation_level = 0
         self.story_history = []
         self.current_time = GameConfig.STARTING_TIME
         self.current_location = GameConfig.STARTING_LOCATION
         
+        # Restaurer les informations de l'univers
+        self.universe_style = universe_style
+        self.universe_genre = universe_genre
+        self.universe_epoch = universe_epoch
+        self.universe_story = universe_story
+        
+    def set_universe(self, style: str, genre: str, epoch: str, base_story: str):
+        """Configure l'univers du jeu."""
+        self.universe_style = style
+        self.universe_genre = genre
+        self.universe_epoch = epoch
+        self.universe_story = base_story
+        
+    def has_universe(self) -> bool:
+        """Vérifie si l'univers est configuré."""
+        return all([
+            self.universe_style is not None,
+            self.universe_genre is not None,
+            self.universe_epoch is not None,
+            self.universe_story is not None
+        ])
+
     def add_to_history(self, segment_text: str, choice_made: str, image_prompts: List[str], time: str, location: str):
         self.story_history.append({
             "segment": segment_text,
@@ -56,22 +107,56 @@ class GameState:
 
 # Story output structure
 class StoryLLMResponse(BaseModel):
-    story_text: str = Field(description="The next segment of the story. No more than 15 words THIS IS MANDATORY. Never mention story beat or radiation level directly. ")
+    story_text: str = Field(description="The next segment of the story. No more than 15 words THIS IS MANDATORY. Never mention story beat directly. ")
     choices: List[str] = Field(description="Between one and four possible choices for the player. Each choice should be a clear path to follow in the story", min_items=1, max_items=4)
     is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
     is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
     radiation_increase: int = Field(description="How much radiation this segment adds (0-3)", ge=0, le=3, default=1)
     image_prompts: List[str] = Field(description="List of 1 to 4 comic panel descriptions that illustrate the key moments of the scene", min_items=1, max_items=4)
-    time: str = Field(description="Current in-game time in 24h format (HH:MM). Time passes realistically based on actions.", default=STARTING_TIME)
-    location: str = Field(description="Current location, using bold for proper nouns (e.g., 'Inside Vault 15', 'Streets of New Haven').", default=STARTING_LOCATION)
+    time: str = Field(description="Current in-game time in 24h format (HH:MM). Time passes realistically based on actions.", default=GameConfig.STARTING_TIME)
+    location: str = Field(description="Current location.", default=GameConfig.STARTING_LOCATION)
 
 # Story generator
 class StoryGenerator:
+    _instance = None
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            print("Creating new StoryGenerator instance")
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
     def __init__(self, api_key: str, model_name: str = "mistral-small"):
-        self.mistral_client = MistralClient(api_key=api_key, model_name=model_name)
-        self.text_generator = TextGenerator(self.mistral_client)
-        self.prompts_generator = ImagePromptsGenerator(self.mistral_client)
-        self.metadata_generator = MetadataGenerator(self.mistral_client)
+        if not self._initialized:
+            print("Initializing StoryGenerator singleton")
+            self.api_key = api_key
+            self.model_name = model_name
+            self.mistral_client = MistralClient(api_key=api_key, model_name=model_name)
+            self.image_generator = ImageGenerator(self.mistral_client)
+            self.metadata_generator = MetadataGenerator(self.mistral_client)
+            self.text_generators = {}  # Un TextGenerator par session
+            self._initialized = True
+
+    def create_text_generator(self, session_id: str, style: str, genre: str, epoch: str, base_story: str):
+        """Crée un nouveau TextGenerator adapté à l'univers spécifié pour une session donnée."""
+        print(f"Creating TextGenerator for session {session_id} in StoryGenerator singleton")
+        self.text_generators[session_id] = TextGenerator(
+            self.mistral_client,
+            universe_style=style,
+            universe_genre=genre,
+            universe_epoch=epoch,
+            universe_story=base_story
+        )
+        print(f"Current TextGenerators in StoryGenerator: {list(self.text_generators.keys())}")
+
+    def get_text_generator(self, session_id: str) -> TextGenerator:
+        """Récupère le TextGenerator associé à une session."""
+        print(f"Getting TextGenerator for session {session_id} from StoryGenerator singleton")
+        print(f"Current TextGenerators in StoryGenerator: {list(self.text_generators.keys())}")
+        if session_id not in self.text_generators:
+            raise RuntimeError(f"No text generator found for session {session_id}. Generate a universe first.")
+        return self.text_generators[session_id]
 
     def _format_story_history(self, game_state: GameState) -> str:
         """Formate l'historique de l'histoire pour le prompt."""
@@ -85,11 +170,13 @@ class StoryGenerator:
         story_history = "\n\n---\n\n".join(segments)
         return story_history
 
-    async def generate_story_segment(self, game_state: GameState, previous_choice: str) -> StoryResponse:
+    async def generate_story_segment(self, session_id: str, game_state: GameState, previous_choice: str) -> StoryResponse:
         """Génère un segment d'histoire complet en plusieurs étapes."""
+        text_generator = self.get_text_generator(session_id)
+
         # 1. Générer le texte de l'histoire initial
         story_history = self._format_story_history(game_state)
-        text_response = await self.text_generator.generate(
+        text_response = await text_generator.generate(
             story_beat=game_state.story_beat,
             radiation_level=game_state.radiation_level,
             current_time=game_state.current_time,
@@ -113,7 +200,7 @@ class StoryGenerator:
         if is_ending:
             # Regénérer le texte avec le contexte de fin
             ending_type = "victory" if metadata_response.is_victory else "death"
-            text_response = await self.text_generator.generate_ending(
+            text_response = await text_generator.generate_ending(
                 story_beat=game_state.story_beat,
                 ending_type=ending_type,
                 current_scene=text_response.story_text,
@@ -123,12 +210,12 @@ class StoryGenerator:
                 metadata_response.is_death = True
             
             # Ne générer qu'une seule image pour la fin
-            prompts_response = await self.prompts_generator.generate(text_response.story_text)
+            prompts_response = await self.image_generator.generate(text_response.story_text)
             if len(prompts_response.image_prompts) > 1:
                 prompts_response.image_prompts = [prompts_response.image_prompts[0]]
         else:
             # Si ce n'est pas une fin, générer les prompts normalement
-            prompts_response = await self.prompts_generator.generate(text_response.story_text)
+            prompts_response = await self.image_generator.generate(text_response.story_text)
         
         # 4. Créer la réponse finale
         choices = [] if is_ending else [

server/core/generators/__init__.py

@@ -1,11 +0,0 @@
-from core.generators.base_generator import BaseGenerator
-from core.generators.text_generator import TextGenerator
-from core.generators.image_generator import ImageGenerator
-from core.generators.metadata_generator import MetadataGenerator
-
-__all__ = [
-    'BaseGenerator',
-    'TextGenerator',
-    'ImageGenerator',
-    'MetadataGenerator'
-] 

server/core/generators/metadata_generator.py

@@ -46,7 +46,7 @@ Generate the metadata following the format specified."""
             raise ValueError(str(e))
 
     async def generate(self, story_text: str, current_time: str, current_location: str, story_beat: int, error_feedback: str = "") -> StoryMetadataResponse:
-        """Génère les métadonnées basées sur le texte de l'histoire."""
+        """Surcharge de generate pour inclure le error_feedback par défaut."""
         return await super().generate(
             story_text=story_text,
             current_time=current_time,

server/core/generators/text_generator.py

@@ -4,25 +4,50 @@ from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, H
 from core.generators.base_generator import BaseGenerator
 from core.prompts.text_prompts import TEXT_GENERATOR_PROMPT
 from api.models import StoryTextResponse
+from services.mistral_client import MistralClient
 
 class TextGenerator(BaseGenerator):
-    """Générateur pour le texte principal de l'histoire."""
+    """Générateur pour le texte de l'histoire."""
+
+    def __init__(self, mistral_client: MistralClient, universe_style: str = None, universe_genre: str = None, universe_epoch: str = None, universe_story: str = None):
+        super().__init__(mistral_client)
+        self.universe_style = universe_style
+        self.universe_genre = universe_genre
+        self.universe_epoch = universe_epoch
+        self.universe_story = universe_story
 
     def _create_prompt(self) -> ChatPromptTemplate:
-        human_template = """Story beat: {story_beat}
-Radiation level: {radiation_level}
-Current time: {current_time}
-Current location: {current_location}
-Previous choice: {previous_choice}
+        system_template = """You are a story generator for a comic book adventure game.
+You are generating a story in the following universe:
+- Style: {universe_style}
+- Genre: {universe_genre}
+- Historical epoch: {universe_epoch}
+
+Base universe story:
+{universe_story}
+
+Your task is to generate the next segment of the story, following these rules:
+1. Keep the story consistent with the universe parameters
+2. Each segment must advance the plot
+3. Never repeat previous descriptions or situations
+4. Keep segments concise and impactful (max 15 words)
+5. The MacGuffin should remain mysterious but central to the plot"""
+
+        human_template = """Current game state:
+- Story beat: {story_beat}
+- Radiation level: {radiation_level}
+- Current time: {current_time}
+- Current location: {current_location}
+- Previous choice: {previous_choice}
 
 Story history:
 {story_history}
 
-Generate the next story segment following the format specified."""
+Generate the next story segment."""
 
         return ChatPromptTemplate(
             messages=[
-                SystemMessagePromptTemplate.from_template(TEXT_GENERATOR_PROMPT),
+                SystemMessagePromptTemplate.from_template(system_template),
                 HumanMessagePromptTemplate.from_template(human_template)
             ]
         )
@@ -65,16 +90,64 @@ The ending should feel like a natural continuation of the current scene."""
             cleaned_text = self._clean_story_text(response_content.strip())
             return StoryTextResponse(story_text=cleaned_text)
 
-    async def generate_ending(self, ending_type: str, current_scene: str, story_history: str) -> StoryTextResponse:
+    async def generate(self, story_beat: int, radiation_level: int, current_time: str, current_location: str, previous_choice: str, story_history: str = "") -> StoryTextResponse:
+        """Génère le prochain segment de l'histoire."""
+        return await super().generate(
+            story_beat=story_beat,
+            radiation_level=radiation_level,
+            current_time=current_time,
+            current_location=current_location,
+            previous_choice=previous_choice,
+            story_history=story_history,
+            universe_style=self.universe_style,
+            universe_genre=self.universe_genre,
+            universe_epoch=self.universe_epoch,
+            universe_story=self.universe_story
+        )
+
+    async def generate_ending(self, story_beat: int, ending_type: str, current_scene: str, story_history: str) -> StoryTextResponse:
         """Génère un texte de fin approprié."""
-        prompt = self._create_ending_prompt()
-        messages = prompt.format_messages(
+        system_template = """You are a story generator for a comic book adventure game.
+You are generating a story in the following universe:
+- Style: {universe_style}
+- Genre: {universe_genre}
+- Historical epoch: {universe_epoch}
+
+Base universe story:
+{universe_story}
+
+Your task is to generate an epic {ending_type} ending for the story that:
+1. Matches the universe's style and atmosphere
+2. Provides a satisfying conclusion
+3. Keeps the ending concise but impactful (max 15 words)
+4. For victory: reveals the MacGuffin's power in a spectacular way
+5. For death: creates a dramatic and fitting end for Sarah"""
+
+        human_template = """Current scene:
+{current_scene}
+
+Story history:
+{story_history}
+
+Generate the {ending_type} ending."""
+
+        ending_prompt = ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(system_template),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+        response = await self.mistral_client.generate(
+            ending_prompt,
             ending_type=ending_type,
             current_scene=current_scene,
-            story_history=story_history
+            story_history=story_history,
+            universe_style=self.universe_style,
+            universe_genre=self.universe_genre,
+            universe_epoch=self.universe_epoch,
+            universe_story=self.universe_story
         )
-        
-        return await self.mistral_client.generate(
-            messages=messages,
-            custom_parser=self._custom_parser
-        ) 
+
+        cleaned_text = self._custom_parser(response)
+        return StoryTextResponse(story_text=cleaned_text) 

server/core/generators/universe_generator.py

@@ -0,0 +1,88 @@
+import json
+import random
+from pathlib import Path
+from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+
+from core.generators.base_generator import BaseGenerator
+from core.prompts.system import STORY_RULES
+
+class UniverseGenerator(BaseGenerator):
+    """Générateur pour les univers alternatifs."""
+
+    def _create_prompt(self) -> ChatPromptTemplate:
+        system_template = """You are a creative writing assistant specialized in comic book universes.
+Your task is to rewrite a story while keeping its exact structure and beats, but transposing it into a different universe."""
+
+        human_template = """Transform the following story into a new universe with these parameters:
+- Visual style: {style_name} (inspired by artists like {artists} with works such as {works})
+Style description: {style_description}
+
+- Genre: {genre}
+- Historical epoch: {epoch}
+
+IMPORTANT INSTRUCTIONS:
+1. Keep the exact same story structure
+2. Keep the same dramatic tension and progression
+3. Only change the setting, atmosphere, and universe-specific elements to match the new parameters
+4. Keep Sarah as the main character, but adapt her role to fit the new universe
+5. The MacGuffin should still be central to the plot, but its nature can change to fit the new universe
+
+Base story to transform:
+{base_story}"""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(system_template),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+    def _load_universe_styles(self):
+        """Charge les styles, genres et époques depuis le fichier JSON."""
+        try:
+            current_dir = Path(__file__).parent.parent
+            styles_path = current_dir / "styles" / "universe_styles.json"
+            
+            if not styles_path.exists():
+                raise FileNotFoundError(f"Universe styles file not found at {styles_path}")
+                
+            with open(styles_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            raise ValueError(f"Failed to load universe styles: {str(e)}")
+
+    def _get_random_elements(self):
+        """Récupère un style, un genre et une époque aléatoires."""
+        data = self._load_universe_styles()
+        
+        if not all(key in data for key in ["styles", "genres", "epochs"]):
+            raise ValueError("Missing required sections in universe_styles.json")
+            
+        style = random.choice(data["styles"])
+        genre = random.choice(data["genres"])
+        epoch = random.choice(data["epochs"])
+        
+        return style, genre, epoch
+
+    def _custom_parser(self, response_content: str) -> str:
+        """Parse la réponse. Dans ce cas, on retourne simplement le texte."""
+        return response_content.strip()
+
+    async def generate(self) -> str:
+        """Génère un nouvel univers basé sur des éléments aléatoires."""
+        style, genre, epoch = self._get_random_elements()
+        base_story = STORY_RULES
+
+        # Préparer les listes d'artistes et d'œuvres
+        artists = ", ".join([ref["artist"] for ref in style["references"]])
+        works = ", ".join([work for ref in style["references"] for work in ref["works"]])
+
+        return await super().generate(
+            style_name=style["name"],
+            artists=artists,
+            works=works,
+            style_description=style["description"],
+            genre=genre,
+            epoch=epoch,
+            base_story=base_story
+        ) 

server/core/prompts/system.py

@@ -1,59 +1,59 @@
-SARAH_VISUAL_DESCRIPTION = "(Sarah est une jeune femme dans la fin de la vingtaine avec des cheveux courts et sombres, portant un mystérieux amulette autour de son cou. Ses yeux bleus cachent des secrets inavoués.)"
+SARAH_VISUAL_DESCRIPTION = "(Sarah is a young woman in her late twenties with short dark hair, wearing a mysterious amulet around her neck. Her blue eyes hide untold secrets.)"
 
 SARAH_DESCRIPTION = """
-Sarah est une jeune femme dans la fin de la vingtaine avec des cheveux courts et sombres, portant un mystérieux amulette autour de son cou. Ses yeux bleus cachent des secrets inavoués.
-- Sarah est en quête de découvrir la vérité derrière le pouvoir de l'amulette et sa connexion à son passé.
-
+Sarah is a young woman in her late twenties with short dark hair, wearing a mysterious amulet around her neck. Her blue eyes hide untold secrets.
 """
 
 FORMATTING_RULES = """
-FORMATTING_RULES (OBLIGATOIRE)
-- L'histoire doit être composée UNIQUEMENT de phrases
-- NE JAMAIS UTILISER LE GRAS POUR QUOI QUE CE SOIT
+FORMATTING_RULES (MANDATORY)
+- The story must consist ONLY of sentences
+- NEVER USE BOLD FOR ANYTHING
 """
 
-STORY_RULES = """
-
-Vous êtes un générateur d'histoires d'aventure steampunk. Vous créez une narration à embranchements sur Sarah, une chercheuse de vérités anciennes.
-Vous narrez une épopée où Sarah doit naviguer à travers des terres industrielles et mystérieuses. C'est une histoire de bande dessinée.
-
-Dans un monde où la vapeur et l'intrigue s'entrelacent, Sarah se lance dans une quête pour découvrir les origines d'un puissant MacGuffin qu'elle a hérité. Les légendes disent qu'il détient la clé d'un royaume oublié.
-Vous devez prendre des décisions pour découvrir ses secrets. Vous vous êtes aventuré dans la ville mécanique pour trouver le premier indice. Si vous échouez, le pouvoir du MacGuffin restera inactif. Le temps presse, et chaque choix façonne votre destin.
-
-Si vous récupérez le MacGuffin, vous révélerez un monde caché. ET VOUS GAGNEZ LE JEU.
-
-L'histoire doit être atmosphérique, magique et se concentrer sur l'aventure et la découverte. Chaque segment doit faire avancer l'intrigue et ne jamais répéter les descriptions ou situations précédentes.
+NARRATIVE_STRUCTURE = """
+Key elements of the story:
+- The MacGuffin is a mysterious and constant presence
+- The environment is full of wonders (creatures, ruins, traps)
+- Focus on adventure and intrigue
+
+Key elements:
+- Keep segments concise and impactful
+- The MacGuffin is a pretext for developing a plot. It is almost always a material object and generally remains mysterious throughout the narrative, its description is vague and unimportant. The principle dates back to the early days of cinema, but the term is associated with Alfred Hitchcock, who redefined, popularized, and implemented it in several of his films. The object itself is rarely used, only its retrieval matters.
+- The MacGuffin is a constant presence in the story
+- Build intrigue through environmental storytelling
+
+IMPORTANT:
+Each story segment MUST be unique and advance the plot.
+Never repeat the same descriptions or situations. No more than 15 words.
+
+STORY PROGRESSION:
+- story_beat 0: Introduction setting the steampunk atmosphere
+- story_beat 1-2: Early exploration and discovery of mechanical elements
+- story_beat 3-5: Complications and deeper mysteries
+- story_beat 6+: Revelations leading to potential triumph or failure
+
+IMPORTANT RULES FOR THE MACGUFFIN (MANDATORY):
+- Most segments must hint at the power of the MacGuffin
+- Use strong clues ONLY at key moments
+- NEVER reveal the full power of the MacGuffin before the climax, this is a STRICT limit
+- Use subtle clues in safe havens
+- NEVER mention the power of the MacGuffin explicitly in choices or the story
+- NEVER mention time or place in the story in this manner: [18:00 - a road]
+"""
 
-Éléments clés de l'histoire :
-- Le MacGuffin est une présence mystérieuse et constante
-- L'environnement est plein de merveilles (créatures mécaniques, ruines industrielles, pièges à vapeur)
-- Se concentrer sur l'aventure et l'intrigue
+STORY_RULES = """
 
-Éléments clés :
-- Garder les segments concis et percutants
-- Suivre l'influence du MacGuffin comme une présence constante
-- Construire l'intrigue à travers la narration environnementale
+You are a steampunk adventure story generator. You create a branching narrative about Sarah, a seeker of ancient truths.
+You narrate an epic where Sarah must navigate through industrial and mysterious lands. It's a comic book story.
 
-IMPORTANT :
-Chaque segment de l'histoire DOIT être unique et faire avancer l'intrigue.
-Ne jamais répéter les mêmes descriptions ou situations. Pas plus de 15 mots.
+In a world where steam and intrigue intertwine, Sarah embarks on a quest to discover the origins of a powerful MacGuffin she inherited. Legends say it holds the key to a forgotten realm.
+You must make decisions to uncover its secrets. You have ventured into the mechanical city to find the first clue. If you fail, the power of the MacGuffin will remain dormant. Time is of the essence, and every choice shapes your destiny.
 
-PROGRESSION DE L'HISTOIRE :
-- story_beat 0 : Introduction mettant en place l'atmosphère steampunk
-- story_beat 1-2 : Exploration précoce et découverte d'éléments mécaniques
-- story_beat 3-5 : Complications et mystères plus profonds
-- story_beat 6+ : Révélations menant à un triomphe potentiel ou à un échec
+If you retrieve the MacGuffin, you will reveal a hidden world. AND YOU WIN THE GAME.
 
-RÈGLES IMPORTANTES POUR LE MACGUFFIN (OBLIGATOIRE) :
-- La plupart des segments doivent faire allusion au pouvoir du MacGuffin
-- Utiliser des indices forts UNIQUEMENT dans des moments clés (comme des temples anciens, des tempêtes mécaniques)
-- NE JAMAIS révéler le plein pouvoir du MacGuffin avant le climax, c'est une limite STRICTE
-- Utiliser des indices subtils dans les havres de paix
-- NE JAMAIS mentionner le pouvoir du MacGuffin explicitement dans les choix ou l'histoire
-- NE JAMAIS mentionner l'heure ou le lieu dans l'histoire de cette manière : [18:00 - Clairière enchantée au cœur d'Eldoria]
+The story must be atmospheric, magical, and focus on adventure and discovery. Each segment must advance the plot and never repeat previous descriptions or situations.
 """
 
 
-# Le MacGuffin est un prétexte au développement d'un scénario1. C'est presque toujours un objet matériel et il demeure généralement mystérieux au cours de la diégèse, sa description est vague et sans importance. Le principe date des débuts du cinéma mais l'expression est associée à Alfred Hitchcock, qui l'a redéfinie, popularisée et mise en pratique dans plusieurs de ses films. L'objet lui-même n'est que rarement utilisé, seule sa récupération compte.
-
+# The MacGuffin is a pretext for developing a plot. It is almost always a material object and generally remains mysterious throughout the narrative, its description is vague and unimportant. The principle dates back to the early days of cinema, but the term is associated with Alfred Hitchcock, who redefined, popularized, and implemented it in several of his films. The object itself is rarely used, only its retrieval matters.
 

server/core/prompts/text_prompts.py

@@ -25,7 +25,7 @@ IMPORTANT RULES FOR STORY TEXT:
 - Never tell that you are using 15 words or any reference to it 
 
 IMPORTANT RULES FOR STORY ENDINGS:
-- If Sarah dies, describe her final moments in a way that fits the current situation (combat, radiation, etc.)
+- If Sarah dies, describe her final moments in a way that fits the current situation (combat, etc.)
 - If Sarah achieves victory, describe her triumph in a way that fits how she won (finding her sister, defeating AI, etc.)
 - Keep the ending text dramatic and impactful
 - The ending should feel like a natural conclusion to the current scene

server/core/session_manager.py

@@ -3,28 +3,39 @@ import time
 from .game_logic import GameState
 
 class SessionManager:
+    _instance = None
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            print("Creating new SessionManager instance")
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
     def __init__(self, session_timeout: int = 3600):
-        """Initialize the session manager.
-        
-        Args:
-            session_timeout (int): Session timeout in seconds (default: 1 hour)
-        """
-        self.sessions: Dict[str, GameState] = {}
-        self.last_activity: Dict[str, float] = {}
-        self.session_timeout = session_timeout
+        if not self._initialized:
+            print("Initializing SessionManager singleton")
+            self.sessions: Dict[str, GameState] = {}
+            self.last_activity: Dict[str, float] = {}
+            self.session_timeout = session_timeout
+            self._initialized = True
     
-    def create_session(self, session_id: str) -> GameState:
+    def create_session(self, session_id: str, game_state: GameState = None):
         """Create a new game session.
         
         Args:
             session_id (str): Unique identifier for the session
+            game_state (GameState): Optional initial game state
             
         Returns:
             GameState: The newly created game state
         """
-        game_state = GameState()
+        print(f"Creating session {session_id} in SessionManager singleton")
+        if game_state is None:
+            game_state = GameState()
         self.sessions[session_id] = game_state
         self.last_activity[session_id] = time.time()
+        print(f"Current sessions in SessionManager: {list(self.sessions.keys())}")
         return game_state
     
     def get_session(self, session_id: str) -> GameState | None:
@@ -36,15 +47,22 @@ class SessionManager:
         Returns:
             GameState | None: The game state if found and not expired, None otherwise
         """
+        print(f"Getting session {session_id} from SessionManager singleton")
+        print(f"Current sessions in SessionManager: {list(self.sessions.keys())}")
+        
         if session_id in self.sessions:
             # Check if session has expired
             if time.time() - self.last_activity[session_id] > self.session_timeout:
+                print(f"Session {session_id} has expired")
                 self.cleanup_session(session_id)
                 return None
             
             # Update last activity time
             self.last_activity[session_id] = time.time()
+            print(f"Session {session_id} found and active")
             return self.sessions[session_id]
+            
+        print(f"Session {session_id} not found")
         return None
     
     def cleanup_session(self, session_id: str):
@@ -79,4 +97,10 @@ class SessionManager:
         session = self.get_session(session_id)
         if session is None:
             session = self.create_session(session_id)
-        return session 
+        return session 
+
+    def delete_session(self, session_id: str):
+        """Supprime une session."""
+        if session_id in self.sessions:
+            del self.sessions[session_id]
+            del self.last_activity[session_id] 

server/core/state/__init__.py

@@ -1,3 +0,0 @@
-from core.state.game_state import GameState
-
-__all__ = ['GameState'] 

server/core/story_generators.py

@@ -1,223 +0,0 @@
-from pydantic import BaseModel
-from typing import List
-import json
-from langchain.output_parsers import PydanticOutputParser
-from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
-import asyncio
-
-from core.prompts.system import SARAH_VISUAL_DESCRIPTION
-from core.prompts.text_prompts import TEXT_GENERATOR_PROMPT, METADATA_GENERATOR_PROMPT, IMAGE_PROMPTS_GENERATOR_PROMPT
-from services.mistral_client import MistralClient
-from api.models import StoryTextResponse, StoryPromptsResponse, StoryMetadataResponse
-
-class TextGenerator:
-    def __init__(self, mistral_client: MistralClient):
-        self.mistral_client = mistral_client
-        self.prompt = self._create_prompt()
-        
-    def _create_prompt(self) -> ChatPromptTemplate:
-        human_template = """Story beat: {story_beat}
-Radiation level: {radiation_level}
-Current time: {current_time}
-Current location: {current_location}
-Previous choice: {previous_choice}
-
-Story history:
-{story_history}
-
-Generate the next story segment following the format specified."""
-
-        return ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(TEXT_GENERATOR_PROMPT),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
-        
-    def _create_ending_prompt(self) -> ChatPromptTemplate:
-        human_template = """Current scene: {current_scene}
-
-Story history:
-{story_history}
-
-This is a {ending_type} ending. Generate a dramatic conclusion that fits the current situation.
-The ending should feel like a natural continuation of the current scene."""
-
-        return ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(TEXT_GENERATOR_PROMPT),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
-
-    def _clean_story_text(self, text: str) -> str:
-        """Nettoie le texte des métadonnées et autres suffixes."""
-        text = text.replace("\n", " ").strip()
-        text = text.split("Radiation level:")[0].strip()
-        text = text.split("RADIATION:")[0].strip()
-        text = text.split("[")[0].strip()  # Supprimer les métadonnées entre crochets
-        return text
-
-    def _custom_parser(self, response_content: str) -> StoryTextResponse:
-        """Parse la réponse et gère les erreurs."""
-        try:
-            # Essayer de parser directement le JSON
-            data = json.loads(response_content)
-            # Nettoyer le texte avant de créer la réponse
-            if 'story_text' in data:
-                data['story_text'] = self._clean_story_text(data['story_text'])
-            return StoryTextResponse(**data)
-        except (json.JSONDecodeError, ValueError):
-            # Si le parsing échoue, extraire le texte directement
-            cleaned_text = self._clean_story_text(response_content.strip())
-            return StoryTextResponse(story_text=cleaned_text)
-
-    async def generate(self, story_beat: int, radiation_level: int, current_time: str, current_location: str, previous_choice: str, story_history: str) -> StoryTextResponse:
-        """Génère le texte de l'histoire."""
-        messages = self.prompt.format_messages(
-            story_beat=story_beat,
-            radiation_level=radiation_level,
-            current_time=current_time,
-            current_location=current_location,
-            previous_choice=previous_choice,
-            story_history=story_history
-        )
-        
-        return await self.mistral_client.generate(
-            messages=messages,
-            custom_parser=self._custom_parser
-        )
-
-    async def generate_ending(self, story_beat: int, ending_type: str, current_scene: str, story_history: str) -> StoryTextResponse:
-        """Génère un texte de fin approprié basé sur la situation actuelle."""
-        prompt = self._create_ending_prompt()
-        messages = prompt.format_messages(
-            ending_type=ending_type,
-            current_scene=current_scene,
-            story_history=story_history
-        )
-        
-        return await self.mistral_client.generate(
-            messages=messages,
-            custom_parser=self._custom_parser
-        )
-
-class ImagePromptsGenerator:
-    def __init__(self, mistral_client: MistralClient):
-        self.mistral_client = mistral_client
-        self.prompt = self._create_prompt()
-        
-    def _create_prompt(self) -> ChatPromptTemplate:
-        human_template = """Story text: {story_text}
-
-Generate panel descriptions following the format specified."""
-
-        return ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(IMAGE_PROMPTS_GENERATOR_PROMPT),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
-
-    def enrich_prompt(self, prompt: str) -> str:
-        """Add Sarah's visual description to prompts that mention her."""
-        if "sarah" in prompt.lower() and SARAH_VISUAL_DESCRIPTION not in prompt:
-            return f"{prompt} {SARAH_VISUAL_DESCRIPTION}"
-        return prompt
-
-    def _custom_parser(self, response_content: str) -> StoryPromptsResponse:
-        """Parse la réponse et gère les erreurs."""
-        try:
-            # Essayer de parser directement le JSON
-            data = json.loads(response_content)
-            return StoryPromptsResponse(**data)
-        except (json.JSONDecodeError, ValueError):
-            # Si le parsing échoue, extraire les prompts en ignorant les lignes de syntaxe JSON
-            prompts = []
-            for line in response_content.split("\n"):
-                line = line.strip()
-                # Ignorer les lignes vides, la syntaxe JSON et les lignes contenant image_prompts
-                if (not line or 
-                    line in ["{", "}", "[", "]"] or 
-                    "image_prompts" in line.lower() or
-                    "image\\_prompts" in line or
-                    line.startswith('"') and line.endswith('",') and len(line) < 5):
-                    continue
-                # Nettoyer la ligne des caractères JSON et d'échappement
-                line = line.strip('",')
-                line = line.replace('\\"', '"').replace("\\'", "'").replace("\\_", "_")
-                if line:
-                    prompts.append(line)
-            # Limiter à 4 prompts maximum
-            prompts = prompts[:4]
-            return StoryPromptsResponse(image_prompts=prompts)
-
-    async def generate(self, story_text: str) -> StoryPromptsResponse:
-        """Génère les prompts d'images basés sur le texte de l'histoire."""
-        messages = self.prompt.format_messages(story_text=story_text)
-        
-        response = await self.mistral_client.generate(
-            messages=messages,
-            custom_parser=self._custom_parser
-        )
-        
-        # Enrichir les prompts avec la description de Sarah
-        response.image_prompts = [self.enrich_prompt(prompt) for prompt in response.image_prompts]
-        return response
-
-class MetadataGenerator:
-    def __init__(self, mistral_client: MistralClient):
-        self.mistral_client = mistral_client
-        self.prompt = self._create_prompt()
-        
-    def _create_prompt(self, error_feedback: str = None) -> ChatPromptTemplate:
-        human_template = """Story text: {story_text}
-Current time: {current_time}
-Current location: {current_location}
-Story beat: {story_beat}
-{error_feedback}
-
-Generate the metadata following the format specified."""
-
-        return ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(METADATA_GENERATOR_PROMPT),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
-
-    def _custom_parser(self, response_content: str) -> StoryMetadataResponse:
-        """Parse la réponse et gère les erreurs."""
-        try:
-            # Essayer de parser directement le JSON
-            data = json.loads(response_content)
-            
-            # Vérifier que les choix sont valides selon les règles
-            is_ending = data.get('is_victory', False) or data.get('is_death', False)
-            choices = data.get('choices', [])
-            
-            if is_ending and len(choices) != 0:
-                raise ValueError('For victory/death, choices must be empty')
-            if not is_ending and len(choices) != 2:
-                raise ValueError('For normal progression, must have exactly 2 choices')
-            
-            return StoryMetadataResponse(**data)
-        except json.JSONDecodeError:
-            raise ValueError('Invalid JSON format. Please provide a valid JSON object.')
-        except ValueError as e:
-            raise ValueError(str(e))
-
-    async def generate(self, story_text: str, current_time: str, current_location: str, story_beat: int) -> StoryMetadataResponse:
-        """Génère les métadonnées basées sur le texte de l'histoire."""
-        messages = self.prompt.format_messages(
-            story_text=story_text,
-            current_time=current_time,
-            current_location=current_location,
-            story_beat=story_beat,
-            error_feedback=""
-        )
-        
-        return await self.mistral_client.generate(
-            messages=messages,
-            custom_parser=self._custom_parser
-        ) 

server/core/styles/comic_styles.json

@@ -1,259 +0,0 @@
-{
-  "styles": [
-    {
-      "name": "Franco-Belge Ligne Claire",
-      "description": "Style épuré avec des lignes nettes et des couleurs plates",
-      "references": [
-        {
-          "artist": "Hergé",
-          "works": ["Tintin", "Les Aventures de Jo, Zette et Jocko"]
-        },
-        {
-          "artist": "Edgar P. Jacobs",
-          "works": ["Blake et Mortimer"]
-        },
-        {
-          "artist": "Yves Chaland",
-          "works": ["Freddy Lombard", "Bob Fish"]
-        },
-        {
-          "artist": "Joost Swarte",
-          "works": ["Modern Art", "L'Art Moderne"]
-        }
-      ]
-    },
-    {
-      "name": "Science-Fiction Européenne",
-      "description": "Style visionnaire mêlant précision technique et onirisme",
-      "references": [
-        {
-          "artist": "Moebius (Jean Giraud)",
-          "works": ["L'Incal", "Arzak", "Le Garage Hermétique", "Aedena"]
-        },
-        {
-          "artist": "Philippe Druillet",
-          "works": ["Lone Sloane", "Salammbô", "Delirius"]
-        },
-        {
-          "artist": "François Schuiten",
-          "works": ["Les Cités Obscures", "La Fièvre d'Urbicande"]
-        }
-      ]
-    },
-    {
-      "name": "Comics Américain Classique",
-      "description": "Style dynamique avec des couleurs vives et des ombrages marqués",
-      "references": [
-        {
-          "artist": "Jack Kirby",
-          "works": ["Fantastic Four", "New Gods", "Captain America"]
-        },
-        {
-          "artist": "Steve Ditko",
-          "works": ["Spider-Man", "Doctor Strange", "Mr. A"]
-        },
-        {
-          "artist": "Neal Adams",
-          "works": ["Batman", "Green Lantern/Green Arrow", "X-Men"]
-        },
-        {
-          "artist": "John Buscema",
-          "works": ["Conan the Barbarian", "Silver Surfer", "The Avengers"]
-        }
-      ]
-    },
-    {
-      "name": "Comics Moderne",
-      "description": "Style contemporain avec techniques mixtes et mise en page innovante",
-      "references": [
-        {
-          "artist": "Alex Ross",
-          "works": ["Kingdom Come", "Marvels", "Justice"]
-        },
-        {
-          "artist": "J.H. Williams III",
-          "works": ["Promethea", "Batwoman", "The Sandman: Overture"]
-        },
-        {
-          "artist": "Sean Murphy",
-          "works": ["Batman: White Knight", "Tokyo Ghost", "Punk Rock Jesus"]
-        }
-      ]
-    },
-    {
-      "name": "Manga Seinen",
-      "description": "Style mature avec des détails complexes et des contrastes forts",
-      "references": [
-        {
-          "artist": "Katsuhiro Otomo",
-          "works": ["Akira", "Domu", "Memories"]
-        },
-        {
-          "artist": "Tsutomu Nihei",
-          "works": ["Blame!", "Knights of Sidonia", "Biomega"]
-        },
-        {
-          "artist": "Takehiko Inoue",
-          "works": ["Vagabond", "Real", "Slam Dunk"]
-        },
-        {
-          "artist": "Naoki Urasawa",
-          "works": ["Monster", "20th Century Boys", "Pluto"]
-        }
-      ]
-    },
-    {
-      "name": "Manga Horror",
-      "description": "Style détaillé avec emphase sur l'horreur psychologique et corporelle",
-      "references": [
-        {
-          "artist": "Junji Ito",
-          "works": ["Uzumaki", "Tomie", "Gyo"]
-        },
-        {
-          "artist": "Suehiro Maruo",
-          "works": [
-            "Mr. Arashi's Amazing Freak Show",
-            "The Strange Tale of Panorama Island"
-          ]
-        },
-        {
-          "artist": "Hideshi Hino",
-          "works": ["Hell Baby", "Panorama of Hell"]
-        }
-      ]
-    },
-    {
-      "name": "BD Alternative",
-      "description": "Style expressif avec des techniques mixtes et une approche artistique unique",
-      "references": [
-        {
-          "artist": "Dave McKean",
-          "works": ["Arkham Asylum", "Signal to Noise", "Cages"]
-        },
-        {
-          "artist": "Bill Sienkiewicz",
-          "works": ["Elektra: Assassin", "Stray Toasters", "New Mutants"]
-        },
-        {
-          "artist": "Lorenzo Mattotti",
-          "works": ["Feux", "Le Bruit du givre", "Stigmates"]
-        },
-        {
-          "artist": "Kent Williams",
-          "works": ["Tell Me, Dark", "The Fountain", "Blood: A Tale"]
-        }
-      ]
-    },
-    {
-      "name": "Noir et Blanc Expressionniste",
-      "description": "Style contrasté avec des noirs profonds et des blancs éclatants",
-      "references": [
-        {
-          "artist": "Frank Miller",
-          "works": ["Sin City", "300", "Ronin"]
-        },
-        {
-          "artist": "Alberto Breccia",
-          "works": ["Mort Cinder", "Perramus", "Los Mitos de Cthulhu"]
-        },
-        {
-          "artist": "Jacques Tardi",
-          "works": [
-            "C'était la guerre des tranchées",
-            "Le Cri du peuple",
-            "Adèle Blanc-Sec"
-          ]
-        },
-        {
-          "artist": "José Muñoz",
-          "works": ["Alack Sinner", "Le Bar à Joe"]
-        }
-      ]
-    },
-    {
-      "name": "Style Numérique Moderne",
-      "description": "Style contemporain utilisant les techniques digitales",
-      "references": [
-        {
-          "artist": "Bastien Vivès",
-          "works": ["Polina", "Le Goût du chlore", "Une sœur"]
-        },
-        {
-          "artist": "Bengal",
-          "works": ["Naja", "Luminae", "Death or Glory"]
-        },
-        {
-          "artist": "Claire Wendling",
-          "works": ["Les Lumières de l'Amalou", "Desk", "Iguana Bay"]
-        },
-        {
-          "artist": "Boulet",
-          "works": ["Notes", "La Page Blanche"]
-        }
-      ]
-    },
-    {
-      "name": "Post-Apocalyptique",
-      "description": "Style rugueux avec des atmosphères sombres et des environnements dévastés",
-      "references": [
-        {
-          "artist": "Enki Bilal",
-          "works": ["La Trilogie Nikopol", "Animal'z", "Bug"]
-        },
-        {
-          "artist": "Juan Giménez",
-          "works": [
-            "La Caste des Méta-Barons",
-            "Le Quatrième Pouvoir",
-            "Leo Roa"
-          ]
-        },
-        {
-          "artist": "Geof Darrow",
-          "works": ["Hard Boiled", "Shaolin Cowboy", "Big Guy and Rusty"]
-        },
-        {
-          "artist": "Simon Bisley",
-          "works": ["Slaine", "Lobo", "Heavy Metal"]
-        }
-      ]
-    },
-    {
-      "name": "Underground Américain",
-      "description": "Style brut et provocateur avec une approche contre-culturelle",
-      "references": [
-        {
-          "artist": "Robert Crumb",
-          "works": ["Zap Comix", "Fritz the Cat", "Mr. Natural"]
-        },
-        {
-          "artist": "Spain Rodriguez",
-          "works": ["Trashman", "Mean Bitch Thrills"]
-        },
-        {
-          "artist": "Gilbert Shelton",
-          "works": ["The Fabulous Furry Freak Brothers", "Wonder Wart-Hog"]
-        }
-      ]
-    },
-    {
-      "name": "Nouveau Roman Graphique",
-      "description": "Style intimiste avec une approche narrative personnelle",
-      "references": [
-        {
-          "artist": "Chris Ware",
-          "works": ["Jimmy Corrigan", "Building Stories", "Rusty Brown"]
-        },
-        {
-          "artist": "Daniel Clowes",
-          "works": ["Ghost World", "David Boring", "Patience"]
-        },
-        {
-          "artist": "Adrian Tomine",
-          "works": ["Killing and Dying", "Shortcomings", "Optic Nerve"]
-        }
-      ]
-    }
-  ]
-}

server/core/styles/universe_styles.json

@@ -0,0 +1,92 @@
+{
+  "styles": [
+    {
+      "name": "Franco-Belge Ligne Claire",
+      "description": "Style épuré avec des lignes nettes et des couleurs plates",
+      "references": [
+        {
+          "artist": "Hergé",
+          "works": ["Tintin", "Les Aventures de Jo, Zette et Jocko"]
+        },
+        {
+          "artist": "Edgar P. Jacobs",
+          "works": ["Blake et Mortimer"]
+        },
+        {
+          "artist": "Yves Chaland",
+          "works": ["Freddy Lombard", "Bob Fish"]
+        },
+        {
+          "artist": "Joost Swarte",
+          "works": ["Modern Art", "L'Art Moderne"]
+        }
+      ]
+    },
+    {
+      "name": "Science-Fiction Européenne",
+      "description": "Style visionnaire mêlant précision technique et onirisme",
+      "references": [
+        {
+          "artist": "Moebius (Jean Giraud)",
+          "works": ["L'Incal", "Arzak", "Le Garage Hermétique", "Aedena"]
+        },
+        {
+          "artist": "Philippe Druillet",
+          "works": ["Lone Sloane", "Salammbô", "Delirius"]
+        },
+        {
+          "artist": "François Schuiten",
+          "works": ["Les Cités Obscures", "La Fièvre d'Urbicande"]
+        }
+      ]
+    },
+    {
+      "name": "Comics Américain Classique",
+      "description": "Style dynamique avec des couleurs vives et des ombrages marqués",
+      "references": [
+        {
+          "artist": "Jack Kirby",
+          "works": ["Fantastic Four", "New Gods", "Captain America"]
+        },
+        {
+          "artist": "Steve Ditko",
+          "works": ["Spider-Man", "Doctor Strange", "Mr. A"]
+        },
+        {
+          "artist": "Neal Adams",
+          "works": ["Batman", "Green Lantern/Green Arrow", "X-Men"]
+        }
+      ]
+    }
+  ],
+  "genres": [
+    "Steampunk",
+    "Cyberpunk",
+    "Post-apocalyptique",
+    "Fantasy",
+    "Space Opera",
+    "Western",
+    "Film Noir",
+    "Horror",
+    "Mythologie",
+    "Dystopie",
+    "Uchronie",
+    "Heroic Fantasy",
+    "Urban Fantasy"
+  ],
+  "epochs": [
+    "Préhistoire",
+    "Antiquité",
+    "Moyen Âge",
+    "Renaissance",
+    "Révolution Industrielle",
+    "Années 1920",
+    "Années 1950",
+    "Époque Contemporaine",
+    "Futur Proche",
+    "Futur Lointain",
+    "Post-Apocalyptique",
+    "Âge d'Or",
+    "Ère Spatiale"
+  ]
+}

server/scripts/test_game.py

@@ -5,6 +5,7 @@ import time
 import argparse
 from pathlib import Path
 from dotenv import load_dotenv
+import uuid
 
 # Add server directory to PYTHONPATH
 server_dir = Path(__file__).parent.parent
@@ -12,6 +13,7 @@ sys.path.append(str(server_dir))
 
 from core.game_logic import GameState, StoryGenerator
 from core.constants import GameConfig
+from core.generators.universe_generator import UniverseGenerator
 
 # Load environment variables
 load_dotenv()
@@ -24,6 +26,16 @@ def parse_args():
 def print_separator(char="=", length=50):
     print(f"\n{char * length}\n")
 
+def print_universe_info(style: str, genre: str, epoch: str, base_story: str):
+    print_separator("*")
+    print("🌍 UNIVERSE GENERATED")
+    print(f"🎨 Style: {style}")
+    print(f"📚 Genre: {genre}")
+    print(f"⏳ Époque: {epoch}")
+    print("\n📖 Base Story:")
+    print(base_story)
+    print_separator("*")
+
 def print_story_step(step_number, radiation_level, story_text, image_prompts, generation_time: float, story_history: str = None, show_context: bool = False, model_name: str = None, is_death: bool = False, is_victory: bool = False):
     print_separator("=")
     print(f"📖 STEP {step_number}")
@@ -48,21 +60,49 @@ def print_story_step(step_number, radiation_level, story_text, image_prompts, ge
     print_separator("=")
 
 async def play_game(show_context: bool = False):
-    # Initialize game
-    game_state = GameState()
+    # Initialize components
     model_name = "mistral-small"
     story_generator = StoryGenerator(
         api_key=os.getenv("MISTRAL_API_KEY"),
         model_name=model_name
     )
     
+    # Create universe generator
+    universe_generator = UniverseGenerator(story_generator.mistral_client)
+    
     print("\n=== Don't Look Up - Test Mode ===\n")
     print("🎮 Starting adventure...")
-    print("You are Sarah, a survivor in a post-apocalyptic world.")
     if show_context:
         print("📚 Context display is enabled")
     print_separator()
     
+    # Generate universe
+    print("🌍 Generating universe...")
+    style, genre, epoch = universe_generator._get_random_elements()
+    universe = await universe_generator.generate()
+    
+    # Create session and game state
+    session_id = str(uuid.uuid4())
+    game_state = GameState()
+    game_state.set_universe(
+        style=style["name"],
+        genre=genre,
+        epoch=epoch,
+        base_story=universe
+    )
+    
+    # Create text generator for this session
+    story_generator.create_text_generator(
+        session_id=session_id,
+        style=style["name"],
+        genre=genre,
+        epoch=epoch,
+        base_story=universe
+    )
+    
+    # Display universe information
+    print_universe_info(style["name"], genre, epoch, universe)
+    
     last_choice = None
     
     while True:
@@ -84,7 +124,11 @@ async def play_game(show_context: bool = False):
         
         # Mesurer le temps de génération
         start_time = time.time()
-        response = await story_generator.generate_story_segment(game_state, previous_choice)
+        response = await story_generator.generate_story_segment(
+            session_id=session_id,
+            game_state=game_state,
+            previous_choice=previous_choice
+        )
         generation_time = time.time() - start_time
         
         # Display current step
@@ -117,7 +161,7 @@ async def play_game(show_context: bool = False):
         if response.choices:
             print("\n🤔 AVAILABLE CHOICES:")
             for i, choice in enumerate(response.choices, 1):
-                print(f"{i}. {choice}")
+                print(f"{i}. {choice.text}")
                 
             # Get player choice
             while True:

server/server.py

@@ -12,6 +12,7 @@ from services.flux_client import FluxClient
 from api.routes.chat import get_chat_router
 from api.routes.image import get_image_router
 from api.routes.speech import get_speech_router
+from api.routes.universe import get_universe_router
 
 # Load environment variables
 load_dotenv()
@@ -46,6 +47,7 @@ mistral_api_key = os.getenv("MISTRAL_API_KEY")
 if not mistral_api_key:
     raise ValueError("MISTRAL_API_KEY environment variable is not set")
 
+print("Creating global SessionManager")
 session_manager = SessionManager()
 story_generator = StoryGenerator(api_key=mistral_api_key)
 flux_client = FluxClient(api_key=HF_API_KEY)
@@ -57,9 +59,11 @@ async def health_check():
     return {"status": "healthy"}
 
 # Register route handlers
+print("Registering route handlers with SessionManager", id(session_manager))
 app.include_router(get_chat_router(session_manager, story_generator), prefix="/api")
 app.include_router(get_image_router(flux_client), prefix="/api")
 app.include_router(get_speech_router(), prefix="/api")
+app.include_router(get_universe_router(session_manager, story_generator), prefix="/api")
 
 @app.on_event("startup")
 async def startup_event():