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>

tests/test_player_state.py

@@ -0,0 +1,108 @@
+"""Tests de la couche db/ pour l'état par joueur (Phase 1 du plan
+d'extension du moteur) : une variable globale/un objet marqué per_player=1
+(par défaut) donne une valeur/des lignes indépendantes par joueur ; marqué
+per_player=0, la valeur/les lignes restent partagées entre tous les
+joueurs. L'aperçu créateur (PLAYER_SHARED, le défaut de tous les
+paramètres player_id) doit continuer de fonctionner exactement comme
+avant ces changements — voir tests/test_confort.py, test_flow.py etc., qui
+n'ont pas eu besoin d'être modifiés."""
+import db
+
+
+def test_global_variable_per_player_gives_independent_values(game):
+    db.create_global_variable(game, "score", "nombre_entier", "0", per_player=True)
+    db.update_global_variable_value(game, "score", "10", player_id="alice")
+    db.update_global_variable_value(game, "score", "99", player_id="bob")
+
+    assert db.get_global_variable(game, "score", player_id="alice")["value"] == "10"
+    assert db.get_global_variable(game, "score", player_id="bob")["value"] == "99"
+    # Le créateur (PLAYER_SHARED, la ligne "modèle") garde la valeur par
+    # défaut — jamais écrasée par les joueurs.
+    assert db.get_global_variable(game, "score")["value"] == "0"
+
+
+def test_global_variable_new_player_falls_back_to_default_value(game):
+    db.create_global_variable(game, "vies", "nombre_entier", "3", per_player=True)
+    assert db.get_global_variable(game, "vies", player_id="charlie")["value"] == "3"
+
+
+def test_global_variable_shared_ignores_player_id(game):
+    db.create_global_variable(game, "compteur_visites", "nombre_entier", "0", per_player=False)
+    db.update_global_variable_value(game, "compteur_visites", "1", player_id="alice")
+    db.update_global_variable_value(game, "compteur_visites", "2", player_id="bob")
+    # Même valeur pour tout le monde, y compris un 3e joueur qui n'a jamais écrit.
+    assert db.get_global_variable(game, "compteur_visites", player_id="alice")["value"] == "2"
+    assert db.get_global_variable(game, "compteur_visites", player_id="bob")["value"] == "2"
+    assert db.get_global_variable(game, "compteur_visites", player_id="charlie")["value"] == "2"
+
+
+def test_global_variable_list_only_shows_template_row(game):
+    db.create_global_variable(game, "score", "nombre_entier", "0", per_player=True)
+    db.update_global_variable_value(game, "score", "10", player_id="alice")
+    variables = db.list_global_variables(game)
+    assert len(variables) == 1
+    assert variables[0]["value"] == "0"
+
+
+def test_global_variable_delete_by_id_cascades_all_players(game):
+    var_id = db.create_global_variable(game, "score", "nombre_entier", "0", per_player=True)
+    db.update_global_variable_value(game, "score", "10", player_id="alice")
+    db.delete_global_variable_by_id(game, var_id)
+    assert db.get_global_variable(game, "score", player_id="alice") is None
+    assert db.get_global_variable(game, "score") is None
+
+
+def test_object_per_player_gives_independent_rows(game):
+    definition_id = db.create_definition(
+        game, "Inventaire", [{"name": "objet", "type": "texte", "required": False}], per_player=True
+    )
+    definition = db.get_definition(game, definition_id)
+    db.insert_row(game, definition, {"objet": "épée"}, player_id="alice")
+    db.insert_row(game, definition, {"objet": "bouclier"}, player_id="bob")
+
+    alice_rows = db.list_rows(game, definition, player_id="alice")
+    bob_rows = db.list_rows(game, definition, player_id="bob")
+    assert [r["objet"] for r in alice_rows] == ["épée"]
+    assert [r["objet"] for r in bob_rows] == ["bouclier"]
+    # Un nouveau joueur qui n'a encore rien démarre VIDE (pas de valeur par
+    # défaut à copier pour une LISTE, contrairement à une variable scalaire).
+    assert db.list_rows(game, definition, player_id="charlie") == []
+
+
+def test_object_shared_gives_same_rows_to_every_player(game):
+    definition_id = db.create_definition(
+        game, "Catalogue", [{"name": "nom", "type": "texte", "required": False}], per_player=False
+    )
+    definition = db.get_definition(game, definition_id)
+    db.insert_row(game, definition, {"nom": "Potion"})
+    alice_rows = db.list_rows(game, definition, player_id="alice")
+    bob_rows = db.list_rows(game, definition, player_id="bob")
+    assert [r["nom"] for r in alice_rows] == ["Potion"]
+    assert [r["nom"] for r in bob_rows] == ["Potion"]
+
+
+def test_get_row_does_not_leak_across_players(game):
+    definition_id = db.create_definition(
+        game, "Inventaire", [{"name": "objet", "type": "texte", "required": False}], per_player=True
+    )
+    definition = db.get_definition(game, definition_id)
+    row_id = db.insert_row(game, definition, {"objet": "épée"}, player_id="alice")
+    # Bob ne doit jamais pouvoir lire/modifier/supprimer la ligne d'Alice,
+    # même en devinant son row_id (garde-fou de sécurité pour la route
+    # publique /jouer/<slug>).
+    assert db.get_row(game, definition, row_id, player_id="bob") is None
+    db.update_row_field(game, definition, row_id, definition["fields"][0], "hache", player_id="bob")
+    assert db.get_row(game, definition, row_id, player_id="alice")["objet"] == "épée"
+    db.delete_row(game, definition, row_id, player_id="bob")
+    assert db.get_row(game, definition, row_id, player_id="alice") is not None
+
+
+def test_creator_preview_default_matches_shared_definition_behavior(game):
+    """L'aperçu créateur (aucun player_id passé nulle part, donc
+    PLAYER_SHARED partout) doit continuer de fonctionner exactement comme
+    avant l'état par joueur — un seul appelant, un seul jeu de lignes."""
+    definition_id = db.create_definition(game, "Notes", [{"name": "texte", "type": "texte", "required": False}])
+    definition = db.get_definition(game, definition_id)
+    db.insert_row(game, definition, {"texte": "bonjour"})
+    rows = db.list_rows(game, definition)
+    assert [r["texte"] for r in rows] == ["bonjour"]