Phase 1 (1/3) : état par joueur — couche db/ et chaîne de rendu

Fil directeur du plan : chaque variable globale et chaque objet de
données gagne un player_id (sentinelle PLAYER_SHARED='__shared__' par
défaut partout — l'aperçu créateur et tous les tests existants
continuent de fonctionner À L'IDENTIQUE, aucune signature appelée sans
argument explicite ne change de comportement), plus un réglage
per_player choisi une fois à la création :
- per_player=1 (par défaut) : chaque joueur a sa propre valeur/ses
  propres lignes.
- per_player=0 : valeur/lignes partagées par tous les joueurs (ex. un
  compteur de visiteurs global, un catalogue commun).

db/global_vars/ : _global_variables passe de UNIQUE(name) à
UNIQUE(name, player_id) — SQLite ne permet pas de modifier une
contrainte UNIQUE via ALTER TABLE, reconstruction de la table détectée
et faite une seule fois (ensure_global_vars_schema.py) pour les jeux
créés avant cette phase. La ligne "modèle" (player_id=PLAYER_SHARED,
créée par le créateur) porte le réglage per_player et sert de valeur
PAR DÉFAUT : la première écriture d'un joueur sur une variable
per_player crée paresseusement SA propre ligne (copiée depuis le
modèle) ; une lecture sans ligne encore écrite retombe sur le modèle
(nouveau resolve_player_key.py). list_global_variables() (tableau de
bord) ne montre toujours que les lignes modèles ; nouveau
list_global_variables_for_player() expose la valeur EFFECTIVE d'un
joueur au runtime (full_game_payload.py).

db/definitions/ + db/rows/ : chaque table d'objet généré
(create_definition.py) gagne une colonne player_id (ADD COLUMN simple,
pas de contrainte UNIQUE en jeu ici) ; _definitions gagne per_player.
Contrairement aux variables, PAS de repli sur une ligne "modèle" pour
les lignes d'un objet per_player — une LISTE n'a pas de valeur par
défaut unique à copier comme un scalaire, un nouvel objet per_player
démarre VIDE pour chaque joueur (nouveau resolve_row_player_key.py).
get_row/update_row/update_row_field/delete_row filtrent aussi par
player_id (pas seulement id) : garde-fou contre un row_id d'un AUTRE
joueur, nécessaire dès qu'un objet per_player sera exposé sur la future
route publique /jouer/<slug>. Migration : nouveau
ensure_player_id_column(slug, table_name), appelé avant toute requête
sur une table d'objet créée avant cette phase.

Chaîne de rendu (screens/elements/list_elements.py ->
screens/rendering/render_element_html.py -> render_repeater.py/
render_jauge.py/resolve_bound_row.py/visibility_condition.py/
filter_repeater_rows.py) : player_id transite dans le ctx déjà utilisé
partout pour "champ en cours" (ctx["_forge_player_id"], même patron que
ctx["_forge_play_mode"], posé une seule fois par list_elements quand
enforce_visibility=True) — pas de nouveau paramètre positionnel à
threader dans chaque fonction, juste une clé de plus dans un mécanisme
déjà en place.

Nouveau tests/test_player_state.py : verrouille à la fois le nouveau
comportement (deux joueurs => valeurs/lignes indépendantes ; per_player=0
=> partagé ; nouveau joueur => valeur par défaut pour une variable, liste
VIDE pour un objet ; get_row ne fuite jamais vers un autre joueur) et la
non-régression de l'aperçu créateur (comportement historique inchangé).

Vérifié : 232 tests passent (9 nouveaux). Reste à faire (prochains
commits) : route publique /jouer/<slug>, identité visiteur (cookie),
bascule "Publier en ligne" dans le tableau de bord.

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

screens/rendering/filter_repeater_rows.py

@@ -65,7 +65,7 @@ def _field_column(definition, field_name):
     return col
 
 
