Ajoute les événements personnalisés (backend) : déclencher/écouter

Première moitié de la fonctionnalité "événements" (NEED_ACTION et
autres) : une entité game-wide (nom, description, "a un paramètre
élément" oui/non), déclenchable comme nouvelle action du graphe de
logique depuis n'importe quelle scène/modèle, et écoutable comme
nouveau type de déclencheur depuis n'importe quel autre. L'UI (nouvel
onglet "Événements" dans screen_edit.html, formulaires de nœud, exécution
côté client dans play.html) suit dans un commit séparé.

- db/custom_events/ (calqué sur db/global_vars/) : CRUD de la table
  _custom_events (nom unique, description, has_element_param).
  create_custom_event est idempotent par nom (même convention que
  create_global_variable) — sans risque en cas de double soumission.
- screens/flow/ : 3 nouvelles colonnes sur _flow_nodes
  (trigger_custom_event_id/target_custom_event_id : quel événement un
  nœud écoute/déclenche ; target_element_from_event : indicateur
  réutilisable par n'importe quel nœud Action utilisant déjà
  target_element_id, pour résoudre "l'élément transmis par l'événement
  en cours" au lieu d'une cible fixe — contourne la contrainte de clé
  étrangère de target_element_id, qui empêche d'y stocker un sentinel
  comme EVENT_ROW_ID directement). Nouveau trigger_event "evenement" et
  action_type "declencher_evenement".
- screens/custom_events/ (PAS dans db/, même séparation que
  screens/elements/delete_element.py) : delete_custom_event, la SEULE
  suppression d'entité game-wide du moteur à vraiment cascader (demande
  explicite) — supprime tous les nœuds/arêtes qui référencent
  l'événement, sur TOUTES les scènes ET tous les modèles à la fois
  (aucun filtre screen_id nécessaire : un modèle est un écran caché,
  même table _flow_nodes). list_custom_event_usages : où un événement
  est écouté/déclenché, pour l'onglet Événements à venir.
- routes/custom_events/ : CRUD monté sous /game/<slug>/events/...,
  redirige vers l'éditeur de scène/modèle d'origine (screen_id transmis
  par le formulaire) avec l'onglet "events" à ouvrir.

tests/test_custom_events.py (nouveau) : idempotence à la création,
usages détectés sur deux écrans différents, suppression qui retire bien
les DEUX nœuds (un sur une vraie scène, un sur un modèle/écran caché)
en une seule opération, sans toucher aux écrans eux-mêmes. 207 tests au
total.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

db/__init__.py

@@ -61,6 +61,11 @@ from .global_vars.update_global_variable import update_global_variable
 from .global_vars.delete_global_variable import delete_global_variable
 from .global_vars.delete_global_variable_by_id import delete_global_variable_by_id
 
