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>

db/__init__.py

@@ -53,7 +53,9 @@ 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.ensure_global_vars_schema import PLAYER_SHARED
 from .global_vars.list_global_variables import list_global_variables
+from .global_vars.list_global_variables_for_player import list_global_variables_for_player
 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
@@ -67,7 +69,7 @@ from .custom_events.create_custom_event import create_custom_event
 from .custom_events.update_custom_event import update_custom_event
 
 __all__ = [
-    "PROJECTS_DIR", "FIELD_TYPES", "GLOBAL_VARIABLE_TYPES",
+    "PROJECTS_DIR", "FIELD_TYPES", "GLOBAL_VARIABLE_TYPES", "PLAYER_SHARED",
     "slugify", "table_name_for", "game_dir", "db_path", "connect",
     "list_games", "game_meta", "create_game", "update_game_name", "delete_game", "move_game",
     "list_definitions", "get_definition", "create_definition", "rename_definition",
@@ -75,7 +77,7 @@ __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",
+    "list_global_variables", "list_global_variables_for_player", "get_global_variable", "create_global_variable",
     "update_global_variable_value", "update_global_variable", "delete_global_variable",
     "delete_global_variable_by_id",
     "list_custom_events", "get_custom_event", "create_custom_event", "update_custom_event",

db/definitions/create_definition.py

@@ -7,18 +7,28 @@ from .get_definition import get_definition
 from .ensure_field_bounds_schema import ensure_field_bounds_schema
 
 
-def create_definition(slug, name, fields):
+def create_definition(slug, name, fields, per_player=True):
     """Feature 2 : crée une définition d'objet (comme une table de BDD) et
     exécute le vrai CREATE TABLE correspondant, avec les bons types de
     colonne, y compris les colonnes de clé étrangère pour les relations
     vers d'autres définitions déjà créées dans CE jeu (une définition peut
-    donc "en contenir" une autre, au sens relationnel)."""
+    donc "en contenir" une autre, au sens relationnel).
+
+    per_player (état par joueur, Phase 1) : True (par défaut) = chaque
+    joueur a ses propres lignes (une table player_id-scopée qui démarre
+    VIDE pour chaque nouveau joueur — pas de valeur par défaut à copier,
+    contrairement à une variable globale, voir
+    db/global_vars/update_global_variable_value.py) ; False = lignes
+    partagées par tous les joueurs (ex. un catalogue/une liste de
+    questions), toujours player_id=PLAYER_SHARED quel que soit le joueur
+    qui consulte."""
     ensure_field_bounds_schema(slug)
     conn = connect(slug)
     tname = table_name_for(name)
 
     conn.execute(
-        "INSERT INTO _definitions (name, table_name) VALUES (?, ?)", (name, tname)
+        "INSERT INTO _definitions (name, table_name, per_player) VALUES (?, ?, ?)",
+        (name, tname, 1 if per_player else 0),
     )
     definition_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
 
@@ -50,6 +60,7 @@ def create_definition(slug, name, fields):
             (definition_id, f["name"], ftype, relation_definition_id, required, pos, min_value, max_value),
         )
 
+    columns_sql.append("player_id TEXT NOT NULL DEFAULT '__shared__'")
     columns_sql.append("created_at TEXT DEFAULT CURRENT_TIMESTAMP")
     create_sql = f"CREATE TABLE {tname} ({', '.join(columns_sql)})"
     conn.execute(create_sql)

db/definitions/ensure_field_bounds_schema.py

@@ -4,13 +4,19 @@ from ..connection import connect
 def ensure_field_bounds_schema(slug):
     """Migration légère (voir screens/screens_repo/ensure_schema.py pour le
     même principe) : ajoute les colonnes min_value/max_value à _fields pour
