Donnée liée : conditions ET/OU illimitées + conditions de logique sur une variable globale

Deux fonctionnalités demandées, développées et corrigées dans cet
échange :

1. "Donnée liée" (Texte/Titre) : le réglage à 2 filtres fixes (toujours
   combinés en ET) devient une liste de conditions ILLIMITÉE, avec un
   choix ET/OU pour les combiner (screens/widgets/controls/c_clause_list.py,
   screens/clause_list_codec.py). Rétrocompatible avec les anciens
   éléments (_data_filtre_champ/_data_filtre2_champ), convertis à la
   volée à la lecture, sans migration. Après un premier essai à la
   présentation trop compacte et technique (retour utilisateur : "pas de
   champ technique, pas de notation bizarre {{ }}"), la présentation
   finale reprend EXACTEMENT l'ancien style (labels "Champ"/"...est"/
   "...cette valeur", même sélecteur de valeur fixe/dynamique/variable
   déjà existant, jamais la syntaxe brute), simplement répétée par
   condition (templates/partials/clause_row.html), avec un bouton
   "+ Ajouter une condition" bien visible et une liste scrollable
   (static/style.css, .clauseListWrap). Le même moteur (filter_repeater_
   rows.py généralisé) profite aussi au Répéteur de données en interne.

2. Nœud Condition de la Logique de la scène : peut désormais tester une
   VARIABLE GLOBALE en plus d'un champ d'objet (cond_source/cond_variable/
   cond_variable_chemin — screens/flow/ensure_flow_schema.py), sur la
   clause principale ET chaque clause supplémentaire (ET/OU). Évalué côté
   CLIENT (templates/play.html, evaluateConditionClause), contre un
   nouveau gameData.variables exposé par full_game_payload.py — tenu à
   jour par refreshRuntimeData() après toute action qui modifie une
   variable, sans changement supplémentaire nécessaire. Le panneau de
   condition reste utilisable même sans aucun objet défini dans le jeu
   (avant, il disparaissait entièrement).

Vérifié : 153 tests pytest (nouveaux : test_data_binding_clause_list.py,
test_condition_variable.py) + logique JS d'évaluation des conditions
vérifiée isolément avec Node (variable scalaire, objet avec chemin
chaîné, tableau par index, variable introuvable, booléen, rétrocompatibilité
legacy) + rendu des deux pages (éditeur/jeu) vérifié sur le vrai projet
"test" en plus des jeux de test.

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

screens/rendering/filter_repeater_rows.py

@@ -3,6 +3,8 @@ import re
 
 import db
 
+from ..clause_list_codec import decode_clauses
+
 # {{NomDeLObjet.nom_du_champ}} : référence à un AUTRE objet de données, pour
 # comparer le champ filtré à une valeur qui change en cours de partie (ex:
 # le niveau atteint) plutôt qu'à une valeur fixe tapée en dur — même
@@ -154,13 +156,30 @@ def _compare(actual, operator, expected, field_type):
     return False
 
 
-def _apply_one_filter(slug, definition, rows, field_name, operator, raw_value):
+def _clause_matches(slug, definition, row, clause):
+    field_name = (clause.get("champ") or "").strip()
     if not field_name:
-        return rows
-    expected = _resolve_filter_value(slug, raw_value or "")
+        return True
+    operator = clause.get("operateur") or "egal"
+    expected = _resolve_filter_value(slug, clause.get("valeur") or "")
     field_type = next((f["type"] for f in definition["fields"] if f["name"] == field_name), "texte")
     col = _field_column(definition, field_name)
-    return [r for r in rows if _compare(r.get(col), operator, expected, field_type)]
+    return _compare(row.get(col), operator, expected, field_type)
+
+
+def filter_rows_by_clauses(slug, definition, rows, clauses, combinator):
+    """Ne garde, parmi les lignes, que celles qui satisfont la liste de
+    clauses données (un nombre quelconque), combinées entre elles par ET
+    (toutes vraies) ou par OU (au moins une vraie) selon `combinator`
+    ("et"/"ou"). Utilisé aussi bien par le Répéteur de données (clauses
+    reconstruites depuis _filtre_champ/_filtre2_champ, voir
+    filter_repeater_rows ci-dessous) que par la "Donnée liée" d'un Texte/
+    Titre (clauses illimitées, voir resolve_bound_row.py)."""
+    if not clauses:
+        return rows
+    if combinator == "ou":
+        return [r for r in rows if any(_clause_matches(slug, definition, r, c) for c in clauses)]
+    return [r for r in rows if all(_clause_matches(slug, definition, r, c) for c in clauses)]
 
 
 def filter_repeater_rows(slug, definition, rows, attrs):
