Ajoute la condition de visibilité et les variables globales

Nouveau panneau "Condition de visibilité" disponible dans les propriétés
de TOUT élément (widget) : permet de masquer un élément en mode jouable
selon deux moyens, au choix -
  - une variable globale (nom + type + valeur, une seule par jeu, stockée
    dans une nouvelle table _global_variables) ;
  - le champ d'un objet de données existant (même convention "état de
    partie" - une seule ligne - déjà utilisée par la Jauge).

Une variable ne servant à rien si elle ne peut jamais changer en cours de
partie, ajoute aussi une nouvelle action de flow "Modifier une variable
globale" (parallèle à "Modifier une donnée"), avec sa propre route
d'exécution serveur et son sous-formulaire dans l'éditeur de logique de
scène. Une variable peut aussi se créer à la volée depuis le sélecteur du
panneau de visibilité, sans quitter les propriétés de l'élément.

La condition n'est évaluée qu'en mode jouable (/game/<slug>/play), jamais
dans l'éditeur, pour que l'élément reste toujours sélectionnable. Un
élément masqué se réévalue en direct après toute action "Modifier une
donnée/variable", via le même mécanisme de rafraîchissement déjà utilisé
par la Jauge et le Répéteur.

Corrige au passage deux bugs découverts en testant bout en bout : (1)
apply_ctx plantait sur le nouveau marqueur interne _forge_play_mode (un
booléen parmi les {{champ}} à substituer, qui attend des chaînes) ; (2)
_compare traitait toute valeur booléenne stockée en chaîne ("0" inclus,
donc toujours vraie en Python) comme vraie - correct pour les champs
d'objet (entiers SQLite) mais faux pour les variables globales (toujours
stockées en texte).

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

screens/rendering/apply_ctx.py

@@ -5,5 +5,10 @@ def _apply_ctx(text, ctx):
     if not ctx or not text:
         return text
     for k, v in ctx.items():
+        # "_forge_play_mode" (voir render_element_html.py) est un indicateur
+        # interne posé dans ce même ctx, pas une valeur de champ {{...}} —
+        # à ignorer ici.
+        if k == "_forge_play_mode":
+            continue
         text = text.replace("{{" + k + "}}", v)
     return text

screens/rendering/filter_repeater_rows.py

@@ -51,7 +51,15 @@ def _compare(actual, operator, expected, field_type):
     """Équivalent Python de compareValues() dans templates/play.html — les
     deux doivent rester alignées si on ajoute un opérateur."""
     if field_type == "booleen":
-        a = 1 if actual else 0
+        # "actual" est un int SQLite (0/1) pour un champ d'objet, mais une
+        # chaîne pour une variable globale (voir db/global_vars/, toujours
+        # stockée en TEXT) — "0" est une chaîne non vide donc VRAIE en
+        # Python, d'où ce traitement explicite plutôt qu'un simple bool(...).
+        if isinstance(actual, str):
+            truthy = actual.strip().lower() not in ("", "0", "false", "faux", "none")
+        else:
+            truthy = bool(actual)
+        a = 1 if truthy else 0
         e = 1 if str(expected).strip().lower() in ("1", "true", "vrai") else 0
         return a != e if operator == "different" else a == e
     try:

screens/rendering/render_element_html.py

@@ -16,6 +16,7 @@ from .render_overlay import _render_overlay
 from .render_onglets import _render_onglets
 from .render_icone import _render_icone
 from .resolve_bound_row import _resolve_bound_row_ctx
+from .visibility_condition import is_element_visible
 
 
 def render_element_html(el, slug=None, children_map=None, ctx=None, parent_flex_direction=None):
