ravenous_roll20/craft_web/tools/build.py

224 lines
10 KiB
Python

#!/usr/bin/env python3
"""Build the dependency-free Ravenous Craft Workshop static site."""
import argparse
import csv
import hashlib
import json
import re
import shutil
import sqlite3
import sys
import tempfile
import unicodedata
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
WEB = ROOT / "craft_web"
SRC = WEB / "src"
CRAFT = ROOT / "ravenous_typst/data/src/craft"
WEAPONS = ROOT / "ravenous_typst/data/src/db/weapons.db"
sys.path.insert(0, str(ROOT))
from tools.build import read_glossary_labels, read_theme_palettes, translate_typst # noqa: E402
TABLES = {
"alchemy_solvants.tsv": ("Alchimie", "Solvants"),
"alchemy_reagents.tsv": ("Alchimie", "Réagents"),
"alchemy_transmutations.tsv": ("Alchimie", "Transmutations"),
"brewry_ferments.tsv": ("Brasserie", "Ferments"),
"brewry_methods.tsv": ("Brasserie", "Méthodes"),
"brewry_main_effects.tsv": ("Brasserie", "Effets principaux"),
"brewry_secondary_effects.tsv": ("Brasserie", "Effets secondaires"),
"brewry_finishing.tsv": ("Brasserie", "Finitions"),
"forge_materials.tsv": ("Forge", "Matériaux"),
"forge_finishing.tsv": ("Forge", "Finitions"),
"restoration_main.tsv": ("Restauration", "Principaux"),
"restoration_sides.tsv": ("Restauration", "Accompagnements"),
"restoration_seasoning.tsv": ("Restauration", "Assaisonnements"),
"traps.tsv": ("Pièges", "Pièges"),
}
FORGE_NUMERIC_FIELDS = (
"rarity", "cost", "difficulty", "tier", "damage", "p_damage", "precision",
"rmax", "armor_break", "armor_pierce", "antimaterial", "protection",
"integrity", "dodge", "parry", "speed", "stealth", "action_cost", "range",
"agility_bonus",
)
FORGE_ADJECTIVES = {
"Light": ("léger", "légère"), "Medium": ("moyen", "moyenne"),
"Heavy": ("lourd", "lourde"), "SuperHeavy": ("super-lourd", "super-lourde"),
}
def json_scalar(value):
if value in (None, "", "null"):
return None
try:
return json.loads(value)
except (TypeError, json.JSONDecodeError):
return value
def forge_name(shape: dict, nature: dict) -> str:
category = json_scalar(nature.get("category"))
masculine, feminine = FORGE_ADJECTIVES[category]
adjective = feminine if shape["name"] in {"Épée", "Hache", "Arbalète", "Armure"} else masculine
if shape["name"] == "Griffes":
adjective += "s"
return f"{shape['name']} {adjective}"
def compose_forge_base(shape: dict, nature: dict) -> dict:
item = dict(shape)
for field in FORGE_NUMERIC_FIELDS:
item[field] = (shape.get(field) or 0) + (nature.get(field) or 0)
item.update({
"shape_id": shape["id"], "nature_id": nature["id"],
"shape_name": shape["name"], "nature_name": nature["name"],
"shape_category": json_scalar(shape.get("category")),
"nature_category": json_scalar(nature.get("category")),
"name": forge_name(shape, nature), "meta_category": "Equipment",
})
reload_cost = json_scalar(shape.get("reload_cost"))
reload_modifier = json_scalar(nature.get("reload_cost")) or 0
item["reload_cost"] = None if reload_cost is None else reload_cost + reload_modifier
return item
def slug(value: str) -> str:
plain = unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode().lower()
return re.sub(r"[^a-z0-9]+", "-", plain).strip("-")
def number(value: str) -> int | float | None:
match = re.fullmatch(r"\s*#(?:dd|tox|wine|time)lvl\(\s*(-?\d+(?:\.\d+)?)\s*(?:,[^)]*)?\)\s*", value)
raw = match.group(1) if match else value.strip()
if not re.fullmatch(r"-?\d+(?:\.\d+)?", raw):
return None
return float(raw) if "." in raw else int(raw)
def metric(headers: list[str], row: list[str], token: str) -> int | float | None:
for index, header in enumerate(headers):
if token in header.lower() and index < len(row):
return number(row[index])
return None
def typed_metric(value: str, kind: str) -> int | float | None:
"""Return the sum of one numeric Typst wrapper without evaluating markup."""
values = re.findall(rf"#(?:{re.escape(kind)})lvl\(\s*(-?\d+(?:\.\d+)?)", value or "")
if not values:
return number(value or "")
total = sum(float(item) if "." in item else int(item) for item in values)
return int(total) if isinstance(total, float) and total.is_integer() else total
def header_metric(headers: list[str], row: list[str], token: str, kind: str | None = None):
for index, header in enumerate(headers):
if token in header.lower() and index < len(row):
return typed_metric(row[index], kind) if kind else number(row[index])
return None
def row_typed_sum(row: list[str], kind: str):
present = [typed_metric(value, kind) for value in row if f"#{kind}lvl(" in value]
return sum(present) if present else None
def catalog() -> list[dict]:
glossary = read_glossary_labels()
entries = []
for filename, (discipline, stage) in TABLES.items():
path = CRAFT / filename
with path.open(encoding="utf-8", newline="") as stream:
rows = list(csv.reader(stream, delimiter="\t"))
headers = rows[0]
for index, row in enumerate(rows[1:], 1):
row += [""] * (len(headers) - len(row))
name = row[0].strip()
raw = {headers[i]: row[i] for i in range(len(headers)) if row[i].strip()}
display = {translate_typst(key, glossary): translate_typst(value, glossary)
for key, value in raw.items()}
entries.append({
"id": f"{slug(discipline)}:{slug(stage)}:{slug(name)}",
"discipline": discipline, "stage": stage, "name": name,
"tier": metric(headers, row, "tier"), "cost": metric(headers, row, "cst"),
"difficulty": metric(headers, row, "lvl"), "toxicity": metric(headers, row, "tox"),
"finishing": metric(headers, row, "end"), "source": f"craft/{filename}:{index + 1}",
"satiety": header_metric(headers, row, "sat"),
"wine": header_metric(headers, row, "titrage", "wine") or header_metric(headers, row, "coût", "wine"),
"wine_available": header_metric(headers, row, "titrage", "wine"),
"wine_cost": header_metric(headers, row, "coût", "wine"),
"time": row_typed_sum(row, "time"),
"fields": display,
})
if WEAPONS.is_file():
with sqlite3.connect(f"file:{WEAPONS}?mode=ro", uri=True) as db:
db.row_factory = sqlite3.Row
rows = [dict(row) for row in db.execute("SELECT * FROM Equipements ORDER BY id")]
shapes = [row for row in rows if row["meta_category"] == "Shape" and json_scalar(row.get("apply_category"))]
natures = [row for row in rows if row["meta_category"] == "Nature"]
equipment = [compose_forge_base(shape, nature) for shape in shapes for nature in natures
if json_scalar(nature.get("target")) == json_scalar(shape.get("apply_category"))]
for item in equipment:
name = item["name"]
entries.append({
"id": f"forge:bases:{item['shape_id']}:{item['nature_id']}", "discipline": "Forge", "stage": "Bases",
"name": name, "tier": item.get("tier"), "cost": item.get("cost"),
"difficulty": item.get("difficulty"), "toxicity": None, "finishing": None,
"satiety": None, "wine": None, "wine_available": None, "wine_cost": None, "time": None,
"source": f"db/weapons.db:Equipements:{item['id']}",
"fields": {key.replace("_", " ").title(): str(value) for key, value in item.items()
if value not in (None, "", 0, "0")},
})
return entries
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]:
entries = catalog()
palettes = read_theme_palettes()
payload = {"version": 1, "entries": entries, "themes": list(palettes)}
packed = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
digest = hashlib.sha256(packed.encode()).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_CRAFT_CATALOG=" + packed + ";\n"
files["workshop-recipe-v1.schema.json"] = (WEB / "schemas/workshop-recipe-v1.schema.json").read_text(encoding="utf-8")
files["ravenous-craft-v1.schema.json"] = (ROOT / "docs/ravenous-craft-v1.schema.json").read_text(encoding="utf-8")
files["build-info.json"] = json.dumps({"catalog_hash": digest, "entries": len(entries),
"disciplines": sorted({item["discipline"] for item in entries}), "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("Craft website files are stale: " + ", ".join(stale))
print(f"Craft 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 craft website: {len(files)} files, {len(catalog())} catalog entries.")
if __name__ == "__main__":
main()