224 lines
10 KiB
Python
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()
|