#!/usr/bin/env python3
"""Baut die statische Zauberturm-Website aus dem Vault.
Erzeugt nach `web/`:
- index.php Startseite mit beiden Projekten
- weltenauge.php Bildergalerie (liest weltenauge/ auf dem Server)
– nur wenn SHOW_WELTENAUGE aktiv ist, sonst nicht gebaut
- westreiche/index.html Übersicht der Sitzungsprotokolle
- westreiche/protokolle/*.html
- westreiche/regeln.html datiertes Regeländerungs-Changelog
(Quelle: RPG/5-Regeln/Hausregeln/Regeländerungen (Changelog).md)
Aufruf: python3 tools/build_site.py
"""
from __future__ import annotations
import html
import re
import shutil
from dataclasses import dataclass
from pathlib import Path
import markdown
ROOT = Path(__file__).resolve().parent.parent
OUT = ROOT / "web"
SESSIONS = ROOT / "RPG" / "1-Sessions"
CHANGELOG = ROOT / "RPG" / "5-Regeln" / "Hausregeln" / "Regeländerungen (Changelog).md"
SITE_NAME = "Zauberturm"
SITE_TAGLINE = "Erzählwelten, Karten und Chroniken"
SITE_URL = "zauberturm.de"
YEAR = "2026"
# Projekt-Schalter: Das Weltenauge ruht seit 20.11.2026. Auf False wird die
# Galerie-Seite nicht gebaut, der Nav-Punkt und die Startseiten-Karte entfallen.
# Zum Wiederbeleben nur auf True setzen, bauen und deployen.
SHOW_WELTENAUGE = False
# --------------------------------------------------------------------------- #
# Helfer
# --------------------------------------------------------------------------- #
def normalize_list_indent(text: str) -> str:
"""Obsidian rückt Unterlisten mit 2 Leerzeichen ein, Python-Markdown
erwartet 4 – Einrückungen von Listenzeilen daher verdoppeln."""
out = []
fence = False
for line in text.splitlines():
if line.lstrip().startswith("```"):
fence = not fence
if not fence:
m = re.match(r"^( {1,12})([-*+] |\d+\. )", line)
if m:
line = " " * (len(m.group(1)) * 2) + line[len(m.group(1)):]
out.append(line)
return "\n".join(out)
def md_to_html(text: str) -> str:
"""Markdown (inkl. Obsidian-Eigenheiten) nach HTML."""
# Obsidian-Bilder und eingebettete Notizen entfernen
text = re.sub(r"!\[\[.*?\]\]", "", text)
# [[Ziel|Anzeige]] -> Anzeige, [[Ziel]] -> Ziel
text = re.sub(r"\[\[([^\]|]+)\|([^\]]+)\]\]", r"\2", text)
text = re.sub(r"\[\[([^\]]+)\]\]", r"\1", text)
text = normalize_list_indent(text)
return markdown.markdown(
text,
extensions=["tables", "fenced_code", "sane_lists", "nl2br", "toc"],
extension_configs={"toc": {"permalink": False}},
)
def page(
*,
title: str,
body: str,
base: str,
nav_current: str = "",
head_extra: str = "",
) -> str:
"""Gemeinsames HTML-Gerüst."""
def nav_item(label: str, href: str, key: str) -> str:
current = ' aria-current="page"' if key == nav_current else ""
return f'{label}'
# Kein "Start"-Punkt: Der Weg zur Startseite ist das Logo im Kopf.
nav = ""
if SHOW_WELTENAUGE:
nav += nav_item("Weltenauge", "weltenauge.php", "weltenauge") + '✦'
nav += (
nav_item("Westreiche", "westreiche/index.html", "westreiche")
+ '✦'
+ nav_item("Zauber", "westreiche/zauber.html", "zauber")
+ '✦'
+ nav_item("Regeln", "westreiche/regeln.html", "regeln")
+ '✦'
+ nav_item("Enshrouded", "enshrouded/enshrouded_stats.html", "enshrouded")
)
footer_projects = "Weltenauge & Westreiche" if SHOW_WELTENAUGE else "Westreiche"
return f"""
{html.escape(title)} · {SITE_NAME}
{head_extra}
{SITE_NAME}
{SITE_TAGLINE}
{body}
"""
# --------------------------------------------------------------------------- #
# Protokolle einsammeln
# --------------------------------------------------------------------------- #
@dataclass
class Doc:
path: Path
session: int
date: str # TT.MM.JJJJ oder ""
kind: str # "Geschehnisse" | "Notizen" | "Protokoll"
title: str
body_html: str
slug: str
@property
def sort_key(self) -> tuple:
return (-self.session, self.kind)
DATE_RE = re.compile(r"(\d{2})\.(\d{2})\.(\d{4})")
SESSION_RE = re.compile(r"Sitzung\s*0*(\d+)")
KIND_RE = re.compile(r"\((Geschehnisse|Notizen)\)", re.I)
def slugify(name: str) -> str:
name = name.lower()
name = name.replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss")
name = re.sub(r"[^a-z0-9]+", "-", name)
return re.sub(r"-+", "-", name).strip("-")
# Dokumentarten, die veröffentlicht werden. Notizen und ältere Kurzprotokolle
# bleiben im Vault, erscheinen aber nicht auf der Website – die Geschehnisse
# decken den Inhalt ab (keine Dubletten).
PUBLISH_KINDS = {"Geschehnisse"}
def collect_docs() -> list[Doc]:
docs: list[Doc] = []
for path in sorted(SESSIONS.rglob("*.md")):
if "Protokoll" not in path.name and not re.match(r"Sitzung 0*\d+, \d", path.name):
continue
raw = path.read_text(encoding="utf-8", errors="replace").strip()
if len(raw) < 200: # leere Platzhalter überspringen
continue
rel = str(path.relative_to(SESSIONS))
session = int(SESSION_RE.search(rel).group(1)) if SESSION_RE.search(rel) else 0
date = ""
m = DATE_RE.search(rel)
if m:
date = ".".join(m.groups())
kind_match = KIND_RE.search(path.stem)
if kind_match:
kind = kind_match.group(1).capitalize()
title = f"Sitzung {session:03d} — {kind}"
else:
kind = "Protokoll"
title = path.stem
# vorhandene H1 aus dem Markdown als Titel nutzen
first_line = raw.splitlines()[0]
if first_line.startswith("# "):
title = first_line[2:].strip()
raw = "\n".join(raw.splitlines()[1:]).lstrip()
# Dokumentart notfalls aus der Überschrift ableiten
# (z. B. „Westreiche – Sitzung 13 (24.10.2026): Geschehnisse")
if not kind_match:
h1_kind = KIND_RE.search(title)
if not h1_kind:
for candidate in ("Geschehnisse", "Notizen", "Zusammenfassung"):
if candidate.lower() in title.lower():
kind = candidate
break
else:
kind = h1_kind.group(1).capitalize()
if kind not in PUBLISH_KINDS:
continue
docs.append(
Doc(
path=path,
session=session,
date=date,
kind=kind,
title=title,
body_html=md_to_html(raw),
slug=slugify(f"sitzung-{session:03d}-{kind}") + ".html",
)
)
docs.sort(key=lambda d: d.sort_key)
# doppelte Slugs (mehrere Dokumente gleicher Art in einer Sitzung) eindeutig machen
seen: dict[str, int] = {}
for doc in docs:
count = seen.get(doc.slug, 0) + 1
seen[doc.slug] = count
if count > 1:
doc.slug = f"{doc.slug[:-5]}-{count}.html"
return docs
# --------------------------------------------------------------------------- #
# Seiten bauen
# --------------------------------------------------------------------------- #
# --------------------------------------------------------------------------- #
# Zauber (arkan + klerikal) für die Regeln-Seite
# --------------------------------------------------------------------------- #
SPELL_SOURCES = {
"arkan": (ROOT / "RPG" / "5-Regeln" / "Zauber" / "Arkan", "Magierzauber",
"arkan", "Gilde"),
"klerikal": (ROOT / "RPG" / "5-Regeln" / "Zauber" / "Klerikal", "Klerikerzauber",
"klerikal", "Gemeinschaft"),
}
SPELL_SECTIONS = ("Wirkung", "Regelhinweise", "Verwandte Zauber", "Erwerb", "Offene Punkte")
def _spell_md_to_html(lines: list[str]) -> str:
return md_to_html("\n".join(lines).strip())
def collect_spells() -> dict[str, list[dict]]:
"""Liest alle Zauberdateien und liefert je Schule eine sortierte Liste."""
out: dict[str, list[dict]] = {}
for key, (base, _label, _school, gilde_head) in SPELL_SOURCES.items():
spells: list[dict] = []
for path in sorted(base.glob("Grad */*.md")):
m = re.search(r"Grad (\d+)", path.parent.name)
if not m:
continue
text = path.read_text(encoding="utf-8", errors="replace")
title_m = re.search(r"^# (.+)$", text, re.M)
grad_m = re.search(r"\*\*Grad:\*\*\s*(\d+)", text)
if not title_m or not grad_m:
continue
klasse_m = re.search(r"\*\*Klasse:\*\*\s*([A-Za-zÄÖÜäöüß]+)", text)
dauer_m = re.search(r"\*\*Dauer:\*\*\s*(.+?)\s*(?:·|\n)", text)
reich_m = re.search(r"\*\*Reichweite:\*\*\s*(.+?)\s*(?:\n|$)", text)
engl_m = re.search(r"\*\*Englisch:\*\*\s*(.+?)\s*(?:·|\n)", text)
sections: dict[str, list[str]] = {}
current = None
for line in text.splitlines():
if line.startswith("## "):
current = line[3:].strip()
sections.setdefault(current, [])
continue
if current:
sections[current].append(line)
lehrt: list[str] = []
signaturen: list[tuple[str, str, str]] = []
sonderorte: list[tuple[str, str]] = []
for line in sections.get(gilde_head, []):
s = line.strip()
m2 = re.match(r"-\s+\*\*Signatur \(nur hier\)\s+–\s+(.+?)\*\*\s*\((.+?)\):\s*(.+?)\.?$", s)
if m2:
signaturen.append((m2.group(1), m2.group(2), m2.group(3)))
continue
m2 = re.match(r"-\s+\*\*Nur an besonderem Ort\s+–\s+(.+?)\*\*:\s*(.+?)\.?$", s)
if m2:
sonderorte.append((m2.group(1), m2.group(2)))
continue
if "Gelehrt von:" in s or "Schwerpunkt bei:" in s:
for name in re.findall(r"\*\*([^*]+)\*\*", s):
if not name.lower().startswith(("gelehrt von", "schwerpunkt bei")):
lehrt.append(name.strip())
body_parts = []
for sec in SPELL_SECTIONS:
lines = [l for l in sections.get(sec, []) if l.strip()]
if lines:
body_parts.append(f"
{html.escape(sec)}
" + _spell_md_to_html(lines))
spells.append({
"key": key,
"title": title_m.group(1).strip(),
"grad": int(grad_m.group(1)),
"klasse": klasse_m.group(1) if klasse_m else "",
"dauer": re.sub(r"\*\*", "", dauer_m.group(1)).strip() if dauer_m else "",
"reichweite": re.sub(r"\*\*", "", reich_m.group(1)).strip() if reich_m else "",
"englisch": re.sub(r"\*\*", "", engl_m.group(1)).strip() if engl_m else "",
"lehrt": list(dict.fromkeys(lehrt)),
"signaturen": signaturen,
"sonderorte": sonderorte,
"body": "".join(body_parts),
})
spells.sort(key=lambda s: (s["grad"], s["title"].lower()))
out[key] = spells
return out
def spell_section_html(key: str, spells: list[dict]) -> str:
_base, label, school, gilde_head = SPELL_SOURCES[key]
anchor = f"zauber-{school}"
klassen = sorted({s["klasse"] for s in spells if s["klasse"]})
grade = sorted({s["grad"] for s in spells})
lehren = sorted({n for s in spells for n in s["lehrt"]})
def opts(values, all_label):
return '" + "".join(
f'' for v in values)
items = []
for sp in spells:
tags = [f'Grad {sp["grad"]}']
if sp["klasse"]:
tags.append(sp["klasse"])
if sp["dauer"]:
tags.append(sp["dauer"])
if sp["reichweite"]:
tags.append(sp["reichweite"])
if sp["englisch"]:
tags.append(sp["englisch"])
meta = " · ".join(html.escape(t) for t in tags)
lehre_html = ""
if sp["lehrt"]:
schule_label = "Gelehrt von" if sp["grad"] > 2 else "Schwerpunkt bei"
if key == "klerikal" and sp["klasse"] == "Druide":
schule_label = "Gelehrt von"
lehre_html += (
f'
{schule_label}: '
+ ", ".join(html.escape(n) for n in sp["lehrt"]) + "
")
elif sp["grad"] <= 2:
lehre_html += ('
Gelehrt von: alle '
+ ("Gilden" if key == "arkan" else "Gemeinschaften") + "
")
for name, gname, text in sp["signaturen"]:
lehre_html += (f'
{html.escape(name)}'
f' ({html.escape(gname)}) – {html.escape(text)}.
')
for ort, bedingung in sp["sonderorte"]:
lehre_html += (f'
"""
(OUT / "weltenauge.php").write_text(
page(title="Weltenauge", body=body, base="", nav_current="weltenauge"),
encoding="utf-8",
)
def build_regeln() -> None:
"""Datiertes Changelog der Hausregeln aus dem Vault."""
if CHANGELOG.exists():
raw = CHANGELOG.read_text(encoding="utf-8", errors="replace").strip()
lines = raw.splitlines()
# eigene H1 unterdrücken – die Seite hat ein Hero
if lines and lines[0].startswith("# "):
raw = "\n".join(lines[1:]).lstrip()
# Pflege-Hinweis („Zweck/Format") bleibt draußen – das ist SL-Werkzeug
raw = re.split(r"\n---\n", raw, maxsplit=1)[-1].lstrip()
content = md_to_html(raw)
else:
content = '
Was am Spieltisch anders läuft als im Regelwerk – datiert,
neueste Änderung oben. Jede Zeile hier ist eine Entscheidung, die wir
gemeinsam getroffen haben.
Alles, was in den Westreichen gesprochen, gebetet und geflüstert wird:
{n_arkan} arkane Sprüche und {n_klerikal} göttliche Liturgien. Durchsuchen, filtern,
anklicken – und die Beschreibung steht da.
'
)
if SHOW_WELTENAUGE:
lead = ("Zwei Erzählwelten unter einem Dach: das Reich der Westreiche und "
"das Projekt Weltenauge. Chroniken, Karten und Bilder, gesammelt "
"hinter denselben Mauern.")
gallery_card = """
Projekt
Weltenauge
Die Bildergalerie aus der Entwicklung: entstandene Welten, Testgebäude,
Avatare und Eindrücke, die das Weltenauge eingefangen hat.
"""
else:
lead = ("Die Chronik der Westreiche: Sitzungsprotokolle, Hausregeln und "
"Weltnotizen, gesammelt hinter stillen Mauern.")
gallery_card = ""
body = f"""
Der Zauberturm
{lead}
✦
Kampagne
Westreiche
Vom Kürbistal und dem Grabmal des alten Ritters über Garana bis zur
Zauber-Truhe: die vollständigen Sitzungsprotokolle der Kampagne, Sitzung
für Sitzung.
"""
(OUT / "index.php").write_text(
page(title="Der Zauberturm", body=body, base="", nav_current="start"),
encoding="utf-8",
)
def main() -> None:
if OUT.exists():
shutil.rmtree(OUT / "westreiche", ignore_errors=True)
OUT.mkdir(parents=True, exist_ok=True)
docs = collect_docs()
build_protocol_pages(docs)
build_westreiche_index(docs)
build_regeln()
build_zauber()
gallery = OUT / "weltenauge.php"
if SHOW_WELTENAUGE:
build_weltenauge()
elif gallery.exists():
# ruhendes Projekt: Seite lokal löschen; die Datei auf dem Server
# muss per FTP entfernt werden (Deploy-Skript lädt nur hoch)
gallery.unlink()
build_start(docs, next((d for d in docs if d.session == max(x.session for x in docs)), None))
print(f"{len(docs)} Protokolle, {len({d.session for d in docs})} Sitzungen nach {OUT} gebaut.")
if __name__ == "__main__":
main()