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>

db/__init__.py

@@ -52,6 +52,12 @@ from .rows.update_row_field import update_row_field
 from .rows.delete_row import delete_row
 from .rows.rows_referencing import rows_referencing
 
+from .global_vars.list_global_variables import list_global_variables
+from .global_vars.get_global_variable import get_global_variable
+from .global_vars.create_global_variable import create_global_variable
+from .global_vars.update_global_variable_value import update_global_variable_value
+from .global_vars.delete_global_variable import delete_global_variable
+
 __all__ = [
     "PROJECTS_DIR", "FIELD_TYPES",
     "slugify", "table_name_for", "game_dir", "db_path", "connect",
@@ -61,4 +67,6 @@ __all__ = [
     "delete_definition",
     "list_rows", "relation_options", "insert_row", "get_row", "update_row",
     "update_row_field", "delete_row", "rows_referencing",
+    "list_global_variables", "get_global_variable", "create_global_variable",
+    "update_global_variable_value", "delete_global_variable",
 ]

db/global_vars/create_global_variable.py

@@ -0,0 +1,27 @@
+from ..connection import connect
+from .ensure_global_vars_schema import ensure_global_vars_schema
+
+
+def create_global_variable(slug, name, var_type="texte", default_value=""):
+    """Crée une variable globale si son nom n'existe pas déjà (les noms sont
+    uniques — voir ensure_global_vars_schema.py) ; si elle existe déjà, ne
+    touche à rien et renvoie simplement son id existant, pour que "créer"
+    depuis le sélecteur de condition de visibilité (voir screen_edit.html)
+    reste sans risque même en cas de double clic/soumission."""
+    name = (name or "").strip()
+    if not name:
+        return None
+    ensure_global_vars_schema(slug)
+    conn = connect(slug)
+    existing = conn.execute("SELECT id FROM _global_variables WHERE name = ?", (name,)).fetchone()
+    if existing:
+        conn.close()
+        return existing["id"]
+    conn.execute(
+        "INSERT INTO _global_variables (name, type, value) VALUES (?, ?, ?)",
+        (name, var_type, default_value),
+    )
+    new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
+    conn.commit()
+    conn.close()
+    return new_id

db/global_vars/delete_global_variable.py

@@ -0,0 +1,10 @@
+from ..connection import connect
+from .ensure_global_vars_schema import ensure_global_vars_schema
+
+
+def delete_global_variable(slug, name):
+    ensure_global_vars_schema(slug)
+    conn = connect(slug)
+    conn.execute("DELETE FROM _global_variables WHERE name = ?", (name,))
+    conn.commit()
+    conn.close()

db/global_vars/ensure_global_vars_schema.py

@@ -0,0 +1,23 @@
+from ..connection import connect
+
+
+def ensure_global_vars_schema(slug):
+    """Migration légère (même principe que ensure_field_bounds_schema.py) :
+    crée _global_variables si absente — aucune migration manuelle nécessaire
+    pour les jeux créés avant cette fonctionnalité, la prochaine lecture
+    suffit. Une variable globale vit pour TOUT le jeu (pas par écran, pas
+    par ligne) : "nom" est donc UNIQUE, une seule valeur actuelle par nom."""
+    conn = connect(slug)
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS _global_variables (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE,
+            type TEXT NOT NULL DEFAULT 'texte',
+            value TEXT,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+        """
+    )
+    conn.commit()
+    conn.close()

db/global_vars/get_global_variable.py

@@ -0,0 +1,16 @@
+from ..connection import connect
+from .ensure_global_vars_schema import ensure_global_vars_schema
+
+
+def get_global_variable(slug, name):
+    """Par NOM (unique), pas par id — c'est comme ça qu'une variable est
+    référencée partout ailleurs (condition de visibilité, action "Modifier
+    une variable"), jamais par un id technique que l'utilisateur ne voit
+    pas."""
+    if not name:
+        return None
+    ensure_global_vars_schema(slug)
+    conn = connect(slug)
+    row = conn.execute("SELECT * FROM _global_variables WHERE name = ?", (name,)).fetchone()
+    conn.close()
+    return dict(row) if row else None

db/global_vars/list_global_variables.py

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

db/global_vars/update_global_variable_value.py

@@ -0,0 +1,18 @@
+from ..connection import connect
+from .ensure_global_vars_schema import ensure_global_vars_schema
+from .get_global_variable import get_global_variable
+
+
+def update_global_variable_value(slug, name, new_value):
+    """Écrit une nouvelle valeur BRUTE (déjà calculée par l'appelant) sur la
+    variable — utilisé aussi bien par l'action "Modifier une variable" (voir
+    screens/global_vars/apply_variable_action.py) que par une éventuelle
+    modification directe (page de gestion des variables)."""
+    if not get_global_variable(slug, name):
+        return False
+    ensure_global_vars_schema(slug)
+    conn = connect(slug)
+    conn.execute("UPDATE _global_variables SET value = ? WHERE name = ?", (str(new_value), name))
+    conn.commit()
+    conn.close()
+    return True