rpg-westreiche/tools/build_site.py
torsten 2dd6295caf Westreiche: Vault, Werkzeuge und Website
Neuinitialisierung ohne den PDF-Ballast (Regelwerke/Abenteuer/Magazine liegen
auf dem Server, siehe tools/pdf_sync.py und tools/pdf_manifest.json).
Vorherige Historie bewusst verworfen.
2026-11-20 17:20:36 +01:00

742 lines
28 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/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'<a href="{base}{href}"{current}>{label}</a>'
# Kein "Start"-Punkt: Der Weg zur Startseite ist das Logo im Kopf.
nav = ""
if SHOW_WELTENAUGE:
nav += nav_item("Weltenauge", "weltenauge.php", "weltenauge") + '<span class="sep">✦</span>'
nav += (
nav_item("Westreiche", "westreiche/index.html", "westreiche")
+ '<span class="sep">✦</span>'
+ nav_item("Zauber", "westreiche/zauber.html", "zauber")
+ '<span class="sep">✦</span>'
+ nav_item("Regeln", "westreiche/regeln.html", "regeln")
+ '<span class="sep">✦</span>'
+ nav_item("Enshrouded", "enshrouded/enshrouded_stats.html", "enshrouded")
)
footer_projects = "Weltenauge &amp; Westreiche" if SHOW_WELTENAUGE else "Westreiche"
return f"""<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{html.escape(title)} · {SITE_NAME}</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Cinzel:wght@400;600&family=EB+Garamond:ital,wght@0,400;0,600;1,400&display=swap" rel="stylesheet">
<link rel="stylesheet" href="{base}assets/style.css">
<link rel="icon" href="{base}assets/logo_zauberturm.png">
{head_extra}</head>
<body>
<header class="site-header">
<a href="{base}index.php"><img class="logo" src="{base}assets/logo_zauberturm.png" alt="Wappen des Zauberturms"></a>
<p class="brand">{SITE_NAME}</p>
<p class="tagline">{SITE_TAGLINE}</p>
</header>
<nav class="site-nav">{nav}</nav>
{body}
<footer class="site-footer">
<p class="rune">✦ ❖ ✦</p>
<p>&copy; {YEAR} {SITE_URL} · {footer_projects}</p>
</footer>
</body>
</html>
"""
# --------------------------------------------------------------------------- #
# 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"<h4>{html.escape(sec)}</h4>" + _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 '<option value="">' + all_label + "</option>" + "".join(
f'<option value="{html.escape(str(v))}">{html.escape(str(v))}</option>' 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'<p class="spell-teach"><b>{schule_label}:</b> '
+ ", ".join(html.escape(n) for n in sp["lehrt"]) + "</p>")
elif sp["grad"] <= 2:
lehre_html += ('<p class="spell-teach"><b>Gelehrt von:</b> alle '
+ ("Gilden" if key == "arkan" else "Gemeinschaften") + "</p>")
for name, gname, text in sp["signaturen"]:
lehre_html += (f'<p class="spell-sig"><b>{html.escape(name)}</b>'
f' ({html.escape(gname)}) – {html.escape(text)}.</p>')
for ort, bedingung in sp["sonderorte"]:
lehre_html += (f'<p class="spell-place"><b>{html.escape(ort)}</b> – '
f'{html.escape(bedingung)}.</p>')
data = (f'data-grad="{sp["grad"]}" data-klasse="{html.escape(sp["klasse"])}" '
f'data-lehrt="{html.escape("|".join(sp["lehrt"]))}"')
items.append(f"""
<details class="spell" {data}>
<summary>
<span class="spell-name">{html.escape(sp["title"])}</span>
<span class="spell-meta">{meta}</span>
</summary>
<div class="spell-body">
{lehre_html}
{sp["body"]}
</div>
</details>""")
return f"""
<section class="spell-block" id="{anchor}">
<h2>{label}</h2>
<p class="spell-count">{len(spells)} Zauber · {len(grade)} Grade · anklicken für die Beschreibung</p>
<div class="spell-filter" data-target="{anchor}">
<input type="search" class="sf-search" placeholder="Suchen (Name oder Text) …" aria-label="Zauber durchsuchen">
<select class="sf-grad" aria-label="Grad filtern">{opts(grade, "alle Grade")}</select>
<select class="sf-klasse" aria-label="Klasse filtern">{opts(klassen, "alle Klassen")}</select>
<select class="sf-lehrt" aria-label="Lehrende filtern">{opts(lehren, "alle Lehrenden")}</select>
<button type="button" class="sf-reset">Zurücksetzen</button>
<span class="sf-status" aria-live="polite"></span>
</div>
<div class="spell-list">{"".join(items)}
</div>
</section>"""
SPELL_FILTER_JS = """
<script>
(function () {
document.querySelectorAll(".spell-filter").forEach(function (bar) {
var target = document.getElementById(bar.dataset.target);
if (!target) return;
var items = Array.prototype.slice.call(target.querySelectorAll("details.spell"));
var search = bar.querySelector(".sf-search");
var grad = bar.querySelector(".sf-grad");
var klasse = bar.querySelector(".sf-klasse");
var lehrt = bar.querySelector(".sf-lehrt");
var status = bar.querySelector(".sf-status");
function apply() {
var q = (search.value || "").toLowerCase().trim();
var shown = 0;
items.forEach(function (it) {
var ok = true;
if (grad.value && it.dataset.grad !== grad.value) ok = false;
if (klasse.value && it.dataset.klasse !== klasse.value) ok = false;
if (lehrt.value && (it.dataset.lehrt || "").split("|").indexOf(lehrt.value) === -1) ok = false;
if (ok && q && it.textContent.toLowerCase().indexOf(q) === -1) ok = false;
it.hidden = !ok;
if (ok) shown++;
});
status.textContent = shown + " von " + items.length;
}
[search, grad, klasse, lehrt].forEach(function (el) {
el.addEventListener("input", apply);
el.addEventListener("change", apply);
});
bar.querySelector(".sf-reset").addEventListener("click", function () {
search.value = ""; grad.value = ""; klasse.value = ""; lehrt.value = "";
apply();
});
apply();
});
})();
</script>
"""
def build_protocol_pages(docs: list[Doc]) -> None:
target = OUT / "westreiche" / "protokolle"
target.mkdir(parents=True, exist_ok=True)
for i, doc in enumerate(docs):
prev_doc = docs[i - 1] if i > 0 else None
next_doc = docs[i + 1] if i + 1 < len(docs) else None
nav_parts = []
if prev_doc:
nav_parts.append(
f'<a href="{prev_doc.slug}">&larr; {html.escape(prev_doc.title)}</a>'
)
nav_parts.append('<a href="../index.html">Alle Sitzungen</a>')
if next_doc:
nav_parts.append(
f'<a href="{next_doc.slug}">{html.escape(next_doc.title)} &rarr;</a>'
)
body = f"""
<main class="wrap narrow">
<p class="breadcrumb"><a href="../../index.php">Start</a> · <a href="../index.html">Westreiche</a> · Sitzung {doc.session:03d}</p>
<article class="protocol">
{doc.body_html}
</article>
<nav class="doc-nav">
{''.join(nav_parts)}
</nav>
</main>
"""
html_out = page(
title=doc.title,
body=body,
base="../../",
nav_current="westreiche",
)
(target / doc.slug).write_text(html_out, encoding="utf-8")
def build_westreiche_index(docs: list[Doc]) -> None:
by_session: dict[int, list[Doc]] = {}
for doc in docs:
by_session.setdefault(doc.session, []).append(doc)
blocks = []
for session in sorted(by_session, reverse=True):
group = by_session[session]
date = group[0].date
items = "\n".join(
f' <li><a href="protokolle/{d.slug}">{html.escape(d.title)}'
f'<span class="tag">{html.escape(d.kind)}</span></a></li>'
for d in group
)
blocks.append(
f""" <section class="session">
<div class="session-head">
<h2>Sitzung {session:03d}</h2>
<span class="date">{date}</span>
</div>
<ul class="doc-list">
{items}
</ul>
</section>"""
)
body = f"""
<main class="wrap mid">
<section class="hero">
<h1>Westreiche</h1>
<p class="lead">Die Chronik der Kampagne: Sitzungsprotokolle von den ersten Schritten
im Kürbistal bis zur Zauber-Truhe und dem Nekromanten hinter dem grünen Portal.</p>
</section>
<div class="rule">✦</div>
<p class="cta"><a href="zauber.html">Die Zauber &rarr;</a> · <a href="regeln.html">Regeländerungen &rarr;</a></p>
{chr(10).join(blocks)}
</main>
"""
out = OUT / "westreiche" / "index.html"
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(page(title="Westreiche", body=body, base="../", nav_current="westreiche"), encoding="utf-8")
def build_weltenauge() -> None:
body = """
<main class="wrap">
<section class="hero">
<h1>Weltenauge</h1>
<p class="lead">Blicke aus der Entwicklung: Szenen, Testwelten und Momente,
die im Weltenauge ihren Weg ins Licht gefunden haben.</p>
</section>
<div class="rule">✦</div>
<div class="gallery">
<?php
$dir = 'weltenauge';
$allowed = ['jpg', 'jpeg', 'png', 'webp', 'gif'];
$files = [];
if (is_dir($dir)) {
foreach (array_diff(scandir($dir), ['..', '.']) as $f) {
$ext = strtolower(pathinfo($f, PATHINFO_EXTENSION));
if (in_array($ext, $allowed, true)) {
$files[$f] = filemtime($dir . '/' . $f);
}
}
}
arsort($files);
if ($files) {
foreach ($files as $file => $mtime) {
$src = htmlspecialchars($dir . '/' . rawurlencode($file));
$name = htmlspecialchars($file);
$date = date('d.m.Y H:i', $mtime);
echo "<figure class='shot'>
<a href='$src' target='_blank' rel='noopener'>
<img src='$src' alt='$name' loading='lazy'>
</a>
<div class='meta'>$name<small>$date</small></div>
</figure>";
}
} else {
echo "<p class='empty'>Noch keine Bilder im Archiv des Weltenauges.</p>";
}
?>
</div>
</main>
"""
(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 = '<p class="empty">Noch keine Regeländerungen erfasst.</p>'
body = f"""
<main class="wrap narrow">
<p class="breadcrumb"><a href="../index.php">Start</a> · <a href="index.html">Westreiche</a> · Regeln</p>
<section class="hero">
<h1>Regeländerungen</h1>
<p class="lead">Was am Spieltisch anders läuft als im Regelwerk – datiert,
neueste Änderung oben. Jede Zeile hier ist eine Entscheidung, die wir
gemeinsam getroffen haben.</p>
</section>
<div class="rule">✦</div>
<p class="cta"><a href="zauber.html">Alle Zauber der Westreiche &rarr;</a></p>
<article class="protocol">
{content}
</article>
</main>
"""
target = OUT / "westreiche"
target.mkdir(parents=True, exist_ok=True)
(target / "regeln.html").write_text(
page(title="Regeländerungen", body=body, base="../", nav_current="regeln"),
encoding="utf-8",
)
def build_zauber() -> None:
"""Eigener Bereich „Zauber": arkan und klerikal, filterbar und aufklappbar."""
spells = collect_spells()
arkan = spell_section_html("arkan", spells.get("arkan", []))
klerikal = spell_section_html("klerikal", spells.get("klerikal", []))
n_arkan = len(spells.get("arkan", []))
n_klerikal = len(spells.get("klerikal", []))
body = f"""
<main class="wrap mid">
<p class="breadcrumb"><a href="../index.php">Start</a> · <a href="index.html">Westreiche</a> · Zauber</p>
<section class="hero">
<h1>Zauber</h1>
<p class="lead">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.</p>
</section>
<div class="rule">✦</div>
<nav class="toc-inline">
<a href="#zauber-arkan">Magierzauber</a>
<a href="#zauber-klerikal">Klerikerzauber</a>
</nav>
{arkan}
{klerikal}
</main>
{SPELL_FILTER_JS}
"""
target = OUT / "westreiche"
target.mkdir(parents=True, exist_ok=True)
(target / "zauber.html").write_text(
page(title="Zauber", body=body, base="../", nav_current="zauber"),
encoding="utf-8",
)
def build_start(docs: list[Doc], latest: Doc | None) -> None:
latest_line = ""
if latest:
latest_line = (
f'<p class="latest">Zuletzt eingetragen: '
f'<a href="westreiche/protokolle/{latest.slug}">{html.escape(latest.title)}</a>'
f'{" · " + latest.date if latest.date else ""}</p>'
)
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 = """
<article class="project-card">
<p class="kicker">Projekt</p>
<h2>Weltenauge</h2>
<p>Die Bildergalerie aus der Entwicklung: entstandene Welten, Testgebäude,
Avatare und Eindrücke, die das Weltenauge eingefangen hat.</p>
<p class="cta"><a href="weltenauge.php">Zur Galerie &rarr;</a></p>
</article>"""
else:
lead = ("Die Chronik der Westreiche: Sitzungsprotokolle, Hausregeln und "
"Weltnotizen, gesammelt hinter stillen Mauern.")
gallery_card = ""
body = f"""
<main class="wrap">
<section class="hero">
<h1>Der Zauberturm</h1>
<p class="lead">{lead}</p>
</section>
<div class="rule">✦</div>
<div class="card-grid">
<article class="project-card">
<p class="kicker">Kampagne</p>
<h2>Westreiche</h2>
<p>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.</p>
{latest_line}
<p class="cta"><a href="westreiche/index.html">Zu den Protokollen &rarr;</a></p>
</article>
<article class="project-card">
<p class="kicker">Zauberwerk</p>
<h2>Zauber</h2>
<p>Alle arkanen Sprüche und göttlichen Liturgien der Westreiche – durchsuchbar,
nach Grad, Klasse und Gilde filterbar, mit Beschreibung auf einen Klick.</p>
<p class="cta"><a href="westreiche/zauber.html">Zu den Zaubern &rarr;</a></p>
</article>
<article class="project-card">
<p class="kicker">Regelwerk</p>
<h2>Regeländerungen</h2>
<p>Was am Spieltisch anders läuft als im Regelwerk – jede Hausregel-Änderung
datiert, mit Begründung und dem, was am Tisch zu tun ist.</p>
<p class="cta"><a href="westreiche/regeln.html">Zum Changelog &rarr;</a></p>
</article>
<article class="project-card">
<p class="kicker">Werkzeug</p>
<h2>Enshrouded Dashboard</h2>
<p>Die Auswertung unserer Enshrouded-Runde: Spielerdaten, Fortschritt und
Statistiken, laufend aus den Spieldaten aktualisiert.</p>
<p class="cta"><a href="enshrouded/enshrouded_stats.html">Zum Dashboard &rarr;</a></p>
</article>{gallery_card}
</div>
</main>
"""
(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()