Forge-Engine/publish/build_package.py

"""Assemble le zip exporté d'un jeu (bouton "Publier", voir
routes/publish/publish_game.py) : un dossier autonome contenant Python
portable + Flask (vendorés une fois, voir vendor_runtime.py), une copie
figée du jeu (screens/db/filters/core minimal + templates/play.html +
le sous-ensemble utile de static/), sa base SQLite et ses fichiers
envoyés (uploads/), et les scripts de lancement (player_app.py/run.bat).

Ne modifie JAMAIS les fichiers réels de l'app (tout se passe dans un
dossier de travail temporaire, supprimé après envoi de la réponse) ni la
vraie base de données du jeu (copiée, jamais déplacée)."""
import os
import shutil
import tempfile
import zipfile

import db
import screens

from . import vendor_runtime

_PUBLISH_DIR = os.path.dirname(os.path.abspath(__file__))
_BASE_DIR = os.path.dirname(_PUBLISH_DIR)

# Sous-ensemble de static/ réellement nécessaire au mode jouable (voir
# templates/play.html) — jamais les assets propres à l'éditeur seul
# (icônes de l'interface de l'éditeur mises à part, déjà dans icons/).
_STATIC_ITEMS = ["style.css", "csrf_fetch.js", "icons", "branding", "vendor/fonts", "vendor/animate.min.css", "js/play", "characters"]

_SLUG_PLACEHOLDER = "_SLUG_PLACEHOLDER"


def _copy_characters(static_dir, used_forge_characters):
    """`static/characters/` contient 2 rangements bien distincts (voir le
    plan "Bibliothèque de sprites animaux CraftPix") : le rangement plat
    Kenney (`<slug>/*.png`, CC0, ~6 Mo, toujours copié comme avant) et
    `animals/<animal>/<NN>/` (CraftPix, ~1,5-2 Go pour les 210 variantes)
    — celui-ci copié SÉLECTIVEMENT, seulement les dossiers (animal, NN)
    correspondant aux personnages `animal-<animal>-<NN>` réellement
    utilisés par CE jeu (used_forge_characters), pour ne pas gonfler
    CHAQUE .zip exporté du poids de toute la bibliothèque. manifest.json
    est toujours copié : screens/labels/animal_sprite_library.py le lit à
    l'import, sans lui `screens` (copié intégralement juste après) ne
    s'importerait plus dans le paquet exporté."""
    src_root = os.path.join(_BASE_DIR, "static", "characters")
    dst_root = os.path.join(static_dir, "characters")
    for name in os.listdir(src_root):
        if name == "animals":
            continue
        src = os.path.join(src_root, name)
        dst = os.path.join(dst_root, name)
        if os.path.isdir(src):
            shutil.copytree(src, dst)
        else:
            os.makedirs(dst_root, exist_ok=True)
            shutil.copy2(src, dst)

    animals_src_root = os.path.join(src_root, "animals")
    if not os.path.isdir(animals_src_root):
        return
    animals_dst_root = os.path.join(dst_root, "animals")
    os.makedirs(animals_dst_root, exist_ok=True)
    shutil.copy2(os.path.join(animals_src_root, "manifest.json"), os.path.join(animals_dst_root, "manifest.json"))
    used_variants = set()
    for slug in used_forge_characters:
        # slug = "animal-<animal>-<NN>" (voir screens/labels/animal_sprite_library.py) ;
        # ignore silencieusement tout ce qui ne colle pas à ce format —
        # un personnage Kenney (déjà copié ci-dessus) n'a pas ce préfixe.
        if not slug.startswith("animal-"):
            continue
        animal, _, nn = slug[len("animal-"):].rpartition("-")
        if animal:
            used_variants.add((animal, nn))
    for animal, nn in used_variants:
        src = os.path.join(animals_src_root, animal, nn)
        if os.path.isdir(src):
            shutil.copytree(src, os.path.join(animals_dst_root, animal, nn))


