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/data_actions/apply_data_action.py

@@ -3,12 +3,14 @@ import db
 from .compute_operation import compute_new_value
 
 
-def apply_data_action(slug, action):
+def apply_data_action(slug, action, player_id=db.PLAYER_SHARED):
     """Exécute au moment du clic (mode jouable) une action "modifier_donnee" :
     lit l'objet/la ligne/le champ visés dans l'action, calcule la nouvelle
     valeur selon l'opération choisie, et l'enregistre — un vrai UPDATE SQL,
     limité à cette seule colonne (les autres champs de la ligne ne sont pas
-    touchés)."""
+    touchés). `player_id` (état par joueur, Phase 1) : la ligne visée doit
+    appartenir à CE joueur pour un objet per_player (voir get_row.py/
+    update_row_field.py — garde-fou contre un row_id d'un autre joueur)."""
     definition_id = action.get("target_definition_id")
     row_id = action.get("target_row_id")
     field_name = action.get("target_field")
@@ -22,7 +24,7 @@ def apply_data_action(slug, action):
     field_def = next((f for f in definition["fields"] if f["name"] == field_name), None)
     if not field_def:
         return False
-    row = db.get_row(slug, definition, row_id)
+    row = db.get_row(slug, definition, row_id, player_id)
     if not row:
         return False
     col = db.slugify(field_def["name"]).replace("-", "_")
@@ -36,7 +38,7 @@ def apply_data_action(slug, action):
         return False
 
     new_value = _clamp_to_field_bounds(new_value, field_def)
-    db.update_row_field(slug, definition, row_id, field_def, new_value)
+    db.update_row_field(slug, definition, row_id, field_def, new_value, player_id)
     return True
 
 

screens/data_actions/apply_variable_action.py

@@ -3,18 +3,19 @@ import db
 from .compute_operation import compute_new_value
 
 
-def apply_variable_action(slug, action):
+def apply_variable_action(slug, action, player_id=db.PLAYER_SHARED):
     """Exécute au moment du clic (mode jouable) une action
     "modifier_variable" — même logique/vocabulaire d'opérations que
     apply_data_action.py (DATA_OPERATIONS), appliqué à une variable globale
-    (une seule valeur pour tout le jeu) plutôt qu'au champ d'une ligne
-    d'objet."""
+    plutôt qu'au champ d'une ligne d'objet. `player_id` (état par joueur,
+    Phase 1) : pour une variable per_player, lit/écrit la valeur propre à
+    CE joueur (voir db/global_vars/resolve_player_key.py)."""
     var_name = action.get("target_variable")
     operation = action.get("data_operation")
     raw_value = action.get("data_value")
     if not (var_name and operation):
         return False
-    variable = db.get_global_variable(slug, var_name)
+    variable = db.get_global_variable(slug, var_name, player_id)
     if not variable:
         return False
     var_type = variable["type"]
@@ -32,4 +33,4 @@ def apply_variable_action(slug, action):
     except ValueError:
         return False
 
-    return db.update_global_variable_value(slug, var_name, new_value)
+    return db.update_global_variable_value(slug, var_name, new_value, player_id)

screens/elements/list_elements.py

@@ -6,7 +6,7 @@ from ..rendering.render_element_html import render_element_html
 from ..element_types.is_overlay_only import _is_overlay_only_element_type
 
 
-def list_elements(slug, screen_id, enforce_visibility=False):
+def list_elements(slug, screen_id, enforce_visibility=False, player_id=db.PLAYER_SHARED):
     """Renvoie TOUS les éléments de l'écran, à plat (parent_id indique
     l'imbrication) — pratique pour construire l'arbre côté appelant. CHAQUE
     élément (premier niveau ou imbriqué) reçoit son propre "rendered_html" :
@@ -28,7 +28,13 @@ def list_elements(slug, screen_id, enforce_visibility=False):
     full_game_payload.py) — applique la "condition de visibilité" de chaque
     élément (voir visibility_condition.py). Toujours False pour l'éditeur,
     qui doit continuer à montrer/sélectionner un élément même si sa
