Rename to LoveMath + major UX improvements

- Rename app MathAnimaux → LoveMath
- Translate all UI text to minimal English
- Add emoji selector (animals + places) before quiz
- Background pre-generation of reward images via ThreadPoolExecutor
- Emoji→text mapping injected into FLUX prompt
- Comprehensive error handling throughout
- Update README with local run instructions

README.md

@@ -1,6 +1,6 @@
 ---
-title: MathAnimaux
-emoji: 🐾
+title: LoveMath
+emoji: 💖
 colorFrom: purple
 colorTo: pink
 sdk: gradio
@@ -16,26 +16,52 @@ tags:
   - math
 ---
 
-# 🐾 MathAnimaux
+# 💖 LoveMath
 
-Une application de calcul mental pour les enfants, avec des récompenses sous forme d'images d'animaux générées par l'IA !
+A mental math app for kids — answer questions, earn cute AI-generated animal images as rewards!
 
-## Comment ça marche ?
+## How it works
 
-1. Entre ton prénom
-2. Réponds aux questions de calcul mental
-3. Toutes les **3 bonnes réponses**, tu gagnes une image d'un animal trop mignon généré par IA !
-4. Monte de niveau : Additions → Soustractions → Multiplications → Mélange
+1. Enter your name
+2. Pick your favourite animals 🐾 and places 🌍 (used to personalise reward images)
+3. Answer math questions — every **3 correct answers** earns a reward image
+4. Level up: **Additions → Subtractions → Multiplications → Mix**
 
-## Niveaux
+## Levels
 
-| Niveau | Opération | Objectif |
-|--------|-----------|----------|
-| 1 | ➕ Additions | 5 bonnes réponses |
-| 2 | ➖ Soustractions | 5 bonnes réponses |
-| 3 | ✖️ Multiplications | 5 bonnes réponses |
-| 4 | 🎲 Mélange | Mode expert infini |
+| Level | Operation | Goal |
+|-------|-----------|------|
+| 1 | ➕ Additions | 5 correct |
+| 2 | ➖ Subtractions | 5 correct |
+| 3 | ✖️ Multiplications | 5 correct |
+| 4 | 🎲 Mix | Endless |
 
-## Modèle utilisé
+## Image model
 