-    les jeux créés avant le bornage automatique (2.2) — aucune migration
-    manuelle nécessaire, la prochaine lecture d'une définition suffit."""
+    les jeux créés avant le bornage automatique (2.2), et per_player à
+    _definitions pour les jeux créés avant l'état par joueur (Phase 1) —
+    aucune migration manuelle nécessaire, la prochaine lecture d'une
+    définition suffit. per_player=1 par défaut (comportement le plus
+    proche de l'ancien objet-par-défaut : voir create_definition.py)."""
     conn = connect(slug)
     cols = {r["name"] for r in conn.execute("PRAGMA table_info(_fields)").fetchall()}
     if "min_value" not in cols:
         conn.execute("ALTER TABLE _fields ADD COLUMN min_value REAL")
     if "max_value" not in cols:
         conn.execute("ALTER TABLE _fields ADD COLUMN max_value REAL")
+    definition_cols = {r["name"] for r in conn.execute("PRAGMA table_info(_definitions)").fetchall()}
+    if "per_player" not in definition_cols:
+        conn.execute("ALTER TABLE _definitions ADD COLUMN per_player INTEGER NOT NULL DEFAULT 1")
     conn.commit()
     conn.close()

db/global_vars/create_global_variable.py

@@ -1,27 +1,37 @@
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema
+from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
 from .coerce_structured_value import coerce_structured_value
 
 
-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."""
+def create_global_variable(slug, name, var_type="texte", default_value="", per_player=True):
+    """Crée la ligne "modèle" d'une variable globale (toujours
+    player_id=PLAYER_SHARED, quel que soit per_player — voir
+    ensure_global_vars_schema.py) si son nom n'existe pas déjà ; 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.
+
+    per_player (réglé une fois, à la création, coché par défaut) :
+    True = chaque joueur aura sa propre valeur (une ligne créée
+    paresseusement à sa première écriture, voir
+    update_global_variable_value.py) ; False = valeur unique partagée par
+    tous les joueurs (ex. un compteur de visiteurs global)."""
     name = (name or "").strip()
     if not name:
         return None
     default_value = coerce_structured_value(var_type, default_value)
     ensure_global_vars_schema(slug)
     conn = connect(slug)
-    existing = conn.execute("SELECT id FROM _global_variables WHERE name = ?", (name,)).fetchone()
+    existing = conn.execute(
+        "SELECT id FROM _global_variables WHERE name = ? AND player_id = ?", (name, PLAYER_SHARED)
+    ).fetchone()
     if existing:
         conn.close()
         return existing["id"]
     conn.execute(
-        "INSERT INTO _global_variables (name, type, value) VALUES (?, ?, ?)",
-        (name, var_type, default_value),
+        "INSERT INTO _global_variables (name, type, value, player_id, per_player) VALUES (?, ?, ?, ?, ?)",
+        (name, var_type, default_value, PLAYER_SHARED, 1 if per_player else 0),
     )
     new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
     conn.commit()

db/global_vars/delete_global_variable.py

@@ -3,6 +3,9 @@ from .ensure_global_vars_schema import ensure_global_vars_schema
 
 
 def delete_global_variable(slug, name):
+    """Supprime TOUTES les lignes de ce nom, pas seulement la ligne modèle
+    PLAYER_SHARED — une variable per_player peut avoir une ligne par joueur
+    ayant déjà écrit dessus (voir update_global_variable_value.py)."""
     ensure_global_vars_schema(slug)
     conn = connect(slug)
     conn.execute("DELETE FROM _global_variables WHERE name = ?", (name,))

db/global_vars/delete_global_variable_by_id.py

@@ -6,9 +6,15 @@ def delete_global_variable_by_id(slug, var_id):
     """Version par id de delete_global_variable — utilisée par la page de
     gestion des variables (game_variables.html), où chaque ligne connaît son
     id technique mais pas nécessairement un nom encore garanti unique côté
-    formulaire d'URL (espaces, accents...)."""
+    formulaire d'URL (espaces, accents...). Supprime aussi TOUTES les
+    lignes des autres joueurs pour ce même nom (une variable per_player en
+    a une par joueur qui a déjà écrit dessus, voir
+    update_global_variable_value.py) — sans ça, supprimer une variable
+    depuis le tableau de bord laisserait des lignes orphelines."""
     ensure_global_vars_schema(slug)
     conn = connect(slug)
-    conn.execute("DELETE FROM _global_variables WHERE id = ?", (var_id,))
+    row = conn.execute("SELECT name FROM _global_variables WHERE id = ?", (var_id,)).fetchone()
+    if row:
+        conn.execute("DELETE FROM _global_variables WHERE name = ?", (row["name"],))
     conn.commit()
     conn.close()

db/global_vars/ensure_global_vars_schema.py

@@ -1,23 +1,59 @@
 from ..connection import connect
 
+PLAYER_SHARED = "__shared__"
+
 
 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."""