+from .custom_events.list_custom_events import list_custom_events
+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
+
 __all__ = [
     "PROJECTS_DIR", "FIELD_TYPES", "GLOBAL_VARIABLE_TYPES",
     "slugify", "table_name_for", "game_dir", "db_path", "connect",
@@ -73,4 +78,5 @@ __all__ = [
     "list_global_variables", "get_global_variable", "create_global_variable",
     "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",
 ]

db/custom_events/create_custom_event.py

@@ -0,0 +1,26 @@
+from ..connection import connect
+from .ensure_custom_events_schema import ensure_custom_events_schema
+
+
+def create_custom_event(slug, name, description="", has_element_param=False):
+    """Idempotent par nom (même convention que create_global_variable.py) :
+    si le nom existe déjà, ne touche à rien et renvoie simplement son id
+    existant plutôt que de lever une erreur — sans risque en cas de
+    double clic/soumission depuis l'onglet Événements (screen_edit.html)."""
+    name = (name or "").strip()
+    if not name:
+        return None
+    ensure_custom_events_schema(slug)
+    conn = connect(slug)
+    existing = conn.execute("SELECT id FROM _custom_events WHERE name = ?", (name,)).fetchone()
+    if existing:
+        conn.close()
+        return existing["id"]
+    conn.execute(
+        "INSERT INTO _custom_events (name, description, has_element_param) VALUES (?, ?, ?)",
+        (name, (description or "").strip(), 1 if has_element_param else 0),
+    )
+    new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
+    conn.commit()
+    conn.close()
+    return new_id

db/custom_events/ensure_custom_events_schema.py

@@ -0,0 +1,25 @@
+from ..connection import connect
+
+
+def ensure_custom_events_schema(slug):
+    """Migration légère (même principe que ensure_global_vars_schema.py) :
+    crée _custom_events si absente. Un événement personnalisé vit pour
+    TOUT le jeu (pas par écran, pas par modèle) : "name" est donc UNIQUE —
+    c'est par ce nom qu'on le désigne dans l'interface, même si les nœuds
+    du graphe le référencent par id technique (voir
+    screens/flow/ensure_flow_schema.py, trigger_custom_event_id/
+    target_custom_event_id)."""
+    conn = connect(slug)
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS _custom_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE,
+            description TEXT,
+            has_element_param INTEGER NOT NULL DEFAULT 0,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+        """
+    )
+    conn.commit()
+    conn.close()

db/custom_events/get_custom_event.py

@@ -0,0 +1,12 @@
+from ..connection import connect
+from .ensure_custom_events_schema import ensure_custom_events_schema
+
+
+def get_custom_event(slug, event_id):
+    if not event_id:
+        return None
+    ensure_custom_events_schema(slug)
+    conn = connect(slug)
+    row = conn.execute("SELECT * FROM _custom_events WHERE id = ?", (event_id,)).fetchone()
+    conn.close()
+    return dict(row) if row else None

db/custom_events/list_custom_events.py

@@ -0,0 +1,10 @@
+from ..connection import connect
+from .ensure_custom_events_schema import ensure_custom_events_schema
+
+
+def list_custom_events(slug):
+    ensure_custom_events_schema(slug)
+    conn = connect(slug)
+    rows = conn.execute("SELECT * FROM _custom_events ORDER BY name").fetchall()
+    conn.close()
+    return [dict(r) for r in rows]

db/custom_events/update_custom_event.py

@@ -0,0 +1,19 @@
+from ..connection import connect
+from .ensure_custom_events_schema import ensure_custom_events_schema
+
+
+def update_custom_event(slug, event_id, description="", has_element_param=False):
+    """Le NOM reste volontairement immuable après création — comme une
+    variable globale (voir update_global_variable.py) : c'est par ce nom
+    qu'on désigne l'événement dans l'interface, mais surtout par son ID
+    TECHNIQUE que les nœuds du graphe le référencent
+    (trigger_custom_event_id/target_custom_event_id) — le renommer ne
+    casserait donc rien niveau logique."""
+    ensure_custom_events_schema(slug)
+    conn = connect(slug)
+    conn.execute(
+        "UPDATE _custom_events SET description = ?, has_element_param = ? WHERE id = ?",
+        ((description or "").strip(), 1 if has_element_param else 0, event_id),
+    )
+    conn.commit()
+    conn.close()

routes/__init__.py

@@ -1 +1 @@
-from . import auth, games, objects, screens, elements, legacy_actions, flow, element_types, uploads, play, animations, global_vars, publish
+from . import auth, games, objects, screens, elements, legacy_actions, flow, element_types, uploads, play, animations, global_vars, publish, custom_events

routes/custom_events/__init__.py

@@ -0,0 +1 @@
+from . import custom_event_new, custom_event_edit, custom_event_delete

routes/custom_events/custom_event_delete.py

@@ -0,0 +1,18 @@
+from flask import request, redirect, url_for
+
+import screens
+
+from core.flask_app import app
+
+
+@app.route("/game/<slug>/events/<int:event_id>/delete", methods=["POST"])
+def custom_event_delete(slug, event_id):
+    """Supprime aussi TOUS les nœuds Déclencheur/Action qui référencent cet
+    événement, sur toutes les scènes et tous les modèles (voir
+    screens/custom_events/delete_custom_event.py) — seule suppression
+    d'entité game-wide du moteur à vraiment cascader, sur demande
+    explicite (une variable globale ou une définition d'objet supprimée,
+    elles, laissent des références pendantes tolérées ailleurs)."""
+    screen_id = request.form.get("screen_id", type=int)
+    screens.delete_custom_event(slug, event_id)
+    return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="events"))

routes/custom_events/custom_event_edit.py

@@ -0,0 +1,14 @@
+from flask import request, redirect, url_for
+
+import db
+
+from core.flask_app import app
+
+
+@app.route("/game/<slug>/events/<int:event_id>/edit", methods=["POST"])
+def custom_event_edit(slug, event_id):
+    description = request.form.get("description") or ""
+    has_element_param = request.form.get("has_element_param") == "on"
+    screen_id = request.form.get("screen_id", type=int)
+    db.update_custom_event(slug, event_id, description, has_element_param)
+    return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="events"))

routes/custom_events/custom_event_new.py

@@ -0,0 +1,21 @@
+from flask import request, redirect, url_for
+
+import db
+
+from core.flask_app import app
+
+
+@app.route("/game/<slug>/events/new", methods=["POST"])
+def custom_event_new(slug):
+    """Depuis l'onglet Événements de l'éditeur de scène/modèle
+    (screen_edit.html) — idempotent par nom (voir db.create_custom_event),
+    sans risque en cas de double soumission. screen_id (l'écran/modèle
+    depuis lequel on a créé l'événement) sert uniquement à revenir sur le
+    bon écran ensuite, jamais stocké sur l'événement lui-même (game-wide)."""
+    name = (request.form.get("name") or "").strip()
+    description = request.form.get("description") or ""
+    has_element_param = request.form.get("has_element_param") == "on"
+    screen_id = request.form.get("screen_id", type=int)
+    if name:
+        db.create_custom_event(slug, name, description, has_element_param)
+    return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="events"))