-Images générées avec **FLUX.1-schnell** (12B paramètres, Apache 2.0) via 🤗 Diffusers.
+Rewards generated with **FLUX.1-schnell** (12B params, Apache 2.0) via 🤗 Diffusers.  
+Images start generating in the background as soon as the quiz begins.
+
+## Run locally
+
+> Requires Python on Apple Silicon (arm64). Recommended: [Miniforge](https://github.com/conda-forge/miniforge).
+
+```bash
+# 1. Install dependencies
+~/miniforge3/bin/pip install -r requirements.txt
+
+# 2. Accept FLUX.1-schnell license on HuggingFace
+#    → https://huggingface.co/black-forest-labs/FLUX.1-schnell
+#    Then log in:
+hf auth login
+
+# 3. Run
+~/miniforge3/bin/python3 app.py
+# Opens at http://localhost:7860
+# First run downloads ~23GB of model weights (cached after that)
+```
+
+> On standard Python/pip (non-Apple Silicon):
+> ```bash
+> pip install -r requirements.txt
+> python app.py
+> ```

app.py

@@ -1,242 +1,334 @@
 """
-🐾 MathAnimaux — Application de calcul mental avec récompenses mignonnes !
-Pour Léa et Zoé 🌟
+💖 LoveMath — Math practice with cute AI-generated animal rewards!
 """
 
-import gradio as gr
+import random
+import concurrent.futures
 from math_engine import generate_question, LEVEL_NAMES, LEVEL_THRESHOLDS, level_up_message
 from image_generator import generate_reward_image
 
 # ---------------------------------------------------------------------------
-# How many correct answers trigger a reward image
+# Constants
 # ---------------------------------------------------------------------------
-REWARD_EVERY = 3
 
+REWARD_EVERY = 3  # correct answers needed to trigger a reward
+
+ANIMAL_EMOJIS = ["🐶", "🐱", "🐰", "🦊", "🐼", "🐨", "🦁", "🐯", "🐸", "🐧", "🦋", "🦄"]
+PLACE_EMOJIS  = ["🌊", "🏔️", "🌸", "🌈", "🌙", "⭐", "🌴", "🏡", "🌺", "🍄"]
+
+_executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
 
 # ---------------------------------------------------------------------------
-# Core game logic
+# State helpers
 # ---------------------------------------------------------------------------
 
-def start_game(player_name: str, state: dict):
-    """Initialize or reset the game for a player."""
-    name = player_name.strip() or "Champion(ne)"
-    state = {
-        "name": name,
-        "level": 1,
-        "score": 0,
-        "streak": 0,
-        "correct_since_reward": 0,
-        "level_correct": 0,
-        "question": "",
-        "answer": 0,
-        "waiting_next": False,
-    }
-    question, answer = generate_question(state["level"])
-    state["question"] = question
-    state["answer"] = answer
-
-    status = _status_text(state)
+def _empty_state() -> dict:
+    return {}
+
+def _status_text(state: dict) -> str:
+    if not state:
+        return ""
+    level_name = LEVEL_NAMES.get(state["level"], "")
+    return f"👤 {state['name']}  |  ⭐ {state['score']}  |  📚 {level_name}"
+
+def _submit_generation(state: dict):
+    """Fire off a background image generation job and store Future in state."""
+    animals = state.get("selected_animals", [random.choice(ANIMAL_EMOJIS)])
+    places  = state.get("selected_places",  [random.choice(PLACE_EMOJIS)])
+    streak  = state.get("streak", 0)
+    future  = _executor.submit(generate_reward_image, streak, animals, places)
+    state["future"] = future
+    state["awaiting_reward"] = False
+
+def _no_change_outputs(state: dict):
+    import gradio as gr
     return (
         state,
-        gr.update(visible=False),          # hide welcome panel
-        gr.update(visible=True),           # show game panel
-        f"Bonjour **{name}** ! C'est parti 🚀",
-        status,
-        f"## {question} = ?",
-        "",                                # clear input
-        "",                                # clear feedback
-        None,                              # clear image
-        gr.update(visible=False),          # hide reward panel
+        _status_text(state),
+        f"## {state.get('question', '')} = ?",
+        "",
+        "",
+        None,
+        gr.update(visible=False),
     )
 
+# ---------------------------------------------------------------------------
+# Game flow
+# ---------------------------------------------------------------------------
 
-def check_answer(user_input: str, state: dict):
-    """Validate the answer and update game state."""
-    if not state or state.get("waiting_next"):
-        return (state,) + _no_change_outputs(state)
-
+def enter_name(player_name: str, state: dict):
+    """Step 1: validate name, move to emoji picker."""
     try:
-        user_answer = int(user_input.strip())
-    except ValueError:
+        import gradio as gr
+        name = player_name.strip() or "Player"
+        state = {"name": name}
         return (
             state,
-            _status_text(state),
-            f"## {state['question']} = ?",
-            "",
-            "⚠️ Écris un nombre entier !",
-            None,
-            gr.update(visible=False),
+            gr.update(visible=False),   # hide welcome
+            gr.update(visible=True),    # show emoji picker
+            gr.update(visible=False),   # hide game
+            random.sample(ANIMAL_EMOJIS, 1),   # pre-select 1 animal
+            random.sample(PLACE_EMOJIS, 1),    # pre-select 1 place
         )
+    except Exception as e:
+        print(f"enter_name error: {e}")
+        import gradio as gr
+        return state, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), [], []
+
+
+def start_game(animal_sel: list, place_sel: list, state: dict):
+    """Step 2: emoji confirmed → start quiz + fire background image generation."""
+    import gradio as gr
+    try:
+        # Validate selections (1–3 each required)
+        if not animal_sel or not place_sel:
+            return (state, gr.update(visible=True), gr.update(visible=False), "⚠️ Pick at least one animal and one place!", "", "")
+
+        state["selected_animals"] = animal_sel[:3]
+        state["selected_places"]  = place_sel[:3]
+        state["level"]              = 1
+        state["score"]              = 0
+        state["streak"]             = 0
+        state["correct_since_reward"] = 0
+        state["level_correct"]      = 0
+        state["awaiting_reward"]    = False
+        state["future"]             = None
+
+        question, answer = generate_question(state["level"])
+        state["question"] = question
+        state["answer"]   = answer
+
+        # Pre-generate first reward image immediately
+        _submit_generation(state)
+
+        return (state, gr.update(visible=False), gr.update(visible=True), "", _status_text(state), f"## {question} = ?")
+
+    except Exception as e:
+        print(f"start_game error: {e}")
+        return (state, gr.update(visible=True), gr.update(visible=False), f"⚠️ Something went wrong, try again.", "", "")
+
+
+def check_answer(user_input: str, state: dict):
+    """Validate answer, update state, potentially show reward."""
+    import gradio as gr
+    try:
+        if not state or not state.get("question"):
+            return _no_change_outputs(state)
+
+        # Parse input
+        try:
+            user_answer = int(user_input.strip())
+        except (ValueError, AttributeError):
+            return (
+                state,
+                _status_text(state),
+                f"## {state['question']} = ?",
+                "",
+                "⚠️ Numbers only!",
+                None,
+                gr.update(visible=False),
+            )
 