+    crée _global_variables si absente. Depuis l'état par joueur (Phase 1),
+    une variable a une ligne "modèle" créée par le créateur du jeu
+    (player_id=PLAYER_SHARED, voir PLAYER_SHARED ci-dessus), qui porte son
+    réglage per_player (1 = chaque joueur a sa propre valeur, une ligne
+    créée paresseusement à sa première écriture — voir
+    update_global_variable_value.py ; 0 = valeur unique partagée par tous
+    les joueurs, toujours la ligne PLAYER_SHARED elle-même) — "nom" n'est
+    donc plus unique à lui seul, seulement (nom, player_id)."""
     conn = connect(slug)
     conn.execute(
         """
         CREATE TABLE IF NOT EXISTS _global_variables (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL UNIQUE,
+            name TEXT NOT NULL,
             type TEXT NOT NULL DEFAULT 'texte',
             value TEXT,
-            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            player_id TEXT NOT NULL DEFAULT '__shared__',
+            per_player INTEGER NOT NULL DEFAULT 1,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(name, player_id)
         );
         """
     )
+    # SQLite ne permet pas de modifier une contrainte UNIQUE existante via
+    # ALTER TABLE ADD COLUMN — un jeu créé avant la Phase 1 a déjà cette
+    # table, sous l'ancien schéma (UNIQUE(name) seul, sans player_id/
+    # per_player) : reconstruction complète si détecté, chaque variable
+    # existante devenant la ligne "modèle" PLAYER_SHARED, per_player=1 par
+    # défaut (comportement le plus proche de l'ancien : une seule valeur
+    # jusqu'ici, qui devient réellement par-joueur dès la Phase 1 en place).
+    cols = {r["name"] for r in conn.execute("PRAGMA table_info(_global_variables)").fetchall()}
+    if "player_id" not in cols:
+        conn.executescript(
+            """
+            ALTER TABLE _global_variables RENAME TO _global_variables_old;
+            CREATE TABLE _global_variables (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                type TEXT NOT NULL DEFAULT 'texte',
+                value TEXT,
+                player_id TEXT NOT NULL DEFAULT '__shared__',
+                per_player INTEGER NOT NULL DEFAULT 1,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                UNIQUE(name, player_id)
+            );
+            INSERT INTO _global_variables (id, name, type, value, created_at)
+                SELECT id, name, type, value, created_at FROM _global_variables_old;
+            DROP TABLE _global_variables_old;
+            """
+        )
     conn.commit()
     conn.close()

db/global_vars/get_global_variable.py

@@ -1,16 +1,24 @@
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema
+from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
+from .resolve_player_key import resolve_player_key
 
 
-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."""
+def get_global_variable(slug, name, player_id=PLAYER_SHARED):
+    """Par NOM (pas par id — c'est comme ça qu'une variable est référencée
+    partout ailleurs, condition de visibilité, action "Modifier une
+    variable") et par joueur (voir resolve_player_key.py) : une variable
+    per_player renvoie la ligne propre à `player_id`, ou à défaut (ce
+    joueur n'a encore rien écrit) la ligne modèle PLAYER_SHARED, qui porte
+    la valeur par défaut définie à la création."""
     if not name:
         return None
     ensure_global_vars_schema(slug)
     conn = connect(slug)
-    row = conn.execute("SELECT * FROM _global_variables WHERE name = ?", (name,)).fetchone()
+    key = resolve_player_key(conn, name, player_id)
+    row = conn.execute("SELECT * FROM _global_variables WHERE name = ? AND player_id = ?", (name, key)).fetchone()
+    if not row and key != PLAYER_SHARED:
+        row = conn.execute(
+            "SELECT * FROM _global_variables WHERE name = ? AND player_id = ?", (name, PLAYER_SHARED)
+        ).fetchone()
     conn.close()
     return dict(row) if row else None