@@ -31,7 +32,28 @@ def render_element_html(el, slug=None, children_map=None, ctx=None, parent_flex_
     pose physiquement cet élément, s'il y en a un — elle influence la largeur
     par défaut de cet élément (voir _style_string)."""
     meta = widget_meta(el.get("widget"))
-    bound_ctx = _resolve_bound_row_ctx(slug, el.get("attributes") or {})
+    attrs_raw = el.get("attributes") or {}
+    # La condition de visibilité (voir VISIBILITY_CONDITION_CONTROLS) n'est
+    # appliquée qu'en mode JOUABLE (ctx["_forge_play_mode"], posé par
+    # full_game_payload.py via list_elements(..., enforce_visibility=True))
+    # — jamais dans l'éditeur, où l'élément doit rester visible/sélectionnable
+    # même si la condition serait actuellement fausse, sans quoi il
+    # deviendrait impossible de le retrouver pour le régler. Un commentaire
+    # marqueur ("visibilityGated") reste posé sur le HTML même quand la
+    # condition est vraie, pour que refreshRuntimeData() (play.html) sache
+    # qu'il faut réévaluer cet élément après toute action "Modifier une
+    # donnée"/"Modifier une variable" — pas seulement Jauge/Répéteur, qui ont
+    # déjà chacun leur propre marqueur ("jaugeBar"/"repeaterItem") couvrant
+    # ce cas d'office.
+    has_visibility_condition = attrs_raw.get("_visibilite_cond_mode") in ("variable", "objet")
+    play_mode = bool((ctx or {}).get("_forge_play_mode"))
+    if play_mode and has_visibility_condition and not is_element_visible(slug, attrs_raw):
+        return f'<div class="visibilityGated" data-element-id="{el["id"]}" style="display:none;"></div>'
+
+    def _mark(html_str):
+        return html_str + "<!--visibilityGated-->" if has_visibility_condition else html_str
+
+    bound_ctx = _resolve_bound_row_ctx(slug, attrs_raw)
     if bound_ctx:
         ctx = {**(ctx or {}), **bound_ctx}
     special = meta.get("special_render")
@@ -72,7 +94,7 @@ def render_element_html(el, slug=None, children_map=None, ctx=None, parent_flex_
         attrs["data-hover-text"] = _apply_ctx(hover_text, ctx)
 
     if meta.get("self_closing"):
-        return f"<{tag} {_attr_string(attrs, style)}>"
+        return _mark(f"<{tag} {_attr_string(attrs, style)}>")
 
     content = _apply_ctx(el.get("content") or "", ctx)
     child_html = _render_children(el, slug, children_map, ctx)
@@ -80,7 +102,7 @@ def render_element_html(el, slug=None, children_map=None, ctx=None, parent_flex_
     if tag in ("ul", "ol"):
         items = [line.strip() for line in content.split("\n") if line.strip()]
         inner = "".join(f"<li>{html_lib.escape(item)}</li>" for item in items) + child_html
-        return f"<{tag} {_attr_string(attrs, style)}>{inner}</{tag}>"
+        return _mark(f"<{tag} {_attr_string(attrs, style)}>{inner}</{tag}>")
 
     safe_content = html_lib.escape(content).replace("\n", "<br>") if content else ""
-    return f"<{tag} {_attr_string(attrs, style)}>{safe_content}{child_html}</{tag}>"
+    return _mark(f"<{tag} {_attr_string(attrs, style)}>{safe_content}{child_html}</{tag}>")

screens/rendering/visibility_condition.py

@@ -0,0 +1,44 @@
+import db
+
+from .filter_repeater_rows import _resolve_filter_value, _compare, _field_column
+
+
+def is_element_visible(slug, attrs):
+    """Condition de visibilité (panneau de propriétés, tout widget — voir
+    VISIBILITY_CONDITION_CONTROLS) : masque un élément selon soit une
+    VARIABLE GLOBALE (une seule valeur pour tout le jeu, voir
+    db/global_vars/), soit le champ d'un objet de données (convention "1
+    seule ligne = état de partie", déjà utilisée par la Jauge/Donnée liée).
+    Absente de réglage (_visibilite_cond_mode vide) => toujours visible,
+    comportement inchangé pour tous les éléments déjà créés. Réutilise
+    _compare/_resolve_filter_value/_field_column de filter_repeater_rows.py
+    pour rester cohérent avec les mêmes opérateurs et la même syntaxe
+    "{{Objet.champ}}" pour une valeur de comparaison dynamique."""
+    mode = attrs.get("_visibilite_cond_mode")
+    if mode not in ("variable", "objet"):
+        return True
+    operator = attrs.get("_visibilite_cond_operateur") or "egal"
+    expected = _resolve_filter_value(slug, attrs.get("_visibilite_cond_valeur") or "")
+
+    if mode == "variable":
+        var_name = attrs.get("_visibilite_cond_variable")
+        if not var_name:
+            return True
+        variable = db.get_global_variable(slug, var_name)
+        if not variable:
+            return True  # variable supprimée depuis : ne bloque jamais l'affichage
+        return _compare(variable.get("value"), operator, expected, variable.get("type") or "texte")
+
+    definition_id = attrs.get("_visibilite_cond_definition_id")
+    field_name = attrs.get("_visibilite_cond_champ")
+    if not definition_id or not field_name:
+        return True
+    definition = db.get_definition(slug, int(definition_id))
+    if not definition:
+        return True
+    rows = db.list_rows(slug, definition)
+    if not rows:
+        return True  # objet sans donnée pour l'instant : ne bloque pas
+    row = rows[0]  # convention "état de partie" : une seule ligne, voir data_definition_options.py
+    field_type = next((f["type"] for f in definition["fields"] if f["name"] == field_name), "texte")
+    return _compare(row.get(_field_column(definition, field_name)), operator, expected, field_type)