-    condition serait actuellement fausse."""
+    condition serait actuellement fausse.
+
+    player_id (état par joueur, Phase 1) : posé dans ctx["_forge_player_id"]
+    pour tout le rendu en aval (Répéteur/Jauge/Donnée liée/condition de
+    visibilité) — quel joueur consulte cet écran, pour qu'un objet/une
+    variable per_player affiche SA valeur (voir db/global_vars/,
+    db/rows/)."""
     conn = db.connect(slug)
     rows = conn.execute(
         "SELECT * FROM _screen_elements WHERE screen_id = ? ORDER BY z_index, id", (screen_id,)
@@ -74,7 +80,7 @@ def list_elements(slug, screen_id, enforce_visibility=False):
     for d in result:
         if d.get("parent_id"):
             children_map.setdefault(d["parent_id"], []).append(d)
-    play_ctx = {"_forge_play_mode": True} if enforce_visibility else None
+    play_ctx = {"_forge_play_mode": True, "_forge_player_id": player_id} if enforce_visibility else None
     for d in result:
         # Un exemplaire de premier niveau d'un élément de jeu dont le
         # modèle N'EST QU'une superposition : son cadre de positionnement

screens/payload/full_game_payload.py

@@ -8,21 +8,28 @@ from ..animations.list_animation_clips import list_animation_clips
 from ..element_types.list_element_types import list_element_types
 
 
-def full_game_payload(slug):
+def full_game_payload(slug, player_id=db.PLAYER_SHARED):
     """Toutes les données nécessaires au runtime JS de la page de jeu jouable
-    (/game/<slug>/play) : chaque écran avec ses éléments (HTML déjà généré,
-    y compris les Répéteurs de données, lus en direct), le graphe de logique
-    (nœuds + fils) de chaque écran, et un instantané des données du jeu
-    (avec le type de chaque champ, nécessaire pour évaluer une condition
-    correctement) — un seul aller-retour serveur, ensuite tout se joue côté
-    client (aucune navigation ne recharge la page, sauf pour appliquer une
-    action "modifier une donnée", qui doit passer par le serveur)."""
+    (/game/<slug>/play, ou /jouer/<slug> — voir routes/public_play/) : chaque
+    écran avec ses éléments (HTML déjà généré, y compris les Répéteurs de
+    données, lus en direct), le graphe de logique (nœuds + fils) de chaque
+    écran, et un instantané des données du jeu (avec le type de chaque
+    champ, nécessaire pour évaluer une condition correctement) — un seul
+    aller-retour serveur, ensuite tout se joue côté client (aucune
+    navigation ne recharge la page, sauf pour appliquer une action "modifier
+    une donnée", qui doit passer par le serveur).
+
+    player_id (état par joueur, Phase 1) : PLAYER_SHARED pour l'aperçu
+    créateur (comportement inchangé — une seule partie partagée pendant la
+    conception), l'identifiant réel du visiteur pour une partie publique
+    (voir core/player_identity.py) — chaque objet/variable per_player
+    renvoie alors la valeur propre à CE joueur."""
     screens_ = list_screens(slug)
     payload_screens = []
     flows = {}
     animations = {}
     for s in screens_:
-        elements = list_elements(slug, s["id"], enforce_visibility=True)
+        elements = list_elements(slug, s["id"], enforce_visibility=True, player_id=player_id)
         payload_screens.append({**s, "elements": elements})
 
     # Le graphe de logique et les animations sont, eux, lus pour TOUS les
@@ -50,7 +57,7 @@ def full_game_payload(slug):
     fields_meta = {}
     for d in definitions:
         full = db.get_definition(slug, d["id"])
-        rows = db.list_rows(slug, full)
+        rows = db.list_rows(slug, full, player_id)
         cols = {f["name"]: db.slugify(f["name"]).replace("-", "_") for f in full["fields"]}
         data[str(d["id"])] = [
             {**{fname: r.get(col) for fname, col in cols.items()}, "id": r["id"]}
@@ -73,7 +80,10 @@ def full_game_payload(slug):
     # SERVEUR au rendu (filter_repeater_rows.py) et n'a jamais eu besoin de
     # ça. refreshRuntimeData() récupère un payload entier (donc des
     # variables à jour) après toute action qui en modifie une.
-    variables = {v["name"]: {"value": v["value"], "type": v["type"]} for v in db.list_global_variables(slug)}
+    variables = {
+        v["name"]: {"value": v["value"], "type": v["type"]}
+        for v in db.list_global_variables_for_player(slug, player_id)
+    }
 
     return {
         "screens": payload_screens, "flows": flows, "animations": animations,

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