db/global_vars/list_global_variables.py

@@ -1,10 +1,17 @@
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema
+from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
 
 
 def list_global_variables(slug):
+    """Toujours les lignes MODÈLES (PLAYER_SHARED) — c'est la liste des
+    variables telle que le créateur les a définies dans le tableau de
+    bord, jamais influencée par le nombre de joueurs ayant déjà leur
+    propre valeur pour une variable per_player (voir
+    ensure_global_vars_schema.py)."""
     ensure_global_vars_schema(slug)
     conn = connect(slug)
-    rows = conn.execute("SELECT * FROM _global_variables ORDER BY name").fetchall()
+    rows = conn.execute(
+        "SELECT * FROM _global_variables WHERE player_id = ? ORDER BY name", (PLAYER_SHARED,)
+    ).fetchall()
     conn.close()
     return [dict(r) for r in rows]

db/global_vars/list_global_variables_for_player.py

@@ -0,0 +1,18 @@
+from .ensure_global_vars_schema import PLAYER_SHARED
+from .list_global_variables import list_global_variables
+from .get_global_variable import get_global_variable
+
+
+def list_global_variables_for_player(slug, player_id=PLAYER_SHARED):
+    """Valeur EFFECTIVE de chaque variable pour ce joueur (voir
+    get_global_variable.py : la ligne propre à ce joueur si elle existe
+    déjà, sinon la valeur par défaut de la ligne modèle) — à la différence
+    de list_global_variables() (toujours les lignes modèles, pour le
+    tableau de bord), c'est cette version qu'il faut exposer au runtime
+    jouable (full_game_payload.py), pour qu'une condition évaluée côté
+    client reflète bien l'état RÉEL de CE joueur."""
+    result = []
+    for template in list_global_variables(slug):
+        value = get_global_variable(slug, template["name"], player_id)
+        result.append(value if value else template)
+    return result

db/global_vars/resolve_player_key.py

@@ -0,0 +1,17 @@
+from .ensure_global_vars_schema import PLAYER_SHARED
+
+
+def resolve_player_key(conn, name, player_id):
+    """Détermine le player_id à utiliser RÉELLEMENT pour lire/écrire cette
+    variable : celui du joueur (variable per_player=1, le cas par défaut),
+    ou toujours PLAYER_SHARED (variable explicitement partagée entre tous
+    les joueurs, per_player=0) — décidé par le réglage de la ligne
+    "modèle" créée par le créateur du jeu (voir create_global_variable.py).
+    Une variable encore inconnue (aucune ligne modèle) est traitée comme
+    per_player=1 par défaut."""
+    row = conn.execute(
+        "SELECT per_player FROM _global_variables WHERE name = ? AND player_id = ?",
+        (name, PLAYER_SHARED),
+    ).fetchone()
+    per_player = row["per_player"] if row else 1
+    return player_id if per_player else PLAYER_SHARED

db/global_vars/update_global_variable_value.py

@@ -1,18 +1,38 @@
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema
-from .get_global_variable import get_global_variable
+from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
+from .resolve_player_key import resolve_player_key
 
 
-def update_global_variable_value(slug, name, new_value):
+def update_global_variable_value(slug, name, new_value, player_id=PLAYER_SHARED):
     """É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
+    screens/data_actions/apply_variable_action.py) que par une éventuelle
+    modification directe (page de gestion des variables).
+
+    Pour une variable per_player, la PREMIÈRE écriture de ce joueur crée sa
+    propre ligne (copiée depuis la ligne modèle PLAYER_SHARED — même type/
+    per_player) ; les écritures suivantes mettent juste à jour cette ligne.
+    Une variable per_player=0 écrit toujours la ligne PLAYER_SHARED elle-même
+    (voir resolve_player_key.py)."""
     ensure_global_vars_schema(slug)
     conn = connect(slug)
