Variables globales Objet/Tableau, lisibles via un chemin dans les conditions et filtres

Deux nouveaux types de variable globale (db/constants.py) : "objet" et
"tableau" — valeur stockée en JSON (colonne TEXT existante), avec
validation à la création/modification (db/global_vars/
coerce_structured_value.py) : un JSON invalide retombe sur un défaut sûr
("{}"/"[]") plutôt que de corrompre silencieusement la variable pour
toutes ses lectures suivantes. apply_variable_action.py n'a besoin
d'aucun changement — "definir_texte" écrit déjà n'importe quelle chaîne
telle quelle.

Nouvelle résolution de chemin, partagée (screens/rendering/
filter_repeater_rows.py::_resolve_variable_path) : navigue dans la
valeur JSON d'une variable selon un chemin ".champ"/"[index]" chaînable
(ex. ".arme.degats", "[0].valeur") — ne lève jamais, renvoie None si le
JSON est invalide ou qu'un segment du chemin ne correspond à rien.
Branchée à deux endroits, qui lisaient déjà une variable globale :

- La valeur de comparaison {{$nom_variable}} (filtres de Répéteur ET
  Condition de visibilité, qui partagent le même
  _resolve_filter_value()) accepte maintenant un chemin optionnel :
  {{$perso.nom}}, {{$scores[0]}}. Le sélecteur "Variable globale" du
  panneau de propriétés (screen_edit.html, .filterValueVariable) gagne un
  champ "Chemin optionnel" à côté du choix de variable — même regex
  étendue côté JS (_VAR_REF_RE) que côté Python (_VAR_REF_PATTERN), pour
  que la valeur round-trip correctement à la réouverture du panneau.

- La variable VÉRIFIÉE par une Condition de visibilité en mode "variable"
  (choisie via un <select>, pas la syntaxe {{$...}}) gagne son propre
  nouveau contrôle "Chemin dans la variable" (visibility_condition_
  controls.py) — nécessaire pour comparer un champ d'un Objet ou un
  élément d'un Tableau, pas seulement la variable entière.

game_dashboard.html (onglet Variables) : la valeur par défaut de la barre
de création devient un <textarea> (fonctionne aussi bien pour un JSON
multi-ligne qu'un scalaire court), et la cellule "Valeur" du tableau des
variables existantes devient un <textarea> quand le type est objet/
tableau.

4 nouveaux tests (tests/test_variable_object_array.py) : validation JSON
à la création, filtre de Répéteur avec chemin chaîné, condition de
visibilité avec accès par index de tableau, chemin invalide/absent sans
plantage.

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

screens/rendering/filter_repeater_rows.py

@@ -1,3 +1,4 @@
+import json
 import re
 
 import db
@@ -12,8 +13,41 @@ _REF_PATTERN = re.compile(r"^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$")
 # {{$nom_variable}} : référence à une VARIABLE GLOBALE (voir db/global_vars/)
 # — le "$" (jamais utilisé dans un nom d'objet/de champ) distingue sans
 # ambiguïté cette syntaxe de _REF_PATTERN ci-dessus, qui, elle, attend
-# toujours un point ("Objet.champ").
-_VAR_REF_PATTERN = re.compile(r"^\{\{\s*\$([^.{}]+)\s*\}\}$")
+# toujours un point ("Objet.champ"). Le 2e groupe capture un CHEMIN
+# optionnel à l'intérieur de la variable ({{$perso.nom}}, {{$scores[0]}},
+# chaînable : {{$perso.arme.degats}}) — utile seulement pour une variable
+# de type "objet"/"tableau" (voir _resolve_variable_path ci-dessous), sans
+# effet sur une variable scalaire (chemin vide dans ce cas).
+_VAR_REF_PATTERN = re.compile(r"^\{\{\s*\$([^.{}\[\]]+)((?:\.[^.{}\[\]]+|\[\d+\])*)\s*\}\}$")
+
+# Un segment de chemin est soit ".champ" (clé d'objet) soit "[index]"
+# (élément de tableau, 0 = premier) — voir _VAR_REF_PATTERN ci-dessus et le
+# contrôle "Chemin dans la variable" de la Condition de visibilité
+# (visibility_condition_controls.py).
+_PATH_SEGMENT_RE = re.compile(r"\.([^.\[\]]+)|\[(\d+)\]")
+
+
+def _resolve_variable_path(raw_value, path):
+    """Navigue dans une valeur JSON (chaîne stockée en base, colonne TEXT)
+    selon un chemin ".champ"/"[index]" chaînable. Ne lève jamais : chemin
+    vide -> valeur brute inchangée (utile pour une variable scalaire, où le
+    chemin est toujours vide) ; JSON invalide, clé/index absent ou valeur
+    intermédiaire pas navigable -> None — même convention que le reste de
+    ce fichier (objet/variable introuvable -> ne matche rien plutôt que
+    planter)."""
+    if not path:
+        return raw_value
+    try:
+        current = json.loads(raw_value) if raw_value else None
+    except (TypeError, ValueError):
+        return None
+    for m in _PATH_SEGMENT_RE.finditer(path):
+        key, index = m.group(1), m.group(2)
+        try:
+            current = current[key] if key is not None else current[int(index)]
+        except (KeyError, IndexError, TypeError):
+            return None
+    return current
 
 
 def _field_column(definition, field_name):
@@ -45,7 +79,9 @@ def _resolve_filter_value(slug, raw_value):
     var_match = _VAR_REF_PATTERN.match(stripped)
     if var_match:
         variable = db.get_global_variable(slug, var_match.group(1).strip())
-        return variable.get("value") if variable else None  # variable supprimée depuis : ne matche rien plutôt que planter
+        if not variable:
+            return None  # variable supprimée depuis : ne matche rien plutôt que planter
+        return _resolve_variable_path(variable.get("value"), var_match.group(2))
 
     m = _REF_PATTERN.match(stripped)
     if not m:

screens/rendering/visibility_condition.py

@@ -1,6 +1,6 @@
 import db
 
-from .filter_repeater_rows import _resolve_filter_value, _compare, _field_column
+from .filter_repeater_rows import _resolve_filter_value, _resolve_variable_path, _compare, _field_column
 
 
 def is_element_visible(slug, attrs, ctx=None):
@@ -39,7 +39,15 @@ def is_element_visible(slug, attrs, ctx=None):
         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")
+        value = variable.get("value")
+        # "Chemin dans la variable" (voir visibility_condition_controls.py)
+        # : nécessaire pour comparer un CHAMP d'une variable "objet" ou un
+        # ÉLÉMENT d'une variable "tableau", pas seulement la variable
+        # entière — même syntaxe ".champ"/"[index]" que {{$var.chemin}}.
+        path = attrs.get("_visibilite_cond_variable_chemin")
+        if path:
+            value = _resolve_variable_path(value, path)
+        return _compare(value, operator, expected, variable.get("type") or "texte")
 
     definition_id = attrs.get("_visibilite_cond_definition_id")
     field_name = attrs.get("_visibilite_cond_champ")