-    correct = user_answer == state["answer"]
-
-    if correct:
-        state["score"] += 1
-        state["streak"] += 1
-        state["correct_since_reward"] += 1
-        state["level_correct"] += 1
-
-        # Check level-up
-        level_msg = ""
-        leveled_up = False
-        threshold = LEVEL_THRESHOLDS.get(state["level"], 999)
-        if state["level_correct"] >= threshold and state["level"] < 4:
-            state["level"] += 1
-            state["level_correct"] = 0
-            level_msg = level_up_message(state["level"])
-            leveled_up = True
-
-        # Check reward
+        correct = (user_answer == state["answer"])
         reward_image = None
         reward_visible = False
-        if state["correct_since_reward"] >= REWARD_EVERY:
-            state["correct_since_reward"] = 0
-            reward_image, _ = generate_reward_image(state["streak"])
-            reward_visible = True
+        feedback = ""
+
+        if correct:
+            state["score"]               += 1
+            state["streak"]              += 1
+            state["correct_since_reward"] += 1
+            state["level_correct"]        += 1
+
+            # Check for level-up
+            threshold  = LEVEL_THRESHOLDS.get(state["level"], 999)
+            level_msg  = ""
+            if state["level_correct"] >= threshold and state["level"] < 4:
+                state["level"]         += 1
+                state["level_correct"]  = 0
+                level_msg = level_up_message(state["level"])
+
+            streak_fire = "🔥" * min(state["streak"], 5)
+            feedback = f"✅ Great! {streak_fire}" if not level_msg else f"✅ {level_msg}"
+
+            # Check if reward is due
+            if state["correct_since_reward"] >= REWARD_EVERY:
+                state["correct_since_reward"] = 0
+                future = state.get("future")
+
+                if future is not None and future.done():
+                    # Image ready — grab it
+                    try:
+                        result = future.result()
+                        reward_image = result[0] if result else None
+                    except Exception as e:
+                        print(f"Image retrieval error: {e}")
+                        reward_image = None
+
+                    # Kick off next generation
+                    _submit_generation(state)
+                else:
+                    # Still generating — mark as awaiting
+                    state["awaiting_reward"] = True
+
+                reward_visible = True
+
+        else:
+            state["streak"] = 0
+            feedback = f"❌ Answer: **{state['answer']}**"
+
+        # If previously awaiting reward and image is now ready, grab it
+        if state.get("awaiting_reward") and not reward_visible:
+            future = state.get("future")
+            if future is not None and future.done():
+                try:
+                    result = future.result()
+                    reward_image = result[0] if result else None
+                except Exception as e:
+                    print(f"Image retrieval error: {e}")
+                    reward_image = None
+                state["awaiting_reward"] = False
+                _submit_generation(state)
+                reward_visible = True
 
         # Next question
         question, answer = generate_question(state["level"])
         state["question"] = question
-        state["answer"] = answer
-
-        streak_emoji = "🔥" * min(state["streak"], 5)
-        if leveled_up:
-            feedback = f"✅ Correct ! {level_msg}"
-        else:
-            feedback = f"✅ Bravo ! {streak_emoji}" if state["streak"] > 1 else "✅ Correct !"
+        state["answer"]   = answer
 
         return (
             state,
             _status_text(state),
             f"## {question} = ?",
-            "",
+            "",          # clear input
             feedback,
             reward_image,
             gr.update(visible=reward_visible),
         )
 
-    else:
-        state["streak"] = 0
-        feedback = f"❌ Raté ! La réponse était **{state['answer']}**. Essaie encore !"
-        # New question after wrong answer
-        question, answer = generate_question(state["level"])
+    except Exception as e:
+        print(f"check_answer error: {e}")
+        question, answer = generate_question(state.get("level", 1))
         state["question"] = question