@@ -172,12 +191,5 @@ def filter_repeater_rows(slug, definition, rows, attrs):
     sur un écran unique") : c'est ce qui permet à un seul écran de n'afficher,
     par exemple, que le niveau du parcours en cours (2 conditions : le bon
     parcours ET le bon numéro de niveau) plutôt que tous les niveaux."""
-    rows = _apply_one_filter(
-        slug, definition, rows,
-        (attrs.get("_filtre_champ") or "").strip(), attrs.get("_filtre_operateur") or "egal", attrs.get("_filtre_valeur"),
-    )
-    rows = _apply_one_filter(
-        slug, definition, rows,
-        (attrs.get("_filtre2_champ") or "").strip(), attrs.get("_filtre2_operateur") or "egal", attrs.get("_filtre2_valeur"),
-    )
-    return rows
+    clauses, combinator = decode_clauses(attrs, "_filtres_json", "_filtre_combinateur", legacy_prefix="_filtre")
+    return filter_rows_by_clauses(slug, definition, rows, clauses, combinator)

screens/rendering/render_element_html.py

@@ -117,19 +117,35 @@ def render_element_html(el, slug=None, children_map=None, ctx=None, parent_flex_
         # Un exemplaire d'élément de jeu est posé par défaut avec le widget
         # générique "conteneur" (add_element.py, "default_widget") — utile
         # pour la plupart des modèles, mais QUAND le modèle entier n'est
-        # qu'une "Superposition / boîte de dialogue", cette enveloppe
-        # (fond, bordure, position normale sur le canevas — voir
-        # widgets/registry.py "conteneur") resterait visible EN PERMANENCE
-        # à l'endroit où l'exemplaire a été déposé, alors que la
-        # superposition à l'intérieur gère déjà entièrement sa propre
-        # apparence et son propre masquage (position:fixed plein écran,
-        # démarre masquée) — vécu comme "un conteneur vide apparaît sur la
-        # scène, pas la boîte de dialogue" (en réalité la boîte de dialogue
-        # existe bien, juste masquée comme prévu ; c'est le conteneur
-        # AUTOUR qui n'aurait jamais dû être visible). On court-circuite
-        # donc entièrement l'enveloppe et on renvoie directement le
-        # contenu du modèle.
-        return _mark(child_html)
+        # qu'une "Superposition / boîte de dialogue", la classe Bulma "box"
+        # de ce widget (widgets/registry.py "conteneur") lui donnait un
+        # fond opaque TOUJOURS VISIBLE à l'endroit où l'exemplaire a été
+        # déposé, alors que la superposition à l'intérieur gère déjà
+        # entièrement sa propre apparence et son propre masquage
+        # (position:fixed plein écran, démarre masquée) — vécu comme "un
+        # conteneur vide apparaît sur la scène, pas la boîte de dialogue"
+        # (en réalité la boîte de dialogue existe bien, juste masquée comme
+        # prévu ; c'est le conteneur AUTOUR qui n'aurait jamais dû avoir sa
+        # propre apparence visuelle).
+        #
+        # On ne court-circuite PLUS entièrement cette enveloppe (un essai
+        # précédent le faisait, en renvoyant `child_html` directement) :
+        # cette balise porte le SEUL id/data-element-id de CET EXEMPLAIRE
+        # précis (id=el["id"], distinct de l'id interne du modèle,
+        # ex. l'overlay du modèle "dialog" garde son propre id 72 alors que
+        # CET exemplaire est, par ex., 77) — une action "Modifier un
+        # élément" posée sur LA SCÈNE qui l'accueille (pas sur le modèle
+        # lui-même) cible cet id d'exemplaire, jamais celui, interne et
+        # partagé par tous les exemplaires, du modèle. La court-circuiter
+        # entièrement faisait disparaître cet id du DOM, rendant
+        # IMPOSSIBLE tout contrôle de la boîte de dialogue depuis la
+        # logique de la scène qui l'accueille ("j'ai aucun contrôle sur la
+        # visibilité de la modale depuis la scène"). On garde donc la
+        # balise (avec son id), mais SANS la classe "box" du widget
+        # générique — juste une balise transparente, invisible tant
+        # qu'elle ne porte ni fond ni bordure."""
+        attrs.pop("class", None)
+        return _mark(f"<div {_attr_string(attrs, style)}>{child_html}</div>")
 
     if tag in ("ul", "ol"):
         items = [line.strip() for line in content.split("\n") if line.strip()]
