Merge pull request 'Dev' (#15) from dev into main

Reviewed-on: #15

db/__init__.py

@@ -84,17 +84,7 @@ from .custom_events.get_custom_event import get_custom_event
 from .custom_events.create_custom_event import create_custom_event
 from .custom_events.update_custom_event import update_custom_event
 
-from .quests.constants import (
+from .dialogue_lines import sanitize_dialogue_lines, QUESTION_REWARD_TYPES, sum_question_rewards
-    QUEST_STATUS_CHOICES, QUEST_STATUS_LABELS, QUEST_RESULT_CHOICES, QUEST_RESULT_LABELS,
-)
-from .quests.list_quests import list_quests
-from .quests.get_quest import get_quest
-from .quests.create_quest import create_quest
-from .quests.update_quest import update_quest
-from .quests.delete_quest import delete_quest
-from .quests.set_quest_dialogues import set_quest_dialogues
-from .quests.sanitize_quest_dialogues import sanitize_quest_dialogues, QUESTION_REWARD_TYPES
-from .quests.reward_budget import quest_dialogues_total_reward
 
 __all__ = [
     "PROJECTS_DIR", "FIELD_TYPES", "GLOBAL_VARIABLE_TYPES", "PLAYER_SHARED",
@@ -113,7 +103,5 @@ __all__ = [
     "update_global_variable_value", "update_global_variable", "delete_global_variable",
     "delete_global_variable_by_id",
     "list_custom_events", "get_custom_event", "create_custom_event", "update_custom_event",
-    "QUEST_STATUS_CHOICES", "QUEST_STATUS_LABELS", "QUEST_RESULT_CHOICES", "QUEST_RESULT_LABELS",
+    "sanitize_dialogue_lines", "QUESTION_REWARD_TYPES", "sum_question_rewards",
-    "list_quests", "get_quest", "create_quest", "update_quest", "delete_quest",
-    "set_quest_dialogues", "sanitize_quest_dialogues", "QUESTION_REWARD_TYPES", "quest_dialogues_total_reward",
 ]

db/dialogue_lines.py

@@ -1,9 +1,7 @@
-from .constants import QUEST_STATUS_CHOICES
-
 _MAX_LINES_PER_COLUMN = 200
 _MAX_SPEAKER_LENGTH = 60
 
-# Question à choix (voir "❓ Question", static/js/quests/quest-editor.js) :
+# Question à choix (voir "❓ Question", static/js/triggers/trigger-editor.js) :
 # une bulle jaune posée dans le même enchaînement qu'une réplique de
 # dialogue — plusieurs choix, une seule bonne réponse, une récompense.
 # Un seul type de récompense pour l'instant (le score, voir db.SCORE_STATUS_*/
@@ -61,22 +59,31 @@ def _sanitize_line(raw_line):
     return _sanitize_dialogue_line(raw_line)
 
 
-def sanitize_quest_dialogues(raw_dialogues):
+def sanitize_dialogue_lines(raw_lines):
-    """Une colonne (voir QUEST_STATUS_CHOICES) contient une suite de
+    """Sanitize une LISTE de répliques de dialogue ({type: "dialogue",
-    répliques de dialogue ({type: "dialogue", speaker, text} — le nom
+    speaker, text} — le nom vient du champ "ℹ️ Informations" d'un objet de
-    vient du champ "ℹ️ Informations" d'un objet de scène, ou "Joueur",
+    scène, ou "Joueur", voir screens/rendering/scene_object_names.py)
-    voir screens/rendering/scene_object_names.py) ET/OU de questions à
+    ET/OU de questions à choix ({type: "question", text, choices,
-    choix ({type: "question", text, choices, correct_index, reward_type,
+    correct_index, reward_type, reward_amount}, voir QUESTION_REWARD_TYPES
-    reward_amount}, voir QUESTION_REWARD_TYPES ci-dessus) — même esprit
+    ci-dessus) — même esprit que resolve_collision_rules.sanitize_collision_rules :
-    que resolve_collision_rules.sanitize_collision_rules : rejette tout
+    rejette tout élément invalide plutôt que de lever. Les lignes d'UN
-    élément invalide plutôt que de lever."""
+    dialogue embarqué dans une action "dialogue" (voir
-    result = {status: [] for status in QUEST_STATUS_CHOICES}
+    screens/rendering/collision_rules.py) : chaque occurrence de
-    if not isinstance(raw_dialogues, dict):
+    "Déclencher ce dialogue" porte le sien."""
-        return result
+    if not isinstance(raw_lines, list):
-    for status in QUEST_STATUS_CHOICES:
+        return []
-        raw_lines = raw_dialogues.get(status)
+    cleaned = [_sanitize_line(raw_line) for raw_line in raw_lines[:_MAX_LINES_PER_COLUMN]]
-        if not isinstance(raw_lines, list):
+    return [line for line in cleaned if line]
-            continue
+
-        cleaned = [_sanitize_line(raw_line) for raw_line in raw_lines[:_MAX_LINES_PER_COLUMN]]
+
-        result[status] = [line for line in cleaned if line]
+def sum_question_rewards(lines):
-    return result
+    """Somme des récompenses de toutes les questions ("❓ Question" ci-
+    dessus) d'UNE liste de répliques/questions — utilisée pour calculer le
+    score max possible du quiz à l'export SCORM, sur TOUTES les lignes de
+    TOUS les dialogues du jeu (voir screens.collect_all_dialogue_lines,
+    publish/build_scorm_package.py)."""
+    total = 0
+    for line in (lines or []):
+        if isinstance(line, dict) and line.get("type") == "question":
+            total += line.get("reward_amount", 0) or 0
+    return total

db/quests/constants.py

@@ -1,4 +0,0 @@
-QUEST_STATUS_CHOICES = ["nouvelle", "en_cours", "terminee"]
-QUEST_STATUS_LABELS = {"nouvelle": "Nouvelle", "en_cours": "En cours", "terminee": "Terminée"}
-QUEST_RESULT_CHOICES = ["reussi", "echoue"]
-QUEST_RESULT_LABELS = {"reussi": "Réussi", "echoue": "Échoué"}

db/quests/create_quest.py

@@ -1,18 +0,0 @@
-from ..connection import connect
-from .ensure_quests_schema import ensure_quests_schema
-from .get_quest import get_quest
-
-
-def create_quest(slug, title="Nouvelle quête"):
-    """Titre par défaut plutôt qu'un refus — créée d'un clic depuis la
-    liste (voir l'onglet "🗺️ Quêtes", templates/scene_edit.html) ou depuis l'assistant "+ Action"
-    de l'éditeur de collision (voir collision-rules-editor.js), avant
-    même que l'auteur ait choisi un titre."""
-    ensure_quests_schema(slug)
-    title = (title or "").strip() or "Nouvelle quête"
-    conn = connect(slug)
-    conn.execute("INSERT INTO _quests (title) VALUES (?)", (title,))
-    new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
-    conn.commit()
-    conn.close()
-    return get_quest(slug, new_id)

db/quests/delete_quest.py

@@ -1,10 +0,0 @@
-from ..connection import connect
-from .ensure_quests_schema import ensure_quests_schema
-
-
-def delete_quest(slug, quest_id):
-    ensure_quests_schema(slug)
-    conn = connect(slug)
-    conn.execute("DELETE FROM _quests WHERE id = ?", (quest_id,))
-    conn.commit()
-    conn.close()

db/quests/ensure_quests_schema.py

@@ -1,29 +0,0 @@
-from ..connection import connect
-
-
-def ensure_quests_schema(slug):
-    """Migration légère (même principe que ensure_custom_events_schema.py) :
-    crée _quests si absente. Une quête vit pour TOUT le jeu (pas par écran),
-    référencée par id technique depuis l'action "quete" d'une règle de
-    collision (voir screens/rendering/collision_rules.py, quete_id). Les
-    dialogues (voir static/js/quests/quest-editor.js — 3 colonnes
-    nouvelle/en_cours/terminee) sont stockés en JSON plutôt qu'une table à
-    part : jamais interrogés/filtrés côté SQL, toujours lus/réécrits en
-    bloc pour UNE quête à la fois (même convention que _scene_objects.attributes)."""
-    conn = connect(slug)
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS _quests (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            title TEXT NOT NULL,
-            objectif TEXT DEFAULT '',
-            recompense_score INTEGER DEFAULT 0,
-            status TEXT DEFAULT 'nouvelle',
-            resultat TEXT,
-            dialogues_json TEXT DEFAULT '{}',
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP
-        );
-        """
-    )
-    conn.commit()
-    conn.close()

db/quests/get_quest.py

@@ -1,11 +0,0 @@
-from ..connection import connect
-from .ensure_quests_schema import ensure_quests_schema
-from .list_quests import _row_to_quest
-
-
-def get_quest(slug, quest_id):
-    ensure_quests_schema(slug)
-    conn = connect(slug)
-    row = conn.execute("SELECT * FROM _quests WHERE id = ?", (quest_id,)).fetchone()
-    conn.close()
-    return _row_to_quest(row) if row else None

db/quests/list_quests.py

@@ -1,22 +0,0 @@
-import json
-
-from ..connection import connect
-from .ensure_quests_schema import ensure_quests_schema
-
-
-def _row_to_quest(row):
-    quest = dict(row)
-    try:
-        quest["dialogues"] = json.loads(quest.pop("dialogues_json") or "{}")
-    except (TypeError, ValueError):
-        quest["dialogues"] = {}
-        quest.pop("dialogues_json", None)
-    return quest
-
-
-def list_quests(slug):
-    ensure_quests_schema(slug)
-    conn = connect(slug)
-    rows = conn.execute("SELECT * FROM _quests ORDER BY created_at DESC, id DESC").fetchall()
-    conn.close()
-    return [_row_to_quest(r) for r in rows]

db/quests/reward_budget.py

@@ -1,15 +0,0 @@
-def quest_dialogues_total_reward(dialogues):
-    """Somme des récompenses de toutes les questions ("❓ Question", voir
-    sanitize_quest_dialogues.py), TOUTES colonnes/statuts confondus — une
-    quête n'a qu'UNE SEULE récompense totale (quest["recompense_score"]),
-    jamais une par statut. Utilisée pour empêcher d'enregistrer plus de
-    points répartis entre les questions que la quête n'en offre (voir
-    routes/quests/quest_dialogues.py et quest_update.py)."""
-    total = 0
-    for lines in (dialogues or {}).values():
-        if not isinstance(lines, list):
-            continue
-        for line in lines:
-            if isinstance(line, dict) and line.get("type") == "question":
-                total += line.get("reward_amount", 0) or 0
-    return total

db/quests/set_quest_dialogues.py

@@ -1,21 +0,0 @@
-import json
-
-from ..connection import connect
-from .ensure_quests_schema import ensure_quests_schema
-from .get_quest import get_quest
-from .sanitize_quest_dialogues import sanitize_quest_dialogues
-
-
-def set_quest_dialogues(slug, quest_id, raw_dialogues):
-    """Toujours les 3 colonnes ENTIÈRES (nouvelle/en_cours/terminee) en un
-    bloc — même convention "replace-all" que set_scene_object_collision_rules.py,
-    jamais une réplique isolée."""
-    ensure_quests_schema(slug)
-    if get_quest(slug, quest_id) is None:
-        return None
-    dialogues = sanitize_quest_dialogues(raw_dialogues)
-    conn = connect(slug)
-    conn.execute("UPDATE _quests SET dialogues_json = ? WHERE id = ?", (json.dumps(dialogues), quest_id))
-    conn.commit()
-    conn.close()
-    return dialogues

db/quests/update_quest.py

@@ -1,42 +0,0 @@
-from ..connection import connect
-from .constants import QUEST_STATUS_CHOICES, QUEST_RESULT_CHOICES
-from .ensure_quests_schema import ensure_quests_schema
-from .get_quest import get_quest
-
-
-def update_quest(slug, quest_id, fields):
-    """Met à jour uniquement les clés reconnues et valides de `fields` —
-    ignore tout le reste plutôt que de lever, même esprit que
-    sanitize_collision_rules (jamais confiance dans ce qu'envoie le
-    client). title vide => ignoré (garde l'ancien plutôt qu'un titre vide)."""
-    ensure_quests_schema(slug)
-    if get_quest(slug, quest_id) is None:
-        return None
-    updates = {}
-    if "title" in fields:
-        title = (fields["title"] or "").strip()
-        if title:
-            updates["title"] = title
-    if "objectif" in fields:
-        updates["objectif"] = (fields["objectif"] or "").strip()
-    if "recompense_score" in fields:
-        try:
-            updates["recompense_score"] = int(fields["recompense_score"])
-        except (TypeError, ValueError):
-            pass
-    if "status" in fields and fields["status"] in QUEST_STATUS_CHOICES:
-        updates["status"] = fields["status"]
-    if "resultat" in fields:
-        resultat = fields["resultat"]
-        if resultat in QUEST_RESULT_CHOICES:
-            updates["resultat"] = resultat
-        elif resultat is None:
-            updates["resultat"] = None
-    if not updates:
-        return get_quest(slug, quest_id)
-    conn = connect(slug)
-    set_clause = ", ".join(f"{key} = ?" for key in updates)
-    conn.execute(f"UPDATE _quests SET {set_clause} WHERE id = ?", (*updates.values(), quest_id))
-    conn.commit()
-    conn.close()
-    return get_quest(slug, quest_id)

publish/build_scorm_package.py

@@ -277,17 +277,18 @@ def build_scorm_zip(slug):
         else "static/js/play/offline/scorm-api.js"
     )
 
-    # Score max possible (voir db/quests/reward_budget.py) : sans lui, un
+    # Score max possible (voir db/dialogue_lines.py::sum_question_rewards) :
-    # LMS SCORM 1.2 n'a que cmi.core.score.raw (un total de points brut,
+    # sans lui, un LMS SCORM 1.2 n'a que cmi.core.score.raw (un total de
-    # sans barème) et l'affiche à tort avec un "%" — demande utilisateur
+    # points brut, sans barème) et l'affiche à tort avec un "%" — demande
-    # "5% pour 1.2 mais 100% pour 2004 avec 1 seule question, c'est un
+    # utilisateur "5% pour 1.2 mais 100% pour 2004 avec 1 seule question,
-    # défaut de la 1.2 qu'on ne peut pas régler ?". En fournissant aussi
+    # c'est un défaut de la 1.2 qu'on ne peut pas régler ?". En fournissant
-    # min/max (voir static/js/play/offline/scorm-api.js), le LMS peut
+    # aussi min/max (voir static/js/play/offline/scorm-api.js), le LMS peut
     # calculer raw/max lui-même, un vrai pourcentage au lieu du score brut
-    # mal étiqueté.
+    # mal étiqueté. Les dialogues vivent dans les règles de collision des
-    max_quiz_score = sum(
+    # objets de scène (voir screens/rendering/collision_rules.py::
-        db.quest_dialogues_total_reward(quest["dialogues"]) for quest in db.list_quests(slug)
+    # "dialogue".dialogue), retrouvés via screens.collect_all_dialogue_lines.
-    )
+    all_dialogue_lines = [line for lines in screens.collect_all_dialogue_lines(slug) for line in lines]
+    max_quiz_score = db.sum_question_rewards(all_dialogue_lines)
 
     # gameData.icon_data_uris (voir forgeRenderIcone,
     # static/js/play/offline/render-special-widgets.js) : ajouté au

routes/__init__.py

@@ -1 +1 @@
-from . import auth, games, screens, flow, uploads, play, animations, global_vars, publish, custom_events, flow_blocks, scenes, onboarding, quests
+from . import auth, games, screens, flow, uploads, play, animations, global_vars, publish, custom_events, flow_blocks, scenes, onboarding, triggers

routes/global_vars/create_global_var.py

@@ -7,12 +7,13 @@ from core.flask_app import app
 
 @app.route("/game/<slug>/variables/new", methods=["POST"])
 def create_global_var(slug):
-    """Depuis la page de gestion des variables (game_variables.html) —
+    """Depuis l'onglet "Variables" de l'éditeur de scène (screen_edit.html)
-    idempotent par nom (voir db.create_global_variable), donc sans risque en
+    — idempotent par nom (voir db.create_global_variable), donc sans
-    cas de double soumission."""
+    risque en cas de double soumission."""
     name = (request.form.get("name") or "").strip()
     var_type = request.form.get("type") or "texte"
     default_value = request.form.get("default_value") or ""
+    screen_id = request.form.get("screen_id", type=int)
     # État par joueur (Phase 1) : coché par défaut (une case DÉCOCHÉE
     # explicitement rend la variable partagée par tous les joueurs, voir
     # db/global_vars/create_global_variable.py) — absent du formulaire
@@ -20,4 +21,6 @@ def create_global_var(slug):
     per_player = request.form.get("per_player", "1") == "1"
     if name:
         db.create_global_variable(slug, name, var_type, default_value, per_player=per_player)
-    return redirect(url_for("game_dashboard", slug=slug, tab="variables"))
+    if screen_id:
+        return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="variables"))
+    return redirect(url_for("game_dashboard", slug=slug))

routes/global_vars/global_var_delete.py

@@ -1,4 +1,4 @@
-from flask import redirect, url_for
+from flask import request, redirect, url_for
 
 import db
 
@@ -7,5 +7,8 @@ from core.flask_app import app
 
 @app.route("/game/<slug>/variables/<int:var_id>/delete", methods=["POST"])
 def global_var_delete(slug, var_id):
+    screen_id = request.form.get("screen_id", type=int)
     db.delete_global_variable_by_id(slug, var_id)
-    return redirect(url_for("game_dashboard", slug=slug, tab="variables"))
+    if screen_id:
+        return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="variables"))
+    return redirect(url_for("game_dashboard", slug=slug))

routes/global_vars/global_var_edit.py

@@ -9,5 +9,8 @@ from core.flask_app import app
 def global_var_edit(slug, var_id):
     var_type = request.form.get("type") or "texte"
     value = request.form.get("value") or ""
+    screen_id = request.form.get("screen_id", type=int)
     db.update_global_variable(slug, var_id, var_type, value)
-    return redirect(url_for("game_dashboard", slug=slug, tab="variables"))
+    if screen_id:
+        return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="variables"))
+    return redirect(url_for("game_dashboard", slug=slug))

routes/quests/__init__.py

@@ -1 +0,0 @@
-from . import quests_list_json, quest_new, quest_update, quest_delete, quest_dialogues

routes/quests/quest_delete.py

@@ -1,11 +0,0 @@
-from flask import jsonify
-
-import db
-
-from core.flask_app import app
-
-
-@app.route("/game/<slug>/quests/<int:quest_id>/delete", methods=["POST"])
-def quest_delete(slug, quest_id):
-    db.delete_quest(slug, quest_id)
-    return jsonify({"ok": True})

routes/quests/quest_dialogues.py

@@ -1,34 +0,0 @@
-from flask import jsonify, request
-
-import db
-
-from core.flask_app import app
-
-
-@app.route("/game/<slug>/quests/<int:quest_id>/dialogues", methods=["POST"])
-def quest_dialogues(slug, quest_id):
-    """Toujours les 3 colonnes ENTIÈRES (voir db.set_quest_dialogues) —
-    le client (renderQuestDialogueColumns, quest-editor.js) poste l'objet
-    complet à chaque modification plutôt qu'une réplique isolée.
-
-    Refusé (400) si la somme des récompenses des questions ("❓ Question")
-    dépasse la récompense totale de la quête (recompense_score) — voir
-    db.quest_dialogues_total_reward. Validé ICI (avant persistance)
-    plutôt que dans db.set_quest_dialogues, pour renvoyer un message
-    d'erreur explicite au lieu d'enregistrer silencieusement un état
-    incohérent."""
-    quest = db.get_quest(slug, quest_id)
-    if quest is None:
-        return jsonify({"error": "quête introuvable"}), 404
-    body = request.get_json(silent=True) or {}
-    sanitized = db.sanitize_quest_dialogues(body.get("dialogues"))
-    allocated = db.quest_dialogues_total_reward(sanitized)
-    if allocated > quest["recompense_score"]:
-        return jsonify({
-            "error": (
-                f"La somme des récompenses des questions ({allocated} pts) dépasse "
-                f"la récompense totale de la quête ({quest['recompense_score']} pts)."
-            ),
-        }), 400
-    dialogues = db.set_quest_dialogues(slug, quest_id, body.get("dialogues"))
-    return jsonify({"dialogues": dialogues})

routes/quests/quest_new.py

@@ -1,12 +0,0 @@
-from flask import jsonify, request
-
-import db
-
-from core.flask_app import app
-
-
-@app.route("/game/<slug>/quests/new", methods=["POST"])
-def quest_new(slug):
-    body = request.get_json(silent=True) or {}
-    quest = db.create_quest(slug, body.get("title"))
-    return jsonify({"quest": quest})

routes/quests/quest_update.py

@@ -1,36 +0,0 @@
-from flask import jsonify, request
-
-import db
-
-from core.flask_app import app
-
-
-@app.route("/game/<slug>/quests/<int:quest_id>", methods=["POST"])
-def quest_update(slug, quest_id):
-    """Refusé (400) si "recompense_score" est abaissé SOUS le total déjà
-    réparti entre les questions ("❓ Question") du dialogue de cette
-    quête — voir db.quest_dialogues_total_reward, même contrainte que
-    routes/quests/quest_dialogues.py mais dans l'autre sens (ici c'est le
-    budget total qui bouge, pas la répartition)."""
-    body = request.get_json(silent=True) or {}
-    if "recompense_score" in body:
-        quest = db.get_quest(slug, quest_id)
-        if quest is None:
-            return jsonify({"error": "quête introuvable"}), 404
-        try:
-            new_score = int(body["recompense_score"])
-        except (TypeError, ValueError):
-            new_score = None
-        if new_score is not None:
-            allocated = db.quest_dialogues_total_reward(quest["dialogues"])
-            if new_score < allocated:
-                return jsonify({
-                    "error": (
-                        f"La récompense totale ({new_score} pts) est inférieure aux "
-                        f"{allocated} pts déjà répartis entre les questions du dialogue."
-                    ),
-                }), 400
-    quest = db.update_quest(slug, quest_id, body)
-    if quest is None:
-        return jsonify({"error": "quête introuvable"}), 404
-    return jsonify({"quest": quest})

routes/quests/quests_list_json.py

@@ -1,15 +0,0 @@
-from flask import jsonify
-
-import db
-
-from core.flask_app import app
-
-
-@app.route("/game/<slug>/quests/list.json")
-def quests_list_json(slug):
-    """Utilisé par l'assistant "+ Action" de l'éditeur de collision (voir
-    collision-rules-editor.js) pour lister les quêtes existantes sans
-    quitter la modale déjà ouverte (l'onglet "🗺️ Quêtes" lui-même reçoit
-    déjà sa liste via QUESTS_JSON, voir routes/scenes/scene_edit_view.py —
-    cette route ne sert qu'à la RAFRAÎCHIR depuis le contexte collision)."""
-    return jsonify({"quests": db.list_quests(slug)})

routes/scenes/__init__.py

@@ -6,9 +6,7 @@ from . import (
     scene_object_commands,
     scene_object_role,
     scene_object_collision,
-    scene_object_collision_rules,
     scene_object_name,
     scene_object_dialogue_box_style,
-    scene_collision_rule_objects,
     scene_object_names_list,
 )

routes/scenes/scene_collision_rule_objects.py

@@ -1,24 +0,0 @@
-from flask import jsonify
-
-import screens
-
-from core.flask_app import app
-
-from .collision_rule_objects import build_collision_rule_objects
-
-
-@app.route("/game/<slug>/screens/<int:screen_id>/collision-rule-objects", methods=["GET"])
-def scene_collision_rule_objects(slug, screen_id):
-    """Liste à jour des cartes "🧩 Collision" (voir COLLISION_RULE_OBJECTS,
-    templates/scene_edit.html) — appelée en AJAX après un ajout/suppression
-    d'objet, ou un changement de rôle/nom (voir static/js/scenes/
-    scene-editor.js) qui peut faire apparaître/disparaître un objet de
-    cette liste (rôle passé à/depuis "joueur", voir
-    build_collision_rule_objects) ou changer son libellé affiché (nom).
-    Recalculée entièrement plutôt que diffée : la liste reste petite (un
-    objet de scène par carte, jamais un "fond"/widget d'UI) et cette même
-    fonction est déjà appelée à chaque rendu complet de la page."""
-    objects = screens.list_scene_objects(slug, screen_id)
-    for o in objects:
-        o["rendered_html"] = screens.render_scene_object(o)
-    return jsonify(build_collision_rule_objects(objects))

routes/scenes/scene_edit_view.py

@@ -5,8 +5,6 @@ from flask import render_template, request, abort, g
 import db
 import screens
 
-from .collision_rule_objects import build_collision_rule_objects
-
 
 def render_scene_edit(slug, screen_id, game):
     """Vue de l'éditeur de scène 2D — appelée par routes/screens/
@@ -63,12 +61,6 @@ def render_scene_edit(slug, screen_id, game):
         o["id"]: screens.resolve_personnage_animations(o) for o in objects if o["kind"] == "personnage"
     }
 
-    # "🧩 Collision" — voir build_collision_rule_objects() (routes/scenes/
-    # collision_rule_objects.py, factorisé pour être réutilisé par
-    # l'endpoint AJAX scene_collision_rule_objects.py, appelé après ajout/
-    # suppression/changement de rôle ou de nom sans recharger la page).
-    collision_rule_objects = build_collision_rule_objects(objects)
-
     flow_blocks = screens.list_flow_blocks(slug, screen_id)
     flow_nodes = screens.list_flow_nodes(slug, screen_id)
     flow_edges = screens.list_flow_edges(slug, screen_id)
@@ -125,24 +117,15 @@ def render_scene_edit(slug, screen_id, game):
         flow_blocks_json=json.dumps(flow_blocks), blocks_view=blocks_view,
         animation_clips=animation_clips, animation_clips_json=json.dumps(animation_clips),
         animate_css_catalog=screens.ANIMATE_CSS_CATALOG, animate_css_labels_json=json.dumps(screens.ANIMATE_CSS_LABELS),
-        global_variables=global_variables,
+        global_variables=global_variables, global_variable_types=db.GLOBAL_VARIABLE_TYPES,
         custom_events=custom_events, custom_event_usages=custom_event_usages,
         custom_events_map_json=json.dumps(custom_events_map),
         definitions=db.list_definitions(slug),
         definitions_json=json.dumps({str(d["id"]): screens.data_definition_options(slug, d["id"]) for d in db.list_definitions(slug)}),
         definitions_names_json=json.dumps({d["id"]: d["name"] for d in db.list_definitions(slug)}),
-        collision_rule_objects_json=json.dumps(collision_rule_objects),
+        # "qui parle" dans un dialogue de déclencheur (voir "ℹ️
-        collision_action_types=screens.ACTION_TYPES, collision_trigger_types=screens.TRIGGER_TYPES,
+        # Informations", static/js/triggers/trigger-editor.js) : les noms
-        collision_default_perimetre_px=screens.DEFAULT_PERIMETRE_PX,
+        # donnés à N'IMPORTE QUEL objet de scène (personnage, décor,
-        # Éditeur de quêtes (voir db/quests/) : préchargées ici pour que
+        # fond), toutes scènes du jeu confondues.
-        # collisionRuleActionSummary (collision-rules-editor.js) affiche
-        # tout de suite le TITRE de la quête référencée par une règle
-        # existante, sans attendre l'ouverture de l'assistant "+ Action"
-        # (seul moment où questPickerHtml irait la chercher sinon).
-        quests_json=json.dumps(db.list_quests(slug)),
-        # "qui parle" dans le dialogue d'une quête (voir "ℹ️ Informations",
-        # static/js/quests/quest-editor.js) : les noms donnés à N'IMPORTE
-        # QUEL objet de scène (personnage, décor, fond), toutes scènes du
-        # jeu confondues.
         scene_object_names_json=json.dumps(screens.list_named_scene_object_names(slug)),
     )

routes/scenes/scene_object_collision_rules.py

@@ -1,21 +0,0 @@
-from flask import request, jsonify
-
-import screens
-
-from core.flask_app import app
-
-
-@app.route("/game/<slug>/scene-objects/<int:object_id>/collision-rules", methods=["POST"])
-def scene_object_collision_rules(slug, object_id):
-    """Liste complète des règles "déclencheur -> action" d'un objet (voir
-    "🧩 Collision" dans templates/scene_edit.html) — le client poste
-    toujours la liste ENTIÈRE (ajout/suppression déjà appliqués côté
-    client), jamais une règle isolée, même patron que
-    scene_object_commands.py pour "extra"."""
-    body = request.get_json(silent=True) or {}
-    obj = screens.get_scene_object(slug, object_id)
-    if not obj:
-        return jsonify({"error": "objet introuvable"}), 404
-    rules = screens.sanitize_collision_rules(body.get("rules"))
-    screens.set_scene_object_collision_rules(slug, object_id, rules)
-    return jsonify({"ok": True, "rules": rules})

routes/scenes/scene_object_names_list.py

@@ -9,12 +9,13 @@ from core.flask_app import app
 def scene_object_names_list(slug):
     """Noms d'objets de scène à jour, pour repeupler le sélecteur "qui
     parle" de l'éditeur de dialogue (voir SCENE_OBJECT_NAMES_JSON,
-    templates/scene_edit.html, questSpeakerOptions() dans static/js/
+    templates/scene_edit.html, triggerSpeakerOptions() dans static/js/
-    quests/quest-editor.js) — cette variable n'est posée qu'une fois au
+    triggers/trigger-editor.js) — cette variable n'est posée qu'une fois
-    chargement complet de la page (HORS de #builder3, jamais rafraîchie
+    au chargement complet de la page (HORS de #builder3, jamais
-    par une sélection d'objet sans rechargement, voir goToSelected()) :
+    rafraîchie par une sélection d'objet sans rechargement, voir
-    sans cet endpoint, renommer un personnage puis rouvrir la modale de
+    goToSelected()) : sans cet endpoint, renommer un personnage puis
-    dialogue dans la MÊME session ne faisait jamais apparaître son nouveau
+    rouvrir un dialogue de déclencheur dans la MÊME session ne faisait
-    nom, tant qu'aucun vrai rechargement de page n'avait eu lieu entre
+    jamais apparaître son nouveau nom, tant qu'aucun vrai rechargement de
-    temps — appelée en AJAX depuis saveSceneObjectName()."""
+    page n'avait eu lieu entre temps — appelée en AJAX depuis
+    saveSceneObjectName()."""
     return jsonify(screens.list_named_scene_object_names(slug))

routes/triggers/__init__.py

@@ -0,0 +1 @@
+from . import triggers

routes/triggers/triggers.py

@@ -0,0 +1,112 @@
+from flask import jsonify, request
+
+import screens
+
+from core.flask_app import app
+
+
+@app.route("/game/<slug>/triggers/objects-catalog", methods=["GET"])
+def triggers_objects_catalog(slug):
+    """Catalogue des objets de scène éligibles à un déclencheur, pour la
+    grille "choisis un objet" de la modale d'ajout (voir
+    screens.list_all_collision_objects)."""
+    return jsonify(screens.list_all_collision_objects(slug))
+
+
+@app.route("/game/<slug>/triggers", methods=["GET"])
+def triggers_get(slug):
+    """TOUS les déclencheurs du jeu (voir screens.list_all_triggers) — plus
+    de recherche inversée par quête, la logique est portée directement par
+    chaque déclencheur."""
+    return jsonify(screens.list_all_triggers(slug))
+
+
+@app.route("/game/<slug>/triggers", methods=["POST"])
+def triggers_add(slug):
+    """Ajoute un déclencheur sur l'objet choisi — body {object_id, rule},
+    `rule` construite par l'assistant "déclencheur -> action" (voir
+    openTriggerWizard, static/js/scenes/collision-rules-editor.js) :
+    n'importe quel type de déclencheur/action qu'il propose passe donc
+    déjà tel quel, sans changement à faire ici si de nouveaux types
+    apparaissent un jour. Même contrat "liste ENTIÈRE" que l'éditeur de
+    collision (routes/scenes/scene_object_collision_rules.py) : on
+    recharge les règles existantes de l'objet, on y ajoute la nouvelle, on
+    sauvegarde la liste complète."""
+    body = request.get_json(silent=True) or {}
+    try:
+        object_id = int(body.get("object_id"))
+    except (TypeError, ValueError):
+        return jsonify({"error": "object_id invalide"}), 400
+    obj = screens.get_scene_object(slug, object_id)
+    if obj is None:
+        return jsonify({"error": "objet introuvable"}), 404
+    new_rule = body.get("rule")
+    if not isinstance(new_rule, dict):
+        return jsonify({"error": "rule invalide"}), 400
+
+    rules = screens.resolve_collision_rules(obj)
+    rules.append(new_rule)
+    sanitized = screens.sanitize_collision_rules(rules)
+    screens.set_scene_object_collision_rules(slug, object_id, sanitized)
+    return jsonify({"ok": True})
+
+
+@app.route("/game/<slug>/triggers/<int:object_id>", methods=["DELETE"])
+def triggers_delete(slug, object_id):
+    """Retire TOUTES les règles de collision de CET objet — sans quête
+    pour distinguer "cette règle-ci" d'une autre, un objet ne porte de
+    toute façon en pratique qu'un seul déclencheur à la fois (posé par
+    l'assistant, jamais cumulé)."""
+    obj = screens.get_scene_object(slug, object_id)
+    if obj is None:
+        return jsonify({"error": "objet introuvable"}), 404
+    screens.set_scene_object_collision_rules(slug, object_id, [])
+    return jsonify({"ok": True})
+
+
+@app.route("/game/<slug>/triggers/<int:object_id>/dialogue", methods=["POST"])
+def trigger_dialogue_update(slug, object_id):
+    """Édition EN LIGNE des répliques d'UN dialogue précis (voir
+    screens/rendering/collision_rules.py::"dialogue".dialogue) — body
+    {dialogue_id, lines}. 404 si `dialogue_id` ne correspond à aucun
+    dialogue de CET objet (règle supprimée entre-temps, référence
+    orpheline)."""
+    obj = screens.get_scene_object(slug, object_id)
+    if obj is None:
+        return jsonify({"error": "objet introuvable"}), 404
+    body = request.get_json(silent=True) or {}
+    dialogue_id = body.get("dialogue_id")
+    if not isinstance(dialogue_id, str) or not dialogue_id.strip():
+        return jsonify({"error": "dialogue_id invalide"}), 400
+
+    rules = screens.resolve_collision_rules(obj)
+    if not screens.set_dialogue_lines_in_rules(rules, dialogue_id, body.get("lines")):
+        return jsonify({"error": "dialogue introuvable"}), 404
+    sanitized = screens.sanitize_collision_rules(rules)
+    screens.set_scene_object_collision_rules(slug, object_id, sanitized)
+    return jsonify({"ok": True})
+
+
+@app.route("/game/<slug>/triggers/<int:object_id>/append-action", methods=["POST"])
+def trigger_append_action(slug, object_id):
+    """"+ Ajouter une action" en bout de chaîne (voir screens/rendering/
+    collision_rules.py::set_then_action_in_rules, static/js/triggers/
+    trigger-editor.js) — body {after_id, action} : `after_id` est le
+    dialogue.id (feuille "dialogue") ou id (feuille "variable") de la
+    DERNIÈRE feuille d'une chaîne. 404 si `after_id` introuvable ou si
+    cette feuille a déjà un "then" (jamais écrasé par cette route — un
+    nouvel appel doit d'abord recharger la chaîne à jour)."""
+    obj = screens.get_scene_object(slug, object_id)
+    if obj is None:
+        return jsonify({"error": "objet introuvable"}), 404
+    body = request.get_json(silent=True) or {}
+    after_id = body.get("after_id")
+    if not isinstance(after_id, str) or not after_id.strip():
+        return jsonify({"error": "after_id invalide"}), 400
+
+    rules = screens.resolve_collision_rules(obj)
+    if not screens.set_then_action_in_rules(rules, after_id, body.get("action")):
+        return jsonify({"error": "action précédente introuvable ou déjà chaînée"}), 404
+    sanitized = screens.sanitize_collision_rules(rules)
+    screens.set_scene_object_collision_rules(slug, object_id, sanitized)
+    return jsonify({"ok": True})

screens/__init__.py

@@ -54,8 +54,7 @@ from .rendering.personnage_data import resolve_personnage_data, resolve_personna
 from .rendering.personnage_role import resolve_personnage_role, PERSONNAGE_ROLES, PERSONNAGE_ROLE_LABELS, DEFAULT_PERSONNAGE_ROLE
 from .rendering.collision_settings import resolve_collision_settings, DEFAULT_COLLISION_SETTINGS, COLLISION_SHAPES
 from .rendering.collision_rules import (
-    resolve_collision_rules, sanitize_collision_rules,
+    resolve_collision_rules, sanitize_collision_rules, set_dialogue_lines_in_rules, set_then_action_in_rules,
-    ACTION_TYPES, TRIGGER_TYPES, DEFAULT_PERIMETRE_PX,
 )
 from .rendering.personnage_commands import resolve_personnage_commands, DEFAULT_PERSONNAGE_COMMANDS, sanitize_extra_commands
 from .rendering.scene_object_names import list_named_scene_object_names
@@ -87,6 +86,11 @@ from .scenes.set_scene_object_collision_rules import set_scene_object_collision_
 from .scenes.set_scene_object_name import set_scene_object_name
 from .scenes.set_scene_object_dialogue_box_style import set_scene_object_dialogue_box_style
 from .scenes.render_scene_object import render_scene_object
+from .scenes.build_collision_rule_objects import build_collision_rule_objects
+from .rendering.trigger_graph import (
+    list_all_triggers, list_all_collision_objects, collect_all_dialogue_lines,
+    list_completable_dialogue_ids,
+)
 from .scenes.flow_palette import TRIGGER_EVENTS_2D, ACTION_TYPE_LABELS_2D, OBJECT_ACTION_PROPERTIES
 
 from .flow.ensure_flow_schema import ensure_flow_schema

screens/payload/full_game_payload.py

@@ -10,6 +10,7 @@ from ..rendering.personnage_role import resolve_personnage_role
 from ..rendering.collision_settings import resolve_collision_settings
 from ..rendering.collision_rules import resolve_collision_rules
 from ..rendering.dialogue_box_style import resolve_dialogue_box_style
+from ..rendering.trigger_graph import list_completable_dialogue_ids
 from ..scenes.list_scene_objects import list_scene_objects
 from ..scenes.render_scene_object import render_scene_object
 
@@ -156,18 +157,18 @@ def full_game_payload(slug, player_id=db.PLAYER_SHARED):
     # ci-dessus sont déjà indexés par id, jamais par nom.
     definition_names = {str(d["id"]): d["name"] for d in definitions}
 
-    # Quêtes (voir db/quests/, onglet "🗺️ Quêtes") : GAME-WIDE, jamais
+    # Déclencheurs "terminés" (voir screens/rendering/collision_rules.py::
-    # rattachées à un écran comme "elements" ci-dessus — nécessaires ici
+    # "dialogue".mark_completed) : GAME-WIDE, la liste des id de dialogue
-    # pour que static/js/play/dialogue-box-controller.js puisse retrouver,
+    # que le créateur a marqués comme concluant la partie — nécessaire à
-    # à l'exécution d'une action "quete" (collision-rules-controller.js),
+    # static/js/play/dialogue-box-controller.js::
-    # le dialogue de la colonne correspondant au STATUT ACTUEL de la
+    # forgeSyncAllDialoguesCompletionToScorm pour savoir quand TOUS ont
-    # quête (nouvelle/en_cours/terminee) sans aller-retour serveur.
+    # été joués, sans plus aucune notion de quête.
-    quests = db.list_quests(slug)
+    completable_dialogue_ids = list_completable_dialogue_ids(slug)
 
     return {
         "screens": payload_screens, "flows": flows, "animations": animations,
         "data": data, "fields_meta": fields_meta,
         "variables": variables, "personnage_animations": personnage_animations,
         "definition_names": definition_names,
-        "quests": quests,
+        "completable_dialogue_ids": completable_dialogue_ids,
     }

screens/rendering/collision_rules.py

@@ -1,42 +1,166 @@
 import json
 
-# Éditeur de collision (nouvel onglet dédié aux scènes 2D, voir
+from db.dialogue_lines import sanitize_dialogue_lines
-# templates/scene_edit.html) : chaque objet de scène (hors le personnage
+from screens.flow.constants import CONDITION_OPERATORS
-# "joueur" — voir screens/rendering/personnage_role.py — et un "fond",
+from screens.labels.data_operations import DATA_OPERATION_LABELS
-# jamais une cible/source de collision) porte une LISTE de règles
+
-# "déclencheur -> action", construites carte par carte dans l'éditeur.
+# Éditeur de déclencheurs (voir static/js/triggers/trigger-editor.js::
+# openTriggerWizard et static/js/scenes/collision-rule-wizard.js) : chaque
+# objet de scène (hors le personnage "joueur" — voir screens/rendering/
+# personnage_role.py — et un "fond", jamais une cible/source de collision)
+# porte une LISTE de règles "déclencheur -> action".
 #
 # Déclencheur : "collision" (chevauchement direct, voir
-# static/js/play/conditions.js::forgeShapesOverlap) ou "perimetre" (le
+# static/js/play/conditions.js::forgeShapesOverlap) — seul déclencheur
-# joueur entre dans un rayon de `perimetre_px` pixels autour de l'objet).
+# encore proposé ("perimetre" retiré, ne servait à rien pour l'instant,
+# demande explicite).
 #
-# Action (une seule par règle) :
+# Action :
-#   - "quete"     : quete_id (id technique d'une quête — voir db/quests/,
+#   - "dialogue"  : la logique n'est plus portée par une "quête" mais
-#                   choisie/créée via l'assistant "+ Action" qui ouvre
+#                   DIRECTEMENT par le déclencheur — cette action EST un
-#                   directement l'éditeur de quête, static/js/quests/
+#                   dialogue, pas une référence à autre chose. `dialogue`
-#                   quest-editor.js) — une quête inexistante/supprimée
+#                   (optionnel) : {id, lines} — `id` généré côté client
-#                   depuis reste une référence orpheline plutôt qu'une
+#                   (voir static/js/scenes/collision-rules-editor.js),
-#                   contrainte SQL, comme le reste de ce moteur (voir
+#                   `lines` une liste de répliques/questions (voir
-#                   evenement_id ci-dessous, même principe).
+#                   db/dialogue_lines.py) — chaque occurrence de
-#   - "attaque"   : joue la pose "attack" du personnage si disponible (voir
+#                   "Déclencher ce dialogue" (directe, sous "interagir",
-#                   personnage-controller.js) — pas de système de combat
+#                   ou dans une branche de "condition") porte SON PROPRE
-#                   (dégâts/PV...) pour l'instant, effet visuel seul.
+#                   dialogue, édité en ligne dans l'onglet "Déclencheurs".
-#   - "evenement" : evenement_id — réutilise TEL QUEL le système
+#                   `mark_completed` (optionnel, bool) : le créateur
-#                   d'événements personnalisés existant (db.list_custom_events,
+#                   marque explicitement ce déclencheur comme "terminé"
-#                   window.dispatchGameEvent), la logique de flow d'un écran
+#                   une fois ce dialogue joué (voir static/js/play/
-#                   document peut donc déjà écouter ce déclenchement.
+#                   dialogue-box-controller.js::
-#   - "interagir" : affiche "Appuie sur [touche]" (la touche "interagir" du
+#                   forgeSyncAllDialoguesCompletionToScorm).
-#                   joueur, voir personnage_commands.py) tant que la
+#   - "variable"  : modifie une variable globale — MÊME vocabulaire que
-#                   collision/le périmètre est actif, puis exécute
+#                   l'action "Modifier une variable" du graphe de logique
-#                   `sub_action` (même forme qu'une action, SAUF
+#                   document (voir screens/data_actions/apply_variable_action.py,
-#                   "interagir" à nouveau — UN seul niveau d'imbrication,
+#                   screens/labels/data_operations.py::DATA_OPERATION_LABELS,
-#                   pas une récursion illimitée) à l'appui de la touche.
+#                   réutilisé tel quel plutôt que réinventé) :
-ACTION_TYPES = ["quete", "attaque", "evenement", "interagir"]
+#                   `target_variable` (nom), `data_operation` (une clé de
-TRIGGER_TYPES = ["collision", "perimetre"]
+#                   DATA_OPERATION_LABELS), `data_value` (optionnel, absent
-DEFAULT_PERIMETRE_PX = 5
+#                   pour definir_bool_vrai/definir_bool_faux/basculer_bool
+#                   qui n'ont besoin d'aucune valeur). `id` généré côté
+#                   client, comme `dialogue.id` — sert à adresser CETTE
+#                   feuille précise pour y attacher un "then" plus tard
+#                   (voir set_then_action_in_rules).
+#   - "interagir" : affiche "Appuie sur [touche]" (la touche "interagir"
+#                   du joueur, voir personnage_commands.py) tant que la
+#                   collision est active, puis exécute `sub_action` (même
+#                   forme qu'une action, SAUF "interagir" à nouveau — UN
+#                   seul niveau d'imbrication, pas une récursion illimitée)
+#                   à l'appui de la touche.
+#   - "condition" : Si <variable> <opérateur> <valeur> (voir
+#                   screens/flow/constants.py::CONDITION_OPERATORS, même
+#                   vocabulaire que le nœud Condition de l'éditeur de
+#                   logique) -> exécute `si_vrai` ou `si_faux` (chacun soit
+#                   None — "ne rien faire", soit une FEUILLE — "dialogue"
+#                   ou "variable", voir maquette validée, JAMAIS une
+#                   nouvelle "interagir"/"condition" imbriquée : une
+#                   branche reste une feuille).
+#
+# CHAÎNAGE : une feuille ("dialogue" ou "variable") peut porter un champ
+# optionnel "then" — l'action suivante à exécuter une fois celle-ci
+# terminée, elle-même une feuille, qui peut à son tour avoir un "then"
+# (borné par _MAX_THEN_CHAIN) — demande explicite : "pouvoir modifier un
+# déclencheur pour lui ajouter des actions" (plusieurs actions chaînées,
+# pas juste remplacer l'action actuelle).
+#
+# ("attaque"/"evenement" retirés — ne servaient à rien pour l'instant,
+# demande explicite.)
+ACTION_TYPES = ["dialogue", "variable", "interagir", "condition"]
+LEAF_ACTION_TYPES = ("dialogue", "variable")
+TRIGGER_TYPES = ["collision"]
+CONDITION_OPERATOR_KEYS = {key for key, _label in CONDITION_OPERATORS}
 # Profondeur max d'imbrication ("interagir" -> sous-action) — évite une
 # structure sans fin construite par un JSON posté à la main.
 _MAX_ACTION_DEPTH = 2
+# Longueur max d'une chaîne de "then" — même esprit que _MAX_ACTION_DEPTH.
+_MAX_THEN_CHAIN = 4
+
+
+_MAX_ACTION_ID_LENGTH = 40
+# Opérations qui n'ont besoin d'AUCUNE valeur (voir screens/labels/
+# data_operations.py::DATA_OPERATIONS) — data_value est toujours omis
+# pour celles-ci, quoi que le client envoie (même logique que
+# static/js/scenes/collision-rules-editor.js::COLLISION_NO_VALUE_OPERATIONS,
+# qui masque le champ correspondant côté formulaire).
+_NO_VALUE_OPERATIONS = ("definir_bool_vrai", "definir_bool_faux", "basculer_bool")
+
+
+def _sanitize_dialogue(raw_dialogue):
+    if not isinstance(raw_dialogue, dict):
+        return None
+    dialogue_id = raw_dialogue.get("id")
+    if not isinstance(dialogue_id, str) or not dialogue_id.strip():
+        return None
+    return {
+        "id": dialogue_id.strip()[:_MAX_ACTION_ID_LENGTH],
+        "lines": sanitize_dialogue_lines(raw_dialogue.get("lines")),
+    }
+
+
+def _sanitize_dialogue_action(raw_action):
+    action = {"type": "dialogue"}
+    dialogue = _sanitize_dialogue(raw_action.get("dialogue"))
+    if dialogue:
+        action["dialogue"] = dialogue
+    if raw_action.get("mark_completed") is True:
+        action["mark_completed"] = True
+    return action
+
+
+def _sanitize_variable_action(raw_action):
+    target_variable = raw_action.get("target_variable")
+    if not isinstance(target_variable, str) or not target_variable.strip():
+        return None
+    data_operation = raw_action.get("data_operation")
+    if data_operation not in DATA_OPERATION_LABELS:
+        return None
+    action = {"type": "variable", "target_variable": target_variable.strip(), "data_operation": data_operation}
+    action_id = raw_action.get("id")
+    if isinstance(action_id, str) and action_id.strip():
+        action["id"] = action_id.strip()[:_MAX_ACTION_ID_LENGTH]
+    if data_operation not in _NO_VALUE_OPERATIONS:
+        raw_value = raw_action.get("data_value")
+        if isinstance(raw_value, str) and raw_value.strip():
+            action["data_value"] = raw_value.strip()
+        elif isinstance(raw_value, (int, float)) and not isinstance(raw_value, bool):
+            action["data_value"] = str(raw_value)
+    return action
+
+
+def _sanitize_leaf_action(raw_action, depth=1):
+    """Sanitize une FEUILLE ("dialogue" ou "variable") et son éventuelle
+    chaîne "then" (bornée à _MAX_THEN_CHAIN) — utilisée partout où une
+    feuille est attendue : action de premier niveau, sous "interagir", ou
+    branche Vrai/Faux de "condition"."""
+    if not isinstance(raw_action, dict):
+        return None
+    action_type = raw_action.get("type")
+    if action_type == "dialogue":
+        action = _sanitize_dialogue_action(raw_action)
+    elif action_type == "variable":
+        action = _sanitize_variable_action(raw_action)
+    else:
+        return None
+    if not action:
+        return None
+    if depth < _MAX_THEN_CHAIN:
+        then_action = _sanitize_leaf_action(raw_action.get("then"), depth=depth + 1)
+        if then_action:
+            action["then"] = then_action
+    return action
+
+
+def _sanitize_condition_branch(raw_branch):
+    """Une branche Vrai/Faux de "condition" : soit None ("ne rien
+    faire", jamais un dict vide), soit une FEUILLE ("dialogue" ou
+    "variable", éventuellement chaînée via "then") — jamais "interagir"/
+    "condition" à nouveau, pour garder la structure bornée (voir maquette
+    validée : chaque branche n'a que ces choix)."""
+    if raw_branch is None:
+        return None
+    return _sanitize_leaf_action(raw_branch)
 
 
 def _sanitize_action(raw_action, depth=1):
@@ -47,31 +171,33 @@ def _sanitize_action(raw_action, depth=1):
         return None
     if action_type == "interagir" and depth >= _MAX_ACTION_DEPTH:
         return None  # un seul niveau d'imbrication autorisé
-    action = {"type": action_type}
+    if action_type in LEAF_ACTION_TYPES:
-    if action_type == "quete":
+        return _sanitize_leaf_action(raw_action)
-        try:
+    if action_type == "interagir":
-            action["quete_id"] = int(raw_action.get("quete_id"))
-        except (TypeError, ValueError):
-            return None
-    elif action_type == "evenement":
-        try:
-            action["evenement_id"] = int(raw_action.get("evenement_id"))
-        except (TypeError, ValueError):
-            return None
-    elif action_type == "interagir":
         sub_action = _sanitize_action(raw_action.get("sub_action"), depth=depth + 1)
         if not sub_action:
             return None
-        action["sub_action"] = sub_action
+        return {"type": "interagir", "sub_action": sub_action}
-    # "attaque" : aucun champ supplémentaire.
+    # "condition"
-    return action
+    variable = (raw_action.get("variable") or "").strip()
+    operateur = raw_action.get("operateur")
+    if not variable or operateur not in CONDITION_OPERATOR_KEYS:
+        return None
+    return {
+        "type": "condition",
+        "variable": variable,
+        "operateur": operateur,
+        "valeur": str(raw_action.get("valeur") if raw_action.get("valeur") is not None else ""),
+        "si_vrai": _sanitize_condition_branch(raw_action.get("si_vrai")),
+        "si_faux": _sanitize_condition_branch(raw_action.get("si_faux")),
+    }
 
 
 def sanitize_collision_rules(raw_rules):
     """Valide/nettoie une liste de règles postée par le client (voir
-    routes/scenes/scene_object_collision_rules.py) — une règle invalide
+    routes/triggers/) — une règle invalide (déclencheur/action inconnus,
-    (déclencheur/action inconnus, imbrication trop profonde...) est
+    imbrication trop profonde...) est IGNORÉE plutôt que de faire planter
-    IGNORÉE plutôt que de faire planter la sauvegarde entière."""
+    la sauvegarde entière."""
     if not isinstance(raw_rules, list):
         return []
     cleaned = []
@@ -84,16 +210,96 @@ def sanitize_collision_rules(raw_rules):
         action = _sanitize_action(raw_rule.get("action"))
         if not action:
             continue
-        rule = {"trigger": trigger, "action": action}
+        cleaned.append({"trigger": trigger, "action": action})
-        if trigger == "perimetre":
-            try:
-                rule["perimetre_px"] = max(1, float(raw_rule.get("perimetre_px", DEFAULT_PERIMETRE_PX)))
-            except (TypeError, ValueError):
-                rule["perimetre_px"] = DEFAULT_PERIMETRE_PX
-        cleaned.append(rule)
     return cleaned
 
 
+def _apply_dialogue_lines(action, dialogue_id, lines):
+    if not isinstance(action, dict):
+        return False
+    action_type = action.get("type")
+    if action_type == "dialogue":
+        dialogue = action.get("dialogue")
+        if isinstance(dialogue, dict) and dialogue.get("id") == dialogue_id:
+            action["dialogue"] = {"id": dialogue_id, "lines": lines}
+            return True
+        return _apply_dialogue_lines(action.get("then"), dialogue_id, lines)
+    if action_type == "variable":
+        return _apply_dialogue_lines(action.get("then"), dialogue_id, lines)
+    if action_type == "interagir":
+        return _apply_dialogue_lines(action.get("sub_action"), dialogue_id, lines)
+    if action_type == "condition":
+        return (
+            _apply_dialogue_lines(action.get("si_vrai"), dialogue_id, lines)
+            or _apply_dialogue_lines(action.get("si_faux"), dialogue_id, lines)
+        )
+    return False
+
+
+def set_dialogue_lines_in_rules(rules, dialogue_id, raw_lines):
+    """Met à jour EN PLACE les répliques du dialogue `dialogue_id`,
+    où qu'il se trouve dans l'arbre d'action d'une des règles (direct,
+    chaîné via "then", sous "interagir", ou dans une branche de
+    "condition") — utilisé par routes/triggers/ pour l'édition en ligne
+    d'un dialogue depuis l'onglet "Déclencheurs". Retourne False sans
+    rien modifier si `dialogue_id` n'existe dans aucune règle (référence
+    orpheline, ex. règle supprimée entre-temps)."""
+    lines = sanitize_dialogue_lines(raw_lines)
+    for rule in rules:
+        if _apply_dialogue_lines(rule.get("action"), dialogue_id, lines):
+            return True
+    return False
+
+
+def _leaf_id(action):
+    if action.get("type") == "dialogue":
+        dialogue = action.get("dialogue")
+        return dialogue.get("id") if isinstance(dialogue, dict) else None
+    if action.get("type") == "variable":
+        return action.get("id")
+    return None
+
+
+def _apply_then_action(action, leaf_id, then_action):
+    if not isinstance(action, dict):
+        return False
+    action_type = action.get("type")
+    if action_type in LEAF_ACTION_TYPES:
+        if _leaf_id(action) == leaf_id:
+            if "then" in action:
+                return False  # jamais écraser un chaînage déjà posé
+            action["then"] = then_action
+            return True
+        return _apply_then_action(action.get("then"), leaf_id, then_action)
+    if action_type == "interagir":
+        return _apply_then_action(action.get("sub_action"), leaf_id, then_action)
+    if action_type == "condition":
+        return (
+            _apply_then_action(action.get("si_vrai"), leaf_id, then_action)
+            or _apply_then_action(action.get("si_faux"), leaf_id, then_action)
+        )
+    return False
+
+
+def set_then_action_in_rules(rules, leaf_id, raw_then_action):
+    """Attache EN PLACE une NOUVELLE action `then` sur la feuille
+    ("dialogue" ou "variable") identifiée par `leaf_id` (dialogue.id pour
+    une feuille dialogue, id pour une feuille variable) — n'importe où
+    dans l'arbre d'action d'une des règles. Utilisé par routes/triggers/
+    pour "+ Ajouter une action" en bout de chaîne (voir static/js/triggers/
+    trigger-editor.js). Retourne False sans rien modifier si `leaf_id`
+    est introuvable, OU si la feuille trouvée a DÉJÀ un "then" (on
+    n'écrase jamais un chaînage existant par cette route — seulement
+    ajouter à la fin réelle de la chaîne)."""
+    then_action = _sanitize_leaf_action(raw_then_action)
+    if not then_action:
+        return False
+    for rule in rules:
+        if _apply_then_action(rule.get("action"), leaf_id, then_action):
+            return True
+    return False
+
+
 def resolve_collision_rules(obj):
     """Décode attributes._collision_rules en liste Python, jamais None —
     un attribut absent/corrompu retombe sur aucune règle (comportement

screens/rendering/dialogue_box_style.py

@@ -3,7 +3,7 @@ import json
 # Widget d'interface "💬 Boîte de dialogue" (voir "🖥️ Interface",
 # templates/scene_edit.html, screens/scenes/add_scene_object.py kind=
 # "dialogue_box") : affiche AUTOMATIQUEMENT, en jeu, la réplique en cours
-# d'une quête déclenchée par une règle de collision "quete" (voir
+# d'un dialogue déclenché par une règle de collision "dialogue" (voir
 # static/js/play/dialogue-box-controller.js) — header (nom du
 # personnage qui parle), corps (texte), pied (bouton "Suivant"),
 # entièrement stylisable par l'auteur.

screens/rendering/scene_object_names.py

@@ -11,10 +11,10 @@ _EXCLUDED_KINDS = {"dialogue_box"}
 def list_named_scene_object_names(slug):
     """Noms distincts de tous les objets de scène nommés (voir "ℹ️
     Informations", templates/scene_edit.html) — n'importe quel kind
-    (personnage, décor, fond), toutes scènes 2D du jeu confondues : une
+    (personnage, décor, fond), toutes scènes 2D du jeu confondues : un
-    quête (voir db/quests/) est GAME-WIDE, son dialogue peut donc mettre
+    déclencheur est GAME-WIDE, son dialogue peut donc mettre en scène un
-    en scène un objet posé sur une autre scène que celle où la règle de
+    objet posé sur une autre scène que celle où la règle de collision se
-    collision se déclenche. Ordre alphabétique, jamais de doublon."""
+    déclenche. Ordre alphabétique, jamais de doublon."""
     names = set()
     for s in list_screens(slug):
         if s["kind"] != "jeu_2d":

screens/rendering/trigger_graph.py

@@ -0,0 +1,199 @@
+def _game_objects_with_thumbnails(slug, screens_mod):
+    """Objets de TOUTES les scènes "jeu_2d" du jeu (contrairement à
+    screens.list_scene_objects, qui ne prend qu'un screen_id) —
+    rendered_html ajouté comme l'exigent screens.build_collision_rule_objects
+    (voir routes/scenes/scene_edit_view.py pour le même patron, une seule
+    scène)."""
+    result = []
+    for s in screens_mod.list_screens(slug):
+        if s["kind"] != "jeu_2d":
+            continue
+        objects = screens_mod.list_scene_objects(slug, s["id"])
+        for o in objects:
+            o["rendered_html"] = screens_mod.render_scene_object(o)
+            o["screen_id"] = s["id"]
+            o["screen_name"] = s["name"]
+        result.extend(objects)
+    return result
+
+
+def _describe_leaf(action):
+    """Une seule feuille ("dialogue" ou "variable", voir
+    screens/rendering/collision_rules.py) décrite pour l'affichage,
+    SANS son éventuel "then" (voir _describe_chain, qui aplatit la
+    chaîne complète)."""
+    if action.get("type") == "dialogue":
+        return {"type": "dialogue", "dialogue": action.get("dialogue")}
+    return {
+        "type": "variable",
+        "id": action.get("id"),
+        "target_variable": action.get("target_variable"),
+        "data_operation": action.get("data_operation"),
+        "data_value": action.get("data_value"),
+    }
+
+
+def _describe_chain(action):
+    """Aplatit une feuille + ses "then" successifs en une LISTE, dans
+    l'ordre d'exécution — voir maquette validée ("plusieurs actions
+    chaînées"). Liste vide si `action` n'est ni "dialogue" ni "variable"."""
+    chain = []
+    node = action
+    while isinstance(node, dict) and node.get("type") in ("dialogue", "variable"):
+        chain.append(_describe_leaf(node))
+        node = node.get("then")
+    return chain
+
+
+def _branch_info(branch):
+    if not isinstance(branch, dict) or branch.get("type") not in ("dialogue", "variable"):
+        return None
+    return {"chain": _describe_chain(branch)}
+
+
+def _resolve_action_trigger(action, has_interagir=False):
+    """Décrit ENTIÈREMENT un arbre d'action (voir screens/rendering/
+    collision_rules.py) pour l'affichage dans l'onglet "Déclencheurs" —
+    chaque feuille ("dialogue"/"variable") affiche DIRECTEMENT son propre
+    contenu, où qu'elle soit dans l'arbre (y compris CHAQUE branche d'une
+    "condition", indépendamment l'une de l'autre), et sa chaîne "then"
+    complète (voir _describe_chain). Retourne {has_interagir, chain,
+    condition} — `chain` est une LISTE (jamais None, vide si l'action ne
+    se termine par aucune feuille reconnue) ; `condition` est None sauf
+    pour une action "condition", auquel cas il porte {variable, operateur,
+    valeur, si_vrai, si_faux} où si_vrai/si_faux valent chacun None ("ne
+    rien faire") ou {chain: [...]}."""
+    if not isinstance(action, dict):
+        return {"has_interagir": has_interagir, "chain": [], "condition": None}
+    action_type = action.get("type")
+    if action_type in ("dialogue", "variable"):
+        return {"has_interagir": has_interagir, "chain": _describe_chain(action), "condition": None}
+    if action_type == "interagir":
+        return _resolve_action_trigger(action.get("sub_action") or {}, has_interagir=True)
+    if action_type == "condition":
+        return {
+            "has_interagir": has_interagir, "chain": [],
+            "condition": {
+                "variable": action.get("variable"), "operateur": action.get("operateur"),
+                "valeur": action.get("valeur"),
+                "si_vrai": _branch_info(action.get("si_vrai")),
+                "si_faux": _branch_info(action.get("si_faux")),
+            },
+        }
+    return {"has_interagir": has_interagir, "chain": [], "condition": None}
+
+
+def list_all_triggers(slug):
+    """TOUS les déclencheurs du jeu, un par occurrence de "À la collision"
+    posée sur un objet de scène — remplace l'ancienne recherche inversée
+    par quête : plus de filtrage par id, chaque déclencheur affiche
+    directement sa propre logique (voir onglet "Déclencheurs",
+    static/js/triggers/trigger-editor.js)."""
+    import screens as screens_mod
+
+    objects = _game_objects_with_thumbnails(slug, screens_mod)
+    rule_objects = screens_mod.build_collision_rule_objects(objects)
+
+    result = []
+    for obj in rule_objects:
+        for rule in obj["rules"]:
+            info = _resolve_action_trigger(rule["action"])
+            result.append({
+                "object_id": obj["id"],
+                "object_name": obj["name"],
+                "thumbnail_html": obj["thumbnail_html"],
+                "has_interagir": info["has_interagir"],
+                "trigger": rule["trigger"],
+                "condition": info["condition"],
+                "chain": info["chain"],
+            })
+    return result
+
+
+def _collect_dialogue_lines_from_action(action, acc):
+    if not isinstance(action, dict):
+        return
+    action_type = action.get("type")
+    if action_type == "dialogue":
+        dialogue = action.get("dialogue")
+        if isinstance(dialogue, dict):
+            acc.append(dialogue.get("lines") or [])
+        _collect_dialogue_lines_from_action(action.get("then"), acc)
+    elif action_type == "variable":
+        _collect_dialogue_lines_from_action(action.get("then"), acc)
+    elif action_type == "interagir":
+        _collect_dialogue_lines_from_action(action.get("sub_action"), acc)
+    elif action_type == "condition":
+        _collect_dialogue_lines_from_action(action.get("si_vrai"), acc)
+        _collect_dialogue_lines_from_action(action.get("si_faux"), acc)
+
+
+def collect_all_dialogue_lines(slug):
+    """Toutes les répliques/questions de TOUS les dialogues embarqués dans
+    les règles de collision de TOUS les objets de scène du jeu (voir
+    screens/rendering/collision_rules.py::"dialogue".dialogue), y compris
+    au fil d'une chaîne "then" — une liste de listes de lignes (une par
+    dialogue trouvé), jamais fusionnée ici. Utilisée pour calculer le
+    score max possible du quiz à l'export SCORM (voir
+    publish/build_scorm_package.py)."""
+    import screens as screens_mod
+
+    acc = []
+    for s in screens_mod.list_screens(slug):
+        if s["kind"] != "jeu_2d":
+            continue
+        for obj in screens_mod.list_scene_objects(slug, s["id"]):
+            for rule in screens_mod.resolve_collision_rules(obj):
+                _collect_dialogue_lines_from_action(rule.get("action"), acc)
+    return acc
+
+
+def _collect_completable_ids_from_action(action, acc):
+    if not isinstance(action, dict):
+        return
+    action_type = action.get("type")
+    if action_type == "dialogue":
+        dialogue = action.get("dialogue")
+        if action.get("mark_completed") and isinstance(dialogue, dict) and dialogue.get("id"):
+            acc.append(dialogue["id"])
+        _collect_completable_ids_from_action(action.get("then"), acc)
+    elif action_type == "variable":
+        _collect_completable_ids_from_action(action.get("then"), acc)
+    elif action_type == "interagir":
+        _collect_completable_ids_from_action(action.get("sub_action"), acc)
+    elif action_type == "condition":
+        _collect_completable_ids_from_action(action.get("si_vrai"), acc)
+        _collect_completable_ids_from_action(action.get("si_faux"), acc)
+
+
+def list_completable_dialogue_ids(slug):
+    """Tous les id de dialogue du jeu dont l'action porte
+    `mark_completed` (voir screens/rendering/collision_rules.py), y
+    compris au fil d'une chaîne "then" — utilisée par static/js/play/
+    dialogue-box-controller.js::forgeSyncAllDialoguesCompletionToScorm
+    pour savoir quand la partie est terminée (TOUS joués), sans plus
+    aucune notion de quête."""
+    import screens as screens_mod
+
+    acc = []
+    for s in screens_mod.list_screens(slug):
+        if s["kind"] != "jeu_2d":
+            continue
+        for obj in screens_mod.list_scene_objects(slug, s["id"]):
+            for rule in screens_mod.resolve_collision_rules(obj):
+                _collect_completable_ids_from_action(rule.get("action"), acc)
+    return acc
+
+
+def list_all_collision_objects(slug):
+    """Catalogue de TOUS les objets éligibles à une règle de collision,
+    toutes scènes "jeu_2d" confondues — pour peupler le sélecteur d'objet
+    de la modale d'ajout de déclencheur (voir routes/triggers/)."""
+    import screens as screens_mod
+
+    objects = _game_objects_with_thumbnails(slug, screens_mod)
+    rule_objects = screens_mod.build_collision_rule_objects(objects)
+    return [
+        {"id": o["id"], "name": o["name"], "kind": o["kind"], "thumbnail_html": o["thumbnail_html"]}
+        for o in rule_objects
+    ]

screens/scenes/build_collision_rule_objects.py

@@ -10,9 +10,11 @@ def build_collision_rule_objects(objects):
     TOUJOURS les AUTRES objets qui réagissent à SA présence, voir
     screens/rendering/collision_rules.py) — factorisé ici plutôt que
     dupliqué : utilisé au premier rendu de la page (routes/scenes/
-    scene_edit_view.py) ET par l'endpoint AJAX ci-dessous (appelé après
+    scene_edit_view.py), par l'endpoint AJAX scene_collision_rule_objects.py
-    ajout/suppression/changement de rôle ou de nom, voir static/js/scenes/
+    (appelé après ajout/suppression/changement de rôle ou de nom, voir
-    scene-editor.js) pour reconstruire la liste SANS recharger la page.
+    static/js/scenes/scene-editor.js) ET par le listage de TOUS les
+    déclencheurs du jeu (screens/rendering/trigger_graph.py) — vit dans
+    screens/ (pas routes/) pour être appelable depuis les deux.
 
     `objects` doit déjà porter "rendered_html" (voir
     screens.render_scene_object) sur chaque élément.

screens/scenes/render_scene_object.py

@@ -47,7 +47,7 @@ def render_scene_object(obj):
         # body/footer sont remplis EN JEU (data-dialogue-role sert de
         # sélecteur), masqué par défaut au jeu (voir static/style.css,
         # `.playScreen .dialogueBoxWidget`) jusqu'à ce qu'une règle de
-        # collision "quete" ait un dialogue à afficher. Toujours VISIBLE
+        # collision "dialogue" ait un dialogue à afficher. Toujours VISIBLE
         # dans l'éditeur (avec un texte d'exemple) pour pouvoir le
         # positionner/styliser.
         style = resolve_dialogue_box_style(obj)

screens/scenes/set_scene_object_name.py

@@ -9,8 +9,8 @@ def set_scene_object_name(slug, object_id, name):
     partout ailleurs, mais jamais éditable avant le panneau "ℹ️
     Informations", templates/scene_edit.html). Pour un personnage, ce nom
     est aussi celui proposé comme "qui parle" dans l'éditeur de dialogue
-    de quête (voir screens/rendering/scene_object_names.py, static/js/
+    d'un déclencheur (voir screens/rendering/scene_object_names.py,
-    quests/quest-editor.js)."""
+    static/js/triggers/trigger-editor.js)."""
     ensure_scene_schema(slug)
     conn = db.connect(slug)
     conn.execute("UPDATE _scene_objects SET name = ? WHERE id = ?", ((name or "").strip() or None, object_id))

static/js/play/__tests__/collision-dialogue-integration.test.js

@@ -1,11 +1,12 @@
-// Bout en bout : une règle de collision "quete" doit réellement faire
+// Bout en bout : une règle de collision "dialogue" doit réellement faire
 // apparaître/avancer/disparaître la boîte de dialogue posée sur la scène
 // — pas seulement chaque brique testée isolément (voir
 // collision-rules-controller.test.js et dialogue-box-controller.test.js).
 // Reproduit le scénario signalé : un objet "Mr. Pinguin" avec une règle
-// "à la collision -> déclencher la quête « test »", une quête au statut
+// "à la collision -> déclencher ce dialogue (avec mark_completed)", un
-// "nouvelle" avec 2 répliques, un widget "💬 Boîte de dialogue" posé sur
+// widget "💬 Boîte de dialogue" posé sur la même scène — plus aucun écran
-// la même scène.
+// d'offre automatique, le dialogue s'affiche directement et se marque
+// terminé à la fin.
 const test = require('node:test');
 const assert = require('node:assert/strict');
 
@@ -22,7 +23,6 @@ const { forgeDialogueBoxAdvance } = require('../dialogue-box-controller.js'); //
 const {
   forgeCollisionRuleTick,
 } = require('../collision-rules-controller.js');
-const { forgeDialogueBoxAcceptQuest, forgeQuestById } = require('../dialogue-box-controller.js');
 
 function fakeEl(style) {
   const classes = new Set();
@@ -43,11 +43,17 @@ function fakeEl(style) {
   };
 }
 
-test('collision "quete" -> dialogue puis offre de quête -> Accepter fait passer la quête en_cours', () => {
+test('collision "dialogue" -> boîte de dialogue -> fin de dialogue (mark_completed) marque le dialogue terminé', () => {
   const player = { id: 1, kind: 'personnage', personnage_role: 'joueur' };
   const mrPinguin = {
-    id: 2, kind: 'personnage',
+    id: 2, kind: 'personnage', name: 'Mr. Pinguin',
-    collision_rules: [{ trigger: 'collision', action: { type: 'quete', quete_id: 99 } }],
+    collision_rules: [{
+      trigger: 'collision',
+      action: {
+        type: 'dialogue', mark_completed: true,
+        dialogue: { id: 'd_intro', lines: [{ speaker: 'Mr. Pinguin', text: 'Bonjour !' }, { speaker: 'Charlie', text: 'Salut !' }] },
+      },
+    }],
   };
   const box = { id: 3, kind: 'dialogue_box' };
 
@@ -61,18 +67,10 @@ test('collision "quete" -> dialogue puis offre de quête -> Accepter fait passer
   boxWidget._footer = { innerHTML: '' };
 
   global.window.currentScreenId = 1;
+  global.window.forgeCompletedDialogueIds = {};
   global.gameData = {
     personnage_animations: {},
-    quests: [{
+    completable_dialogue_ids: ['d_intro'],
-      id: 99, title: 'Retrouver Charlie', status: 'nouvelle', objectif: 'Parler à Mr. Pinguin',
-      dialogues: {
-        nouvelle: [
-          { speaker: 'Mr. Pinguin', text: 'Bonjour !' },
-          { speaker: 'Charlie', text: 'Salut !' },
-        ],
-        en_cours: [], terminee: [],
-      },
-    }],
   };
 
   const previousDoc = global.document;
@@ -94,12 +92,12 @@ test('collision "quete" -> dialogue puis offre de quête -> Accepter fait passer
   try {
     const screenData = { elements: [player, mrPinguin, box] };
 
-    forgeCollisionRuleTick(screenData); // entrée en collision -> déclenche la quête
+    forgeCollisionRuleTick(screenData); // entrée en collision -> déclenche le dialogue
     assert.equal(boxWidget._header.textContent, 'Mr. Pinguin');
     assert.equal(boxWidget._body.textContent, 'Bonjour !');
     assert.equal(boxWidget.classList.contains('is-active'), true);
 
-    forgeCollisionRuleTick(screenData); // toujours en collision -> ne redéclenche pas la quête
+    forgeCollisionRuleTick(screenData); // toujours en collision -> ne redéclenche pas
     assert.equal(boxWidget._header.textContent, 'Mr. Pinguin'); // pas repartie de la 1ère réplique
 
     forgeDialogueBoxAdvance('3'); // clic "Suivant" (bouton du widget)
@@ -107,14 +105,8 @@ test('collision "quete" -> dialogue puis offre de quête -> Accepter fait passer
     assert.equal(boxWidget._body.textContent, 'Salut !');
     assert.equal(boxWidget.classList.contains('is-active'), true);
 
-    forgeDialogueBoxAdvance('3'); // dernière réplique consommée -> quête "nouvelle" -> écran d'offre, PAS masqué
+    forgeDialogueBoxAdvance('3'); // dernière réplique consommée -> mark_completed -> dialogue terminé, boîte masquée
-    assert.equal(boxWidget.classList.contains('is-active'), true);
+    assert.equal(boxWidget.classList.contains('is-active'), false);
-    assert.equal(boxWidget._header.textContent, 'Quête : Retrouver Charlie');
+    assert.equal(window.forgeCompletedDialogueIds['d_intro'], true);
-    assert.equal(boxWidget._body.textContent, 'Parler à Mr. Pinguin');
-    assert.match(boxWidget._footer.innerHTML, /Accepter/);
-
-    forgeDialogueBoxAcceptQuest(99, '3'); // clic "Accepter"
-    assert.equal(forgeQuestById(99).status, 'en_cours');
-    assert.equal(boxWidget.classList.contains('is-active'), false); // la modale disparaît
   } finally { global.document = previousDoc; }
 });

static/js/play/__tests__/collision-rules-controller.test.js

@@ -1,4 +1,4 @@
-// Moteur d'exécution des règles "🧩 Collision" (voir
+// Moteur d'exécution des déclencheurs (voir
 // static/js/play/collision-rules-controller.js) : déclenche une action une
 // seule fois par ENTRÉE en collision/périmètre, jamais en continu tant que
 // la condition reste vraie — et gère "interagir" à part (bulle + attente
@@ -14,6 +14,7 @@ global.heldKeys = new Set();
 const actionsMod = require('../actions.js');
 Object.assign(global, actionsMod);
 require('../personnage-controller.js');
+global.forgeApplyVariableActionOffline = global.forgeApplyVariableActionOffline || require('../offline/apply-actions.js').forgeApplyVariableActionOffline;
 
 const {
   forgeCollisionRuleTriggerActive, forgeRunCollisionRuleAction, forgeCollisionRuleTick,
@@ -86,54 +87,117 @@ test('forgeCollisionRuleTriggerActive — trigger "collision" : vrai aussi pour
   assert.equal(forgeCollisionRuleTriggerActive({ trigger: 'collision' }, objRect, touchingPlayer), true);
 });
 
-test('forgeCollisionRuleTriggerActive — trigger "perimetre" : distance entre centres <= perimetre_px', () => {
+test('forgeRunCollisionRuleAction — "dialogue" délègue à forgeShowDialogueBox (voir dialogue-box-controller.js) avec le nom de l\'objet, les répliques DE CETTE ACTION et mark_completed', () => {
-  const objRect = rect(0, 0, 10, 10); // centre (5,5)
-  const near = rect(10, 0, 10, 10); // centre (15,5) -> distance 10
-  assert.equal(forgeCollisionRuleTriggerActive({ trigger: 'perimetre', perimetre_px: 12 }, objRect, near), true);
-  assert.equal(forgeCollisionRuleTriggerActive({ trigger: 'perimetre', perimetre_px: 5 }, objRect, near), false);
-});
-
-test('forgeRunCollisionRuleAction — "evenement" appelle window.dispatchGameEvent avec evenement_id', () => {
-  const calls = [];
-  global.window.dispatchGameEvent = id => calls.push(id);
-  forgeRunCollisionRuleAction({ type: 'evenement', evenement_id: 42 }, fakeEl(), { id: 1 });
-  assert.deepEqual(calls, [42]);
-});
-
-test('forgeRunCollisionRuleAction — "quete" délègue à forgeShowDialogueBox (voir dialogue-box-controller.js)', () => {
   const calls = [];
   const previousShow = global.forgeShowDialogueBox;
-  global.forgeShowDialogueBox = id => calls.push(id);
+  global.forgeShowDialogueBox = (...args) => calls.push(args);
-  forgeRunCollisionRuleAction({ type: 'quete', quete_id: 42 }, fakeEl(), { id: 1 });
+  const lines = [{ speaker: 'PNJ', text: 'Bonjour !' }];
+  forgeRunCollisionRuleAction({ type: 'dialogue', dialogue: { id: 'd_1', lines: lines }, mark_completed: true }, fakeEl(), { id: 1, name: 'Crokine' });
   global.forgeShowDialogueBox = previousShow;
-  assert.deepEqual(calls, [42]);
+  assert.deepEqual(calls, [['d_1', 'Crokine', lines, true, undefined]]);
 });
 
-test('tick — la collision entre le joueur et un ennemi déclenche "attaque" une seule fois tant que le contact persiste', () => {
+test('forgeRunCollisionRuleAction — "dialogue" sans dialogue (référence orpheline) : transmet une liste vide plutôt que de planter', () => {
-  global.window.dispatchGameEvent = () => {};
+  const calls = [];
+  const previousShow = global.forgeShowDialogueBox;
+  global.forgeShowDialogueBox = (...args) => calls.push(args);
+  forgeRunCollisionRuleAction({ type: 'dialogue' }, fakeEl(), { id: 1, name: 'Crokine' });
+  global.forgeShowDialogueBox = previousShow;
+  assert.deepEqual(calls, [[undefined, 'Crokine', [], undefined, undefined]]);
+});
+
+test('forgeRunCollisionRuleAction — "condition" vraie exécute la branche si_vrai', () => {
+  global.gameData = { variables: { inventaire_cle: { value: '1' } } };
+  const calls = [];
+  const previousShow = global.forgeShowDialogueBox;
+  global.forgeShowDialogueBox = (...args) => calls.push(args);
+  const vraiLines = [{ speaker: 'PNJ', text: 'Vrai !' }];
+  const action = {
+    type: 'condition', variable: 'inventaire_cle', operateur: 'superieur', valeur: '0',
+    si_vrai: { type: 'dialogue', dialogue: { id: 'd_vrai', lines: vraiLines } }, si_faux: null,
+  };
+  forgeRunCollisionRuleAction(action, fakeEl(), { id: 1, name: 'Crokine' });
+  global.forgeShowDialogueBox = previousShow;
+  assert.deepEqual(calls, [['d_vrai', 'Crokine', vraiLines, undefined, undefined]]);
+});
+
+test('forgeRunCollisionRuleAction — "condition" fausse exécute la branche si_faux, jamais si_vrai', () => {
+  global.gameData = { variables: { inventaire_cle: { value: '0' } } };
+  const calls = [];
+  const previousShow = global.forgeShowDialogueBox;
+  global.forgeShowDialogueBox = (...args) => calls.push(args);
+  const fauxLines = [{ speaker: 'PNJ', text: 'Faux !' }];
+  const action = {
+    type: 'condition', variable: 'inventaire_cle', operateur: 'superieur', valeur: '0',
+    si_vrai: { type: 'dialogue', dialogue: { id: 'd_vrai', lines: [] } },
+    si_faux: { type: 'dialogue', dialogue: { id: 'd_faux', lines: fauxLines } },
+  };
+  forgeRunCollisionRuleAction(action, fakeEl(), { id: 1, name: 'Crokine' });
+  global.forgeShowDialogueBox = previousShow;
+  assert.deepEqual(calls, [['d_faux', 'Crokine', fauxLines, undefined, undefined]]);
+});
+
+test('forgeRunCollisionRuleAction — "condition" avec une branche "Ne rien faire" (null) ne fait rien', () => {
+  global.gameData = { variables: { inventaire_cle: { value: '0' } } };
+  const calls = [];
+  const previousShow = global.forgeShowDialogueBox;
+  global.forgeShowDialogueBox = (...args) => calls.push(args);
+  const action = {
+    type: 'condition', variable: 'inventaire_cle', operateur: 'superieur', valeur: '0',
+    si_vrai: { type: 'dialogue', dialogue: { id: 'd_vrai', lines: [] } }, si_faux: null,
+  };
+  forgeRunCollisionRuleAction(action, fakeEl(), { id: 1, name: 'Crokine' });
+  global.forgeShowDialogueBox = previousShow;
+  assert.deepEqual(calls, []);
+});
+
+test('forgeRunCollisionRuleAction — "variable" modifie gameData.variables via forgeApplyVariableActionOffline', () => {
+  global.gameData = { variables: { score: { type: 'nombre_entier', value: '2' } } };
+  forgeRunCollisionRuleAction({ type: 'variable', target_variable: 'score', data_operation: 'incrementer', data_value: '3' }, fakeEl(), { id: 1, name: 'Crokine' });
+  assert.equal(gameData.variables.score.value, '5');
+});
+
+test('forgeRunCollisionRuleAction — "variable" chaînée (then) exécute IMMÉDIATEMENT la suivante (instantané, pas besoin d\'attendre)', () => {
+  global.gameData = { variables: { score: { type: 'nombre_entier', value: '0' }, vies: { type: 'nombre_entier', value: '3' } } };
+  const action = {
+    type: 'variable', target_variable: 'score', data_operation: 'incrementer', data_value: '1',
+    then: { type: 'variable', target_variable: 'vies', data_operation: 'decrementer', data_value: '1' },
+  };
+  forgeRunCollisionRuleAction(action, fakeEl(), { id: 1, name: 'Crokine' });
+  assert.equal(gameData.variables.score.value, '1');
+  assert.equal(gameData.variables.vies.value, '2');
+});
+
+test('forgeRunCollisionRuleAction — "dialogue" transmet son "then" à forgeShowDialogueBox (exécuté APRÈS le dialogue, pas ici)', () => {
+  global.gameData = { variables: {} };
+  const calls = [];
+  const previousShow = global.forgeShowDialogueBox;
+  global.forgeShowDialogueBox = (...args) => calls.push(args);
+  const thenAction = { type: 'variable', target_variable: 'score', data_operation: 'incrementer', data_value: '1' };
+  forgeRunCollisionRuleAction({ type: 'dialogue', dialogue: { id: 'd_1', lines: [] }, then: thenAction }, fakeEl(), { id: 1, name: 'Crokine' });
+  global.forgeShowDialogueBox = previousShow;
+  assert.deepEqual(calls, [['d_1', 'Crokine', [], undefined, thenAction]]);
+});
+
+test('tick — la collision entre le joueur et un objet ne redéclenche pas "dialogue" tant que le contact persiste', () => {
   const player = { id: 1, kind: 'personnage', personnage_role: 'joueur', personnage_commandes: { interagir: 'e' } };
-  const enemy = { id: 2, kind: 'personnage', collision_rules: [{ trigger: 'collision', action: { type: 'attaque' } }] };
+  const npc = { id: 2, kind: 'personnage', name: 'Crokine', collision_rules: [{ trigger: 'collision', action: { type: 'dialogue', dialogue: { id: 'd_7', lines: [] } } }] };
   const playerEl = fakeEl();
-  const enemyEl = fakeEl();
+  const npcEl = fakeEl();
-  enemyEl.style = { left: '5px', top: '5px', width: '20px', height: '20px' }; // chevauche playerEl (0,0,20,20)
+  npcEl.style = { left: '5px', top: '5px', width: '20px', height: '20px' }; // chevauche playerEl (0,0,20,20)
 
   const previousDoc = global.document;
-  global.document = fakeDocument({ 1: playerEl, 2: enemyEl });
+  global.document = fakeDocument({ 1: playerEl, 2: npcEl });
   global.gameData = { personnage_animations: {} };
+  const previousShow = global.forgeShowDialogueBox;
+  const calls = [];
+  global.forgeShowDialogueBox = id => calls.push(id);
   try {
-    const screenData = { elements: [player, enemy] };
+    const screenData = { elements: [player, npc] };
-    let attackCalls = 0;
-    const originalRun = global.runSpriteAnimation;
-    global.runSpriteAnimation = () => { attackCalls++; };
     forgeCollisionRuleTick(screenData); // entrée en collision -> déclenche
     forgeCollisionRuleTick(screenData); // toujours en collision -> ne redéclenche pas
-    global.runSpriteAnimation = originalRun;
+    assert.deepEqual(calls, ['d_7']);
-    // "attaque" ne joue une animation que si le personnage a une pose
+  } finally { global.document = previousDoc; global.forgeShowDialogueBox = previousShow; }
-    // "attaque" (voir forgePersonnageAnimExists) — absente ici, donc 0
-    // appel réel à runSpriteAnimation, mais le test vérifie surtout
-    // l'absence de double déclenchement plutôt que l'appel lui-même.
-    assert.equal(attackCalls, 0);
-  } finally { global.document = previousDoc; }
 });
 
 test('tick — la bulle "Appuie sur X" s\'ancre sur la BOÎTE DE COLLISION, pas le cadre brut du sprite', () => {
@@ -148,7 +212,7 @@ test('tick — la bulle "Appuie sur X" s\'ancre sur la BOÎTE DE COLLISION, pas
     // Sprite de 100×200 px, mais silhouette réelle 20×20 centrée en bas
     // (offset_y positif = décalée vers le bas, voir collision_settings.py).
     collision: { enabled: true, shape: 'rectangle', width: 20, height: 20, offset_x: 0, offset_y: 80 },
-    collision_rules: [{ trigger: 'collision', action: { type: 'interagir', sub_action: { type: 'quete', quete_id: 1 } } }],
+    collision_rules: [{ trigger: 'collision', action: { type: 'interagir', sub_action: { type: 'dialogue' } } }],
   };
   const parent = fakeParentEl();
   const playerEl = fakeEl(parent);
@@ -170,7 +234,7 @@ test('tick — la bulle "Appuie sur X" s\'ancre sur la BOÎTE DE COLLISION, pas
 
 test('tick — "interagir" affiche la bulle "Appuie sur [touche]" pendant la collision, puis la cache en sortant', () => {
   const player = { id: 1, kind: 'personnage', personnage_role: 'joueur', personnage_commandes: { interagir: 'e' } };
-  const pnj = { id: 3, kind: 'personnage', collision_rules: [{ trigger: 'collision', action: { type: 'interagir', sub_action: { type: 'quete', quete_id: 'q-2' } } }] };
+  const pnj = { id: 3, kind: 'personnage', collision_rules: [{ trigger: 'collision', action: { type: 'interagir', sub_action: { type: 'dialogue' } } }] };
   const parentNear = fakeParentEl();
   const parentFar = fakeParentEl();
   const playerElNear = fakeEl(parentNear);
@@ -198,5 +262,5 @@ test('tick — "interagir" affiche la bulle "Appuie sur [touche]" pendant la col
 
 test('forgeStartCollisionRuleControllers — inactif sans joueur ou sans règle (aucun intervalle démarré)', () => {
   assert.doesNotThrow(() => forgeStartCollisionRuleControllers({ kind: 'jeu_2d', elements: [{ kind: 'personnage', personnage_role: 'joueur' }] }));
-  assert.doesNotThrow(() => forgeStartCollisionRuleControllers({ kind: 'jeu_2d', elements: [{ kind: 'personnage', collision_rules: [{ trigger: 'collision', action: { type: 'attaque' } }] }] }));
+  assert.doesNotThrow(() => forgeStartCollisionRuleControllers({ kind: 'jeu_2d', elements: [{ kind: 'personnage', collision_rules: [{ trigger: 'collision', action: { type: 'dialogue' } }] }] }));
 });

static/js/play/__tests__/dialogue-box-controller.test.js

@@ -1,7 +1,11 @@
 // Widget "💬 Boîte de dialogue" — moteur d'exécution (voir
-// static/js/play/dialogue-box-controller.js) : affiche la réplique en
+// static/js/play/dialogue-box-controller.js) : affiche les répliques
-// cours du dialogue d'une quête (gameData.quests) correspondant à son
+// D'UNE ACTION PRÉCISE (transmises en paramètre par collision-rules-
-// STATUT ACTUEL, avance au clic sur "Suivant", se masque à la fin.
+// controller.js, chaque occurrence de "Déclencher ce dialogue" porte les
+// siennes, voir screens/rendering/collision_rules.py), avance au clic sur
+// "Suivant", se masque à la fin — sans écran d'offre automatique ni
+// notion de quête : le nom affiché (en-tête du quiz, xAPI) est celui de
+// l'objet déclencheur.
 const test = require('node:test');
 const assert = require('node:assert/strict');
 
@@ -9,10 +13,9 @@ global.window = global.window || {};
 global.gameData = {};
 
 const {
-  forgeQuestById, forgeShowDialogueBox, forgeDialogueBoxAdvance,
+  forgeShowDialogueBox, forgeDialogueBoxAdvance, forgeCompleteDialogue,
-  forgeDialogueBoxAcceptQuest, forgeDialogueBoxDeclineQuest,
   forgeQuizBoxAnswer, forgeQuizBoxContinue, forgeUpdateAllScoreWidgets,
-  forgeAddQuizScore, forgeSyncAllQuestsCompletionToScorm,
+  forgeAddQuizScore, forgeSyncAllDialoguesCompletionToScorm,
   forgeComputeFinalScormStatus,
 } = require('../dialogue-box-controller.js');
 
@@ -43,50 +46,37 @@ test.beforeEach(() => {
   // fuiraient sur le calcul de statut final du test suivant.
   global.window.forgeQuizTotalAnswered = 0;
   global.window.forgeQuizCorrectAnswered = 0;
-  global.gameData = {
+  global.window.forgeCompletedDialogueIds = {};
-    quests: [
+  global.gameData = { completable_dialogue_ids: [] };
-      { id: 5, title: 'La quête du sorcier', status: 'nouvelle', objectif: 'Parler au sorcier', dialogues: { nouvelle: [{ speaker: 'Le Sorcier', text: 'Bonjour !' }, { speaker: 'Joueur', text: 'Salut.' }], en_cours: [], terminee: [] } },
-      { id: 6, status: 'en_cours', dialogues: { nouvelle: [{ speaker: 'PNJ', text: 'x' }], en_cours: [], terminee: [] } },
-      { id: 8, status: 'terminee', dialogues: { nouvelle: [], en_cours: [], terminee: [{ speaker: 'PNJ', text: 'Merci !' }] } },
-    ],
-  };
 });
 
-test('forgeQuestById retrouve une quête par id', () => {
+test('forgeShowDialogueBox — sans dialogueId : aucun effet (pas de plantage)', () => {
-  assert.equal(forgeQuestById(5).id, 5);
-  assert.equal(forgeQuestById(999), undefined);
-});
-
-test('forgeShowDialogueBox — quête introuvable : aucun effet (pas de plantage)', () => {
   const previousDoc = global.document;
   global.document = { querySelector: () => { throw new Error('ne devrait jamais chercher de widget'); } };
   try {
-    assert.doesNotThrow(() => forgeShowDialogueBox(999));
+    assert.doesNotThrow(() => forgeShowDialogueBox(null, 'PNJ', []));
   } finally { global.document = previousDoc; }
 });
 
-test('forgeShowDialogueBox — quête sans réplique pour son statut "en_cours" (pas "nouvelle") : aucun effet', () => {
+test('forgeShowDialogueBox — dialogue vide, sans mark_completed : aucun effet', () => {
   const widget = fakeWidget(42);
   const previousDoc = global.document;
   global.document = { querySelector: () => widget };
   try {
-    forgeShowDialogueBox(6); // "en_cours" -> dialogues.en_cours est vide, et statut != "nouvelle"
+    forgeShowDialogueBox('d_6', 'PNJ', []);
     assert.equal(widget._classes.has('is-active'), false);
+    assert.equal(window.forgeCompletedDialogueIds['d_6'], undefined);
   } finally { global.document = previousDoc; }
 });
 
-test('forgeShowDialogueBox — quête "nouvelle" SANS réplique : propose directement l\'offre (accepter/refuser)', () => {
+test('forgeShowDialogueBox — dialogue vide AVEC mark_completed : marque le dialogue terminé immédiatement, sans rien afficher', () => {
-  global.gameData.quests.push({ id: 7, title: 'Le trésor perdu', status: 'nouvelle', objectif: 'Trouver le trésor', dialogues: {} });
   const widget = fakeWidget(42);
   const previousDoc = global.document;
   global.document = { querySelector: () => widget };
   try {
-    forgeShowDialogueBox(7);
+    forgeShowDialogueBox('d_6', 'PNJ', [], true);
-    assert.equal(widget._roles.header.textContent, 'Quête : Le trésor perdu');
+    assert.equal(widget._classes.has('is-active'), false);
-    assert.equal(widget._roles.body.textContent, 'Trouver le trésor');
+    assert.equal(window.forgeCompletedDialogueIds['d_6'], true);
-    assert.match(widget._roles.footer.innerHTML, /Accepter/);
-    assert.match(widget._roles.footer.innerHTML, /Refuser/);
-    assert.equal(widget._classes.has('is-active'), true);
   } finally { global.document = previousDoc; }
 });
 
@@ -94,16 +84,16 @@ test('forgeShowDialogueBox — aucun widget posé sur l\'écran : aucun effet',
   const previousDoc = global.document;
   global.document = { querySelector: () => null };
   try {
-    assert.doesNotThrow(() => forgeShowDialogueBox(5));
+    assert.doesNotThrow(() => forgeShowDialogueBox('d_5', 'Le Sorcier', [{ speaker: 'Le Sorcier', text: 'Bonjour !' }]));
   } finally { global.document = previousDoc; }
 });
 
-test('forgeShowDialogueBox puis forgeDialogueBoxAdvance — cycle toutes les répliques puis se masque (quête pas "nouvelle")', () => {
+test('forgeShowDialogueBox puis forgeDialogueBoxAdvance — cycle toutes les répliques puis se masque', () => {
   const widget = fakeWidget(42);
   const previousDoc = global.document;
   global.document = { querySelector: sel => (sel.indexOf('data-object-id="42"') !== -1 ? widget : (sel.indexOf('dialogueBoxWidget') !== -1 ? widget : null)) };
   try {
-    forgeShowDialogueBox(8); // statut "terminee" -> pas d'offre à la fin, se masque normalement
+    forgeShowDialogueBox('d_8', 'PNJ', [{ speaker: 'PNJ', text: 'Merci !' }]);
     assert.equal(widget._roles.header.textContent, 'PNJ');
     assert.equal(widget._roles.body.textContent, 'Merci !');
     assert.equal(widget._classes.has('is-active'), true);
@@ -113,48 +103,68 @@ test('forgeShowDialogueBox puis forgeDialogueBoxAdvance — cycle toutes les ré
   } finally { global.document = previousDoc; }
 });
 
-test('quête "nouvelle" : le dialogue épuisé bascule sur l\'offre (Accepter/Refuser) au lieu de se masquer', () => {
+test('fin de dialogue SANS mark_completed : le dialogue n\'est jamais marqué terminé', () => {
   const widget = fakeWidget(42);
   const previousDoc = global.document;
-  global.document = { querySelector: sel => (sel.indexOf('data-object-id="42"') !== -1 ? widget : (sel.indexOf('dialogueBoxWidget') !== -1 ? widget : null)) };
+  global.document = { querySelector: () => widget };
   try {
-    forgeShowDialogueBox(5);
+    forgeShowDialogueBox('d_5', 'Le Sorcier', [{ speaker: 'Le Sorcier', text: 'Bonjour !' }, { speaker: 'Joueur', text: 'Salut.' }]);
     forgeDialogueBoxAdvance(42);
-    forgeDialogueBoxAdvance(42); // dernière réplique consommée -> écran d'offre, PAS masqué
+    forgeDialogueBoxAdvance(42); // dernière réplique consommée
-    assert.equal(widget._classes.has('is-active'), true);
+    assert.equal(window.forgeCompletedDialogueIds['d_5'], undefined);
-    assert.equal(widget._roles.header.textContent, 'Quête : La quête du sorcier');
-    assert.equal(widget._roles.body.textContent, 'Parler au sorcier');
-    assert.match(widget._roles.footer.innerHTML, /Accepter/);
-    assert.match(widget._roles.footer.innerHTML, /Refuser/);
-  } finally { global.document = previousDoc; }
-});
-
-test('forgeDialogueBoxAcceptQuest — fait passer la quête "en_cours" (en mémoire seulement) et masque la boîte', () => {
-  const widget = fakeWidget(42);
-  const previousDoc = global.document;
-  global.document = { querySelector: () => widget };
-  try {
-    forgeShowDialogueBox(5);
-    widget._classes.add('is-active');
-    forgeDialogueBoxAcceptQuest(5, 42);
-    assert.equal(forgeQuestById(5).status, 'en_cours');
     assert.equal(widget._classes.has('is-active'), false);
   } finally { global.document = previousDoc; }
 });
 
-test('forgeDialogueBoxDeclineQuest — masque la boîte SANS changer le statut (reste "nouvelle")', () => {
+test('fin de dialogue AVEC mark_completed : marque le dialogue terminé et propage vers le SCORM', () => {
   const widget = fakeWidget(42);
+  global.gameData.completable_dialogue_ids = ['d_5']; // seul dialogue connu
+  global.gameData.scoring = { score: 0, status: 'en_cours' };
   const previousDoc = global.document;
   global.document = { querySelector: () => widget };
   try {
-    forgeShowDialogueBox(5);
+    forgeShowDialogueBox('d_5', 'Le Sorcier', [{ speaker: 'Le Sorcier', text: 'Bonjour !' }, { speaker: 'Joueur', text: 'Salut.' }], true);
-    widget._classes.add('is-active');
+    forgeDialogueBoxAdvance(42);
-    forgeDialogueBoxDeclineQuest(42);
+    forgeDialogueBoxAdvance(42); // dernière réplique consommée -> dialogue terminé
-    assert.equal(forgeQuestById(5).status, 'nouvelle'); // inchangé -> le dialogue rejouera depuis le début
+    assert.equal(window.forgeCompletedDialogueIds['d_5'], true);
     assert.equal(widget._classes.has('is-active'), false);
+    assert.equal(gameData.scoring.status, 'termine'); // seul dialogue connu, désormais complété
   } finally { global.document = previousDoc; }
 });
 
+test('forgeShowDialogueBox — dialogue vide AVEC "then" : exécute immédiatement l\'action chaînée (rien à exhiber avant)', () => {
+  const widget = fakeWidget(42);
+  const previousDoc = global.document;
+  const previousRun = global.forgeRunCollisionRuleAction;
+  const calls = [];
+  global.forgeRunCollisionRuleAction = (...args) => calls.push(args);
+  global.document = { querySelector: () => widget };
+  try {
+    const thenAction = { type: 'variable', target_variable: 'score', data_operation: 'incrementer', data_value: '1' };
+    forgeShowDialogueBox('d_6', 'Crokine', [], false, thenAction);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0][0], thenAction);
+    assert.equal(calls[0][2].name, 'Crokine');
+  } finally { global.document = previousDoc; global.forgeRunCollisionRuleAction = previousRun; }
+});
+
+test('fin de dialogue AVEC "then" : exécute l\'action chaînée APRÈS la dernière réplique, jamais avant', () => {
+  const widget = fakeWidget(42);
+  const previousDoc = global.document;
+  const previousRun = global.forgeRunCollisionRuleAction;
+  const calls = [];
+  global.forgeRunCollisionRuleAction = (...args) => calls.push(args);
+  global.document = { querySelector: () => widget };
+  try {
+    const thenAction = { type: 'variable', target_variable: 'score', data_operation: 'incrementer', data_value: '1' };
+    forgeShowDialogueBox('d_9', 'Crokine', [{ speaker: 'PNJ', text: 'Salut !' }], false, thenAction);
+    assert.equal(calls.length, 0); // pas encore, le dialogue n'est pas terminé
+    forgeDialogueBoxAdvance(42); // dernière réplique consommée -> "then" exécuté maintenant
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0][0], thenAction);
+  } finally { global.document = previousDoc; global.forgeRunCollisionRuleAction = previousRun; }
+});
+
 test('forgeDialogueBoxAdvance — objet inconnu (jamais affiché) : aucun effet', () => {
   const previousDoc = global.document;
   global.document = { querySelector: () => null };
@@ -206,36 +216,30 @@ function docWithDialogueAndQuiz(dialogueWidget, quizWidget) {
   };
 }
 
+const QUIZ_LINES = [
+  { type: 'dialogue', speaker: 'PNJ', text: 'Une question pour toi.' },
+  { type: 'question', text: '2+2 ?', choices: ['3', '4'], correct_index: 1, reward_type: 'score', reward_amount: 5 },
+  { type: 'dialogue', speaker: 'PNJ', text: 'Bien joué !' },
+];
+
 test.beforeEach(() => {
-  global.gameData.quests.push({
-    id: 10, title: 'Le quiz du sorcier', status: 'en_cours',
-    dialogues: {
-      nouvelle: [],
-      en_cours: [
-        { type: 'dialogue', speaker: 'PNJ', text: 'Une question pour toi.' },
-        { type: 'question', text: '2+2 ?', choices: ['3', '4'], correct_index: 1, reward_type: 'score', reward_amount: 5 },
-        { type: 'dialogue', speaker: 'PNJ', text: 'Bien joué !' },
-      ],
-      terminee: [],
-    },
-  });
   window.forgeQuizScore = 0;
 });
 
-test('une ligne "question" est affichée dans la boîte à QUIZ (header = quête, corps = question+choix), pas la boîte de dialogue', () => {
+test('une ligne "question" est affichée dans la boîte à QUIZ (header = nom de l\'objet déclencheur, corps = question+choix), pas la boîte de dialogue', () => {
   const dialogueWidget = fakeWidget(42);
   dialogueWidget.getAttribute = attr => (attr === 'data-object-id' ? '42' : null);
   const quizWidget = fakeQuizWidget(99, 2);
   const previousDoc = global.document;
   global.document = docWithDialogueAndQuiz(dialogueWidget, quizWidget);
   try {
-    forgeShowDialogueBox(10);
+    forgeShowDialogueBox('d_10', 'Le sorcier', QUIZ_LINES);
     assert.equal(dialogueWidget._classes.has('is-active'), true); // 1ère ligne : dialogue normal
 
     forgeDialogueBoxAdvance(42); // -> ligne "question"
     assert.equal(dialogueWidget._classes.has('is-active'), false); // masquée pendant la question
     assert.equal(quizWidget._classes.has('is-active'), true);
-    assert.equal(quizWidget._roles.header.textContent, 'Quête : Le quiz du sorcier');
+    assert.equal(quizWidget._roles.header.textContent, 'Le sorcier');
     assert.equal(quizWidget._roles.question.textContent, '2+2 ?');
     assert.match(quizWidget._roles.choices.innerHTML, /forgeQuizBoxAnswer\(99, 0\)/);
     assert.match(quizWidget._roles.choices.innerHTML, /forgeQuizBoxAnswer\(99, 1\)/);
@@ -248,7 +252,7 @@ test('mauvaise réponse au quiz : aucun point, MAIS avance quand même sur "Cont
   const previousDoc = global.document;
   global.document = docWithDialogueAndQuiz(dialogueWidget, quizWidget);
   try {
-    forgeShowDialogueBox(10);
+    forgeShowDialogueBox('d_10', 'Le sorcier', QUIZ_LINES);
     forgeDialogueBoxAdvance(42); // -> question
     forgeQuizBoxAnswer(99, 0); // mauvaise réponse (correct_index=1)
     assert.equal(window.forgeQuizScore, 0); // aucun point
@@ -271,7 +275,7 @@ test('un second clic pendant la révélation (avant "Continuer →") est ignoré
   const previousDoc = global.document;
   global.document = docWithDialogueAndQuiz(dialogueWidget, quizWidget);
   try {
-    forgeShowDialogueBox(10);
+    forgeShowDialogueBox('d_10', 'Le sorcier', QUIZ_LINES);
     forgeDialogueBoxAdvance(42);
     forgeQuizBoxAnswer(99, 0); // 1er clic (faux)
     forgeQuizBoxAnswer(99, 1); // 2nd clic pendant la révélation -> ignoré
@@ -287,7 +291,7 @@ test('bonne réponse au quiz : crédite le score, la surligne en vert, "Continue
   const previousDoc = global.document;
   global.document = docWithDialogueAndQuiz(dialogueWidget, quizWidget);
   try {
-    forgeShowDialogueBox(10);
+    forgeShowDialogueBox('d_10', 'Le sorcier', QUIZ_LINES, true);
     forgeDialogueBoxAdvance(42); // -> question
     forgeQuizBoxAnswer(99, 1); // bonne réponse
     assert.equal(window.forgeQuizScore, 5);
@@ -298,8 +302,8 @@ test('bonne réponse au quiz : crédite le score, la surligne en vert, "Continue
     assert.equal(dialogueWidget._classes.has('is-active'), true);
     assert.equal(dialogueWidget._roles.body.textContent, 'Bien joué !');
 
-    forgeDialogueBoxAdvance(42); // dernière ligne -> dialogue "en_cours" épuisé -> quête "terminee"
+    forgeDialogueBoxAdvance(42); // dernière ligne -> dialogue épuisé, mark_completed -> terminé
-    assert.equal(forgeQuestById(10).status, 'terminee');
+    assert.equal(window.forgeCompletedDialogueIds['d_10'], true);
     assert.equal(dialogueWidget._classes.has('is-active'), false);
   } finally { global.document = previousDoc; }
 });
@@ -313,7 +317,7 @@ test('aucune boîte à quiz posée sur la scène : la question est ignorée, la
   const previousDoc = global.document;
   global.document = docWithDialogueAndQuiz(dialogueWidget, null); // pas de widget à quiz
   try {
-    forgeShowDialogueBox(10);
+    forgeShowDialogueBox('d_10', 'Le sorcier', QUIZ_LINES);
     forgeDialogueBoxAdvance(42); // -> question, mais pas de boîte à quiz -> avance directement
     assert.equal(dialogueWidget._roles.body.textContent, 'Bien joué !'); // déjà à la ligne suivante
     assert.equal(window.forgeQuizScore, 0); // pas de récompense sans réponse
@@ -333,9 +337,9 @@ test('forgeUpdateAllScoreWidgets — met à jour tous les widgets "🏆 Score" a
 });
 
 // ---------- Pont vers SCORM (gameData.scoring, voir static/js/play/offline/scorm-api.js) ----------
-// Bug signalé : "les indicateurs qu'on utilise pour les quêtes devraient
+// Bug signalé : "les indicateurs qu'on utilise pour les dialogues
-// aussi servir aux indicateurs SCORM, or ce n'est pas le cas" — un jeu
+// devraient aussi servir aux indicateurs SCORM, or ce n'est pas le cas" —
-// construit uniquement avec des quêtes/quiz ne touchait jamais
+// un jeu construit uniquement avec des dialogues/quiz ne touchait jamais
 // gameData.scoring, laissant Score/Completion perpétuellement "unknown"
 // dans le LMS même après avoir fini le jeu.
 
@@ -366,42 +370,40 @@ test('forgeAddQuizScore ne rétrograde jamais un statut déjà plus avancé que
   } finally { global.document = previousDoc; }
 });
 
-test('accepter une quête fait passer gameData.scoring.status à "en_cours" (la partie a commencé)', () => {
+test('afficher un dialogue fait passer gameData.scoring.status à "en_cours" (la partie a commencé)', () => {
   const widget = fakeWidget(42);
   global.gameData.scoring = undefined;
   const previousDoc = global.document;
   global.document = { querySelector: () => widget };
   try {
-    forgeDialogueBoxAcceptQuest(5, 42);
+    forgeShowDialogueBox('d_5', 'Le Sorcier', [{ speaker: 'Le Sorcier', text: 'Bonjour !' }]);
     assert.equal(gameData.scoring.status, 'en_cours');
   } finally { global.document = previousDoc; }
 });
 
-test('forgeSyncAllQuestsCompletionToScorm — passe "termine" seulement quand TOUTES les quêtes sont "terminee"', () => {
+test('forgeSyncAllDialoguesCompletionToScorm — passe "termine" seulement quand TOUS les dialogues completable sont completed', () => {
-  global.gameData.quests = [{ id: 1, status: 'terminee' }, { id: 2, status: 'en_cours' }];
+  global.gameData.completable_dialogue_ids = ['d_1', 'd_2'];
+  window.forgeCompletedDialogueIds = { d_1: true };
   global.gameData.scoring = { score: 0, status: 'en_cours' };
-  forgeSyncAllQuestsCompletionToScorm();
+  forgeSyncAllDialoguesCompletionToScorm();
   assert.equal(gameData.scoring.status, 'en_cours'); // pas encore toutes finies
 
-  gameData.quests[1].status = 'terminee';
+  window.forgeCompletedDialogueIds.d_2 = true;
-  forgeSyncAllQuestsCompletionToScorm();
+  forgeSyncAllDialoguesCompletionToScorm();
   assert.equal(gameData.scoring.status, 'termine');
 });
 
-test('la dernière ligne d\'un dialogue "en_cours" propage la complétion à gameData.scoring si c\'est la seule quête', () => {
+test('forgeCompleteDialogue marque le dialogue completed et notifie xAPI', () => {
-  const widget = fakeWidget(42);
+  const calls = [];
-  global.gameData.quests = [
+  global.forgeXapiNotifyDialogueCompleted = (id, name) => calls.push({ id, name });
-    { id: 20, status: 'en_cours', dialogues: { nouvelle: [], en_cours: [{ speaker: 'PNJ', text: 'Bravo !' }], terminee: [] } },
+  global.gameData.completable_dialogue_ids = ['d_20'];
-  ];
   global.gameData.scoring = { score: 0, status: 'en_cours' };
-  const previousDoc = global.document;
-  global.document = { querySelector: sel => (sel.indexOf('data-object-id="42"') !== -1 ? widget : (sel.indexOf('dialogueBoxWidget') !== -1 ? widget : null)) };
   try {
-    forgeShowDialogueBox(20);
+    forgeCompleteDialogue('d_20', 'Crokine');
-    forgeDialogueBoxAdvance(42); // dernière (et unique) ligne consommée -> quête "terminee"
+    assert.equal(window.forgeCompletedDialogueIds['d_20'], true);
-    assert.equal(forgeQuestById(20).status, 'terminee');
+    assert.deepEqual(calls, [{ id: 'd_20', name: 'Crokine' }]);
     assert.equal(gameData.scoring.status, 'termine');
-  } finally { global.document = previousDoc; }
+  } finally { delete global.forgeXapiNotifyDialogueCompleted; }
 });
 
 // ---------- Seuil de réussite (voir db/games/get_success_threshold.py) ----------
@@ -433,31 +435,18 @@ test('forgeComputeFinalScormStatus — seuil par défaut (70%) si FORGE_SUCCESS_
   assert.equal(forgeComputeFinalScormStatus(), 'reussi');
 });
 
-test('forgeSyncAllQuestsCompletionToScorm propage reussi/echoue (pas juste "termine") une fois toutes les quêtes finies', () => {
+test('forgeSyncAllDialoguesCompletionToScorm propage reussi/echoue (pas juste "termine") une fois tous les dialogues finis', () => {
-  global.gameData.quests = [{ id: 1, status: 'terminee' }];
+  global.gameData.completable_dialogue_ids = ['d_1'];
+  window.forgeCompletedDialogueIds = { d_1: true };
   global.gameData.scoring = { score: 0, status: 'en_cours' };
   global.window.forgeQuizTotalAnswered = 4;
   global.window.forgeQuizCorrectAnswered = 1; // 25% < seuil par défaut (70%)
   delete global.window.FORGE_SUCCESS_THRESHOLD_PERCENT;
-  forgeSyncAllQuestsCompletionToScorm();
+  forgeSyncAllDialoguesCompletionToScorm();
   assert.equal(gameData.scoring.status, 'echoue');
 });
 
-// ---------- Granularité xAPI (quête acceptée/terminée, question répondue) ----------
+// ---------- Granularité xAPI (dialogue terminé, question répondue) ----------
-
-test('accepter une quête notifie xAPI (verbe "attempted" ciblant CETTE quête)', () => {
-  const widget = fakeWidget(42);
-  global.gameData.scoring = undefined;
-  const previousDoc = global.document;
-  global.document = { querySelector: () => widget };
-  const calls = [];
-  global.forgeXapiNotifyQuestAccepted = quest => calls.push(quest);
-  try {
-    forgeDialogueBoxAcceptQuest(5, 42);
-    assert.equal(calls.length, 1);
-    assert.equal(calls[0].id, 5);
-  } finally { global.document = previousDoc; delete global.forgeXapiNotifyQuestAccepted; }
-});
 
 test('répondre à une question notifie xAPI avec la bonne/mauvaise réponse et le score gagné', () => {
   const dialogueWidget = fakeWidget(42);
@@ -467,21 +456,19 @@ test('répondre à une question notifie xAPI avec la bonne/mauvaise réponse et
     querySelector: sel => (sel.indexOf('choices') !== -1 ? { innerHTML: '' } : { textContent: '' }),
     querySelectorAll: () => [],
   };
-  global.gameData.quests = [
-    { id: 5, title: 'La quête du sorcier', status: 'en_cours', dialogues: { nouvelle: [], en_cours: [{ type: 'question', text: 'Qui es-tu ?', choices: ['A', 'B'], correct_index: 0, reward_amount: 5 }], terminee: [] } },
-  ];
   const previousDoc = global.document;
   global.document = {
     querySelector: sel => (sel.indexOf('quizBoxWidget') !== -1 ? quizWidget : dialogueWidget),
     querySelectorAll: () => [],
   };
   const calls = [];
-  global.forgeXapiNotifyQuestionAnswered = (quest, index, text, correct, score) => calls.push({ quest, index, text, correct, score });
+  global.forgeXapiNotifyQuestionAnswered = (dialogueId, objectName, index, text, correct, score) => calls.push({ dialogueId, objectName, index, text, correct, score });
   try {
-    forgeShowDialogueBox(5);
+    forgeShowDialogueBox('d_5', 'Le Sorcier', [{ type: 'question', text: 'Qui es-tu ?', choices: ['A', 'B'], correct_index: 0, reward_amount: 5 }]);
     forgeQuizBoxAnswer(99, 0); // bonne réponse (correct_index=0)
     assert.equal(calls.length, 1);
-    assert.equal(calls[0].quest.id, 5);
+    assert.equal(calls[0].dialogueId, 'd_5');
+    assert.equal(calls[0].objectName, 'Le Sorcier');
     assert.equal(calls[0].correct, true);
     assert.equal(calls[0].score, 5);
     forgeQuizBoxContinue(99); // clic explicite (RGAA 2.2.1, plus d'avance automatique)
@@ -496,22 +483,19 @@ test('répondre à une question notifie AUSSI le SCORM 2004 (cmi.interactions.n.
     querySelector: sel => (sel.indexOf('choices') !== -1 ? { innerHTML: '' } : { textContent: '' }),
     querySelectorAll: () => [],
   };
-  global.gameData.quests = [
-    { id: 5, title: 'La quête du sorcier', status: 'en_cours', dialogues: { nouvelle: [], en_cours: [{ type: 'question', text: 'Qui es-tu ?', choices: ['A', 'B'], correct_index: 0, reward_amount: 5 }], terminee: [] } },
-  ];
   const previousDoc = global.document;
   global.document = {
     querySelector: sel => (sel.indexOf('quizBoxWidget') !== -1 ? quizWidget : dialogueWidget),
     querySelectorAll: () => [],
   };
   const calls = [];
-  global.forgeScorm2004NotifyQuestionAnswered = (quest, index, text, correct, choiceIndex, correctIndex) =>
+  global.forgeScorm2004NotifyQuestionAnswered = (dialogueId, objectName, index, text, correct, choiceIndex, correctIndex) =>
-    calls.push({ quest, index, text, correct, choiceIndex, correctIndex });
+    calls.push({ dialogueId, objectName, index, text, correct, choiceIndex, correctIndex });
   try {
-    forgeShowDialogueBox(5);
+    forgeShowDialogueBox('d_5', 'Le Sorcier', [{ type: 'question', text: 'Qui es-tu ?', choices: ['A', 'B'], correct_index: 0, reward_amount: 5 }]);
     forgeQuizBoxAnswer(99, 1); // mauvaise réponse (correct_index=0, répond 1)
     assert.equal(calls.length, 1);
-    assert.equal(calls[0].quest.id, 5);
+    assert.equal(calls[0].dialogueId, 'd_5');
     assert.equal(calls[0].correct, false);
     assert.equal(calls[0].choiceIndex, 1);
     assert.equal(calls[0].correctIndex, 0);

static/js/play/collision-rules-controller.js

@@ -1,13 +1,13 @@
 // ---------- Éditeur de collision — moteur d'exécution en jeu ----------
 // Chaque objet de scène AUTRE que le joueur (jamais un "fond", jamais le
 // personnage "joueur" — voir screens/rendering/collision_rules.py) peut
-// porter des règles "déclencheur -> action" posées dans l'onglet
+// porter des règles "déclencheur -> action", posées depuis l'onglet
-// "🧩 Collision" (static/js/scenes/collision-rules-editor.js). Ce fichier
+// "Déclencheurs" (static/js/triggers/trigger-editor.js::openTriggerWizard).
-// les FAIT VIVRE pendant le jeu : à chaque tick, teste chaque règle contre
+// Ce fichier les FAIT VIVRE pendant le jeu : à chaque tick, teste chaque
-// la position du joueur, déclenche l'action une seule fois par entrée
+// règle contre la position du joueur, déclenche l'action une seule fois
-// (pas en continu tant que la condition reste vraie), même cadence que
+// par entrée (pas en continu tant que la condition reste vraie), même
-// personnage-controller.js (50ms) et réutilise ses mêmes briques
+// cadence que personnage-controller.js (50ms) et réutilise ses mêmes
-// (forgeCollisionRectFromBox/forgeShapesOverlap de conditions.js).
+// briques (forgeCollisionRectFromBox/forgeShapesOverlap de conditions.js).
 // Pur JS client, sans le moindre appel serveur — fonctionne à l'identique
 // en ligne et dans un export SCORM (voir static/js/play/offline/), aucun
 // branchement FORGE_OFFLINE nécessaire ici.
@@ -62,16 +62,10 @@ function forgeExpandRect(rect, margin) {
 
 // "collision" : chevauchement des boîtes, ÉLARGI d'une petite marge pour
 // détecter un simple contact (voir FORGE_COLLISION_RULE_TOUCH_MARGIN
-// ci-dessus). "perimetre" : distance entre les CENTRES des deux boîtes
+// ci-dessus) — seul déclencheur encore proposé ("perimetre" retiré, ne
-// <= rule.perimetre_px (pas entre les bords — plus simple et suffisant
+// servait à rien pour l'instant, demande explicite).
-// pour une portée approximative, cohérent avec le reste du moteur qui ne
-// vise pas une physique précise).
 function forgeCollisionRuleTriggerActive(rule, objRect, playerRect) {
-  if (rule.trigger === 'collision') return forgeShapesOverlap(forgeExpandRect(objRect, FORGE_COLLISION_RULE_TOUCH_MARGIN), playerRect);
+  return forgeShapesOverlap(forgeExpandRect(objRect, FORGE_COLLISION_RULE_TOUCH_MARGIN), playerRect);
-  var ocx = objRect.left + objRect.width / 2, ocy = objRect.top + objRect.height / 2;
-  var pcx = playerRect.left + playerRect.width / 2, pcy = playerRect.top + playerRect.height / 2;
-  var dist = Math.hypot(ocx - pcx, ocy - pcy);
-  return dist <= (rule.perimetre_px || 0);
 }
 
 // La bulle "Appuie sur X" ne peut PAS être un enfant de objectEl : un
@@ -118,27 +112,50 @@ function forgeHideCollisionInteractBubble(objectId, objectEl) {
   if (bubble) bubble.style.display = 'none';
 }
 
-// Exécute une action (top-level ou sub_action d'un "interagir") — jamais
+// Exécute une action (top-level, sub_action d'un "interagir", ou branche
-// appelée pour un "interagir" lui-même à ce niveau, voir forgeCollisionRuleTick
+// si_vrai/si_faux d'une "condition") — jamais appelée pour un "interagir"
-// qui gère "interagir" à part (affichage de bulle + attente de touche).
+// lui-même à ce niveau, voir forgeCollisionRuleTick qui le gère à part
+// (affichage de bulle + attente de touche).
 function forgeRunCollisionRuleAction(action, targetEl, obj) {
-  if (action.type === 'evenement') {
+  if (action.type === 'dialogue') {
-    window.dispatchGameEvent(action.evenement_id);
+    // Affiche LE DIALOGUE DE CETTE ACTION PRÉCISE (action.dialogue.lines
-    return;
+    // — chaque occurrence de "Déclencher ce dialogue" porte le sien,
-  }
+    // voir screens/rendering/collision_rules.py) dans le widget "💬 Boîte
-  if (action.type === 'attaque') {
+    // de dialogue" posé sur l'écran (voir static/js/play/
-    var attackAnim = forgePersonnageAnimExists(obj.id, 'attaque') ? 'attaque' : null;
+    // dialogue-box-controller.js) — sans effet si aucun widget n'est
-    if (attackAnim) runSpriteAnimation(targetEl, resolveSpriteFrames(obj.id, { animation: attackAnim, fps: FORGE_PERSONNAGE_FPS, loop: false }));
+    // posé, comme le reste de ce moteur. Le nom affiché (en-tête du
-    return;
+    // quiz, xAPI) est celui de l'objet déclencheur (voir "ℹ️
-  }
+    // Informations") — plus de "quête" pour le porter. mark_completed
-  if (action.type === 'quete') {
+    // (optionnel) : marque ce dialogue terminé une fois épuisé.
-    // Affiche la réplique en cours du dialogue de cette quête, selon son
+    // `action.then` (chaînage, voir maquette validée : "pouvoir modifier
-    // statut actuel, dans le widget "💬 Boîte de dialogue" posé sur
+    // un déclencheur pour lui ajouter des actions") NE PEUT PAS
-    // l'écran (voir static/js/play/dialogue-box-controller.js) — sans
+    // s'exécuter immédiatement — un dialogue attend des clics du joueur
-    // effet si aucun widget n'est posé ou si la quête n'a aucune
+    // — transmis à forgeShowDialogueBox, exécuté par dialogue-box-
-    // réplique pour son statut, comme le reste de ce moteur.
+    // controller.js une fois le dialogue épuisé.
-    forgeShowDialogueBox(action.quete_id);
+    var lines = (action.dialogue && action.dialogue.lines) || [];
-    return;
+    var dialogueId = action.dialogue && action.dialogue.id;
+    forgeShowDialogueBox(dialogueId, obj.name || 'PNJ', lines, action.mark_completed, action.then);
+  } else if (action.type === 'variable') {
+    // Modifie une variable globale — même vocabulaire/calcul que l'action
+    // "Modifier une variable" du graphe de logique document (voir
+    // screens/data_actions/apply_variable_action.py), portée ici par
+    // forgeApplyVariableActionOffline (static/js/play/offline/apply-actions.js,
+    // TOUJOURS chargée — voir templates/play.html — pas seulement en
+    // export, donc aucun branchement FORGE_OFFLINE nécessaire, même
+    // philosophie que le reste de ce fichier). Instantané : `then`
+    // s'exécute tout de suite, contrairement à un dialogue.
+    forgeApplyVariableActionOffline(gameData, action);
+    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+  } else if (action.type === 'condition') {
+    // Réutilise evaluateConditionClause (static/js/play/conditions.js),
+    // même comparaison qu'un nœud Condition de l'éditeur de logique, sur
+    // une VARIABLE GLOBALE (gameData.variables) — jamais un champ d'objet
+    // ici (voir maquette validée : le losange ne teste qu'une variable).
+    var isTrue = evaluateConditionClause({
+      source: 'variable', variable: action.variable, operator: action.operateur, value: action.valeur,
+    });
+    var branch = isTrue ? action.si_vrai : action.si_faux;
+    if (branch) forgeRunCollisionRuleAction(branch, targetEl, obj);
   }
 }
 
@@ -236,6 +253,7 @@ if (typeof module !== 'undefined' && module.exports) {
   const conditionsMod = require('./conditions.js');
   global.forgeCollisionRectFromBox = global.forgeCollisionRectFromBox || conditionsMod.forgeCollisionRectFromBox;
   global.forgeShapesOverlap = global.forgeShapesOverlap || conditionsMod.forgeShapesOverlap;
+  global.evaluateConditionClause = global.evaluateConditionClause || conditionsMod.evaluateConditionClause;
   const personnageMod = require('./personnage-controller.js');
   global.forgePersonnageAnimExists = global.forgePersonnageAnimExists || personnageMod.forgePersonnageAnimExists;
   global.FORGE_PERSONNAGE_FPS = global.FORGE_PERSONNAGE_FPS || 8;

static/js/play/dialogue-box-controller.js

@@ -1,55 +1,58 @@
 // ---------- Widgets "💬 Boîte de dialogue" / "❓ Boîte à quiz" / "🏆 Score" ----------
-// Fait le lien entre l'éditeur de collision (action "quete", voir
+// Fait le lien entre l'éditeur de déclencheurs (action "dialogue", voir
 // static/js/play/collision-rules-controller.js) et les widgets d'interface
 // posés par l'auteur (voir "🖥️ Interface", templates/scene_edit.html,
 // screens/rendering/dialogue_box_style.py) : à l'exécution d'une action
-// "quete", parcourt le dialogue correspondant au STATUT ACTUEL de la
+// "dialogue", parcourt les répliques DE CETTE ACTION PRÉCISE
-// quête (gameData.quests, voir full_game_payload.py) ligne par ligne —
+// (action.dialogue.lines, transmises telles quelles par
-// une ligne "dialogue" s'affiche dans la boîte de dialogue (bouton
+// collision-rules-controller.js — chaque occurrence de "Déclencher ce
-// "Suivant" pour avancer) ; une ligne "question" ("❓ Question", voir
+// dialogue" porte son propre dialogue, voir screens/rendering/
-// static/js/quests/quest-editor.js) s'affiche dans la boîte à QUIZ (si
+// collision_rules.py) ligne par ligne — une ligne "dialogue" s'affiche
-// posée sur la scène — sinon ignorée silencieusement, la conversation
+// dans la boîte de dialogue (bouton "Suivant" pour avancer) ; une ligne
-// avance sans elle) : cliquer la BONNE réponse crédite le score du
+// "question" ("❓ Question", voir static/js/triggers/trigger-editor.js)
-// montant prévu et avance ; une mauvaise réponse ne fait RIEN, la
+// s'affiche dans la boîte à QUIZ (si posée sur la scène — sinon ignorée
-// question reste affichée (le joueur peut réessayer).
+// silencieusement, la conversation avance sans elle) : cliquer la BONNE
+// réponse crédite le score du montant prévu et avance ; une mauvaise
+// réponse ne fait RIEN, la question reste affichée (le joueur peut
+// réessayer).
 //
-// Une fois le dialogue "nouvelle" épuisé : la boîte bascule en écran
+// Plus aucune "quête" ni écran d'offre automatique (Accepter/Refuser) :
-// d'OFFRE ("Quête : <titre>" / objectif / boutons Accepter-Refuser) au
+// c'est le CRÉATEUR qui pilote l'avancement, via ses propres variables
-// lieu de se masquer — accepter fait passer la quête "en_cours" ; refuser
+// globales et conditions (voir screens/rendering/collision_rules.py::
-// ferme simplement la boîte SANS rien changer (la quête reste "nouvelle",
+// "condition") — le dialogue choisi s'affiche directement. Une action
-// la prochaine interaction rejoue exactement le même dialogue). Une fois
+// "dialogue" peut cocher `mark_completed` : une fois ce dialogue épuisé
-// le dialogue "en_cours" épuisé (donc, s'il contenait des questions,
+// (ou immédiatement s'il est vide), son id est ajouté à
-// toutes répondues correctement), la quête passe "terminee" — le joueur
+// forgeCompletedDialogueIds — RUNTIME uniquement (jamais persisté en
-// peut alors quitter la scène normalement (aucun blocage, ces widgets ne
+// base), qui sert à savoir quand calculer la synthèse SCORM finale (voir
-// sont jamais des obstacles). Tout ceci reste LOCAL à la partie en cours
+// forgeSyncAllDialoguesCompletionToScorm : "terminé" une fois TOUS les
-// (gameData.quests n'est qu'un instantané par joueur, voir
+// dialogues `mark_completed` du jeu joués, voir
-// full_game_payload.py) : jamais persisté en base, qui garde le statut
+// gameData.completable_dialogue_ids). Le seuil de réussite/échec SCORM
-// de DÉPART pour toute nouvelle partie.
+// lui-même reste un réglage du créateur totalement indépendant
+// (db/games/get_success_threshold.py), inchangé ici.
 //
 // Le score du quiz (window.forgeQuizScore) est un compteur RUNTIME dédié
-// à ce système de quête/quiz — distinct du score "classique" du moteur
+// à ce système de dialogue/quiz — distinct du score "classique" du moteur
 // document (db/scoring/, action de flow "Modifier un score"), qui
 // suppose un nœud de flow préconfiguré et un aller-retour serveur, hors
 // de propos pour ce sous-système entièrement client (voir
 // collision-rules-controller.js : "Pur JS client, sans le moindre appel
 // serveur").
 //
-// Silencieux (aucun effet) si la quête est introuvable ou si l'auteur n'a
+// Silencieux (aucun effet) si le widget requis n'est pas posé sur
-// posé aucun widget requis sur l'écran — même esprit que le reste du moteur.
+// l'écran — même esprit que le reste du moteur.
 
 var forgeDialogueBoxState = {};
 var forgeQuizBoxState = {};
 window.forgeQuizScore = window.forgeQuizScore || 0;
 // Compte TOUTE réponse (bonne ou mauvaise) au fil de la partie — sert
 // uniquement à calculer un taux de réussite global (voir
-// forgeSyncAllQuestsCompletionToScorm), distinct de window.forgeQuizScore
+// forgeComputeFinalScormStatus), distinct de window.forgeQuizScore
 // qui ne compte que les points gagnés.
 window.forgeQuizTotalAnswered = window.forgeQuizTotalAnswered || 0;
 window.forgeQuizCorrectAnswered = window.forgeQuizCorrectAnswered || 0;
-
+// Id de dialogue -> true une fois joué ET marqué `mark_completed` — voir
-function forgeQuestById(questId) {
+// forgeSyncAllDialoguesCompletionToScorm.
-  return (gameData.quests || []).find(function (q) { return q.id === questId; });
+window.forgeCompletedDialogueIds = window.forgeCompletedDialogueIds || {};
-}
 
 function forgeEscapeHtml(str) {
   return String(str == null ? '' : str)
@@ -78,9 +81,8 @@ function forgeRenderDialogueBoxLine(widget, line) {
 }
 
 // Remet le pied de la boîte dans son état "dialogue" (un seul bouton
-// "Suivant →", voir render_scene_object.py) — nécessaire pour effacer
+// "Suivant →", voir render_scene_object.py) — appelé avant CHAQUE ligne
-// les boutons Accepter/Refuser d'une offre PRÉCÉDENTE avant de rejouer
+// affichée (voir forgeShowCurrentConversationLine).
-// un nouveau dialogue dans la même boîte.
 function forgeResetDialogueBoxFooter(widget, objectId) {
   var footer = forgeDialogueBoxFooterEl(widget);
   if (footer) footer.innerHTML = '<button type="button" class="dialogueBoxNextBtn" data-dialogue-role="next-btn" onclick="forgeDialogueBoxAdvance(' + objectId + ')">Suivant →</button>';
@@ -110,11 +112,11 @@ function forgeUpdateAllScoreWidgets() {
 
 // Alimente aussi gameData.scoring (voir static/js/play/offline/
 // apply-actions.js, même forme {score, status}) — bug signalé : "les
-// indicateurs qu'on utilise pour les quêtes devraient aussi servir aux
+// indicateurs qu'on utilise pour les dialogues devraient aussi servir aux
 // indicateurs SCORM, or ce n'est pas le cas". C'est CE champ que
 // static/js/play/offline/scorm-api.js lit toutes les 2s pour pousser
 // cmi.core.score.raw/cmi.core.lesson_status au LMS — sans jamais y
-// toucher, un jeu construit uniquement avec des quêtes/quiz (jamais
+// toucher, un jeu construit uniquement avec des dialogues/quiz (jamais
 // l'action de flow "Modifier un score") laissait Score/Completion
 // perpétuellement "unknown" dans SCORM Cloud, même après y avoir joué
 // jusqu'au bout. Vocabulaire de statut identique à db/scoring/
@@ -124,32 +126,36 @@ function forgeSyncQuizScoreToScorm() {
   gameData.scoring.score = window.forgeQuizScore;
   if (gameData.scoring.status === 'non_commence') gameData.scoring.status = 'en_cours';
   // xAPI bolt-on (voir static/js/play/offline/xapi-client.js) : ce chemin
-  // quête/quiz contourne static/js/play/offline/apply-actions.js (aucune
+  // dialogue/quiz contourne static/js/play/offline/apply-actions.js
-  // action de flow "Modifier un score" ici), donc jamais notifié sans cet
+  // (aucune action de flow "Modifier un score" ici), donc jamais notifié
-  // appel direct — même bug que le commentaire ci-dessus pour SCORM.
+  // sans cet appel direct — même bug que le commentaire ci-dessus pour
+  // SCORM.
   if (typeof forgeXapiNotifyScoreChanged === "function") forgeXapiNotifyScoreChanged(gameData.scoring.score);
 }
 
-// Une quête acceptée = la partie a commencé, même sans le moindre point
+// Un dialogue affiché = la partie a commencé, même sans le moindre point
 // encore gagné — sans cet appel, Score restait "0" mais Completion
 // restait "unknown" tant qu'aucune question n'avait encore été résolue.
-function forgeSyncQuestStartedToScorm() {
+// Appelé depuis forgeShowDialogueBox.
+function forgeSyncDialogueStartedToScorm() {
   gameData.scoring = gameData.scoring || { score: 0, status: 'non_commence' };
   if (gameData.scoring.status === 'non_commence') gameData.scoring.status = 'en_cours';
 }
 
-// Le jeu entier est considéré terminé quand TOUTES les quêtes connues
+// Le jeu entier est considéré terminé quand TOUS les dialogues du jeu
-// sont "terminee" — règle simple et prévisible plutôt que de deviner
+// marqués `mark_completed` (voir gameData.completable_dialogue_ids,
-// laquelle des quêtes créées "compte" pour la fin du jeu.
+// screens/rendering/trigger_graph.py::list_completable_dialogue_ids) ont
-// Réussi/Échoué (voir db/games/get_success_threshold.py,
+// été joués (voir forgeAdvanceConversation) — règle simple et
+// prévisible plutôt que de deviner lequel des dialogues créés "compte"
+// pour la fin du jeu. Réussi/Échoué (voir db/games/get_success_threshold.py,
 // window.FORGE_SUCCESS_THRESHOLD_PERCENT injecté par publish/
 // build_scorm_package.py) : demande utilisateur — "il manque
 // l'indicateur succès/échec sur le SCORM". Calculé sur le taux de
 // bonnes réponses au quiz (forgeQuizCorrectAnswered/forgeQuizTotalAnswered)
-// SUR TOUTE LA PARTIE, pas quête par quête — cohérent avec "toutes les
+// SUR TOUTE LA PARTIE, pas dialogue par dialogue — cohérent avec "tous
-// quêtes terminées" qui est déjà la seule condition de fin de partie.
+// les dialogues terminés" qui est déjà la seule condition de fin de
-// Aucune question posée du tout (jeu fait uniquement de dialogues) :
+// partie. Aucune question posée du tout (jeu fait uniquement de
-// reste "termine" (ni réussi ni échoué, rien à évaluer).
+// dialogues) : reste "termine" (ni réussi ni échoué, rien à évaluer).
 function forgeComputeFinalScormStatus() {
   var total = window.forgeQuizTotalAnswered || 0;
   if (total === 0) return 'termine';
@@ -158,9 +164,10 @@ function forgeComputeFinalScormStatus() {
   return percent >= threshold ? 'reussi' : 'echoue';
 }
 
-function forgeSyncAllQuestsCompletionToScorm() {
+function forgeSyncAllDialoguesCompletionToScorm() {
-  var quests = gameData.quests || [];
+  var completableIds = (gameData.completable_dialogue_ids || []);
-  if (!quests.length || !quests.every(function (q) { return q.status === 'terminee'; })) return;
+  var allDone = completableIds.length > 0 && completableIds.every(function (id) { return !!window.forgeCompletedDialogueIds[id]; });
+  if (!allDone) return;
   gameData.scoring = gameData.scoring || { score: 0, status: 'non_commence' };
   var finalStatus = forgeComputeFinalScormStatus();
   gameData.scoring.status = finalStatus;
@@ -187,7 +194,7 @@ function forgeShowCurrentConversationLine(dialogueObjectId) {
   var widget = forgeDialogueBoxWidgetById(dialogueObjectId);
   if (line.type === 'question') {
     if (widget) widget.classList.remove('is-active');
-    forgeShowQuizBox(dialogueObjectId, forgeQuestById(state.questId), line, state.index);
+    forgeShowQuizBox(dialogueObjectId, state.dialogueId, state.objectName, line, state.index);
     return;
   }
   forgeHideQuizBoxOnCurrentScreen();
@@ -197,30 +204,54 @@ function forgeShowCurrentConversationLine(dialogueObjectId) {
   widget.classList.add('is-active');
 }
 
-// Appelée par l'action "quete" (collision-rules-controller.js) — trouve
+// Appelée par l'action "dialogue" (collision-rules-controller.js) —
-// le widget posé sur l'écran ACTUELLEMENT affiché (un seul à la fois,
+// trouve le widget posé sur l'écran ACTUELLEMENT affiché (un seul à la
-// comme le reste du moteur 2D).
+// fois, comme le reste du moteur 2D). `lines` : les répliques DE CETTE
-function forgeShowDialogueBox(questId) {
+// ACTION PRÉCISE (action.dialogue.lines, voir le commentaire d'en-tête).
-  var quest = forgeQuestById(questId);
+// `objectName` : le nom de l'objet déclencheur (voir "ℹ️ Informations"),
-  if (!quest) return;
+// affiché en en-tête du quiz et transmis à xAPI — plus de "quête" pour
-  var lines = (quest.dialogues && quest.dialogues[quest.status]) || [];
+// le porter. `markCompleted` : voir forgeAdvanceConversation ci-dessous.
+// `thenAction` (chaînage, voir screens/rendering/collision_rules.py::
+// "then") : l'action suivante, exécutée seulement une fois ce dialogue
+// épuisé — jamais avant, contrairement à une action "variable" qui,
+// elle, chaîne immédiatement (voir collision-rules-controller.js).
+function forgeShowDialogueBox(dialogueId, objectName, lines, markCompleted, thenAction) {
+  if (!dialogueId) return;
+  lines = lines || [];
   var widget = forgeDialogueBoxWidgetOnCurrentScreen();
   if (!widget) return;
   var objectId = widget.getAttribute('data-object-id');
-  // Aucune ligne posée pour ce statut : une quête "nouvelle" propose
+  forgeSyncDialogueStartedToScorm();
-  // quand même directement l'offre (accepter/refuser), les autres
-  // statuts restent silencieux (rien à montrer).
   if (!lines.length) {
-    if (quest.status === 'nouvelle') forgeShowQuestOffer(widget, objectId, quest);
+    // Rien à jouer : applique quand même markCompleted PUIS thenAction
+    // immédiatement (rien à exhiber avant), sinon silencieux.
+    if (markCompleted) forgeCompleteDialogue(dialogueId, objectName);
+    if (thenAction) forgeRunCollisionRuleAction(thenAction, null, { name: objectName });
     return;
   }
-  forgeDialogueBoxState[objectId] = { questId: questId, lines: lines, index: 0 };
+  forgeDialogueBoxState[objectId] = {
+    dialogueId: dialogueId, objectName: objectName, lines: lines, index: 0,
+    markCompleted: !!markCompleted, thenAction: thenAction,
+  };
   forgeShowCurrentConversationLine(objectId);
 }
 
+// Marque un dialogue `completed` (RUNTIME uniquement, jamais persisté —
+// le créateur pilote lui-même quand, via la case "Marquer ce dialogue
+// comme terminé" de l'assistant) et propage vers le SCORM/xAPI.
+function forgeCompleteDialogue(dialogueId, objectName) {
+  window.forgeCompletedDialogueIds[dialogueId] = true;
+  if (typeof forgeXapiNotifyDialogueCompleted === "function") forgeXapiNotifyDialogueCompleted(dialogueId, objectName);
+  forgeSyncAllDialoguesCompletionToScorm();
+}
+
 // Avance d'une ligne (fin de dialogue -> question, fin de question
 // correcte -> ligne suivante) — appelée par le bouton "Suivant →" ET par
-// une bonne réponse au quiz (voir forgeQuizBoxAnswer).
+// une bonne réponse au quiz (voir forgeQuizBoxAnswer). À l'épuisement des
+// lignes : markCompleted PUIS thenAction (voir screens/rendering/
+// collision_rules.py::"then", demande explicite : "pouvoir modifier un
+// déclencheur pour lui ajouter des actions") — MÊME point de sortie "ce
+// dialogue est fini", jamais avant.
 function forgeAdvanceConversation(dialogueObjectId) {
   var state = forgeDialogueBoxState[dialogueObjectId];
   if (!state) return;
@@ -228,20 +259,8 @@ function forgeAdvanceConversation(dialogueObjectId) {
   if (state.index >= state.lines.length) {
     forgeHideQuizBoxOnCurrentScreen();
     var widget = forgeDialogueBoxWidgetById(dialogueObjectId);
-    var quest = forgeQuestById(state.questId);
+    if (state.markCompleted) forgeCompleteDialogue(state.dialogueId, state.objectName);
-    if (quest && quest.status === 'nouvelle') {
+    if (state.thenAction) forgeRunCollisionRuleAction(state.thenAction, null, { name: state.objectName });
-      if (widget) forgeShowQuestOffer(widget, dialogueObjectId, quest);
-      return;
-    }
-    // Tout le dialogue "en_cours" épuisé (donc, s'il contenait des
-    // questions, toutes répondues correctement) -> quête terminée. Voir
-    // demande utilisateur : "quand le joueur a répondu à toutes les
-    // questions la quête passe au statut terminé".
-    if (quest && quest.status === 'en_cours') {
-      quest.status = 'terminee';
-      if (typeof forgeXapiNotifyQuestCompleted === "function") forgeXapiNotifyQuestCompleted(quest);
-      forgeSyncAllQuestsCompletionToScorm();
-    }
     if (widget) widget.classList.remove('is-active');
     delete forgeDialogueBoxState[dialogueObjectId];
     return;
@@ -260,23 +279,23 @@ function forgeDialogueBoxAdvance(objectId) {
 }
 
 // Affiche une question ("❓ Question") dans la boîte à quiz posée sur
-// l'écran — header = "Quête : <titre>", corps = la question + ses choix
+// l'écran — header = le nom de l'objet déclencheur (voir "ℹ️
-// (voir demande utilisateur) — si l'auteur n'a posé aucune boîte à quiz,
+// Informations"), corps = la question + ses choix — si l'auteur n'a posé
-// la question est ignorée (avance directement) plutôt que de bloquer la
+// aucune boîte à quiz, la question est ignorée (avance directement)
-// conversation pour toujours en attendant une réponse qu'aucun widget ne
+// plutôt que de bloquer la conversation pour toujours en attendant une
-// peut recueillir.
+// réponse qu'aucun widget ne peut recueillir.
-function forgeShowQuizBox(dialogueObjectId, quest, line, questionIndex) {
+function forgeShowQuizBox(dialogueObjectId, dialogueId, objectName, line, questionIndex) {
   var widget = forgeQuizBoxWidgetOnCurrentScreen();
   if (!widget) { forgeAdvanceConversation(dialogueObjectId); return; }
   var quizObjectId = widget.getAttribute('data-object-id');
   forgeQuizBoxState[quizObjectId] = {
     dialogueObjectId: dialogueObjectId, correctIndex: line.correct_index, rewardAmount: line.reward_amount, resolved: false,
-    quest: quest, questionIndex: questionIndex, questionText: line.text,
+    dialogueId: dialogueId, objectName: objectName, questionIndex: questionIndex, questionText: line.text,
   };
   var header = widget.querySelector('[data-quiz-role="header"]');
   var questionEl = widget.querySelector('[data-quiz-role="question"]');
   var choicesEl = widget.querySelector('[data-quiz-role="choices"]');
-  if (header) header.textContent = 'Quête : ' + (quest ? quest.title : '');
+  if (header) header.textContent = objectName || '';
   if (questionEl) questionEl.textContent = line.text;
   if (choicesEl) {
     choicesEl.innerHTML = line.choices.map(function (choice, i) {
@@ -320,13 +339,13 @@ function forgeQuizBoxAnswer(quizObjectId, choiceIndex) {
     window.forgeQuizCorrectAnswered += 1;
     forgeAddQuizScore(state.rewardAmount);
   }
-  if (typeof forgeXapiNotifyQuestionAnswered === "function" && state.quest) {
+  if (typeof forgeXapiNotifyQuestionAnswered === "function") {
-    forgeXapiNotifyQuestionAnswered(state.quest, state.questionIndex, state.questionText, correct, correct ? state.rewardAmount : 0);
+    forgeXapiNotifyQuestionAnswered(state.dialogueId, state.objectName, state.questionIndex, state.questionText, correct, correct ? state.rewardAmount : 0);
   }
   // cmi.interactions.n.* (SCORM 2004 uniquement, voir scorm2004-api.js) :
   // no-op en SCORM 1.2/hors LMS (forgeScorm2004Api y reste null).
-  if (typeof forgeScorm2004NotifyQuestionAnswered === "function" && state.quest) {
+  if (typeof forgeScorm2004NotifyQuestionAnswered === "function") {
-    forgeScorm2004NotifyQuestionAnswered(state.quest, state.questionIndex, state.questionText, correct, choiceIndex, state.correctIndex);
+    forgeScorm2004NotifyQuestionAnswered(state.dialogueId, state.objectName, state.questionIndex, state.questionText, correct, choiceIndex, state.correctIndex);
   }
   // RGAA/WCAG 2.2.1 (délai réglable) : avancait auparavant tout seul
   // après un délai fixe (700ms/1400ms), jamais assez pour un lecteur
@@ -354,58 +373,16 @@ function forgeQuizBoxContinue(quizObjectId) {
   forgeAdvanceConversation(state.dialogueObjectId);
 }
 
-// ---------- Offre de quête (Accepter/Refuser) ----------
-
-// Écran d'offre : header = "Quête : <titre>", body = l'objectif, pied =
-// Accepter/Refuser au lieu du "Suivant" habituel.
-function forgeShowQuestOffer(widget, objectId, quest) {
-  var header = widget.querySelector('[data-dialogue-role="header"]');
-  var body = widget.querySelector('[data-dialogue-role="body"]');
-  var footer = forgeDialogueBoxFooterEl(widget);
-  if (header) header.textContent = 'Quête : ' + quest.title;
-  if (body) body.textContent = quest.objectif || '';
-  if (footer) {
-    footer.innerHTML =
-      '<button type="button" class="dialogueBoxNextBtn dialogueBoxAcceptBtn" onclick="forgeDialogueBoxAcceptQuest(' + quest.id + ', ' + objectId + ')">Accepter</button>' +
-      '<button type="button" class="dialogueBoxNextBtn dialogueBoxDeclineBtn" onclick="forgeDialogueBoxDeclineQuest(' + objectId + ')">Refuser</button>';
-  }
-  forgeDialogueBoxState[objectId] = { questId: quest.id, lines: [], index: 0 };
-  widget.classList.add('is-active');
-}
-
-// Fait passer la quête "en_cours" — UNIQUEMENT dans l'instantané en
-// mémoire (gameData.quests), jamais persisté en base : voir la note en
-// tête de fichier (le statut en base est celui de DÉPART pour toute
-// nouvelle partie, pas un état de partie en cours).
-function forgeDialogueBoxAcceptQuest(questId, objectId) {
-  var quest = forgeQuestById(questId);
-  if (quest) quest.status = 'en_cours';
-  forgeSyncQuestStartedToScorm();
-  if (quest && typeof forgeXapiNotifyQuestAccepted === "function") forgeXapiNotifyQuestAccepted(quest);
-  var widget = forgeDialogueBoxWidgetById(objectId);
-  if (widget) widget.classList.remove('is-active');
-  delete forgeDialogueBoxState[objectId];
-}
-
-// Referme la boîte SANS toucher au statut de la quête (reste "nouvelle")
-// — la prochaine interaction rejoue donc le même dialogue depuis le
-// début : impossible d'avancer la quête sans un jour l'accepter.
-function forgeDialogueBoxDeclineQuest(objectId) {
-  var widget = forgeDialogueBoxWidgetById(objectId);
-  if (widget) widget.classList.remove('is-active');
-  delete forgeDialogueBoxState[objectId];
-}
-
 // static/js/play/__tests__/ (node:test) — même garde que les autres
 // contrôleurs de ce dossier.
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = {
-    forgeQuestById, forgeShowDialogueBox, forgeDialogueBoxAdvance,
+    forgeShowDialogueBox, forgeDialogueBoxAdvance, forgeCompleteDialogue,
     forgeDialogueBoxWidgetOnCurrentScreen, forgeDialogueBoxWidgetById, forgeRenderDialogueBoxLine,
-    forgeShowQuestOffer, forgeDialogueBoxAcceptQuest, forgeDialogueBoxDeclineQuest, forgeResetDialogueBoxFooter,
+    forgeResetDialogueBoxFooter,
     forgeShowQuizBox, forgeQuizBoxAnswer, forgeQuizBoxContinue, forgeQuizBoxWidgetOnCurrentScreen, forgeQuizBoxWidgetById,
     forgeUpdateAllScoreWidgets, forgeAddQuizScore, forgeAdvanceConversation, forgeShowCurrentConversationLine,
-    forgeSyncQuizScoreToScorm, forgeSyncQuestStartedToScorm, forgeSyncAllQuestsCompletionToScorm,
+    forgeSyncQuizScoreToScorm, forgeSyncDialogueStartedToScorm, forgeSyncAllDialoguesCompletionToScorm,
     forgeComputeFinalScormStatus,
   };
 }

static/js/play/offline/__tests__/scorm2004-api.test.js

@@ -116,9 +116,9 @@ test('forgeScorm2004NotifyQuestionAnswered pose une entrée cmi.interactions.n.*
   global.window.API_1484_11 = api;
   try {
     forgeScorm2004Init();
-    forgeScorm2004NotifyQuestionAnswered({ id: 5, title: 'La quête' }, 1, 'Qui es-tu ?', true, 0, 0);
+    forgeScorm2004NotifyQuestionAnswered('d_5', 'Le sorcier', 1, 'Qui es-tu ?', true, 0, 0);
     const sets = Object.fromEntries(api.calls.filter(c => c[0] === 'SetValue').map(c => [c[1], c[2]]));
-    assert.equal(sets['cmi.interactions.2.id'], 'quest:5:question:1');
+    assert.equal(sets['cmi.interactions.2.id'], 'dialogue:d_5:question:1');
     assert.equal(sets['cmi.interactions.2.type'], 'choice');
     assert.match(sets['cmi.interactions.2.timestamp'], /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
     assert.equal(sets['cmi.interactions.2.description'], '{fr-FR}Qui es-tu ?');
@@ -134,7 +134,7 @@ test('forgeScorm2004NotifyQuestionAnswered — mauvaise réponse : result="incor
   global.window.API_1484_11 = api;
   try {
     forgeScorm2004Init();
-    forgeScorm2004NotifyQuestionAnswered({ id: 5, title: 'La quête' }, 0, 'Qui es-tu ?', false, 1, 0);
+    forgeScorm2004NotifyQuestionAnswered('d_5', 'Le sorcier', 0, 'Qui es-tu ?', false, 1, 0);
     const sets = Object.fromEntries(api.calls.filter(c => c[0] === 'SetValue').map(c => [c[1], c[2]]));
     assert.equal(sets['cmi.interactions.0.result'], 'incorrect');
     assert.equal(sets['cmi.interactions.0.learner_response'], '1');
@@ -147,5 +147,5 @@ test('forgeScorm2004NotifyQuestionAnswered ne fait rien hors LMS (forgeScorm2004
   forgeScorm2004Init(); // aucune API trouvée -> remet forgeScorm2004Api à null
   // Si le repli silencieux (if (!forgeScorm2004Api) return;) était absent,
   // ceci lèverait en tentant d'appeler .GetValue sur null.
-  assert.doesNotThrow(() => forgeScorm2004NotifyQuestionAnswered({ id: 1 }, 0, 'x', true, 0, 0));
+  assert.doesNotThrow(() => forgeScorm2004NotifyQuestionAnswered('d_1', 'x', 0, 'x', true, 0, 0));
 });

static/js/play/offline/__tests__/xapi-client.test.js

@@ -1,7 +1,7 @@
 // Export Web/SCORM — bolt-on xAPI (voir ../xapi-client.js) : vérifie la
-// granularité par quête/question demandée par l'utilisateur (quête
+// granularité par dialogue/question demandée par l'utilisateur (dialogue
-// acceptée/terminée, réponse à une question), en plus du score/statut
+// terminé, réponse à une question), en plus du score/statut global déjà
-// global déjà couvert par dialogue-box-controller.test.js.
+// couvert par dialogue-box-controller.test.js.
 const test = require('node:test');
 const assert = require('node:assert/strict');
 
@@ -10,8 +10,8 @@ global.window.addEventListener = global.window.addEventListener || function () {
 global.btoa = global.btoa || (str => Buffer.from(str).toString('base64'));
 
 const {
-  forgeXapiNotifyQuestAccepted, forgeXapiNotifyQuestCompleted, forgeXapiNotifyQuestionAnswered,
+  forgeXapiNotifyDialogueCompleted, forgeXapiNotifyQuestionAnswered,
-  forgeXapiQuestObject, forgeXapiQuestionObject,
+  forgeXapiDialogueObject, forgeXapiQuestionObject,
 } = require('../xapi-client.js');
 
 test.beforeEach(() => {
@@ -21,45 +21,35 @@ test.beforeEach(() => {
   };
 });
 
-test('forgeXapiQuestObject construit un id de sous-activité dérivé de l\'activité du jeu', () => {
+test('forgeXapiDialogueObject construit un id de sous-activité dérivé de l\'activité du jeu, nommé d\'après l\'objet déclencheur', () => {
-  const obj = forgeXapiQuestObject({ id: 5, title: 'La quête du sorcier' });
+  const obj = forgeXapiDialogueObject('d_5', 'Le sorcier');
-  assert.equal(obj.id, 'urn:forge-engine:game:test:quest:5');
+  assert.equal(obj.id, 'urn:forge-engine:game:test:dialogue:d_5');
-  assert.equal(obj.definition.name['fr-FR'], 'La quête du sorcier');
+  assert.equal(obj.definition.name['fr-FR'], 'Le sorcier');
 });
 
-test('forgeXapiQuestionObject construit un id dérivé incluant la quête ET l\'index de question', () => {
+test('forgeXapiQuestionObject construit un id dérivé incluant le dialogue ET l\'index de question', () => {
-  const obj = forgeXapiQuestionObject({ id: 5, title: 'La quête du sorcier' }, 2, 'Qui es-tu ?');
+  const obj = forgeXapiQuestionObject('d_5', 'Le sorcier', 2, 'Qui es-tu ?');
-  assert.equal(obj.id, 'urn:forge-engine:game:test:quest:5:question:2');
+  assert.equal(obj.id, 'urn:forge-engine:game:test:dialogue:d_5:question:2');
   assert.equal(obj.definition.description['fr-FR'], 'Qui es-tu ?');
 });
 
-test('forgeXapiNotifyQuestAccepted envoie un statement "attempted" ciblant la quête', () => {
+test('forgeXapiNotifyDialogueCompleted envoie un statement "completed" ciblant le dialogue (result.completion=true)', () => {
   const calls = [];
   global.fetch = (url, opts) => { calls.push({ url, opts }); return Promise.resolve(); };
-  forgeXapiNotifyQuestAccepted({ id: 5, title: 'La quête du sorcier' });
+  forgeXapiNotifyDialogueCompleted('d_5', 'Le sorcier');
-  assert.equal(calls.length, 1);
-  const body = JSON.parse(calls[0].opts.body);
-  assert.equal(body.verb.id, 'http://adlnet.gov/expapi/verbs/attempted');
-  assert.equal(body.object.id, 'urn:forge-engine:game:test:quest:5');
-});
-
-test('forgeXapiNotifyQuestCompleted envoie un statement "completed" ciblant la quête (result.completion=true)', () => {
-  const calls = [];
-  global.fetch = (url, opts) => { calls.push({ url, opts }); return Promise.resolve(); };
-  forgeXapiNotifyQuestCompleted({ id: 5, title: 'La quête du sorcier' });
   const body = JSON.parse(calls[0].opts.body);
   assert.equal(body.verb.id, 'http://adlnet.gov/expapi/verbs/completed');
-  assert.equal(body.object.id, 'urn:forge-engine:game:test:quest:5');
+  assert.equal(body.object.id, 'urn:forge-engine:game:test:dialogue:d_5');
   assert.equal(body.result.completion, true);
 });
 
 test('forgeXapiNotifyQuestionAnswered envoie un statement "answered" avec success/score, ciblant la question', () => {
   const calls = [];
   global.fetch = (url, opts) => { calls.push({ url, opts }); return Promise.resolve(); };
-  forgeXapiNotifyQuestionAnswered({ id: 5, title: 'La quête du sorcier' }, 1, 'Qui es-tu ?', true, 5);
+  forgeXapiNotifyQuestionAnswered('d_5', 'Le sorcier', 1, 'Qui es-tu ?', true, 5);
   const body = JSON.parse(calls[0].opts.body);
   assert.equal(body.verb.id, 'http://adlnet.gov/expapi/verbs/answered');
-  assert.equal(body.object.id, 'urn:forge-engine:game:test:quest:5:question:1');
+  assert.equal(body.object.id, 'urn:forge-engine:game:test:dialogue:d_5:question:1');
   assert.equal(body.result.success, true);
   assert.equal(body.result.score.raw, 5);
 });
@@ -67,7 +57,7 @@ test('forgeXapiNotifyQuestionAnswered envoie un statement "answered" avec succes
 test('une mauvaise réponse envoie quand même un statement, avec success=false et score=0', () => {
   const calls = [];
   global.fetch = (url, opts) => { calls.push({ url, opts }); return Promise.resolve(); };
-  forgeXapiNotifyQuestionAnswered({ id: 5, title: 'La quête du sorcier' }, 0, 'Qui es-tu ?', false, 0);
+  forgeXapiNotifyQuestionAnswered('d_5', 'Le sorcier', 0, 'Qui es-tu ?', false, 0);
   const body = JSON.parse(calls[0].opts.body);
   assert.equal(body.result.success, false);
   assert.equal(body.result.score.raw, 0);
@@ -76,18 +66,17 @@ test('une mauvaise réponse envoie quand même un statement, avec success=false
 test('le libellé du verbe est fourni en anglais ET en français (LRS libre d\'afficher l\'un ou l\'autre)', () => {
   const calls = [];
   global.fetch = (url, opts) => { calls.push({ url, opts }); return Promise.resolve(); };
-  forgeXapiNotifyQuestAccepted({ id: 5, title: 'La quête du sorcier' });
+  forgeXapiNotifyDialogueCompleted('d_5', 'Le sorcier');
   const body = JSON.parse(calls[0].opts.body);
-  assert.equal(body.verb.display['en-US'], 'attempted');
+  assert.equal(body.verb.display['en-US'], 'completed');
-  assert.equal(body.verb.display['fr-FR'], 'commencé');
+  assert.equal(body.verb.display['fr-FR'], 'terminé');
 });
 
 test('aucun envoi si FORGE_XAPI_CONFIG est null (xAPI non configuré pour ce jeu)', () => {
   global.window.FORGE_XAPI_CONFIG = null;
   let called = false;
   global.fetch = () => { called = true; return Promise.resolve(); };
-  forgeXapiNotifyQuestAccepted({ id: 5, title: 'x' });
+  forgeXapiNotifyDialogueCompleted('d_5', 'x');
-  forgeXapiNotifyQuestCompleted({ id: 5, title: 'x' });
+  forgeXapiNotifyQuestionAnswered('d_5', 'x', 0, 'x', false, 0);
-  forgeXapiNotifyQuestionAnswered({ id: 5, title: 'x' }, 0, 'x', false, 0);
   assert.equal(called, false);
 });

static/js/play/offline/scorm-api.js

@@ -24,7 +24,7 @@ function forgeScormInit() {
   if (!forgeScormApi) return; // ouvert hors LMS (test local) : dégrade en silence
   forgeScormApi.LMSInitialize("");
   // cmi.core.score.min/max (voir publish/build_scorm_package.py,
-  // db/quests/reward_budget.py) : sans eux, le LMS n'a que le score BRUT
+  // db/dialogue_lines.py::sum_question_rewards) : sans eux, le LMS n'a que le score BRUT
   // (cmi.core.score.raw, un total de points sans barème) et l'affiche
   // parfois à tort avec un "%" — en fournissant aussi min/max une seule
   // fois ici, le LMS peut calculer raw/max lui-même, un vrai pourcentage.

static/js/play/offline/scorm2004-api.js

@@ -93,12 +93,12 @@ function forgeScorm2004Timestamp() {
   return new Date().toISOString().replace(/\.\d+Z$/, "");
 }
 
-function forgeScorm2004NotifyQuestionAnswered(quest, questionIndex, questionText, correct, choiceIndex, correctIndex) {
+function forgeScorm2004NotifyQuestionAnswered(dialogueId, objectName, questionIndex, questionText, correct, choiceIndex, correctIndex) {
   if (!forgeScorm2004Api) return;
   var n = parseInt(forgeScorm2004Api.GetValue("cmi.interactions._count"), 10);
   if (isNaN(n)) n = 0;
   var prefix = "cmi.interactions." + n + ".";
-  forgeScorm2004Api.SetValue(prefix + "id", "quest:" + quest.id + ":question:" + questionIndex);
+  forgeScorm2004Api.SetValue(prefix + "id", "dialogue:" + dialogueId + ":question:" + questionIndex);
   forgeScorm2004Api.SetValue(prefix + "type", "choice");
   forgeScorm2004Api.SetValue(prefix + "timestamp", forgeScorm2004Timestamp());
   forgeScorm2004Api.SetValue(prefix + "description", "{fr-FR}" + (questionText || ""));

static/js/play/offline/xapi-client.js

@@ -73,26 +73,28 @@ function forgeXapiObject() {
 }
 
 // Sous-activités xAPI (voir static/js/play/dialogue-box-controller.js) :
-// une quête/question n'est PAS l'activité de premier niveau du jeu
+// un dialogue/question n'est PAS l'activité de premier niveau du jeu
 // (forgeXapiObject ci-dessus) mais une activité fille, identifiée par un
 // id dérivé — assez pour que le LRS les distingue sans configuration
-// supplémentaire côté créateur du jeu.
+// supplémentaire côté créateur du jeu. `objectName` : le nom de l'objet
-function forgeXapiQuestObject(quest) {
+// de scène qui a déclenché ce dialogue (voir "ℹ️ Informations") — plus de
+// "quête" pour le porter.
+function forgeXapiDialogueObject(dialogueId, objectName) {
   var config = window.FORGE_XAPI_CONFIG;
   return {
     objectType: "Activity",
-    id: config.activity_id + ":quest:" + quest.id,
+    id: config.activity_id + ":dialogue:" + dialogueId,
-    definition: { name: { "fr-FR": quest.title || "Quête" }, type: "http://adlnet.gov/expapi/activities/simulation" },
+    definition: { name: { "fr-FR": objectName || "Dialogue" }, type: "http://adlnet.gov/expapi/activities/simulation" },
   };
 }
 
-function forgeXapiQuestionObject(quest, questionIndex, questionText) {
+function forgeXapiQuestionObject(dialogueId, objectName, questionIndex, questionText) {
   var config = window.FORGE_XAPI_CONFIG;
   return {
     objectType: "Activity",
-    id: config.activity_id + ":quest:" + quest.id + ":question:" + questionIndex,
+    id: config.activity_id + ":dialogue:" + dialogueId + ":question:" + questionIndex,
     definition: {
-      name: { "fr-FR": "Question " + (questionIndex + 1) + " — " + (quest.title || "Quête") },
+      name: { "fr-FR": "Question " + (questionIndex + 1) + " — " + (objectName || "Dialogue") },
       description: { "fr-FR": questionText || "" },
       type: "http://adlnet.gov/expapi/activities/cmi.interaction",
       interactionType: "choice",
@@ -146,37 +148,25 @@ function forgeXapiNotifyScoreChanged(newScore) {
   );
 }
 
-// Granularité quête/quiz (voir dialogue-box-controller.js) : demande
+// Granularité dialogue/quiz (voir dialogue-box-controller.js) : demande
-// explicite "il faut savoir quand une quête a été acceptée, à telle
+// explicite "il faut savoir [...] à telle question quel point obtenu,
-// question quel point obtenu, bien répondu ou non" — un statement DÉDIÉ
+// bien répondu ou non" — un statement DÉDIÉ par évènement, distinct du
-// par évènement, distinct du score/statut global (forgeXapiNotify
+// score/statut global (forgeXapiNotifyScoreChanged/StatusChanged
-// ScoreChanged/StatusChanged ci-dessus, qui restent l'activité de
+// ci-dessus, qui restent l'activité de premier niveau).
-// premier niveau).
+function forgeXapiNotifyDialogueCompleted(dialogueId, objectName) {
-function forgeXapiNotifyQuestAccepted(quest) {
-  if (!window.FORGE_XAPI_CONFIG) return;
-  // "attempted" (ADL standard) : pas de verbe dédié "accepted" dans le
-  // vocabulaire ADL de base — attempted rend fidèlement "le joueur s'est
-  // engagé sur cette quête".
-  forgeXapiSendStatement(
-    "http://adlnet.gov/expapi/verbs/attempted",
-    null, forgeXapiQuestObject(quest)
-  );
-}
-
-function forgeXapiNotifyQuestCompleted(quest) {
   if (!window.FORGE_XAPI_CONFIG) return;
   forgeXapiSendStatement(
     "http://adlnet.gov/expapi/verbs/completed",
-    { completion: true }, forgeXapiQuestObject(quest)
+    { completion: true }, forgeXapiDialogueObject(dialogueId, objectName)
   );
 }
 
-function forgeXapiNotifyQuestionAnswered(quest, questionIndex, questionText, correct, scoreAwarded) {
+function forgeXapiNotifyQuestionAnswered(dialogueId, objectName, questionIndex, questionText, correct, scoreAwarded) {
   if (!window.FORGE_XAPI_CONFIG) return;
   forgeXapiSendStatement(
     "http://adlnet.gov/expapi/verbs/answered",
     { success: correct, score: { raw: scoreAwarded || 0 } },
-    forgeXapiQuestionObject(quest, questionIndex, questionText)
+    forgeXapiQuestionObject(dialogueId, objectName, questionIndex, questionText)
   );
 }
 
@@ -203,7 +193,7 @@ if (typeof window !== "undefined") {
 if (typeof module !== "undefined" && module.exports) {
   module.exports = {
     forgeXapiSendStatement, forgeXapiNotifyScoreChanged, forgeXapiNotifyStatusChanged, FORGE_TO_XAPI_VERB,
-    forgeXapiNotifyQuestAccepted, forgeXapiNotifyQuestCompleted, forgeXapiNotifyQuestionAnswered,
+    forgeXapiNotifyDialogueCompleted, forgeXapiNotifyQuestionAnswered,
-    forgeXapiQuestObject, forgeXapiQuestionObject, FORGE_XAPI_VERB_DISPLAY,
+    forgeXapiDialogueObject, forgeXapiQuestionObject, FORGE_XAPI_VERB_DISPLAY,
   };
 }

static/js/quests/quest-editor.js

@@ -1,588 +0,0 @@
-// ---------- Éditeur de quêtes ----------
-// Onglet "🗺️ Quêtes" à côté de "🧩 Collision" (templates/scene_edit.html,
-// jamais une page à part) : une LISTE (mêmes tableau/lignes que l'onglet
-// "📣 Événements") plutôt qu'une grille de cartes. Un clic sur une ligne
-// ouvre la modale de FICHE (titre/objectif/récompense/statut/résultat —
-// "je crée"), qui ouvre à son tour, sur un bouton dédié, la modale
-// PLEIN ÉCRAN d'arbre de dialogue ("j'ajoute les dialogues") — deux
-// étapes séparées, jamais le même formulaire. Les deux modales sont
-// aussi ouvertes depuis l'assistant "+ Action" de l'éditeur de collision
-// (voir static/js/scenes/collision-rules-editor.js) quand l'auteur
-// choisit "Déclencher une quête" — créées dynamiquement (ensureQuest*Modal)
-// plutôt que dupliquées dans deux endroits.
-//
-// Une quête (voir db/quests/) : id, title, objectif, recompense_score,
-// status (nouvelle/en_cours/terminee — statut COURANT, informatif),
-// resultat (reussi/echoue), dialogues (une liste de répliques PAR
-// STATUT — 3 colonnes dans la modale : quel dialogue jouer selon l'état
-// de la quête au moment où le joueur parle au PNJ).
-
-var QUEST_STATUS_LABELS = { nouvelle: 'Nouvelle', en_cours: 'En cours', terminee: 'Terminée' };
-var QUEST_RESULT_LABELS = { reussi: 'Réussi', echoue: 'Échoué' };
-var QUEST_STATUS_ORDER = ['nouvelle', 'en_cours', 'terminee'];
-
-// Quêtes connues côté client — préremplies par QUESTS_JSON (voir
-// templates/scene_edit.html), toujours présentes puisque l'onglet
-// Quêtes vit dans le même éditeur que l'onglet Collision qui en a
-// besoin (collisionRuleActionSummary).
-var QUESTS = (typeof QUESTS_JSON !== 'undefined') ? QUESTS_JSON : [];
-
-// Noms d'objets de scène nommés (voir "ℹ️ Informations", templates/
-// scene_edit.html) — N'IMPORTE QUEL objet (personnage, décor, fond), pas
-// seulement un personnage — proposés comme "qui parle" pour une réplique,
-// en plus de "Joueur" (toujours disponible, jamais un objet de scène).
-var SCENE_OBJECT_NAMES = (typeof SCENE_OBJECT_NAMES_JSON !== 'undefined') ? SCENE_OBJECT_NAMES_JSON : [];
-
-// Une réplique n'a que deux COULEURS possibles (voir .questBubble-joueur/
-// .questBubble-pnj, static/style.css) même si le nom affiché est
-// n'importe quel objet nommé — "Joueur" en vert, n'importe
-// quel autre nom à gauche en bleu (voir demande utilisateur : "les bulles
-// du pnj et du joueur sont d'une couleur différente").
-function questBubbleKind(speaker) {
-  return speaker === 'Joueur' ? 'joueur' : 'pnj';
-}
-
-function questById(questId) {
-  return QUESTS.find(function (q) { return q.id === questId; });
-}
-
-function questListRowHtml(quest) {
-  var resultatHtml = quest.resultat ? '<span class="questPill questPill-resultat">' + QUEST_RESULT_LABELS[quest.resultat] + '</span>' : '<span class="hint">—</span>';
-  return (
-    '<tr class="questListRow" onclick="openQuestFieldsModal(' + quest.id + ')">' +
-      '<td><strong>' + (quest.title || '').replace(/</g, '&lt;') + '</strong></td>' +
-      '<td>' + (quest.objectif ? quest.objectif.replace(/</g, '&lt;') : '<span class="hint">—</span>') + '</td>' +
-      '<td><span class="questPill questPill-score">+' + (quest.recompense_score || 0) + '</span></td>' +
-      '<td><span class="questPill questPill-status questPill-status-' + quest.status + '">' + QUEST_STATUS_LABELS[quest.status] + '</span></td>' +
-      '<td>' + resultatHtml + '</td>' +
-      '<td class="fieldsTableActions">' +
-        '<button type="button" class="button is-small is-danger" title="Supprimer" onclick="event.stopPropagation(); questDeleteFromList(' + quest.id + ')">🗑️</button>' +
-      '</td>' +
-    '</tr>'
-  );
-}
-
-function renderQuestListPage() {
-  var container = document.getElementById('questsTabPanel');
-  if (!container) return;
-  var wrap = document.getElementById('questsListWrap');
-  if (!QUESTS.length) {
-    wrap.innerHTML = '<p class="hint">Aucune quête pour l\'instant — crée-en une avec le bouton ci-dessus.</p>';
-    return;
-  }
-  wrap.innerHTML =
-    '<div class="fieldsTableWrap"><table class="table is-fullwidth is-hoverable fieldsTable">' +
-      '<thead><tr><th>Titre</th><th>Objectif</th><th>Récompense</th><th>Statut</th><th>Résultat</th><th></th></tr></thead>' +
-      '<tbody>' + QUESTS.map(questListRowHtml).join('') + '</tbody>' +
-    '</table></div>';
-}
-
-function createQuestFromListPage() {
-  fetch('/game/' + GAME_SLUG + '/quests/new', {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({}),
-  })
-    .then(function (r) { return r.json(); })
-    .then(function (json) {
-      QUESTS.unshift(json.quest);
-      renderQuestListPage();
-      openQuestFieldsModal(json.quest.id);
-    });
-}
-
-function questDeleteFromList(questId) {
-  var quest = questById(questId);
-  if (!quest || !confirm('Supprimer la quête « ' + quest.title + ' » ? Toute règle de collision qui la référence perdra sa cible.')) return;
-  fetch('/game/' + GAME_SLUG + '/quests/' + questId + '/delete', { method: 'POST' })
-    .then(function () {
-      QUESTS = QUESTS.filter(function (q) { return q.id !== questId; });
-      renderQuestListPage();
-    });
-}
-
-// ---------- Deux modales distinctes ----------
-// 1. #questFieldsModal (taille normale) : "je crée" — titre/objectif/
-//    récompense/statut/résultat, + un bouton qui ouvre...
-// 2. #questDialogueModal (PLEIN ÉCRAN) : "j'ajoute les dialogues" — les
-//    3 colonnes de répliques, rien d'autre. Étapes séparées demandées
-//    explicitement par l'utilisateur (pas un seul gros formulaire).
-// Créées une seule fois chacune (au premier appel), réutilisées ensuite —
-// partagées avec l'assistant "+ Action" de l'éditeur de collision,
-// jamais dupliquées dans les templates.
-var _questModalOnUse = null;
-var _questModalCurrentId = null;
-
-function ensureQuestFieldsModal() {
-  var modal = document.getElementById('questFieldsModal');
-  if (modal) return modal;
-  modal = document.createElement('div');
-  modal.className = 'modal';
-  modal.id = 'questFieldsModal';
-  modal.innerHTML =
-    '<div class="modal-background" onclick="closeQuestFieldsModal()"></div>' +
-    '<div class="modal-content questFieldsModalContent"><div class="box">' +
-      '<div id="questFieldsModalBody"></div>' +
-    '</div></div>';
-  document.body.appendChild(modal);
-  return modal;
-}
-
-// `onUse(quest)` optionnel : posé par collisionWizardChooseAction('quete', ...)
-// pour finaliser la règle de collision avec cette quête, affiche alors un
-// bouton "✓ Utiliser cette quête" dans les deux modales.
-//
-// Masque #collisionRuleModal s'il est ouvert, SANS effacer _collisionWizard
-// (contrairement à closeCollisionRuleModal(), static/js/scenes/
-// collision-rules-editor.js) : appelée depuis questPickerChoose()/
-// questPickerCreate() (assistant "+ Action" de l'onglet Collision, action
-// "quete" — voir renderQuestPickerStep()), CETTE modale et
-// #collisionRuleModal partagent le même z-index (.modal de base) — sans la
-// masquer, les deux restaient actives en même temps, empilées dans l'ordre
-// du DOM plutôt que l'une à la place de l'autre : le bouton "+ Action"
-// semblait ne plus rien faire ensuite (il rouvrait bien #collisionRuleModal,
-// mais caché derrière celle-ci restée active). _collisionWizard doit
-// SURVIVRE à ce masquage : "✓ Utiliser cette quête" (questUseThisQuest)
-// finalise la règle en cours via collisionWizardFinalizeAction(), qui en a
-// encore besoin (objectId, trigger, pendingInteragir pour "interagir").
-function _hideCollisionRuleModalKeepingWizardState() {
-  var modal = document.getElementById('collisionRuleModal');
-  if (modal) modal.classList.remove('is-active');
-}
-
-function openQuestFieldsModal(questId, onUse) {
-  _hideCollisionRuleModalKeepingWizardState();
-  _questModalOnUse = onUse || null;
-  _questModalCurrentId = questId;
-  var modal = ensureQuestFieldsModal();
-  modal.classList.add('is-active');
-  renderQuestFieldsModalBody(questId);
-}
-
-// _questModalOnUse/_questModalCurrentId ne sont PAS remis à null ici :
-// openQuestDialogueModal() ferme cette modale en s'ouvrant (voir plus
-// bas) et a besoin de les garder pour son propre bouton "✓ Utiliser
-// cette quête" — chaque point d'entrée (openQuestFieldsModal) les fixe
-// de toute façon fraîchement à chaque ouverture.
-function closeQuestFieldsModal() {
-  var modal = document.getElementById('questFieldsModal');
-  if (modal) modal.classList.remove('is-active');
-}
-
-function questUseThisQuest(questId) {
-  var quest = questById(questId);
-  if (_questModalOnUse && quest) _questModalOnUse(quest);
-  closeQuestDialogueModal();
-  closeQuestFieldsModal();
-  _questModalOnUse = null;
-  _questModalCurrentId = null;
-}
-
-function questFieldRowHtml(quest) {
-  return (
-    '<div class="questFieldsGrid">' +
-      '<label class="questField"><span>Titre</span><input type="text" class="input" value="' + (quest.title || '').replace(/"/g, '&quot;') + '" onchange="questUpdateField(' + quest.id + ", 'title', this.value)\"></label>" +
-      '<label class="questField questField-wide"><span>Objectif</span><input type="text" class="input" value="' + (quest.objectif || '').replace(/"/g, '&quot;') + '" onchange="questUpdateField(' + quest.id + ", 'objectif', this.value)\"></label>" +
-      '<label class="questField"><span>Récompense (score)</span><input type="number" class="input" value="' + (quest.recompense_score || 0) + '" onchange="questUpdateField(' + quest.id + ", 'recompense_score', this.value)\"></label>" +
-      '<label class="questField"><span>Statut</span><select class="input" onchange="questUpdateField(' + quest.id + ", 'status', this.value)\">" +
-        QUEST_STATUS_ORDER.map(function (s) { return '<option value="' + s + '"' + (quest.status === s ? ' selected' : '') + '>' + QUEST_STATUS_LABELS[s] + '</option>'; }).join('') +
-      '</select></label>' +
-      '<label class="questField"><span>Résultat</span><select class="input" onchange="questUpdateField(' + quest.id + ", 'resultat', this.value)\">" +
-        '<option value=""' + (!quest.resultat ? ' selected' : '') + '>—</option>' +
-        '<option value="reussi"' + (quest.resultat === 'reussi' ? ' selected' : '') + '>Réussi</option>' +
-        '<option value="echoue"' + (quest.resultat === 'echoue' ? ' selected' : '') + '>Échoué</option>' +
-      '</select></label>' +
-    '</div>'
-  );
-}
-
-function renderQuestFieldsModalBody(questId) {
-  var quest = questById(questId);
-  var body = document.getElementById('questFieldsModalBody');
-  if (!quest || !body) return;
-  var useBtn = _questModalOnUse
-    ? '<button type="button" class="collisionRuleAddBtn" onclick="questUseThisQuest(' + quest.id + ')">Utiliser cette quête</button>'
-    : '';
-  body.innerHTML =
-    '<div class="fieldRow questDialogueModalHeader" style="align-items:center; justify-content:space-between;">' +
-      '<h2 class="title is-5" style="margin:0;">' + (quest.title || '').replace(/</g, '&lt;') + '</h2>' +
-      '<button type="button" class="button is-small" onclick="closeQuestFieldsModal()">✕</button>' +
-    '</div>' +
-    questFieldRowHtml(quest) +
-    '<div class="fieldRow" style="justify-content:space-between; align-items:center; margin-top:6px;">' +
-      '<button type="button" class="collisionRuleAddBtn" onclick="openQuestDialogueModal(' + quest.id + ')">Ajouter les dialogues</button>' +
-      useBtn +
-    '</div>';
-}
-
-// Options du <select> "qui parle" — "Joueur" toujours en premier, puis
-// chaque personnage nommé (voir "ℹ️ Informations"), plus le speaker
-// ACTUEL de la réplique s'il n'est plus dans cette liste (personnage
-// renommé/supprimé depuis) pour ne jamais perdre silencieusement la
-// valeur déjà enregistrée.
-function questSpeakerOptions(currentSpeaker) {
-  var options = ['Joueur'].concat(SCENE_OBJECT_NAMES);
-  if (currentSpeaker && options.indexOf(currentSpeaker) === -1) options.push(currentSpeaker);
-  return options;
-}
-
-// Une bulle = header (qui parle, menu déroulant des objets de scène
-// nommés — voir "ℹ️ Informations") + body (le texte) — deux zones
-// distinctes demandées explicitement, pas un seul bloc. Toujours centrée
-// dans sa colonne, 70% de la largeur (voir .questBubble, static/style.css) —
-// aucune limite au nombre de bulles par colonne (voir questAddBubble).
-function questDialogueBubbleHtml(line, status, index) {
-  var kind = questBubbleKind(line.speaker);
-  var speakerSelect = questSpeakerOptions(line.speaker).map(function (name) {
-    return '<option value="' + name.replace(/"/g, '&quot;') + '"' + (name === line.speaker ? ' selected' : '') + '>' + (name === 'Joueur' ? 'Joueur' : name) + '</option>';
-  }).join('');
-  return (
-    '<div class="questBubbleRow">' +
-      '<div class="questBubble questBubble-' + kind + '">' +
-        '<div class="questBubbleHeader">' +
-          '<select class="questBubbleSpeaker" title="Qui parle" onchange="questSetBubbleSpeaker(\'' + status + '\', ' + index + ', this.value)">' + speakerSelect + '</select>' +
-          '<button type="button" class="questBubbleDelete" title="Supprimer" onclick="questDeleteBubble(\'' + status + '\', ' + index + ')">✕</button>' +
-        '</div>' +
-        '<div class="questBubbleBody">' +
-          '<textarea class="questBubbleText" rows="1" placeholder="Réplique..." ' +
-            'oninput="this.style.height=\'auto\'; this.style.height=this.scrollHeight+\'px\';" ' +
-            'onchange="questUpdateBubbleText(\'' + status + '\', ' + index + ', this.value)">' + line.text.replace(/</g, '&lt;') + '</textarea>' +
-        '</div>' +
-      '</div>' +
-    '</div>'
-  );
-}
-
-function questEscAttr(str) {
-  return (str || '').replace(/"/g, '&quot;');
-}
-
-// "❓ Question" — une bulle JAUNE dans la même chaîne qu'une réplique de
-// dialogue (même colonne, même alignement vertical relié par un trait,
-// voir .questBubbleRow/.questBubble ci-dessus et static/style.css) mais
-// un type de ligne différent (voir db/quests/sanitize_quest_dialogues.py) :
-// header = nombre de choix + récompense (type + montant), body = la
-// question et ses choix, avec la bonne réponse cochée. Aucune limite au
-// nombre de questions par colonne (voir questAddQuestion), comme pour
-// une réplique.
-function questQuestionChoiceRowHtml(choice, choiceIndex, correctIndex, status, index) {
-  var radioName = 'questCorrect-' + status + '-' + index;
-  return (
-    '<div class="questChoiceRow">' +
-      '<input type="radio" name="' + radioName + '" class="questChoiceRadio" title="Bonne réponse" ' +
-        (choiceIndex === correctIndex ? 'checked' : '') +
-        ' onchange="questSetQuestionCorrectIndex(\'' + status + '\', ' + index + ', ' + choiceIndex + ')">' +
-      '<input type="text" class="questChoiceInput" placeholder="Choix ' + (choiceIndex + 1) + '" value="' + questEscAttr(choice) + '" ' +
-        'onchange="questSetQuestionChoiceText(\'' + status + '\', ' + index + ', ' + choiceIndex + ', this.value)">' +
-    '</div>'
-  );
-}
-
-function questQuestionBubbleHtml(line, status, index) {
-  var choicesHtml = line.choices.map(function (c, i) { return questQuestionChoiceRowHtml(c, i, line.correct_index, status, index); }).join('');
-  return (
-    '<div class="questBubbleRow">' +
-      '<div class="questBubble questBubble-question">' +
-        '<div class="questBubbleHeader">' +
-          '<label class="questQuestionHeaderField" title="Nombre de choix"><input type="number" min="2" max="4" value="' + line.choices.length + '" ' +
-            'onchange="questSetQuestionChoiceCount(\'' + status + '\', ' + index + ', this.value)"></label>' +
-          '<label class="questQuestionHeaderField" title="Récompense (points de score)"><input type="number" min="0" value="' + line.reward_amount + '" ' +
-            'onchange="questSetQuestionRewardAmount(\'' + status + '\', ' + index + ', this.value)"> pts</label>' +
-          '<button type="button" class="questBubbleDelete" title="Supprimer" onclick="questDeleteBubble(\'' + status + '\', ' + index + ')">✕</button>' +
-        '</div>' +
-        '<div class="questBubbleBody">' +
-          '<input type="text" class="questQuestionText" placeholder="Question..." value="' + questEscAttr(line.text) + '" ' +
-            'onchange="questUpdateQuestionText(\'' + status + '\', ' + index + ', this.value)">' +
-          '<div class="questChoicesList">' + choicesHtml + '</div>' +
-        '</div>' +
-      '</div>' +
-    '</div>'
-  );
-}
-
-function questDialogueColumnHtml(quest, status) {
-  var lines = (quest.dialogues && quest.dialogues[status]) || [];
-  var bubblesHtml = lines.map(function (line, i) {
-    return line.type === 'question' ? questQuestionBubbleHtml(line, status, i) : questDialogueBubbleHtml(line, status, i);
-  }).join('');
-  return (
-    '<div class="questDialogueColumn">' +
-      '<h4 class="questDialogueColumnTitle">' + QUEST_STATUS_LABELS[status] + '</h4>' +
-      '<div class="questDialogueColumnBubbles" id="questDialogueColumn-' + status + '">' + bubblesHtml + '</div>' +
-      '<div class="questDialogueColumnButtons">' +
-        '<button type="button" class="collisionRuleAddBtn questDialogueAddBtn" onclick="questAddBubble(\'' + status + '\')">Réplique</button>' +
-        '<button type="button" class="collisionRuleAddBtn questDialogueAddBtn questQuestionAddBtn" onclick="questAddQuestion(\'' + status + '\')">Question</button>' +
-      '</div>' +
-    '</div>'
-  );
-}
-
-// Modale de dialogue — PLEIN ÉCRAN (voir .questDialogueModal en CSS),
-// ouverte DEPUIS la modale de fiche (bouton "💬 Ajouter les dialogues"),
-// jamais les deux à la fois : referme la fiche en s'ouvrant plutôt que de
-// les empiler, "← Fiche de la quête" y ramène.
-function ensureQuestDialogueModal() {
-  var modal = document.getElementById('questDialogueModal');
-  if (modal) return modal;
-  modal = document.createElement('div');
-  modal.className = 'modal questDialogueModal';
-  modal.id = 'questDialogueModal';
-  modal.innerHTML =
-    '<div class="modal-background" onclick="closeQuestDialogueModal()"></div>' +
-    '<div class="modal-content questDialogueModalContent"><div class="box">' +
-      '<div id="questDialogueModalBody"></div>' +
-    '</div></div>';
-  document.body.appendChild(modal);
-  return modal;
-}
-
-function openQuestDialogueModal(questId) {
-  _questModalCurrentId = questId;
-  closeQuestFieldsModal();
-  var modal = ensureQuestDialogueModal();
-  modal.classList.add('is-active');
-  renderQuestDialogueModalBody(questId);
-}
-
-function closeQuestDialogueModal() {
-  var modal = document.getElementById('questDialogueModal');
-  if (modal) modal.classList.remove('is-active');
-}
-
-function questBackToFieldsModal(questId) {
-  closeQuestDialogueModal();
-  openQuestFieldsModal(questId, _questModalOnUse);
-}
-
-function renderQuestDialogueModalBody(questId) {
-  var quest = questById(questId);
-  var body = document.getElementById('questDialogueModalBody');
-  if (!quest || !body) return;
-  _questModalCurrentId = questId;
-  var useBtn = _questModalOnUse
-    ? '<button type="button" class="collisionRuleAddBtn" onclick="questUseThisQuest(' + quest.id + ')">Utiliser cette quête</button>'
-    : '';
-  body.innerHTML =
-    '<div class="fieldRow questDialogueModalHeader" style="align-items:center; justify-content:space-between;">' +
-      '<div style="display:flex; align-items:center; gap:10px;">' +
-        '<button type="button" class="button is-small" onclick="questBackToFieldsModal(' + quest.id + ')" title="Retour à la fiche">←</button>' +
-        '<h2 class="title is-5" style="margin:0;">' + (quest.title || '').replace(/</g, '&lt;') + ' — dialogues</h2>' +
-      '</div>' +
-      '<div style="display:flex; gap:8px; align-items:center;">' + useBtn +
-        '<button type="button" class="button is-small" onclick="closeQuestDialogueModal()">✕</button>' +
-      '</div>' +
-    '</div>' +
-    '<p class="hint mt-2 mb-2">Dialogue joué selon l\'état de la quête au moment où le joueur parle au PNJ :</p>' +
-    '<div class="questDialogueColumns">' + QUEST_STATUS_ORDER.map(function (s) { return questDialogueColumnHtml(quest, s); }).join('') + '</div>';
-}
-
-function questUpdateField(questId, field, value) {
-  var quest = questById(questId);
-  if (!quest) return;
-  var body = {};
-  body[field] = field === 'recompense_score' ? Number(value) : (value || null);
-  fetch('/game/' + GAME_SLUG + '/quests/' + questId, {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
-  })
-    .then(function (r) { return r.json().then(function (json) { return { ok: r.ok, json: json }; }); })
-    .then(function (res) {
-      // Refusé (400) : recompense_score abaissé sous le total déjà
-      // réparti entre les questions (voir routes/quests/quest_update.py)
-      // — message d'erreur demandé explicitement, et le champ est
-      // remis à sa valeur RÉELLE (inchangée côté serveur).
-      if (!res.ok) { alert(res.json.error || "Impossible d'enregistrer."); renderQuestFieldsModalBody(questId); return; }
-      if (!res.json.quest) return;
-      Object.assign(quest, res.json.quest);
-      renderQuestListPage();
-      renderQuestFieldsModalBody(questId); // seule modale à porter des champs éditables
-    });
-}
-
-// Dialogues : toujours les 3 colonnes ENTIÈRES postées ensemble (voir
-// db/quests/set_quest_dialogues.py) — jamais une réplique isolée.
-// N'ADOPTE JAMAIS la réponse du serveur comme nouvel état local (bug
-// corrigé : sanitize_quest_dialogues.py rejette toute réplique au texte
-// encore vide — juste ajoutée, pas encore tapée — donc chaque
-// enregistrement renvoyait un tableau amputé de la bulle en cours
-// d'écriture ; l'adopter effaçait silencieusement la bulle que l'auteur
-// venait d'ajouter, et le clic suivant sur "+ Réplique" semblait la
-// "remplacer" au lieu d'en ajouter une seconde). L'état local, construit
-// par des mutations client explicites, est déjà la seule source de
-// vérité pendant l'édition.
-function questSaveDialogues(quest) {
-  fetch('/game/' + GAME_SLUG + '/quests/' + quest.id + '/dialogues', {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ dialogues: quest.dialogues }),
-  })
-    .then(function (r) {
-      // Refusé (400) : la somme des récompenses des questions dépasse la
-      // récompense totale de la quête (voir routes/quests/quest_dialogues.py)
-      // — message d'erreur demandé explicitement. La bulle en trop reste
-      // affichée localement (non enregistrée) : l'auteur baisse son
-      // montant ou celui d'une autre question pour repasser sous le budget.
-      if (!r.ok) return r.json().then(function (json) { alert(json.error || "Impossible d'enregistrer."); });
-    });
-}
-
-// Alterne "Joueur" <-> le premier personnage nommé (ou "PNJ" faute de
-// mieux, si aucun personnage n'a encore de nom — voir "ℹ️ Informations")
-// — juste un défaut de départ, l'auteur choisit ensuite librement dans
-// le menu déroulant de la réplique.
-function questNextDefaultSpeaker(lastSpeaker) {
-  if (lastSpeaker === 'Joueur') return SCENE_OBJECT_NAMES[0] || 'PNJ';
-  return 'Joueur';
-}
-
-function questAddBubble(status) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues = quest.dialogues || {};
-  var lines = quest.dialogues[status] || (quest.dialogues[status] = []);
-  var lastSpeaker = lines.length ? lines[lines.length - 1].speaker : 'PNJ';
-  lines.push({ type: 'dialogue', speaker: questNextDefaultSpeaker(lastSpeaker), text: '' });
-  renderQuestDialogueModalBody(quest.id);
-  questSaveDialogues(quest);
-}
-
-// "❓ Question" — voir questQuestionBubbleHtml ci-dessus. Défauts : 2
-// choix vides, la 1ère cochée bonne réponse, récompense "score" à 0 pt
-// (l'auteur règle le montant dans le header de la bulle).
-function questAddQuestion(status) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues = quest.dialogues || {};
-  var lines = quest.dialogues[status] || (quest.dialogues[status] = []);
-  lines.push({ type: 'question', text: '', choices: ['', ''], correct_index: 0, reward_type: 'score', reward_amount: 0 });
-  renderQuestDialogueModalBody(quest.id);
-  questSaveDialogues(quest);
-}
-
-function questUpdateQuestionText(status, index, text) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status][index].text = text;
-  questSaveDialogues(quest);
-}
-
-// Ajuste le NOMBRE de choix (2 à 8, voir db/quests/sanitize_quest_dialogues.py
-// ::_MIN_CHOICES/_MAX_CHOICES) : ajoute des choix vides ou retire les
-// derniers, sans jamais toucher aux choix déjà remplis qui restent dans
-// la nouvelle taille. Recadre la bonne réponse sur le premier choix si
-// elle pointait vers un choix retiré.
-function questSetQuestionChoiceCount(status, index, value) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  var line = quest.dialogues[status][index];
-  var count = Math.max(2, Math.min(4, parseInt(value, 10) || 2));
-  while (line.choices.length < count) line.choices.push('');
-  while (line.choices.length > count) line.choices.pop();
-  if (line.correct_index >= line.choices.length) line.correct_index = 0;
-  renderQuestDialogueModalBody(quest.id);
-  questSaveDialogues(quest);
-}
-
-function questSetQuestionChoiceText(status, index, choiceIndex, text) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status][index].choices[choiceIndex] = text;
-  questSaveDialogues(quest);
-}
-
-function questSetQuestionCorrectIndex(status, index, choiceIndex) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status][index].correct_index = choiceIndex;
-  questSaveDialogues(quest);
-}
-
-function questSetQuestionRewardAmount(status, index, value) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status][index].reward_amount = Math.max(0, parseInt(value, 10) || 0);
-  questSaveDialogues(quest);
-}
-
-function questSetBubbleSpeaker(status, index, speaker) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status][index].speaker = speaker;
-  renderQuestDialogueModalBody(quest.id);
-  questSaveDialogues(quest);
-}
-
-function questUpdateBubbleText(status, index, text) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status][index].text = text;
-  questSaveDialogues(quest);
-}
-
-function questDeleteBubble(status, index) {
-  var quest = questById(_currentQuestModalId());
-  if (!quest) return;
-  quest.dialogues[status].splice(index, 1);
-  renderQuestDialogueModalBody(quest.id);
-  questSaveDialogues(quest);
-}
-
-function _currentQuestModalId() {
-  return _questModalCurrentId;
-}
-
-// ---------- Sélecteur de quête (assistant "+ Action" de l'éditeur de collision) ----------
-// Affiche des cartes + "+ Nouvelle quête" DANS la modale de collision
-// déjà ouverte (voir renderCollisionWizardActionStep) ; choisir/créer une
-// quête ouvre ENSUITE la modale de FICHE (celle-ci par-dessus), avec un
-// bouton "✓ Utiliser cette quête" (disponible aussi depuis la modale de
-// dialogue) qui referme tout et finalise la règle — exactement le
-// comportement demandé : cliquer "Déclencher une quête" ouvre l'éditeur
-// de quête, pas un simple champ texte.
-function questPickerHtml(quests) {
-  if (!quests.length) {
-    return '<p class="hint mb-2">Aucune quête pour l\'instant.</p>';
-  }
-  return '<div class="collisionWizardChoices">' + quests.map(function (q, i) {
-    return '<button type="button" class="collisionWizardChoice" style="animation-delay:' + (i * 40) + 'ms" onclick="questPickerChoose(' + q.id + ')">' +
-      '<span>' + (q.title || '').replace(/</g, '&lt;') + '</span>' +
-    '</button>';
-  }).join('') + '</div>';
-}
-
-var _questPickerOnUse = null;
-
-function renderQuestPickerStep(onUse) {
-  _questPickerOnUse = onUse;
-  var body = collisionWizardBodyEl();
-  body.innerHTML = '<p class="hint mb-2">Quelle quête déclencher ?</p><div id="questPickerList">Chargement…</div>' +
-    '<button type="button" class="collisionRuleAddBtn mt-2" onclick="questPickerCreate()">Nouvelle quête</button>';
-  fetch('/game/' + GAME_SLUG + '/quests/list.json')
-    .then(function (r) { return r.json(); })
-    .then(function (json) {
-      QUESTS = json.quests;
-      var list = document.getElementById('questPickerList');
-      if (list) list.innerHTML = questPickerHtml(QUESTS);
-    });
-}
-
-function questPickerChoose(questId) {
-  openQuestFieldsModal(questId, _questPickerOnUse);
-}
-
-function questPickerCreate() {
-  fetch('/game/' + GAME_SLUG + '/quests/new', {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({}),
-  })
-    .then(function (r) { return r.json(); })
-    .then(function (json) {
-      QUESTS.unshift(json.quest);
-      openQuestFieldsModal(json.quest.id, _questPickerOnUse);
-    });
-}
-
-// Appelé directement (pas de DOMContentLoaded) : ce fichier est chargé par
-// un <script src> posé à la fin du contenu de la page — les éléments dont
-// on a besoin existent déjà à ce stade. Nécessaire aussi pour la
-// navigation pjax (voir static/pjax.js — runScriptsIn ré-exécute ce
-// script à chaque page swappée, mais DOMContentLoaded, lui, ne se
-// redéclenche jamais après le tout premier chargement réel) — sans ça,
-// l'onglet "🗺️ Quêtes" restait vide après un remplacement de <main> (ex.
-// suppression d'un objet de scène, voir scene_object_delete.py) qui ne
-// redéclenche jamais cet événement.
-if (typeof QUESTS_JSON !== 'undefined') renderQuestListPage();

static/js/scenes/collision-rules-editor.js

@@ -1,185 +1,77 @@
-// ---------- Éditeur de collision (nouvel onglet "🧩 Collision") ----------
+// ---------- Assistant "déclencheur -> action" (fusionné dans l'onglet "Déclencheurs") ----------
-// Une carte par objet ÉLIGIBLE (jamais un "fond", jamais le personnage
+// L'onglet "🧩 Collision" séparé a été retiré (redondant une fois la
-// "joueur" — voir COLLISION_RULE_OBJECTS, construit par routes/scenes/
+// vue/gestion des déclencheurs intégrée à l'onglet "Déclencheurs", voir
-// scene_edit_view.py), listant ses règles "déclencheur -> action" déjà
+// static/js/triggers/trigger-editor.js::openAddTriggerModal) — ce
-// posées + un bouton "+ Action" qui ouvre un assistant pas à pas (jamais
+// fichier ne porte plus que le MOTEUR de l'assistant lui-même
-// un vrai formulaire à plusieurs champs) : un clic choisit une option, la
+// (déclencheur -> action, un clic choisit une option, la carte suivante
-// carte suivante s'emboîte aussitôt. Voir screens/rendering/
+// s'emboîte aussitôt), invoqué exclusivement via openTriggerWizard()
-// collision_rules.py pour la forme exacte d'une règle (côté serveur, où
+// ci-dessous. Voir screens/rendering/collision_rules.py pour la forme
-// elle est validée une seconde fois avant d'être enregistrée).
+// exacte d'une règle (côté serveur, où elle est validée une seconde fois
+// avant d'être enregistrée).
 
 var COLLISION_ACTION_LABELS = {
-  quete: 'Déclencher une quête', attaque: 'Attaquer la cible',
+  dialogue: 'Déclencher ce dialogue', variable: 'Modifier une variable',
-  evenement: 'Déclencher un événement', interagir: 'Interagir avec une touche',
+  interagir: 'Interagir avec une touche', condition: 'Si une condition est vraie',
 };
-// "attaque"/"evenement" retirés de l'assistant (pas besoin pour le
+var COLLISION_WIZARD_ACTION_TYPES = ['dialogue', 'variable', 'interagir', 'condition'];
-// moment, demande explicite) — server-side (screens/rendering/
+var COLLISION_TRIGGER_LABELS = { collision: 'À la collision' };
-// collision_rules.py::ACTION_TYPES) les accepte encore telles quelles,
+// Opérations qui n'ont besoin d'AUCUNE valeur (voir screens/labels/
-// pour ne jamais casser une règle déjà enregistrée avec l'un des deux.
+// data_operations.py::DATA_OPERATIONS) — le champ valeur de l'étape
-var COLLISION_WIZARD_ACTION_TYPES = ['quete', 'interagir'];
+// "Modifier une variable" (renderCollisionWizardVariableStep) se masque
-var COLLISION_TRIGGER_LABELS = { collision: 'À la collision', perimetre: 'Dans un périmètre' };
+// pour celles-ci.
-
+var COLLISION_NO_VALUE_OPERATIONS = ['definir_bool_vrai', 'definir_bool_faux', 'basculer_bool'];
-function collisionRuleObjectLabel(obj) {
-  var kindLabel = obj.kind === 'personnage' ? (obj.role === 'ennemie' ? 'Ennemi' : 'PNJ') : 'Décor';
-  return (obj.name || kindLabel);
-}
-
-// Un maillon = un segment de la "chaîne de pièces" affichée dans la carte
-// (déclencheur, puis action, puis éventuellement sous-action) — texte
-// seul, la logique de lecture vit dans collisionRuleActionSummary/
-// collisionRuleTriggerSummary ci-dessous.
-function collisionRuleTriggerSummary(rule) {
-  if (rule.trigger === 'perimetre') return COLLISION_TRIGGER_LABELS.perimetre + ' (' + rule.perimetre_px + 'px)';
-  return COLLISION_TRIGGER_LABELS.collision;
-}
-
-function collisionRuleActionSummary(action) {
-  if (action.type === 'quete') {
-    var quest = (typeof questById === 'function') ? questById(action.quete_id) : null;
-    return COLLISION_ACTION_LABELS.quete + ' « ' + (quest ? quest.title : '#' + action.quete_id) + ' »';
-  }
-  if (action.type === 'evenement') {
-    var ev = CUSTOM_EVENTS_MAP[action.evenement_id];
-    return COLLISION_ACTION_LABELS.evenement + ' « ' + (ev ? ev.name : '?') + ' »';
-  }
-  return COLLISION_ACTION_LABELS[action.type] || action.type;
-}
-
-// Une règle = une chaîne de "maillons" en forme de pièces qui s'emboîtent
-// (déclencheur -> action -> sous-action éventuelle), pas une liste plate —
-// chaque maillon porte un data-kind (couleur en CSS) et un délai d'entrée
-// en cascade (voir @keyframes collisionLinkIn, static/style.css).
-function collisionRuleChainHtml(rule, ruleIndex, objectId) {
-  var links = [
-    { kind: 'trigger', text: collisionRuleTriggerSummary(rule) },
-    { kind: rule.action.type, text: collisionRuleActionSummary(rule.action), questId: rule.action.quete_id },
-  ];
-  var action = rule.action;
-  while (action.type === 'interagir' && action.sub_action) {
-    links.push({ kind: action.sub_action.type, text: collisionRuleActionSummary(action.sub_action), questId: action.sub_action.quete_id });
-    action = action.sub_action;
-  }
-  // Un maillon "quete" (kind==='quete') ouvre directement sa modale de
-  // dialogue (voir openQuestDialogueModal(), static/js/quests/
-  // quest-editor.js) au clic — demande explicite, plutôt qu'un simple
-  // texte informatif comme les autres maillons. Reste un <span> comme les
-  // autres (jamais un <button>, dont le style natif — apparence système,
-  // marges par défaut — grignotait la pointe en clip-path malgré les
-  // resets CSS) : un onclick sur un <span> suffit à le rendre cliquable,
-  // ".collisionRuleLink[data-kind='quete']" ajoute juste le curseur/hover
-  // qui le distingue visuellement (voir static/style.css).
-  var linksHtml = links.map(function (link, i) {
-    var clickable = link.kind === 'quete' && link.questId != null;
-    var onclick = clickable ? ' onclick="openQuestDialogueModal(' + link.questId + ')"' : '';
-    return '<span class="collisionRuleLink" data-kind="' + link.kind + '" style="animation-delay:' + (i * 60) + 'ms"' + onclick + '>' +
-      link.text.replace(/</g, '&lt;') + '</span>';
-  }).join('');
-  return (
-    '<div class="collisionRuleChain">' +
-      '<div class="collisionRuleChainLinks">' + linksHtml + '</div>' +
-      '<button type="button" class="collisionRuleChainDelete" title="Supprimer cette règle" ' +
-        'onclick="deleteCollisionRule(' + objectId + ', ' + ruleIndex + ')">🗑️</button>' +
-    '</div>'
-  );
-}
 
 // obj.thumbnail_html (screens.render_scene_object) porte un style inline
 // PENSÉ POUR LE CANEVAS (position:absolute + left/top en dur, voir
 // screens/scenes/render_scene_object.py) — un personnage déplacé loin
 // dans la scène (left/top de plusieurs centaines de px) ressortait donc
-// hors du petit cadre 120×120 de cette miniature : la règle CSS
+// hors du petit cadre de la miniature : la règle CSS `.questTriggerObjectCard
-// `.collisionRuleCardThumb img` (voir static/style.css) est censée le
+// img`/`.questTriggerObjectThumb img` (static/style.css) est censée le
-// neutraliser (position:static !important etc.), mais s'appuyer sur un
+// neutraliser, mais s'appuyer sur un forçage CSS pour annuler un style
-// forçage CSS pour annuler un style inline entier reste fragile. Plus
+// inline entier reste fragile. Plus robuste : reconstruire ici une balise
-// robuste : reconstruire ici une balise <img> "propre", sans AUCUN style
+// <img> "propre", sans AUCUN style hérité du canevas — seul le src
-// hérité du canevas — seul le src (l'image elle-même) est repris.
+// (l'image elle-même) est repris. Utilisée par static/js/triggers/
+// trigger-editor.js (chaîne de bulles + grille de choix d'objet).
 function collisionRuleThumbHtml(obj) {
   var match = /\ssrc="([^"]*)"/.exec(obj.thumbnail_html || '');
   return match ? '<img src="' + match[1] + '" alt="">' : '';
 }
 
-function collisionRuleCardHtml(obj) {
+// Id court généré CÔTÉ CLIENT pour une NOUVELLE feuille ("dialogue" ou
-  var rulesHtml = obj.rules.length
+// "variable", voir screens/rendering/collision_rules.py) — jamais
-    ? obj.rules.map(function (rule, i) { return collisionRuleChainHtml(rule, i, obj.id); }).join('')
+// recalculé/réattribué côté serveur. Pour un dialogue, sert de
-    : '<p class="hint">Aucune règle pour l\'instant.</p>';
+// dialogue.id (édité en ligne, voir trigger-editor.js) ; pour une
-  return (
+// variable, sert d'id à la feuille elle-même — dans les deux cas,
-    '<div class="collisionRuleCard" id="collisionRuleCard-' + obj.id + '">' +
+// permet d'adresser CETTE feuille précise pour y attacher un "then"
-      '<div class="collisionRuleCardHeader">' +
+// plus tard (voir "+ Ajouter une action", trigger-editor.js).
-        '<div class="collisionRuleCardThumb">' + collisionRuleThumbHtml(obj) + '</div>' +
+function collisionGenerateActionId() {
-        '<h3 class="collisionRuleCardTitle">' + collisionRuleObjectLabel(obj).replace(/</g, '&lt;') + '</h3>' +
+  return 'd_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-      '</div>' +
-      '<div class="collisionRuleCardRules">' + rulesHtml + '</div>' +
-      '<button type="button" class="collisionRuleAddBtn" onclick="openCollisionRuleModal(' + obj.id + ')">Action</button>' +
-    '</div>'
-  );
 }
 
-function renderCollisionRuleCards() {
+// ---------- Assistant "déclencheur -> action" ----------
-  var container = document.getElementById('collisionRulesCards');
-  if (!container) return;
-  if (!COLLISION_RULE_OBJECTS.length) {
-    container.innerHTML = '<p class="hint">Aucun objet éligible pour l\'instant — un décor, un ennemi ou un PNJ (jamais le joueur lui-même).</p>';
-    return;
-  }
-  // Chaque carte entre en cascade (voir @keyframes collisionCardIn,
-  // static/style.css) plutôt que toutes en même temps.
-  container.innerHTML = COLLISION_RULE_OBJECTS.map(function (obj, i) {
-    return collisionRuleCardHtml(obj).replace('<div class="collisionRuleCard"', '<div style="animation-delay:' + (i * 50) + 'ms" class="collisionRuleCard"');
-  }).join('');
-}
-
-function collisionRuleObjectById(objectId) {
-  return COLLISION_RULE_OBJECTS.find(function (o) { return o.id === objectId; });
-}
-
-// Enregistre la liste COMPLÈTE des règles de cet objet (voir
-// routes/scenes/scene_object_collision_rules.py — toujours la liste
-// entière, jamais une règle isolée) puis redessine SA carte.
-function saveCollisionRules(objectId) {
-  var obj = collisionRuleObjectById(objectId);
-  if (!obj) return;
-  fetch('/game/' + GAME_SLUG + '/scene-objects/' + objectId + '/collision-rules', {
-    method: 'POST', headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ rules: obj.rules }),
-  })
-    .then(function (r) { return r.json(); })
-    .then(function (json) {
-      if (json.rules) obj.rules = json.rules; // reflète la validation serveur (voir sanitize_collision_rules)
-      renderCollisionRuleCards();
-    });
-}
-
-function deleteCollisionRule(objectId, ruleIndex) {
-  var obj = collisionRuleObjectById(objectId);
-  if (!obj) return;
-  obj.rules.splice(ruleIndex, 1);
-  saveCollisionRules(objectId);
-}
-
-// ---------- Assistant "+ Action" ----------
 // État du parcours en cours — un seul à la fois (la modale n'autorise
 // qu'une règle en construction) : l'objet ciblé, le déclencheur choisi,
 // et l'action en cours de construction (posée directement dans
 // `action`, ou dans `action.sub_action` au second niveau pour "interagir").
+// Plus de "quête cible" à connaître d'avance — la règle est posée sur
+// l'objet, un déclencheur "dialogue" se suffit à lui-même.
 var _collisionWizard = null;
 
-function openCollisionRuleModal(objectId) {
+// Appelée après avoir choisi l'objet dans la modale d'ajout de déclencheur
-  _collisionWizard = { objectId: objectId, trigger: null, perimetrePx: COLLISION_DEFAULT_PERIMETRE_PX };
+// (voir triggerSelectObject, trigger-editor.js).
-  document.getElementById('collisionRuleModal').classList.add('is-active');
+function openTriggerWizard(objectId, bodyEl) {
+  _collisionWizard = { objectId: objectId, trigger: null, bodyEl: bodyEl };
   renderCollisionWizardTriggerStep();
 }
 
-function closeCollisionRuleModal() {
-  document.getElementById('collisionRuleModal').classList.remove('is-active');
-  _collisionWizard = null;
-}
-
 function collisionWizardBodyEl() {
-  return document.getElementById('collisionRuleModalBody');
+  return _collisionWizard.bodyEl;
 }
 
-// Étape 1 — déclencheur : collision directe, ou périmètre (px réglable,
+// Étape 1 — déclencheur (un seul choix pour l'instant, "collision") : la
-// valeur par défaut COLLISION_DEFAULT_PERIMETRE_PX).
+// carte à choix reste affichée telle quelle (plutôt que sautée
+// automatiquement) pour rester extensible à de futurs types sans rien
+// changer à la structure de l'assistant.
 function renderCollisionWizardTriggerStep() {
   collisionWizardBodyEl().innerHTML =
     '<p class="hint mb-2">Cette règle se déclenche...</p>' +
@@ -187,22 +79,11 @@ function renderCollisionWizardTriggerStep() {
       '<button type="button" class="collisionWizardChoice" style="animation-delay:0ms" onclick="collisionWizardChooseTrigger(\'collision\')">' +
         '<span>' + COLLISION_TRIGGER_LABELS.collision + '</span>' +
       '</button>' +
-      '<button type="button" class="collisionWizardChoice" style="animation-delay:40ms" onclick="collisionWizardChooseTrigger(\'perimetre\')">' +
-        '<span>' + COLLISION_TRIGGER_LABELS.perimetre + '</span>' +
-        '<span class="fieldRow" style="align-items:center; gap:6px;" onclick="event.stopPropagation()">' +
-          '<input type="number" min="1" id="collisionWizardPerimetrePx" value="' + COLLISION_DEFAULT_PERIMETRE_PX + '" style="width:64px;" class="input is-small">' +
-          '<span class="hint">px</span>' +
-        '</span>' +
-      '</button>' +
     '</div>';
 }
 
 function collisionWizardChooseTrigger(trigger) {
   _collisionWizard.trigger = trigger;
-  if (trigger === 'perimetre') {
-    var pxEl = document.getElementById('collisionWizardPerimetrePx');
-    _collisionWizard.perimetrePx = (pxEl && parseFloat(pxEl.value)) || COLLISION_DEFAULT_PERIMETRE_PX;
-  }
   renderCollisionWizardActionStep(false);
 }
 
@@ -240,54 +121,233 @@ function collisionWizardFinalizeAction(action, nested) {
   collisionWizardSaveRule(action);
 }
 
+// Enregistre via la route /game/<slug>/triggers (routes/triggers/triggers.py)
+// — même contrat "liste ENTIÈRE" que l'ancien éditeur de collision
+// (recharge les règles existantes de l'objet, y ajoute la nouvelle,
+// sauvegarde tout), géré côté serveur : le client ne poste que la
+// nouvelle règle + l'id d'objet.
 function collisionWizardSaveRule(action) {
   var rule = { trigger: _collisionWizard.trigger, action: action };
-  if (_collisionWizard.trigger === 'perimetre') rule.perimetre_px = _collisionWizard.perimetrePx;
+  closeTriggerModal();
-  var obj = collisionRuleObjectById(_collisionWizard.objectId);
+  fetch('/game/' + GAME_SLUG + '/triggers', {
-  obj.rules.push(rule);
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
-  var objectId = _collisionWizard.objectId;
+    body: JSON.stringify({ object_id: _collisionWizard.objectId, rule: rule }),
-  closeCollisionRuleModal();
+  }).then(function () { triggerLoadAll(); });
-  saveCollisionRules(objectId);
 }
 
-// Chaque type d'action demande éventuellement une précision avant de
+// "dialogue"/"variable" (des FEUILLES, voir screens/rendering/
-// pouvoir se finaliser ("quête" ouvre l'éditeur de quête lui-même — voir
+// collision_rules.py) enchaînent sur "Ensuite ?" (voir
-// static/js/quests/quest-editor.js::renderQuestPickerStep, pas un simple
+// renderCollisionWizardChainStep — Marquer terminé + chaîner une autre
-// champ texte ; événement -> lequel) — "attaque" n'a besoin de rien de
+// action, demande explicite : "pouvoir modifier un déclencheur pour lui
-// plus, se finalise directement.
+// ajouter des actions") ; "interagir" enchaîne sur une carte de plus
+// (voir collisionWizardFinalizeAction) ; "condition" enchaîne sur son
+// propre mini-formulaire (voir renderCollisionWizardConditionStep).
 function collisionWizardChooseAction(type, nested) {
-  if (type === 'attaque' || type === 'interagir') {
+  if (type === 'interagir') {
     collisionWizardFinalizeAction({ type: type }, nested);
     return;
   }
-  if (type === 'quete') {
+  if (type === 'dialogue') {
-    renderQuestPickerStep(function (quest) {
+    var leaf = { type: 'dialogue', dialogue: { id: collisionGenerateActionId(), lines: [] } };
-      collisionWizardFinalizeAction({ type: 'quete', quete_id: quest.id }, nested);
+    renderCollisionWizardChainStep(leaf, function (finalLeaf) { collisionWizardFinalizeAction(finalLeaf, nested); });
+    return;
+  }
+  if (type === 'variable') {
+    renderCollisionWizardVariableStep(function (action) {
+      renderCollisionWizardChainStep(action, function (finalLeaf) { collisionWizardFinalizeAction(finalLeaf, nested); });
     });
     return;
   }
-  if (type === 'evenement') {
+  if (type === 'condition') {
-    var eventIds = Object.keys(CUSTOM_EVENTS_MAP);
+    renderCollisionWizardConditionStep(nested);
-    if (!eventIds.length) {
-      collisionWizardBodyEl().innerHTML = '<p class="hint">Aucun événement personnalisé pour l\'instant — crée-en un dans l\'onglet "Événements", puis reviens ici.</p>';
-      return;
-    }
-    var buttons = eventIds.map(function (id, i) {
-      return '<button type="button" class="collisionWizardChoice" style="animation-delay:' + (i * 40) + 'ms" onclick="collisionWizardFinalizeAction({type:\'evenement\', evenement_id:' + id + '}, ' + (nested ? 'true' : 'false') + ')">' +
-        '<span>' + CUSTOM_EVENTS_MAP[id].name.replace(/</g, '&lt;') + '</span>' +
-      '</button>';
-    }).join('');
-    collisionWizardBodyEl().innerHTML = '<p class="hint mb-2">Quel événement ?</p><div class="collisionWizardChoices">' + buttons + '</div>';
   }
 }
 
-// Appelé directement (pas de DOMContentLoaded) : ce fichier est chargé par
+// ---------- Étape "Modifier une variable" ----------
-// un <script src> posé à la fin du contenu de la page — les éléments dont
+// Même vocabulaire EXACT que l'action "Modifier une variable" du graphe
-// on a besoin existent déjà à ce stade. Nécessaire aussi pour la
+// de logique document (GLOBAL_VARIABLE_NAMES et DATA_OPERATION_LABELS_MAP
-// navigation pjax (voir static/pjax.js — runScriptsIn ré-exécute ce
+// déjà posés par templates/scene_edit.html — ce dernier n'était utilisé
-// script à chaque page swappée, mais DOMContentLoaded, lui, ne se
+// nulle part avant cette fonctionnalité) : variable ciblée, opération,
-// redéclenche jamais après le tout premier chargement réel) — sans ça,
+// valeur (masquée pour les opérations qui n'en ont pas besoin, voir
-// l'onglet "🧩 Collision" restait vide après un remplacement de <main>
+// COLLISION_NO_VALUE_OPERATIONS). `onChoose(action)`.
-// (ex. suppression d'un objet de scène, voir scene_object_delete.py) qui
+function renderCollisionWizardVariableStep(onChoose) {
-// ne redéclenche jamais cet événement.
+  var variableOptions = (typeof GLOBAL_VARIABLE_NAMES !== 'undefined' ? GLOBAL_VARIABLE_NAMES : [])
-if (typeof COLLISION_RULE_OBJECTS !== 'undefined') renderCollisionRuleCards();
+    .map(function (name) { return '<option value="' + name + '">' + name + '</option>'; }).join('');
+  var operationOptions = Object.keys(DATA_OPERATION_LABELS_MAP).map(function (key) {
+    return '<option value="' + key + '">' + DATA_OPERATION_LABELS_MAP[key] + '</option>';
+  }).join('');
+  collisionWizardBodyEl().innerHTML =
+    '<p class="hint mb-2">Modifier...</p>' +
+    '<div class="collisionWizardConditionForm">' +
+      '<select id="varWizVariable">' + variableOptions + '</select>' +
+      '<select id="varWizOperation" onchange="collisionWizardVariableOperationChanged()">' + operationOptions + '</select>' +
+      '<input type="text" id="varWizValue" placeholder="Valeur">' +
+    '</div>' +
+    '<button type="button" class="button primary mt-3" onclick="collisionWizardVariableNext()">Continuer</button>';
+  _collisionWizard.onVariableChosen = onChoose;
+  collisionWizardVariableOperationChanged();
+}
+
+function collisionWizardVariableOperationChanged() {
+  var operation = document.getElementById('varWizOperation').value;
+  var valueInput = document.getElementById('varWizValue');
+  valueInput.style.display = COLLISION_NO_VALUE_OPERATIONS.indexOf(operation) === -1 ? '' : 'none';
+}
+
+function collisionWizardVariableNext() {
+  var operation = document.getElementById('varWizOperation').value;
+  var action = {
+    type: 'variable', id: collisionGenerateActionId(),
+    target_variable: document.getElementById('varWizVariable').value,
+    data_operation: operation,
+  };
+  if (COLLISION_NO_VALUE_OPERATIONS.indexOf(operation) === -1) {
+    action.data_value = document.getElementById('varWizValue').value;
+  }
+  var onChoose = _collisionWizard.onVariableChosen;
+  _collisionWizard.onVariableChosen = null;
+  onChoose(action);
+}
+
+// ---------- Étape "Ensuite ?" (chaînage + Marquer terminé) ----------
+// Après CHAQUE feuille construite (dialogue ou variable, au premier
+// niveau, sous "interagir", ou dans une branche de condition) : la case
+// "Marquer terminé" (seulement pour un dialogue) PUIS le choix de
+// chaîner une autre action à la suite (voir screens/rendering/
+// collision_rules.py::"then", demande explicite "pouvoir modifier un
+// déclencheur pour lui ajouter des actions") — jamais bloqué à une seule
+// action par déclencheur. `onDone(leafAction)` reçoit la PREMIÈRE
+// feuille de la chaîne (les suivantes sont attachées via `.then`).
+function renderCollisionWizardChainStep(leafAction, onDone) {
+  var completionHtml = leafAction.type === 'dialogue'
+    ? '<label style="display:flex; align-items:center; gap:6px; font-size:13px; margin-bottom:10px;">' +
+        '<input type="checkbox" id="condWizMarkCompleted"' + (leafAction.mark_completed ? ' checked' : '') + '> Marquer ce dialogue comme terminé une fois joué' +
+      '</label>'
+    : '';
+  collisionWizardBodyEl().innerHTML =
+    completionHtml +
+    '<p class="hint mb-2">Ensuite ?</p>' +
+    '<div class="collisionWizardChoices">' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:0ms" onclick="collisionWizardChainDone(\'none\')"><span>Rien de plus</span></button>' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:40ms" onclick="collisionWizardChainDone(\'dialogue\')"><span>Déclencher un dialogue</span></button>' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:80ms" onclick="collisionWizardChainDone(\'variable\')"><span>Modifier une variable</span></button>' +
+    '</div>';
+  _collisionWizard.chainLeaf = leafAction;
+  _collisionWizard.onChainDone = onDone;
+}
+
+function collisionWizardChainDone(choice) {
+  var leafAction = _collisionWizard.chainLeaf;
+  var onDone = _collisionWizard.onChainDone;
+  if (leafAction.type === 'dialogue') {
+    if (document.getElementById('condWizMarkCompleted').checked) leafAction.mark_completed = true;
+    else delete leafAction.mark_completed;
+  }
+  if (choice === 'none') {
+    onDone(leafAction);
+    return;
+  }
+  if (choice === 'dialogue') {
+    var nextLeaf = { type: 'dialogue', dialogue: { id: collisionGenerateActionId(), lines: [] } };
+    leafAction.then = nextLeaf;
+    renderCollisionWizardChainStep(nextLeaf, onDone);
+    return;
+  }
+  // 'variable'
+  renderCollisionWizardVariableStep(function (action) {
+    leafAction.then = action;
+    renderCollisionWizardChainStep(action, onDone);
+  });
+}
+
+// Étape "condition" — variable/opérateur/valeur (même vocabulaire que le
+// nœud Condition de l'éditeur de logique, voir screens/flow/constants.py
+// ::CONDITION_OPERATORS ; GLOBAL_VARIABLE_NAMES et
+// CONDITION_OPERATOR_LABELS_MAP posés par templates/scene_edit.html).
+// `nested` (interagir -> condition) est reporté jusqu'à la finalisation,
+// une fois les deux branches Vrai/Faux choisies ci-dessous.
+function renderCollisionWizardConditionStep(nested) {
+  var variableOptions = (typeof GLOBAL_VARIABLE_NAMES !== 'undefined' ? GLOBAL_VARIABLE_NAMES : [])
+    .map(function (name) { return '<option value="' + name + '">' + name + '</option>'; }).join('');
+  var operatorOptions = Object.keys(CONDITION_OPERATOR_LABELS_MAP).map(function (key) {
+    return '<option value="' + key + '">' + CONDITION_OPERATOR_LABELS_MAP[key] + '</option>';
+  }).join('');
+  collisionWizardBodyEl().innerHTML =
+    '<p class="hint mb-2">Si...</p>' +
+    '<div class="collisionWizardConditionForm">' +
+      '<select id="condWizVariable">' + variableOptions + '</select>' +
+      '<select id="condWizOperator">' + operatorOptions + '</select>' +
+      '<input type="text" id="condWizValue" placeholder="Valeur">' +
+    '</div>' +
+    '<button type="button" class="button primary mt-3" onclick="collisionWizardConditionNext(' + (nested ? 'true' : 'false') + ')">Continuer</button>';
+}
+
+function collisionWizardConditionNext(nested) {
+  _collisionWizard.pendingCondition = {
+    type: 'condition',
+    variable: document.getElementById('condWizVariable').value,
+    operateur: document.getElementById('condWizOperator').value,
+    valeur: document.getElementById('condWizValue').value,
+    si_vrai: null, si_faux: null,
+  };
+  _collisionWizard.pendingConditionNested = nested;
+  renderCollisionWizardBranchStep('si_vrai');
+}
+
+// Étape branche (Vrai puis Faux) — chaque branche est soit "Ne rien
+// faire", soit une FEUILLE ("Déclencher un dialogue" ou "Modifier une
+// variable", voir screens/rendering/collision_rules.py::
+// _sanitize_condition_branch : une branche reste une feuille, jamais une
+// nouvelle "interagir"/"condition" imbriquée) — les DEUX branches
+// peuvent chacune déclencher LEUR PROPRE feuille (et sa propre chaîne),
+// indépendamment l'une de l'autre.
+function renderCollisionWizardBranchStep(branchKey) {
+  var label = branchKey === 'si_vrai' ? '✓ Si VRAI...' : '✕ Si FAUX...';
+  collisionWizardBodyEl().innerHTML =
+    '<p class="hint mb-2">' + label + '</p>' +
+    '<div class="collisionWizardChoices">' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:0ms" onclick="collisionWizardChooseBranch(\'' + branchKey + '\', \'dialogue\')">' +
+        '<span>Déclencher un dialogue</span>' +
+      '</button>' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:40ms" onclick="collisionWizardChooseBranch(\'' + branchKey + '\', \'variable\')">' +
+        '<span>Modifier une variable</span>' +
+      '</button>' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:80ms" onclick="collisionWizardChooseBranch(\'' + branchKey + '\', \'none\')">' +
+        '<span>Ne rien faire</span>' +
+      '</button>' +
+    '</div>';
+}
+
+function collisionWizardChooseBranch(branchKey, choice) {
+  if (choice === 'none') {
+    _collisionWizard.pendingCondition[branchKey] = null;
+    collisionWizardBranchDone(branchKey);
+    return;
+  }
+  if (choice === 'dialogue') {
+    var leaf = { type: 'dialogue', dialogue: { id: collisionGenerateActionId(), lines: [] } };
+    renderCollisionWizardChainStep(leaf, function (finalLeaf) {
+      _collisionWizard.pendingCondition[branchKey] = finalLeaf;
+      collisionWizardBranchDone(branchKey);
+    });
+    return;
+  }
+  // 'variable'
+  renderCollisionWizardVariableStep(function (action) {
+    renderCollisionWizardChainStep(action, function (finalLeaf) {
+      _collisionWizard.pendingCondition[branchKey] = finalLeaf;
+      collisionWizardBranchDone(branchKey);
+    });
+  });
+}
+
+function collisionWizardBranchDone(branchKey) {
+  if (branchKey === 'si_vrai') {
+    renderCollisionWizardBranchStep('si_faux');
+    return;
+  }
+  var nested = _collisionWizard.pendingConditionNested;
+  var condition = _collisionWizard.pendingCondition;
+  _collisionWizard.pendingCondition = null;
+  collisionWizardFinalizeAction(condition, nested);
+}

static/js/scenes/scene-editor.js

@@ -51,7 +51,6 @@ function addSceneObject(kind, forgeCharacter, backgroundSlug) {
         '<div class="canvasElementInner">' + json.rendered_html + '</div>' +
         '<div class="resizeHandle" onmousedown="onSceneObjectResizeMouseDown(event, ' + json.id + ')"></div>';
       canvas.appendChild(el);
-      refreshCollisionRuleObjects();
       if (json.animations) {
         ELEMENT_ANIMATIONS_MAP[json.id] = json.animations;
         restartPersonnageIdlePreview(json.id, json.animations);
@@ -87,7 +86,6 @@ function deleteSceneObject(id) {
       var el = document.getElementById('el-' + id);
       if (el) el.remove();
       if (typeof _stopPersonnageIdlePreview === 'function') _stopPersonnageIdlePreview(id);
-      refreshCollisionRuleObjects();
       // L'objet supprimé était forcément le sélectionné (seul cas où 🗑️
       // est affiché) — referme le panneau de propriétés et l'URL, sans
       // requête supplémentaire au serveur.
@@ -355,25 +353,7 @@ function saveSceneObjectRole(role) {
   fetch('/game/' + GAME_SLUG + '/scene-objects/' + objectId + '/role', {
     method: 'POST', headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ role: role }),
-  }).then(refreshCollisionRuleObjects);
+  });
-}
-
-// Réutilisé après ajout/suppression/changement de rôle ou de nom (voir
-// routes/scenes/scene_collision_rule_objects.py) : un changement de rôle
-// peut faire apparaître/disparaître une carte (passage à/depuis "joueur",
-// jamais dans "🧩 Collision") et un changement de nom change son libellé
-// affiché — recalculée entièrement côté serveur plutôt que rejouée en JS
-// (même logique déjà nécessaire pour le rôle implicite d'une scène posée
-// avant ce réglage, voir build_collision_rule_objects) SANS recharger la
-// page.
-function refreshCollisionRuleObjects() {
-  if (typeof COLLISION_RULE_OBJECTS === 'undefined') return;
-  fetch('/game/' + GAME_SLUG + '/screens/' + SCREEN_ID + '/collision-rule-objects')
-    .then(function (r) { return r.json(); })
-    .then(function (json) {
-      COLLISION_RULE_OBJECTS = json;
-      renderCollisionRuleCards();
-    });
 }
 
 // Boîte de collision (voir screens/rendering/collision_settings.py,
@@ -579,26 +559,24 @@ function addPersonnageCommandExtraRow() {
 }
 
 // "ℹ️ Informations" (voir templates/scene_edit.html) : le nom d'un
-// personnage, réutilisé comme "qui parle" dans l'éditeur de dialogue de
+// personnage, réutilisé comme "qui parle" dans l'éditeur de dialogue d'un
-// quête (voir static/js/quests/quest-editor.js).
+// déclencheur (voir static/js/triggers/trigger-editor.js).
 function saveSceneObjectName(objectId, name) {
   fetch('/game/' + GAME_SLUG + '/scene-objects/' + objectId + '/name', {
     method: 'POST', headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ name: name }),
-  }).then(function () {
+  }).then(refreshSceneObjectNames);
-    refreshCollisionRuleObjects();
-    refreshSceneObjectNames();
-  });
 }
 
 // SCENE_OBJECT_NAMES (voir routes/scenes/scene_object_names_list.py) :
 // posée UNE SEULE FOIS au chargement complet de la page (<script> inline
 // en bas, HORS de #builder3, jamais rafraîchie par une simple sélection
 // sans rechargement, voir goToSelected()) — sans ce rafraîchissement,
-// renommer un personnage puis ouvrir la modale de dialogue dans la MÊME
+// renommer un personnage puis ouvrir un dialogue de déclencheur dans la
-// session ne faisait jamais apparaître son nouveau nom dans "qui parle"
+// MÊME session ne faisait jamais apparaître son nouveau nom dans "qui
-// (voir questSpeakerOptions(), static/js/quests/quest-editor.js) tant
+// parle" (voir triggerSpeakerOptions(), static/js/triggers/
-// qu'aucun vrai rechargement de page n'avait eu lieu entre temps.
+// trigger-editor.js) tant qu'aucun vrai rechargement de page n'avait eu
+// lieu entre temps.
 function refreshSceneObjectNames() {
   if (typeof SCENE_OBJECT_NAMES === 'undefined') return;
   fetch('/game/' + GAME_SLUG + '/scene-object-names')
@@ -721,21 +699,16 @@ initPersonnageCommandsPanel();
 // viennent d'être recréés par le même remplacement, voir
 // startAllPersonnagePreviews()/personnage-preview.js).
 //
-// .builderCanvasArea (les onglets "🖥️ Scène"/"🧩 Collision"/"🗺️ Quêtes"/
+// .builderCanvasArea (les onglets "🖥️ Scène"/"Déclencheurs"/"📣 Événements")
-// "📣 Événements") est ENTIÈREMENT à l'intérieur de #builder3 (voir
+// est ENTIÈREMENT à l'intérieur de #builder3 (voir templates/scene_edit.html)
-// templates/scene_edit.html) — le remplacer réinjecte donc aussi
+// — le remplacer réinjecte donc aussi le conteneur des déclencheurs tel
-// #collisionRulesCards/le conteneur des quêtes tels que le SERVEUR les
+// que le SERVEUR le rend, c'est-à-dire VIDE (rendu entièrement en JS,
-// rend, c'est-à-dire VIDES (ces listes sont rendues entièrement en JS,
+// jamais en Jinja, voir trigger-editor.js) : sans le redessiner ici,
-// jamais en Jinja, voir collision-rules-editor.js/quest-editor.js) : sans
+// l'onglet "Déclencheurs" semblait se "vider" à chaque sélection d'un
-// les redessiner ici, les onglets "🧩 Collision"/"🗺️ Quêtes" semblaient se
+// objet de scène.
-// "vider" à chaque sélection d'un objet de scène. COLLISION_RULE_OBJECTS/
-// QUESTS_JSON eux-mêmes ne sont PAS affectés par ce remplacement (déclarés
-// dans le <script> inline en bas de page, HORS de #builder3) — il suffit
-// donc de rejouer leur rendu, pas de les recharger.
 function initSceneBuilderPanel() {
   initScenePosFields();
   initPersonnageCommandsPanel();
   if (typeof startAllPersonnagePreviews === 'function') startAllPersonnagePreviews();
-  if (typeof renderCollisionRuleCards === 'function') renderCollisionRuleCards();
+  if (typeof initTriggersTab === 'function') initTriggersTab();
-  if (typeof renderQuestListPage === 'function') renderQuestListPage();
 }

static/js/triggers/trigger-editor.js

@@ -0,0 +1,648 @@
+// ---------- Onglet "Déclencheurs" ----------
+// templates/scene_edit.html : un GRAPHE DE LOGIQUE lu par déclencheur
+// (demande explicite : "un RH doit le comprendre, un visuel global") —
+// TOUS les déclencheurs du JEU ENTIER vivent côte à côte dans la même
+// colonne (plus de "quête" pour les regrouper, voir screens/rendering/
+// trigger_graph.py::list_all_triggers), chacun avec SON PROPRE dialogue
+// embarqué ({id, lines}, voir screens/rendering/collision_rules.py::
+// "dialogue".dialogue). Les boutons Réplique/Question sont posés
+// DIRECTEMENT sur le rectangle de dialogue de chaque déclencheur — le
+// seul bouton au bas de la colonne est "Ajouter un déclencheur". Le
+// créateur décide lui-même, via ses variables globales et conditions
+// (voir screens/rendering/collision_rules.py::"condition"), QUAND
+// déclencher quel dialogue et QUAND marquer un dialogue comme terminé
+// (action.mark_completed, voir static/js/play/dialogue-box-controller.js).
+
+// Noms d'objets de scène nommés (voir "ℹ️ Informations", templates/
+// scene_edit.html) — N'IMPORTE QUEL objet (personnage, décor, fond), pas
+// seulement un personnage — proposés comme "qui parle" pour une réplique,
+// en plus de "Joueur" (toujours disponible, jamais un objet de scène).
+var SCENE_OBJECT_NAMES = (typeof SCENE_OBJECT_NAMES_JSON !== 'undefined') ? SCENE_OBJECT_NAMES_JSON : [];
+
+// Une réplique n'a que deux COULEURS possibles (voir .questBubble-joueur/
+// .questBubble-pnj, static/style.css) même si le nom affiché est
+// n'importe quel objet nommé — "Joueur" en vert, n'importe quel autre nom
+// en bleu.
+function triggerBubbleKind(speaker) {
+  return speaker === 'Joueur' ? 'joueur' : 'pnj';
+}
+
+// Options du <select> "qui parle" — "Joueur" toujours en premier, puis
+// chaque personnage nommé (voir "ℹ️ Informations"), plus le speaker
+// ACTUEL de la réplique s'il n'est plus dans cette liste (personnage
+// renommé/supprimé depuis) pour ne jamais perdre silencieusement la
+// valeur déjà enregistrée.
+function triggerSpeakerOptions(currentSpeaker) {
+  var options = ['Joueur'].concat(SCENE_OBJECT_NAMES);
+  if (currentSpeaker && options.indexOf(currentSpeaker) === -1) options.push(currentSpeaker);
+  return options;
+}
+
+function triggerEscAttr(str) {
+  return (str || '').replace(/"/g, '&quot;');
+}
+
+// ---------- Colonne = un graphe de logique lu par déclencheur ----------
+function triggerColumnHtml() {
+  return (
+    '<div class="questDialogueColumn">' +
+      '<div class="questDialogueColumnBody" id="triggerColumnBody">' +
+        '<div class="questTriggersSlot" id="triggersSlot"></div>' +
+      '</div>' +
+      '<div class="questDialogueColumnButtons">' +
+        '<button type="button" class="collisionRuleAddBtn questDialogueAddBtn" onclick="openAddTriggerModal()">Ajouter un déclencheur</button>' +
+      '</div>' +
+    '</div>'
+  );
+}
+
+// ---------- Dialogue INLINE (voir screens/rendering/collision_rules.py
+// ::"dialogue".dialogue) ----------
+// Un dialogue = {id, lines} porté PAR L'ACTION elle-même — rendu comme un
+// rectangle à bords arrondis, MÊME largeur que le reste de la chaîne
+// (pastilles/carte objet), avec un bouton "Réplique"/"Question" qui
+// ajoute une bulle directement dedans.
+
+// Une bulle = header (qui parle, menu déroulant des objets de scène
+// nommés — voir "ℹ️ Informations") + body (le texte) — deux zones
+// distinctes, pas un seul bloc.
+function triggerDialogueBubbleHtml(dialogueId, line, index) {
+  var kind = triggerBubbleKind(line.speaker);
+  var speakerSelect = triggerSpeakerOptions(line.speaker).map(function (name) {
+    return '<option value="' + name.replace(/"/g, '&quot;') + '"' + (name === line.speaker ? ' selected' : '') + '>' + (name === 'Joueur' ? 'Joueur' : name) + '</option>';
+  }).join('');
+  return (
+    '<div class="questBubbleRow">' +
+      '<div class="questBubble questBubble-' + kind + '">' +
+        '<div class="questBubbleHeader">' +
+          '<select class="questBubbleSpeaker" title="Qui parle" onchange="triggerInlineSetBubbleSpeaker(\'' + dialogueId + '\', ' + index + ', this.value)">' + speakerSelect + '</select>' +
+          '<button type="button" class="questBubbleDelete" title="Supprimer" onclick="triggerInlineDeleteBubble(\'' + dialogueId + '\', ' + index + ')">✕</button>' +
+        '</div>' +
+        '<div class="questBubbleBody">' +
+          '<textarea class="questBubbleText" rows="1" placeholder="Réplique..." ' +
+            'oninput="this.style.height=\'auto\'; this.style.height=this.scrollHeight+\'px\';" ' +
+            'onchange="triggerInlineUpdateBubbleText(\'' + dialogueId + '\', ' + index + ', this.value)">' + line.text.replace(/</g, '&lt;') + '</textarea>' +
+        '</div>' +
+      '</div>' +
+    '</div>'
+  );
+}
+
+// "❓ Question" — une bulle JAUNE dans la même chaîne qu'une réplique de
+// dialogue (voir .questBubbleRow/.questBubble et static/style.css) mais
+// un type de ligne différent (voir db/dialogue_lines.py) : header =
+// nombre de choix + récompense (type + montant), body = la question et
+// ses choix, avec la bonne réponse cochée.
+function triggerQuestionChoiceRowHtml(dialogueId, choice, choiceIndex, correctIndex, index) {
+  var radioName = 'triggerCorrect-' + dialogueId + '-' + index;
+  return (
+    '<div class="questChoiceRow">' +
+      '<input type="radio" name="' + radioName + '" class="questChoiceRadio" title="Bonne réponse" ' +
+        (choiceIndex === correctIndex ? 'checked' : '') +
+        ' onchange="triggerInlineSetQuestionCorrectIndex(\'' + dialogueId + '\', ' + index + ', ' + choiceIndex + ')">' +
+      '<input type="text" class="questChoiceInput" placeholder="Choix ' + (choiceIndex + 1) + '" value="' + triggerEscAttr(choice) + '" ' +
+        'onchange="triggerInlineSetQuestionChoiceText(\'' + dialogueId + '\', ' + index + ', ' + choiceIndex + ', this.value)">' +
+    '</div>'
+  );
+}
+
+function triggerQuestionBubbleHtml(dialogueId, line, index) {
+  var choicesHtml = line.choices.map(function (c, i) { return triggerQuestionChoiceRowHtml(dialogueId, c, i, line.correct_index, index); }).join('');
+  return (
+    '<div class="questBubbleRow">' +
+      '<div class="questBubble questBubble-question">' +
+        '<div class="questBubbleHeader">' +
+          '<label class="questQuestionHeaderField"><span class="questQuestionHeaderFieldLabel">Nombre de choix</span>' +
+            '<input type="number" min="2" max="4" value="' + line.choices.length + '" ' +
+            'onchange="triggerInlineSetQuestionChoiceCount(\'' + dialogueId + '\', ' + index + ', this.value)"></label>' +
+          '<label class="questQuestionHeaderField"><span class="questQuestionHeaderFieldLabel">Points gagnés</span>' +
+            '<input type="number" min="0" value="' + line.reward_amount + '" ' +
+            'onchange="triggerInlineSetQuestionRewardAmount(\'' + dialogueId + '\', ' + index + ', this.value)"> pts</label>' +
+          '<button type="button" class="questBubbleDelete" title="Supprimer" onclick="triggerInlineDeleteBubble(\'' + dialogueId + '\', ' + index + ')">✕</button>' +
+        '</div>' +
+        '<div class="questBubbleBody">' +
+          '<input type="text" class="questQuestionText" placeholder="Question..." value="' + triggerEscAttr(line.text) + '" ' +
+            'onchange="triggerInlineUpdateQuestionText(\'' + dialogueId + '\', ' + index + ', this.value)">' +
+          '<div class="questChoicesList">' + choicesHtml + '</div>' +
+        '</div>' +
+      '</div>' +
+    '</div>'
+  );
+}
+
+// Pastille "Déclencher ce dialogue" — visuelle uniquement, la même pour
+// TOUTES les occurrences : posée juste avant le rectangle de dialogue
+// lui-même (voir triggerInlineDialogueHtml).
+function triggerDeclencherDialoguePillHtml() {
+  return '<div class="questTriggerPill quete">Déclencher ce dialogue</div>';
+}
+
+// Libellé lisible d'une action "variable" (voir screens/rendering/
+// collision_rules.py::"variable" et screens/labels/data_operations.py) —
+// DATA_OPERATION_LABELS_MAP est déjà posé par templates/scene_edit.html.
+function triggerVariableActionLabel(item) {
+  var opLabel = (typeof DATA_OPERATION_LABELS_MAP !== 'undefined' && DATA_OPERATION_LABELS_MAP[item.data_operation]) || item.data_operation;
+  var valuePart = (item.data_value !== undefined && item.data_value !== null && item.data_value !== '') ? ' ' + item.data_value : '';
+  return (item.target_variable || '').replace(/</g, '&lt;') + ' — ' + opLabel.replace(/</g, '&lt;') + valuePart;
+}
+
+// Feuille "Modifier une variable" — un encart compact (même largeur que
+// le reste de la chaîne), pas de bulles dedans contrairement au
+// rectangle de dialogue.
+function triggerVariableActionHtml(item) {
+  return (
+    '<div class="dialogueBox questVariableAction">' +
+      '<div class="dialogueBoxHeader">' +
+        '<span class="dialogueBoxTitle">Variable</span>' +
+      '</div>' +
+      '<p class="questVariableActionLabel">' + triggerVariableActionLabel(item) + '</p>' +
+    '</div>'
+  );
+}
+
+// Une chaîne d'actions (voir screens/rendering/trigger_graph.py::
+// _describe_chain) : "Déclencher ce dialogue" + son rectangle, ou une
+// feuille "variable", à la suite les unes des autres — PUIS, en bout de
+// chaîne, "+ Ajouter une action" (demande explicite : "pouvoir modifier
+// un déclencheur pour lui ajouter des actions", jamais bloqué à une
+// seule action). `objectId` : nécessaire pour poster l'ajout sur le bon
+// objet (voir triggerOpenAppendActionModal).
+function triggerActionChainHtml(chain, objectId) {
+  if (!chain || !chain.length) return '';
+  var itemsHtml = chain.map(function (item) {
+    var pill = item.type === 'dialogue' ? triggerDeclencherDialoguePillHtml() : '<div class="questTriggerPill quete">Modifier une variable</div>';
+    var box = item.type === 'dialogue' ? triggerInlineDialogueHtml(item.dialogue) : triggerVariableActionHtml(item);
+    return '<div class="questTriggerConnector"></div>' + pill + '<div class="questTriggerConnector"></div>' + box;
+  }).join('');
+  var lastItem = chain[chain.length - 1];
+  var lastLeafId = lastItem.type === 'dialogue' ? lastItem.dialogue && lastItem.dialogue.id : lastItem.id;
+  var appendBtn = lastLeafId
+    ? '<div class="questTriggerConnector"></div>' +
+      '<button type="button" class="collisionRuleAddBtn questTriggerAddChainedActionBtn" onclick="triggerOpenAppendActionModal(' + objectId + ', \'' + lastLeafId + '\')">+ Ajouter une action</button>'
+    : '';
+  return itemsHtml + appendBtn;
+}
+
+// Le rectangle lui-même — voir screens/rendering/collision_rules.py::
+// "dialogue".dialogue pour la forme {id, lines}. `dialogue` peut être
+// absent (action posée sans passer par l'assistant) : rien n'est rendu
+// plutôt que de planter, même tolérance que le reste de ce moteur.
+function triggerInlineDialogueHtml(dialogue) {
+  if (!dialogue) return '';
+  var lines = dialogue.lines || [];
+  var bubblesHtml = lines.map(function (line, i) {
+    return line.type === 'question' ? triggerQuestionBubbleHtml(dialogue.id, line, i) : triggerDialogueBubbleHtml(dialogue.id, line, i);
+  }).join('');
+  return (
+    '<div class="dialogueBox">' +
+      '<div class="dialogueBoxHeader">' +
+        '<span class="dialogueBoxTitle">Dialogue</span>' +
+        '<div class="dialogueBoxActions">' +
+          '<button type="button" class="addReplyBtn" onclick="triggerInlineAddBubble(\'' + dialogue.id + '\')">Réplique</button>' +
+          '<button type="button" class="addReplyBtn addQuestionBtn" onclick="triggerInlineAddQuestion(\'' + dialogue.id + '\')">Question</button>' +
+        '</div>' +
+      '</div>' +
+      bubblesHtml +
+    '</div>'
+  );
+}
+
+// ---------- Déclencheurs (voir screens/rendering/trigger_graph.py::
+// list_all_triggers) ----------
+// Maquette validée : carte objet + pastilles empilées VERTICALEMENT
+// reliées par des flèches. Le "Déclencher ce dialogue" se termine par le
+// rectangle de dialogue lui-même — la flèche pointe DIRECTEMENT dessus.
+// Quand l'action se termine par une "condition", la chaîne se sépare en
+// un losange à embranchement Vrai/Faux (voir triggerConditionColumnHtml) —
+// chaque branche affiche DIRECTEMENT son propre contenu (plus de "branche
+// qui mène à telle quête" à choisir, chaque branche est indépendante).
+// collisionRuleThumbHtml (static/js/scenes/collision-rules-editor.js,
+// chargé sur la même page) reste réutilisé pour la vignette elle-même.
+
+// Accordéon : object_id -> true si REPLIÉ — par défaut tout est déplié,
+// absent de cette map = déplié.
+var _triggerCollapsed = {};
+// Le déclencheur actif est celui où Réplique/Question ajoutent leur bulle
+// (surligné, voir .questTriggerCol.active en CSS) — par défaut le
+// DERNIER dialogue trouvé, mais cliquer sur la carte d'un autre
+// déclencheur en fait le nouvel actif.
+var _triggerActiveDialogueId = null;
+
+function _chainLeafIds(chain) {
+  return (chain || []).map(function (item) { return item.type === 'dialogue' ? (item.dialogue && item.dialogue.id) : item.id; }).filter(Boolean);
+}
+
+function _triggerLeafIds(trigger) {
+  if (trigger.condition) {
+    var vrai = trigger.condition.si_vrai, faux = trigger.condition.si_faux;
+    return _chainLeafIds(vrai && vrai.chain).concat(_chainLeafIds(faux && faux.chain));
+  }
+  return _chainLeafIds(trigger.chain);
+}
+
+function triggerChainHtml(trigger) {
+  var isCollapsed = !!_triggerCollapsed[trigger.object_id];
+  var leafIds = _triggerLeafIds(trigger);
+  var isActive = _triggerActiveDialogueId && leafIds.indexOf(_triggerActiveDialogueId) !== -1;
+  var cardOnclick = 'triggerClickObjectCard(' + trigger.object_id + ', ' + (leafIds[0] ? '\'' + leafIds[0] + '\'' : 'null') + ')';
+  var card =
+    '<div class="questTriggerObjectCard" title="Cliquer pour replier/déplier — replie aussi la logique associée" onclick="' + cardOnclick + '">' + collisionRuleThumbHtml(trigger) +
+      '<span class="questTriggerObjectName">' + (trigger.object_name || '').replace(/</g, '&lt;') + '</span>' +
+      '<span class="questTriggerCollapseChevron">▾</span>' +
+    '</div>';
+  if (isCollapsed) {
+    return (
+      '<div class="questTriggerCol collapsed">' +
+        '<button type="button" class="questTriggerDelete" title="Retirer ce déclencheur" ' +
+          'onclick="event.stopPropagation(); triggerDeleteTrigger(' + trigger.object_id + ')">✕</button>' +
+        card +
+      '</div>'
+    );
+  }
+  var pills = [{ kind: 'trigger', text: COLLISION_TRIGGER_LABELS.collision }];
+  if (trigger.has_interagir) pills.push({ kind: 'interagir', text: 'Interagir avec une touche' });
+  var pillsHtml = pills.map(function (pill, i) {
+    return (i > 0 ? '<div class="questTriggerConnector"></div>' : '') +
+      '<div class="questTriggerPill ' + pill.kind + '">' + pill.text + '</div>';
+  }).join('');
+  var tailHtml = trigger.condition
+    ? '<div class="questTriggerConnector tall"></div>' + triggerConditionColumnHtml(trigger.condition, trigger.object_id)
+    : triggerActionChainHtml(trigger.chain, trigger.object_id);
+  return (
+    '<div class="questTriggerCol' + (isActive ? ' active' : '') + '">' +
+      '<button type="button" class="questTriggerDelete" title="Retirer ce déclencheur" ' +
+        'onclick="event.stopPropagation(); triggerDeleteTrigger(' + trigger.object_id + ')">✕</button>' +
+      card +
+      '<div class="questTriggerConnector"></div>' +
+      pillsHtml +
+      tailHtml +
+    '</div>'
+  );
+}
+
+// Clic sur la carte objet : replie/déplie TOUTE la logique associée
+// (accordéon, demande explicite) — et rend ce déclencheur actif au
+// passage puisqu'on vient d'y porter son attention.
+function triggerClickObjectCard(objectId, leafId) {
+  _triggerCollapsed[objectId] = !_triggerCollapsed[objectId];
+  if (leafId) _triggerActiveDialogueId = leafId;
+  triggerRenderSlot();
+}
+
+// Losange "condition" — lecture ENTIÈREMENT VERTICALE (demande explicite :
+// "il faut tout mettre verticalement", sans toucher au losange lui-même) :
+// la branche Vrai descend tout droit vers son "Déclencher ce dialogue"
+// (ou "Ne rien faire"), PUIS la branche Faux descend à son tour — jamais
+// deux branches côte à côte. Chaque branche affiche SON PROPRE dialogue
+// (voir screens/rendering/trigger_graph.py::_resolve_action_trigger),
+// indépendamment de l'autre.
+function triggerCondArrowHtml(kind, label) {
+  var color = kind === 'yes' ? '#2ecc71' : '#e0524d';
+  var markerId = 'triggerCondArrow_' + kind + '_' + Math.random().toString(36).slice(2, 8);
+  return (
+    '<div class="questCondArrowWrap">' +
+      '<div class="questCondArrowLabel ' + kind + '">' + label + '</div>' +
+      '<svg viewBox="0 0 34 68" preserveAspectRatio="none" aria-hidden="true">' +
+        '<defs><marker id="' + markerId + '" markerWidth="10" markerHeight="10" refX="7" refY="5" orient="auto">' +
+          '<path d="M0,0 L10,5 L0,10 Z" fill="' + color + '"></path></marker></defs>' +
+        '<line x1="17" y1="0" x2="17" y2="56" stroke="' + color + '" stroke-width="4" marker-end="url(#' + markerId + ')"></line>' +
+      '</svg>' +
+    '</div>'
+  );
+}
+
+function triggerConditionColumnHtml(condition, objectId) {
+  var opLabel = CONDITION_OPERATOR_LABELS_MAP[condition.operateur] || condition.operateur;
+  var label = (condition.variable || '').replace(/</g, '&lt;') + ' ' + (opLabel || '').replace(/</g, '&lt;') + ' ' + (condition.valeur || '').replace(/</g, '&lt;');
+  var branchesHtml = ['si_vrai', 'si_faux'].map(function (branchKey) {
+    var kind = branchKey === 'si_vrai' ? 'yes' : 'no';
+    var arrowLabel = branchKey === 'si_vrai' ? '✓ Vrai' : '✕ Faux';
+    var branch = condition[branchKey];
+    var content = branch
+      ? triggerActionChainHtml(branch.chain, objectId)
+      : '<div class="questTriggerPill none">Ne rien faire</div>';
+    return triggerCondArrowHtml(kind, arrowLabel) + content;
+  }).join('');
+  return (
+    '<div class="questCondColumn">' +
+      '<div class="questCondDiamond"><span>' + label + '</span></div>' +
+      branchesHtml +
+    '</div>'
+  );
+}
+
+// Cache global (voir triggerLoadAll) — muté directement par les fonctions
+// triggerInline* ci-dessous, puis ré-affiché + sauvegardé, sans jamais
+// adopter la réponse du serveur comme nouvel état local (sanitize_dialogue_lines
+// rejette toute réplique au texte encore vide — juste ajoutée, pas encore
+// tapée — l'adopter effacerait silencieusement la bulle en cours
+// d'écriture).
+var _triggersCache = [];
+// dialogue_id -> {objectId, dialogueRef} — `dialogueRef` est LA MÊME
+// référence que dans _triggersCache, muter dialogueRef.lines ici mute
+// donc aussi le cache (une seule source de vérité). Couvre aussi bien le
+// dialogue direct d'un déclencheur que ceux embarqués dans ses branches
+// de condition.
+var _triggerDialogueRegistry = {};
+
+function _registerChainDialogues(chain, objectId, dialogueIds) {
+  (chain || []).forEach(function (item) {
+    if (item.type === 'dialogue' && item.dialogue) {
+      _triggerDialogueRegistry[item.dialogue.id] = { objectId: objectId, dialogueRef: item.dialogue };
+      dialogueIds.push(item.dialogue.id);
+    } else if (item.type === 'variable' && item.id) {
+      dialogueIds.push(item.id); // pas de "dialogueRef" (rien à éditer en ligne), juste pour l'id "actif"
+    }
+  });
+}
+
+function _registerTriggerDialogues(list) {
+  _triggerDialogueRegistry = {};
+  var dialogueIds = [];
+  list.forEach(function (t) {
+    if (t.condition) {
+      ['si_vrai', 'si_faux'].forEach(function (branchKey) {
+        var branch = t.condition[branchKey];
+        if (branch) _registerChainDialogues(branch.chain, t.object_id, dialogueIds);
+      });
+    } else {
+      _registerChainDialogues(t.chain, t.object_id, dialogueIds);
+    }
+  });
+  return dialogueIds;
+}
+
+function triggerLoadAll() {
+  fetch('/game/' + GAME_SLUG + '/triggers')
+    .then(function (r) { return r.json(); })
+    .then(function (list) {
+      _triggersCache = list;
+      var dialogueIds = _registerTriggerDialogues(list);
+      // Le déclencheur actif par défaut est le DERNIER dialogue trouvé —
+      // sauf s'il y en a déjà un actif encore présent, auquel cas on le
+      // garde (cliquer sur une autre carte reste possible, voir
+      // triggerClickObjectCard).
+      if (dialogueIds.indexOf(_triggerActiveDialogueId) === -1) {
+        _triggerActiveDialogueId = dialogueIds[dialogueIds.length - 1] || null;
+      }
+      triggerRenderSlot();
+    });
+}
+
+function triggerRenderSlot() {
+  var slot = document.getElementById('triggersSlot');
+  if (!slot) return;
+  slot.innerHTML = _triggersCache.map(function (t) { return triggerChainHtml(t); }).join('');
+}
+
+function triggerDeleteTrigger(objectId) {
+  fetch('/game/' + GAME_SLUG + '/triggers/' + objectId, { method: 'DELETE' })
+    .then(function () { triggerLoadAll(); });
+}
+
+// ---------- Mutateurs du dialogue INLINE ----------
+// Chaque fonction retrouve son dialogue via le registre (dialogue_id,
+// unique par occurrence de "Déclencher ce dialogue") — pas besoin de
+// connaître l'objet, déjà mémorisé à triggerLoadAll.
+
+function triggerInlineSaveDialogue(dialogueId) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  fetch('/game/' + GAME_SLUG + '/triggers/' + entry.objectId + '/dialogue', {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ dialogue_id: dialogueId, lines: entry.dialogueRef.lines }),
+  }).then(function (r) {
+    if (!r.ok) return r.json().then(function (json) { alert(json.error || "Impossible d'enregistrer."); });
+  });
+}
+
+// Alterne "Joueur" <-> le premier personnage nommé (ou "PNJ" faute de
+// mieux, si aucun personnage n'a encore de nom — voir "ℹ️ Informations")
+// — juste un défaut de départ, l'auteur choisit ensuite librement dans
+// le menu déroulant de la réplique.
+function triggerNextDefaultSpeaker(lastSpeaker) {
+  if (lastSpeaker === 'Joueur') return SCENE_OBJECT_NAMES[0] || 'PNJ';
+  return 'Joueur';
+}
+
+function triggerInlineAddBubble(dialogueId) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  var lines = entry.dialogueRef.lines;
+  var lastSpeaker = lines.length ? lines[lines.length - 1].speaker : 'PNJ';
+  lines.push({ type: 'dialogue', speaker: triggerNextDefaultSpeaker(lastSpeaker), text: '' });
+  triggerRenderSlot();
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+// "❓ Question" — voir triggerQuestionBubbleHtml ci-dessus. Défauts :
+// 2 choix vides, la 1ère cochée bonne réponse, récompense "score" à 0 pt
+// (l'auteur règle le montant dans le header de la bulle).
+function triggerInlineAddQuestion(dialogueId) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines.push({ type: 'question', text: '', choices: ['', ''], correct_index: 0, reward_type: 'score', reward_amount: 0 });
+  triggerRenderSlot();
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineUpdateQuestionText(dialogueId, index, text) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines[index].text = text;
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+// Ajuste le NOMBRE de choix (2 à 4, voir db/dialogue_lines.py::
+// _MIN_CHOICES/_MAX_CHOICES) : ajoute des choix vides ou retire les
+// derniers, sans jamais toucher aux choix déjà remplis qui restent dans
+// la nouvelle taille. Recadre la bonne réponse sur le premier choix si
+// elle pointait vers un choix retiré.
+function triggerInlineSetQuestionChoiceCount(dialogueId, index, value) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  var line = entry.dialogueRef.lines[index];
+  var count = Math.max(2, Math.min(4, parseInt(value, 10) || 2));
+  while (line.choices.length < count) line.choices.push('');
+  while (line.choices.length > count) line.choices.pop();
+  if (line.correct_index >= line.choices.length) line.correct_index = 0;
+  triggerRenderSlot();
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineSetQuestionChoiceText(dialogueId, index, choiceIndex, text) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines[index].choices[choiceIndex] = text;
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineSetQuestionCorrectIndex(dialogueId, index, choiceIndex) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines[index].correct_index = choiceIndex;
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineSetQuestionRewardAmount(dialogueId, index, value) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines[index].reward_amount = Math.max(0, parseInt(value, 10) || 0);
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineSetBubbleSpeaker(dialogueId, index, speaker) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines[index].speaker = speaker;
+  triggerRenderSlot();
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineUpdateBubbleText(dialogueId, index, text) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines[index].text = text;
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+function triggerInlineDeleteBubble(dialogueId, index) {
+  var entry = _triggerDialogueRegistry[dialogueId];
+  if (!entry) return;
+  entry.dialogueRef.lines.splice(index, 1);
+  triggerRenderSlot();
+  triggerInlineSaveDialogue(dialogueId);
+}
+
+// ---------- Modale d'ajout de déclencheur ----------
+// Étape 1 : choisir l'objet de scène (toutes scènes du jeu confondues,
+// voir GET .../triggers/objects-catalog — contrairement à l'éditeur de
+// collision, limité à la scène actuellement ouverte). Étape 2 : le MÊME
+// assistant "déclencheur -> action" que l'éditeur de collision (voir
+// openTriggerWizard, static/js/scenes/collision-rules-editor.js).
+function ensureTriggerModal() {
+  var modal = document.getElementById('questTriggerModal');
+  if (modal) return modal;
+  modal = document.createElement('div');
+  modal.className = 'modal questTriggerModal';
+  modal.id = 'questTriggerModal';
+  modal.innerHTML =
+    '<div class="modal-background" onclick="closeTriggerModal()"></div>' +
+    '<div class="modal-content questFieldsModalContent"><div class="box">' +
+      '<div class="fieldRow" style="align-items:center; justify-content:space-between;">' +
+        '<h2 class="title is-5" style="margin:0;" id="questTriggerModalTitle">Ajouter un déclencheur</h2>' +
+        '<button type="button" class="button is-small" onclick="closeTriggerModal()">✕</button>' +
+      '</div>' +
+      '<div id="questTriggerModalBody"></div>' +
+    '</div></div>';
+  document.body.appendChild(modal);
+  return modal;
+}
+
+function openAddTriggerModal() {
+  var modal = ensureTriggerModal();
+  modal.classList.add('is-active');
+  document.getElementById('questTriggerModalTitle').textContent = 'Ajouter un déclencheur';
+  triggerRenderObjectStep();
+}
+
+function triggerRenderObjectStep() {
+  var body = document.getElementById('questTriggerModalBody');
+  body.innerHTML =
+    '<p class="hint mt-2 mb-2">Choisis l\'objet de scène qui déclenchera ce dialogue :</p>' +
+    '<div id="questTriggerObjectGrid" class="collisionWizardChoices">Chargement…</div>';
+  fetch('/game/' + GAME_SLUG + '/triggers/objects-catalog')
+    .then(function (r) { return r.json(); })
+    .then(function (objects) {
+      var grid = document.getElementById('questTriggerObjectGrid');
+      if (!grid) return;
+      if (!objects.length) { grid.innerHTML = '<p class="hint">Aucun objet éligible sur ce jeu.</p>'; return; }
+      grid.innerHTML = objects.map(function (o, i) {
+        return '<button type="button" class="collisionWizardChoice questTriggerObjectChoice" style="animation-delay:' + (i * 40) + 'ms" onclick="triggerSelectObject(' + o.id + ')">' +
+          '<div class="questTriggerObjectThumb">' + collisionRuleThumbHtml(o) + '</div>' +
+          '<span>' + (o.name || '').replace(/</g, '&lt;') + '</span>' +
+        '</button>';
+      }).join('');
+    });
+}
+
+// Objet choisi -> enchaîne directement sur l'assistant déclencheur/action
+// de l'éditeur de collision (même écran, même modale, juste la suite du
+// parcours) — voir openTriggerWizard.
+function triggerSelectObject(objectId) {
+  var body = document.getElementById('questTriggerModalBody');
+  openTriggerWizard(objectId, body);
+}
+
+// ---------- "+ Ajouter une action" (bout de chaîne d'un déclencheur
+// DÉJÀ posé) ----------
+// Demande explicite : "pouvoir modifier un déclencheur pour lui ajouter
+// des actions" — pas besoin de repasser par la modale de création, on
+// est déjà DANS ce déclencheur (voir triggerActionChainHtml). Réutilise
+// les étapes de l'assistant (static/js/scenes/collision-rules-editor.js) :
+// choix dialogue/variable, puis "Ensuite ?" (Marquer terminé + chaîner
+// encore), avant d'envoyer le tout via /append-action.
+function triggerOpenAppendActionModal(objectId, afterId) {
+  var modal = ensureTriggerModal();
+  modal.classList.add('is-active');
+  document.getElementById('questTriggerModalTitle').textContent = 'Ajouter une action';
+  var body = document.getElementById('questTriggerModalBody');
+  // État minimal partagé avec collision-rules-editor.js (mêmes étapes
+  // réutilisées telles quelles, voir renderCollisionWizardChainStep/
+  // renderCollisionWizardVariableStep — elles ne lisent que .bodyEl).
+  _collisionWizard = { bodyEl: body };
+  body.innerHTML =
+    '<p class="hint mb-2">Ajouter...</p>' +
+    '<div class="collisionWizardChoices">' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:0ms" onclick="triggerAppendLeaf(' + objectId + ', \'' + afterId + '\', \'dialogue\')">' +
+        '<span>Déclencher un dialogue</span>' +
+      '</button>' +
+      '<button type="button" class="collisionWizardChoice" style="animation-delay:40ms" onclick="triggerAppendLeaf(' + objectId + ', \'' + afterId + '\', \'variable\')">' +
+        '<span>Modifier une variable</span>' +
+      '</button>' +
+    '</div>';
+}
+
+function triggerAppendLeaf(objectId, afterId, type) {
+  if (type === 'dialogue') {
+    var leaf = { type: 'dialogue', dialogue: { id: collisionGenerateActionId(), lines: [] } };
+    renderCollisionWizardChainStep(leaf, function (finalLeaf) { triggerSaveAppendedAction(objectId, afterId, finalLeaf); });
+    return;
+  }
+  renderCollisionWizardVariableStep(function (action) {
+    renderCollisionWizardChainStep(action, function (finalLeaf) { triggerSaveAppendedAction(objectId, afterId, finalLeaf); });
+  });
+}
+
+function triggerSaveAppendedAction(objectId, afterId, action) {
+  closeTriggerModal();
+  fetch('/game/' + GAME_SLUG + '/triggers/' + objectId + '/append-action', {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ after_id: afterId, action: action }),
+  }).then(function (r) {
+    if (!r.ok) return r.json().then(function (json) { alert(json.error || "Impossible d'ajouter cette action."); });
+  }).then(function () { triggerLoadAll(); });
+}
+
+function closeTriggerModal() {
+  var modal = document.getElementById('questTriggerModal');
+  if (modal) modal.classList.remove('is-active');
+}
+
+// ---------- Point d'entrée ----------
+// Appelé directement (pas de DOMContentLoaded) : ce fichier est chargé par
+// un <script src> posé à la fin du contenu de la page — les éléments dont
+// on a besoin existent déjà à ce stade. Nécessaire aussi pour la
+// navigation pjax (voir static/pjax.js — runScriptsIn ré-exécute ce
+// script à chaque page swappée, mais DOMContentLoaded, lui, ne se
+// redéclenche jamais après le tout premier chargement réel) — sans ça,
+// l'onglet "Déclencheurs" restait vide après un remplacement de <main>
+// (ex. suppression d'un objet de scène, voir scene_object_delete.py) qui
+// ne redéclenche jamais cet événement.
+function initTriggersTab() {
+  var body = document.getElementById('triggersTabPanelBody');
+  if (!body) return;
+  body.innerHTML = '<div class="questDialogueColumns">' + triggerColumnHtml() + '</div>';
+  triggerLoadAll();
+}
+initTriggersTab();

static/style.css

@@ -725,7 +725,7 @@ body.builderBody > main.content{ flex:1 1 auto; min-height:0; overflow:hidden; d
    static/js/play/dialogue-box-controller.js) : header/body/footer,
    toujours VISIBLE dans l'éditeur (texte d'exemple, pour le positionner/
    styliser) mais masqué par défaut EN JEU tant qu'aucune règle de
-   collision "quete" n'a de réplique à afficher. */
+   collision "dialogue" n'a de réplique à afficher. */
 .dialogueBoxWidget{
   display:flex; flex-direction:column; border-radius:10px; overflow:hidden;
   box-shadow:0 6px 18px rgba(0,0,0,.35); pointer-events:auto;
@@ -740,14 +740,6 @@ body.builderBody > main.content{ flex:1 1 auto; min-height:0; overflow:hidden; d
   border-radius:6px; padding:5px 12px; font:inherit; font-size:12px; cursor:pointer;
 }
 .dialogueBoxNextBtn:hover{ background:rgba(255,255,255,.28); }
-/* Écran d'offre de quête (voir forgeShowQuestOffer, dialogue-box-controller.js) :
-   Accepter/Refuser remplacent le "Suivant" habituel dans le pied de la
-   boîte — verts/rouges pour rester lisibles sur n'importe quelle couleur
-   de pied choisie par l'auteur (voir "🎨 Style"). */
-.dialogueBoxAcceptBtn{ background:#2ecc71; border-color:#2ecc71; color:#0b1a10; font-weight:700; }
-.dialogueBoxAcceptBtn:hover{ background:#3ddb80; }
-.dialogueBoxDeclineBtn{ background:rgba(224,82,77,.25); border-color:#e0524d; }
-.dialogueBoxDeclineBtn:hover{ background:rgba(224,82,77,.4); }
 
 /* Widget "❓ Boîte à quiz" (voir screens/rendering/dialogue_box_style.py,
    static/js/play/dialogue-box-controller.js) : même squelette que
@@ -942,6 +934,14 @@ body.builderBody > main.content{ flex:1 1 auto; min-height:0; overflow:hidden; d
 .collisionWizardChoice:hover{ transform:translateY(-3px) scale(1.02); border-color:var(--accent); box-shadow:0 8px 18px rgba(0,0,0,.25); }
 .collisionWizardChoice .emoji{ font-size:22px; }
 
+/* Étape "condition" de l'assistant (voir renderCollisionWizardConditionStep,
+   collision-rules-editor.js) : variable / opérateur / valeur sur une
+   ligne — les <select>/<input> reprennent déjà le style générique
+   (voir plus haut, input[type=text]/select). */
+.collisionWizardConditionForm{ display:flex; gap:8px; flex-wrap:wrap; }
+.collisionWizardConditionForm select{ flex:1.3; min-width:120px; }
+.collisionWizardConditionForm input{ flex:0.7; min-width:80px; }
+
 /* Bulle "Appuie sur X" (voir forgeShowCollisionInteractBubble,
    collision-rules-controller.js) : SŒUR de l'objet dans son parent
    (.sceneWorld/.sceneUI, déjà position:relative) plutôt qu'ENFANT
@@ -956,10 +956,9 @@ body.builderBody > main.content{ flex:1 1 auto; min-height:0; overflow:hidden; d
   white-space:nowrap; pointer-events:none; z-index:20;
 }
 
-/* ---- Éditeur de quêtes (onglet "🗺️ Quêtes" à côté de "🧩 Collision",
+/* ---- Reliquat de l'ancien onglet "🗺️ Quêtes" (retiré, voir onglet
-   templates/scene_edit.html + modale de dialogue partagée avec
+   "Déclencheurs" et static/js/triggers/trigger-editor.js) — règles
-   l'assistant "+ Action" de l'éditeur de collision, voir
+   orphelines gardées telles quelles, aucune ne s'applique plus. ---- */
-   static/js/quests/quest-editor.js) ---- */
 .questListRow{ cursor:pointer; }
 .questPill{ display:inline-flex; align-items:center; border-radius:999px; padding:3px 10px; font-size:11.5px; font-weight:700; }
 .questPill-score{ background:rgba(242,153,74,.18); color:#f2994a; }
@@ -984,33 +983,166 @@ body.builderBody > main.content{ flex:1 1 auto; min-height:0; overflow:hidden; d
 .questDialogueModal{ z-index:61; }
 .questDialogueModal .modal-content{ width:100vw; height:100vh; max-width:100vw; max-height:100vh; margin:0; }
 /* La modale entière est une colonne flex (jamais un scroll global, voir
-   overflow:hidden ici) : le header/la fiche restent fixes en haut, les 3
+   overflow:hidden ici) : le header reste fixe en haut, le panneau de
-   colonnes de répliques se partagent TOUT le reste de la hauteur
+   déclencheurs prend TOUT le reste de la hauteur. */
-   (demandé explicitement) et défilent CHACUNE indépendamment (voir
-   .questDialogueColumnBubbles plus bas), jamais toute la page. */
 .questDialogueModal .box{ width:100%; height:100%; border-radius:0; overflow:hidden; display:flex; flex-direction:column; }
 .questDialogueModalContent{ width:100%; height:100%; max-width:100%; }
 #questDialogueModalBody{ display:flex; flex-direction:column; flex:1; min-height:0; }
+/* Onglet "Déclencheurs" (templates/scene_edit.html, #triggersTabPanel) —
+   MÊME comportement que #questDialogueModalBody ci-dessus (juste déplacé
+   hors de la modale plein écran dans un onglet, demande explicite :
+   "sans rien toucher au style en place") : colonne flex qui prend tout
+   l'espace du panneau d'onglet actif (voir .builderTabPanel.active). */
+#triggersTabPanelBody{ display:flex; flex-direction:column; flex:1; min-height:0; }
 .questDialogueModalHeader{ flex:0 0 auto; margin-bottom:10px; }
 .questFieldsGrid{ display:grid; grid-template-columns:repeat(auto-fill, minmax(160px, 1fr)); gap:10px; margin-bottom:14px; }
 .questField{ display:flex; flex-direction:column; gap:4px; font-size:12px; font-weight:600; }
 .questField-wide{ grid-column:span 2; }
-.questDialogueColumns{ flex:1; min-height:0; display:grid; grid-template-columns:repeat(3, minmax(220px, 1fr)); gap:14px; }
+/* La modale de dialogue d'une quête est un GRAPHE DE LOGIQUE lu par
+   déclencheur (demande explicite : "un RH doit le comprendre, un visuel
+   global") : UN SEUL panneau (.questDialogueColumn, 90% de largeur,
+   centré, TOUTE LA HAUTEUR disponible) — les déclencheurs de la quête
+   côte à côte (voir .questTriggersSlot plus bas), chacun avec SON PROPRE
+   dialogue édité EN LIGNE (voir .dialogueBox plus bas), PUIS les 3
+   boutons Réplique/Question/Action TOUJOURS tout en bas — ils ajoutent
+   dans le dialogue du déclencheur ACTIF (voir .questTriggerCol.active),
+   jamais dans une liste séparée. */
+.questDialogueColumns{ flex:1; min-height:0; display:flex; }
 .questDialogueColumn{
-  background:rgba(0,0,0,.15); border:1px solid var(--border); border-radius:12px; padding:10px;
+  width:90%; margin:0 auto; height:100%; min-height:0; display:flex; flex-direction:column; gap:8px;
-  display:flex; flex-direction:column; gap:8px; height:100%; min-height:0;
+  background:var(--panel2); border:1px solid var(--border); border-radius:12px; padding:12px;
 }
-.questDialogueColumnTitle{ flex:0 0 auto; margin:0 0 2px; font-size:13px; text-align:center; }
+.questDialogueColumnBody{ display:flex; flex-direction:column; align-items:center; flex:1; min-height:0; overflow-y:auto; gap:14px; padding-top:4px; }
-/* Bulles alignées VERTICALEMENT, centrées dans la colonne, reliées par un
+.questDialogueColumnButtons{ flex:0 0 auto; display:flex; gap:8px; justify-content:center; flex-wrap:wrap; }
-   trait entre chacune (voir ::before sur .questBubbleRow ci-dessous) —
-   demandé explicitement plutôt qu'un alignement gauche/droite. Seule
-   CETTE zone défile (flex:1 + overflow-y:auto) — le titre de colonne et
-   le bouton "+ Réplique" restent fixes, en haut/en bas. */
-.questDialogueColumnBubbles{ display:flex; flex-direction:column; align-items:center; flex:1; min-height:0; overflow-y:auto; padding-top:4px; }
-.questDialogueColumnButtons{ flex:0 0 auto; display:flex; gap:8px; justify-content:center; margin-top:4px; }
 .questDialogueAddBtn{ align-self:center; padding:6px 14px; font-size:12px; }
 .questQuestionAddBtn{ background:linear-gradient(135deg, #e0b93d, #b8890f); }
 
+/* TOUS les déclencheurs du jeu (voir screens/rendering/
+   trigger_graph.py::list_all_triggers) : réutilise TELLES QUELLES
+   .collisionRuleChain/.collisionRuleLink (collision-rules-editor.js) pour
+   la chaîne de pastilles, juste une petite fiche objet au-dessus. Vit dans le MÊME
+   flux que les répliques (.questDialogueColumnBody ci-dessus), aucun
+   scroll ni cadre séparé ici — plusieurs chaînes possibles côte à côte
+   (flex-wrap). */
+.questTriggersSlot{ width:100%; display:flex; flex-wrap:wrap; gap:20px; justify-content:center; }
+.questTriggersSlot:empty::before{ content:"Aucun déclencheur pour l'instant — ajoutes-en un avec le bouton ci-dessous."; color:var(--muted); font-size:13px; }
+
+/* Carte objet + pastilles empilées VERTICALEMENT, reliées par des flèches
+   (maquette validée avec l'utilisateur) — PAS la chaîne horizontale en
+   chevrons de l'éditeur de collision : deux présentations volontairement
+   différentes pour le même modèle de données sous-jacent. */
+.questTriggerCol{ position:relative; display:flex; flex-direction:column; align-items:center; width:70%; }
+/* Modale d'ajout de déclencheur (voir static/js/triggers/trigger-editor.js::
+   openAddTriggerModal) — au-dessus de l'onglet "Déclencheurs", jamais
+   recouverte. */
+.questTriggerModal{ z-index:62; }
+.questTriggerDelete{
+  position:absolute; top:-8px; right:2px; width:20px; height:20px; border-radius:50%;
+  background:var(--panel2); border:1px solid var(--border); color:var(--muted, #8b95a7);
+  font-size:10px; display:flex; align-items:center; justify-content:center; cursor:pointer; z-index:2;
+}
+.questTriggerDelete:hover{ background:#e0524d; color:#fff; border-color:#e0524d; }
+.questTriggerObjectCard{
+  width:100%; background:var(--panel2); border:1px solid var(--border); border-radius:12px;
+  padding:10px; display:flex; flex-direction:column; align-items:center; gap:6px; cursor:pointer;
+}
+.questTriggerObjectCard img{ width:36px; height:36px; border-radius:8px; object-fit:cover; }
+.questTriggerObjectCard .questTriggerObjectName{ font-weight:700; font-size:12.5px; text-align:center; }
+/* Déclencheur ACTIF (voir questClickTriggerObjectCard) : c'est LUI qui
+   reçoit les prochaines répliques/questions ajoutées par les boutons du
+   bas de la colonne — surligné pour que ce soit visible sans avoir à
+   deviner. */
+.questTriggerCol.active .questTriggerObjectCard{ border-color:#3bb3c9; box-shadow:0 0 0 2px rgba(59,179,201,.35); }
+/* Accordéon (demande explicite : "ça retracte toute la logique associée") :
+   replié = seule la carte objet reste visible, chevron tourné. */
+.questTriggerCol.collapsed{ width:auto; min-width:140px; }
+.questTriggerObjectCard .questTriggerCollapseChevron{ font-size:10px; color:var(--muted); transition:transform .15s ease; }
+.questTriggerCol.collapsed .questTriggerCollapseChevron{ transform:rotate(-90deg); }
+.questTriggerConnector{ width:2px; height:16px; background:var(--border); position:relative; flex-shrink:0; }
+.questTriggerConnector::after{
+  content:""; position:absolute; bottom:0; left:50%; transform:translate(-50%,45%);
+  border:5px solid transparent; border-top-color:var(--border);
+}
+/* Flèche menant à une condition — plus grande que les connecteurs
+   ordinaires (demande explicite : "la flèche qui part de interagir vers
+   le losange doit être plus grande"). */
+.questTriggerConnector.tall{ height:32px; width:3px; }
+.questTriggerConnector.tall::after{ border-width:7px; }
+.questTriggerPill{ width:100%; border-radius:100px; padding:8px 14px; font-size:12px; font-weight:700; text-align:center; }
+.questTriggerPill.trigger{ background:#f2994a; color:#1a1002; }
+.questTriggerPill.interagir{ background:#d4a72c; color:#1a1002; }
+.questTriggerPill.quete{ background:#9b59b6; color:#fff; }
+.questTriggerPill.none{ background:transparent; border:1.5px dashed var(--border); color:var(--muted, #8b95a7); }
+
+/* Rectangle "dialogue" — même largeur que le reste de la chaîne (100% de
+   son conteneur, comme les pastilles, maquette validée : "le rectangle
+   doit avoir la même width que les autres éléments"). Un bouton "+" en
+   haut à droite ajoute une réplique DIRECTEMENT dedans (voir
+   static/js/triggers/trigger-editor.js::triggerInlineAddBubble) — chaque
+   occurrence de "Déclencher ce dialogue" porte le sien, édité ici même,
+   à l'endroit où la flèche pointe (plus de colonne séparée). */
+.dialogueBox{
+  width:100%; background:rgba(0,0,0,.18); border:1.5px solid #3bb3c9; border-radius:14px;
+  padding:10px; display:flex; flex-direction:column; gap:8px;
+}
+.dialogueBoxHeader{ display:flex; align-items:center; justify-content:space-between; gap:8px; }
+.dialogueBoxTitle{ font-size:11px; font-weight:800; color:#3bb3c9; text-transform:uppercase; letter-spacing:.04em; }
+.dialogueBoxActions{ display:flex; gap:4px; }
+.addReplyBtn{
+  background:#3bb3c9; color:#04222a; border:none; border-radius:999px; padding:5px 14px;
+  font-size:12px; font-weight:800; line-height:1.4; cursor:pointer; flex-shrink:0;
+}
+.addReplyBtn:hover{ filter:brightness(1.1); }
+.addQuestionBtn{ background:linear-gradient(135deg, #e0b93d, #b8890f); color:#1a1002; }
+
+/* Feuille "Modifier une variable" (voir screens/rendering/collision_rules.py
+   ::"variable") — même famille visuelle que .dialogueBox (rectangle
+   pleine largeur), bordure jaune pour la distinguer d'un dialogue au
+   premier coup d'œil, pas de bulles dedans. */
+.questVariableAction{ border-color:#e0b93d; }
+.questVariableActionLabel{ margin:0; font-size:13px; color:var(--text); }
+/* "+ Ajouter une action" en bout de chaîne (demande explicite : "pouvoir
+   modifier un déclencheur pour lui ajouter des actions") — même largeur
+   que le reste de la chaîne, discret (pointillés) tant qu'on ne survole
+   pas. */
+.questTriggerAddChainedActionBtn{
+  width:100%; background:transparent; border:1.5px dashed var(--border); color:var(--muted, #8b95a7);
+}
+.questTriggerAddChainedActionBtn:hover{ border-color:var(--accent); color:var(--accent); }
+
+/* Losange "condition" — lecture ENTIÈREMENT VERTICALE (demande explicite :
+   "il faut tout mettre verticalement", le losange lui-même ne change
+   pas) : le losange reste petit et centré, la branche qui MÈNE à cette
+   quête descend tout droit en premier (flèche verte ou rouge selon
+   Vrai/Faux) vers "Déclencher ce dialogue" (pleine largeur, comme un
+   déclencheur sans condition) puis son rectangle de dialogue, PUIS
+   l'autre branche descend à son tour vers "Ne rien faire" — jamais deux
+   branches côte à côte. */
+.questCondColumn{ width:100%; display:flex; flex-direction:column; align-items:center; }
+/* Un VRAI losange (carré tourné à 45°, pas un rectangle aplati) — voir
+   demande explicite "je veut un vrai losange comme avant". */
+.questCondDiamond{
+  width:150px; height:150px; margin:16px 0; transform:rotate(45deg);
+  background:#3bb3c9; color:#04222a; display:flex; align-items:center; justify-content:center; border-radius:16%;
+  box-shadow:0 4px 14px rgba(59,179,201,.35);
+}
+.questCondDiamond span{ transform:rotate(-45deg); font-size:11.5px; font-weight:800; text-align:center; line-height:1.3; padding:0 12px; }
+/* Flèches Vrai/Faux plus grandes — demande explicite "c'est trop petit
+   trop tassé". */
+.questCondArrowWrap{ position:relative; display:flex; flex-direction:column; align-items:center; width:100%; height:68px; }
+.questCondArrowWrap svg{ width:34px; height:100%; overflow:visible; }
+.questCondArrowLabel{
+  position:absolute; left:calc(50% + 26px); top:14px; z-index:2; border-radius:999px; padding:6px 16px;
+  font-size:12.5px; font-weight:800; white-space:nowrap;
+}
+.questCondArrowLabel.yes{ background:rgba(46,204,113,.18); color:#2ecc71; border:1px solid rgba(46,204,113,.4); }
+.questCondArrowLabel.no{ background:rgba(224,82,77,.18); color:#e0524d; border:1px solid rgba(224,82,77,.4); }
+
+.questTriggerObjectThumb{ width:40px; height:40px; border-radius:8px; overflow:hidden; background:var(--panel2); display:flex; align-items:center; justify-content:center; }
+.questTriggerObjectThumb img{ width:100%; height:100%; object-fit:cover; }
+.questTriggerObjectChoice{ align-items:center; }
+.questTriggerObjectChoice.is-selected{ border-color:var(--accent); box-shadow:0 0 0 2px var(--accent); }
+
 .questBubbleRow{ display:flex; justify-content:center; width:100%; position:relative; }
 .questBubbleRow:not(:first-child)::before{
   content:''; position:absolute; top:-14px; left:50%; transform:translateX(-50%);
@@ -1029,14 +1161,15 @@ body.builderBody > main.content{ flex:1 1 auto; min-height:0; overflow:hidden; d
 .questBubble-pnj .questBubbleBody{ background:rgba(47,111,237,.16); }
 .questBubble-joueur .questBubbleHeader{ background:#1e9e57; }
 .questBubble-joueur .questBubbleBody{ background:rgba(46,204,113,.16); }
-/* "❓ Question" (voir questQuestionBubbleHtml, static/js/quests/
+/* "❓ Question" (voir triggerQuestionBubbleHtml, static/js/triggers/
-   quest-editor.js) — bulle JAUNE distincte des répliques de dialogue,
+   trigger-editor.js) — bulle JAUNE distincte des répliques de dialogue,
    même chaîne/alignement vertical (.questBubbleRow). */
 .questBubble-question .questBubbleHeader{ background:#b8890f; flex-wrap:wrap; row-gap:4px; }
 .questBubble-question .questBubbleBody{ background:rgba(224,185,61,.14); }
 .questQuestionHeaderField{
-  display:inline-flex; align-items:center; gap:4px; font-size:11px; font-weight:700; color:#fff; white-space:nowrap;
+  display:inline-flex; align-items:center; gap:6px; font-size:11px; font-weight:700; color:#fff; white-space:nowrap;
 }
+.questQuestionHeaderFieldLabel{ font-weight:700; text-transform:uppercase; font-size:10px; letter-spacing:.02em; opacity:.85; }
 .questQuestionHeaderField input{
   width:44px; background:rgba(0,0,0,.25); border:1px solid rgba(255,255,255,.3); border-radius:4px;
   color:#fff; font:inherit; font-size:11px; padding:2px 4px;
@@ -1196,7 +1329,7 @@ code{ background:var(--panel2); border:1px solid var(--border); border-radius:4p
 .builderTabBtn.active{ color:var(--accent); border-bottom-color:var(--accent); font-weight:600; }
 
 /* overflow-y:auto : contrairement à "screen" (voir .canvasFrame plus haut,
-   qui défile LUI-MÊME), "collision-rules"/"quests"/"events" n'ont pas de
+   qui défile LUI-MÊME), "triggers"/"events" n'ont pas de
    sous-conteneur dédié au défilement — sans ça, une liste plus haute que
    l'espace disponible restait simplement coupée par .builderCanvasArea
    (overflow:hidden), au lieu de défiler. */

templates/play.html

@@ -145,7 +145,7 @@
   // bonnes réponses au quiz requis pour un statut de fin "reussi" plutôt
   // que "echoue" (SCORM lesson_status ET xAPI, voir dialogue-box-controller.js).
   window.FORGE_SUCCESS_THRESHOLD_PERCENT = {{ success_threshold_percent|tojson }};
-  // Score max possible du quiz (voir db/quests/reward_budget.py) : permet
+  // Score max possible du quiz (voir db/dialogue_lines.py::sum_question_rewards) : permet
   // au SCORM 1.2 de fournir cmi.core.score.min/max en plus du score brut
   // (voir static/js/play/offline/scorm-api.js), pour qu'un LMS calcule un
   // vrai pourcentage au lieu d'afficher le score brut à tort étiqueté "%".
@@ -163,9 +163,9 @@
 </script>
 <script src="{{ asset_url('js/play/screens.js') }}"></script>
 <script src="{{ asset_url('js/play/conditions.js') }}"></script>
-{% if offline_mode %}
 <script src="{{ asset_url('js/play/offline/compute-operation.js') }}"></script>
 <script src="{{ asset_url('js/play/offline/apply-actions.js') }}"></script>
+{% if offline_mode %}
 <script src="{{ asset_url('js/play/offline/filter-repeater-rows.js') }}"></script>
 <script src="{{ asset_url('js/play/offline/visibility-condition.js') }}"></script>
 <script src="{{ asset_url('js/play/offline/render-jauge.js') }}"></script>

templates/scene_edit.html

@@ -115,7 +115,7 @@
         <button type="button" class="button is-small is-fullwidth mb-2" onclick="addSceneObject('dialogue_box')">Boîte de dialogue</button>
         <button type="button" class="button is-small is-fullwidth mb-2" onclick="addSceneObject('quiz_box')">Boîte à quiz</button>
         <button type="button" class="button is-small is-fullwidth" onclick="addSceneObject('score_widget')">Score</button>
-        <p class="help">Boîte de dialogue/quiz : gérées automatiquement par le moteur (voir l'onglet "Quêtes") — position et style réglables une fois posées. Score : affiche en continu les points gagnés.</p>
+        <p class="help">Boîte de dialogue/quiz : gérées automatiquement par le moteur (voir l'onglet "Déclencheurs") — position et style réglables une fois posées. Score : affiche en continu les points gagnés.</p>
       </div>
     </details>
     </div>
@@ -124,15 +124,16 @@
   <div class="builderCanvasArea">
     <div class="builderTabs" id="builderTabs">
       <button type="button" class="builderTabBtn active" data-tab="screen" onclick="switchBuilderTab('screen')">Scène</button>
-      <button type="button" class="builderTabBtn" data-tab="collision-rules" onclick="switchBuilderTab('collision-rules')">Collision</button>
+      <button type="button" class="builderTabBtn" data-tab="triggers" onclick="switchBuilderTab('triggers')">Déclencheurs</button>
-      <button type="button" class="builderTabBtn" data-tab="quests" onclick="switchBuilderTab('quests')">Quêtes</button>
+      <button type="button" class="builderTabBtn" data-tab="variables" onclick="switchBuilderTab('variables')">Variables</button>
       {% if game.onboarding_type != 'rpg' %}
       <!-- Événements personnalisés (voir db.list_custom_events) : aucun
-           moyen de les DÉCLENCHER depuis un jeu RPG pour l'instant —
+           moyen de les DÉCLENCHER depuis un jeu RPG pour l'instant — le
-           l'assistant "+ Action" de l'onglet Collision exclut
+           seul point d'entrée qui le permettait (l'action "evenement" de
-           délibérément le type "evenement" (voir COLLISION_WIZARD_
+           l'ancien éditeur de collision) a été retiré (demande explicite,
-           ACTION_TYPES, static/js/scenes/collision-rules-editor.js) —
+           ne servait à rien). game.onboarding_type est de toute façon
-           demande explicite : cet onglet n'a donc aucune utilité ici. -->
+           TOUJOURS "rpg" désormais (voir la suppression des types Quiz/
+           Embranchement) — cet onglet ne s'affiche donc plus jamais. -->
       <button type="button" class="builderTabBtn" data-tab="events" onclick="switchBuilderTab('events')">Événements</button>
       {% endif %}
     </div>
@@ -179,55 +180,82 @@
       <p class="hint" style="text-align:center;">Glisse pour déplacer, tire le coin pour redimensionner, clique pour sélectionner. Positions en pixels (scène à taille fixe).</p>
     </div>
 
-    <!-- Éditeur de collision (voir screens/rendering/collision_rules.py) :
+    <!-- Onglet "Déclencheurs" (voir static/js/triggers/trigger-editor.js) :
-         une carte par objet ÉLIGIBLE (jamais un "fond", jamais le
+         un graphe de logique lu par déclencheur — TOUS les déclencheurs du
-         personnage "joueur" — ce sont toujours les AUTRES objets qui
+         jeu, plus aucune notion de quête pour les regrouper (un créateur
-         réagissent à SA présence), listant ses règles "déclencheur ->
+         peut faire un simple quiz sans jamais poser de personnage). Chaque
-         action" déjà posées + un bouton "+ Action" qui ouvre l'assistant
+         déclencheur (objet -> collision -> action) porte SON PROPRE
-         (modale plus bas). Rendu ENTIÈREMENT en JS (voir
+         dialogue, édité en ligne (voir openTriggerWizard(), static/js/
-         static/js/scenes/collision-rules-editor.js) à partir de
+         scenes/collision-rules-editor.js). -->
-         COLLISION_RULE_OBJECTS/CUSTOM_EVENTS_MAP — jamais en Jinja, pour
+    <div class="builderTabPanel" id="triggersTabPanel" data-tab-panel="triggers">
-         pouvoir se redessiner à chaud après chaque ajout/suppression de
+      <div id="triggersTabPanelBody"></div>
-         règle sans recharger la page. -->
-    <div class="builderTabPanel" id="collisionRulesTabPanel" data-tab-panel="collision-rules">
-      <div class="dashPanelHeader">
-        <h2>Collision</h2>
-      </div>
-      <p class="hint">Pour chaque objet (jamais le joueur lui-même), choisis ce qui doit se passer à son contact — la carte se construit au fil de tes choix, comme des pièces qui s'emboîtent.</p>
-      <div id="collisionRulesCards" class="collisionRulesCards"></div>
     </div>
 
-    <!-- Assistant "+ Action" — un seul écran affiché à la fois
+    <!-- Variables globales (voir db/global_vars/) : accessibles à TOUT le
-         (#collisionRuleModalBody, reconstruit à chaque étape), jamais un
+         jeu par leur NOM (immuable après création — condition de
-         vrai formulaire à plusieurs pages : chaque clic choisit une
+         visibilité, action "Modifier une variable", voir
-         option et avance directement à la suivante. -->
+         static/js/play/conditions.js::readVariableValue), pas seulement à
-    <div class="modal" id="collisionRuleModal">
+         un écran. Même patron que l'onglet Événements ci-dessous (table +
-      <div class="modal-background" onclick="closeCollisionRuleModal()"></div>
+         formulaires classiques, POST/redirect — pas de rendu JS). -->
-      <div class="modal-content">
+    <div class="builderTabPanel" id="variablesTabPanel" data-tab-panel="variables">
-        <div class="box">
-          <div class="fieldRow" style="align-items:center; justify-content:space-between;">
-            <h2 class="title is-5" style="margin:0;">Nouvelle règle</h2>
-            <button type="button" class="button is-small" onclick="closeCollisionRuleModal()">✕</button>
-          </div>
-          <div id="collisionRuleModalBody"></div>
-        </div>
-      </div>
-    </div>
-
-    <!-- Éditeur de quêtes (voir db/quests/) : une LISTE (comme l'onglet
-         Événements juste après), pas une grille de cartes — chaque ligne
-         résume titre/objectif/récompense/statut/résultat, cliquer dessus
-         ouvre la modale d'arbre de dialogue (static/js/quests/
-         quest-editor.js, partagée avec l'assistant "+ Action" de l'onglet
-         Collision). Rendu ENTIÈREMENT en JS depuis QUESTS_JSON, même
-         convention que #collisionRulesCards ci-dessus. -->
-    <div class="builderTabPanel" id="questsTabPanel" data-tab-panel="quests">
       <div class="dashPanelHeader">
-        <h2>Quêtes</h2>
+        <h2>Variables</h2>
-        <button type="button" class="button is-small primary" onclick="createQuestFromListPage()">+ Créer une quête</button>
+        <button type="button" class="button is-small primary" onclick="toggleDashCreate('variables')">+ Créer une variable</button>
       </div>
-      <p class="hint">Titre, objectif, récompense, statut, résultat — clique sur une ligne pour écrire son enchaînement de dialogue.</p>
+      <p class="hint">Accessibles depuis n'importe quelle scène (conditions, actions "Modifier une variable"). Le nom ne peut plus changer une fois créé.</p>
-      <div id="questsListWrap"></div>
+      <form method="post" action="{{ url_for('create_global_var', slug=game.slug) }}" class="dashCreateBar" id="dashCreate-variables" style="display:none;">
+        <input type="hidden" name="screen_id" value="{{ screen.id }}">
+        <input type="text" name="name" placeholder="NOM (ex. score_total)" required autocomplete="off">
+        <select name="type">
+          {% for key, t in global_variable_types.items() %}
+          <option value="{{ key }}">{{ t.label }}</option>
+          {% endfor %}
+        </select>
+        <input type="text" name="default_value" placeholder="Valeur par défaut">
+        <label class="checkbox" style="display:flex; align-items:center; gap:4px; white-space:nowrap;" title="Chaque joueur a sa propre valeur (décoché = valeur unique partagée par tous)">
+          <input type="checkbox" name="per_player" value="1" checked> Par joueur
+        </label>
+        <button type="submit" class="primary">Créer</button>
+      </form>
+
+      {% if global_variables %}
+      {% for v in global_variables %}
+      <form method="post" action="{{ url_for('global_var_edit', slug=game.slug, var_id=v.id) }}" id="varEditForm{{ v.id }}">
+        <input type="hidden" name="screen_id" value="{{ screen.id }}">
+      </form>
+      {% endfor %}
+      <div class="fieldsTableWrap">
+        <table class="table is-fullwidth is-hoverable fieldsTable">
+          <thead><tr><th>Nom</th><th>Type</th><th>Valeur</th><th>Par joueur</th><th></th></tr></thead>
+          <tbody>
+            {% for v in global_variables %}
+            <tr>
+              <td><code>{{ v.name }}</code></td>
+              <td>
+                <select form="varEditForm{{ v.id }}" name="type" aria-label="Type de « {{ v.name }} »">
+                  {% for key, t in global_variable_types.items() %}
+                  <option value="{{ key }}" {{ 'selected' if v.type == key else '' }}>{{ t.label }}</option>
+                  {% endfor %}
+                </select>
+              </td>
+              <td><input type="text" form="varEditForm{{ v.id }}" name="value" value="{{ v.value or '' }}" placeholder="Valeur" aria-label="Valeur de « {{ v.name }} »"></td>
+              <td><span class="hint">{{ 'Oui' if v.per_player else 'Non (partagée)' }}</span></td>
+              <td class="fieldsTableActions">
+                <button type="submit" form="varEditForm{{ v.id }}" class="button is-small" title="Enregistrer">💾</button>
+                <form method="post" action="{{ url_for('global_var_delete', slug=game.slug, var_id=v.id) }}"
+                      onsubmit="return confirm('Supprimer la variable « {{ v.name }} » ? Toute condition/action qui la référence encore cessera de fonctionner.');">
+                  <input type="hidden" name="screen_id" value="{{ screen.id }}">
+                  <button type="submit" class="button is-small is-danger" title="Supprimer">🗑️</button>
+                </form>
+              </td>
+            </tr>
+            {% endfor %}
+          </tbody>
+        </table>
+      </div>
+      {% else %}
+      <p class="hint">Aucune variable pour l'instant — crée la première ci-dessus.</p>
+      {% endif %}
     </div>
 
     {% if game.onboarding_type != 'rpg' %}
@@ -311,9 +339,9 @@
            screens/scenes/set_scene_object_name.py) — n'importe quel kind
            (personnage, décor, fond), pas seulement un personnage — c'est
            CE nom qui est ensuite proposé comme "qui parle" dans l'éditeur
-           de dialogue de quête (voir "🗺️ Quêtes", static/js/quests/
+           de dialogue d'un déclencheur (voir "Déclencheurs", static/js/
-           quest-editor.js) : un dialogue peut mettre en scène n'importe
+           triggers/trigger-editor.js) : un dialogue peut mettre en scène
-           quel objet, pas seulement un personnage. -->
+           n'importe quel objet, pas seulement un personnage. -->
       <details class="propGroup" open>
         <summary>Informations</summary>
         <div class="propGroupBody">
@@ -602,18 +630,15 @@
   var ANIMATE_CSS_LABELS = {{ animate_css_labels_json|safe }};
   var SPRITE_LIBRARY = {{ sprite_library_json|safe }};
   var ELEMENT_ANIMATIONS_MAP = {{ element_animations_map_json|safe }};
-  var COLLISION_RULE_OBJECTS = {{ collision_rule_objects_json|safe }};
-  var COLLISION_ACTION_TYPES = {{ collision_action_types|tojson }};
-  var COLLISION_TRIGGER_TYPES = {{ collision_trigger_types|tojson }};
-  var COLLISION_DEFAULT_PERIMETRE_PX = {{ collision_default_perimetre_px }};
-  // Éditeur de quêtes (voir static/js/quests/quest-editor.js) — chargé
-  // avant collision-rules-editor.js : l'action "quete" de l'assistant
-  // "+ Action" ouvre directement cet éditeur (renderQuestPickerStep).
-  var QUESTS_JSON = {{ quests_json|safe }};
   // "qui parle" dans l'éditeur de dialogue (voir "ℹ️ Informations" +
-  // static/js/quests/quest-editor.js::questSpeakerOptions) — n'importe
+  // static/js/triggers/trigger-editor.js::triggerSpeakerOptions) —
-  // quel objet de scène nommé, pas seulement un personnage.
+  // n'importe quel objet de scène nommé, pas seulement un personnage.
   var SCENE_OBJECT_NAMES_JSON = {{ scene_object_names_json|safe }};
+  // Assistant "condition" d'un déclencheur (voir static/js/scenes/
+  // collision-rules-editor.js::renderCollisionWizardConditionStep) — les
+  // noms des variables globales du jeu (voir l'onglet "Variables"
+  // ci-dessus), pour peupler son sélecteur de variable.
+  var GLOBAL_VARIABLE_NAMES = {{ global_variables | map(attribute='name') | list | tojson }};
 </script>
 <script src="{{ url_for('static', filename='js/screen_edit/tree-panels.js') }}"></script>
 <script src="{{ url_for('static', filename='js/screen_edit/panel-init.js') }}"></script>
@@ -621,6 +646,6 @@
 <script src="{{ url_for('static', filename='js/screen_edit/builder-tabs.js') }}"></script>
 <script src="{{ url_for('static', filename='js/screen_edit/personnage-preview.js') }}"></script>
 <script src="{{ url_for('static', filename='js/scenes/scene-editor.js') }}"></script>
-<script src="{{ url_for('static', filename='js/quests/quest-editor.js') }}"></script>
+<script src="{{ url_for('static', filename='js/triggers/trigger-editor.js') }}"></script>
 <script src="{{ url_for('static', filename='js/scenes/collision-rules-editor.js') }}"></script>
 {% endblock %}

tests/test_collision_rules.py

@@ -1,12 +1,11 @@
-"""Éditeur de collision (onglet "🧩 Collision", voir
+"""Règles de collision (voir screens/rendering/collision_rules.py) : une
-screens/rendering/collision_rules.py) : une règle "déclencheur (collision/
+règle "déclencheur (collision) -> action (dialogue/interagir/condition)"
-périmètre) -> action (quête/attaque/événement/interagir)" par carte
+par objet de scène — toujours les AUTRES objets qui réagissent à la
-objet — toujours les AUTRES objets qui réagissent à la présence du
+présence du joueur, jamais l'inverse. Posées depuis l'onglet
-joueur, jamais l'inverse. static/js/scenes/collision-rules-editor.js
+"Déclencheurs" (voir tests/test_triggers.py pour le parcours complet côté
-construit l'assistant "+ Action" ; ce fichier teste la couche serveur
+route) — ce fichier teste la couche de validation/lecture elle-même
-(défauts, validation, exposition dans full_game_payload)."""
+(sanitize_collision_rules/resolve_collision_rules), plus l'exposition
-import re
+dans full_game_payload."""
-
 import db
 import screens
 
@@ -19,6 +18,7 @@ def _create_jeu2d_game(client, tmp_game_slug_cleanup, name="pytest_collision_rul
 
 
 def _add_personnage(client, slug, screen_id, role=None):
+    import re
     resp = client.post(f"/game/{slug}/screens/{screen_id}/scene-objects/add", data={"kind": "personnage"}, follow_redirects=False)
     assert resp.status_code == 302, resp.data
     obj_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
@@ -27,13 +27,6 @@ def _add_personnage(client, slug, screen_id, role=None):
     return obj_id
 
 
-def _add_custom_event(client, slug, name="NEED_HELP"):
-    resp = client.post(f"/game/{slug}/events/new", data={"name": name}, follow_redirects=False)
-    assert resp.status_code == 302, resp.data
-    events = screens.list_custom_events(slug) if hasattr(screens, "list_custom_events") else __import__("db").list_custom_events(slug)
-    return next(e["id"] for e in events if e["name"] == name)
-
-
 def test_freshly_placed_object_has_no_collision_rules(client, tmp_game_slug_cleanup):
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
     enemy_id = _add_personnage(client, slug, screen_id, role="ennemie")
@@ -41,93 +34,293 @@ def test_freshly_placed_object_has_no_collision_rules(client, tmp_game_slug_clea
     assert screens.resolve_collision_rules(obj) == []
 
 
-def test_rules_route_persists_a_collision_trigger_attack_action(client, tmp_game_slug_cleanup):
+def test_sanitize_collision_rules_keeps_a_dialogue_action(tmp_game_slug_cleanup):
-    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    slug = tmp_game_slug_cleanup(db.create_game("pytest_collision_sanitize"))
-    enemy_id = _add_personnage(client, slug, screen_id, role="ennemie")
+    rules = screens.sanitize_collision_rules([
-
+        {"trigger": "collision", "action": {"type": "dialogue"}},
-    resp = client.post(
+    ])
-        f"/game/{slug}/scene-objects/{enemy_id}/collision-rules",
+    assert rules == [{"trigger": "collision", "action": {"type": "dialogue"}}]
-        data='{"rules": [{"trigger": "collision", "action": {"type": "attaque"}}]}',
-        content_type="application/json",
-    )
-    assert resp.status_code == 200
-    assert resp.get_json()["rules"] == [{"trigger": "collision", "action": {"type": "attaque"}}]
-    obj = screens.get_scene_object(slug, enemy_id)
-    assert screens.resolve_collision_rules(obj) == [{"trigger": "collision", "action": {"type": "attaque"}}]
 
 
-def test_rules_route_persists_a_perimeter_trigger_with_custom_radius(client, tmp_game_slug_cleanup):
+def test_sanitize_collision_rules_keeps_an_interagir_action_with_one_level_of_nesting():
-    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
-    enemy_id = _add_personnage(client, slug, screen_id, role="ennemie")
-
-    resp = client.post(
-        f"/game/{slug}/scene-objects/{enemy_id}/collision-rules",
-        data='{"rules": [{"trigger": "perimetre", "perimetre_px": 40, "action": {"type": "attaque"}}]}',
-        content_type="application/json",
-    )
-    rules = resp.get_json()["rules"]
-    assert rules == [{"trigger": "perimetre", "perimetre_px": 40.0, "action": {"type": "attaque"}}]
-
-
-def test_rules_route_persists_a_quest_action_referencing_a_quest_id(client, tmp_game_slug_cleanup):
-    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
-    pnj_id = _add_personnage(client, slug, screen_id, role="pnj")
-    quest = db.create_quest(slug, "Trouver la clé")
-
-    resp = client.post(
-        f"/game/{slug}/scene-objects/{pnj_id}/collision-rules",
-        data='{"rules": [{"trigger": "collision", "action": {"type": "quete", "quete_id": ' + str(quest["id"]) + '}}]}',
-        content_type="application/json",
-    )
-    assert resp.get_json()["rules"] == [{"trigger": "collision", "action": {"type": "quete", "quete_id": quest["id"]}}]
-
-
-def test_rules_route_persists_an_interagir_action_with_one_level_of_nesting(client, tmp_game_slug_cleanup):
     """"interagir" affiche "Appuie sur [touche]" puis exécute une SOUS-action
     à l'appui — un seul niveau d'imbrication autorisé (voir
     screens/rendering/collision_rules.py::_MAX_ACTION_DEPTH)."""
-    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    rules = screens.sanitize_collision_rules([
-    pnj_id = _add_personnage(client, slug, screen_id, role="pnj")
+        {"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "dialogue"}}},
-
+    ])
-    resp = client.post(
+    assert rules == [
-        f"/game/{slug}/scene-objects/{pnj_id}/collision-rules",
+        {"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "dialogue"}}},
-        data='{"rules": [{"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "quete", "quete_id": 1}}}]}',
-        content_type="application/json",
-    )
-    assert resp.get_json()["rules"] == [
-        {"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "quete", "quete_id": 1}}},
     ]
 
 
-def test_rules_route_rejects_interagir_nested_inside_interagir(client, tmp_game_slug_cleanup):
+def test_sanitize_collision_rules_rejects_interagir_nested_inside_interagir():
     """Une imbrication trop profonde (interagir -> interagir -> ...) est
     ignorée plutôt que d'accepter une structure sans fin postée à la main."""
-    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    rules = screens.sanitize_collision_rules([
-    pnj_id = _add_personnage(client, slug, screen_id, role="pnj")
+        {"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "interagir", "sub_action": {"type": "dialogue"}}}},
-
+    ])
-    resp = client.post(
+    assert rules == []  # la règle entière est rejetée
-        f"/game/{slug}/scene-objects/{pnj_id}/collision-rules",
-        data='{"rules": [{"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "interagir", "sub_action": {"type": "attaque"}}}}]}',
-        content_type="application/json",
-    )
-    assert resp.get_json()["rules"] == []  # la règle entière est rejetée
 
 
-def test_rules_route_drops_malformed_rules(client, tmp_game_slug_cleanup):
+def test_sanitize_collision_rules_keeps_a_condition_action_with_both_branches():
-    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    """"condition" (losange à embranchement, maquette validée) : Vrai/Faux
-    enemy_id = _add_personnage(client, slug, screen_id, role="ennemie")
+    peuvent chacun valoir None ("ne rien faire") ou une action "dialogue"."""
-
+    rules = screens.sanitize_collision_rules([{
-    resp = client.post(
+        "trigger": "collision",
-        f"/game/{slug}/scene-objects/{enemy_id}/collision-rules",
+        "action": {
-        data='{"rules": [{"trigger": "diagonale", "action": {"type": "attaque"}}, {"trigger": "collision", "action": {"type": "sorcellerie"}}, "pas un objet"]}',
+            "type": "condition", "variable": "inventaire_cle", "operateur": "superieur", "valeur": "0",
-        content_type="application/json",
+            "si_vrai": {"type": "dialogue"}, "si_faux": None,
-    )
+        },
-    assert resp.get_json()["rules"] == []
+    }])
+    assert rules == [{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "inventaire_cle", "operateur": "superieur", "valeur": "0",
+            "si_vrai": {"type": "dialogue"}, "si_faux": None,
+        },
+    }]
 
 
-def test_rules_route_404s_for_missing_object(client, game):
+def test_sanitize_collision_rules_rejects_a_condition_without_variable_or_with_an_unknown_operator():
-    resp = client.post(f"/game/{game}/scene-objects/999999/collision-rules", data='{"rules": []}', content_type="application/json")
+    rules = screens.sanitize_collision_rules([
-    assert resp.status_code == 404
+        {"trigger": "collision", "action": {"type": "condition", "variable": "", "operateur": "superieur", "valeur": "0", "si_vrai": None, "si_faux": None}},
+        {"trigger": "collision", "action": {"type": "condition", "variable": "score", "operateur": "sorcellerie", "valeur": "0", "si_vrai": None, "si_faux": None}},
+    ])
+    assert rules == []
+
+
+def test_sanitize_collision_rules_rejects_interagir_nested_inside_a_condition_branch():
+    """Une branche Vrai/Faux reste une FEUILLE — jamais une nouvelle
+    "interagir"/"condition" imbriquée (voir maquette validée : chaque
+    branche n'a que "Déclencher ce dialogue" ou "Ne rien faire")."""
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "score", "operateur": "egal", "valeur": "1",
+            "si_vrai": {"type": "interagir", "sub_action": {"type": "dialogue"}}, "si_faux": None,
+        },
+    }])
+    assert rules == [{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "score", "operateur": "egal", "valeur": "1",
+            "si_vrai": None, "si_faux": None,
+        },
+    }]
+
+
+def test_sanitize_collision_rules_keeps_interagir_wrapping_a_condition():
+    """interagir -> condition -> dialogue (maquette validée : "Interagir avec
+    une touche" PUIS un test avant de déclencher le dialogue)."""
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "interagir",
+            "sub_action": {
+                "type": "condition", "variable": "score", "operateur": "superieur_egal", "valeur": "10",
+                "si_vrai": {"type": "dialogue"}, "si_faux": {"type": "dialogue"}},
+        },
+    }])
+    assert rules[0]["action"]["sub_action"]["type"] == "condition"
+    assert rules[0]["action"]["sub_action"]["si_vrai"] == {"type": "dialogue"}
+
+
+def test_sanitize_collision_rules_keeps_a_valid_dialogue_and_mark_completed():
+    """Chaque occurrence de "Déclencher ce dialogue" porte SON PROPRE
+    dialogue ({id, lines}, voir maquette validée : "un dialogue est un
+    ensemble de répliques regroupées par un id")."""
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue", "mark_completed": True,
+            "dialogue": {"id": "d_1", "lines": [{"speaker": "pnj", "text": "Salut !"}, {"speaker": "x", "text": "  "}]},
+        },
+    }])
+    assert rules == [{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue", "mark_completed": True,
+            "dialogue": {"id": "d_1", "lines": [{"type": "dialogue", "speaker": "pnj", "text": "Salut !"}]},
+        },
+    }]
+
+
+def test_sanitize_collision_rules_drops_a_dialogue_without_a_valid_id():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "  ", "lines": [{"speaker": "pnj", "text": "Salut !"}]}},
+    }])
+    assert "dialogue" not in rules[0]["action"]
+
+
+def test_sanitize_collision_rules_keeps_a_dialogue_on_a_condition_branch():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "score", "operateur": "egal", "valeur": "1",
+            "si_vrai": {"type": "dialogue", "dialogue": {"id": "d_vrai", "lines": []}}, "si_faux": None,
+        },
+    }])
+    assert rules[0]["action"]["si_vrai"]["dialogue"] == {"id": "d_vrai", "lines": []}
+
+
+def test_set_dialogue_lines_in_rules_updates_the_matching_dialogue_wherever_it_is():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "interagir",
+            "sub_action": {
+                "type": "condition", "variable": "score", "operateur": "egal", "valeur": "1",
+                "si_vrai": None, "si_faux": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+            },
+        },
+    }])
+    updated = screens.set_dialogue_lines_in_rules(rules, "d_1", [{"speaker": "pnj", "text": "Trouvé !"}])
+    assert updated is True
+    assert rules[0]["action"]["sub_action"]["si_faux"]["dialogue"]["lines"] == [{"type": "dialogue", "speaker": "pnj", "text": "Trouvé !"}]
+
+
+def test_set_dialogue_lines_in_rules_returns_false_for_an_unknown_dialogue_id():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+    assert screens.set_dialogue_lines_in_rules(rules, "d_absent", [{"speaker": "pnj", "text": "x"}]) is False
+    assert rules[0]["action"]["dialogue"]["lines"] == []  # inchangé
+
+
+def test_sanitize_collision_rules_keeps_a_variable_action():
+    """"Modifier une variable" (même vocabulaire que l'action du graphe de
+    logique document, voir screens/labels/data_operations.py) — utilisable
+    partout où une feuille est attendue : ici directement après une
+    collision."""
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "variable", "id": "d_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "5"},
+    }])
+    assert rules == [{
+        "trigger": "collision",
+        "action": {"type": "variable", "id": "d_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "5"},
+    }]
+
+
+def test_sanitize_collision_rules_drops_a_variable_action_without_a_target_or_with_an_unknown_operation():
+    rules = screens.sanitize_collision_rules([
+        {"trigger": "collision", "action": {"type": "variable", "target_variable": "", "data_operation": "incrementer"}},
+        {"trigger": "collision", "action": {"type": "variable", "target_variable": "score", "data_operation": "sorcellerie"}},
+    ])
+    assert rules == []
+
+
+def test_sanitize_collision_rules_omits_data_value_for_operations_that_need_none():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "variable", "target_variable": "actif", "data_operation": "basculer_bool", "data_value": "peu importe"},
+    }])
+    assert "data_value" not in rules[0]["action"]
+
+
+def test_sanitize_collision_rules_keeps_a_variable_action_as_a_condition_branch():
+    """Une branche Vrai/Faux peut être une feuille "variable" tout autant
+    qu'une feuille "dialogue" (voir maquette validée : chaque branche
+    reste une feuille, peu importe laquelle)."""
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "score", "operateur": "egal", "valeur": "1",
+            "si_vrai": {"type": "variable", "target_variable": "vies", "data_operation": "decrementer", "data_value": "1"}, "si_faux": None,
+        },
+    }])
+    assert rules[0]["action"]["si_vrai"]["type"] == "variable"
+
+
+def test_sanitize_collision_rules_keeps_a_then_chain_of_leaves():
+    """Chaînage (demande explicite : "pouvoir modifier un déclencheur pour
+    lui ajouter des actions") : dialogue -> then variable -> then dialogue,
+    plusieurs actions à la suite sur le MÊME déclencheur."""
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue", "dialogue": {"id": "d_1", "lines": []},
+            "then": {
+                "type": "variable", "id": "d_2", "target_variable": "score", "data_operation": "incrementer", "data_value": "1",
+                "then": {"type": "dialogue", "dialogue": {"id": "d_3", "lines": []}},
+            },
+        },
+    }])
+    action = rules[0]["action"]
+    assert action["then"]["type"] == "variable"
+    assert action["then"]["then"] == {"type": "dialogue", "dialogue": {"id": "d_3", "lines": []}}
+
+
+def test_sanitize_collision_rules_bounds_a_then_chain_that_is_too_long():
+    """_MAX_THEN_CHAIN borne la chaîne — une chaîne trop longue postée à la
+    main est coupée plutôt que rejetée entièrement (même tolérance que le
+    reste de ce moteur)."""
+    chain = {"type": "variable", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"}
+    node = chain
+    for _ in range(10):  # largement au-delà de _MAX_THEN_CHAIN (4)
+        node["then"] = {"type": "variable", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"}
+        node = node["then"]
+    rules = screens.sanitize_collision_rules([{"trigger": "collision", "action": chain}])
+    depth = 0
+    node = rules[0]["action"]
+    while node:
+        depth += 1
+        node = node.get("then")
+    assert depth == 4  # _MAX_THEN_CHAIN, jamais plus
+
+
+def test_set_then_action_in_rules_attaches_a_new_leaf_at_the_end_of_a_dialogue_chain():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+    attached = screens.set_then_action_in_rules(rules, "d_1", {"type": "variable", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"})
+    assert attached is True
+    assert rules[0]["action"]["then"] == {"type": "variable", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"}
+
+
+def test_set_then_action_in_rules_addresses_a_variable_leaf_by_its_own_id():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"},
+    }])
+    attached = screens.set_then_action_in_rules(rules, "v_1", {"type": "dialogue", "dialogue": {"id": "d_2", "lines": []}})
+    assert attached is True
+    assert rules[0]["action"]["then"]["dialogue"]["id"] == "d_2"
+
+
+def test_set_then_action_in_rules_returns_false_for_an_unknown_leaf_id():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+    assert screens.set_then_action_in_rules(rules, "d_absent", {"type": "variable", "target_variable": "score", "data_operation": "incrementer"}) is False
+
+
+def test_set_then_action_in_rules_never_overwrites_an_existing_then():
+    rules = screens.sanitize_collision_rules([{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue", "dialogue": {"id": "d_1", "lines": []},
+            "then": {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"},
+        },
+    }])
+    attached = screens.set_then_action_in_rules(rules, "d_1", {"type": "variable", "target_variable": "vies", "data_operation": "decrementer", "data_value": "1"})
+    assert attached is False
+    assert rules[0]["action"]["then"]["target_variable"] == "score"  # inchangé
+
+
+def test_sanitize_collision_rules_drops_malformed_or_unknown_rules():
+    rules = screens.sanitize_collision_rules([
+        {"trigger": "diagonale", "action": {"type": "dialogue"}},
+        {"trigger": "collision", "action": {"type": "sorcellerie"}},
+        {"trigger": "perimetre", "action": {"type": "dialogue"}},  # "perimetre" retiré (demande explicite)
+        "pas un objet",
+    ])
+    assert rules == []
 
 
 def test_full_game_payload_excludes_the_player_and_fond_from_collision_rule_objects(client, tmp_game_slug_cleanup):
@@ -148,17 +341,34 @@ def test_full_game_payload_excludes_the_player_and_fond_from_collision_rule_obje
     assert enemy_payload["collision_rules"] == []
 
 
-def test_scene_edit_view_lists_eligible_objects_only(client, tmp_game_slug_cleanup):
+def test_build_collision_rule_objects_excludes_the_player(client, tmp_game_slug_cleanup):
+    """screens.build_collision_rule_objects (voir screens/rendering/
+    trigger_graph.py pour son autre appelant, le listage de tous les
+    déclencheurs du jeu) : "Joueur" (le seul rôle exclu) est désormais
+    toujours un choix explicite."""
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
-    # Rôle "pnj" par défaut (voir add_scene_object.py, demande explicite) :
-    # "Joueur" (le seul rôle exclu de "🧩 Collision") est désormais toujours
-    # un choix explicite.
     player_id = _add_personnage(client, slug, screen_id, role="joueur")
     enemy_id = _add_personnage(client, slug, screen_id, role="ennemie")
 
-    html = client.get(f"/game/{slug}/screens/{screen_id}/edit").get_data(as_text=True)
+    objects = screens.list_scene_objects(slug, screen_id)
-    idx = html.find("var COLLISION_RULE_OBJECTS")
+    for o in objects:
-    end = html.find(";", idx)
+        o["rendered_html"] = screens.render_scene_object(o)
-    snippet = html[idx:end]
+    rule_objects = screens.build_collision_rule_objects(objects)
-    assert f'"id": {enemy_id}' in snippet
+    ids = [o["id"] for o in rule_objects]
-    assert f'"id": {player_id}' not in snippet
+    assert enemy_id in ids
+    assert player_id not in ids
+
+
+def test_game_play_online_route_loads_the_scripts_that_apply_a_variable_action(client, tmp_game_slug_cleanup):
+    """Bug corrigé : compute-operation.js/apply-actions.js (qui portent
+    forgeApplyVariableActionOffline, appelée par collision-rules-controller.js
+    pour l'action "Modifier une variable") n'étaient chargés QUE derrière
+    `{% if offline_mode %}` dans templates/play.html — en aperçu créateur
+    (/game/<slug>/play, jamais offline_mode), l'action ne faisait donc
+    RIEN (fonction absente). Les deux scripts doivent être chargés
+    inconditionnellement (voir aussi test_export_scorm.py, qui vérifie
+    qu'ils restent bien présents dans le paquet exporté)."""
+    slug, _ = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    html = client.get(f"/game/{slug}/play").data.decode()
+    assert 'src="/static/js/play/offline/compute-operation.js"' in html
+    assert 'src="/static/js/play/offline/apply-actions.js"' in html

tests/test_dialogue_box.py

@@ -1,11 +1,11 @@
 """Widget d'interface "🖥️ Interface -> 💬 Boîte de dialogue" (voir
 screens/rendering/dialogue_box_style.py, screens/scenes/add_scene_object.py
 kind="dialogue_box") : affiche automatiquement, en jeu, la réplique en
-cours d'une quête déclenchée par une règle de collision "quete" (voir
+cours d'un dialogue déclenché par une règle de collision "dialogue" (voir
 static/js/play/dialogue-box-controller.js) — header/body/footer
 stylisables. Et le nom d'un personnage ("ℹ️ Informations",
 screens/scenes/set_scene_object_name.py), utilisé comme "qui parle" dans
-l'éditeur de dialogue de quête (screens/rendering/scene_object_names.py)."""
+l'éditeur de dialogue d'un déclencheur (screens/rendering/scene_object_names.py)."""
 import db
 import screens
 
@@ -44,10 +44,8 @@ def test_render_dialogue_box_has_header_body_footer(tmp_game_slug_cleanup):
     assert f'data-object-id="{obj_id}"' in html
     # Bug corrigé : le footer n'avait PAS data-dialogue-role="footer" (seul
     # son bouton "Suivant" interne l'avait, sous "next-btn") — le JS
-    # (forgeShowQuestOffer, static/js/play/dialogue-box-controller.js) le
+    # (forgeResetDialogueBoxFooter, static/js/play/dialogue-box-controller.js)
-    # cherche par ce sélecteur pour y injecter Accepter/Refuser en fin de
+    # le cherche par ce sélecteur pour y (re)poser le bouton "Suivant".
-    # dialogue d'une quête "nouvelle" ; sans lui, l'écran d'offre gardait
-    # silencieusement le bouton "Suivant" au lieu des deux nouveaux boutons.
     assert 'data-dialogue-role="header"' in html
     assert 'data-dialogue-role="body"' in html
     assert 'data-dialogue-role="footer"' in html
@@ -95,11 +93,16 @@ def test_dialogue_box_excluded_from_collision_rules_payload(tmp_game_slug_cleanu
     assert box["dialogue_box_style"] == screens.DEFAULT_DIALOGUE_BOX_STYLE
 
 
-def test_full_game_payload_exposes_quests_game_wide(tmp_game_slug_cleanup):
+def test_full_game_payload_exposes_completable_dialogue_ids_game_wide(tmp_game_slug_cleanup):
     slug, screen_id = _create_jeu2d_game(tmp_game_slug_cleanup)
-    db.create_quest(slug, "Trouver la clé")
+    obj_id = screens.add_scene_object(slug, screen_id, kind="personnage")
+    rules = [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}, "mark_completed": True},
+    }]
+    screens.set_scene_object_collision_rules(slug, obj_id, screens.sanitize_collision_rules(rules))
     payload = screens.full_game_payload(slug)
-    assert [q["title"] for q in payload["quests"]] == ["Trouver la clé"]
+    assert payload["completable_dialogue_ids"] == ["d_1"]
 
 
 # ---------- Nom d'un personnage ("ℹ️ Informations") ----------
@@ -179,7 +182,7 @@ def test_render_quiz_box_has_header_and_choices(tmp_game_slug_cleanup):
     obj_id = screens.add_scene_object(slug, screen_id, kind="quiz_box")
     obj = screens.get_scene_object(slug, obj_id)
     html = screens.render_scene_object(obj)
-    assert 'data-quiz-role="header"' in html  # "Quête : <titre>", rempli en jeu
+    assert 'data-quiz-role="header"' in html  # nom de l'objet déclencheur, rempli en jeu
     assert 'data-quiz-role="question"' in html  # le texte de la question, dans le corps
     assert 'data-quiz-role="choices"' in html
     assert f'data-object-id="{obj_id}"' in html

tests/test_export_scorm.py

@@ -6,9 +6,11 @@ vérifient l'assemblage (imsmanifest.xml, index.html en FORGE_OFFLINE,
 JS hors ligne présent), jamais un vrai import dans un LMS réel (voir le
 plan — validation ADL SCORM Cloud/Moodle hors du champ de la suite
 automatisée)."""
+import re
 import zipfile
 
 import db
+import screens
 from tests.test_auth import anon_client  # noqa: F401
 
 
@@ -125,7 +127,7 @@ def test_export_scorm_2004_uses_the_2004_manifest_and_wrapper(client, game):
 
 
 def test_export_scorm_index_html_embeds_the_max_quiz_score(client, game):
-    """Sans quête/question : max=0 (SCORM 1.2/2004 n'ont alors rien à
+    """Sans déclencheur/question : max=0 (SCORM 1.2/2004 n'ont alors rien à
     barémer, voir static/js/play/offline/scorm-api.js)."""
     resp = client.post(f"/game/{game}/export-scorm")
     import io
@@ -133,20 +135,62 @@ def test_export_scorm_index_html_embeds_the_max_quiz_score(client, game):
         html = zf.read("index.html").decode("utf-8")
     assert "window.FORGE_MAX_QUIZ_SCORE = 0;" in html
 
-    quest = db.create_quest(game, "Une quête")
+    # Les dialogues vivent dans les règles de collision d'un objet de
-    db.set_quest_dialogues(game, quest["id"], {
+    # scène (voir screens/rendering/collision_rules.py::"dialogue".dialogue).
-        "nouvelle": [], "terminee": [],
+    screen_id = screens.create_screen(game, "Scène 1", kind="jeu_2d")
-        "en_cours": [
+    resp = client.post(f"/game/{game}/screens/{screen_id}/scene-objects/add", data={"kind": "personnage"}, follow_redirects=False)
-            {"type": "question", "text": "1+1 ?", "choices": ["1", "2"], "correct_index": 1, "reward_amount": 5},
+    obj_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
-            {"type": "question", "text": "2+2 ?", "choices": ["3", "4"], "correct_index": 1, "reward_amount": 7},
+    rules = [{
-        ],
+        "trigger": "collision",
-    })
+        "action": {
+            "type": "dialogue",
+            "dialogue": {"id": "d_1", "lines": [
+                {"type": "question", "text": "1+1 ?", "choices": ["1", "2"], "correct_index": 1, "reward_amount": 5},
+                {"type": "question", "text": "2+2 ?", "choices": ["3", "4"], "correct_index": 1, "reward_amount": 7},
+            ]},
+        },
+    }]
+    screens.set_scene_object_collision_rules(game, obj_id, screens.sanitize_collision_rules(rules))
     resp = client.post(f"/game/{game}/export-scorm")
     with zipfile.ZipFile(io.BytesIO(resp.data)) as zf:
         html = zf.read("index.html").decode("utf-8")
     assert "window.FORGE_MAX_QUIZ_SCORE = 12;" in html
 
 
+def test_export_scorm_index_html_embeds_the_max_quiz_score_across_a_then_chain(client, game):
+    """Chaînage (demande explicite : "pouvoir modifier un déclencheur pour
+    lui ajouter des actions") : un dialogue -> then variable -> then
+    dialogue — les DEUX dialogues de la chaîne comptent pour le score max,
+    la feuille "variable" au milieu n'en interrompt pas la collecte."""
+    screen_id = screens.create_screen(game, "Scène 1", kind="jeu_2d")
+    resp = client.post(f"/game/{game}/screens/{screen_id}/scene-objects/add", data={"kind": "personnage"}, follow_redirects=False)
+    obj_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
+    rules = [{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue",
+            "dialogue": {"id": "d_1", "lines": [
+                {"type": "question", "text": "1+1 ?", "choices": ["1", "2"], "correct_index": 1, "reward_amount": 5},
+            ]},
+            "then": {
+                "type": "variable", "target_variable": "score", "data_operation": "incrementer", "data_value": "1",
+                "then": {
+                    "type": "dialogue",
+                    "dialogue": {"id": "d_2", "lines": [
+                        {"type": "question", "text": "2+2 ?", "choices": ["3", "4"], "correct_index": 1, "reward_amount": 7},
+                    ]},
+                },
+            },
+        },
+    }]
+    screens.set_scene_object_collision_rules(game, obj_id, screens.sanitize_collision_rules(rules))
+    resp = client.post(f"/game/{game}/export-scorm")
+    import io
+    with zipfile.ZipFile(io.BytesIO(resp.data)) as zf:
+        html = zf.read("index.html").decode("utf-8")
+    assert "window.FORGE_MAX_QUIZ_SCORE = 12;" in html
+
+
 def test_export_scorm_route_is_isolated_like_other_game_routes(anon_client):
     """Même garde d'accès que /game/<slug>/publish (core/auth_guard.py) —
     aucune vérification supplémentaire écrite pour cette route."""

tests/test_global_variables_tab.py

@@ -0,0 +1,74 @@
+"""Onglet "Variables" de l'éditeur de scène (templates/scene_edit.html) —
+CRUD classique (formulaires POST/redirect, voir l'onglet "Événements"
+pour le même patron) sur les fonctions déjà existantes de db/global_vars/
+(list/create/update/delete). Le nom est la clé stable lue par
+static/js/play/conditions.js::readVariableValue — jamais modifiable après
+création (voir db/global_vars/update_global_variable.py)."""
+import re
+
+import db
+
+
+def _create_screen(client, slug, name="Accueil"):
+    resp = client.post(f"/game/{slug}/screens/new", data={"name": name}, follow_redirects=False)
+    return int(re.search(r"/screens/(\d+)/edit", resp.headers["Location"]).group(1))
+
+
+def test_create_global_var_route_persists_and_redirects_to_the_variables_tab(client, game):
+    screen_id = _create_screen(client, game)
+    resp = client.post(
+        f"/game/{game}/variables/new",
+        data={"name": "score_total", "type": "nombre_entier", "default_value": "0", "screen_id": screen_id},
+        follow_redirects=False,
+    )
+    assert resp.status_code == 302
+    assert resp.headers["Location"].endswith(f"/game/{game}/screens/{screen_id}/edit?tab=variables")
+    variables = db.list_global_variables(game)
+    assert [v["name"] for v in variables] == ["score_total"]
+    assert variables[0]["type"] == "nombre_entier"
+    assert variables[0]["value"] == "0"
+
+
+def test_create_global_var_is_idempotent_by_name(client, game):
+    screen_id = _create_screen(client, game)
+    client.post(f"/game/{game}/variables/new", data={"name": "score_total", "screen_id": screen_id})
+    client.post(f"/game/{game}/variables/new", data={"name": "score_total", "screen_id": screen_id})
+    assert len(db.list_global_variables(game)) == 1
+
+
+def test_global_var_edit_route_updates_type_and_value(client, game):
+    screen_id = _create_screen(client, game)
+    client.post(f"/game/{game}/variables/new", data={"name": "score_total", "type": "nombre_entier", "default_value": "0", "screen_id": screen_id})
+    var_id = db.list_global_variables(game)[0]["id"]
+
+    resp = client.post(
+        f"/game/{game}/variables/{var_id}/edit",
+        data={"type": "texte", "value": "beaucoup", "screen_id": screen_id},
+        follow_redirects=False,
+    )
+    assert resp.status_code == 302
+    assert resp.headers["Location"].endswith(f"/game/{game}/screens/{screen_id}/edit?tab=variables")
+    variable = db.list_global_variables(game)[0]
+    assert variable["type"] == "texte"
+    assert variable["value"] == "beaucoup"
+    assert variable["name"] == "score_total"  # le nom ne change jamais
+
+
+def test_global_var_delete_route_removes_it(client, game):
+    screen_id = _create_screen(client, game)
+    client.post(f"/game/{game}/variables/new", data={"name": "score_total", "screen_id": screen_id})
+    var_id = db.list_global_variables(game)[0]["id"]
+
+    resp = client.post(f"/game/{game}/variables/{var_id}/delete", data={"screen_id": screen_id}, follow_redirects=False)
+    assert resp.status_code == 302
+    assert resp.headers["Location"].endswith(f"/game/{game}/screens/{screen_id}/edit?tab=variables")
+    assert db.list_global_variables(game) == []
+
+
+def test_variables_tab_lists_existing_variables_in_the_scene_edit_page(client, game):
+    screen_id = _create_screen(client, game)
+    client.post(f"/game/{game}/variables/new", data={"name": "score_total", "type": "nombre_entier", "default_value": "5", "screen_id": screen_id})
+
+    html = client.get(f"/game/{game}/screens/{screen_id}/edit").get_data(as_text=True)
+    assert "score_total" in html
+    assert 'data-tab="variables"' in html

tests/test_quests.py

@@ -1,264 +0,0 @@
-"""Éditeur de quêtes (voir db/quests/, routes/quests/, onglet "🗺️ Quêtes"
-de l'éditeur de scène 2D, templates/scene_edit.html) : id, titre, objectif, récompense
-(score), statut (nouvelle/en_cours/terminee), résultat (reussi/echoue),
-et un dialogue par statut (3 colonnes — voir static/js/quests/
-quest-editor.js et sanitize_quest_dialogues). Une quête vit pour TOUT le
-jeu, jamais par écran (mêmes conventions que les événements
-personnalisés, db/custom_events/)."""
-import json
-
-import db
-
-
-def _make_game(tmp_game_slug_cleanup, name="pytest_quests"):
-    return tmp_game_slug_cleanup(db.create_game(name))
-
-
-def test_create_quest_has_sensible_defaults(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    assert quest["title"] == "Trouver la clé"
-    assert quest["objectif"] == ""
-    assert quest["recompense_score"] == 0
-    assert quest["status"] == "nouvelle"
-    assert quest["resultat"] is None
-    assert quest["dialogues"] == {}
-
-
-def test_create_quest_falls_back_to_default_title_when_blank(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "   ")
-    assert quest["title"] == "Nouvelle quête"
-
-
-def test_list_quests_orders_most_recent_first(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    first = db.create_quest(slug, "Première")
-    second = db.create_quest(slug, "Seconde")
-    ids = [q["id"] for q in db.list_quests(slug)]
-    assert ids[:2] == [second["id"], first["id"]]
-
-
-def test_update_quest_only_applies_known_valid_fields(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    updated = db.update_quest(slug, quest["id"], {
-        "title": "Trouver la clé dorée", "objectif": "Fouiller le donjon",
-        "recompense_score": 50, "status": "en_cours", "resultat": "reussi",
-        "unknown_field": "ignoré", "id": 999999,
-    })
-    assert updated["title"] == "Trouver la clé dorée"
-    assert updated["objectif"] == "Fouiller le donjon"
-    assert updated["recompense_score"] == 50
-    assert updated["status"] == "en_cours"
-    assert updated["resultat"] == "reussi"
-    assert updated["id"] == quest["id"]  # "id" dans fields est ignoré, jamais modifiable
-
-
-def test_update_quest_rejects_invalid_status_and_blank_title(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    updated = db.update_quest(slug, quest["id"], {"status": "en_pause", "title": "   "})
-    assert updated["status"] == "nouvelle"  # inchangé, valeur invalide ignorée
-    assert updated["title"] == "Trouver la clé"  # inchangé, titre vide ignoré
-
-
-def test_update_quest_returns_none_for_missing_quest(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    assert db.update_quest(slug, 999999, {"title": "x"}) is None
-
-
-def test_delete_quest_removes_it(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    db.delete_quest(slug, quest["id"])
-    assert db.get_quest(slug, quest["id"]) is None
-
-
-def test_sanitize_quest_dialogues_keeps_only_valid_lines_per_status():
-    """speaker est un nom de PERSONNAGE libre (voir "ℹ️ Informations",
-    screens/rendering/scene_object_names.py) — "Le Sorcier" est donc un nom
-    valide comme n'importe quel autre, seul un speaker/texte VIDE ou un
-    élément mal formé est rejeté."""
-    raw = {
-        "nouvelle": [{"speaker": "Le Sorcier", "text": "Bonjour !"}, {"speaker": "Joueur", "text": "  "}],
-        "en_cours": [{"speaker": "  ", "text": "sans nom"}, {"speaker": 42, "text": "nom non textuel"}, "pas un objet"],
-        "terminee": "pas une liste",
-        "statut_inconnu": [{"speaker": "Le Sorcier", "text": "ignoré"}],
-    }
-    cleaned = db.sanitize_quest_dialogues(raw)
-    assert cleaned == {
-        "nouvelle": [{"type": "dialogue", "speaker": "Le Sorcier", "text": "Bonjour !"}],
-        "en_cours": [],
-        "terminee": [],
-    }
-
-
-def test_sanitize_quest_dialogues_accepts_a_valid_question_and_rejects_malformed_ones():
-    """"❓ Question" (voir static/js/quests/quest-editor.js) : une bulle
-    jaune avec plusieurs choix, une seule bonne réponse, une récompense —
-    même chaîne qu'une réplique de dialogue, un autre "type" de ligne."""
-    raw = {
-        "nouvelle": [
-            {"type": "question", "text": "2+2 ?", "choices": ["3", "4", "5"], "correct_index": 1, "reward_type": "score", "reward_amount": 2},
-            {"type": "question", "text": "Une seule option", "choices": ["seule"], "correct_index": 0},  # < 2 choix -> rejetée
-            {"type": "question", "text": "index hors bornes", "choices": ["a", "b"], "correct_index": 5},  # rejetée
-            {"type": "question", "text": "  ", "choices": ["a", "b"], "correct_index": 0},  # texte vide -> rejetée
-            {"type": "question", "text": "type de récompense inconnu", "choices": ["a", "b"], "correct_index": 0, "reward_type": "vie"},
-        ],
-        "en_cours": [], "terminee": [],
-    }
-    cleaned = db.sanitize_quest_dialogues(raw)
-    assert cleaned["nouvelle"] == [
-        {"type": "question", "text": "2+2 ?", "choices": ["3", "4", "5"], "correct_index": 1, "reward_type": "score", "reward_amount": 2},
-        # reward_type invalide -> repli sur le premier type connu ("score"), jamais rejetée pour ça seul
-        {"type": "question", "text": "type de récompense inconnu", "choices": ["a", "b"], "correct_index": 0, "reward_type": "score", "reward_amount": 0},
-    ]
-
-
-def test_set_quest_dialogues_persists_all_three_columns(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    dialogues = {
-        "nouvelle": [
-            {"type": "dialogue", "speaker": "pnj", "text": "Peux-tu m'aider ?"},
-            {"type": "dialogue", "speaker": "joueur", "text": "Bien sûr !"},
-            {"type": "question", "text": "2+2 ?", "choices": ["3", "4"], "correct_index": 1, "reward_type": "score", "reward_amount": 2},
-        ],
-        "en_cours": [{"type": "dialogue", "speaker": "pnj", "text": "Alors, cette clé ?"}],
-        "terminee": [{"type": "dialogue", "speaker": "pnj", "text": "Merci beaucoup !"}],
-    }
-    db.set_quest_dialogues(slug, quest["id"], dialogues)
-    reloaded = db.get_quest(slug, quest["id"])
-    assert reloaded["dialogues"] == dialogues
-
-
-def test_set_quest_dialogues_returns_none_for_missing_quest(tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    assert db.set_quest_dialogues(slug, 999999, {}) is None
-
-
-# ---------- Routes ----------
-
-def test_quest_new_route_creates_and_returns_json(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    resp = client.post(f"/game/{slug}/quests/new", data='{"title": "Nouvelle quête du donjon"}', content_type="application/json")
-    assert resp.status_code == 200
-    quest = resp.get_json()["quest"]
-    assert quest["title"] == "Nouvelle quête du donjon"
-    assert db.get_quest(slug, quest["id"]) is not None
-
-
-def test_quests_list_json_route_returns_all_quests(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    db.create_quest(slug, "A")
-    db.create_quest(slug, "B")
-    resp = client.get(f"/game/{slug}/quests/list.json")
-    titles = {q["title"] for q in resp.get_json()["quests"]}
-    assert titles == {"A", "B"}
-
-
-def test_quest_update_route_persists_fields(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    resp = client.post(f"/game/{slug}/quests/{quest['id']}", data='{"recompense_score": 100, "status": "terminee"}', content_type="application/json")
-    assert resp.get_json()["quest"]["recompense_score"] == 100
-    assert resp.get_json()["quest"]["status"] == "terminee"
-
-
-def test_quest_update_route_404s_for_missing_quest(client, game):
-    resp = client.post(f"/game/{game}/quests/999999", data="{}", content_type="application/json")
-    assert resp.status_code == 404
-
-
-def test_quest_delete_route_removes_it(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    resp = client.post(f"/game/{slug}/quests/{quest['id']}/delete")
-    assert resp.get_json() == {"ok": True}
-    assert db.get_quest(slug, quest["id"]) is None
-
-
-def test_quest_dialogues_route_sanitizes_and_persists(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    resp = client.post(
-        f"/game/{slug}/quests/{quest['id']}/dialogues",
-        data='{"dialogues": {"nouvelle": [{"speaker": "pnj", "text": "Salut !"}], "en_cours": [], "terminee": []}}',
-        content_type="application/json",
-    )
-    assert resp.get_json()["dialogues"]["nouvelle"] == [{"type": "dialogue", "speaker": "pnj", "text": "Salut !"}]
-    assert db.get_quest(slug, quest["id"])["dialogues"]["nouvelle"] == [{"type": "dialogue", "speaker": "pnj", "text": "Salut !"}]
-
-
-def test_quest_dialogues_route_404s_for_missing_quest(client, game):
-    resp = client.post(f"/game/{game}/quests/999999/dialogues", data='{"dialogues": {}}', content_type="application/json")
-    assert resp.status_code == 404
-
-
-def _question_line(reward_amount, correct_index=0):
-    return {
-        "type": "question", "text": "2+2 ?", "choices": ["3", "4"],
-        "correct_index": correct_index, "reward_type": "score", "reward_amount": reward_amount,
-    }
-
-
-def test_quest_dialogues_route_rejects_questions_totaling_more_than_the_reward(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    db.update_quest(slug, quest["id"], {"recompense_score": 5})
-    resp = client.post(
-        f"/game/{slug}/quests/{quest['id']}/dialogues",
-        data=json.dumps({"dialogues": {"nouvelle": [_question_line(3), _question_line(3)], "en_cours": [], "terminee": []}}),
-        content_type="application/json",
-    )
-    assert resp.status_code == 400
-    assert "pts" in resp.get_json()["error"]
-    # Rien n'a été enregistré — la répartition invalide n'est jamais persistée.
-    assert db.get_quest(slug, quest["id"])["dialogues"] == {}
-
-
-def test_quest_dialogues_route_accepts_questions_totaling_exactly_the_reward(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    db.update_quest(slug, quest["id"], {"recompense_score": 5})
-    resp = client.post(
-        f"/game/{slug}/quests/{quest['id']}/dialogues",
-        data=json.dumps({"dialogues": {"nouvelle": [_question_line(2), _question_line(3)], "en_cours": [], "terminee": []}}),
-        content_type="application/json",
-    )
-    assert resp.status_code == 200
-
-
-def test_quest_update_route_rejects_lowering_reward_below_already_allocated_questions(client, tmp_game_slug_cleanup):
-    slug = _make_game(tmp_game_slug_cleanup)
-    quest = db.create_quest(slug, "Trouver la clé")
-    db.update_quest(slug, quest["id"], {"recompense_score": 10})
-    db.set_quest_dialogues(slug, quest["id"], {"nouvelle": [_question_line(6)], "en_cours": [], "terminee": []})
-    resp = client.post(
-        f"/game/{slug}/quests/{quest['id']}",
-        data=json.dumps({"recompense_score": 3}),
-        content_type="application/json",
-    )
-    assert resp.status_code == 400
-    assert "pts" in resp.get_json()["error"]
-    assert db.get_quest(slug, quest["id"])["recompense_score"] == 10  # inchangé
-
-
-def test_sanitize_quest_dialogues_caps_choices_at_four():
-    raw = {
-        "nouvelle": [{"type": "question", "text": "Q", "choices": ["a", "b", "c", "d", "e"], "correct_index": 4, "reward_type": "score", "reward_amount": 1}],
-        "en_cours": [], "terminee": [],
-    }
-    cleaned = db.sanitize_quest_dialogues(raw)
-    # Coupé à 4 choix -> l'index 4 (qui pointait sur le 5e, retiré) sort des bornes -> ligne rejetée.
-    assert cleaned["nouvelle"] == []
-
-
-def test_quest_dialogues_total_reward_sums_questions_across_all_statuses():
-    dialogues = {
-        "nouvelle": [_question_line(2)],
-        "en_cours": [_question_line(3), {"type": "dialogue", "speaker": "pnj", "text": "x"}],
-        "terminee": [],
-    }
-    assert db.quest_dialogues_total_reward(dialogues) == 5

tests/test_scene_collision_rule_objects.py

@@ -1,9 +1,12 @@
-"""Liste "🧩 Collision" à jour en AJAX (voir routes/scenes/
+"""screens.build_collision_rule_objects (voir screens/scenes/
-scene_collision_rule_objects.py, refreshCollisionRuleObjects() dans
+build_collision_rule_objects.py) : la liste d'objets éligibles à un
-static/js/scenes/scene-editor.js) : appelée après ajout/suppression d'un
+déclencheur de collision, réutilisée par le listage de TOUS les
-objet de scène ou changement de rôle/nom, pour ne jamais recharger la page
+déclencheurs du jeu (screens/rendering/trigger_graph.py, voir
-alors que cette liste doit refléter le changement (un objet apparaît/
+tests/test_triggers.py) — un objet apparaît/disparaît selon son
-disparaît selon son rôle, ou change de libellé affiché)."""
+rôle, ou change de libellé affiché selon son nom. L'ancien endpoint AJAX
+dédié (routes/scenes/scene_collision_rule_objects.py) a été retiré avec
+l'onglet "🧩 Collision" séparé — ce fichier teste directement les
+fonctions Python plutôt qu'une route HTTP désormais inexistante."""
 import screens
 
 
@@ -21,16 +24,17 @@ def _add_ajax(client, slug, screen_id, **data):
     ).get_json()
 
 
-def _list(client, slug, screen_id):
+def _list(slug, screen_id):
-    resp = client.get(f"/game/{slug}/screens/{screen_id}/collision-rule-objects")
+    objects = screens.list_scene_objects(slug, screen_id)
-    assert resp.status_code == 200
+    for o in objects:
-    return resp.get_json()
+        o["rendered_html"] = screens.render_scene_object(o)
+    return screens.build_collision_rule_objects(objects)
 
 
 def test_freshly_added_personnage_is_pnj_in_the_list(client, tmp_game_slug_cleanup):
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
     obj_id = _add_ajax(client, slug, screen_id, kind="personnage")["id"]
-    entries = _list(client, slug, screen_id)
+    entries = _list(slug, screen_id)
     assert len(entries) == 1
     assert entries[0]["id"] == obj_id
     assert entries[0]["role"] == "pnj"
@@ -40,7 +44,7 @@ def test_role_change_to_joueur_removes_it_from_the_list(client, tmp_game_slug_cl
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
     obj_id = _add_ajax(client, slug, screen_id, kind="personnage")["id"]
     client.post(f"/game/{slug}/scene-objects/{obj_id}/role", data='{"role": "joueur"}', content_type="application/json")
-    assert _list(client, slug, screen_id) == []
+    assert _list(slug, screen_id) == []
 
 
 def test_role_change_back_to_pnj_readds_it_to_the_list(client, tmp_game_slug_cleanup):
@@ -48,7 +52,7 @@ def test_role_change_back_to_pnj_readds_it_to_the_list(client, tmp_game_slug_cle
     obj_id = _add_ajax(client, slug, screen_id, kind="personnage")["id"]
     client.post(f"/game/{slug}/scene-objects/{obj_id}/role", data='{"role": "joueur"}', content_type="application/json")
     client.post(f"/game/{slug}/scene-objects/{obj_id}/role", data='{"role": "ennemie"}', content_type="application/json")
-    entries = _list(client, slug, screen_id)
+    entries = _list(slug, screen_id)
     assert len(entries) == 1
     assert entries[0]["role"] == "ennemie"
 
@@ -57,7 +61,7 @@ def test_name_change_is_reflected_in_the_list(client, tmp_game_slug_cleanup):
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
     obj_id = _add_ajax(client, slug, screen_id, kind="personnage")["id"]
     client.post(f"/game/{slug}/scene-objects/{obj_id}/name", data='{"name": "Le Sorcier"}', content_type="application/json")
-    entries = _list(client, slug, screen_id)
+    entries = _list(slug, screen_id)
     assert entries[0]["name"] == "Le Sorcier"
 
 
@@ -65,11 +69,11 @@ def test_deleted_object_is_removed_from_the_list(client, tmp_game_slug_cleanup):
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
     obj_id = _add_ajax(client, slug, screen_id, kind="personnage")["id"]
     client.post(f"/game/{slug}/scene-objects/{obj_id}/delete", headers={"X-Requested-With": "fetch"})
-    assert _list(client, slug, screen_id) == []
+    assert _list(slug, screen_id) == []
 
 
 def test_decor_has_no_role(client, tmp_game_slug_cleanup):
     slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
     _add_ajax(client, slug, screen_id, kind="decor")
-    entries = _list(client, slug, screen_id)
+    entries = _list(slug, screen_id)
     assert entries[0]["role"] is None

tests/test_triggers.py

@@ -0,0 +1,356 @@
+"""Déclencheurs de collision — onglet "Déclencheurs" (voir
+screens/rendering/trigger_graph.py, routes/triggers/triggers.py) : TOUS
+les déclencheurs du jeu, plus aucune notion de quête pour les regrouper —
+un créateur peut faire un simple quiz sans jamais poser de personnage.
+Chaque occurrence de "Déclencher ce dialogue" porte son propre dialogue
+({id, lines}, voir screens/rendering/collision_rules.py::"dialogue".dialogue),
+édité en ligne (voir routes POST .../triggers/<object_id>/dialogue
+ci-dessous). Source de données UNIQUE avec l'éditeur de collision : toute
+règle ajoutée/retirée/modifiée ici doit rester visible/cohérente via
+screens.resolve_collision_rules directement sur l'objet."""
+import re
+
+import screens
+from tests.test_auth import anon_client  # noqa: F401
+
+
+def _create_jeu2d_game(client, tmp_game_slug_cleanup, name="pytest_triggers"):
+    resp = client.post("/games/new", data={"name": name}, follow_redirects=False)
+    slug = tmp_game_slug_cleanup(resp.headers["Location"].rstrip("/").split("/")[-1])
+    screen_id = screens.create_screen(slug, "Scène 1", kind="jeu_2d")
+    return slug, screen_id
+
+
+def _add_personnage(client, slug, screen_id, role=None):
+    resp = client.post(f"/game/{slug}/screens/{screen_id}/scene-objects/add", data={"kind": "personnage"}, follow_redirects=False)
+    assert resp.status_code == 302, resp.data
+    obj_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
+    if role:
+        client.post(f"/game/{slug}/scene-objects/{obj_id}/role", data=f'{{"role": "{role}"}}', content_type="application/json")
+    return obj_id
+
+
+def _set_rules(slug, object_id, rules):
+    """Pose des règles directement (sans passer par une route HTTP —
+    l'ancienne route de sauvegarde, routes/scenes/scene_object_collision_rules.py,
+    a été retirée avec l'éditeur de collision séparé) pour préparer un
+    scénario de test."""
+    screens.set_scene_object_collision_rules(slug, object_id, screens.sanitize_collision_rules(rules))
+
+
+def test_mark_completed_is_kept_when_true(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, obj_id, [{"trigger": "collision", "action": {"type": "dialogue", "mark_completed": True}}])
+    obj = screens.get_scene_object(slug, obj_id)
+    rules = screens.resolve_collision_rules(obj)
+    assert rules[0]["action"]["mark_completed"] is True
+
+
+def test_mark_completed_is_dropped_when_false_or_absent(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, obj_id, [{"trigger": "collision", "action": {"type": "dialogue", "mark_completed": False}}])
+    obj = screens.get_scene_object(slug, obj_id)
+    rules = screens.resolve_collision_rules(obj)
+    assert "mark_completed" not in rules[0]["action"]
+
+
+def test_list_all_triggers_finds_direct_and_nested_rules(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    direct_id = _add_personnage(client, slug, screen_id, role="pnj")
+    nested_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, direct_id, [{"trigger": "collision", "action": {"type": "dialogue"}}])
+    _set_rules(slug, nested_id, [{"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "dialogue"}}}])
+
+    result = screens.list_all_triggers(slug)
+    ids = [o["object_id"] for o in result]
+    assert direct_id in ids
+    assert nested_id in ids
+    direct_entry = next(o for o in result if o["object_id"] == direct_id)
+    assert direct_entry["has_interagir"] is False
+    nested_entry = next(o for o in result if o["object_id"] == nested_id)
+    assert nested_entry["has_interagir"] is True
+
+
+def test_list_all_triggers_surfaces_both_branches_of_a_condition_independently(client, tmp_game_slug_cleanup):
+    """Losange à embranchement (maquette validée, lecture verticale) :
+    Vrai ET Faux peuvent chacun déclencher LEUR PROPRE dialogue,
+    indépendamment l'un de l'autre — plus de "branche qui mène à telle
+    quête" à choisir (voir static/js/triggers/trigger-editor.js::
+    triggerConditionColumnHtml pour son affichage)."""
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "inventaire_cle", "operateur": "superieur", "valeur": "0",
+            "si_vrai": {"type": "dialogue", "dialogue": {"id": "d_vrai", "lines": []}},
+            "si_faux": {"type": "dialogue", "dialogue": {"id": "d_faux", "lines": []}},
+        },
+    }])
+
+    result = screens.list_all_triggers(slug)
+    entry = next(o for o in result if o["object_id"] == obj_id)
+    assert entry["condition"]["variable"] == "inventaire_cle"
+    assert entry["condition"]["si_vrai"] == {"chain": [{"type": "dialogue", "dialogue": {"id": "d_vrai", "lines": []}}]}
+    assert entry["condition"]["si_faux"] == {"chain": [{"type": "dialogue", "dialogue": {"id": "d_faux", "lines": []}}]}
+
+
+def test_list_all_triggers_leaves_a_branch_none_when_it_does_nothing(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "score", "operateur": "egal", "valeur": "0",
+            "si_vrai": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}}, "si_faux": None,
+        },
+    }])
+
+    result = screens.list_all_triggers(slug)
+    entry = next(o for o in result if o["object_id"] == obj_id)
+    assert entry["condition"]["si_faux"] is None
+
+
+def test_triggers_delete_removes_all_rules_on_the_object(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+    _set_rules(slug, obj_id, [{"trigger": "collision", "action": {"type": "dialogue"}}])
+
+    resp = client.delete(f"/game/{slug}/triggers/{obj_id}")
+    assert resp.status_code == 200
+    obj = screens.get_scene_object(slug, obj_id)
+    assert screens.resolve_collision_rules(obj) == []
+
+
+def test_triggers_route_add_then_get_then_delete(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    resp = client.post(
+        f"/game/{slug}/triggers",
+        json={
+            "object_id": obj_id,
+            "rule": {"trigger": "collision", "action": {"type": "interagir", "sub_action": {"type": "dialogue", "mark_completed": True}}},
+        },
+    )
+    assert resp.status_code == 200
+
+    # Même donnée, visible directement via la couche collision (source unique).
+    obj = screens.get_scene_object(slug, obj_id)
+    rules = screens.resolve_collision_rules(obj)
+    assert rules == [{
+        "trigger": "collision",
+        "action": {"type": "interagir", "sub_action": {"type": "dialogue", "mark_completed": True}},
+    }]
+
+    resp = client.get(f"/game/{slug}/triggers")
+    result = resp.get_json()
+    assert [o["object_id"] for o in result] == [obj_id]
+    assert result[0]["has_interagir"] is True
+
+    resp = client.delete(f"/game/{slug}/triggers/{obj_id}")
+    assert resp.status_code == 200
+    obj = screens.get_scene_object(slug, obj_id)
+    assert screens.resolve_collision_rules(obj) == []
+
+
+def test_list_all_triggers_surfaces_the_dialogue(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": [{"speaker": "pnj", "text": "Salut !"}]}},
+    }])
+    result = screens.list_all_triggers(slug)
+    assert result[0]["chain"] == [{"type": "dialogue", "dialogue": {"id": "d_1", "lines": [{"type": "dialogue", "speaker": "pnj", "text": "Salut !"}]}}]
+
+
+def test_list_all_triggers_surfaces_a_chain_of_actions(client, tmp_game_slug_cleanup):
+    """Chaînage (demande explicite : "pouvoir modifier un déclencheur pour
+    lui ajouter des actions") : dialogue -> then variable, la chaîne
+    ENTIÈRE est aplatie dans l'ordre d'exécution."""
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue", "dialogue": {"id": "d_1", "lines": []},
+            "then": {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"},
+        },
+    }])
+    result = screens.list_all_triggers(slug)
+    assert result[0]["chain"] == [
+        {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+        {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"},
+    ]
+
+
+def test_list_completable_dialogue_ids_collects_mark_completed_dialogues_everywhere(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    direct_id = _add_personnage(client, slug, screen_id, role="pnj")
+    cond_id = _add_personnage(client, slug, screen_id, role="pnj")
+    other_id = _add_personnage(client, slug, screen_id, role="pnj")
+
+    _set_rules(slug, direct_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_direct", "lines": []}, "mark_completed": True},
+    }])
+    _set_rules(slug, cond_id, [{
+        "trigger": "collision",
+        "action": {
+            "type": "condition", "variable": "score", "operateur": "egal", "valeur": "1",
+            "si_vrai": {"type": "dialogue", "dialogue": {"id": "d_cond", "lines": []}, "mark_completed": True},
+            "si_faux": None,
+        },
+    }])
+    _set_rules(slug, other_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_not_completing", "lines": []}},
+    }])
+
+    ids = screens.list_completable_dialogue_ids(slug)
+    assert set(ids) == {"d_direct", "d_cond"}
+
+
+def test_trigger_dialogue_update_route_persists_the_new_lines(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+
+    resp = client.post(
+        f"/game/{slug}/triggers/{obj_id}/dialogue",
+        json={"dialogue_id": "d_1", "lines": [{"speaker": "pnj", "text": "Trouvé !"}]},
+    )
+    assert resp.status_code == 200
+    obj = screens.get_scene_object(slug, obj_id)
+    rules = screens.resolve_collision_rules(obj)
+    assert rules[0]["action"]["dialogue"]["lines"] == [{"type": "dialogue", "speaker": "pnj", "text": "Trouvé !"}]
+
+
+def test_trigger_dialogue_update_route_404s_for_an_unknown_dialogue_id(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+
+    resp = client.post(
+        f"/game/{slug}/triggers/{obj_id}/dialogue",
+        json={"dialogue_id": "d_absent", "lines": [{"speaker": "pnj", "text": "x"}]},
+    )
+    assert resp.status_code == 404
+
+
+def test_trigger_dialogue_update_route_404s_for_an_unknown_object(client, game):
+    resp = client.post(
+        f"/game/{game}/triggers/999999/dialogue",
+        json={"dialogue_id": "d_1", "lines": []},
+    )
+    assert resp.status_code == 404
+
+
+def test_trigger_append_action_route_attaches_a_then_at_the_end_of_the_chain(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+
+    resp = client.post(
+        f"/game/{slug}/triggers/{obj_id}/append-action",
+        json={"after_id": "d_1", "action": {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"}},
+    )
+    assert resp.status_code == 200
+    obj = screens.get_scene_object(slug, obj_id)
+    rules = screens.resolve_collision_rules(obj)
+    assert rules[0]["action"]["then"] == {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"}
+
+
+def test_trigger_append_action_route_404s_for_an_unknown_after_id(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {"type": "dialogue", "dialogue": {"id": "d_1", "lines": []}},
+    }])
+
+    resp = client.post(
+        f"/game/{slug}/triggers/{obj_id}/append-action",
+        json={"after_id": "d_absent", "action": {"type": "variable", "target_variable": "score", "data_operation": "incrementer"}},
+    )
+    assert resp.status_code == 404
+
+
+def test_trigger_append_action_route_404s_when_the_leaf_already_has_a_then(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    obj_id = _add_personnage(client, slug, screen_id, role="pnj")
+    _set_rules(slug, obj_id, [{
+        "trigger": "collision",
+        "action": {
+            "type": "dialogue", "dialogue": {"id": "d_1", "lines": []},
+            "then": {"type": "variable", "id": "v_1", "target_variable": "score", "data_operation": "incrementer", "data_value": "1"},
+        },
+    }])
+
+    resp = client.post(
+        f"/game/{slug}/triggers/{obj_id}/append-action",
+        json={"after_id": "d_1", "action": {"type": "variable", "target_variable": "vies", "data_operation": "decrementer"}},
+    )
+    assert resp.status_code == 404
+    obj = screens.get_scene_object(slug, obj_id)
+    assert screens.resolve_collision_rules(obj)[0]["action"]["then"]["target_variable"] == "score"  # inchangé
+
+
+def test_trigger_append_action_route_404s_for_an_unknown_object(client, game):
+    resp = client.post(f"/game/{game}/triggers/999999/append-action", json={"after_id": "d_1", "action": {}})
+    assert resp.status_code == 404
+
+
+def test_objects_catalog_lists_eligible_objects_with_thumbnails(client, tmp_game_slug_cleanup):
+    slug, screen_id = _create_jeu2d_game(client, tmp_game_slug_cleanup)
+    _add_personnage(client, slug, screen_id, role="pnj")
+
+    resp = client.get(f"/game/{slug}/triggers/objects-catalog")
+    assert resp.status_code == 200
+    catalog = resp.get_json()
+    assert len(catalog) == 1
+    assert catalog[0]["thumbnail_html"]
+
+
+def test_triggers_route_is_isolated_like_other_game_routes(anon_client):
+    """Même garde d'accès que /game/<slug>/publish (core/auth_guard.py) —
+    aucune vérification supplémentaire écrite pour ces routes."""
+    from tests.test_auth import _register, _confirm_2fa, _complete_onboarding, _cleanup_project
+
+    _register(anon_client, "triggersisolation@example.com")
+    _confirm_2fa(anon_client)
+    _complete_onboarding(anon_client)
+    try:
+        resp = anon_client.get("/game/un-projet-qui-nest-pas-le-sien/triggers")
+        assert resp.status_code == 403
+        resp = anon_client.post("/game/un-projet-qui-nest-pas-le-sien/triggers", json={})
+        assert resp.status_code == 403
+        resp = anon_client.delete("/game/un-projet-qui-nest-pas-le-sien/triggers/1")
+        assert resp.status_code == 403
+        resp = anon_client.post("/game/un-projet-qui-nest-pas-le-sien/triggers/1/dialogue", json={})
+        assert resp.status_code == 403
+        resp = anon_client.post("/game/un-projet-qui-nest-pas-le-sien/triggers/1/append-action", json={})
+        assert resp.status_code == 403
+        resp = anon_client.get("/game/un-projet-qui-nest-pas-le-sien/triggers/objects-catalog")
+        assert resp.status_code == 403
+    finally:
+        _cleanup_project("triggersisolation@example.com")