williamandClaude Sonnet 5
236d6b4b46
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>
70 lines
3.1 KiB
Python
70 lines
3.1 KiB
Python
from ..connection import connect
|
|
from ..constants import FIELD_TYPES
|
|
from ..quote_ident import quote_ident
|
|
from ..slugify import slugify
|
|
from ..table_name_for import table_name_for
|
|
from .get_definition import get_definition
|
|
from .ensure_field_bounds_schema import ensure_field_bounds_schema
|
|
|
|
|
|
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).
|
|
|
|
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, per_player) VALUES (?, ?, ?)",
|
|
(name, tname, 1 if per_player else 0),
|
|
)
|
|
definition_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
|
|
|
|
columns_sql = ["id INTEGER PRIMARY KEY AUTOINCREMENT"]
|
|
for pos, f in enumerate(fields):
|
|
fname = slugify(f["name"]).replace("-", "_")
|
|
ftype = f["type"]
|
|
required = 1 if f.get("required") else 0
|
|
relation_definition_id = None
|
|
|
|
if ftype == "relation":
|
|
related = get_definition(slug, int(f["relation_definition_id"]))
|
|
col = f"{fname}_id"
|
|
columns_sql.append(
|
|
f"{quote_ident(col)} INTEGER REFERENCES {related['table_name']}(id)"
|
|
)
|
|
relation_definition_id = related["id"]
|
|
else:
|
|
sql_type = FIELD_TYPES[ftype]["sql"]
|
|
not_null = " NOT NULL" if required else ""
|
|
columns_sql.append(f"{quote_ident(fname)} {sql_type}{not_null}")
|
|
|
|
min_value = f.get("min_value") if ftype in ("nombre_entier", "nombre_decimal") else None
|
|
max_value = f.get("max_value") if ftype in ("nombre_entier", "nombre_decimal") else None
|
|
conn.execute(
|
|
"""INSERT INTO _fields
|
|
(definition_id, name, type, relation_definition_id, required, position, min_value, max_value)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
|
|
(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)
|
|
conn.commit()
|
|
conn.close()
|
|
return definition_id
|