def _copy_engine_sources(staging_dir, slug):
    """Copie la partie du moteur nécessaire au mode jouable SEUL (jamais
    l'éditeur ni l'authentification — voir le constat d'exploration dans
    le plan : screens/ et db/ sont déjà totalement découplés de auth//
    routes/, core/flask_app.py et core/jinja_filters.py sont les 2 SEULS
    fichiers de core/ dont ils dépendent réellement)."""
    for pkg in ("screens", "db", "filters"):
        shutil.copytree(os.path.join(_BASE_DIR, pkg), os.path.join(staging_dir, pkg),
                         ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))

    core_dir = os.path.join(staging_dir, "core")
    os.makedirs(core_dir, exist_ok=True)
    for fname in ("__init__.py", "flask_app.py", "jinja_filters.py"):
        shutil.copy2(os.path.join(_BASE_DIR, "core", fname), os.path.join(core_dir, fname))

    templates_dir = os.path.join(staging_dir, "templates")
    os.makedirs(templates_dir, exist_ok=True)
    shutil.copy2(os.path.join(_BASE_DIR, "templates", "play.html"), os.path.join(templates_dir, "play.html"))

    static_dir = os.path.join(staging_dir, "static")
    used_forge_characters = screens.list_used_forge_characters(slug)
    for item in _STATIC_ITEMS:
        if item == "characters":
            _copy_characters(static_dir, used_forge_characters)
            continue
        src = os.path.join(_BASE_DIR, "static", item)
        dst = os.path.join(static_dir, item)
        os.makedirs(os.path.dirname(dst), exist_ok=True)
        if os.path.isdir(src):
            shutil.copytree(src, dst)
        else:
            shutil.copy2(src, dst)


def _copy_game_data(staging_dir, slug):
    """Copie le dossier RÉEL du jeu (game.db + uploads/, voir
    db.game_dir) tel quel — jamais déplacé, jamais modifié."""
    src = db.game_dir(slug)
    dst = os.path.join(staging_dir, "projects", slug)
    shutil.copytree(src, dst, ignore=shutil.ignore_patterns("index.html", "index.css", "index.js"))


def _write_player_app(staging_dir, slug):
    template_path = os.path.join(_PUBLISH_DIR, "player_app_template.py")
    with open(template_path, encoding="utf-8") as f:
        content = f.read()
    content = content.replace(_SLUG_PLACEHOLDER, slug)
    with open(os.path.join(staging_dir, "player_app.py"), "w", encoding="utf-8") as f:
        f.write(content)


def _write_run_bat(staging_dir):
    src = os.path.join(_PUBLISH_DIR, "run_bat_template.bat")
    shutil.copy2(src, os.path.join(staging_dir, "run.bat"))


def _zip_dir(staging_dir, zip_path):
    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
        for root, _dirs, files in os.walk(staging_dir):
            for name in files:
                full = os.path.join(root, name)
                rel = os.path.relpath(full, staging_dir)
                zf.write(full, rel)


def build_game_zip(slug):
    """Construit le zip et renvoie son chemin (dans un dossier temporaire
    — à l'appelant de le supprimer une fois la réponse HTTP envoyée, voir
    routes/publish/publish_game.py)."""
    game = db.game_meta(slug)
    python_dir, pylibs_dir = vendor_runtime.ensure_vendor_ready()

    staging_dir = tempfile.mkdtemp(prefix="forge_publish_")
    try:
        shutil.copytree(python_dir, os.path.join(staging_dir, "python-embed"))
        shutil.copytree(pylibs_dir, os.path.join(staging_dir, "python-embed", "pylibs"))
        _copy_engine_sources(staging_dir, slug)
        _copy_game_data(staging_dir, slug)
        _write_player_app(staging_dir, slug)
        _write_run_bat(staging_dir)

        zip_fd, zip_path = tempfile.mkstemp(prefix="forge_publish_", suffix=".zip")
        os.close(zip_fd)
        _zip_dir(staging_dir, zip_path)
    finally:
        shutil.rmtree(staging_dir, ignore_errors=True)
    return zip_path, game["name"]