screens/__init__.py

@@ -55,7 +55,9 @@ from .labels.element_action_properties import (
 from .labels.element_visibility import ELEMENT_VISIBILITY_VALUES, ELEMENT_VISIBILITY_LABELS
 from .labels.data_operations import DATA_OPERATIONS, DATA_OPERATION_LABELS
 
-from .flow.constants import TRIGGER_EVENTS, CONDITION_OPERATORS, CONDITION_OPERATOR_LABELS, CLICKED_ROW_ID
+from .flow.constants import (
+    TRIGGER_EVENTS, CONDITION_OPERATORS, CONDITION_OPERATOR_LABELS, CLICKED_ROW_ID, EVENT_ROW_ID,
+)
 
 from .rendering.render_element_html import render_element_html
 from .rendering.trigger_for import _trigger_for
@@ -117,4 +119,7 @@ from .animations.update_animation_clip import update_animation_clip
 from .animations.delete_animation_clip import delete_animation_clip
 from .animations.animate_css_catalog import ANIMATE_CSS_CATALOG, ANIMATE_CSS_LABELS
 
+from .custom_events.list_custom_event_usages import list_custom_event_usages
+from .custom_events.delete_custom_event import delete_custom_event
+
 from .payload.full_game_payload import full_game_payload

screens/custom_events/__init__.py

@@ -0,0 +1,9 @@
+"""Tout ce qui touche à la fois _custom_events (db/custom_events/) ET
+_flow_nodes/_flow_edges (screens/flow/) — jamais dans db/custom_events/,
+pour la même raison que screens/elements/delete_element.py n'est pas
+dans db/ : ce sont deux domaines différents (une entité game-wide, des
+nœuds de graphe), le nettoyage croisé vit dans screens/, pas db/."""
+from .list_custom_event_usages import list_custom_event_usages
+from .delete_custom_event import delete_custom_event
+
+__all__ = ["list_custom_event_usages", "delete_custom_event"]

screens/custom_events/delete_custom_event.py

@@ -0,0 +1,30 @@
+import db
+from ..flow.ensure_flow_schema import ensure_flow_schema
+
+
+def delete_custom_event(slug, event_id):
+    """Seule suppression d'entité game-wide du moteur qui cascade
+    RÉELLEMENT (demande explicite) : une variable globale ou une
+    définition d'objet supprimée laisse des références pendantes
+    tolérées ailleurs (voir db/global_vars/, db/definitions/) — un
+    événement, lui, doit emporter avec lui TOUS ses écouteurs (nœuds
+    Déclencheur, trigger_custom_event_id) et déclencheurs (nœuds Action,
+    target_custom_event_id), sur TOUS les écrans ET modèles à la fois
+    (aucun filtre screen_id, comme screens/elements/delete_element.py —
+    un modèle est un écran caché, même table _flow_nodes)."""
+    ensure_flow_schema(slug)
+    conn = db.connect(slug)
+    conn.execute(
+        """DELETE FROM _flow_edges WHERE from_node_id IN
+               (SELECT id FROM _flow_nodes WHERE trigger_custom_event_id = ? OR target_custom_event_id = ?)
+            OR to_node_id IN
+               (SELECT id FROM _flow_nodes WHERE trigger_custom_event_id = ? OR target_custom_event_id = ?)""",
+        (event_id, event_id, event_id, event_id),
+    )
+    conn.execute(
+        "DELETE FROM _flow_nodes WHERE trigger_custom_event_id = ? OR target_custom_event_id = ?",
+        (event_id, event_id),
+    )
+    conn.execute("DELETE FROM _custom_events WHERE id = ?", (event_id,))
+    conn.commit()
+    conn.close()

screens/custom_events/list_custom_event_usages.py

@@ -0,0 +1,37 @@
+import db
+from ..flow.ensure_flow_schema import ensure_flow_schema
+
+
+def list_custom_event_usages(slug):
+    """Pour CHAQUE événement, où est-il écouté ("ecoute", nœud Déclencheur)
+    et déclenché ("declenche", nœud Action) — une seule requête plutôt
+    qu'une par événement, pour l'onglet Événements (screen_edit.html) qui
+    les affiche tous à la fois. Aucun filtre screen_id : couvre aussi bien
+    les écrans que les modèles (un modèle est un écran caché, voir
+    screens/element_types/create_element_type.py), exactement comme la
+    suppression en cascade (delete_custom_event.py).
+
+    Renvoie {event_id: [{"screen_id", "screen_name", "is_template", "role"}, ...]}."""
+    ensure_flow_schema(slug)
+    conn = db.connect(slug)
+    rows = conn.execute(
+        """
+        SELECT DISTINCT n.id AS node_id, s.id AS screen_id, s.name AS screen_name, s.is_template AS is_template,
+               CASE WHEN n.trigger_custom_event_id IS NOT NULL THEN n.trigger_custom_event_id
+                    ELSE n.target_custom_event_id END AS event_id,
+               CASE WHEN n.trigger_custom_event_id IS NOT NULL THEN 'ecoute'
+                    ELSE 'declenche' END AS role
+        FROM _flow_nodes n
+        JOIN _screens s ON s.id = n.screen_id
+        WHERE n.trigger_custom_event_id IS NOT NULL OR n.target_custom_event_id IS NOT NULL
+        ORDER BY s.name
+        """
+    ).fetchall()
+    conn.close()
+    usages = {}
+    for row in rows:
+        usages.setdefault(row["event_id"], []).append({
+            "screen_id": row["screen_id"], "screen_name": row["screen_name"],
+            "is_template": bool(row["is_template"]), "role": row["role"],
+        })
+    return usages

screens/flow/constants.py

@@ -21,6 +21,16 @@
 # AUTOINCREMENT SQLite).
 CLICKED_ROW_ID = -1
 
+# Même principe que CLICKED_ROW_ID, pour un second contexte dynamique :
+# "la ligne de Répéteur transmise par l'événement personnalisé en cours
+# d'exécution" (voir screens/custom_events/, nœud Déclencheur
+# trigger_event="evenement") — stockable directement dans target_row_id
+# (déjà sans contrainte de clé étrangère, voir ensure_flow_schema.py) au
+# même titre que CLICKED_ROW_ID, résolu côté client (templates/play.html)
+# via window.lastEventParams.row_id au lieu de window.lastClickedRowId.
+# Valeur distincte de CLICKED_ROW_ID pour ne jamais les confondre.
+EVENT_ROW_ID = -2
+
 TRIGGER_EVENTS = [
     ("clic", "Au clic"),
     ("soumission", "À la soumission"),
@@ -42,6 +52,14 @@ TRIGGER_EVENTS = [
     # cacher/montrer un élément selon l'état de la partie SANS qu'un clic
     # explicite soit nécessaire pour le réévaluer.
     ("affichage", "À l'affichage de l'écran"),
+    # Écoute un événement personnalisé (voir screens/custom_events/),
+    # déclenché depuis N'IMPORTE QUEL autre graphe (une autre scène, un
+    # autre modèle) via l'action "declencher_evenement" — ni élément ni
+    # écran précis : trigger_custom_event_id (quel événement) est le seul
+    # réglage propre à ce nœud, retrouvé par un scan global de
+    # gameData.flows côté client (voir dispatchGameEvent() dans
+    # templates/play.html), au même titre que findTriggerNode().
+    ("evenement", "Sur un événement personnalisé"),
 ]
 
 CONDITION_OPERATORS = [
@@ -69,4 +87,16 @@ FLOW_NODE_FIELDS = {
     "action_type", "target_screen_id", "target_element_id", "element_property", "element_value",
     "target_definition_id", "target_row_id", "target_field", "data_operation", "data_value",
     "target_variable",
+    # Événements personnalisés (voir screens/custom_events/) : quel
+    # événement un nœud Déclencheur écoute (trigger_event="evenement") ou
+    # un nœud Action déclenche (action_type="declencher_evenement") —
+    # target_element_id/target_row_id (déjà ci-dessus, EVENT_ROW_ID
+    # compris) portent les paramètres transmis au déclenchement.
+    # target_element_from_event : indicateur réutilisable par N'IMPORTE
+    # QUEL nœud Action qui accepte déjà target_element_id (v1 : seule
+    # "modifier_element" le supporte) — contourne la contrainte de clé
+    # étrangère de target_element_id (impossible d'y stocker un sentinel
+    # comme EVENT_ROW_ID sur target_row_id) en résolvant "l'élément
+    # transmis par l'événement en cours" côté client à la place.
+    "trigger_custom_event_id", "target_custom_event_id", "target_element_from_event",
 }

screens/flow/ensure_flow_schema.py

@@ -72,5 +72,24 @@ def ensure_flow_schema(slug):
         conn.execute("ALTER TABLE _flow_nodes ADD COLUMN cond_variable TEXT")
     if "cond_variable_chemin" not in cols:
         conn.execute("ALTER TABLE _flow_nodes ADD COLUMN cond_variable_chemin TEXT")
+    if "trigger_custom_event_id" not in cols:
+        # Événements personnalisés (voir screens/custom_events/) : quel
+        # événement un nœud Déclencheur écoute (trigger_event="evenement")
+        # ou un nœud Action déclenche (action_type="declencher_evenement").
+        # Pas de FK vers _custom_events : une suppression d'événement
+        # nettoie déjà ces colonnes elle-même (voir
+        # screens/custom_events/delete_custom_event.py), une contrainte
+        # ferait double emploi sans rien apporter de plus.
+        conn.execute("ALTER TABLE _flow_nodes ADD COLUMN trigger_custom_event_id INTEGER")
+    if "target_custom_event_id" not in cols:
+        conn.execute("ALTER TABLE _flow_nodes ADD COLUMN target_custom_event_id INTEGER")
+    if "target_element_from_event" not in cols:
+        # Indicateur réutilisable par n'importe quel nœud Action qui
+        # accepte déjà target_element_id (v1 : seule "modifier_element") —
+        # contourne la contrainte de clé étrangère de target_element_id
+        # (impossible d'y stocker un sentinel comme EVENT_ROW_ID sur
+        # target_row_id) en résolvant "l'élément transmis par l'événement
+        # en cours" côté client (templates/play.html) à la place.
+        conn.execute("ALTER TABLE _flow_nodes ADD COLUMN target_element_from_event INTEGER NOT NULL DEFAULT 0")
     conn.commit()
     conn.close()

screens/labels/action_type_labels.py

@@ -8,5 +8,6 @@ ACTION_TYPE_LABELS = {
     "ouvrir_ligne": "Ouvrir la ligne de Répéteur cliquée",
     "activer_onglet": "Afficher cet élément, masquer tous ses frères",
     "attendre": "Attendre quelques secondes avant de continuer",
+    "declencher_evenement": "Déclencher un événement",
     "rien": "Ne rien faire",
 }

screens/labels/trigger_labels.py

@@ -4,4 +4,5 @@ TRIGGER_LABELS = {
     "affichage": "À l'affichage de l'écran",
     "survol": "Au survol",
     "fin_survol": "Fin du survol",
+    "evenement": "Sur un événement personnalisé",
 }

tests/test_custom_events.py

@@ -0,0 +1,112 @@
+"""Événements personnalisés (db/custom_events/, screens/custom_events/) :
+un événement game-wide (ex. NEED_ACTION) écouté par un nœud Déclencheur
+("trigger_event"="evenement") sur UNE scène/UN modèle, et déclenché par
+un nœud Action ("action_type"="declencher_evenement") sur UNE AUTRE
+scène/UN AUTRE modèle — la seule entité game-wide du moteur dont la
+suppression cascade RÉELLEMENT vers les nœuds qui la référencent,
+partout à la fois (voir screens/custom_events/delete_custom_event.py)."""
+import json
+import re
+
+import db
+import screens
+
+
+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 _add_element(client, slug, screen_id, widget="bouton"):
+    resp = client.post(f"/game/{slug}/screens/{screen_id}/elements/add", data={"widget": widget}, follow_redirects=False)
+    return int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
+
+
+def _add_flow_node(client, slug, screen_id, **fields):
+    resp = client.post(
+        f"/game/{slug}/screens/{screen_id}/flow/nodes/add",
+        data=json.dumps(fields),
+        content_type="application/json",
+    )
+    assert resp.status_code == 200
+    return resp.get_json()["id"]
+
+
+def test_create_event_is_idempotent_by_name(client, game):
+    screen_id = _create_screen(client, game)
+    resp = client.post(f"/game/{game}/events/new", data={
+        "name": "NEED_ACTION", "description": "Besoin d'action", "has_element_param": "on", "screen_id": screen_id,
+    })
+    assert resp.status_code == 302
+    events = db.list_custom_events(game)
+    assert len(events) == 1
+    assert events[0]["name"] == "NEED_ACTION"
+    assert events[0]["has_element_param"] == 1
+
+    # Double soumission : ne crée pas un deuxième événement du même nom.
+    client.post(f"/game/{game}/events/new", data={"name": "NEED_ACTION", "screen_id": screen_id})
+    assert len(db.list_custom_events(game)) == 1
+
+
+def test_edit_event_updates_description_and_param_flag(client, game):
+    screen_id = _create_screen(client, game)
+    event_id = db.create_custom_event(game, "NEED_ACTION", "old", False)
+    resp = client.post(f"/game/{game}/events/{event_id}/edit", data={
+        "description": "new", "has_element_param": "on", "screen_id": screen_id,
+    })
+    assert resp.status_code == 302
+    event = db.get_custom_event(game, event_id)
+    assert event["description"] == "new"
+    assert event["has_element_param"] == 1
+
+
+def test_usages_reports_listener_and_dispatcher_across_different_screens(client, game):
+    event_id = db.create_custom_event(game, "NEED_ACTION", "", True)
+
+    listener_screen = _create_screen(client, game, "Écran écouteur")
+    _add_flow_node(client, game, listener_screen, node_type="trigger", trigger_event="evenement", trigger_custom_event_id=event_id)
+
+    dispatcher_screen = _create_screen(client, game, "Écran déclencheur")
+    element_id = _add_element(client, game, dispatcher_screen)
+    _add_flow_node(
+        client, game, dispatcher_screen,
+        node_type="action", action_type="declencher_evenement",
+        target_custom_event_id=event_id, target_element_id=element_id,
+    )
+
+    usages = screens.list_custom_event_usages(game)
+    roles = {u["role"] for u in usages[event_id]}
+    screen_ids = {u["screen_id"] for u in usages[event_id]}
+    assert roles == {"ecoute", "declenche"}
+    assert screen_ids == {listener_screen, dispatcher_screen}
+
+
+def test_deleting_an_event_cascades_to_every_referencing_node_everywhere(client, game):
+    event_id = db.create_custom_event(game, "NEED_ACTION", "", True)
+
+    listener_screen = _create_screen(client, game, "Écran écouteur")
+    listener_node_id = _add_flow_node(
+        client, game, listener_screen,
+        node_type="trigger", trigger_event="evenement", trigger_custom_event_id=event_id,
+    )
+
+    # Le modèle (élément de jeu réutilisable) est un écran caché — voir
+    # screens.create_element_type — le déclencheur y est posé exactement
+    # comme sur une vraie scène.
+    screens.create_element_type(game, "Carte email", "📧")
+    template = next(t for t in screens.list_element_types(game) if t["name"] == "Carte email")
+    template_screen_id = template["template_screen_id"]
+    dispatcher_node_id = _add_flow_node(
+        client, game, template_screen_id,
+        node_type="action", action_type="declencher_evenement", target_custom_event_id=event_id,
+    )
+
+    resp = client.post(f"/game/{game}/events/{event_id}/delete", data={"screen_id": listener_screen}, follow_redirects=False)
+    assert resp.status_code == 302
+
+    assert db.get_custom_event(game, event_id) is None
+    assert screens.get_flow_node(game, listener_node_id) is None
+    assert screens.get_flow_node(game, dispatcher_node_id) is None
+    # Les écrans/modèles eux-mêmes ne sont pas touchés, seuls les nœuds.
+    assert screens.get_screen(game, listener_screen) is not None
+    assert screens.get_screen(game, template_screen_id) is not None