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.
This commit is contained in:
torsten 2026-11-20 17:20:36 +01:00
commit 2dd6295caf
611 changed files with 100926 additions and 0 deletions

742
tools/build_site.py Normal file
View file

@ -0,0 +1,742 @@
#!/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()