-    conn.execute("UPDATE _global_variables SET value = ? WHERE name = ?", (str(new_value), name))
+    key = resolve_player_key(conn, name, player_id)
+    existing = conn.execute(
+        "SELECT id FROM _global_variables WHERE name = ? AND player_id = ?", (name, key)
+    ).fetchone()
+    if existing:
+        conn.execute("UPDATE _global_variables SET value = ? WHERE id = ?", (str(new_value), existing["id"]))
+    else:
+        template = conn.execute(
+            "SELECT type, per_player FROM _global_variables WHERE name = ? AND player_id = ?", (name, PLAYER_SHARED)
+        ).fetchone()
+        if not template:
+            conn.close()
+            return False
+        conn.execute(
+            "INSERT INTO _global_variables (name, type, value, player_id, per_player) VALUES (?, ?, ?, ?, ?)",
+            (name, template["type"], str(new_value), key, template["per_player"]),
+        )
     conn.commit()
     conn.close()
     return True

db/rows/delete_row.py

@@ -1,8 +1,12 @@
 from ..connection import connect
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import resolve_row_player_key, PLAYER_SHARED
 
 
-def delete_row(slug, definition, row_id):
+def delete_row(slug, definition, row_id, player_id=PLAYER_SHARED):
+    ensure_player_id_column(slug, definition["table_name"])
+    key = resolve_row_player_key(definition, player_id)
     conn = connect(slug)
-    conn.execute(f"DELETE FROM {definition['table_name']} WHERE id = ?", (row_id,))
+    conn.execute(f"DELETE FROM {definition['table_name']} WHERE id = ? AND player_id = ?", (row_id, key))
     conn.commit()
     conn.close()

db/rows/ensure_player_id_column.py

@@ -0,0 +1,16 @@
+from ..connection import connect
+
+
+def ensure_player_id_column(slug, table_name):
+    """Migration légère (même principe que ensure_field_bounds_schema.py) :
+    ajoute player_id à la table d'un objet créé avant l'état par joueur
+    (Phase 1) — ses lignes existantes deviennent implicitement
+    PLAYER_SHARED (comportement le plus proche de l'ancien : une seule
+    liste jusqu'ici, désormais la liste "partagée" par défaut tant que le
+    créateur n'a rien de plus à faire)."""
+    conn = connect(slug)
+    cols = {r["name"] for r in conn.execute(f"PRAGMA table_info({table_name})").fetchall()}
+    if "player_id" not in cols:
+        conn.execute(f"ALTER TABLE {table_name} ADD COLUMN player_id TEXT NOT NULL DEFAULT '__shared__'")
+        conn.commit()
+    conn.close()

db/rows/get_row.py

@@ -1,10 +1,19 @@
 from ..connection import connect
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import resolve_row_player_key, PLAYER_SHARED
 
 
-def get_row(slug, definition, row_id):
+def get_row(slug, definition, row_id, player_id=PLAYER_SHARED):
+    """Filtre aussi par player_id (pas seulement id) : même si `row_id` est
+    déjà un identifiant unique dans toute la table, ce garde-fou empêche un
+    joueur de lire la ligne d'un AUTRE joueur en devinant/altérant un
+    row_id (garantie utile dès qu'un objet per_player est exposé sur la
+    route publique /jouer/<slug>, voir routes/public_play/)."""
+    ensure_player_id_column(slug, definition["table_name"])
+    key = resolve_row_player_key(definition, player_id)
     conn = connect(slug)
     row = conn.execute(
-        f"SELECT * FROM {definition['table_name']} WHERE id = ?", (row_id,)
+        f"SELECT * FROM {definition['table_name']} WHERE id = ? AND player_id = ?", (row_id, key)
     ).fetchone()
     conn.close()
     return dict(row) if row else None

db/rows/insert_row.py

@@ -1,16 +1,24 @@
 from ..connection import connect
 from ..quote_ident import quote_ident
 from .row_columns_and_values import row_columns_and_values
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import resolve_row_player_key, PLAYER_SHARED
 
 
-def insert_row(slug, definition, form_data):
+def insert_row(slug, definition, form_data, player_id=PLAYER_SHARED):
     """Feature 3 : enregistre en base les données saisies dans le formulaire
     généré à partir de la définition d'objet."""