-def _resolve_filter_value(slug, raw_value):
+def _resolve_filter_value(slug, raw_value, player_id=db.PLAYER_SHARED):
     """Si raw_value est une référence "{{Objet.champ}}", va lire la valeur
     ACTUELLE de ce champ sur la ligne la plus récente de cet objet (par
     convention, un objet utilisé comme "état de partie" — niveau courant,
@@ -73,14 +73,18 @@ def _resolve_filter_value(slug, raw_value):
     par des actions "Modifier une donnée" plutôt que d'en créer une
     nouvelle à chaque fois). Si c'est une référence "{{$nom_variable}}", va
     lire la valeur ACTUELLE de cette variable globale (voir
-    db/global_vars/). Sinon, renvoie raw_value tel quel (valeur fixe)."""
+    db/global_vars/). Sinon, renvoie raw_value tel quel (valeur fixe).
+    `player_id` : état par joueur (Phase 1) — quel joueur consulte, pour
+    qu'un objet/une variable per_player renvoie SA valeur (voir
+    resolve_player_key.py/resolve_row_player_key.py, appelés en interne par
+    get_global_variable/list_rows)."""
     if not raw_value:
         return raw_value
     stripped = raw_value.strip()
 
     var_match = _VAR_REF_PATTERN.match(stripped)
     if var_match:
-        variable = db.get_global_variable(slug, var_match.group(1).strip())
+        variable = db.get_global_variable(slug, var_match.group(1).strip(), player_id)
         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))
@@ -92,7 +96,7 @@ def _resolve_filter_value(slug, raw_value):
     for d in db.list_definitions(slug):
         if d["name"] == object_name:
             full = db.get_definition(slug, d["id"])
-            rows = db.list_rows(slug, full)
+            rows = db.list_rows(slug, full, player_id)
             if rows:
                 return rows[0].get(_field_column(full, field_name))
             return None
@@ -156,18 +160,18 @@ def _compare(actual, operator, expected, field_type):
     return False
 
 
-def _clause_matches(slug, definition, row, clause):
+def _clause_matches(slug, definition, row, clause, player_id=db.PLAYER_SHARED):
     field_name = (clause.get("champ") or "").strip()
     if not field_name:
         return True
     operator = clause.get("operateur") or "egal"
-    expected = _resolve_filter_value(slug, clause.get("valeur") or "")
+    expected = _resolve_filter_value(slug, clause.get("valeur") or "", player_id)
     field_type = next((f["type"] for f in definition["fields"] if f["name"] == field_name), "texte")
     col = _field_column(definition, field_name)
     return _compare(row.get(col), operator, expected, field_type)
 
 
-def filter_rows_by_clauses(slug, definition, rows, clauses, combinator):
+def filter_rows_by_clauses(slug, definition, rows, clauses, combinator, player_id=db.PLAYER_SHARED):
     """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`
@@ -178,11 +182,11 @@ def filter_rows_by_clauses(slug, definition, rows, clauses, combinator):
     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)]
+        return [r for r in rows if any(_clause_matches(slug, definition, r, c, player_id) for c in clauses)]
+    return [r for r in rows if all(_clause_matches(slug, definition, r, c, player_id) for c in clauses)]
 
 
-def filter_repeater_rows(slug, definition, rows, attrs):
+def filter_repeater_rows(slug, definition, rows, attrs, player_id=db.PLAYER_SHARED):
     """Ne garde, parmi les lignes d'un Répéteur, que celles qui correspondent
     au(x) filtre(s) optionnel(s) réglé(s) dans ses propriétés (_filtre_champ/
     _filtre_operateur/_filtre_valeur, ET, si renseigné, _filtre2_champ/
@@ -192,4 +196,4 @@ def filter_repeater_rows(slug, definition, rows, attrs):
     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."""
     clauses, combinator = decode_clauses(attrs, "_filtres_json", "_filtre_combinateur", legacy_prefix="_filtre")
-    return filter_rows_by_clauses(slug, definition, rows, clauses, combinator)
+    return filter_rows_by_clauses(slug, definition, rows, clauses, combinator, player_id)

screens/rendering/render_element_html.py

@@ -74,7 +74,7 @@ def render_element_html(el, slug=None, children_map=None, ctx=None, parent_flex_
             markers += "<!--dataBound-->"
         return html_str + markers
 
-    bound_ctx = _resolve_bound_row_ctx(slug, attrs_raw)
+    bound_ctx = _resolve_bound_row_ctx(slug, attrs_raw, (ctx or {}).get("_forge_player_id", "__shared__"))
     if bound_ctx:
         ctx = {**(ctx or {}), **bound_ctx}
     # Chaque branche "special_render" passe elle aussi par _mark() : sans

screens/rendering/render_jauge.py

@@ -22,7 +22,7 @@ def _interpolate_color(low_hex, high_hex, ratio):
     return "#{:02x}{:02x}{:02x}".format(*mixed)
 
 
-def _read_field_value(slug, definition_id, row_id, field_name):
+def _read_field_value(slug, definition_id, row_id, field_name, player_id=db.PLAYER_SHARED):
     """Lit la valeur du champ demandé sur l'enregistrement visé (row_id) de
     l'objet suivi — quand un objet contient plusieurs enregistrements (ex:
     Réputation/Trésorerie/Confiance dans un même objet "jauge"), row_id est
@@ -35,7 +35,7 @@ def _read_field_value(slug, definition_id, row_id, field_name):
     definition = db.get_definition(slug, int(definition_id))
     if not definition:
         return None
-    rows = db.list_rows(slug, definition)
+    rows = db.list_rows(slug, definition, player_id)
     if not rows:
         return None
     row = None
@@ -95,7 +95,8 @@ def _render_jauge(el, meta, slug, children_map=None, ctx=None, parent_flex_direc
     couleur_haute = attrs.get("_couleur_haute") or "#4caf50"
     afficher_valeur = attrs.get("_afficher_valeur") == "1"
 
-    raw_value = _read_field_value(slug, definition_id, row_id, field_name) if field_name else None
+    player_id = (ctx or {}).get("_forge_player_id", db.PLAYER_SHARED)
+    raw_value = _read_field_value(slug, definition_id, row_id, field_name, player_id) if field_name else None
     try:
         value = float(raw_value)
     except (TypeError, ValueError):
@@ -116,7 +117,7 @@ def _render_jauge(el, meta, slug, children_map=None, ctx=None, parent_flex_direc
 
     name_html = ""
     if field_name_nom:
-        nom_value = _read_field_value(slug, definition_id, row_id, field_name_nom)
+        nom_value = _read_field_value(slug, definition_id, row_id, field_name_nom, player_id)
         if nom_value not in (None, ""):
             text_align = "left" if (nom_position == "dessus" and nom_alignement == "gauche") else "center"
             name_html = (

screens/rendering/render_repeater.py

@@ -30,8 +30,9 @@ def _render_repeater(el, meta, slug, children_map, ctx=None, parent_flex_directi
         return f'<div id="{_auto_id(el)}" data-element-id="{el["id"]}" style="{html_lib.escape(style)}"><em>Objet introuvable — a-t-il été supprimé ?</em></div>'
     # (definition_attr est ajouté au conteneur du Répéteur plus bas, une fois
     # qu'on sait que l'objet est valide.)
-    rows = db.list_rows(slug, definition)
-    rows = filter_repeater_rows(slug, definition, rows, attrs_raw)
+    player_id = (ctx or {}).get("_forge_player_id", db.PLAYER_SHARED)
+    rows = db.list_rows(slug, definition, player_id)
+    rows = filter_repeater_rows(slug, definition, rows, attrs_raw, player_id)
     field_cols = {f["name"]: _field_column(definition, f["name"]) for f in definition["fields"]}
 
     # Modèle de ligne = un élément de jeu (conteneur stylisé réutilisable) :

screens/rendering/resolve_bound_row.py

@@ -4,7 +4,7 @@ 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):
+def _resolve_bound_row_ctx(slug, attrs, player_id=db.PLAYER_SHARED):
     """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 conditions
@@ -27,9 +27,9 @@ def _resolve_bound_row_ctx(slug, attrs):
         return None
     if not definition:
         return None
-    rows = db.list_rows(slug, definition)
+    rows = db.list_rows(slug, definition, player_id)
     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)
+    rows = filter_rows_by_clauses(slug, definition, rows, clauses, combinator, player_id)
     if not rows:
         return None
     row = rows[0]

screens/rendering/visibility_condition.py

@@ -26,17 +26,18 @@ def is_element_visible(slug, attrs, ctx=None):
     pas dans ctx et on retombe sur la convention "1 seule ligne = état de
     partie" (déjà utilisée par la Jauge/Donnée liée) : la ligne la plus
     récente de l'objet choisi."""
+    player_id = (ctx or {}).get("_forge_player_id", db.PLAYER_SHARED)
     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 "")
+    expected = _resolve_filter_value(slug, attrs.get("_visibilite_cond_valeur") or "", player_id)
 
     if mode == "variable":
         var_name = attrs.get("_visibilite_cond_variable")
         if not var_name:
             return True
-        variable = db.get_global_variable(slug, var_name)
+        variable = db.get_global_variable(slug, var_name, player_id)
         if not variable:
             return True  # variable supprimée depuis : ne bloque jamais l'affichage
         value = variable.get("value")
@@ -61,7 +62,7 @@ def is_element_visible(slug, attrs, ctx=None):
     if ctx and field_name in ctx:
         return _compare(ctx.get(field_name), operator, expected, field_type)
 
-    rows = db.list_rows(slug, definition)
+    rows = db.list_rows(slug, definition, player_id)
     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