146 lines
6.6 KiB
Python
146 lines
6.6 KiB
Python
#!/usr/bin/env python3
|
|
"""Build the dependency-free Ravenous Effects Library static site."""
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import re
|
|
import shutil
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
import yaml
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
WEB = ROOT / "effects_web"
|
|
SRC = WEB / "src"
|
|
SOURCE = ROOT / "ravenous_typst/data/src/glossaries/alterations.yaml"
|
|
sys.path.insert(0, str(ROOT))
|
|
from tools.build import (_replace_balanced_calls, effect_reminder_metadata, # noqa: E402
|
|
read_glossary_labels, read_theme_palettes, translate_typst)
|
|
|
|
|
|
def translate_alteration(text: str, glossary: dict[str, str]) -> str:
|
|
"""Render alteration-only macros before the shared conservative translator."""
|
|
text = re.sub(r'#reference\(<[^>]+>,\s*fallback:\s*\[([^]]+)]\)', r'\1', text)
|
|
|
|
def alteration_mark(arguments: str) -> str:
|
|
positional = re.findall(r'(?<!:\s)\[([^]]*)]', arguments)
|
|
if len(positional) < 4:
|
|
raise ValueError("alteration-mark requires four positional arguments")
|
|
recovery = re.search(r'recovery\s*:\s*\[([^]]*)]', arguments)
|
|
trigger = re.search(r'trigger\s*:\s*"([^"]*)"', arguments)
|
|
duration = re.search(r'duration\s*:\s*(\d+)', arguments)
|
|
cumulative = re.search(r'cumulative\s*:\s*true', arguments)
|
|
maximum = re.search(r'maximum\s*:\s*(\d+)', arguments)
|
|
name, mark_type, placement, effect = positional[:4]
|
|
trigger_text = trigger.group(1) if trigger else "subissez"
|
|
duration_value = int(duration.group(1)) if duration else 2
|
|
turn_word = "tour" if duration_value == 1 else "tours"
|
|
parts = [
|
|
mark_type,
|
|
f"À chaque fois que vous {trigger_text} un effet de {name}, placez une marque {name} {placement}.",
|
|
f"À la fin de votre tour, {effect}",
|
|
f"Chaque marque dure {duration_value} {turn_word}.",
|
|
]
|
|
if recovery:
|
|
parts.append(f"Vous perdez cette altération {recovery.group(1)}.")
|
|
if cumulative:
|
|
parts.append(f"À chaque fois que vous gagnez une nouvelle marque {name}, réinitialisez la durée de cette altération.")
|
|
if maximum:
|
|
parts.append(f"Vous pouvez posséder jusqu'à {maximum.group(1)} marques {name} maximum.")
|
|
return " ".join(parts)
|
|
|
|
return translate_typst(_replace_balanced_calls(text, "alteration-mark", alteration_mark), glossary)
|
|
|
|
|
|
def effects_catalog() -> list[dict]:
|
|
glossary = read_glossary_labels()
|
|
rows = yaml.safe_load(SOURCE.read_text(encoding="utf-8")) or []
|
|
effects = []
|
|
for row in rows:
|
|
key = str(row.get("key", "")).strip()
|
|
if not key.startswith("al_") or row.get("group") == "Types d'altérations":
|
|
continue
|
|
custom = row.get("custom") if isinstance(row.get("custom"), dict) else {}
|
|
raw_description = str(row.get("description", ""))
|
|
description = translate_alteration(raw_description, glossary)
|
|
category = translate_typst(str(custom.get("category", "")), glossary)
|
|
timing = effect_reminder_metadata(description)
|
|
effects.append({
|
|
"id": key, "effect_id": key, "name": str(row.get("short") or key),
|
|
"group": str(row.get("group") or "Altérations"),
|
|
"description": description, "resisted_by": str(custom.get("resisted_by", "")),
|
|
"difficulty": custom.get("difficulty", ""), "category": category,
|
|
"type": "alteration", "enabled": True,
|
|
"duration": "", "duration_type": timing.get("duration_type", "manual"),
|
|
"remaining": timing.get("remaining", 0),
|
|
"countdown_phase": timing.get("countdown_phase", "end"),
|
|
"start_reminder": timing.get("start_reminder", ""),
|
|
"end_reminder": timing.get("end_reminder", ""),
|
|
"apply_reminder": "", "removal_reminder": "",
|
|
})
|
|
return effects
|
|
|
|
|
|
def theme_css(palettes: dict[str, dict[str, str]]) -> str:
|
|
keys = {"ink": "ink", "muted": "muted-ink", "gold": "gold", "dark-gold": "dark-gold",
|
|
"paper": "parchment", "surface": "parchment-light", "accent": "parchment-accent",
|
|
"border": "border", "blood": "blood"}
|
|
return "\n".join(
|
|
f'[data-theme="{name}"]{{' + "".join(f"--{css}:{palette[source].lower()};" for css, source in keys.items()) + "}"
|
|
for name, palette in palettes.items()
|
|
)
|
|
|
|
|
|
def generated_files() -> dict[str, str]:
|
|
effects = effects_catalog()
|
|
palettes = read_theme_palettes()
|
|
packed = json.dumps({"version": 1, "effects": effects, "themes": list(palettes)},
|
|
ensure_ascii=False, separators=(",", ":"))
|
|
digest = hashlib.sha256(packed.encode("utf-8")).hexdigest()[:12]
|
|
replacements = {
|
|
"{{THEME_OPTIONS}}": "".join(f'<option value="{name}">{name.replace("-", " ").title()}</option>' for name in palettes),
|
|
"{{THEME_CSS}}": theme_css(palettes), "{{CATALOG_HASH}}": digest,
|
|
}
|
|
files = {}
|
|
for name in ("index.html", "styles.css", "app.js"):
|
|
content = (SRC / name).read_text(encoding="utf-8")
|
|
for marker, value in replacements.items():
|
|
content = content.replace(marker, value)
|
|
files[name] = content
|
|
files["catalog.js"] = "window.RAVENOUS_EFFECTS_CATALOG=" + packed + ";\n"
|
|
files["ravenous-effects-v1.schema.json"] = (WEB / "schemas/ravenous-effects-v1.schema.json").read_text(encoding="utf-8")
|
|
files["build-info.json"] = json.dumps({"catalog_hash": digest, "effects": len(effects),
|
|
"groups": sorted({item["group"] for item in effects}), "themes": list(palettes)},
|
|
ensure_ascii=False, indent=2) + "\n"
|
|
return files
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--output", type=Path, default=WEB / "build")
|
|
parser.add_argument("--check", action="store_true")
|
|
args = parser.parse_args()
|
|
files = generated_files()
|
|
if args.check:
|
|
stale = [name for name, content in files.items()
|
|
if not (args.output / name).is_file() or (args.output / name).read_text(encoding="utf-8") != content]
|
|
if stale:
|
|
raise SystemExit("Effects website files are stale: " + ", ".join(stale))
|
|
print(f"Effects website is current ({len(files)} files).")
|
|
return
|
|
args.output.mkdir(parents=True, exist_ok=True)
|
|
for old in args.output.iterdir():
|
|
if old.is_file():
|
|
old.unlink()
|
|
elif old.is_dir():
|
|
shutil.rmtree(old)
|
|
for name, content in files.items():
|
|
(args.output / name).write_text(content, encoding="utf-8")
|
|
print(f"Built effects website: {len(files)} files, {len(effects_catalog())} effects.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|