+    ensure_player_id_column(slug, definition["table_name"])
+    key = resolve_row_player_key(definition, player_id)
     cols, values = row_columns_and_values(definition, form_data)
+    cols = cols + ["player_id"]
+    values = values + [key]
     conn = connect(slug)
     placeholders = ["?"] * len(cols)
     quoted_cols = ", ".join(quote_ident(c) for c in cols)
     sql = f"INSERT INTO {definition['table_name']} ({quoted_cols}) VALUES ({', '.join(placeholders)})"
     conn.execute(sql, values)
+    new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
     conn.commit()
     conn.close()
+    return new_id

db/rows/list_rows.py

@@ -1,8 +1,14 @@
 from ..connection import connect
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import resolve_row_player_key, PLAYER_SHARED
 
 
-def list_rows(slug, definition):
+def list_rows(slug, definition, player_id=PLAYER_SHARED):
+    ensure_player_id_column(slug, definition["table_name"])
+    key = resolve_row_player_key(definition, player_id)
     conn = connect(slug)
-    rows = conn.execute(f"SELECT * FROM {definition['table_name']} ORDER BY id DESC").fetchall()
+    rows = conn.execute(
+        f"SELECT * FROM {definition['table_name']} WHERE player_id = ? ORDER BY id DESC", (key,)
+    ).fetchall()
     conn.close()
     return [dict(r) for r in rows]

db/rows/relation_options.py

@@ -1,13 +1,21 @@
 from ..connection import connect
 from ..slugify import slugify
 from ..definitions.get_definition import get_definition
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import PLAYER_SHARED
 
 
 def relation_options(slug, related_definition_id):
-    """Lignes existantes d'un objet lié, pour peupler un <select> de relation."""
+    """Lignes existantes d'un objet lié, pour peupler un <select> de
+    relation — toujours la vue "modèle"/créateur (PLAYER_SHARED), cette
+    fonction n'est utilisée que côté tableau de bord/éditeur, jamais
+    depuis la route publique /jouer/<slug>."""
     related = get_definition(slug, related_definition_id)
+    ensure_player_id_column(slug, related["table_name"])
     conn = connect(slug)
-    rows = conn.execute(f"SELECT * FROM {related['table_name']} ORDER BY id").fetchall()
+    rows = conn.execute(
+        f"SELECT * FROM {related['table_name']} WHERE player_id = ? ORDER BY id", (PLAYER_SHARED,)
+    ).fetchall()
     conn.close()
     display_field = related["fields"][0]["name"] if related["fields"] else "id"
     display_col = slugify(display_field).replace("-", "_")

db/rows/resolve_row_player_key.py

@@ -0,0 +1,14 @@
+PLAYER_SHARED = "__shared__"
+
+
+def resolve_row_player_key(definition, player_id):
+    """Détermine le player_id à utiliser réellement pour lire/écrire les
+    lignes de cet objet : celui du joueur (objet per_player=1, le cas par
+    défaut — voir create_definition.py), ou toujours PLAYER_SHARED (objet
+    explicitement partagé, per_player=0, ex. un catalogue commun à tous
+    les joueurs). Contrairement à une variable globale (db/global_vars/
+    resolve_player_key.py), pas de repli implicite sur la ligne "modèle" :
+    un objet per_player démarre VIDE pour chaque nouveau joueur, il n'y a
+    pas de valeur par défaut unique à copier pour une LISTE de lignes."""
+    per_player = definition.get("per_player", 1)
+    return player_id if per_player else PLAYER_SHARED

db/rows/rows_referencing.py

@@ -3,6 +3,8 @@ from ..quote_ident import quote_ident
 from ..slugify import slugify
 from ..definitions.definitions_referencing import definitions_referencing
 from ..definitions.get_definition import get_definition
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import PLAYER_SHARED
 
 
 def rows_referencing(slug, definition_id, row_id):
