update story

client/src/components/GameNavigation.jsx

@@ -2,8 +2,11 @@ import { IconButton, Tooltip } from "@mui/material";
 import ArrowBackIcon from "@mui/icons-material/ArrowBack";
 import VolumeOffIcon from "@mui/icons-material/VolumeOff";
 import VolumeUpIcon from "@mui/icons-material/VolumeUp";
+import PhotoCameraOutlinedIcon from "@mui/icons-material/PhotoCameraOutlined";
 import { useNavigate } from "react-router-dom";
 import { useSoundSystem } from "../contexts/SoundContext";
+import { useStoryCapture } from "../hooks/useStoryCapture";
+import { useRef } from "react";
 import { storyApi } from "../utils/api";
 
 const SOUND_ENABLED_KEY = "sound_enabled";
@@ -11,6 +14,8 @@ const SOUND_ENABLED_KEY = "sound_enabled";
 export function GameNavigation() {
   const navigate = useNavigate();
   const { isSoundEnabled, setIsSoundEnabled, playSound } = useSoundSystem();
+  const { downloadStoryImage } = useStoryCapture();
+  const containerRef = useRef(null);
 
   const handleBack = () => {
     playSound("page");
@@ -24,8 +29,21 @@ export function GameNavigation() {
     storyApi.setSoundEnabled(newSoundState);
   };
 
+  const handleCapture = async () => {
+    playSound("page");
+    const container = document.querySelector(
+      "[data-comic-layout]"
+    )?.parentElement;
+    if (container) {
+      await downloadStoryImage(
+        { current: container },
+        `your-story-${Date.now()}.png`
+      );
+    }
+  };
+
   return (
-    <div style={{ position: "relative", zIndex: 1000 }}>
+    <div style={{ position: "relative", zIndex: 1000 }} ref={containerRef}>
       {window.location.pathname !== "/" && (
         <Tooltip title="Back to home">
           <IconButton
@@ -48,6 +66,25 @@ export function GameNavigation() {
         </Tooltip>
       )}
 
+      <Tooltip title="Capture story">
+        <IconButton
+          onClick={handleCapture}
+          sx={{
+            position: "fixed",
+            top: 24,
+            right: 88,
+            color: "white",
+            backgroundColor: "rgba(0, 0, 0, 0.5)",
+            "&:hover": {
+              backgroundColor: "rgba(0, 0, 0, 0.7)",
+            },
+            pointerEvents: "auto",
+          }}
+        >
+          <PhotoCameraOutlinedIcon />
+        </IconButton>
+      </Tooltip>
+
       <Tooltip title={isSoundEnabled ? "Mute sound" : "Unmute sound"}>
         <IconButton
           onClick={handleToggleSound}

client/src/components/StoryChoices.jsx

@@ -112,6 +112,7 @@ export function StoryChoices() {
 
   return (
     <Box
+      data-story-choices
       sx={{
         display: "flex",
         flexDirection: isMobile ? "column" : "row",

client/src/components/UniverseSlotMachine.jsx

@@ -209,7 +209,7 @@ export const UniverseSlotMachine = ({
         }}
       >
         <SlotSection
-          label="Told in"
+          label=""
           value={style}
           words={RANDOM_STYLES}
           delay={0}

client/src/hooks/useStoryCapture.js

@@ -7,6 +7,38 @@ export function useStoryCapture() {
     quality: 1.0,
   });
 
+  const calculateOptimalWidth = (element) => {
+    // Get all comic pages
+    const comicPages = element.querySelectorAll("[data-comic-page]");
+    if (!comicPages.length) return element.scrollWidth;
+
+    // Get width of a single page (they all have the same width)
+    const firstPage = comicPages[0];
+    const pageWidth = firstPage.offsetWidth;
+    const gap = 32; // Fixed gap between pages
+    const padding = 32; // Fixed padding on both sides
+
+    // Calculate total width:
+    // - All pages width (pageWidth * nbPages)
+    // - Gaps only between pages, so (nbPages - 1) gaps
+    // - Padding on both sides
+    const totalWidth =
+      pageWidth * comicPages.length +
+      (comicPages.length > 1 ? gap * (comicPages.length - 1) : 0) +
+      padding * 2;
+
+    console.log("Width calculation:", {
+      numberOfPages: comicPages.length,
+      pageWidth,
+      gapBetweenPages: gap,
+      totalGaps: comicPages.length > 1 ? gap * (comicPages.length - 1) : 0,
+      padding,
+      totalWidth,
+    });
+
+    return totalWidth;
+  };
+
   const captureStory = useCallback(
     async (containerRef) => {
       if (!containerRef.current) return null;
@@ -21,17 +53,24 @@ export function useStoryCapture() {
         // Save original styles
         const originalStyle = element.style.cssText;
         const originalScroll = element.scrollLeft;
+        const originalWidth = element.style.width;
+        const originalPadding = element.style.padding;
+        const originalGap = element.style.gap;
+
+        // Calculate optimal width
+        const optimalWidth = calculateOptimalWidth(element);
 
-        // Reset scroll and padding temporarily for the screenshot
+        // Reset scroll and styles temporarily for the screenshot
         Object.assign(element.style, {
-          paddingLeft: "0",
-          paddingRight: "0",
-          width: `${element.scrollWidth - 975}px`, // Reduce width by choices panel
+          width: `${optimalWidth}px`,
           display: "flex",
           flexDirection: "row",
           gap: "32px",
           padding: "32px",
+          paddingLeft: "32px !important", // Force override the dynamic padding
+          paddingRight: "32px !important", // Force override the dynamic padding
           overflow: "hidden",
+          transition: "none", // Disable transitions during capture
         });
         element.scrollLeft = 0;
 
@@ -41,7 +80,7 @@ export function useStoryCapture() {
         // Take screenshot
         const result = await takeScreenshot(element, {
           backgroundColor: "#242424",
-          width: element.offsetWidth,
+          width: optimalWidth,
           height: element.scrollHeight,
           style: {
             transform: "none",
@@ -51,6 +90,9 @@ export function useStoryCapture() {
 
         // Restore original styles
         element.style.cssText = originalStyle;
+        element.style.width = originalWidth;
+        element.style.padding = originalPadding;
+        element.style.gap = originalGap;
         element.scrollLeft = originalScroll;
 
         return result;

client/src/layouts/ComicLayout.jsx

@@ -50,6 +50,22 @@ function ComicPage({ layout, layoutIndex, isLastPage, preloadedImages }) {
     return total + (segment.images?.length || 0);
   }, 0);
 
+  // Sélectionner aléatoirement un panneau qui accepte le texte
+  const [selectedTextPanelIndex] = useState(() => {
+    const acceptingPanels = LAYOUTS[layout.type].panels
+      .slice(0, totalImages)
+      .map((panel, index) => ({ panel, index }))
+      .filter(({ panel }) => panel.acceptText);
+
+    if (acceptingPanels.length === 0) {
+      // Si aucun panneau n'accepte le texte, utiliser le premier panneau par défaut
+      return 0;
+    }
+    // Sélectionner un panneau aléatoire parmi ceux qui acceptent le texte
+    const randomIndex = Math.floor(Math.random() * acceptingPanels.length);
+    return acceptingPanels[randomIndex].index;
+  });
+
   // Son d'écriture
   const playWritingSound = useSoundEffect({
     basePath: "/sounds/drawing-",
@@ -136,6 +152,7 @@ function ComicPage({ layout, layoutIndex, isLastPage, preloadedImages }) {
       }}
     >
       <Box
+        data-comic-page
         sx={{
           display: "grid",
           gridTemplateColumns: `repeat(${LAYOUTS[layout.type].gridCols}, 1fr)`,
@@ -189,6 +206,7 @@ function ComicPage({ layout, layoutIndex, isLastPage, preloadedImages }) {
                   handleImageLoad(`page-${layoutIndex}-image-${panelIndex}`)
                 }
                 imageId={`page-${layoutIndex}-image-${panelIndex}`}
+                showText={panelIndex === selectedTextPanelIndex}
               />
             );
           })}

client/src/layouts/Panel.jsx

@@ -43,6 +43,7 @@ export function Panel({
   totalImagesInPage,
   onImageLoad,
   imageId,
+  showText,
 }) {
   const { regenerateImage } = useGame();
   const [imageLoaded, setImageLoaded] = useState(
@@ -54,7 +55,6 @@ export function Panel({
   const [isRegenerating, setIsRegenerating] = useState(false);
   const [isSpinning, setIsSpinning] = useState(false);
   const hasImage = segment?.images?.[panelIndex];
-  const isFirstPanel = panelIndex === 0;
   const imgRef = useRef(null);
   const imageDataRef = useRef(null);
   const mountedRef = useRef(true);
@@ -234,7 +234,7 @@ export function Panel({
           <RefreshIcon />
         </IconButton>
       </Tooltip>
-      {isFirstPanel && segment?.text && (
+      {showText && segment?.text && (
         <Box
           sx={{
             position: "absolute",
@@ -248,7 +248,10 @@ export function Panel({
             fontWeight: 500,
             borderRadius: "8px",
             display: "flex",
+            flexDirection: "column",
             alignItems: "center",
+            gap: 1,
+            boxShadow: "0 2px 8px rgba(0,0,0,0.1)",
             fontSize: { xs: "0.775rem", sm: "1rem" }, // Responsive font size
             color: "black",
             lineHeight: 1.1,

client/src/layouts/config.js

@@ -21,17 +21,42 @@ export const LAYOUTS = {
     gridCols: 1,
     gridRows: 1,
     panels: [
-      { ...PANEL_SIZES.COVER_SIZE, gridColumn: "1", gridRow: "1" }, // Format portrait
+      {
+        ...PANEL_SIZES.COVER_SIZE,
+        gridColumn: "1",
+        gridRow: "1",
+        acceptText: true,
+      }, // Format portrait
     ],
   },
   LAYOUT_1: {
     gridCols: 2,
     gridRows: 2,
     panels: [
-      { ...PANEL_SIZES.LANDSCAPE, gridColumn: "1", gridRow: "1" }, // Landscape top left
-      { ...PANEL_SIZES.PORTRAIT, gridColumn: "2", gridRow: "1" }, // Portrait top right
-      { ...PANEL_SIZES.LANDSCAPE, gridColumn: "1", gridRow: "2" }, // Landscape middle left
-      { ...PANEL_SIZES.PORTRAIT, gridColumn: "2", gridRow: "2" }, // Portrait right
+      {
+        ...PANEL_SIZES.LANDSCAPE,
+        gridColumn: "1",
+        gridRow: "1",
+        acceptText: true,
+      }, // Landscape top left
+      {
+        ...PANEL_SIZES.PORTRAIT,
+        gridColumn: "2",
+        gridRow: "1",
+        acceptText: false,
+      }, // Portrait top right
+      {
+        ...PANEL_SIZES.LANDSCAPE,
+        gridColumn: "1",
+        gridRow: "2",
+        acceptText: true,
+      }, // Landscape middle left
+      {
+        ...PANEL_SIZES.PORTRAIT,
+        gridColumn: "2",
+        gridRow: "2",
+        acceptText: false,
+      }, // Portrait right
     ],
   },
   LAYOUT_2: {
@@ -42,45 +67,103 @@ export const LAYOUTS = {
         ...PANEL_SIZES.LANDSCAPE,
         gridColumn: GRID.TWO_THIRDS,
         gridRow: "1",
+        acceptText: true,
       }, // Large square top left
-      { ...PANEL_SIZES.PORTRAIT, gridColumn: "3", gridRow: "1" }, // Portrait top right
-      { ...PANEL_SIZES.LANDSCAPE, gridColumn: GRID.FULL_WIDTH, gridRow: "2" }, // Full width landscape bottom
+      {
+        ...PANEL_SIZES.PORTRAIT,
+        gridColumn: "3",
+        gridRow: "1",
+        acceptText: false,
+      }, // Portrait top right
+      {
+        ...PANEL_SIZES.LANDSCAPE,
+        gridColumn: GRID.FULL_WIDTH,
+        gridRow: "2",
+        acceptText: false,
+      }, // Full width landscape bottom
     ],
   },
   LAYOUT_3: {
     gridCols: 3,
     gridRows: 2,
     panels: [
-      { ...PANEL_SIZES.SQUARE, gridColumn: GRID.TWO_THIRDS, gridRow: "1" }, // Wide landscape top left
-      { ...PANEL_SIZES.COLUMN, gridColumn: "3", gridRow: "1" }, // COLUMN top right
-      { ...PANEL_SIZES.COLUMN, gridColumn: "1", gridRow: "2" }, // COLUMN bottom left
-      { ...PANEL_SIZES.SQUARE, gridColumn: "2 / span 2", gridRow: "2" }, // Wide landscape bottom right
+      {
+        ...PANEL_SIZES.SQUARE,
+        gridColumn: GRID.TWO_THIRDS,
+        gridRow: "1",
+        acceptText: true,
+      }, // Wide landscape top left
+      {
+        ...PANEL_SIZES.COLUMN,
+        gridColumn: "3",
+        gridRow: "1",
+        acceptText: false,
+      }, // COLUMN top right
+      {
+        ...PANEL_SIZES.COLUMN,
+        gridColumn: "1",
+        gridRow: "2",
+        acceptText: false,
+      }, // COLUMN bottom left
+      {
+        ...PANEL_SIZES.SQUARE,
+        gridColumn: "2 / span 2",
+        gridRow: "2",
+        acceptText: true,
+      }, // Wide landscape bottom right
     ],
   },
   LAYOUT_4: {
     gridCols: 2,
     gridRows: 3,
     panels: [
-      { ...PANEL_SIZES.PANORAMIC, gridColumn: "1 / span 2", gridRow: "1" }, // Wide panoramic top
+      {
+        ...PANEL_SIZES.PANORAMIC,
+        gridColumn: "1 / span 2",
+        gridRow: "1",
+        acceptText: true,
+      }, // Wide panoramic top
       {
         ...PANEL_SIZES.COLUMN,
         gridColumn: "1",
         gridRow: GRID.FULL_HEIGHT_FROM_2,
+        acceptText: false,
       }, // Tall portrait left
-      { ...PANEL_SIZES.SQUARE, gridColumn: "2", gridRow: "2" }, // Square middle right
-      { ...PANEL_SIZES.SQUARE, gridColumn: "2", gridRow: "3" }, // Square bottom right
+      {
+        ...PANEL_SIZES.SQUARE,
+        gridColumn: "2",
+        gridRow: "2",
+        acceptText: false,
+      }, // Square middle right
+      {
+        ...PANEL_SIZES.SQUARE,
+        gridColumn: "2",
+        gridRow: "3",
+        acceptText: false,
+      }, // Square bottom right
     ],
   },
   LAYOUT_5: {
     gridCols: 3,
     gridRows: 3,
     panels: [
-      { ...PANEL_SIZES.PANORAMIC, gridColumn: GRID.FULL_WIDTH, gridRow: "1" }, // Wide panoramic top
-      { ...PANEL_SIZES.COLUMN, gridColumn: "1", gridRow: "2 / span 2" }, // Tall portrait left
+      {
+        ...PANEL_SIZES.PANORAMIC,
+        gridColumn: GRID.FULL_WIDTH,
+        gridRow: "1",
+        acceptText: false,
+      }, // Wide panoramic top
+      {
+        ...PANEL_SIZES.COLUMN,
+        gridColumn: "1",
+        gridRow: "2 / span 2",
+        acceptText: false,
+      }, // Tall portrait left
       {
         ...PANEL_SIZES.POTRAIT,
         gridColumn: "2 / span 2",
         gridRow: "2 / span 2",
+        acceptText: true,
       }, // Large square right
     ],
   },
@@ -88,8 +171,18 @@ export const LAYOUTS = {
     gridCols: 1,
     gridRows: 2,
     panels: [
-      { ...PANEL_SIZES.LANDSCAPE, gridColumn: GRID.FULL_WIDTH, gridRow: "1" }, // Portrait top right
-      { ...PANEL_SIZES.LANDSCAPE, gridColumn: GRID.FULL_WIDTH, gridRow: "2" }, // Full width landscape bottom
+      {
+        ...PANEL_SIZES.LANDSCAPE,
+        gridColumn: GRID.FULL_WIDTH,
+        gridRow: "1",
+        acceptText: true,
+      }, // Portrait top right
+      {
+        ...PANEL_SIZES.LANDSCAPE,
+        gridColumn: GRID.FULL_WIDTH,
+        gridRow: "2",
+        acceptText: true,
+      }, // Full width landscape bottom
     ],
   },
 };
@@ -103,8 +196,8 @@ export const nonRandomLayouts = Object.keys(LAYOUTS).filter(
 export const LAYOUTS_BY_PANEL_COUNT = {
   1: ["COVER"],
   2: ["LAYOUT_7"],
-  3: ["LAYOUT_2"], //"LAYOUT_5"
-  4: ["LAYOUT_3"], //, "LAYOUT_4"
+  3: ["LAYOUT_2", "LAYOUT_5"], //"LAYOUT_5"
+  4: ["LAYOUT_3", "LAYOUT_4"], //, "LAYOUT_4"
 };
 
 // Helper functions for layout configuration

client/src/pages/Debug.jsx

@@ -77,8 +77,10 @@ const Debug = () => {
       const initialHistoryEntry = {
         segment: response.story_text,
         player_choice: null,
+        available_choices: response.choices.map((choice) => choice.text),
         time: response.time,
         location: response.location,
+        previous_choice: response.previous_choice,
       };
 
       setGameState({
@@ -105,12 +107,14 @@ const Debug = () => {
       const response = await storyApi.makeChoice(choiceIndex + 1, sessionId);
       setCurrentStory(response);
 
-      // Construire l'entrée d'historique dans le même format que le serveur
+      // Construire l'entrée d'historique
       const historyEntry = {
         segment: response.story_text,
         player_choice: currentStory.choices[choiceIndex].text,
+        available_choices: currentStory.choices.map((choice) => choice.text),
         time: response.time,
         location: response.location,
+        previous_choice: response.previous_choice,
       };
 
       setGameState((prev) => ({
@@ -140,6 +144,70 @@ const Debug = () => {
     }
   }, [gameState?.story_history]);
 
+  // Render history entries
+  const renderHistoryEntry = (entry, idx) => (
+    <Box
+      key={idx}
+      sx={{ mb: 2, p: 2, bgcolor: "background.paper", borderRadius: 1 }}
+    >
+      <Stack spacing={1}>
+        {/* Previous Choice (if any) */}
+        {entry.previous_choice && (
+          <Box
+            sx={{
+              display: "flex",
+              alignItems: "center",
+              gap: 1,
+              color: "text.secondary",
+            }}
+          >
+            <ArrowForwardIcon fontSize="small" />
+            <Typography variant="body2" sx={{ fontStyle: "italic" }}>
+              Choix précédent : {entry.previous_choice}
+            </Typography>
+          </Box>
+        )}
+
+        {/* Time and Location */}
+        <Box sx={{ display: "flex", gap: 2, color: "text.secondary" }}>
+          <Box sx={{ display: "flex", alignItems: "center", gap: 0.5 }}>
+            <TimerIcon fontSize="small" />
+            <Typography variant="body2">{entry.time}</Typography>
+          </Box>
+          <Box sx={{ display: "flex", alignItems: "center", gap: 0.5 }}>
+            <LocationIcon fontSize="small" />
+            <Typography variant="body2">{entry.location}</Typography>
+          </Box>
+        </Box>
+
+        {/* Story Text */}
+        <Typography>{entry.segment}</Typography>
+
+        {/* Available Choices */}
+        {entry.available_choices && entry.available_choices.length > 0 && (
+          <Box sx={{ mt: 1 }}>
+            <Typography variant="body2" color="text.secondary">
+              Choix disponibles :
+            </Typography>
+            <Box sx={{ display: "flex", gap: 1, flexWrap: "wrap", mt: 0.5 }}>
+              {entry.available_choices.map((choice, choiceIdx) => (
+                <Chip
+                  key={choiceIdx}
+                  label={choice}
+                  size="small"
+                  color={choice === entry.player_choice ? "primary" : "default"}
+                  variant={
+                    choice === entry.player_choice ? "filled" : "outlined"
+                  }
+                />
+              ))}
+            </Box>
+          </Box>
+        )}
+      </Stack>
+    </Box>
+  );
+
   if (error || sessionError) {
     return (
       <Box p={3}>
@@ -463,94 +531,9 @@ const Debug = () => {
                 }}
               >
                 {gameState.story_history.length > 0 ? (
-                  gameState.story_history.map((entry, idx) => (
-                    <Box
-                      key={idx}
-                      sx={{
-                        p: 1.5,
-                        borderBottom: 1,
-                        borderColor: "divider",
-                        "&:last-child": {
-                          borderBottom: 0,
-                        },
-                        backgroundColor:
-                          idx === gameState.story_history.length - 1
-                            ? "action.hover"
-                            : "inherit",
-                      }}
-                    >
-                      <Stack spacing={1}>
-                        {/* Story Text */}
-                        <Box
-                          sx={{
-                            backgroundColor: "background.paper",
-                            p: 1,
-                            borderRadius: 1,
-                            border: 1,
-                            borderColor: "divider",
-                          }}
-                        >
-                          <Typography variant="body2" color="text.primary">
-                            {entry.segment}
-                          </Typography>
-                        </Box>
-
-                        {/* Player Choice */}
-                        {entry.player_choice && (
-                          <Box
-                            sx={{
-                              display: "flex",
-                              alignItems: "center",
-                              gap: 0.5,
-                              backgroundColor: "action.selected",
-                              p: 1,
-                              borderRadius: 1,
-                              ml: 2,
-                            }}
-                          >
-                            <ArrowForwardIcon
-                              fontSize="small"
-                              sx={{ color: "primary.main" }}
-                            />
-                            <Typography
-                              variant="caption"
-                              sx={{
-                                color: "text.primary",
-                                fontWeight: "medium",
-                              }}
-                            >
-                              {entry.player_choice}
-                            </Typography>
-                          </Box>
-                        )}
-
-                        {/* Metadata */}
-                        <Stack
-                          direction="row"
-                          spacing={2}
-                          sx={{
-                            color: "text.secondary",
-                            mt: 0.5,
-                            "& > span": {
-                              display: "flex",
-                              alignItems: "center",
-                              gap: 0.5,
-                              fontSize: "0.75rem",
-                            },
-                          }}
-                        >
-                          <span>
-                            <TimerIcon fontSize="inherit" />
-                            {entry.time}
-                          </span>
-                          <span>
-                            <LocationIcon fontSize="inherit" />
-                            {entry.location}
-                          </span>
-                        </Stack>
-                      </Stack>
-                    </Box>
-                  ))
+                  gameState.story_history.map((entry, idx) =>
+                    renderHistoryEntry(entry, idx)
+                  )
                 ) : (
                   <Box sx={{ p: 2, textAlign: "center" }}>
                     <Typography variant="body2" color="text.secondary">

client/src/pages/Home.jsx

@@ -43,9 +43,9 @@ export function Home() {
           justifyContent: "center",
           minHeight: "100vh",
           height: "100%",
-          width: "100%",
+          width: isMobile ? "80%" : "40%", // Adjust the width of the containing block
+          margin: "auto",
           position: "relative",
-          overflow: "hidden",
         }}
       >
         <Typography
@@ -82,12 +82,11 @@ export function Home() {
         </Typography>
 
         <Typography
-          variant="body1"
+          variant="caption"
           sx={{
             zIndex: 10,
             textAlign: "center",
             mt: 2,
-            maxWidth: isMobile ? "80%" : "50%",
             opacity: 0.8,
             px: isMobile ? 2 : 0,
             fontSize: "clamp(0.875rem, 2vw, 1.125rem)",

client/src/pages/Tutorial.jsx

@@ -10,6 +10,8 @@ import { useSoundSystem } from "../contexts/SoundContext";
 import { motion } from "framer-motion";
 import { GameNavigation } from "../components/GameNavigation";
 import { StyledText } from "../components/StyledText";
+import MouseOutlinedIcon from "@mui/icons-material/MouseOutlined";
+import CreateOutlinedIcon from "@mui/icons-material/CreateOutlined";
 
 export function Tutorial() {
   const navigate = useNavigate();
@@ -44,7 +46,8 @@ export function Tutorial() {
           justifyContent: "center",
           minHeight: "100vh",
           height: "100%",
-          width: "100%",
+          width: isMobile ? "90%" : "70%",
+          margin: "auto",
           position: "relative",
           overflow: "hidden",
         }}
@@ -84,11 +87,73 @@ export function Tutorial() {
           for each playthrough.
           <br />
           <br />
-          At every stage of the narrative, you will be presented with choices or
-          the opportunity to write the next part of the story yourself.
+          At each step you can decide to
           <br />
           <br />
-          Think of it more as a lucid dream than a traditional game. Enjoy!
+          <Box
+            sx={{
+              display: "flex",
+              gap: 4,
+              justifyContent: "center",
+              mb: 2,
+              alignItems: "center",
+            }}
+          >
+            <Box
+              sx={{
+                border: "1px solid rgba(255,255,255,0.3)",
+                borderRadius: "8px",
+                p: 2,
+                flex: 1,
+                maxWidth: "200px",
+                display: "flex",
+                flexDirection: "column",
+                alignItems: "center",
+                gap: 1,
+                backdropFilter: "blur(20px)",
+                backgroundColor: "rgba(255,255,255,0.05)",
+              }}
+            >
+              <MouseOutlinedIcon
+                sx={{ fontSize: 40, color: "primary.main", mb: 1 }}
+              />
+              <Typography variant="subtitle1" sx={{ color: "primary.main" }}>
+                Make a choice
+              </Typography>
+            </Box>
+            <Typography
+              variant="h6"
+              sx={{
+                color: "rgba(255,255,255,0.5)",
+                fontWeight: "bold",
+              }}
+            >
+              OR
+            </Typography>
+            <Box
+              sx={{
+                border: "1px solid rgba(255,255,255,0.3)",
+                borderRadius: "8px",
+                p: 2,
+                flex: 1,
+                maxWidth: "200px",
+                display: "flex",
+                flexDirection: "column",
+                alignItems: "center",
+                gap: 1,
+                backdropFilter: "blur(20px)",
+                backgroundColor: "rgba(255,255,255,0.05)",
+              }}
+            >
+              <CreateOutlinedIcon
+                sx={{ fontSize: 40, color: "primary.main", mb: 1 }}
+              />
+              <Typography variant="subtitle1" sx={{ color: "primary.main" }}>
+                Write your own
+              </Typography>
+            </Box>
+          </Box>
+          Until the end of the game
         </Typography>
 
         <Button

server/api/models.py

@@ -62,6 +62,7 @@ class UniverseResponse(BaseModel):
 
 # Complete story response combining all parts - preserved for API compatibility
 class StoryResponse(BaseModel):
+    previous_choice: str = Field(description="The previous choice made by the player")
     story_text: str = Field(description="The story text. No more than 15 words THIS IS MANDATORY.  Never mention story beat directly. ")
     choices: List[Choice]
     raw_choices: List[str] = Field(description="Raw choice texts from LLM before conversion to Choice objects")

server/api/routes/chat.py

@@ -57,49 +57,45 @@ def get_chat_router(session_manager: SessionManager, story_generator):
                 # Pour les choix personnalisés, on les traite immédiatement
                 if chat_message.message == "custom_choice" and chat_message.custom_text:
                     previous_choice = chat_message.custom_text
-                    # On ajoute le choix à l'historique avant de générer le segment
-                    game_state.add_to_history(
-                        f"You decide to: {chat_message.custom_text}",
-                        previous_choice,
-                        [],  # pas d'image pour le choix
-                        game_state.current_time,
-                        game_state.current_location
+                    # On crée un StoryResponse pour le choix personnalisé
+                    custom_choice_response = StoryResponse(
+                        story_text=f"You decide to: {chat_message.custom_text}",
+                        choices=[
+                            Choice(id=1, text="Continue..."),  # Choix fictif pour validation
+                            Choice(id=2, text="Continue...")
+                        ],
+                        raw_choices=["Continue...", "Continue..."],
+                        time=game_state.current_time,
+                        location=game_state.current_location,
+                        image_prompts=["Character making a custom choice"],  # Prompt fictif pour validation
+                        is_first_step=False,
+                        is_death=False,
+                        is_victory=False,
+                        previous_choice=previous_choice
                     )
+                    game_state.add_to_history(custom_choice_response)
                 else:
-                    previous_choice = f"Choice {chat_message.choice_id}" if chat_message.choice_id else "none"
+                    # Si un choix a été fait, récupérer le texte du choix à partir de l'historique
+                    if chat_message.choice_id and len(game_state.story_history) > 0:
+                        last_story = game_state.story_history[-1]
+                        choice_index = chat_message.choice_id - 1
+                        if 0 <= choice_index < len(last_story.choices):
+                            previous_choice = last_story.choices[choice_index].text
+                        else:
+                            previous_choice = "none"
+                    else:
+                        previous_choice = "none"
 
             # Generate story segment
-            llm_response = await story_generator.generate_story_segment(
+            response = await story_generator.generate_story_segment(
                 session_id=x_session_id,
                 game_state=game_state,
                 previous_choice=previous_choice
             )
 
-            # Add segment to history
-            game_state.add_to_history(
-                llm_response.story_text,
-                previous_choice,
-                llm_response.image_prompts,
-                llm_response.time,
-                llm_response.location
-            )
-
             # Pour la première étape, on ne garde qu'un seul prompt d'image
-            if game_state.story_beat == 0 and len(llm_response.image_prompts) > 1:
-                llm_response.image_prompts = [llm_response.image_prompts[0]]
-            
-            # Prepare response
-            response = StoryResponse(
-                story_text=llm_response.story_text,
-                choices=llm_response.choices,
-                raw_choices=llm_response.raw_choices,
-                time=llm_response.time,
-                location=llm_response.location,
-                is_first_step=game_state.story_beat == 0,
-                image_prompts=llm_response.image_prompts,
-                is_death=llm_response.is_death,
-                is_victory=llm_response.is_victory
-            )
+            if game_state.story_beat == 0 and len(response.image_prompts) > 1:
+                response.image_prompts = [response.image_prompts[0]]
             
             # Increment story beat
             game_state.story_beat += 1

server/core/game_state.py

@@ -1,10 +1,11 @@
 from core.constants import GameConfig
 from typing import List
+from api.models import StoryResponse
 
 class GameState:
     def __init__(self):
         self.story_beat = GameConfig.STORY_BEAT_INTRO
-        self.story_history = []
+        self.story_history: List[StoryResponse] = []
         self.current_time = GameConfig.STARTING_TIME
         self.current_location = GameConfig.STARTING_LOCATION
         # Universe information
@@ -50,27 +51,42 @@ class GameState:
         ])
 
     def format_history(self) -> str:
-        """Format story history for the prompt."""
+        """Format story history for the prompt.
+        Returns only the last 4 segments of the story (or less if not available)."""
         if not self.story_history:
             return ""
             
+        # Ne prendre que les 3 derniers segments
+        last_segments = self.story_history[-4:] if len(self.story_history) > 4 else self.story_history
+            
         segments = []
-        for entry in self.story_history:
-            segment = entry['segment']
-            if entry['player_choice']:
-                segment += f"\n[Choix du joueur: {entry['player_choice']}]"
-            segments.append(segment)
+        for story_response in last_segments:
+            # Commencer par le choix précédent s'il existe
+            segment_parts = []
+            if story_response.previous_choice and story_response.previous_choice != "none":
+                segment_parts.append(f"[Previous choice: {story_response.previous_choice}]")
+            
+            # Ajouter le texte de l'histoire
+            segment_parts.append(story_response.story_text)
+            
+            # Ajouter les choix disponibles s'ils existent
+            if story_response.choices:
+                choices_text = "\nAvailable choices were:"
+                for choice in story_response.choices:
+                    choices_text += f"\n- {choice.text}"
+                segment_parts.append(choices_text)
+            
+            # Joindre toutes les parties avec des sauts de ligne
+            segments.append("\n".join(segment_parts))
+        
+        # Ajouter une indication si on a tronqué l'historique
+        if len(self.story_history) > 4:
+            segments.insert(0, f"[...{len(self.story_history) - 4} earlier segments omitted...]")
         
         return "\n\n---\n\n".join(segments)
 
-    def add_to_history(self, segment_text: str, choice_made: str, image_prompts: List[str], time: str, location: str):
-        """Add a segment to history with essential information."""
-        self.story_history.append({
-            "segment": segment_text,
-            "player_choice": choice_made,
-            "time": time,
-            "location": location,
-            "image_prompts": image_prompts
-        })
-        self.current_time = time
-        self.current_location = location 
+    def add_to_history(self, story_response: StoryResponse):
+        """Add a story response to history."""
+        self.story_history.append(story_response)
+        self.current_time = story_response.time
+        self.current_location = story_response.location 

server/core/generators/image_prompt_generator.py

@@ -2,7 +2,7 @@ from typing import List
 from pydantic import BaseModel, Field
 from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 import json
-
+import random
 from core.generators.base_generator import BaseGenerator
 
 class ImagePromptResponse(BaseModel):
@@ -67,25 +67,21 @@ class ImagePromptGenerator(BaseGenerator):
         "[shot type] [scene description]"
 
         EXAMPLES:
-        - "low angle shot of a mysterious figure checking an object in a dark corridor"
-        - "wide shot of a ruined cityscape at sunset, silhouette of a lone traveler in the foreground"
-        - "Dutch angle close-up of a determined face illuminated by the glow of an object"
-        - "over shoulder shot of a character looking at an ancient map spread out on a table"
-        - "close-up of eyes reflecting the flames of a nearby fire"
-        - "wide shot of a dense forest with a figure barely visible among the trees"
-        - "high angle shot of a character standing at the edge of a cliff, looking down at a vast ocean"
-        - "medium shot of a person walking through a bustling marketplace, with various vendors and colorful stalls"
-        - "low angle shot of a character standing in front of a towering ancient statue, looking up in awe"
-        - "close-up of fingers tracing the carvings on an ancient artifact"
-        - "wide shot of a stormy sky with lightning illuminating a determined silhouette"
-        - "close-up of an ancient compass, its needle spinning wildly"
-        - "over shoulder shot of a mysterious figure watching from the shadows"
-        - "medium shot of a group of travelers gathered around a campfire, sharing stories"
-        - "Dutch angle shot of a clock tower striking midnight, casting long shadows"
-        - "close-up of a hand gripping a sword hilt, ready for battle"
-        - "wide shot of a bustling port with ships coming and going, seagulls circling above"
-        - "high angle shot of a chessboard mid-game, pieces scattered in strategic positions"
-        - "medium shot of two characters in a heated argument, tension visible in their expressions"
+        - "medium shot of a bustling marketplace, vibrant colors and lively chatter"
+        - "close-up of a mysterious figure's eyes, reflecting a hidden agenda"
+        - "wide shot of a serene lake at dawn, mist rising from the water"
+        - "Dutch angle of a character sprinting through a narrow alley, urgency in every step"
+        - "over shoulder shot of a child peering into a forbidden book, curiosity in their eyes"
+        - "low angle shot of a towering skyscraper, clouds swirling around its peak"
+        - "high angle shot of a chessboard mid-game, pieces poised for a decisive move"
+        - "close-up of a hand reaching for a glowing orb, anticipation in the air"
+        - "wide shot of a desert landscape, a lone figure trudging through the sand"
+        - "medium shot of a character standing in a rain-soaked street, determination etched on their face"
+        - "Dutch angle of a clock tower striking midnight, shadows stretching across the square"
+        - "over shoulder shot of a detective examining a crime scene, clues scattered around"
+        - "close-up of a flower blooming in a crack in the pavement, symbolizing hope"
+        - "wide shot of a stormy sea, waves crashing against a rocky shore"
+        - "medium shot of a group of friends laughing around a campfire, warmth in their expressions"
 
         Always maintain consistency with {self.hero_name}'s appearance and the style.
 
@@ -122,11 +118,13 @@ Story text: {story_text}
 Generate panel descriptions that capture the key moments of this scene.
 do not have panels that look alike, each successive panel must be different,
 and explain the story like a storyboard.
+SHOW, DONT TELL. DESCRIBE THE PANELS, be specific, put names on things.
 
 Dont put the hero name every time.
-Exactly between 1 and 4 panels. (mostly 2 or 3)
+{how_many_panels} panels
 
 {is_end}
+
 """
 
         return ChatPromptTemplate(
@@ -230,7 +228,14 @@ Exactly between 1 and 4 panels. (mostly 2 or 3)
             ImagePromptResponse containing the generated and formatted image prompts
         """
 
-        is_end="Must have between 2 and 4 prompts, MANDATORY."
+        how_many_panels = 2
+        # Générer un nombre aléatoire de panneaux entre 1 et 4
+        if is_death or is_victory:
+            how_many_panels = 1
+        else:
+            how_many_panels = random.choices([1, 2, 3, 4], weights=[0.05, 0.3, 0.4, 0.25], k=1)[0]
+
+        is_end=""
         if is_death:
             is_end = f"This is the death of {self.hero_name}. just one panel, MANDATORY."
         elif is_victory:
@@ -243,6 +248,7 @@ Exactly between 1 and 4 panels. (mostly 2 or 3)
             is_death=is_death,
             is_victory=is_victory,
             is_end=is_end,
+            how_many_panels=how_many_panels,
         )
         
         # Format each prompt with metadata

server/core/generators/metadata_generator.py

@@ -35,44 +35,50 @@ class MetadataGenerator(BaseGenerator):
         You must return a JSON object with the following format:
         {{{{
             "is_death": false,  # Set to true for death scenes
-            "is_victory": false  # Set to true for victory scenes
-            "choices": ["Choice 1", "Choice 2"],  # ALWAYS exactly two choices, each max 6 words
+            "is_victory": false,  # Set to true for victory scenes
             "time": "HH:MM",
             "location": "Location",
+            "choices": ["Choice 1", "Choice 2"]  # ALWAYS exactly two choices, each max 6 words
         }}}}
         """
 
         human_template = """
 
-History:
-{story_history}
-
-Current story segment:
-{story_text}
-
-- Current time: {current_time}
-- Current location: {current_location}
 
 
 FOR CHOICES : NEVER propose to go back to the previous location or go back to the portal. NEVER.
 Dont be obvious. NEVER use "approach the ...", its too slow to be a choice.
 
-{is_end}
 
 You can be original in your choices, but dont be too far from the story.
 Dont be too cliché. The choices should be realistically different.
 The choices should be the direct continuation of the story.
 The choices should be the direct continuation of the story.
 The choices should be the direct continuation of the story.
+The choice not have to be the most obvious one. or even the most logical one.
+
+History:
+{story_history}
+
+Current story segment:
+{story_text}
+
+- Current time: {current_time}
+- Current location: {current_location}
+
+{is_end}
+
+The choice not have to be the most obvious one. or even the most logical one.
+It MUST have a relation to the context of the story but it can be a choice that doesn't make sense.
 
 - Each choice MUST be NO MORE than 6 words - this is a HARD limit
 You must return a JSON object with the following format:
 {{{{
     "is_death": false,  # Set to true for death scenes
-    "is_victory": false  # Set to true for victory scenes
-    "choices": ["Choice 1", "Choice 2"],  # ALWAYS exactly two choices, each max 6 words
+    "is_victory": false,  # Set to true for victory scenes
     "time": "HH:MM",
     "location": "Location name",
+    "choices": ["Choice 1", "Choice 2"]  # ALWAYS exactly two choices, each max 6 words
 }}}}
 
 """
@@ -87,45 +93,76 @@ You must return a JSON object with the following format:
 
     def _validate_choices(self, choices) -> bool:
         """Valide que les choix respectent les règles."""
-        if not isinstance(choices, list) or len(choices) != 2:
+        if not isinstance(choices, list):
             return False
         
+        if len(choices) != 2:
+            return False
+            
+        # Vérifier que les choix sont différents et pas trop longs
+        seen_choices = set()
         for choice in choices:
-            # Vérifier la longueur des mots
-            word_count = len(choice.split())
-            if word_count > 6:
+            if not isinstance(choice, str):
                 return False
-            
-            # Vérifier que le choix n'est pas vide
-            if not choice.strip():
+            if len(choice.split()) > 6:  # Max 6 mots
                 return False
-            
-            # Vérifier que les choix ne contiennent pas de mots interdits
-            forbidden_words = ["back", "return", "portal"]
-            if any(word.lower() in choice.lower() for word in forbidden_words):
+            if choice.lower() in seen_choices:
                 return False
-        
-        # Vérifier que les choix sont différents
-        if choices[0].lower() == choices[1].lower():
-            return False
+            seen_choices.add(choice.lower())
             
         return True
 
+    def _get_error_feedback(self, error, response=None) -> str:
+        """Génère un feedback spécifique basé sur le type d'erreur."""
+        if isinstance(error, json.JSONDecodeError):
+            return "Your response must be a valid JSON object. Please ensure proper JSON formatting."
+        
+        if "choices" in str(error).lower():
+            choices = response.choices if response and hasattr(response, 'choices') else []
+            issues = []
+            
+            if not isinstance(choices, list):
+                return "The 'choices' field must be a list containing exactly 2 choices."
+                
+            if len(choices) != 2:
+                issues.append(f"Found {len(choices)} choices, need exactly 2")
+            
+            seen = set()
+            for choice in choices:
+                if not isinstance(choice, str):
+                    issues.append("All choices must be strings")
+                elif len(choice.split()) > 6:
+                    issues.append(f"Choice '{choice}' is too long (max 6 words)")
+                elif choice.lower() in seen:
+                    issues.append(f"Choice '{choice}' is duplicated")
+                seen.add(choice.lower())
+            
+            return "Choice validation failed: " + ", ".join(issues)
+            
+        if "missing" in str(error).lower():
+            return "Missing required fields in response. Please include: is_death, is_victory, choices, time, location"
+            
+        return str(error)
+
     async def generate(self, story_text: str, current_time: str, current_location: str, story_beat: int, error_feedback: str = "", turn_before_end: int = 0, is_winning_story: bool = False, story_history: str = "") -> StoryMetadataResponse:
         """Surcharge de generate pour inclure le error_feedback par défaut."""
 
         is_end = "This IS the end of the story." if story_beat == turn_before_end else ""
         retry_count = 0
         last_error = None
+        last_response = None
 
         while retry_count < self.max_retries:
             try:
+                # Si on a un feedback d'erreur précédent, l'utiliser
+                current_feedback = self._get_error_feedback(last_error, last_response) if last_error else error_feedback
+                
                 response = await super().generate(
                     story_text=story_text,
                     current_time=current_time,
                     current_location=current_location,
                     story_beat=story_beat,
-                    error_feedback=error_feedback,
+                    error_feedback=current_feedback,
                     is_end=is_end,
                     turn_before_end=turn_before_end,
                     is_winning_story=is_winning_story,
@@ -133,19 +170,16 @@ You must return a JSON object with the following format:
                 )
 
                 print(f"[MetadataGenerator] Raw response before validation (attempt {retry_count + 1}):", response)
-                print(f"[MetadataGenerator] Choices:", response.choices)
-                print(f"[MetadataGenerator] Time:", response.time)
-                print(f"[MetadataGenerator] Location:", response.location)
-
+                
                 # Valider les choix
                 if self._validate_choices(response.choices):
                     print("[MetadataGenerator] Validation successful!")
                     return response
                 
                 print(f"[MetadataGenerator] Validation failed for choices:", response.choices)
-                # Si les choix ne sont pas valides, ajouter un feedback et réessayer
+                last_response = response
+                last_error = ValueError("Invalid choices format")
                 retry_count += 1
-                error_feedback = f"Previous choices were invalid. Remember: EXACTLY 2 choices, MAX 6 words each, must be different and relevant. Last attempt: {response.choices}"
                 continue
 
             except Exception as e:
@@ -155,7 +189,6 @@ You must return a JSON object with the following format:
                 if retry_count >= self.max_retries:
                     print(f"[MetadataGenerator] Failed to generate valid metadata after {self.max_retries} attempts. Last error: {str(e)}")
                     raise e
-                error_feedback = f"Error in previous attempt: {str(e)}. Please try again with valid format."
                 continue
 
         # Si on arrive ici, c'est qu'on a épuisé toutes les tentatives
@@ -178,14 +211,16 @@ You must return a JSON object with the following format:
                 print("[MetadataGenerator] First cleaning failed:", str(e1))
                 # Deuxième tentative : supprimer les commentaires et les espaces superflus
                 import re
-                # Supprimer les commentaires
                 cleaned_content = re.sub(r'#.*$', '', cleaned_content, flags=re.MULTILINE)
-                # Supprimer les espaces superflus
                 cleaned_content = re.sub(r'\s+', ' ', cleaned_content)
                 print("[MetadataGenerator] Second cleaning attempt:", cleaned_content)
-                data = json.loads(cleaned_content)
-                print("[MetadataGenerator] Successfully parsed JSON after second cleaning")
-            
+                try:
+                    data = json.loads(cleaned_content)
+                    print("[MetadataGenerator] Successfully parsed JSON after second cleaning")
+                except json.JSONDecodeError as e2:
+                    print("[MetadataGenerator] Second cleaning failed:", str(e2))
+                    raise ValueError("Failed to parse JSON after multiple cleaning attempts")
+
             # Vérifier que les choix sont valides selon les règles
             choices = data.get('choices', [])
             print("[MetadataGenerator] Extracted choices:", choices)
@@ -208,4 +243,4 @@ You must return a JSON object with the following format:
         except Exception as e:
             print("[MetadataGenerator] Final error:", str(e))
             print("[MetadataGenerator] Failed to parse response content")
-            raise ValueError('Invalid JSON format. Must have EXACTLY two choices. Please provide a valid JSON object.') 
+            raise ValueError(str(e)) 

server/core/generators/story_segment_generator.py

@@ -60,7 +60,7 @@ Base 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
+2. Each segment must go forward in the story
 3. Never repeat previous descriptions or situations
 4. Keep segments concise and impactful
 
@@ -73,12 +73,14 @@ Hero Description: {self.hero_desc}
 Story history:
 {story_history}
 
-
 Never describes game variables.
 
 IT MUST BE THE DIRECT CONTINUATION OF THE CURRENT STORY.
 You MUST mention the previous situation and what is happening now with the new choice.
 Never propose choices or options. Never describe the game variables.
+The world is a dangerous place. The hero is in GREAT danger. he has great risk to die.
+If you fail a big battle, the hero is dead.
+
 LIMIT: 15 words.
 """
         return ChatPromptTemplate(
@@ -155,7 +157,9 @@ LIMIT: 15 words.
         is_death = True if is_end and is_winning_story else False
         is_victory = True if is_end and not is_winning_story else False
 
-        what_to_represent = self._get_what_to_represent(story_beat, is_death, is_victory)
+        what_to_represent = ""
+        # what_to_represent = self._get_what_to_represent(story_beat, is_death, is_victory)
+        # 
 
         # Si c'est un choix personnalisé, on l'utilise comme contexte pour générer la suite
         if previous_choice and not previous_choice.startswith("Choice "):
@@ -163,13 +167,13 @@ LIMIT: 15 words.
 Based on the player's custom choice: "{previous_choice}"
 
 Write a story segment that:
-1. Directly follows and incorporates the player's choice
-2. Maintains consistency with the universe and story
-3. Respects all previous rules about length and style
-4. Naturally integrates the custom elements while staying true to the plot
-5. NEVER FORGET THE CHOICE, IT MUST BE MENTIONED IN THE STORY.
-6. Start with a direct reaction to the player's choice
-7. Show immediate consequences of their action
+1. Respects all previous rules about length and style
+2. Ff you find a path to go in a special place, you have to travel there. 
+3. Directly follows and incorporates the player's choice
+4. Maintains consistency with the universe and story
+5. Naturally integrates the custom elements while staying true to the plot
+
+MANDATORY : Start with a direct reaction to the player's choice, Show immediate consequences of their action. Then go forward in the story.
 """
 
         # Créer les messages

server/core/generators/universe_generator.py

@@ -24,7 +24,7 @@ class UniverseGenerator(BaseGenerator):
 - Genre: {genre}
 - Historical epoch: {epoch}
 
-Describe the first segment of the story. in 20 words. Where is the main character, what is he doing? HE has to do something banal. You have to describe the first action.
+Describe the first segment of the story. in 30 words. Where is the main character, what is he doing? HE has to do something banal. You have to describe the first action.
 """
 
         return ChatPromptTemplate(

server/core/story_generator.py

@@ -49,7 +49,7 @@ class StoryGenerator:
                 artist = style["references"][0]["artist"]
                 
             # Create a detailed artist style string
-            artist_style = f"{artist}, {style['name']} style, {genre} in {epoch}"
+            artist_style = f"{style['name']}, {genre} in {epoch}"
             
             # Always create a new ImagePromptGenerator for each session with the correct artist and hero
             self.image_prompt_generator = ImagePromptGenerator(
@@ -128,7 +128,6 @@ class StoryGenerator:
                 is_winning_story=self.is_winning_story,
                 story_history=game_state.format_history()
             )
-            # print(f"Generated metadata_response: {metadata_response}")
             
             # Generate image prompts
             prompts_response = await self.image_prompt_generator.generate(
@@ -140,7 +139,6 @@ class StoryGenerator:
                 turn_before_end=self.turn_before_end,
                 is_winning_story=self.is_winning_story
             )
-            # print(f"Generated image prompts: {prompts_response}")
             
             # Create choices
             choices = [
@@ -151,16 +149,21 @@ class StoryGenerator:
             response = StoryResponse(
                 story_text=story_text,
                 choices=choices,
+                raw_choices=metadata_response.choices,
                 time=metadata_response.time,
                 location=metadata_response.location,
-                raw_choices=metadata_response.choices,
                 image_prompts=prompts_response.image_prompts,
                 is_first_step=(game_state.story_beat == GameConfig.STORY_BEAT_INTRO),
                 is_death=metadata_response.is_death,
-                is_victory=metadata_response.is_victory
+                is_victory=metadata_response.is_victory,
+                previous_choice=previous_choice
             )
             
-            return response 
+            # Add the response to game state history
+            game_state.add_to_history(response)
+            
+            return response
+            
         except Exception as e:
             print(f"Unexpected error in generate_story_segment: {str(e)}")
             raise 

server/core/styles/universe_styles.json

@@ -43,7 +43,6 @@
     "Fantasy",
     "Adventure",
     "Mystery",
-    "Romance",
     "Horror",
     "Drama"
   ],

server/scripts/test_game.py

@@ -41,26 +41,31 @@ def print_universe_info(style: str, genre: str, epoch: str, base_story: str):
     print_separator("*")
 
 def print_story_step(step_number, 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}")
-    print(f"⏱️  Generation time: {generation_time:.2f}s (model: {model_name})")
-    print(f"💀 Death: {is_death}")
-    print(f"🏆 Victory: {is_victory}")
+    """Print a story step with formatting."""
+    print("\n" + "="*80)
+    print(f"Step {step_number}")
+    print("-"*80)
     
     if show_context and story_history:
-        print_separator("-")
-        print("📚 FULL CONTEXT:")
+        print("\nContext:")
+        print("-"*20)
         print(story_history)
+        print("-"*20 + "\n")
     
-    print_separator("-")
-    print("📜 STORY:")
+    print(f"Story ({generation_time:.2f}s):")
     print(story_text)
-    print_separator("-")
-    print("🎬 STORYBOARD:")
-    for i, prompt in enumerate(image_prompts, 1):
-        print(f"\nPanel {i}:")
-        print(f"  {prompt}")
-    print_separator("=")
+    
+    if image_prompts:
+        print("\nImage Prompts:")
+        for i, prompt in enumerate(image_prompts, 1):
+            print(f"{i}. {prompt}")
+    
+    if is_death:
+        print("\n💀 GAME OVER - You died!")
+    elif is_victory:
+        print("\n🏆 VICTORY - You won!")
+    
+    print("="*80)
 
 async def play_game(show_context: bool = False, auto_mode: bool = False, max_turns: int = 15):
     # Initialize components
@@ -133,10 +138,10 @@ async def play_game(show_context: bool = False, auto_mode: bool = False, max_tur
         story_history = ""
         if game_state.story_history:
             segments = []
-            for entry in game_state.story_history:
-                segment = entry['segment']
-                time_location = f"[{entry['time']} - {entry['location']}]"
-                image_descriptions = "\nVisual panels:\n" + "\n".join(f"- {prompt}" for prompt in entry['image_prompts'])
+            for story_response in game_state.story_history:
+                segment = story_response.story_text
+                time_location = f"[{story_response.time} - {story_response.location}]"
+                image_descriptions = "\nVisual panels:\n" + "\n".join(f"- {prompt}" for prompt in story_response.image_prompts)
                 segments.append(f"{time_location}\n{segment}{image_descriptions}")
             
             story_history = "\n\n---\n\n".join(segments)
@@ -199,13 +204,7 @@ async def play_game(show_context: bool = False, auto_mode: bool = False, max_tur
             
             # Update game state
             game_state.story_beat += 1
-            game_state.add_to_history(
-                response.story_text,
-                f"Choice {last_choice}",
-                response.image_prompts,
-                response.time,
-                response.location
-            )
+            # Le StoryResponse est déjà ajouté à l'historique dans generate_story_segment
             
         else:
             print("\n❌ Error: Invalid number of choices received from server")

server/services/flux_client.py

@@ -17,7 +17,7 @@ class FluxClient:
                       prompt: str, 
                       width: int, 
                       height: int,
-                      num_inference_steps: int = 3,
+                      num_inference_steps: int = 5,
                       guidance_scale: float = 9.0) -> Optional[bytes]:
         """Génère une image à partir d'un prompt."""
         try:

server/services/mistral_client.py

@@ -30,6 +30,22 @@ logger = logging.getLogger(__name__)
 #
 # Pricing: https://docs.mistral.ai/platform/pricing/
 
+class MistralAPIError(Exception):
+    """Base class for Mistral API errors"""
+    pass
+
+class MistralRateLimitError(MistralAPIError):
+    """Raised when hitting rate limits"""
+    pass
+
+class MistralParsingError(MistralAPIError):
+    """Raised when response parsing fails"""
+    pass
+
+class MistralValidationError(MistralAPIError):
+    """Raised when response validation fails"""
+    pass
+
 class MistralClient:
     def __init__(self, api_key: str, model_name: str = "mistral-large-latest", max_tokens: int = 1000):
         logger.info(f"Initializing MistralClient with model: {model_name}, max_tokens: {max_tokens}")
@@ -48,6 +64,8 @@ class MistralClient:
         self.last_call_time = 0
         self.min_delay = 1  # 1 seconde minimum entre les appels
         self.max_retries = 5
+        self.backoff_factor = 2  # For exponential backoff
+        self.max_backoff = 30  # Maximum backoff time in seconds
     
     async def _wait_for_rate_limit(self):
         """Attend le temps nécessaire pour respecter le rate limit."""
@@ -61,6 +79,19 @@ class MistralClient:
         
         self.last_call_time = asyncio.get_event_loop().time()
 
+    async def _handle_api_error(self, error: Exception, retry_count: int) -> float:
+        """Handle API errors and return wait time for retry"""
+        wait_time = min(self.backoff_factor ** retry_count, self.max_backoff)
+        
+        if "rate limit" in str(error).lower():
+            logger.warning(f"Rate limit hit, waiting {wait_time}s before retry")
+            raise MistralRateLimitError(str(error))
+        elif "403" in str(error):
+            logger.error("Authentication error - invalid API key or quota exceeded")
+            raise MistralAPIError("Authentication failed")
+        
+        return wait_time
+
     async def _generate_with_retry(
         self,
         messages: list[BaseMessage],
@@ -68,77 +99,68 @@ class MistralClient:
         custom_parser: Optional[Callable[[str], T]] = None,
         error_feedback: str = None
     ) -> T | str:
-        """
-        Génère une réponse avec retry et parsing structuré optionnel.
-        
-        Args:
-            messages: Liste des messages pour le modèle
-            response_model: Classe Pydantic pour parser la réponse
-            custom_parser: Fonction de parsing personnalisée
-            error_feedback: Feedback d'erreur à ajouter au prompt en cas de retry
-        """
         retry_count = 0
         last_error = None
         
         while retry_count < self.max_retries:
             try:
-                # Log attempt
                 logger.info(f"Attempt {retry_count + 1}/{self.max_retries}")
                 
-                # Ajouter le feedback d'erreur si présent
                 current_messages = messages.copy()
                 if error_feedback and retry_count > 0:
-                    logger.info(f"Adding error feedback: {error_feedback}")
-                    current_messages.append(HumanMessage(content=f"Previous error: {error_feedback}. Please try again."))
+                    if isinstance(last_error, MistralParsingError):
+                        # For parsing errors, add structured format reminder
+                        current_messages.append(HumanMessage(content="Please ensure your response is in valid JSON format."))
+                    elif isinstance(last_error, MistralValidationError):
+                        # For validation errors, add the specific feedback
+                        current_messages.append(HumanMessage(content=f"Previous error: {error_feedback}. Please try again."))
                 
-                # Log request details
-                logger.debug("Request details:")
-                for msg in current_messages:
-                    logger.debug(f"- {msg.type}: {msg.content[:100]}...")
-                
-                # Générer la réponse
                 await self._wait_for_rate_limit()
                 try:
                     response = await self.model.ainvoke(current_messages)
                     content = response.content
                     logger.debug(f"Raw response: {content[:100]}...")
                 except Exception as api_error:
-                    logger.error(f"API Error: {str(api_error)}")
-                    if "403" in str(api_error):
-                        logger.error("Received 403 Forbidden - This might indicate an invalid API key or quota exceeded")
+                    wait_time = await self._handle_api_error(api_error, retry_count)
+                    retry_count += 1
+                    if retry_count < self.max_retries:
+                        await asyncio.sleep(wait_time)
+                        continue
                     raise
-                
+
                 # Si pas de parsing requis, retourner le contenu brut
                 if not response_model and not custom_parser:
                     return content
-                
+
                 # Parser la réponse
-                if custom_parser:
-                    return custom_parser(content)
-                
-                # Essayer de parser avec le modèle Pydantic
                 try:
+                    if custom_parser:
+                        return custom_parser(content)
+                    
+                    # Essayer de parser avec le modèle Pydantic
                     data = json.loads(content)
                     return response_model(**data)
                 except json.JSONDecodeError as e:
-                    last_error = f"Invalid JSON format: {str(e)}"
-                    logger.error(f"JSON parsing error: {last_error}")
-                    raise ValueError(last_error)
+                    last_error = MistralParsingError(f"Invalid JSON format: {str(e)}")
+                    logger.error(f"JSON parsing error: {str(e)}")
+                    raise last_error
                 except Exception as e:
-                    last_error = str(e)
-                    logger.error(f"Pydantic parsing error: {last_error}")
-                    raise ValueError(last_error)
-                
-            except Exception as e:
+                    last_error = MistralValidationError(str(e))
+                    logger.error(f"Validation error: {str(e)}")
+                    raise last_error
+
+            except (MistralParsingError, MistralValidationError) as e:
                 logger.error(f"Error on attempt {retry_count + 1}/{self.max_retries}: {str(e)}")
+                last_error = e
                 retry_count += 1
                 if retry_count < self.max_retries:
-                    wait_time = 2 * retry_count
+                    wait_time = min(self.backoff_factor ** retry_count, self.max_backoff)
                     logger.info(f"Waiting {wait_time} seconds before retry...")
                     await asyncio.sleep(wait_time)
                     continue
-                logger.error(f"Failed after {self.max_retries} attempts. Last error: {last_error or str(e)}")
-                raise Exception(f"Failed after {self.max_retries} attempts. Last error: {last_error or str(e)}")
+                
+                logger.error(f"Failed after {self.max_retries} attempts. Last error: {str(last_error)}")
+                raise Exception(f"Failed after {self.max_retries} attempts. Last error: {str(last_error)}")
     
     async def generate(self, messages: list[BaseMessage], response_model: Optional[Type[T]] = None, custom_parser: Optional[Callable[[str], T]] = None) -> T | str:
         """Génère une réponse à partir d'une liste de messages avec parsing optionnel."""