@@ -154,12 +170,29 @@ def _render_element_type_children(el, slug, ctx):
     de ce mécanisme) plutôt que d'afficher un exemplaire silencieusement
     vide. Le second élément renvoyé indique si le modèle N'EST QUE une
     superposition (voir l'appelant : dans ce cas précis, l'enveloppe
-    générique "conteneur" de l'exemplaire doit être court-circuitée)."""
+    générique "conteneur" de l'exemplaire ne doit pas avoir sa propre
+    apparence visuelle)."""
     template_tree = _load_template_tree(slug, el["element_type_id"])
     if not template_tree:
         return None, False
+    is_overlay_only = _is_overlay_only_element_type(slug, el["element_type_id"])
+    if is_overlay_only:
+        # Le masquage de CET EXEMPLAIRE est entièrement délégué à
+        # l'enveloppe (voir l'appelant : add_element.py la fait démarrer
+        # masquée par défaut, exactement comme la superposition elle-même)
+        # — la superposition INTERNE au modèle ne doit donc plus appliquer
+        # SON PROPRE réglage "Visibilité" une fois posée comme exemplaire
+        # ailleurs (sinon double masquage : rendre l'enveloppe visible
+        # depuis la scène qui l'accueille resterait sans aucun effet
+        # visible tant que la superposition interne, elle, reste "Masqué"
+        # dans le modèle). On retire donc "display" de sa copie de style
+        # avant rendu (copie éphémère, jamais réenregistrée) — seul le
+        # display:flex de base (render_overlay.py) s'applique alors.
+        overlay_root = dict(template_tree["top"][0])
+        overlay_root["style"] = {k: v for k, v in overlay_root["style"].items() if k != "display"}
+        template_tree["top"][0] = overlay_root
     html = "".join(
         render_element_html(c, slug, template_tree["children_map"], ctx)
         for c in template_tree["top"]
     )
-    return html, _is_overlay_only_element_type(slug, el["element_type_id"])
+    return html, is_overlay_only

screens/rendering/resolve_bound_row.py

@@ -1,13 +1,17 @@
 import db
 
-from .filter_repeater_rows import filter_repeater_rows, _field_column
+from .filter_repeater_rows import filter_rows_by_clauses, _field_column
+from ..clause_list_codec import decode_clauses
 
 
 def _resolve_bound_row_ctx(slug, attrs):
     """Si cet élément est lié à un objet de données (attr:_data_definition_id —
     réglage "Lier à un objet de données" des widgets Texte/Titre, voir
-    DATA_BINDING_CONTROLS), retrouve LA ligne qui correspond aux 1 ou 2
-    filtres réglés (_data_filtre*/_data_filtre2*) — même moteur que le
+    DATA_BINDING_CONTROLS), retrouve LA ligne qui correspond aux conditions
+    réglées (un nombre quelconque, combinées par ET/OU — attr:
+    _data_filtres_json/_data_filtre_combinateur, avec repli sur l'ancien
+    format à 2 filtres fixes _data_filtre*/_data_filtre2* pour les éléments
+    créés avant l'ajout des clauses illimitées) — même moteur que le
     filtre du Répéteur de données, voir filter_repeater_rows.py — et
     renvoie ses champs sous forme de {nom_du_champ: valeur en texte},
     exploitable par {{champ}} dans le contenu. Permet d'afficher UNE seule
@@ -24,14 +28,8 @@ def _resolve_bound_row_ctx(slug, attrs):
     if not definition:
         return None
     rows = db.list_rows(slug, definition)
-    rows = filter_repeater_rows(slug, definition, rows, {
-        "_filtre_champ": attrs.get("_data_filtre_champ"),
-        "_filtre_operateur": attrs.get("_data_filtre_operateur"),
-        "_filtre_valeur": attrs.get("_data_filtre_valeur"),
-        "_filtre2_champ": attrs.get("_data_filtre2_champ"),
-        "_filtre2_operateur": attrs.get("_data_filtre2_operateur"),
-        "_filtre2_valeur": attrs.get("_data_filtre2_valeur"),
-    })
+    clauses, combinator = decode_clauses(attrs, "_data_filtres_json", "_data_filtre_combinateur", legacy_prefix="_data_filtre")
+    rows = filter_rows_by_clauses(slug, definition, rows, clauses, combinator)
     if not rows:
         return None
     row = rows[0]