Forge-Engine/screens/payload/full_game_payload.py

import db

from ..screens_repo.list_screens import list_screens
from ..elements.list_elements import list_elements
from ..flow.list_flow_nodes import list_flow_nodes
from ..flow.list_flow_edges import list_flow_edges
from ..animations.list_animation_clips import list_animation_clips
from ..element_types.list_element_types import list_element_types
from ..rendering.personnage_data import resolve_personnage_animations


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, 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, player_id=player_id)
        payload_screens.append({**s, "elements": elements})

    # Le graphe de logique et les animations sont, eux, lus pour TOUS les
    # écrans, écrans-modèles compris (include_templates=True) — pas
    # seulement les "vrais" écrans ci-dessus. Un élément de jeu réutilisable
    # (ex. "mail content") peut avoir son propre déclencheur/sa propre
    # animation posée dans l'éditeur de SON écran-modèle (voir
    # screen_edit.html) : sans ses entrées ici, gameData.flows/
    # gameData.animations n'auraient jamais contenu cet écran-modèle côté
    # client, et findTriggerNode()/collectAnimationClips() (templates/
    # play.html) — pourtant déjà écrits pour les chercher — n'auraient
    # jamais rien trouvé. On ne les ajoute PAS à payload_screens : un
    # écran-modèle ne doit jamais être rendu comme un vrai <div
    # class="playScreen"> (il n'est jamais affiché tel quel, seulement
    # rechargé en direct à l'intérieur d'un élément qui l'utilise).
    # Animations d'un personnage (Phase 8) — résolues ici, à CHAQUE
    # affichage de la page de jeu (donc toujours à partir du personnage
    # Forge ACTUELLEMENT assigné), plutôt que figées dans le nœud de flow/
    # le clip de Timeline au moment où le créateur les a configurés : sans
    # ça, changer le personnage Forge d'un élément dans l'éditeur laissait
    # ses animations déjà posées dans la logique/la Timeline continuer à
    # jouer les frames de l'ANCIEN personnage indéfiniment (bug signalé —
    # voir runActionNode()/applyAnimationClip() qui font cette résolution
    # à l'exécution à partir de gameData.personnage_animations plutôt que
    # depuis un data_value/custom_keyframes qui contiendrait des frames
    # déjà résolues). include_templates=True : un personnage peut vivre
    # dans un écran-modèle d'élément de jeu réutilisable, comme les flows/
    # animations ci-dessous.
    personnage_animations = {}
    for s in list_screens(slug, include_templates=True):
        flows[str(s["id"])] = {
            "nodes": list_flow_nodes(slug, s["id"]),
            "edges": list_flow_edges(slug, s["id"]),
        }
        animations[str(s["id"])] = list_animation_clips(slug, s["id"])
        for el in list_elements(slug, s["id"]):
            if el.get("widget") == "personnage":
                personnage_animations[str(el["id"])] = resolve_personnage_animations(el)

    definitions = db.list_definitions(slug)
    data = {}
    fields_meta = {}
    for d in definitions:
        full = db.get_definition(slug, d["id"])
        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"]}
            for r in rows
        ]
        fields_meta[str(d["id"])] = [{"name": f["name"], "type": f["type"]} for f in full["fields"]]

    # element_type_id -> id de son écran-modèle : nécessaire côté client (voir
    # collectAnimationClips() dans play.html) pour savoir, quand un élément de
    # jeu réutilisable (ex. "mail content") est posé sur un écran, quels
    # autres clips d'animation (ceux de SON PROPRE écran-modèle) doivent
    # aussi être joués à l'affichage de cet écran — sans quoi une animation
    # posée directement dans l'éditeur du modèle ne se jouait jamais quand le
    # modèle est utilisé ailleurs.
    element_types = {str(t["id"]): t["template_screen_id"] for t in list_element_types(slug)}

    # Instantané des variables globales, pour qu'un nœud Condition puisse en
    # tester une côté CLIENT (evaluateConditionClause, templates/play.html) —
    # {{$var}} (Répéteur/Condition de visibilité), lui, reste résolu côté
    # 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_for_player(slug, player_id)
    }

    return {
        "screens": payload_screens, "flows": flows, "animations": animations,
        "element_types": element_types, "data": data, "fields_meta": fields_meta,
        "variables": variables, "personnage_animations": personnage_animations,
    }