-        state["answer"] = answer
+        state["answer"]   = answer
         return (
             state,
             _status_text(state),
             f"## {question} = ?",
             "",
-            feedback,
+            "⚠️ Something went wrong!",
             None,
             gr.update(visible=False),
         )
 
 
-def _status_text(state: dict) -> str:
-    if not state:
-        return ""
-    level_name = LEVEL_NAMES.get(state["level"], "")
-    return (
-        f"👤 {state['name']}  |  "
-        f"⭐ Score : {state['score']}  |  "
-        f"📚 Niveau : {level_name}"
-    )
-
-
-def _no_change_outputs(state):
-    return (
-        _status_text(state),
-        f"## {state.get('question', '')} = ?",
-        "",
-        "",
-        None,
-        gr.update(visible=False),
-    )
-
+def restart(state: dict):
+    """Cancel any running future and go back to welcome screen."""
+    import gradio as gr
+    try:
+        future = state.get("future")
+        if future is not None:
+            future.cancel()
+    except Exception:
+        pass
+    return {}, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), "", ""
 
 # ---------------------------------------------------------------------------
 # Gradio UI
 # ---------------------------------------------------------------------------
 
+import gradio as gr
+
 CSS = """
-#title { text-align: center; font-size: 2em; margin-bottom: 0.2em; }
-#subtitle { text-align: center; color: #888; margin-bottom: 1em; }
-#question-box { text-align: center; font-size: 2.5em; font-weight: bold; padding: 0.5em; }
-#feedback-box { text-align: center; font-size: 1.3em; min-height: 2em; }
-#status-box { text-align: center; padding: 0.4em; background: #f9f0ff; border-radius: 8px; }
-#reward-img { border-radius: 16px; }
+#title       { text-align: center; font-size: 2.2em; margin-bottom: 0.1em; }
+#subtitle    { text-align: center; color: #888; margin-bottom: 1em; font-style: italic; }
+#question-box{ text-align: center; font-size: 2.6em; font-weight: bold; padding: 0.5em; }
+#feedback-box{ text-align: center; font-size: 1.3em; min-height: 2em; }
+#status-box  { text-align: center; padding: 0.4em; border-radius: 8px; }
+#reward-img  { border-radius: 16px; }
 .answer-input input { font-size: 2em !important; text-align: center !important; }
+.emoji-group label { font-size: 1.6em !important; }
 """
 
-with gr.Blocks(title="🐾 MathAnimaux", theme=gr.themes.Soft(primary_hue="purple", secondary_hue="pink")) as demo:
+with gr.Blocks(title="💖 LoveMath") as demo:
 
     state = gr.State({})
 
-    # ---- Header ----
-    gr.Markdown("# 🐾 MathAnimaux", elem_id="title")
-    gr.Markdown("*Calcule bien et gagne des images d'animaux trop mignons !*", elem_id="subtitle")
+    gr.Markdown("# 💖 LoveMath", elem_id="title")
+    gr.Markdown("*Do maths. Win cute animals!*", elem_id="subtitle")
 
-    # ---- Welcome panel ----
+    # ── Welcome panel ──────────────────────────────────────────────────────
     with gr.Group(visible=True) as welcome_panel:
-        gr.Markdown("### 👋 Qui es-tu ?")
-        player_name = gr.Textbox(
-            placeholder="Écris ton prénom…",
-            label="Ton prénom",
-            max_lines=1,
+        gr.Markdown("### Who are you?")
+        player_name = gr.Textbox(placeholder="Your name…", label="", max_lines=1)
+        next_btn    = gr.Button("Next ➡️", variant="primary", size="lg")
+
+    # ── Emoji picker panel ─────────────────────────────────────────────────
+    with gr.Group(visible=False) as emoji_panel:
+        gr.Markdown("### Pick your animals 🐾")
+        animal_picker = gr.CheckboxGroup(
+            choices=ANIMAL_EMOJIS,
+            label="",
+            elem_classes=["emoji-group"],
+        )
+        gr.Markdown("### Pick your places 🌍")
+        place_picker = gr.CheckboxGroup(
+            choices=PLACE_EMOJIS,
+            label="",
+            elem_classes=["emoji-group"],
         )
-        start_btn = gr.Button("🚀 Commencer !", variant="primary", size="lg")
+        picker_error = gr.Markdown("")
+        go_btn = gr.Button("Let's go! 🚀", variant="primary", size="lg")
 
-    # ---- Game panel ----
+    # ── Game panel ─────────────────────────────────────────────────────────
     with gr.Group(visible=False) as game_panel:
-        hello_msg = gr.Markdown("")
-        status_md = gr.Markdown("", elem_id="status-box", container=True)
-
+        status_md   = gr.Markdown("", elem_id="status-box", container=True)
         question_md = gr.Markdown("", elem_id="question-box")
 
         answer_input = gr.Textbox(
-            placeholder="Ta réponse…",
-            label="Ta réponse",
+            placeholder="?",
+            label="Your answer",
             max_lines=1,
             elem_classes=["answer-input"],
         )
-        submit_btn = gr.Button("✔️ Valider", variant="primary")
-
+        check_btn  = gr.Button("✔️ Check!", variant="primary")
         feedback_md = gr.Markdown("", elem_id="feedback-box")
 
-        # ---- Reward panel ----
         with gr.Group(visible=False) as reward_panel:
-            gr.Markdown("### 🎁 Bravo ! Voici ta récompense !")
+            gr.Markdown("### 🎁 Your reward!")
             reward_image = gr.Image(
-                label="",
-                show_label=False,
-                elem_id="reward-img",
-                height=400,
+                label="", show_label=False,
+                elem_id="reward-img", height=400,
             )
 
-    # ---- Restart button (always visible once game started) ----
-    restart_btn = gr.Button("🔄 Recommencer", variant="secondary", size="sm")
-
-    # ---- Wiring ----
-    start_outputs = [
-        state, welcome_panel, game_panel,
-        hello_msg, status_md, question_md,
-        answer_input, feedback_md, reward_image, reward_panel,
-    ]
-    start_btn.click(start_game, inputs=[player_name, state], outputs=start_outputs)
-    player_name.submit(start_game, inputs=[player_name, state], outputs=start_outputs)
-
-    check_outputs = [
-        state, status_md, question_md, answer_input, feedback_md, reward_image, reward_panel,
-    ]
-    submit_btn.click(check_answer, inputs=[answer_input, state], outputs=check_outputs)
+    restart_btn = gr.Button("🔄 Restart", variant="secondary", size="sm")
+
+    # ── Event wiring ───────────────────────────────────────────────────────
+
+    # Welcome → Emoji picker
+    enter_outputs = [state, welcome_panel, emoji_panel, game_panel, animal_picker, place_picker]
+    next_btn.click(enter_name, inputs=[player_name, state], outputs=enter_outputs)
+    player_name.submit(enter_name, inputs=[player_name, state], outputs=enter_outputs)
+
+    # Emoji picker → Game
+    start_outputs = [state, emoji_panel, game_panel, picker_error, status_md, question_md]
+    go_btn.click(start_game, inputs=[animal_picker, place_picker, state], outputs=start_outputs)
+
+    # Answer checking
+    check_outputs = [state, status_md, question_md, answer_input, feedback_md, reward_image, reward_panel]
+    check_btn.click(check_answer,  inputs=[answer_input, state], outputs=check_outputs)
     answer_input.submit(check_answer, inputs=[answer_input, state], outputs=check_outputs)
 
+    # Restart
     restart_btn.click(
-        lambda: (gr.update(visible=True), gr.update(visible=False), {}, "", ""),
-        outputs=[welcome_panel, game_panel, state, player_name, hello_msg],
+        restart,
+        inputs=[state],
+        outputs=[state, welcome_panel, emoji_panel, game_panel, player_name, picker_error],
     )
 
 
 if __name__ == "__main__":
-    demo.launch(css=CSS)
+    demo.launch(
+        css=CSS,
+        theme=gr.themes.Soft(primary_hue="purple", secondary_hue="pink"),
+    )

image_generator.py

@@ -5,33 +5,46 @@ import torch
 # Patch for torch < 2.4 which lacks torch.xpu (required by diffusers >= 0.30)
 if not hasattr(torch, "xpu"):
     class _MockXPU:
-        is_available = staticmethod(lambda: False)
-        device_count = staticmethod(lambda: 0)
-        empty_cache = staticmethod(lambda: None)
-        manual_seed = staticmethod(lambda seed: None)
+        is_available    = staticmethod(lambda: False)
+        device_count    = staticmethod(lambda: 0)
+        empty_cache     = staticmethod(lambda: None)
+        manual_seed     = staticmethod(lambda seed: None)
         reset_peak_memory_stats = staticmethod(lambda: None)
-        max_memory_allocated = staticmethod(lambda: 0)
-        synchronize = staticmethod(lambda: None)
+        max_memory_allocated    = staticmethod(lambda: 0)
+        synchronize     = staticmethod(lambda: None)
     torch.xpu = _MockXPU()
 
 # ---------------------------------------------------------------------------
-# Detect if running on HuggingFace Spaces with ZeroGPU
+# Detect HuggingFace Spaces ZeroGPU
 # ---------------------------------------------------------------------------
 
 IS_HF_SPACE = os.environ.get("SPACE_ID") is not None
-
 if IS_HF_SPACE:
     import spaces
 
 # ---------------------------------------------------------------------------
-# Animal reward prompts — escalate with streak
+# Emoji → descriptive text maps (fed into FLUX prompt)
 # ---------------------------------------------------------------------------
 
-ANIMALS = [
-    "bunny", "kitten", "puppy", "baby panda", "duckling",
-    "baby fox", "hedgehog", "baby penguin", "baby koala",
-    "baby deer", "hamster", "baby owl", "baby elephant",
-]
+ANIMAL_MAP: dict[str, str] = {
+    "🐶": "puppy",        "🐱": "kitten",       "🐰": "bunny",
+    "🦊": "baby fox",     "🐼": "baby panda",   "🐨": "baby koala",
+    "🦁": "baby lion",    "🐯": "baby tiger",   "🐸": "baby frog",
+    "🐧": "baby penguin", "🦋": "butterfly",    "🦄": "unicorn",
+}
+
+PLACE_MAP: dict[str, str] = {
+    "🌊": "on a sunny beach with ocean waves",
+    "🏔️": "on a snowy mountain top",
+    "🌸": "in a cherry blossom garden",
+    "🌈": "under a rainbow",
+    "🌙": "on a glowing crescent moon",
+    "⭐": "surrounded by sparkling stars",
+    "🌴": "on a tropical island",
+    "🏡": "in a cosy cottage garden",
+    "🌺": "in a field of tropical flowers",
+    "🍄": "in an enchanted mushroom forest",
+}
 
 STYLES = [
     "kawaii digital art",
@@ -40,33 +53,40 @@ STYLES = [
     "pastel chibi illustration",
 ]
 
-def build_prompt(streak: int) -> str:
-    animal = random.choice(ANIMALS)
-    style = random.choice(STYLES)
+# ---------------------------------------------------------------------------
+# Prompt builder
+# ---------------------------------------------------------------------------
+
+def build_prompt(streak: int, animals: list[str], places: list[str]) -> str:
+    # Pick one animal and one place from user selection
+    animal_emoji = random.choice(animals) if animals else random.choice(list(ANIMAL_MAP))
+    place_emoji  = random.choice(places)  if places  else random.choice(list(PLACE_MAP))
+
+    animal_text = ANIMAL_MAP.get(animal_emoji, "bunny")
+    place_text  = PLACE_MAP.get(place_emoji,   "in a magical garden")
+    style       = random.choice(STYLES)
 
     if streak <= 2:
-        mood = "cute"
+        mood   = "cute"
         extras = "with big sparkling eyes, soft pastel colors"
     elif streak <= 5:
-        mood = "super cute and happy"
+        mood   = "super cute and happy"
         extras = "with big sparkling eyes, glitter, pastel rainbow colors, smiling"
     else:
-        mood = "magically adorable, ultra fluffy"
+        mood   = "magically adorable, ultra fluffy"
         extras = (
             "with big sparkling eyes, magical sparkles, rainbow aura, "
             "tiny crown, pastel colors, looking amazed"
         )
 
     prompt = (
-        f"A {mood} {animal}, {style}, {extras}, "
-        "white background, children's book illustration style, "
-        "high quality, detailed"
+        f"A {mood} {animal_text} {place_text}, {style}, {extras}, "
+        "white background, children's book illustration style, high quality, detailed"
     )
     return prompt
 
-
 # ---------------------------------------------------------------------------
-# Pipeline loader (cached so we only load once)
+# Pipeline loader (cached)
 # ---------------------------------------------------------------------------
 
 _pipe = None
@@ -78,50 +98,56 @@ def get_pipeline():
 
     from diffusers import FluxPipeline
 
-    print("Loading FLUX.1-schnell pipeline...")
+    print("Loading FLUX.1-schnell pipeline…")
     _pipe = FluxPipeline.from_pretrained(
         "black-forest-labs/FLUX.1-schnell",
         torch_dtype=torch.bfloat16,
     )
 
-    # Device selection: CUDA > MPS (Apple Silicon) > CPU
     if torch.cuda.is_available():
         _pipe = _pipe.to("cuda")
     elif torch.backends.mps.is_available():
         _pipe = _pipe.to("mps")
     else:
-        # CPU fallback — slow but works
         _pipe.enable_model_cpu_offload()
 
     print("Pipeline ready.")
     return _pipe
 
-
 # ---------------------------------------------------------------------------
-# Main generation function
-# Two versions: one with @spaces.GPU for HF, one plain for local
+# Core generation (always wrapped in try/except)
 # ---------------------------------------------------------------------------
 
-def _generate(streak: int):
-    pipe = get_pipeline()
-    prompt = build_prompt(streak)
-    print(f"Generating image | streak={streak} | prompt: {prompt}")
-    result = pipe(
-        prompt=prompt,
-        num_inference_steps=4,   # schnell is optimised for 1-4 steps
-        guidance_scale=0.0,      # schnell doesn't use CFG
-        height=512,
-        width=512,
-    )
-    return result.images[0], prompt
+def _generate(streak: int, animals: list[str], places: list[str]):
+    try:
+        pipe   = get_pipeline()
+        prompt = build_prompt(streak, animals, places)
+        print(f"Generating | streak={streak} | prompt: {prompt}")
+
+        result = pipe(
+            prompt=prompt,
+            num_inference_steps=4,
+            guidance_scale=0.0,
+            height=512,
+            width=512,
+        )
+        return result.images[0], prompt
+
+    except Exception as e:
+        print(f"Image generation failed: {e}")
+        return None, ""
 
 
+# ---------------------------------------------------------------------------
+# Public API — two versions depending on environment
+# ---------------------------------------------------------------------------
+
 if IS_HF_SPACE:
     @spaces.GPU(duration=60)
-    def generate_reward_image(streak: int):
-        """Generate a cute animal image as a reward (HF Spaces / ZeroGPU)."""
-        return _generate(streak)
+    def generate_reward_image(streak: int, animals: list[str], places: list[str]):
+        """Generate reward image on HF Spaces ZeroGPU."""
+        return _generate(streak, animals, places)
 else:
-    def generate_reward_image(streak: int):
-        """Generate a cute animal image as a reward (local)."""
-        return _generate(streak)
+    def generate_reward_image(streak: int, animals: list[str], places: list[str]):
+        """Generate reward image locally."""
+        return _generate(streak, animals, places)

math_engine.py

@@ -1,7 +1,7 @@
 import random
 
-# Levels definition: (operation_label, generator_function)
-# Targeting ages 9-10 (French CE2/CM1 curriculum)
+# Levels definition
+# Targeting ages 9-10
 
 def generate_question(level: int) -> tuple[str, int]:
     """
@@ -19,7 +19,7 @@ def generate_question(level: int) -> tuple[str, int]:
 
     elif level == 2:
         a = random.randint(1, 30)
-        b = random.randint(1, a)  # ensure positive result
+        b = random.randint(1, a)
         return f"{a} - {b}", a - b
 
     elif level == 3:
@@ -45,17 +45,17 @@ def generate_question(level: int) -> tuple[str, int]:
 
 LEVEL_NAMES = {
     1: "➕ Additions",
-    2: "➖ Soustractions",
+    2: "➖ Subtractions",
     3: "✖️ Multiplications",
-    4: "🎲 Mélange",
+    4: "🎲 Mix",
 }
 
-LEVEL_THRESHOLDS = {1: 5, 2: 5, 3: 5, 4: 999}  # correct answers needed to level up
+LEVEL_THRESHOLDS = {1: 5, 2: 5, 3: 5, 4: 999}
 
 def level_up_message(level: int) -> str:
     messages = {
-        2: "🎉 Bravo ! Tu passes aux soustractions !",
-        3: "🌟 Incroyable ! Place aux multiplications !",
-        4: "🏆 Tu es un(e) champion(ne) ! Mode expert activé !",
+        2: "🎉 Next level!",
+        3: "🌟 Multiplications!",
+        4: "🏆 Expert mode!",
     }
     return messages.get(level, "")