@@ -10,16 +12,19 @@ def rows_referencing(slug, definition_id, row_id):
     qui a une relation vers l'objet de cette ligne, combien de ses lignes
     pointent vers CETTE ligne précise — pour avertir avant une suppression
     qui laisserait des relations orphelines (aucune suppression en cascade
-    n'est faite automatiquement, par sécurité)."""
+    n'est faite automatiquement, par sécurité). Toujours la vue "modèle"/
+    créateur (PLAYER_SHARED), utilisée uniquement côté tableau de bord."""
     refs = []
     for d in definitions_referencing(slug, definition_id):
         full = get_definition(slug, d["id"])
         for f in full["fields"]:
             if f["type"] == "relation" and f["relation_definition_id"] == definition_id:
                 col = slugify(f["name"]).replace("-", "_") + "_id"
+                ensure_player_id_column(slug, full["table_name"])
                 conn = connect(slug)
                 count = conn.execute(
-                    f"SELECT COUNT(*) AS c FROM {full['table_name']} WHERE {quote_ident(col)} = ?", (row_id,)
+                    f"SELECT COUNT(*) AS c FROM {full['table_name']} WHERE {quote_ident(col)} = ? AND player_id = ?",
+                    (row_id, PLAYER_SHARED),
                 ).fetchone()["c"]
                 conn.close()
                 if count:

db/rows/update_row.py

@@ -1,17 +1,23 @@
 from ..connection import connect
 from ..quote_ident import quote_ident
 from .row_columns_and_values import row_columns_and_values
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import resolve_row_player_key, PLAYER_SHARED
 
 
-def update_row(slug, definition, row_id, form_data):
+def update_row(slug, definition, row_id, form_data, player_id=PLAYER_SHARED):
     """CRUD — Update : ré-enregistre une ligne existante avec les nouvelles
-    valeurs saisies dans le même formulaire généré que pour la création."""
+    valeurs saisies dans le même formulaire généré que pour la création.
+    Filtre aussi par player_id (voir get_row.py — même garde-fou contre un
+    row_id d'un autre joueur)."""
+    ensure_player_id_column(slug, definition["table_name"])
+    key = resolve_row_player_key(definition, player_id)
     cols, values = row_columns_and_values(definition, form_data)
     conn = connect(slug)
     set_clause = ", ".join(f"{quote_ident(c)} = ?" for c in cols)
     conn.execute(
-        f"UPDATE {definition['table_name']} SET {set_clause} WHERE id = ?",
-        values + [row_id],
+        f"UPDATE {definition['table_name']} SET {set_clause} WHERE id = ? AND player_id = ?",
+        values + [row_id, key],
     )
     conn.commit()
     conn.close()

db/rows/update_row_field.py

@@ -1,16 +1,24 @@
 from ..connection import connect
 from ..quote_ident import quote_ident
 from ..slugify import slugify
+from .ensure_player_id_column import ensure_player_id_column
+from .resolve_row_player_key import resolve_row_player_key, PLAYER_SHARED
 
 
-def update_row_field(slug, definition, row_id, field_def, new_value):
+def update_row_field(slug, definition, row_id, field_def, new_value, player_id=PLAYER_SHARED):
     """Met à jour UNE SEULE colonne d'une ligne existante — utilisé par les
     actions "Modifier une donnée" du mode jouable, qui ne doivent jamais
     écraser les autres champs de la ligne (contrairement à update_row, qui
-    attend un formulaire complet)."""
+    attend un formulaire complet). Filtre aussi par player_id (voir
+    get_row.py)."""
+    ensure_player_id_column(slug, definition["table_name"])
+    key = resolve_row_player_key(definition, player_id)
     fname = slugify(field_def["name"]).replace("-", "_")
     col = f"{fname}_id" if field_def["type"] == "relation" else fname
     conn = connect(slug)
-    conn.execute(f"UPDATE {definition['table_name']} SET {quote_ident(col)} = ? WHERE id = ?", (new_value, row_id))
+    conn.execute(
+        f"UPDATE {definition['table_name']} SET {quote_ident(col)} = ? WHERE id = ? AND player_id = ?",
+        (new_value, row_id, key),
+    )
     conn.commit()
     conn.close()