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

BIN
tools/a5-reference.odt Normal file

Binary file not shown.

View file

@ -0,0 +1,403 @@
#!/usr/bin/env python3
"""Ergänzt in den klerikalen Liturgiedateien einen Abschnitt „Gemeinschaft".
Klerikales Gegenstück zu `add_guild_notes.py`. Zuordnung folgt
`RPG/5-Regeln/Hausregeln/Liturgien und Glaubensgemeinschaften.md` (§2, §3, §6)
und `RPG/4-Organisationen/Glaubensgemeinschaften – Standorte.md`.
KIR Kirche des Amaunator – Ordnung, Beständigkeit, Licht, Heilung, legitime Herrschaft
KON Scharlachroter Konvent – Heilung, Sühne, Reinigung
SWF Jünger des Schwertfeuers – Inquisition: Häresie aufspüren, richten, bannen
SEH Orden der Seher – Prophezeiung, Träume, Zeichendeutung
ARI Hüter von Aribor – Bewahrung heiliger Orte, Schutz statt Mission
NAT Naturzirkel – Natur, Gleichgewicht, Neutralität
Grad 1–2 ist Allgemeingut der Kirche (nur Schwerpunkt wird vermerkt); ab Grad 3
gilt der Lehrplan der Gemeinschaft. Ausnahme (§3.1): Druidenliturgien sind
**kein** Allgemeingut – sie kommen über den Naturzirkel.
Aufruf: python3 tools/add_gemeinschaft_notes.py [--check] [--force]
"""
from __future__ import annotations
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
SPELLS = ROOT / "RPG" / "5-Regeln" / "Zauber" / "Klerikal"
GEMEINSCHAFT_NAME = {
"KIR": "Kirche des Amaunator",
"KON": "Scharlachroter Konvent",
"SWF": "Jünger des Schwertfeuers",
"SEH": "Orden der Seher",
"ARI": "Hüter von Aribor",
"NAT": "Naturzirkel",
}
GEMEINSCHAFT_FOCUS = {
"KIR": "Ordnung, Beständigkeit, Licht, Heilung und legitime Herrschaft",
"KON": "Heilung, Sühne und Reinigung",
"SWF": "Inquisition: Häresie aufspüren, richten, bannen",
"SEH": "Prophezeiung, Träume und Zeichendeutung",
"ARI": "Bewahrung heiliger Orte, Schutz statt Mission",
"NAT": "Natur, Gleichgewicht und Neutralität",
}
# Liturgien ab Grad 3: welche Gemeinschaften lehren sie?
# Schlüssel: "grad/name" (Grad nötig, weil derselbe Name in zwei Graden steht).
MAPPING: dict[str, list[str]] = {
# ---- Grad 3 -----------------------------------------------------------
"3/baumgestalt": ["NAT"],
"3/blitz rufen": ["NAT"],
"3/dauerhaftes licht": ["KIR"],
"3/fluch bannen": ["KIR", "SWF", "ARI"],
"3/gegenstand lokalisieren": ["KIR", "SEH"],
"3/krankheit heilen": ["KIR", "KON"],
"3/schlagkraft": ["SWF"],
"3/schutz vor gift": ["NAT"],
"3/tier festhalten": ["NAT"],
"3/tierwachstum": ["NAT"],
"3/wachstum der natur": ["NAT"],
"3/wasser atmen": ["NAT", "KIR"],
"3/sühne": ["KON"],
"3/schmerz tragen": ["KON"],
"3/sterbesegen": ["KON"],
"3/eid binden": ["ARI"],
# ---- Grad 4 -----------------------------------------------------------
"4/gift neutralisieren": ["KIR", "KON"],
"4/magie bannen": ["KIR", "SWF", "NAT"],
"4/mit pflanzen sprechen": ["NAT"],
"4/schutz vor bösem": ["KIR", "SWF", "ARI"],
"4/schutz vor feuer und blitzen": ["NAT"],
"4/schwere wunden heilen": ["KIR", "KON", "NAT"],
"4/stöcke zu schlangen": ["KIR", "SWF"],
"4/temperatur kontrollieren": ["NAT"],
"4/tiere herbeirufen": ["NAT"],
"4/wasser erschaffen": ["KIR", "KON", "NAT"],
"4/reinigung der stätte": ["KON"],
"4/traumgesicht": ["SEH"],
"4/grenzweihe": ["ARI"],
"4/zeichenlesen": ["SEH"],
# ---- Grad 5 -----------------------------------------------------------
"5/böses bannen": ["KIR", "SWF"],
"5/dornenwand": ["NAT"],
"5/durch pflanzen gehen": ["NAT"],
"5/fels zu schlamm verwandeln": ["NAT"],
"5/gemeinschaft mit der natur": ["NAT"],
"5/göttliche gemeinschaft": ["KIR", "SEH"],
"5/insektenplage": ["SWF"],
"5/nahrung erschaffen": ["KIR", "KON", "NAT"],
"5/queste": ["KIR", "SWF"],
"5/schutz vor pflanzen und tieren": ["NAT"],
"5/tote erwecken": ["KIR"],
}
# Schwerpunkte für Allgemeingut-Liturgien (Grad 1–2), nur für Kleriker-Sprüche.
FOCUS: dict[str, list[str]] = {
"1/böses entdecken": ["SWF"],
"1/furcht bannen": ["KIR"],
"1/kälte widerstehen": ["KIR"],
"1/leichte wunden heilen": ["KIR", "KON"],
"1/licht": ["KIR"],
"1/magie entdecken": ["KIR", "SEH"],
"1/nahrung und wasser reinigen": ["KIR", "KON"],
"1/schutz vor bösem": ["KIR", "ARI"],
"2/fallen finden": ["SEH", "SWF"],
"2/feuer widerstehen": ["KIR"],
"2/gesinnung erkennen": ["SWF", "SEH"],
"2/mit tieren sprechen": ["NAT"],
"2/person festhalten": ["KIR", "SWF"],
"2/schlangen bezaubern": ["KIR", "SEH"],
"2/segen": ["KIR", "KON"],
"2/stille": ["KON", "ARI"],
}
# Druidenliturgien (Klasse Druide): gehören dem Naturzirkel, kein Allgemeingut.
DRUIDE_NOTE = (
"> **Zugang:** Naturzirkel-Lehre – Druidenliturgien sind **kein** Allgemeingut "
"der Kirche, auch nicht in Grad 1–2 (siehe [[Liturgien und Glaubensgemeinschaften]] §3.1)."
)
EXCLUDE_REASON = {
"KIR": "keine Liturgie der Ordnung, des Lichts oder der legitimen Herrschaft",
"KON": "kein Heil-, Sühne- oder Reinigungsbezug",
"SWF": "kein inquisitorischer Auftrag (Erkennen, Richten, Bannen)",
"SEH": "kein Feld der Zeichendeutung",
"ARI": "kein Bezug zu Bewahrung oder Wacht",
"NAT": "keine Naturliturgie",
}
EXCLUSIVE_HINT = {
"5/insektenplage": (
"Richtspruch, kein Segen: Die Jünger wirken sie gegen Land und Leute, die der "
"Häresie überführt wurden."
),
"3/sühne": (
"Die Amtskirche verwaltet Buße als **Amt** (Auflage, Wallfahrt, Prälat) – sie gibt sie "
"nicht als Handauflegen weiter. Sühne ist Konvent-Sache."
),
"3/schmerz tragen": (
"Nur wer selbst im Siechenhaus dient, lernt das Teilen von Wunden – die Kirche heilt aus "
"Amt, der Konvent aus Anwesenheit."
),
"3/sterbesegen": (
"Die Gegenliturgie zu `Tote erwecken`: Der Konvent lässt gehen, die Kirche holt zurück. "
"Keine Kirche lehrt beides."
),
"4/reinigung der stätte": (
"Gemeindearbeit statt Amtshandlung: Der Konvent reinigt Siechenhäuser und Brunnen, die "
"Amtskirche segnet Herrschaft."
),
"4/traumgesicht": (
"Der Orden gibt Träume nicht heraus – wer ein Traumgesicht lernt, hinterlässt seine Frage "
"im Haus der Träume."
),
"4/grenzweihe": (
"Die Weihe eines Bezirks gehört den Hütern; sie verlangen einen Eid auf den Wachstein."
),
"3/eid binden": (
"Kein Eid wird ohne Zeugen gesprochen: Aribor hört zu, aber nur die Hüter halten das Wort "
"fest – und sie bürgen mit."
),
"4/zeichenlesen": (
"Zeichen lesen die Seher, nicht die Amtskirche: Der Orden deutet den Ort, und niemand sonst "
"bekommt die Bilder zu sehen."
),
}
# Liturgien ohne regulären Lehrplan: Sie werden ausschließlich an besonderen Stätten
# weitergegeben – nie „nebenbei“, nie auf Reisen (siehe §3.5).
NUR_SONDERORT = {"5/tote erwecken"}
# Besondere Lehrstätten: key -> [(Ort, Bedingung), ...]
SONDERORT: dict[str, list[tuple[str, str]]] = {
"5/tote erwecken": [
("Halle der Namen, Krypta unter dem Tempel zu Garana",
"nur mit Erlaubnis des Abts, nach drei Nächten Totenwache am offenen Sarg und einem "
"Gelöbnis für den Verstorbenen; die Lehre wird im Totenbuch verzeichnet"),
("Betkammer der Erz-Heilerin zu Lichtenwalde",
"nur nach Fürsprache der Erz-Heilerin und nur für Tote, die nicht über Garana kamen "
"(Bann-Dekret, §3.4) – als Gegenleistung für einen Dienst an der Kirche"),
],
"5/göttliche gemeinschaft": [
("Traumkammer im Haus der Träume zu Kandelstein",
"nur nach der Prüfung der Seher und unter Schweigegelübde; die erste Frage stellt der "
"Orden, nicht der Kleriker"),
],
"5/queste": [
("Schwurkapelle an der Burg Hammerwacht",
"nur wer den Schwur vor Zeugen spricht; der Lehrende nimmt die Queste an, die damit "
"beginnt"),
],
"5/insektenplage": [
("Feuerhof zu Garana",
"nur nach Rechtsurteil der Inquisition, im Beisein eines Richters – nie gegen Gläubige"),
],
"3/dauerhaftes licht": [
("Sonnenschrein in den Hügeln über Garana",
"nur in der Sonnenwendnacht; das Licht wird am Schrein entzündet und von dort getragen"),
],
"5/gemeinschaft mit der natur": [
("Steinkreis im Rabenforst",
"nur zur Sonnenwende, in Anwesenheit von mindestens drei Zirkelmitgliedern"),
],
}
SONDERORT_LABEL = "**Nur an besonderem Ort"
# Signaturfassungen: exklusiv je Gemeinschaft – die Standardliturgie bleibt überall,
# aber nur diese Gemeinschaft lehrt ihre eigene Formel (Hausregel §7).
# key -> [(code, Name der Fassung, Vorteil; Nachteil)]
SIGNATUREN: dict[str, list[tuple[str, str, str]]] = {
"1/licht": [
("KIR", "Amaunator-Licht",
"gilt als echtes Tageslicht, Untote im Umkreis fliehen; weithin sichtbar, "
"Heimlichkeit ausgeschlossen"),
],
"1/leichte wunden heilen": [
("KON", "Konvent-Heilung",
"heilt +2 TP zusätzlich; der Heiler verliert selbst 1 TP (Sühne am eigenen Leib)"),
],
"2/segen": [
("KON", "Segen der Aufgenommenen",
"wirkt auch auf Gebannte und Bußfertige, die sonst nicht gesegnet werden dürfen; "
"nur innerhalb eines Roten Hauses"),
("ARI", "Wachsteinsegen",
"hält bis zum nächsten Sonnenaufgang und gilt für jeden, der den Bezirk verteidigt; "
"außerhalb des geweihten Bezirks wirkungslos"),
],
"1/schutz vor bösem": [
("ARI", "Aribor-Wächter",
"Radius doppelt so groß; wirkt nur innerhalb eines geweihten Bezirks"),
],
"2/gesinnung erkennen": [
("SEH", "Seherblick",
"zeigt zusätzlich die schwerste Schuld des Ziels; das Ziel spürt den Blick und weiß, "
"dass es geprüft wurde"),
],
"1/verstricken": [
("NAT", "Zirkel-Verstrickung",
"Dauer verdoppelt; wirkt nur in unberührter Wildnis, nicht auf Feld oder Straße"),
],
"5/böses bannen": [
("KIR", "Sonnenwort",
"deckt zusätzlich Meineid und Eidbruch im Umkreis auf; wirkt nur bei Tageslicht"),
("SWF", "Richturteil",
"wirkt auch gegen namentlich Verurteilte, die nicht böse sind; ein Fehlurteil trifft "
"den Anwender mit (Gunststufe −1)"),
],
"3/fluch bannen": [
("SWF", "Schwertfeuer-Bann",
"+1 auf den Spruchcheck und deckt den Urheber auf; laut und amtlich, die Inquisition "
"erfährt davon"),
],
"3/krankheit heilen": [
("KIR", "Sonnenreinigung",
"heilt zusätzlich 1W4 TP; dauert eine Stunde Gebet, nicht im Kampf einsetzbar"),
],
"3/wasser atmen": [
("NAT", "Zirkel-Atem",
"Dauer verdoppelt; wirkt nur in natürlichem Gewässer, nicht in Zisternen oder Kanälen"),
],
"4/schwere wunden heilen": [
("KON", "Wundmal-Heilung",
"heilt +3 TP und hinterlässt keine Narbe; der Heiler trägt die Wunde sichtbar als Mal "
"und kann sich bis zur nächsten Rast nicht durch Rasten erholen"),
],
"5/göttliche gemeinschaft": [
("SEH", "Traumantwort",
"die Antwort kommt als Bild im Schlaf und ist deutbar; keine knappen Ja/Nein-Antworten "
"und nur einmal pro Monat"),
],
}
def signatur_lines(key: str) -> list[str]:
return [f"- **Signatur (nur hier) – {name}** ({GEMEINSCHAFT_NAME[code]}): {text}."
for code, name, text in SIGNATUREN.get(key, [])]
def sonderort_lines(key: str) -> list[str]:
return [f"- {SONDERORT_LABEL} – {ort}**: {bedingung}."
for ort, bedingung in SONDERORT.get(key, [])]
def key_of(grade: int, stem: str) -> str:
return f"{grade}/{stem.strip().lower()}"
def gemeinschaft_section(grade: int, klasse: str, stem: str) -> str:
key = key_of(grade, stem)
if klasse == "Druide":
lines = ["## Gemeinschaft", "", DRUIDE_NOTE, "",
f"- **Gelehrt von:** **{GEMEINSCHAFT_NAME['NAT']}** "
f"({GEMEINSCHAFT_FOCUS['NAT']})."]
lines += sonderort_lines(key)
return "\n".join(lines) + "\n"
if grade <= 2:
lines = [
"## Gemeinschaft",
"",
"> **Zugang:** Allgemeingut (Grad 1–2) – jede Gemeinschaft lehrt die "
"Standardfassung in der Grundausbildung "
"(siehe [[Liturgien und Glaubensgemeinschaften]] §3.1).",
]
g = FOCUS.get(key)
if g:
namen = ", ".join(f"**{GEMEINSCHAFT_NAME[c]}** ({GEMEINSCHAFT_FOCUS[c]})" for c in g)
lines += ["", f"- **Schwerpunkt bei:** {namen}.",
"- Andere Gemeinschaften beten die Liturgie ebenfalls, aber ohne eigene "
"Formel oder Zusatzausbildung."]
lines += signatur_lines(key)
lines += sonderort_lines(key)
return "\n".join(lines) + "\n"
g = MAPPING.get(key)
if not g:
return ""
namen = "; ".join(f"**{GEMEINSCHAFT_NAME[c]}** ({GEMEINSCHAFT_FOCUS[c]})" for c in g)
if key in NUR_SONDERORT:
zugang = (
"> **Zugang:** Kein Lehrplan. Diese Liturgie wird ausschließlich an besonderen "
"Stätten weitergegeben, unter Auflagen und nie nebenbei "
"(siehe [[Liturgien und Glaubensgemeinschaften]] §3.5)."
)
else:
zugang = (
"> **Zugang:** Lehrplan der Gemeinschaft ab Grad 3 – nicht Allgemeingut "
"(siehe [[Liturgien und Glaubensgemeinschaften]] §3.2)."
)
lines = [
"## Gemeinschaft",
"",
zugang,
"",
f"- **Gelehrt von:** {namen}.",
]
missing = [c for c in GEMEINSCHAFT_NAME if c not in set(g)]
if missing:
lines.append("- **Nicht im Angebot:** "
+ "; ".join(f"{GEMEINSCHAFT_NAME[c]} ({EXCLUDE_REASON[c]})" for c in missing)
+ ".")
hint = EXCLUSIVE_HINT.get(key)
if hint and len(g) == 1:
lines.append(f"- **Hinweis:** {hint}")
lines += signatur_lines(key)
lines += sonderort_lines(key)
return "\n".join(lines) + "\n"
def insert_section(text: str, section: str) -> str:
marker = "\n## Wirkung"
if marker not in text:
return text
head, rest = text.split(marker, 1)
return f"{head.rstrip()}\n\n{section}{marker}{rest}"
def main() -> None:
check = "--check" in sys.argv
force = "--force" in sys.argv
changed = 0
unknown: list[str] = []
already = 0
for path in sorted(SPELLS.rglob("*.md")):
grade = int(re.search(r"Grad (\d)", path.parent.name).group(1))
text = path.read_text(encoding="utf-8")
m = re.search(r"\*\*Klasse:\*\*\s*([A-Za-zÄÖÜäöüß]+)", text)
klasse = m.group(1) if m else "Kleriker"
section = gemeinschaft_section(grade, klasse, path.stem)
if not section:
unknown.append(f"Grad {grade}/{path.stem}")
continue
if "## Gemeinschaft" in text:
if not force:
already += 1
continue
text = re.sub(r"\n## Gemeinschaft\n.*?(?=\n## )", "\n", text, flags=re.S)
if check:
print(f"[check] {path.relative_to(ROOT)}")
continue
path.write_text(insert_section(text, section), encoding="utf-8")
changed += 1
print(f"ergänzt: {changed}, bereits vorhanden: {already}, unbekannt: {len(unknown)}")
for u in unknown:
print(" ??", u)
if __name__ == "__main__":
main()

401
tools/add_guild_notes.py Normal file
View file

@ -0,0 +1,401 @@
#!/usr/bin/env python3
"""Ergänzt in den arkanen Zauberdateien einen Abschnitt „Gilde".
Zuordnung folgt der Ausrichtung der Gilden (siehe
`RPG/5-Regeln/Hausregeln/Gildenzauber.md`):
KOL Königliches Magie-Kollegium – staatliche Lizenz, Kampf und Schutz
AKA Arkane Akademie – Erkenntnis, Divination, Illusion, Verwandlung
BRU Bruderschaft des Wortes – Schrift, Sprachen, Siegel, Wände, Information
ZFM Zentrum für Monsterüberwachung– Monsterkunde, Erkennung, Eindämmung, Feldmagie
KON Das arkane Konvent – Geist, Verwandlung, verbotene Grenzbereiche
ZIR Zirkel der Magier – Meta-Magie, seltene Varianten (kein Lehrbetrieb)
ELD Meister Eldoras' Akademie – Forschung, alte Siegel (keine offene Lehre)
Grad 1–2 sind Allgemeingut und werden überall gelehrt; dort wird nur ein
Schwerpunkt vermerkt. Ab Grad 3 gilt der Gildenlehrplan.
Aufruf: python3 tools/add_guild_notes.py [--check]
"""
from __future__ import annotations
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
SPELLS = ROOT / "RPG" / "5-Regeln" / "Zauber" / "Arkan"
GUILD_NAME = {
"KOL": "Königliches Magie-Kollegium",
"AKA": "Arkane Akademie",
"BRU": "Bruderschaft des Wortes",
"ZFM": "Zentrum für Monsterüberwachung",
"KON": "Das arkane Konvent",
"ZIR": "Zirkel der Magier",
"ELD": "Meister Eldoras' Akademie in Kandelstein",
}
GUILD_FOCUS = {
"KOL": "staatliche Lizenzlehre, Kampf- und Schutzzauber",
"AKA": "Erkenntnis, Divination, Illusion und Verwandlung",
"BRU": "Schrift, Sprachen, Siegel und Wände",
"ZFM": "Monsterkunde, Erkennung und Eindämmung",
"KON": "Geist, Verwandlung und verbotene Grenzbereiche",
"ZIR": "Meta-Magie und seltene Varianten, kein regulärer Lehrbetrieb",
"ELD": "Forschung und alte Siegel, keine offene Lehre",
}
# Zauber ab Grad 3: welche Gilden lehren sie?
MAPPING: dict[str, list[str]] = {
# ---- Grad 3 -----------------------------------------------------------
"blitzschlag": ["KOL"],
"feuerball": ["KOL"],
"fliegen": ["AKA", "KOL"],
"furcht": ["KON"],
"geisterform": ["KON"],
"hast": ["AKA", "KOL"],
"hellsehen": ["AKA"],
"illusion bannen": ["AKA"],
"infravision": ["AKA", "ZFM"],
"lähmung": ["KON", "KOL"],
"magie bannen": ["KOL"],
"nichtentdeckung": ["BRU", "AKA"],
"person festhalten": ["KOL", "ZFM"],
"phantomross": ["KON", "AKA"],
"schutz vor bösem": ["KOL"],
"schutz vor bösem, 3m radius": ["KOL"],
"schutz vor normalen geschossen": ["KOL"],
"schwarzes licht": ["KON"],
"seiltrick": ["AKA"],
"spektrale kraft": ["KON"],
"suggestion": ["KON"],
"trugbild": ["AKA"],
"unsichtbarkeit": ["AKA"],
"unsichtbarkeit – 3 m radius": ["AKA"],
"unsichtbarkeit – 3 m radius, illusionist": ["AKA"],
"wasser atmen": ["AKA"],
# ---- Grad 4 -----------------------------------------------------------
"andere verwandeln": ["AKA"],
"dimensionstür": ["AKA"],
"eiswand": ["KOL"],
"emotion": ["KON"],
"fester nebel": ["KOL"],
"feuerwand": ["KOL"],
"fluch bannen": ["KOL"],
"geringe erschaffung": ["AKA"],
"illusorische ausdauer": ["AKA"],
"massenverwandlung": ["AKA"],
"monster bezaubern": ["ZFM"],
"pflanzenwachstum": ["AKA"],
"phantastischer killer": ["AKA"],
"regenbogenmuster": ["AKA"],
"schattenmonster": ["KON"],
"schleier der verlassenheit": ["KON"],
"selbst verwandeln": ["AKA"],
"verbesserte unsichtbarkeit": ["AKA"],
"verwirrung": ["AKA"],
"zauberauge": ["BRU", "ZFM"],
# ---- Grad 5 -----------------------------------------------------------
"chaos": ["KON"],
"elementar beschwören": ["KOL", "AKA"],
"fels zu schlamm verwandeln": ["AKA"],
"große erschaffung": ["AKA"],
"halbschattenmonster": ["KON"],
"heimsuchung": ["KON"],
"höhere ebene kontaktieren": ["AKA", "KON"],
"illusion": ["AKA"],
"magisches gefäß": ["KON"],
"monster festhalten": ["ZFM"],
"projiziertes abbild": ["AKA"],
"schattenhafte verwandlung": ["KON"],
"schattenwurf": ["KON"],
"schein": ["AKA"],
"spiegellabyrinth": ["AKA"],
"spiegelwelt": ["AKA"],
"steinwand": ["BRU", "KOL"],
"telekinese": ["AKA"],
"teleportation": ["AKA"],
"todeswolke": ["KOL"],
"untote beleben": ["KON"],
"verstand schwächen": ["KON"],
"wand durchqueren": ["AKA"],
"zeitfluss": ["ZIR", "AKA"],
# ---- Grad 6 -----------------------------------------------------------
"antimagische hülle": ["KOL"],
"ausgelöste illusion": ["AKA"],
"desintegration": ["KOL"],
"durch den spiegel": ["AKA"],
"erde bewegen": ["AKA", "KOL"],
"geas": ["KON"],
"irreführung": ["AKA"],
"massensuggestion": ["KON"],
"permanente illusion": ["AKA", "ZIR"],
"reinkarnation": ["AKA", "KON"],
"säurenebel": ["KOL"],
"schatten": ["KON"],
"stein zu fleisch": ["AKA"],
"todeszauber": ["KOL", "KON"],
"traum manifestieren": ["KON"],
"traumqueste": ["KON"],
"unsichtbarer verfolger": ["ZFM", "AKA"],
"verkörperung": ["KON"],
"vision": ["AKA", "BRU"],
"wahrer blick": ["AKA", "BRU"],
"wasser senken": ["AKA"],
"wasser teilen": ["AKA"],
"schrift binden": ["BRU"],
"zunge lösen": ["BRU"],
"siegel siegeln": ["BRU"],
"alte zunge": ["ELD"],
"siegel erneuern": ["ELD"],
"formel lesen": ["ZIR"],
"verzögerter spruch": ["ZIR"],
"spruchdoppelung": ["ZIR"],
"wetterkontrolle": ["AKA"],
}
# Schwerpunkte für Allgemeingut-Zauber (Grad 1–2)
FOCUS: dict[str, list[str]] = {
"akustische illusion": ["AKA"],
"arkanes lesen": ["AKA", "BRU"],
"arkanes lesen (illusionist)": ["AKA"],
"bauchreden": ["KON"],
"chromatische kugel": ["AKA"],
"farbstrahl": ["AKA"],
"glamour": ["AKA"],
"hypnotismus": ["KON", "AKA"],
"illusion entdecken": ["AKA"],
"licht": ["AKA"],
"licht (illusionist)": ["AKA"],
"magie entdecken": ["AKA", "ZFM"],
"magischer riegel": ["BRU"],
"magisches geschoss": ["KOL"],
"nebelwand": ["AKA"],
"person bezaubern": ["KON"],
"phantastische kraft": ["AKA"],
"phantastische kraft (illusionist)": ["AKA"],
"schild": ["KOL"],
"schlaf": ["KON"],
"schrecken": ["KON"],
"schutz vor bösem": ["KOL"],
"schwebende scheibe": ["AKA"],
"sprachen lesen": ["BRU"],
"tanzende lichter": ["AKA"],
"blitz - taubheit": ["KON"],
"blindheit - taubheit": ["KON"],
"böses entdecken (magier)": ["KOL"],
"dauerhaftes licht (magier)": ["AKA"],
"esp (gedanken lesen)": ["AKA"],
"falsche aura": ["KON", "BRU"],
"faszinieren": ["KON", "AKA"],
"flammenpfeil": ["KOL"],
"flüsternder wind": ["AKA"],
"gegenstand lokalisieren (magier)": ["BRU", "ZFM"],
"hypnotisches muster": ["AKA"],
"klopfen": ["AKA", "BRU"],
"levitation": ["AKA"],
"magie entdecken (illusionist)": ["AKA"],
"magischer mund": ["BRU"],
"magischer verschluss": ["BRU"],
"netz": ["ZFM", "KOL"],
"phantastische kraft (magier)": ["AKA"],
"quasimorph": ["KON"],
"spiegelbilder": ["AKA"],
"spiegelbilder (illusionist)": ["AKA"],
"unsichtbares entdecken": ["ZFM", "AKA"],
"unsichtbarkeit (illusionist)": ["AKA"],
"dunkelheit": ["KON"],
"unsichtbarkeit": ["AKA"],
"verbesserte phantastische kraft": ["AKA"],
"verschwimmen": ["AKA"],
}
EXCLUSIVE_HINT = {
"ZFM": "Monsterbezug ist Alleinstellungsmerkmal des Zentrums – keine andere Gilde lehrt diesen Zauber.",
"KON": "Verbotene Grenzlehre: nur das Konvent lehrt diesen Zauber, andere Gilden verweigern ihn.",
"ZIR": "Meta-Magie: Der Zirkel lehrt nicht für Fremde – Aufnahme nur über Meisterprüfung und ein Dienstversprechen.",
}
# Exklusive Signaturfassungen: Die Standardversion lehrt jede Gilde, aber nur die
# genannte Gilde lehrt ihre eigene Fassung (siehe Gildenzauber §5).
# key -> [(code, Name der Fassung, "Vorteil; Nachteil")]
SIGNATUREN: dict[str, list[tuple[str, str, str]]] = {
"feuerball": [
("KOL", "Kollegiums-Feuerball", "Radius 4,5 m statt 6 m, dafür +1 auf den Spruchcheck; "
"kleinerer Wirkungsbereich"),
("AKA", "Akademie-Feuerball", "kann einen Verbündeten im Wirkungsbereich ausnehmen; "
"−1 auf den Spruchcheck"),
],
"magisches geschoss": [
("KOL", "Kollegiums-Geschoss", "+1 auf den Spruchcheck; kein zusätzlicher Schaden, "
"streng lizenzierte Komponente"),
],
"schild": [
("KOL", "Kollegiums-Schild", "RK 3 gegen alle Angriffe; Dauer nur 1 Phase"),
],
"licht": [
("AKA", "Akademie-Licht", "Dauer 12 Phasen; Radius nur 3 m"),
],
"unsichtbarkeit": [
("AKA", "Akademie-Unsichtbarkeit", "doppelte Dauer; endet, wenn das Ziel spricht"),
],
"schlaf": [
("KON", "Konvents-Schlaf", "2W8 TW + 1W4 TW betroffen; Ziele erhalten +2 auf den Rettungswurf"),
],
"magischer riegel": [
("BRU", "Bruderschafts-Riegel", "Dauer 4W6 Phasen; das Öffnen ist laut und alarmiert die "
"Umgebung"),
],
"magischer mund": [
("BRU", "Bruderschafts-Mund", "bis zu 50 Wörter; nur eine Auslösung, danach endet der Zauber"),
],
"monster festhalten": [
("ZFM", "Monsterfessel", "+1 auf den Spruchcheck gegen natürliche Monster; wirkt nur gegen "
"Tiere, Riesentiere und magische Bestien, nicht gegen Humanoide, "
"Untote oder intelligente Monster"),
],
"zauberauge": [
("ZFM", "Jägerauge", "sieht auch unsichtbare Kreaturen und Wärmespuren; das Auge ist für "
"magische Detektion sichtbar, kürzere Dauer"),
],
"zeitfluss": [
("ZIR", "Zirkel-Zeitfluss", "wirkt auch auf einen Verbündeten in Reichweite; der Anwender "
"altert um 1W4 Jahre"),
],
"permanente illusion": [
("ZIR", "Zirkel-Permanenz", "hält bis zur nächsten Sonnenwende, ohne Bindung an einen Ort; "
"nur einmal pro Monat wirkbar"),
],
"klopfen": [
("ELD", "Eldoras-Schlüssel", "öffnet auch magisch versiegelte Türen und Truhen; die Öffnung "
"ist laut und hinterlässt eine sichtbare Spur"),
],
"steinwand": [
("ELD", "Eldoras-Wand", "hält doppelt so lange und ist gegen Bannen resistent; wirkt nur in "
"altem Mauerwerk, Fels oder Fundament"),
],
}
def signatur_lines(stem: str) -> list[str]:
key = base_name(stem)
return [f"- **Signatur (nur hier) – {name}** ({GUILD_NAME[code]}): {text}."
for code, name, text in SIGNATUREN.get(key, [])]
EXCLUDE_REASON = {
"KOL": "kein Kampf- oder Schutzzauber, damit nicht Teil der Lizenzlehre",
"AKA": "kein Forschungsfeld der Akademie",
"BRU": "kein Bezug zu Schrift, Sprachen, Siegeln oder Wänden",
"ZFM": "kein Monster- oder Feldbezug",
"KON": "liegt außerhalb der verbotenen Grenzbereiche",
"ZIR": "kein Standardlehrbetrieb, nur Varianten und Meta-Magie",
"ELD": "reine Forschung, keine Lehre für Fremde",
}
def base_name(stem: str) -> str:
return re.sub(r"\s*\([^)]*\)", "", stem).strip().lower()
def guild_section(kind: str, grade: int, stem: str) -> str:
key = stem.lower()
base = base_name(stem)
if grade <= 2:
gilden = FOCUS.get(key) or FOCUS.get(base)
lines = [
"## Gilde",
"",
"> **Zugang:** Allgemeingut (Grad 1–2) – alle Gilden lehren die "
"Standardversion, unabhängig von ihrer Ausrichtung "
"(siehe [[Gildenzauber]]).",
]
if gilden:
namen = ", ".join(
f"**{GUILD_NAME[g]}** ({GUILD_FOCUS[g]})" for g in gilden
)
lines.append("")
lines.append(f"- **Schwerpunkt bei:** {namen}.")
lines.append(
"- Andere Gilden lehren den Zauber ebenfalls, aber ohne "
"eigene Variante oder Zusatzausbildung."
)
lines += signatur_lines(stem)
return "\n".join(lines) + "\n"
gilden = MAPPING.get(base) or MAPPING.get(key)
if not gilden:
return "" # unbekannt -> im Check melden
namen = "; ".join(f"**{GUILD_NAME[g]}** ({GUILD_FOCUS[g]})" for g in gilden)
lines = [
"## Gilde",
"",
"> **Zugang:** Gildenlehrplan ab Grad 3 – nicht Allgemeingut "
"(siehe [[Gildenzauber]]).",
"",
f"- **Gelehrt von:** {namen}.",
]
taught = set(gilden)
missing = [g for g in GUILD_NAME if g not in taught]
if missing:
lines.append(
"- **Nicht im Angebot:** "
+ "; ".join(f"{GUILD_NAME[g]} ({EXCLUDE_REASON[g]})" for g in missing)
+ "."
)
if len(gilden) == 1 and gilden[0] in EXCLUSIVE_HINT:
lines.append(f"- **Hinweis:** {EXCLUSIVE_HINT[gilden[0]]}")
lines += signatur_lines(stem)
return "\n".join(lines) + "\n"
def insert_section(text: str, section: str) -> str:
marker = "\n## Wirkung"
if marker not in text:
return text
head, rest = text.split(marker, 1)
return f"{head}\n\n{section}{marker}{rest}"
def main() -> None:
check = "--check" in sys.argv
force = "--force" in sys.argv
changed = 0
unknown: list[str] = []
already = 0
for path in sorted(SPELLS.rglob("*.md")):
grade = int(re.search(r"Grad (\d)", path.parent.name).group(1))
text = path.read_text(encoding="utf-8")
section = guild_section("", grade, path.stem)
if not section:
unknown.append(f"Grad {grade}/{path.stem}")
continue
if "## Gilde" in text:
if not force:
already += 1
continue
text = re.sub(r"\n## Gilde\n.*?(?=\n## )", "\n", text, flags=re.S)
if check:
print(f"[check] {path.relative_to(ROOT)}")
continue
path.write_text(insert_section(text, section), encoding="utf-8")
changed += 1
print(f"ergänzt: {changed}, bereits vorhanden: {already}, unbekannt: {len(unknown)}")
for u in unknown:
print(" ??", u)
if __name__ == "__main__":
main()

58
tools/autowidth.lua Normal file
View file

@ -0,0 +1,58 @@
-- Verteilt Tabellenspalten proportional zur Inhaltslänge (statt gleicher
-- Breiten aus der Markdown-Trennzeile). Für Tabellen mit langer
-- Beschreibungsspalte (typisch bei RPG-Tabellen) deutlich besser lesbar.
--
-- Die Breite einer Spalte = max. Zeichenlänge ihrer Zellen (Header + Rumpf),
-- normalisiert auf Anteile. Mindestbreite 12 %, um schmale Kennspalten
-- (z. B. "d6") nicht zu erdrücken.
local FLOOR = 0.08
local function strlen(s)
local ok, n = pcall(utf8.len, s)
if ok then return n end
return #s
end
local function celltext(blocks)
return pandoc.utils.stringify(blocks)
end
function Table(tbl)
local ncols = #tbl.colspecs
if ncols < 1 then return tbl end
local lens = {}
for i = 1, ncols do lens[i] = 1 end
local function measure(cells)
for i, cell in ipairs(cells) do
local l = strlen(celltext(cell.contents))
if l > lens[i] then lens[i] = l end
end
end
if tbl.head and tbl.head.rows then
for _, row in ipairs(tbl.head.rows) do measure(row.cells) end
end
for _, body in ipairs(tbl.bodies) do
for _, row in ipairs(body.body) do measure(row.cells) end
end
local total = 0
for i = 1, ncols do
lens[i] = math.sqrt(lens[i])
total = total + lens[i]
end
if total > 0 then
for i = 1, ncols do
local w = lens[i] / total
if w < FLOOR then w = FLOOR end
-- ColSpec ist positionsbasiert: [1]=align, [2]=width
tbl.colspecs[i][2] = w
end
end
return tbl
end

View file

@ -0,0 +1,999 @@
#!/usr/bin/env python3
"""
Baut das Spieler-Handout "Göttliche Liturgien – Ein Summarium für Terian".
Klerikales Gegenstück zu `build_zauber_almanach.py` (Magier-Summarium).
Inhalt:
1. Titelblatt (mit Kopfband-Illustration `RPG/7-Prep/prep_2026-11-20/liturgie_titelband.png`,
Gegenstück zum Magierband `summarium_titelband.png`)
2. Vorwort von Vater Damian (Methaven)
3. Loses Blatt: Vom Maß des Gebets (Entrückung)
4. Gemeinschaften-Teil: Hausregeln aus
`RPG/5-Regeln/Hausregeln/Liturgien und Glaubensgemeinschaften.md`
(Gebetskapazität, Sonnenritus, Zugang nach Grad, Gebetswoche, Gunst/Buße,
Umkehrungen, Varianten, Entrückung, Geografie des Glaubens)
5. Liturgien nach Grad (nur Klasse Kleriker, Detail aus 5-Regeln/Zauber/Klerikal)
6. Kurzreferenz + Anhang: Liturgien des Naturzirkels (Druiden)
Datenquelle für „Gelehrt von“ sind die `## Gemeinschaft`-Abschnitte der
Liturgiedateien (erzeugt von `tools/add_gemeinschaft_notes.py`).
**Textregel (Spielerhandout!):** Nur Beobachtbares beschreiben. Keine SL-Erklärungen –
kein Ferrum (nicht bekannt, die Erz-Heilerin gibt metallische Heiltränke als Gnadengabe
aus), keine Motivationen von NPCs, keine Ursachen von Konflikten. Zwiespalt ja, Deutung
nein: „Wie es dazu kam, erzählt jede Seite anders.“
Aufruf:
.venv/bin/python tools/build_liturgie_summarium.py [-o ausgabe.pdf]
"""
from __future__ import annotations
import argparse
import re
import sys
from pathlib import Path
from reportlab.lib import colors
from reportlab.lib.pagesizes import A5
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import mm
from reportlab.platypus import (BaseDocTemplate, CondPageBreak, Frame, Image as RLImage,
KeepTogether, NextPageTemplate, PageBreak, PageTemplate,
Paragraph, Spacer, Table, TableStyle)
from reportlab.platypus.tableofcontents import TableOfContents
sys.path.insert(0, str(Path(__file__).resolve().parent))
from build_zauber_almanach import (AlmanachDoc, Heading, Rule, S, als_a4, # noqa: E402
block_flowables, inline, page_decoration, plain, shaded_box,
title_decoration, ACCENT, GREY, INK, MARGIN_BOT,
MARGIN_TOP, MARGIN_X, PAGE_H, PAGE_W, RULE)
from add_gemeinschaft_notes import SIGNATUREN # noqa: E402
ROOT = Path(__file__).resolve().parent.parent
VAULT = ROOT / "RPG"
# Prep-Material liegt pro Prep-Session in einem eigenen Unterordner
PREP = VAULT / "7-Prep" / "prep_2026-11-20"
SPELL_DIR = VAULT / "5-Regeln" / "Zauber" / "Klerikal"
TITLE_IMAGE = PREP / "liturgie_titelband.png"
# Klerikaler Akzent: dunkles Gold statt Zauberrot
GOLD = colors.HexColor("#84601a")
import build_zauber_almanach as _base # noqa: E402
_base.ACCENT = GOLD
for _style in S.values():
if getattr(_style, "textColor", None) == ACCENT:
_style.textColor = GOLD
BULLET = "\u2022"
GEMEINSCHAFT_NAME = {
"KIR": "Kirche des Amaunator",
"KON": "Scharlachroter Konvent",
"SWF": "Jünger des Schwertfeuers",
"SEH": "Orden der Seher",
"ARI": "Hüter von Aribor",
"NAT": "Naturzirkel",
}
KURZ = {"Kirche des Amaunator": "KIR", "Scharlachroter Konvent": "Ko",
"Jünger des Schwertfeuers": "SF", "Orden der Seher": "Seh",
"Hüter von Aribor": "Ar", "Naturzirkel": "Nat"}
LEGENDE = [
("KIR", "Kirche des Amaunator"),
("Ko", "Scharlachroter Konvent"),
("SF", "Jünger des Schwertfeuers"),
("Seh", "Orden der Seher"),
("Ar", "Hüter von Aribor"),
("Nat", "Naturzirkel (Druiden)"),
("†", "nur an einer besonderen Lehrstätte, unter Auflage"),
]
# ---------------------------------------------------------------- Tabellen aus Markdown
def md_flowables(lines: list[str]) -> list:
"""Wie block_flowables, aber mit spaltenzahlabhängigen Tabellenbreiten."""
out: list = []
rows: list[list[str]] = []
def flush():
nonlocal rows
if not rows:
return
if len(rows) > 1:
cols = max(len(r) for r in rows)
rows = [r + [""] * (cols - len(r)) for r in rows]
weights = []
for c in range(cols):
longest = max(len(plain(r[c])) for r in rows)
weights.append(max(longest, 8))
total = sum(weights)
width = PAGE_W - 2 * MARGIN_X
col_widths = [width * w / total for w in weights]
data = [[Paragraph(inline(c), S["cell_h" if i == 0 else "cell"]) for c in row]
for i, row in enumerate(rows)]
t = Table(data, colWidths=col_widths, hAlign="LEFT", repeatRows=1)
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), GOLD),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.3, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f7f2e6")]),
("LEFTPADDING", (0, 0), (-1, -1), 3),
("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 1.8),
("BOTTOMPADDING", (0, 0), (-1, -1), 1.8),
]))
out.append(t)
out.append(Spacer(1, 3))
rows = []
for line in lines:
s = line.rstrip()
if s.startswith("|"):
cells = [c.strip() for c in s.strip("|").split("|")]
if all(re.fullmatch(r":?-{2,}:?", c) for c in cells if c):
continue
rows.append(cells)
continue
flush()
if not s.strip():
continue
if s.startswith("### "):
out.append(Paragraph(inline(s[4:]), S["h4"]))
continue
if s.startswith("> "):
out.append(Paragraph(inline(s[2:]), S["quote"]))
continue
m = re.match(r"^[-*]\s+(.*)$", s)
if m:
out.append(Paragraph(inline(m.group(1)), S["bullet"], bulletText=BULLET))
continue
if re.fullmatch(r"-{3,}", s.strip()):
out.append(Rule(space_before=2, space_after=2))
continue
out.append(Paragraph(inline(s), S["body"]))
flush()
return out
def text_block(*lines: str) -> list:
return md_flowables(list(lines))
def simple_table(rows: list[list[str]], weights: list[float] | None = None) -> Table:
width = PAGE_W - 2 * MARGIN_X
cols = len(rows[0])
weights = weights or [1] * cols
total = sum(weights)
data = [[Paragraph(inline(c), S["cell_h" if i == 0 else "cell"]) for c in row]
for i, row in enumerate(rows)]
t = Table(data, colWidths=[width * w / total for w in weights], hAlign="LEFT", repeatRows=1)
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), GOLD),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.3, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f7f2e6")]),
("LEFTPADDING", (0, 0), (-1, -1), 3),
("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 1.8),
("BOTTOMPADDING", (0, 0), (-1, -1), 1.8),
]))
return t
# ---------------------------------------------------------------- Liturgien parsen
def parse_spell(path: Path) -> dict:
sp = {"path": path, "title": None, "grad": None, "klasse": "Kleriker",
"dauer": "", "reichweite": "", "zugang": "", "lehrt": [], "sonderorte": [],
"signaturen": [], "sections": {}}
section = None
for line in path.read_text(encoding="utf-8").split("\n"):
s = line.rstrip()
if s.startswith("# ") and sp["title"] is None:
sp["title"] = s[2:].strip()
continue
if s.startswith("## "):
section = s[3:].strip()
sp["sections"].setdefault(section, [])
continue
if s.startswith("> "):
body = s[2:].strip()
m = re.search(r"\*\*Grad:\*\*\s*(\d+)", body)
if m:
sp["grad"] = int(m.group(1))
m = re.search(r"\*\*Klasse:\*\*\s*([A-Za-zÄÖÜäöüß]+)", body)
if m:
sp["klasse"] = m.group(1)
m = re.search(r"\*\*Dauer:\*\*\s*(.+?)\s*(?:·\s*\*\*Reichweite:\*\*|\*Reichweite)", body)
if m:
sp["dauer"] = re.sub(r"\*\*", "", m.group(1)).strip()
m = re.search(r"\*\*Reichweite:\*\*\s*(.+)", body)
if m:
sp["reichweite"] = re.sub(r"\*\*", "", m.group(1)).strip()
if section and section in sp["sections"]:
sp["sections"][section].append("> " + body)
continue
if section:
sp["sections"][section].append(s)
for line in sp["sections"].get("Gemeinschaft", []):
m = re.match(r"-\s+\*\*Nur an besonderem Ort\s+–\s+(.+?)\*\*:\s*(.+?)\.?$", line.strip())
if m:
sp["sonderorte"].append((m.group(1).strip(), handout_text(m.group(2).strip())))
continue
m = re.match(r"-\s+\*\*Signatur \(nur hier\)\s+–\s+(.+?)\*\*\s*\((.+?)\):\s*(.+?)\.?$",
line.strip())
if m:
sp["signaturen"].append((m.group(1).strip(), m.group(2).strip(),
handout_text(m.group(3).strip())))
continue
if "Gelehrt von" in line or "Schwerpunkt bei" in line:
for name in re.findall(r"\*\*([^*]+)\*\*", line):
if name.lower() in ("gelehrt von:", "schwerpunkt bei:"):
continue
sp["lehrt"].append(name.strip())
sp["lehrt"] = [n for n in sp["lehrt"] if not n.endswith(":")]
return sp
def load_spells() -> list[dict]:
spells = []
for grad_dir in sorted(SPELL_DIR.glob("Grad *"), key=lambda p: int(p.name.split()[1])):
for md in sorted(grad_dir.glob("*.md")):
sp = parse_spell(md)
if sp["title"] and sp["grad"]:
spells.append(sp)
return spells
def kurz(name: str) -> str:
return KURZ.get(name.strip(), name.strip())
def handout_text(text: str) -> str:
"""Entfernt Vault-Interna aus übernommenen Textzeilen (§-Verweise, „siehe“-Links).
Die Paragraphennummern gehören zur Hausregeldatei – im Spielerhandout gibt es
keine §-Nummerierung, dort bleibt nur der Name der Regel stehen.
"""
t = re.sub(r"\s*\(?siehe\s+\[\[[^\]]+\]\][^)]*\)?", "", text)
t = re.sub(r",?\s*§\s*\d+(?:\.\d+)?", "", t)
t = re.sub(r"[,;]?\s*siehe\s*(?=[.,;)]|$)", "", t)
t = re.sub(r"[,;]\s*$", "", t)
t = re.sub(r"\(\s*[,;]?\s*\)", "", t)
t = re.sub(r"\s+([.,;)»])", r"\1", t)
return t.strip()
# ---------------------------------------------------------------- Textbausteine
VORWORT = [
"Terian,",
"du hast in Methaven angefangen, an einem Schrein mit einer Bank, zwei Kerzen und einem Dach, "
"das bei Westwind tropft. Du hast gelernt, was man dort lernen kann: das Licht, den Segen, die "
"leichte Handauflegung, das Erkennen von Gut und Böse. Das war keine schlechte Ausbildung. Es "
"war nur eine kurze.",
"Denn Methaven hat **keine Betkammer**. Ich kann dir das Grundgebet beibringen, und ich kann dir "
"sagen, wann du bereit bist für mehr – aber ich kann dir das Mehr nicht geben. Wer Liturgien "
"weitergibt, gibt Amt weiter, und Amt habe ich hier nicht. Das ist keine Bescheidenheit, das ist "
"Kirchenrecht. **Ich habe dir deshalb dieses Buch zusammengestellt, statt dich zu lehren.**",
"Was darin steht, ist aus Tempelabschriften zusammengetragen – aus Garana, aus Lichtenwalde, und "
"aus zwei Büchern, die ich lieber nicht benenne. Es ist kein vollständiges Werk. Es ist ein "
"Summarium: erst die Ordnung, in der wir beten (wie Gunst funktioniert, was der Sonnenritus ist, "
"wie eine Gebetswoche abläuft und was eine Umkehrung kostet), dann die Liturgien selbst, geordnet "
"nach Grad, mit der Angabe, **welche Gemeinschaft sie lehrt**.",
"Nimm diesen letzten Punkt ernst. In diesen Landen ist niemand ein Kleriker überhaupt, sondern "
"immer ein Kleriker **von etwas**. Die Kirche des Amaunator hat den Tempel in Garana und die "
"Erz-Heilerin in Lichtenwalde – und zwei Zentren bedeuten zwei Antworten auf dieselbe Frage. Der "
"Scharlachrote Konvent heilt jeden, auch den Ketzer, und nennt das Sühne. Die Jünger des "
"Schwertfeuers lehren schnell und laut und verlangen dafür einen Ketzer. Die Seher verkaufen dir "
"Deutung und nehmen Schweigen. Die Hüter von Aribor lehren nur, wer den Eid auf den Stein ablegt. "
"Und der Naturzirkel lässt dich erst eine Nacht allein im Hain stehen, bis du weißt, welche Eiche "
"deine Mistel trägt – und erst dann zeigt er dir, wie man Dornen wachsen lässt.",
"Du kannst bei jeder Gemeinschaft Liturgien lernen. Du kannst nicht bei allen gleichzeitig zu Hause "
"sein. **Such dir aus, wem du folgen willst – und dann folge konsequent genug, dass man es dir "
"ansieht.** Wer überall ein wenig betet, wird nirgends erhört. Die Menschen merken es eher als "
"die Gottheit – und sie verzeihen es seltener.",
"Ich weiß, was in Garana gerade geschieht: Es liegt ein Bann-Dekret in der Luft, und zwei Häuser "
"legen es unterschiedlich aus – beide berufen sich auf dieselbe Sonne. Ich weiß auch, dass du dich "
"in diesem Streit wirst entscheiden müssen. Ich gebe dir keinen Rat für die eine Seite. Ich gebe dir "
"nur das hier: **Sprich mit beiden, bevor du einer Seite recht gibst.** Ein Bann kann Ordnung sein "
"oder auch nicht – man erkennt den Unterschied nur, wenn man die Betroffenen ansieht.",
"Und noch etwas, das kein Summarium dir abnimmt: Du bist nicht der einzige Geweihte in dieser "
"Gruppe. Der Paladin neben dir hat seinen Schwur, und du hast deinen. Ein Schwur, den man an deiner "
"Stelle für dich spricht, ist nichts wert. Ebenso wenig ein Eid, den du brichst, weil es grad "
"bequem ist. Ich sage das nicht als Warnung, sondern weil ich dich kenne: Du wirst in Versuchung "
"kommen, das Richtige sehr laut zu tun.",
"Betest du, dann aufrecht, und mit dem Gesicht zur aufgehenden Sonne – nicht zur Menge. Hilf dem, "
"der vor dir steht, bevor du den erklärst, der hinter dir steht. Und wenn du einmal nicht mehr "
"weißt, wem du eigentlich folgst: komm zurück nach Methaven und sieh nach dem Schrein, an dem du "
"angefangen hast. Dort brennt eine Kerze, und die Bank ist frei. Setz dich hin, bevor du "
"weiterziehst.",
"Vater Damian, Geweihter des Amaunators zu Methaven",
]
LOSES_BLATT = [
"Was in keinem Lehrplan steht und was man dir in keiner Betkammer sagen wird, weil man es dort "
"nicht sagen muss: Wo die Gunst der Gottheit ist, ist sie nicht unbegrenzt.",
"Der Kleriker glaubt gern, er bete nur. Aber jedes Gebet, das Erhörung findet, geht durch ihn "
"hindurch – nicht durch seinen Willen, sondern durch seine Fassungskraft. Und diese Kraft ist bei "
"jedem anders groß. Solange du sie nicht überschreitest, spürst du sie nicht; das ist das "
"Heimtückische an der Sache. Es gibt keinen Schmerz beim Überschreiten, kein Zeichen vorher.",
"Was danach kommt, sieht nicht wie Strafe aus, sondern wie Erwählung: Zeichen an Haut und Hand, "
"eine Wahrheit, die man nicht mehr abschalten kann, ein Licht, das aus einem herausleuchtet. Ich "
"habe einen Kaplan gekannt, der an einem einzigen Nachmittag sechs Liturgien wirkte. Bei der "
"siebten versagte ihm die Stimme. Er stand vier Stunden lang stumm neben einem Kind mit "
"gebrochenem Arm und konnte nicht einmal sagen, dass es nicht schlimm sei. Am Abend war die Stimme "
"zurück. Der Arm ist krumm zusammengewachsen. Niemand hat ihn dafür getadelt, und er hat es nie "
"vergessen.",
"**Führ Buch über deine Gebete.** Nicht weil die Gottheit mitzählt – sondern weil du aufhören "
"können musst, solange du es noch selbst entscheidest.",
]
MERKSAETZE = [
"Wer nur betet, wenn es drängt, betet umsonst.",
"Das Maß ist nicht dein Eifer, sondern deine Fassung.",
"Überschreitung merkst du nicht beim Beten – erst danach, an dir.",
"Zeichen sind Antworten, keine Auszeichnungen.",
]
GEMEINSCHAFTEN = [
("Kirche des Amaunator",
"Die anerkannte Amtskirche der Westreiche: Gott der Ordnung und Beständigkeit, Symbol die Sonne. "
"Sie segnet Herrschaft, hält Eide, heilt die Gläubigen und wacht darüber, wer als rechtmäßig gilt. "
"Wer eine höhere Liturgie erbitten will, muss sich an den örtlichen Klerus wenden – und dafür gibt "
"es zurzeit zwei Orte: den Tempel in Garana und die Erz-Heilerin in Lichtenwalde. Beide lehren, "
"beide weihen, und zwischen ihnen steht ein Bann-Dekret. Wie es dazu kam, erzählt jede Seite "
"anders.",
"Weihe, Rang und Tempeldienst; Zulassung durch den örtlichen Klerus"),
("Scharlachroter Konvent",
"Heilender Zweig und kämpfender Arm in den Rote Häusern vor den Mauern: Heilung, Sühne, Reinigung "
"– ohne Ansehen der Person, auch bei Ketzern und Fremden. Die Amtskirche nennt ihn Sekte; seine "
"Heilungen gelten auch Gebannten, und daran stoßen sich beide Seiten. Als Liturgiequelle ist er "
"offen und freundlich; er bindet seine Helfer dafür nach einer Probezeit.",
"Aufnahme als Helfer, Probezeit, Gehorsam gegenüber dem Konvent"),
("Jünger des Schwertfeuers",
"Inquisition: Häresie aufspüren, richten, bannen. Sie sitzen im Feuerhof zu Garana – in "
"derselben Stadt wie der Tempel, dem sie misstrauen – und reisen nur auf Anruf von Adel und "
"Paktlords. Ihre Liturgien erkennen, treffen und bannen; sie kommen nie umsonst.",
"Berufung, Inquisitionsauftrag, Gehorsam – oft bezahlt mit einem Ketzer"),
("Orden der Seher",
"Prophezeiung, Träume und Zeichendeutung. Sitz ist der Turm der Seher im Adelsviertel zu Garana; "
"er hat keinen Publikumsverkehr – man hinterlässt eine Frage und wartet. Gelernt wird im "
"Schweigen; Schweigegelübde ist Aufnahmebedingung.",
"Einladung, Prüfung der Seher, Schweigegelübde"),
("Hüter von Aribor",
"Wächter eines heiligen Ortes, dessen Lage geheim ist. Keine Mission, keine Predigt, keine Werbung "
"– Schutzwacht und Bewahrung. Ihre Liturgien schützen, versiegeln und bannen; sie werden nur auf "
"Aribor selbst gelehrt.",
"Vereidigung auf Aribor, Wachdienst, Fürsprache"),
("Naturzirkel",
"Druiden und Wanderer an Steinkreisen; Schirmherren von Gleichgewicht und Jahreszeit, kein Sitz in "
"einer Stadt, in Garana nur Gärtner. Sie lehren, was keine Kirche lehrt: Feenfeuer, Verstricken, "
"Rindenhaut, Wachstum, Blitz und Wetter. Elias ist einer ihrer Wanderer.",
"Mistelweihe, Zirkelaufnahme, Eide des Gleichgewichts"),
]
ZUGANG = [
["Rang", "Voraussetzung", "Zugang"],
["Novize", "Aufnahme, Weihe", "Grad 1–2"],
["Geweihter", "Probezeit, erste Prüfung", "Grad 3"],
["Priester", "Weihe durch einen Prälaten, Gemeindedienst", "Grad 4"],
["Prälat", "Amt, Verdienst, Fürsprache; darf weihen und lehren", "Grad 5–6"],
["Erz-Kleriker", "Führung einer Kirche oder eines Ordens", "alle Liturgien, Liturgie-Politik"],
]
ZIRKEL_AUFNAHME = [
"**Mistelweihe:** Du erntest selbst einen Mistelzweig – mit der Sichel, bei Mondlicht, von einer "
"Eiche, die du benennen kannst. Der Zweig ist danach dein Symbol: **ohne ihn keine Liturgie**, "
"auch keine, die du längst kennst.",
"**Fürsprache:** Ein Zirkelmitglied bürgt für dich – Elias wäre der naheliegende Name. Ohne "
"Fürsprache keine Prüfung.",
"**Prüfung an der Sonnenwende:** eine Nacht und ein Tag allein im Hain, ohne Feuer, ohne Waffe, "
"ohne Gebet an eine andere Gottheit. Wer geht, kommt nicht wieder.",
"**Eid des Gleichgewichts:** die Wildnis schützen, nicht die Menschen bekämpfen; nicht roden, "
"nicht brandschatzen, nicht jagen, was du nicht isst; Heilung niemals umkehren.",
"**Doktrin:** keine metallische Rüstung, keine schneidenden Waffen – auch nicht als Gast.",
"**Schweigen:** über die Haine wird nicht gesprochen. Wer sie verrät, verliert die Fürsprache "
"und die Liturgien mit ihr.",
]
ZIRKEL_DOPPELBINDUNG = (
"**Für dich, Terian, heißt das:** Du kannst die Zirkellehre lernen – aber du kannst kein Amt im "
"Zirkel tragen, und die Kirche sieht darin eine Neigung, keine Mitgliedschaft. Wer beides will, "
"muss es beiden Seiten offen sagen. Die Gebetswoche kommt zusätzlich, und der Zweig muss in "
"deiner Hand sein, nicht in deinem Gepäck."
)
GUNST = [
["Stufe", "Zustand", "Wirkung"],
["3 – Im Licht", "Gebote gehalten, Sonnenritus gehalten, keine unheiligen Mittel",
"kein Abzug; neue Liturgien lernbar"],
["2 – Gedämpft", "kleine Verfehlung, Ritus wochenlang versäumt, Streit mit dem eigenen Klerus",
"−1 auf alle Spruchchecks; keine neuen Liturgien bis zur Buße"],
["1 – Ferne", "schwere Verfehlung, Gebotsbruch, Machtmissbrauch, unheilige Mittel",
"−2 auf Spruchchecks; Grad 4+ gesperrt; Grad 1 nur in schwacher Fassung"],
["0 – Abgefallen", "klerikaler Patzer mit kritischem Fehler, Bruch des Kernsgebots, Gebrauch verbotener Mittel",
"alle klerikalen Fähigkeiten weg bis zur Buße"],
]
BUSSE = [
["Schwere", "Bußauflage", "Dauer / Kosten", "Rückgewinn"],
["Leicht", "Fasten und Nachtwache im Schrein, Geständnis", "1 Tag, 5 Taler Opfer", "+1 Stufe"],
["Mittel", "Tempeldienst, Wallfahrt, Verzicht auf einen Zaubereffekt",
"1 Woche, 20 Taler oder ein Dienst", "+1 Stufe"],
["Schwer", "Pilgerfahrt, Sühnequeste, Weihe neu ablegen", "Wochen bis Monate, Abenteuer",
"+1 Stufe, frühestens bei 1"],
["Abgefallen", "öffentliche Sühne, Aufgabe eines Besitzes oder Amtes, Prüfung durch einen Prälaten",
"ein Abenteuer", "0 → 1, dann wie „Schwer“"],
]
UMKEHRUNGEN = [
["Liturgie", "Umkehrung", "KIR", "Ko", "SF", "Seh", "Ar", "Nat"],
["Leichte / Schwere Wunden heilen", "Wunden verursachen", "nein", "nein", "Urteil", "nein",
"nein", "nein"],
["Krankheit heilen", "Krankheit verursachen", "nein", "nein", "Urteil", "nein", "nein", "nein"],
["Furcht bannen", "Furcht verursachen", "ja", "nein", "ja", "nein", "nein", "ja"],
["Segen", "Fluch", "nein", "nein", "ja", "nein", "nein", "nein"],
["Licht / Dauerhaftes Licht", "Dunkelheit", "nein", "nein", "nein", "nein", "nein", "ja"],
["Fluch bannen", "Fluch legen", "ja", "ja", "ja", "nein", "ja", "nein"],
["Queste", "Queste aufheben", "ja", "ja", "ja", "nein", "nein", "nein"],
["Wasser atmen", "Wasser atmen aufheben", "ja", "nein", "nein", "nein", "ja", "ja"],
["Fels zu Schlamm verwandeln", "Schlamm zu Fels", "ja", "nein", "nein", "nein", "ja", "ja"],
["Tote erwecken", "Todesfinger", "nein", "nein", "Urteil", "nein", "nein", "nein"],
["Grenzweihe", "Grenzweihe brechen", "ja", "nein", "nein", "nein", "ja", "ja"],
]
PRAESENZ = [
["Stufe", "Was es vor Ort gibt", "Konsequenz für Liturgien"],
["Sitz", "vollständige Gemeinschaft: Prälat, Archiv, Betkammern",
"alle Liturgien der Gemeinschaft; Weihe und Rangverleihung"],
["Stützpunkt", "Schrein, Kapelle oder Gebetshaus mit einem Geweihten",
"Grad 1–3, Gebetswoche möglich; ab Grad 4 nur mit Fürsprache"],
["Zelle / Reiseprediger", "einzelner Geweihter, kein Gebäude, keine Betkammer",
"Grad 1–2; höhere Liturgien nur, was dieser eine NPC zufällig kennt"],
["Kein Zugang", "Ort ohne Präsenz",
"nur Gastgeleit in einem fremden Tempel oder Heimlichkeit"],
]
STANDORTE = [
["Gemeinschaft", "Sitz", "Stützpunkte", "Von Garana aus erreichbar"],
["Kirche des Amaunator", "Tempel in Garana (Abt Volus)",
"Lichtenwalde (Erz-Heilerin), Schrein Methaven (Vater Damian), Kapellen Weiherlaach und Hammerwacht",
"alles vor Ort – aber Grad 4+ faktisch nur in Lichtenwalde"],
["Scharlachroter Konvent", "altes Siechenhaus im Hügelland",
"Rote Häuser in Garana (vor der Mauer) und Aschenheim",
"ja, vor der Mauer; Heilung umsonst, aber nur mit Probezeit"],
["Jünger des Schwertfeuers", "Feuerhof in Garana",
"Zellen in Lichtenwalde und Kandelstein", "ja, aber teuer – Lehre gegen einen Ketzerauftrag"],
["Orden der Seher", "Turm der Seher, Garana",
"„Haus der Träume“ in Kandelstein", "nur über Zeichen – kein Publikumsverkehr"],
["Hüter von Aribor", "Aribor selbst (Lage geheim)",
"Wachstein an der Straße zum Hain", "nein – nur über Fürsprache oder Eid"],
["Naturzirkel", "kein Sitz, Steinkreise zu den Sonnenwenden",
"Haine im Rabenforst, Hügel um Weiherlaach, Rand des Kürbistals",
"nur außerhalb der Mauern – der nächste Hain liegt im Hügelland"],
]
def signaturen_tabelle(spells: list[dict]) -> list:
"""Übersicht der exklusiven Signaturfassungen (Quelle: add_gemeinschaft_notes)."""
titel = {(sp["grad"], sp["title"].lower()): sp["title"] for sp in spells}
rows = [["Standardliturgie", "Signatur", "Gemeinschaft", "Vorteil", "Nachteil"]]
for key in sorted(SIGNATUREN, key=lambda k: (int(k.split("/")[0]), k.split("/", 1)[1])):
grad, name = key.split("/", 1)
base = titel.get((int(grad), name), name.title())
for code, sig, text in SIGNATUREN[key]:
vorteil, _, nachteil = text.partition("; ")
rows.append([f"{base} (Grad {grad})", sig,
GEMEINSCHAFT_NAME.get(code, code), vorteil, nachteil or "–"])
return [Spacer(1, 1 * mm), simple_table(rows, [0.20, 0.20, 0.16, 0.23, 0.21]), Spacer(1, 2 * mm)]
# ---------------------------------------------------------------- Dokument
def page_frame(canvas, doc):
"""Wie im Magier-Summarium, aber mit klerikalem Kopf."""
canvas.saveState()
canvas.setFont("Sans", 7)
canvas.setFillColor(GREY)
canvas.drawString(MARGIN_X, PAGE_H - 11 * mm, "Göttliche Liturgien · Summarium")
canvas.setStrokeColor(RULE)
canvas.setLineWidth(0.4)
canvas.line(MARGIN_X, PAGE_H - 12.5 * mm, PAGE_W - MARGIN_X, PAGE_H - 12.5 * mm)
canvas.setFont("Serif", 8.5)
canvas.setFillColor(GOLD)
canvas.drawCentredString(PAGE_W / 2, 9.5 * mm, str(doc.page))
canvas.restoreState()
def abschnitt(story: list, text: str, style: str = "h2", level: int = 1,
min_space: float = 45 * mm) -> None:
"""Abschnittsüberschrift, die bei zu wenig Platz auf die nächste Seite rutscht.
So bleibt ein Abschnitt zusammen: Überschrift plus erster Absatz/Tabelle beginnen
nie in den letzten Zentimetern einer Seite.
"""
story.append(CondPageBreak(min_space))
story.append(Heading(text, S[style], level=level))
def build(outpath: Path):
spells = load_spells()
kleriker = [sp for sp in spells if sp["klasse"] == "Kleriker"]
druiden = [sp for sp in spells if sp["klasse"] == "Druide"]
doc = AlmanachDoc(
str(outpath), pagesize=A5,
leftMargin=MARGIN_X, rightMargin=MARGIN_X,
topMargin=MARGIN_TOP, bottomMargin=MARGIN_BOT,
title="Göttliche Liturgien – Ein Summarium für Terian",
author="Vater Damian zu Methaven",
subject="Liturgie-Summarium für Terian (Westreiche)",
)
frame = Frame(MARGIN_X, MARGIN_BOT, PAGE_W - 2 * MARGIN_X,
PAGE_H - MARGIN_TOP - MARGIN_BOT, id="body")
title_frame = Frame(20 * mm, 20 * mm, PAGE_W - 40 * mm, PAGE_H - 40 * mm, id="title")
doc.addPageTemplates([
PageTemplate(id="title", frames=[title_frame], onPage=title_decoration,
autoNextPageTemplate="body"),
PageTemplate(id="body", frames=[frame], onPage=page_frame),
])
story: list = []
# --- Titelblatt
story += [Spacer(1, 8 * mm)]
if TITLE_IMAGE.exists():
story += [RLImage(str(TITLE_IMAGE), width=118 * mm, height=118 * mm * 516 / 1276),
Spacer(1, 10 * mm)]
else:
story += [Spacer(1, 14 * mm)]
story += [Paragraph("Göttliche Liturgien", S["title"]),
Rule(width_frac=0.34, thickness=0.9, space_before=6, space_after=8, color=GOLD),
Paragraph("Ein Summarium für Terian", S["subtitle"]),
Spacer(1, 11 * mm),
Paragraph("Gemeinschaft. Gebet. Gunst.", S["smallcaps"]),
Spacer(1, 3 * mm),
Paragraph("Zusammengestellt in Methaven von Vater Damian", S["smallcaps"]),
Spacer(1, 20 * mm),
Paragraph("Kein vollständiges Werk – ein Summarium", S["smallcaps"]),
Spacer(1, 4 * mm),
Paragraph("Weitergabe von Liturgien ist Weitergabe von Amt", S["smallcaps"]),
NextPageTemplate("body"), PageBreak()]
# --- Inhalt
story.append(Heading("Inhalt", S["h1"], level=0, toc=False, key="inhalt"))
toc = TableOfContents()
toc.levelStyles = [S["toc0"], S["toc1"]]
toc.dotsMinLevel = 0
story += [toc, PageBreak()]
# --- Vorwort
story.append(Heading("Vorwort", S["h1"], level=0, key="vorwort"))
vorwort_style = ParagraphStyle("vorwort", parent=S["body_left"], leading=12.2)
for i, para in enumerate(VORWORT):
if i == len(VORWORT) - 1:
story.append(Paragraph(inline(para), ParagraphStyle(
"sig", parent=vorwort_style, fontName="Serif-Bold", fontSize=9.5, spaceBefore=6)))
else:
story.append(Paragraph(inline(para), vorwort_style))
story.append(PageBreak())
# --- Loses Blatt
story.append(Heading("Ein loses Blatt: Vom Maß des Gebets", S["h1"], level=0, key="mass"))
for para in LOSES_BLATT:
story.append(Paragraph(inline(para), S["body_left"]))
story.append(Spacer(1, 4 * mm))
box = [Paragraph("Damians Merksätze", ParagraphStyle(
"boxhead", fontName="Sans-Bold", fontSize=8, leading=11, textColor=GOLD, spaceAfter=3))]
box += [Paragraph(inline(t), S["bullet"]) for t in MERKSAETZE]
story.append(shaded_box(box))
story.append(PageBreak())
# --- Teil I: Gemeinschaften
story.append(Heading("Die Gemeinschaften und ihre Ordnung", S["h1"], level=0, key="ordnung"))
abschnitt(story, "Wie göttliche Magie funktioniert")
story += text_block(
"Göttliche Magie in den Westreichen ist kein Handwerk, das man beherrscht, sondern eine "
"Beziehung, die man unterhält. Vier Punkte regeln alles Weitere.",
"### Zauberplätze sind Fehlversuche, keine Vorräte",
"- Der Kleriker hat **Zauberplätze pro Grad und Tag** nach der Stufentabelle. Sie werden "
"nicht beim Wirken verbraucht: Ein **gelungener Spruchcheck kostet nichts**, ein "
"misslungener kostet **einen Platz des Grades**.",
"- Die Plätze sagen also, wie viele **Fehlversuche** eines Grades er an einem Tag wegsteckt. "
"Solange noch Plätze übrig sind, darf er weiter Liturgien dieses Grades erbitten – auch "
"dieselbe wieder und wieder.",
"- **Das Morgengebet setzt alle Plätze wieder auf das Maximum.** Nach der Gebetszeit ist das "
"Kontingent frisch – vorausgesetzt, die Gunst steht und der Sonnenritus ist gehalten.",
"- Ein Kleriker, der viel und oft zaubert, riskiert die **Entrückung**; sein Geist entfernt "
"sich dann in mehreren Schritten immer weiter von der realen Welt.",
"**Zauberplätze des Klerikers (Fehlversuche pro Grad und Tag)**",
"| Stufe | 1 | 2 | 3 | 4 | 5 |",
"|---|---|---|---|---|---|",
"| 2 | 1 | – | – | – | – |",
"| 3 | 2 | – | – | – | – |",
"| 4 | 2 | 1 | – | – | – |",
"| 5 | 2 | 2 | – | – | – |",
"| 6 | 2 | 2 | 1 | 1 | – |",
"| 7 | 2 | 2 | 2 | 1 | 1 |",
"| 8 | 3 | 3 | 2 | 2 | 1 |",
"| 9 | 3 | 3 | 3 | 2 | 2 |",
"| 10 | 4 | 4 | 3 | 3 | 2 |",
"| 11 | 4 | 4 | 4 | 3 | 3 |",
"| 12 | 5 | 5 | 4 | 4 | 3 |",
"| 13 | 5 | 5 | 5 | 4 | 4 |",
"| 14 | 6 | 5 | 5 | 5 | 4 |",
"Stufe 1 hat noch keine Liturgien – erst mit dem zweiten Grad des Glaubens kommt die erste.",
"### Voraussetzungen des Wirkens",
"1. **Heiliges Symbol** muss getragen werden – ohne Symbol keine Liturgie.",
"2. **Lebensführung nach den Geboten der Gottheit**, dazu der tägliche Sonnenritus.",
"3. **Gunst** der Gottheit: Ist sie gedämpft, wird das Gebet nicht erhört.",
"### Unzuverlässiges Beten",
"Jede Liturgie verlangt einen Spruchcheck. Ein **klerikaler Patzer kostet den Kontakt zur "
"Gottheit** – die Fähigkeiten kommen erst durch Buße zurück. Ein Patzer ist keine Explosion, "
"sondern ein Beziehungsbruch: der Grund, warum Kleriker vorsichtig beten.",
"### Kein automatisches Wissen",
"> „Kleriker, Druiden sowie hochstufige Waldläufer und Paladine haben **nicht automatisches "
"Wissen** über Magie. Der Zugriff auf einzelne Zaubergebete wird ihnen **über Lehrer** "
"zugänglich gemacht.“",
"Eine Liturgie ist eine überlieferte Formel mit Gesten, Rufantworten und Komponenten – kein "
"Gefühl. **Wer sie nie gelehrt bekam, kann sie nicht erbitten, auch wenn seine Stufe reicht.** "
"Genau darum geht es im nächsten Abschnitt.",
)
abschnitt(story, "Der Sonnenritus")
story += text_block(
"- **Täglich, bei Sonnenaufgang, 10 Minuten:** Gebet mit dem Symbol in der Hand. Keine Probe, "
"keine Kosten. Er entfällt nur, wenn der Kleriker bewusstlos, eingesperrt oder von der Sonne "
"abgeschnitten ist.",
"- **Wöchentlich ein Ruhetag:** Fällt er mit einer Rast zusammen, ist er erfüllt – es wird "
"**kein Kalender geführt**.",
"- **Wirkung:** Der Ritus ist die Bedingung dafür, dass die Gottheit überhaupt zuhört "
"(Gunststufe 3). Er ist keine Probe und kein Zauber.",
"- **Anreiz statt Fessel:** Hält der Kleriker den Wochenritus, gibt er der Gruppe für den "
"folgenden Tag **+1 auf den ersten Rettungswurf** jedes Gruppenmitglieds.",
"- **Andere Gottheiten, gleiche Form:** Konvent – Handauflegen am Krankenbett; Schwertfeuer – "
"Morgenappell mit Urteilsgebet; Seher – Traumnotiz vor dem Schlafen; Naturzirkel – Gruß an die "
"aufgehende Sonne oder den Mond; Aribor – Hand auf den Wachstein.",
"| Situation | Folge |",
"|---|---|",
"| Ein Tag ohne Ritus (Kerker, Krankheit, Nachtkampf) | nichts – wird bei der nächsten Andacht "
"nachgeholt |",
"| Eine Woche ohne Ruhetag | **Buße light:** 5 Taler Opfer oder Fasten bis zum Abend |",
"| Ritus über Wochen ignoriert, obwohl Zeit war | **Gunststufe 2** bis zur Buße |",
"| Ritus bewusst verweigert | Gunststufe 1 und ein Gespräch mit dem Vorgesetzten |",
)
abschnitt(story, "Zugang nach Spruchgrad")
story += text_block(
"- **Grad 1–2 ist Allgemeingut:** Jede Gemeinschaft lehrt dieselbe Grundausbildung – Segen, "
"Licht, Heilung, Schutz, Erkennen. Ein Wechsel kostet nur Zeit und einen Vorwand.",
"- **Ausnahme:** Druidenliturgien (Feenfeuer, Verstricken, Rindenhaut, Wachstum …) sind **nicht** "
"Allgemeingut der Kirche. Wer sie wirken will, braucht den Naturzirkel oder eine Lehrzeit bei "
"einem Druiden.",
"- **Ab Grad 3** lehrt jede Gemeinschaft eine breite, aber nicht vollständige Auswahl – den "
"**Lehrplan**. Was nicht darin steht, gibt es nur über Umwege.",
"- **Ab Grad 4** ist Zugang **Amtssache**: Der örtliche Klerus entscheidet, nicht der Spieler. "
"Ab Grad 5–6 kommt eine Queste oder ein Gelübde hinzu (siehe die Tabelle unten).",
"- **Einzelne Liturgien stehen in gar keinem Lehrplan** (†): Sie werden nur an einer besonderen "
"Lehrstätte und nur unter Auflage weitergegeben – siehe „Besondere Lehrstätten“.",
"- **Gemeinsame Liturgien** (Krankheit heilen, Fluch bannen, Gegenstand lokalisieren) lehren "
"mehrere Gemeinschaften; **Signaturen** sind gemeinschaftsspezifische Fassungen derselben "
"Liturgie.",
)
story += [Spacer(1, 2 * mm), simple_table(ZUGANG, [0.22, 0.44, 0.34]), Spacer(1, 4 * mm)]
abschnitt(story, "Die Gebetswoche")
story += text_block(
"Das Gegenstück zum Abschreiben – aber ohne Tinte, Pergament und "
"Intelligenzwurf. **Der Kleriker schreibt nicht ab, er betet nach.**",
"- **Voraussetzung:** Der Spruchgrad ist durch die Stufe freigeschaltet, die Gunst steht "
"mindestens auf 2, und es gibt Zugang zu einem Schrein, Tempel oder einer geweihten Stätte der "
"eigenen Gemeinschaft.",
"- **Dauer:** **1 Tag pro Spruchgrad**, mindestens drei Tage; mehrere Liturgien in derselben "
"Woche werden summiert.",
"- **Kosten:** **5 Taler pro Spruchgrad** als Tempelabgabe (Kerzen, Weihrauch, Opfer). "
"Betkammer und Zehrung kommen obendrauf; in Garana steht eine Kammer am Allerheiligsten derzeit "
"bei 200 statt 100 Talern, solange der Bann schwelt.",
"- **Wurf am Ende der Woche:** 1W20 gegen den **Weisheits-Wert**, vermindert um "
"**Spruchgrad − 1** (Grad 1: kein Malus, Grad 3: −2, Grad 5: −4).",
"- **Erfolg:** Die Liturgie ist **verankert** und darf ab sofort erbeten werden.",
"- **Misserfolg:** **Göttliches Schweigen.** Zeit und Abgabe sind verloren, die Liturgie ist "
"einen Monat gesperrt. Kein Gunstverlust – die Gottheit schweigt, sie zürnt nicht.",
"- **Ausnahme Grad 1:** Liturgien des ersten Grades gelten als Gebetsgrundlage und brauchen "
"keine Gebetswoche. Sie kommen mit der Weihe.",
"Der SL würfelt am Ende jeder Gebetswoche zusätzlich 1W6 auf die Gebetswochentabelle der "
"Gemeinschaft – Stimmung und Plot-Hook, keine Strafe.",
"### Liturgien außerhalb der eigenen Gemeinschaft",
"1. **Gastgeleit:** förmliche Erlaubnis, in einem fremden Tempel zu beten; kostet Zeit, Abgabe "
"und einen Gefallen. Der fremde Klerus entscheidet über den Rang.",
"2. **Gebetsbuch:** ein erbeutetes oder geliehenes Buch enthält Liturgien in fremder Formel – "
"lernen ja, aber die Herkunft bleibt peinlich, wenn es auffällt.",
"3. **Vision oder Traumoffenbarung:** Der SL kann eine Liturgie schenken – ohne Gebetswoche, "
"ohne Abgabe, aber als Auftrag.",
"4. **Ketzer-Mentor:** lehrt schnell und ohne Fragen. Politischer Selbstmord, wenn es "
"herauskommt – und die Gunst leidet.",
)
abschnitt(story, "Gunst und Buße")
story += text_block(
"Die Gunst ist die klerikale Ressource. Sie ersetzt keinen Rang und kostet kein "
"Zauberkontingent – "
"sie entscheidet, ob die Gottheit überhaupt zuhört. **Sie wird nicht offen als Zahl geführt:** "
"Der SL beschreibt den Zustand (das kalte Gefühl beim Gebet, das Ausbleiben des Lichts).",
)
story += [Spacer(1, 2 * mm), simple_table(GUNST, [0.16, 0.42, 0.42]), Spacer(1, 3 * mm)]
story += text_block(
"**Ein-Wege-Regel:** hoch nur durch Buße, nicht durch Zeit. Ein Kleriker steigt nicht "
"automatisch wieder auf.",
"**Auslöser:** klerikaler Patzer, wochenlang versäumter Ritus, Gebotsbruch der eigenen "
"Gemeinschaft (Amaunator: Wortbruch und Eidbruch; Konvent: verweigerte Heilung aus Geiz; "
"Schwertfeuer: Nachsicht mit Häresie; Naturzirkel: sinnlose Zerstörung von Wildnis), "
"**verbotene Umkehrungen** und **unheilige Mittel** – also Mittel, die wirken, obwohl sie es "
"nicht dürften. Was darunter fällt, entscheidet der SL, nicht der Spieler; der bloße Verdacht "
"ist noch kein Beweis: Manche davon werden von angesehenen Händen ausgegeben und in gutem "
"Glauben benutzt.",
)
story += [Spacer(1, 2 * mm), simple_table(BUSSE, [0.16, 0.40, 0.24, 0.20]), Spacer(1, 3 * mm)]
story += text_block(
"**Untote vertreiben** ist keine Liturgie, sondern eine Machtprobe der Gottheit: kein "
"Spruchcheck, keine Komponente – aber sie hängt an der Gunst. Ab Stufe 1 wirkt Vertreiben mit "
"−2, auf Stufe 0 gar nicht. Ein kritischer Fehler kann die Gunst um eine Stufe senken.",
"### Kirchenbann und Sanktionen",
"Gemeinschaften können Liturgien **sperren** – für Personen, Orte oder ganze Städte. Das "
"**Bann-Dekret** der Kirche von Lichtenwalde gegen den Abt von Garana ist das Beispiel aus "
"dieser Kampagne: Heilungen und Wiederbelebungen für Tote aus Garana werden verweigert. Ein "
"verhängter Bann sperrt die betroffenen Liturgien; der Zauber misslingt nicht – er wird **gar "
"nicht erst erhört**, es wird kein Spruchcheck gewürfelt. Gelöst wird ein Bann durch Fürsprache, "
"Pilgerfahrt, Sühne oder politischen Handel.",
)
abschnitt(story, "Umkehrungen")
story += text_block(
"Viele Liturgien haben eine **Umkehrung**. Diese Hausregel macht daraus eine Glaubensfrage "
"statt einer Geschmacksfrage: **Die Umkehrung ist eine eigene Liturgie.** Sie wird separat "
"gelehrt, separat erbeten und kostet eine Gunststufe, wenn sie ohne Rechtfertigung gewirkt "
"wird.",
)
story += [Spacer(1, 2 * mm),
simple_table(UMKEHRUNGEN, [0.30, 0.26, 0.07, 0.07, 0.10, 0.07, 0.07, 0.07]),
Spacer(1, 2 * mm)]
story += text_block(
"**ja** = lehrbar und ohne Gunstmalus · **Urteil** = nur nach Rechtsurteil der Gemeinschaft, "
"sonst Gunststufe −1 · **nein** = führt zu Gunststufe 0 und Kirchenbann. Die Tabelle ist der "
"Startpunkt, nicht das Gesetz: Der SL darf begründete Ausnahmen zulassen – aber **vor** dem "
"Wirken, nicht hinterher.",
)
abschnitt(story, "Signaturen: exklusiv ist die Fassung")
story += text_block(
"Keine Gemeinschaft hat das Monopol auf eine Liturgie – aber jede hat ihre eigene **Fassung** "
"davon, und die gibt sie nicht weiter. Das ist der Grund, warum zwei Kleriker derselben Gottheit "
"unterschiedlich beten können, ohne daß einer weniger kann.",
"**Keine Signatur ist ein striktes Upgrade.** Jede hat einen Vorteil und einen spürbaren "
"Nachteil. Wer die Fassung einer fremden Gemeinschaft will, braucht Gastgeleit, ein Gebetsbuch "
"oder einen Ketzer-Mentor.",
)
story += signaturen_tabelle(spells)
story += text_block(
"**Konvent, Seher und Aribor haben zusätzlich eigene Liturgien**, die keine andere Gemeinschaft "
"lehrt – sie stehen mit † im Liturgieteil: `Sühne`, `Schmerz tragen`, `Sterbesegen` und "
"`Reinigung der Stätte` (Konvent), `Traumgesicht` und `Zeichenlesen` (Seher), `Grenzweihe` und "
"`Eid binden` (Aribor).",
)
abschnitt(story, "Entrückung: wenn zu viel durch dich hindurchgeht")
story += text_block(
"**Es gibt keine Zahl, die du abhaken könntest.** Das ist das Heimtückische: Der Kleriker merkt "
"nicht, wann es zu viel war – er merkt es danach. Es gibt keinen Schmerz beim Überschreiten und "
"kein Zeichen vorher, nur die Folgen.",
"Was dann kommt, hat viele Gesichter: Zeichen an Haut und Hand, eine Stimme, die nicht mehr die "
"eigene ist, ein Licht, das aus einem herausleuchtet, ein Metallgeschmack im Mund, ein Tag, den "
"man nicht mehr erinnert, eine Woche, in der man nur noch den letzten Satz betet. Die Betkammer "
"nennt das **Entrückung**. Die Laien nennen es Gnade. Es ist dasselbe.",
"**Wer einmal entrückt war, kennt die Anzeichen** – und hört früher auf. Wer es für Erwählung "
"hält, betet weiter; das ist der Weg, auf dem Kaplanen sterben, von denen man später sagt, sie "
"hätten so viel Gutes getan.",
"> Was du wirklich wissen willst, steht nicht in diesem Buch: **wann** es zu viel ist. Das weiß "
"keiner für dich. Es hängt nicht an deinem Eifer, sondern an dem, was du tragen kannst.",
)
abschnitt(story, "Geografie des Glaubens")
story += text_block(
"Nicht jede Gemeinschaft ist überall. **Merksatz:** *Grad 1–2 findet man überall, Grad 3 am "
"Stützpunkt, Grad 4+ am Sitz – und was in keinem Lehrplan steht, nur an einer besonderen "
"Stätte (†).*",
)
story += [Spacer(1, 2 * mm), simple_table(PRAESENZ, [0.18, 0.34, 0.48]), Spacer(1, 3 * mm)]
story += [simple_table(STANDORTE, [0.20, 0.22, 0.30, 0.28]), Spacer(1, 3 * mm)]
story += text_block(
"**Bezugsort ist Garana**, nicht Methaven: Methaven ist Startort mit einem einzigen Schrein – "
"kein Standort für höhere Weihen.",
)
abschnitt(story, "Besondere Lehrstätten")
story += text_block(
"**Je endgültiger die Wirkung, desto strenger der Ort.** Tote zurückholen, ein Urteil über "
"Land und Leute sprechen, einen Schwur binden – das ist kein Wandspruch, den man in einer "
"Betkammer nebenbei mitbekommt. Solche Liturgien stehen in **keinem Lehrplan**; sie werden an "
"einem konkreten Ort unter einer Auflage weitergegeben. Die Auflagen werden erfüllt, **bevor** "
"gewürfelt wird – und wer lernt, steht im Buch der Stätte.",
)
sonder_rows = [["Lehrstätte", "Liturgie", "Auflage"]]
for sp in sorted(kleriker, key=lambda s: (s["grad"], s["title"])):
for ort, bedingung in sp["sonderorte"]:
sonder_rows.append([ort, f'{sp["title"]} (Grad {sp["grad"]})', bedingung])
story += [Spacer(1, 2 * mm), simple_table(sonder_rows, [0.28, 0.20, 0.52]), Spacer(1, 2 * mm)]
story += text_block(
"Am Tisch ist die Stätte ein **Abenteuer oder eine Schuld**: eine Pilgerreise, ein Gelöbnis, "
"ein Dienst. Wer die Liturgie will, bezahlt sie mit einer Geschichte, nicht mit Gold.",
)
abschnitt(story, "Die Gemeinschaften im Einzelnen")
for name, text, zugang in GEMEINSCHAFTEN:
story.append(KeepTogether([
Heading(name, S["h3"], level=1, toc=False),
Paragraph(inline(text), S["body"]),
Paragraph(f"<b>Zugang:</b> {inline(zugang)}", S["meta"]),
Spacer(1, 1.5 * mm),
]))
story.append(PageBreak())
# --- Teil II: Liturgien nach Grad
story.append(Heading("Die Liturgien nach Grad", S["h1"], level=0, key="liturgien"))
story.append(Paragraph(inline(
"Geordnet nach Spruchgrad. Die Angabe „Gelehrt von“ nennt die Gemeinschaften, deren Lehrplan "
"die Liturgie führt – bei Grad 1–2 ist das nur ein Schwerpunkt, gelehrt wird sie überall. "
"Das Zeichen **†** markiert Liturgien ohne Lehrplan: Sie gibt es nur an einer besonderen "
"Lehrstätte. Die Liturgien des Naturzirkels stehen im Anhang."), S["notice"]))
story.append(Spacer(1, 3 * mm))
for grad in range(1, 6):
grade_spells = [sp for sp in kleriker if sp["grad"] == grad]
if not grade_spells:
continue
story.append(PageBreak())
story.append(Heading(f"{grad}. Grad", S["h1"], level=1, key=f"grad{grad}"))
for sp in grade_spells:
# Kein erzwungener Seitenumbruch pro Liturgie (spart Leerraum): Nur der
# Kopf bleibt mit den ersten Zeilen zusammen, der Rest darf fließen.
fl = spell_flowables(sp)
story.append(KeepTogether(fl[:3]))
story += fl[3:]
# --- Kurzreferenz
story.append(PageBreak())
story.append(Heading("Kurzreferenz", S["h1"], level=0, key="kurzreferenz"))
story += text_block(
"Alle klerikalen Liturgien dieses Summariums nach Spruchgrad, innerhalb des Grades alphabetisch – "
"mit der Gemeinschaft, die sie lehrt. Für den schnellen Blick am Spieltisch.",
)
rows = [["Liturgie", "Gr.", "Gelehrt von"]]
for sp in sorted(kleriker, key=lambda s: (s["grad"], s["title"].lower())):
names = ", ".join(kurz(n) for n in sp["lehrt"])
if sp["grad"] <= 2:
lehrt = f"alle ({names})" if names else "alle"
else:
lehrt = names or "alle"
titel = sp["title"] + (" †" if sp["sonderorte"] else "")
rows.append([titel, str(sp["grad"]), lehrt])
story += [Spacer(1, 2 * mm), simple_table(rows, [0.54, 0.08, 0.38]), Spacer(1, 4 * mm)]
story.append(KeepTogether(
[Paragraph("Abkürzungen der Gemeinschaften", S["h4"])]
+ [Paragraph(inline(f"- **{short}** – {full}"), S["bullet"], bulletText=BULLET)
for short, full in LEGENDE]))
story.append(Spacer(1, 3 * mm))
story.append(Paragraph(inline(
"„alle“ bedeutet: Die Liturgie ist Allgemeingut (Grad 1–2) und wird von jeder Gemeinschaft "
"gelehrt; die Spalte nennt in diesem Fall den Schwerpunkt."), S["notice"]))
# --- Anhang: Naturzirkel
story.append(PageBreak())
story.append(Heading("Anhang: Die Liturgien des Naturzirkels", S["h1"], level=0, key="naturzirkel"))
story += text_block(
"Druidenliturgien sind **kein Allgemeingut** der Kirche – auch nicht in Grad 1–2. Wer sie "
"erbitten will, braucht die Mistelweihe des Naturzirkels oder eine Lehrzeit bei einem Druiden "
"(z. B. Elias). Die Liste steht hier, damit Terian weiß, was am Steinkreis zu haben ist – und "
"was er dafür schwören müsste.",
)
rows = [["Liturgie", "Gr.", "Dauer", "Signatur des Zirkels"]]
for sp in sorted(druiden, key=lambda s: s["title"].lower()):
sig = "; ".join(n for n, g, t in sp["signaturen"] if g == "Naturzirkel")
rows.append([sp["title"], str(sp["grad"]), sp["dauer"] or "–", sig or "–"])
story += [Spacer(1, 2 * mm), simple_table(rows, [0.40, 0.07, 0.33, 0.20])]
story.append(Spacer(1, 5 * mm))
abschnitt(story, "Was der Steinkreis verlangt")
story += text_block(
"Aufgenommen wird nicht mit Gold, sondern mit einer Nacht. Wer die Liturgien des Zirkels "
"erbitten will, muss aufgenommen sein – ein Gastgeleit gibt es für eine Nacht, nicht für eine "
"Lehre.",
)
box = [Paragraph("Bedingungen der Aufnahme", ParagraphStyle(
"zirkelhead", fontName="Sans-Bold", fontSize=8, leading=11, textColor=GOLD, spaceAfter=3))]
box += [Paragraph(inline(t), S["bullet"], bulletText=BULLET) for t in ZIRKEL_AUFNAHME]
story.append(shaded_box(box))
story.append(Spacer(1, 3 * mm))
story.append(Paragraph(inline(ZIRKEL_DOPPELBINDUNG), S["notice"]))
story.append(Spacer(1, 4 * mm))
story.append(Paragraph(inline(
"Warum hier nur Name, Grad und Dauer stehen: Die Formeln dieser Liturgien gehören dem Zirkel. "
"Wer sie wirken will, lernt sie am Steinkreis – aus keiner Abschrift, an keiner Tempeltür und "
"aus keinem Buch."), S["notice"]))
doc.multiBuild(story)
return doc.page, len(kleriker), len(druiden)
def spell_flowables(sp: dict) -> list:
head = [
Heading(sp["title"], S["h3"], level=2, toc=False),
Paragraph(inline(f'Grad {sp["grad"]} · {sp["klasse"]}'
+ (f' · Dauer: {sp["dauer"]}' if sp["dauer"] else "")
+ (f' · Reichweite: {sp["reichweite"]}' if sp["reichweite"] else "")),
S["meta"]),
]
body: list = []
secs = sp["sections"]
gemeinschaft = []
if sp["lehrt"]:
label = "**Gelehrt von:** " + ", ".join(sp["lehrt"])
if sp["grad"] <= 2:
label += " (Allgemeingut – jede Gemeinschaft lehrt die Standardfassung)"
gemeinschaft.append(Paragraph(inline(label), S["body"]))
elif sp["grad"] <= 2:
gemeinschaft.append(Paragraph(inline("**Gelehrt von:** alle Gemeinschaften (Allgemeingut)"),
S["body"]))
if gemeinschaft:
body.append(Paragraph("Gemeinschaft", S["h4"]))
body += gemeinschaft
if sp["signaturen"]:
body.append(Paragraph("Signatur (nur hier)", S["h4"]))
for name, gemein, text in sp["signaturen"]:
body.append(Paragraph(inline(f"**{name}** ({gemein}) – {text}."), S["quote"],
bulletText=BULLET))
if sp["sonderorte"]:
body.append(Paragraph("Besondere Lehrstätten", S["h4"]))
body.append(Paragraph(inline(
"Diese Liturgie steht in keinem Lehrplan – sie wird nur hier und nur unter Auflage "
"weitergegeben. Die Gebetswoche kommt zusätzlich."), S["notice"]))
for ort, bedingung in sp["sonderorte"]:
body.append(Paragraph(inline(f"**{ort}** – {bedingung}."), S["quote"], bulletText=BULLET))
wirkung = [l for l in secs.get("Wirkung", []) if l.strip()]
if wirkung:
body.append(Paragraph("Wirkung", S["h4"]))
body += block_flowables(wirkung)
for extra, lines in secs.items():
if extra in ("Gemeinschaft", "Wirkung"):
continue
clean = [l for l in lines if l.strip()]
if clean:
body.append(Paragraph(extra, S["h4"]))
body += block_flowables(clean)
body.append(Spacer(1, 3 * mm))
body.append(Rule(thickness=0.3, space_before=0, space_after=2))
return head + body
def main():
ap = argparse.ArgumentParser()
ap.add_argument("-o", "--out", default=str(
PREP / "Goettliche Liturgien - Summarium fuer Terian.pdf"))
ap.add_argument("--a4", action="store_true",
help="zusätzlich eine A4-Version erzeugen (Inhalt auf volle Seite skaliert)")
args = ap.parse_args()
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
pages, n_k, n_d = build(out)
print(f"OK: {out} ({pages} Seiten, {n_k} klerikale Liturgien, {n_d} im Anhang)")
if args.a4:
print(f"OK: {als_a4(out)}")
if __name__ == "__main__":
main()

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()

345
tools/build_sl_schirm.py Normal file
View file

@ -0,0 +1,345 @@
#!/usr/bin/env python3
"""
Baut den verdeckten SL-Schirm (A5 quer) aus einer Markdown-Datenquelle.
Trennung von Inhalt und Layout: Der Inhalt steht in einer editierbaren
Markdown-Datei (Standard: RPG/7-Prep/<prep>/SL Schirm/SL-Schirm Inhalt.md),
dieses Skript rendert daraus ein druckfertiges PDF. Für die nächste Prep-Session
wird nur die Markdown-Datei kopiert/aktualisiert und neu gebaut.
Quellformat
-----------
---
titel: SL-Schirm
untertitel: … (optional, erscheint klein unter dem Titel)
ingame: 1. Dezember (optional, steht im Kopf jeder Seite)
---
## Karte 1 · Fraktionen & Absichten
farbe: rot (optional: rot | blau | gruen | schwarz | grau)
### Unterabschnitt (optional, Zwischenüberschrift)
| Kopf | Kopf | (Pipe-Tabelle, erste Zeile = Kopfzeile)
| --- | --- |
| … | … |
- Stichpunkt
> Hinweis (klein, grau)
Fließtext
Jede `##`-Karte beginnt auf einer neuen Seite.
Aufruf:
.venv/bin/python tools/build_sl_schirm.py # Standardquelle + Standardziel
.venv/bin/python tools/build_sl_schirm.py -s quelle.md -o ziel.pdf
"""
from __future__ import annotations
import argparse
import re
from pathlib import Path
from reportlab.lib import colors
from reportlab.lib.pagesizes import A5, landscape
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import mm
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.platypus import (BaseDocTemplate, Frame, PageBreak, PageTemplate,
Paragraph, Spacer, Table, TableStyle)
ROOT = Path(__file__).resolve().parent.parent
VAULT = ROOT / "RPG"
# Prep-Material liegt pro Prep-Session in einem eigenen Unterordner
PREP = VAULT / "7-Prep" / "prep_2026-11-20"
QUELLE = PREP / "SL Schirm" / "SL-Schirm Inhalt.md"
ZIEL = PREP / "SL Schirm" / "SL-Schirm (A5 quer).pdf"
FONT_DIR = Path("/usr/share/fonts/truetype/dejavu")
pdfmetrics.registerFont(TTFont("Serif", str(FONT_DIR / "DejaVuSerif.ttf")))
pdfmetrics.registerFont(TTFont("Serif-Bold", str(FONT_DIR / "DejaVuSerif-Bold.ttf")))
pdfmetrics.registerFont(TTFont("Sans", str(FONT_DIR / "DejaVuSans.ttf")))
pdfmetrics.registerFont(TTFont("Sans-Bold", str(FONT_DIR / "DejaVuSans-Bold.ttf")))
pdfmetrics.registerFontFamily("Serif", normal="Serif", bold="Serif-Bold",
italic="Serif", boldItalic="Serif-Bold")
pdfmetrics.registerFontFamily("Sans", normal="Sans", bold="Sans-Bold",
italic="Sans", boldItalic="Sans-Bold")
INK = colors.HexColor("#2b2118")
GREY = colors.HexColor("#6b6259")
RULE = colors.HexColor("#b9a893")
ACCENT = colors.HexColor("#7a2e1e")
# Farbcode je Karte – am Tisch soll ein Griff genügen
FARBEN = {
"rot": colors.HexColor("#7a2e1e"),
"blau": colors.HexColor("#1f4e6b"),
"gruen": colors.HexColor("#3d5a2e"),
"schwarz": colors.HexColor("#2b2118"),
"grau": colors.HexColor("#5c5349"),
"gold": colors.HexColor("#8a6a1f"),
}
PAGE_W, PAGE_H = landscape(A5) # 210 × 148 mm
MARGIN_X = 9 * mm
MARGIN_TOP = 9 * mm
MARGIN_BOT = 8 * mm
S = {
"karte": ParagraphStyle("karte", fontName="Serif-Bold", fontSize=13.5, leading=16.5,
textColor=colors.white),
"karte_sub": ParagraphStyle("karte_sub", fontName="Sans", fontSize=7.4, leading=9.4,
textColor=colors.white),
"h2": ParagraphStyle("h2", fontName="Serif-Bold", fontSize=9.6, leading=12.4,
textColor=ACCENT, spaceBefore=4, spaceAfter=2, keepWithNext=1),
"body": ParagraphStyle("body", fontName="Serif", fontSize=8.2, leading=10.9,
textColor=INK, spaceAfter=2),
"bullet": ParagraphStyle("bullet", fontName="Serif", fontSize=8.2, leading=10.9,
textColor=INK, leftIndent=8, bulletIndent=1, spaceAfter=1.4),
"note": ParagraphStyle("note", fontName="Sans", fontSize=7.2, leading=9.6,
textColor=GREY, spaceAfter=2),
"cell": ParagraphStyle("cell", fontName="Serif", fontSize=7.4, leading=9.0, textColor=INK),
"cell_b": ParagraphStyle("cell_b", fontName="Serif-Bold", fontSize=7.4, leading=9.0,
textColor=INK),
"cell_h": ParagraphStyle("cell_h", fontName="Sans-Bold", fontSize=7.4, leading=9.0,
textColor=colors.white),
}
# ------------------------------------------------------------------ Markdown
def clean(text: str) -> str:
t = text.strip()
t = t.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
t = re.sub(r"\[\[([^\]|]+)\|([^\]]+)\]\]", r"\2", t)
t = re.sub(r"\[\[([^\]]+)\]\]", r"\1", t)
t = re.sub(r"\*\*([^*]+)\*\*", r"<b>\1</b>", t)
t = re.sub(r"(?<!\*)\*([^*\n]+)\*(?!\*)", r"<i>\1</i>", t)
t = t.replace("--", "–")
return t
def parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
if not text.startswith("---"):
return {}, text
parts = text.split("---", 2)
if len(parts) < 3:
return {}, text
meta: dict[str, str] = {}
for line in parts[1].splitlines():
if ":" in line:
k, v = line.split(":", 1)
meta[k.strip()] = v.strip()
return meta, parts[2]
def parse_cards(text: str) -> list[dict]:
cards: list[dict] = []
akt: dict | None = None
for raw in text.splitlines():
line = raw.rstrip()
if line.startswith("## "):
akt = {"titel": line[3:].strip(), "farbe": "rot", "zeilen": []}
cards.append(akt)
continue
if akt is None:
continue
m = re.match(r"farbe:\s*(\w+)", line.strip(), re.I)
if m and not akt["zeilen"]:
akt["farbe"] = m.group(1).lower()
continue
akt["zeilen"].append(line)
return cards
# ------------------------------------------------------------------ Flowables
def is_table_row(line: str) -> bool:
return line.strip().startswith("|")
def split_row(line: str) -> list[str]:
return [c.strip() for c in line.strip().strip("|").split("|")]
def nice_weights(rows: list[list[str]]) -> list[float]:
"""Spaltenbreiten grob nach Inhalt (Kopfzeile + mittlere Zelllänge)."""
cols = max(len(r) for r in rows)
raw: list[float] = []
for c in range(cols):
lens = [len(r[c]) for r in rows[1:] if c < len(r) and r[c]]
kopf = len(rows[0][c]) if c < len(rows[0]) else 6
mittel = sum(lens) / len(lens) if lens else kopf
raw.append(max(kopf * 1.1, mittel) ** 0.72)
lo = min(raw)
return [max(w / lo, 1.0) for w in raw]
def make_table(rows: list[list[str]], farbe) -> Table:
cols = max(len(r) for r in rows)
rows = [r + [""] * (cols - len(r)) for r in rows]
breite = PAGE_W - 2 * MARGIN_X
weights = nice_weights(rows)
total = sum(weights)
data = [[Paragraph(clean(c),
S["cell_h"] if i == 0 else S["cell_b" if j == 0 else "cell"])
for j, c in enumerate(row)] for i, row in enumerate(rows)]
t = Table(data, colWidths=[breite * w / total for w in weights],
repeatRows=1, hAlign="LEFT")
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), farbe),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.4, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f6f1ea")]),
("LEFTPADDING", (0, 0), (-1, -1), 3),
("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 1.6),
("BOTTOMPADDING", (0, 0), (-1, -1), 1.6),
]))
return t
def karte_kopf(titel: str, untertitel: str, farbe) -> Table:
breite = PAGE_W - 2 * MARGIN_X
text = [Paragraph(clean(titel), S["karte"])]
if untertitel:
text.append(Paragraph(clean(untertitel), S["karte_sub"]))
t = Table([[text, Paragraph("SL · vertraulich", S["karte_sub"])]],
colWidths=[breite * 0.82, breite * 0.18], hAlign="LEFT")
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, -1), farbe),
("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
("ALIGN", (1, 0), (1, 0), "RIGHT"),
("LEFTPADDING", (0, 0), (-1, -1), 5),
("RIGHTPADDING", (0, 0), (-1, -1), 5),
("TOPPADDING", (0, 0), (-1, -1), 3),
("BOTTOMPADDING", (0, 0), (-1, -1), 3),
]))
return t
def card_story(card: dict, untertitel: str) -> list:
farbe = FARBEN.get(card["farbe"], ACCENT)
story: list = [karte_kopf(card["titel"], untertitel, farbe), Spacer(1, 2.2 * mm)]
zeilen = card["zeilen"]
i = 0
while i < len(zeilen):
line = zeilen[i]
s = line.strip()
if not s:
i += 1
continue
if s.startswith("|"):
block = []
while i < len(zeilen) and is_table_row(zeilen[i]):
cells = split_row(zeilen[i])
if not all(re.fullmatch(r":?-{2,}:?", c) for c in cells if c):
block.append(cells)
i += 1
if block:
story += [make_table(block, farbe), Spacer(1, 2 * mm)]
continue
if s.startswith("### "):
story.append(Paragraph(clean(s[4:]), S["h2"]))
i += 1
continue
if s.startswith(">"):
story.append(Paragraph(clean(s.lstrip("> ")), S["note"]))
i += 1
continue
if s.startswith(("- ", "* ")):
gruppe = []
while i < len(zeilen) and zeilen[i].strip().startswith(("- ", "* ")):
gruppe.append(Paragraph(clean(zeilen[i].strip()[2:]),
S["bullet"], bulletText="•"))
i += 1
story += gruppe + [Spacer(1, 1.2 * mm)]
continue
# Fließtext: bis zur nächsten Sonderzeile sammeln
gruppe = []
while i < len(zeilen):
t = zeilen[i].strip()
if not t or t[0] in "|#>-" :
break
gruppe.append(t)
i += 1
story += [Paragraph(clean(" ".join(gruppe)), S["body"]), Spacer(1, 1.2 * mm)]
return story
# ------------------------------------------------------------------ Dokument
def page_frame(canvas, doc):
canvas.saveState()
canvas.setStrokeColor(RULE)
canvas.setLineWidth(0.4)
canvas.line(MARGIN_X, PAGE_H - 6.5 * mm, PAGE_W - MARGIN_X, PAGE_H - 6.5 * mm)
canvas.setFont("Sans", 6.8)
canvas.setFillColor(GREY)
canvas.drawString(MARGIN_X, PAGE_H - 5.4 * mm, doc.schirm_titel)
if doc.ingame:
canvas.setFont("Sans-Bold", 6.8)
canvas.setFillColor(ACCENT)
canvas.drawCentredString(PAGE_W / 2, PAGE_H - 5.4 * mm, f"In-Game: {doc.ingame}")
canvas.setFont("Sans", 6.8)
canvas.setFillColor(GREY)
canvas.drawRightString(PAGE_W - MARGIN_X, PAGE_H - 5.4 * mm,
f"Seite {doc.page}")
canvas.restoreState()
class SchirmDoc(BaseDocTemplate):
def __init__(self, *args, schirm_titel: str = "SL-Schirm", ingame: str = "", **kw):
self.schirm_titel = schirm_titel
self.ingame = ingame
super().__init__(*args, **kw)
def build(src: Path = QUELLE, dst: Path = ZIEL) -> tuple[Path, int]:
if not src.exists():
raise SystemExit(f"Quelle fehlt: {src}")
meta, body = parse_frontmatter(src.read_text(encoding="utf-8"))
cards = parse_cards(body)
if not cards:
raise SystemExit(f"Keine '## Karte …'-Abschnitte gefunden in {src}")
titel = meta.get("titel", "SL-Schirm")
untertitel = meta.get("untertitel", "")
ingame = meta.get("ingame", "")
doc = SchirmDoc(str(dst), pagesize=(PAGE_W, PAGE_H),
leftMargin=MARGIN_X, rightMargin=MARGIN_X,
topMargin=MARGIN_TOP, bottomMargin=MARGIN_BOT,
title=f"{titel} – Westreiche", author="Westreiche",
subject="Spielleiter-Schirm (vertraulich)", schirm_titel=titel,
ingame=ingame)
frame = Frame(MARGIN_X, MARGIN_BOT, PAGE_W - 2 * MARGIN_X,
PAGE_H - MARGIN_TOP - MARGIN_BOT, id="body")
doc.addPageTemplates([PageTemplate(id="body", frames=[frame], onPage=page_frame)])
story: list = []
for n, card in enumerate(cards):
if n:
story.append(PageBreak())
story += card_story(card, untertitel)
doc.build(story)
return dst, doc.page
def main() -> None:
ap = argparse.ArgumentParser(description="SL-Schirm (A5 quer) aus Markdown bauen")
ap.add_argument("-s", "--src", default=str(QUELLE))
ap.add_argument("-o", "--out", default=str(ZIEL))
args = ap.parse_args()
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
dst, pages = build(Path(args.src), out)
print(f"OK: {dst} ({pages} Seiten, A5 quer)")
if __name__ == "__main__":
main()

285
tools/build_sl_tabellen.py Normal file
View file

@ -0,0 +1,285 @@
#!/usr/bin/env python3
"""
Baut das Spielleiter-Handout „Ausbrennen & Entrückung" für den Spieltisch.
Quellen (werden gelesen, nicht dupliziert):
* arkanes Ausbrennen: RPG/3-Welt/Geheimnisse/Es gibt kein unbegrenztes Zaubern.md
* klerikale Entrückung: RPG/5-Regeln/Hausregeln/Liturgien und Glaubensgemeinschaften.md (§9)
Beides ist SL-Wissen und steht bewusst in keinem Spielerhandout.
Aufruf:
.venv/bin/python tools/build_sl_tabellen.py # A4 (Spieltisch-Handout)
.venv/bin/python tools/build_sl_tabellen.py --a5 # A5 (Heftchen, -> 7-Prep/prep_2026-11-20/pdf_export/)
.venv/bin/python tools/build_sl_tabellen.py [-o ausgabe.pdf]
"""
from __future__ import annotations
import argparse
import re
from pathlib import Path
from reportlab.lib import colors
from reportlab.lib.enums import TA_CENTER
from reportlab.lib.pagesizes import A4, A5
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import mm
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.platypus import (BaseDocTemplate, Frame, PageBreak, PageTemplate,
Paragraph, Spacer, Table, TableStyle)
ROOT = Path(__file__).resolve().parent.parent
VAULT = ROOT / "RPG"
# Prep-Material liegt pro Prep-Session in einem eigenen Unterordner
PREP = VAULT / "7-Prep" / "prep_2026-11-20"
SRC_ARKAN = VAULT / "3-Welt" / "Geheimnisse" / "Es gibt kein unbegrenztes Zaubern.md"
SRC_Klerus = VAULT / "5-Regeln" / "Hausregeln" / "Liturgien und Glaubensgemeinschaften.md"
FONT_DIR = Path("/usr/share/fonts/truetype/dejavu")
pdfmetrics.registerFont(TTFont("Serif", str(FONT_DIR / "DejaVuSerif.ttf")))
pdfmetrics.registerFont(TTFont("Serif-Bold", str(FONT_DIR / "DejaVuSerif-Bold.ttf")))
pdfmetrics.registerFont(TTFont("Sans", str(FONT_DIR / "DejaVuSans.ttf")))
pdfmetrics.registerFont(TTFont("Sans-Bold", str(FONT_DIR / "DejaVuSans-Bold.ttf")))
pdfmetrics.registerFontFamily("Serif", normal="Serif", bold="Serif-Bold",
italic="Serif", boldItalic="Serif-Bold")
pdfmetrics.registerFontFamily("Sans", normal="Sans", bold="Sans-Bold",
italic="Sans", boldItalic="Sans-Bold")
INK = colors.HexColor("#2b2118")
ACCENT = colors.HexColor("#7a2e1e")
GREY = colors.HexColor("#6b6259")
RULE = colors.HexColor("#b9a893")
# Seitenmaß und Ränder werden von configure() gesetzt (A4 = Spieltisch, A5 = Heftchen).
PAGE_W, PAGE_H = A4
MARGIN_X = 18 * mm
MARGIN_TOP = 20 * mm
MARGIN_BOT = 18 * mm
S: dict[str, ParagraphStyle] = {}
def make_styles(k: float = 1.0) -> dict[str, ParagraphStyle]:
"""Stilvorlagen; `k` skaliert alle Schriftgrade (1.0 = A4)."""
def fs(x: float) -> float:
return round(x * k, 1)
return {
"title": ParagraphStyle("title", fontName="Serif-Bold", fontSize=fs(24),
leading=round(29 * k, 1), textColor=INK,
alignment=TA_CENTER, spaceAfter=6),
"sub": ParagraphStyle("sub", fontName="Sans", fontSize=fs(10), leading=round(14 * k, 1),
textColor=ACCENT, alignment=TA_CENTER, spaceAfter=4),
"h1": ParagraphStyle("h1", fontName="Serif-Bold", fontSize=fs(15),
leading=round(19 * k, 1), textColor=ACCENT, spaceBefore=8,
spaceAfter=6, keepWithNext=1),
# Tabellen-Überschrift ohne keepWithNext: die Tabelle darf direkt darunter umbrechen
"h1t": ParagraphStyle("h1t", fontName="Serif-Bold", fontSize=fs(15),
leading=round(19 * k, 1), textColor=ACCENT, spaceBefore=8,
spaceAfter=6),
"body": ParagraphStyle("body", fontName="Serif", fontSize=fs(9.6),
leading=round(13.2 * k, 1), textColor=INK, spaceAfter=4),
"note": ParagraphStyle("note", fontName="Sans", fontSize=fs(8.6),
leading=round(12 * k, 1), textColor=GREY, spaceAfter=3),
"cell": ParagraphStyle("cell", fontName="Serif", fontSize=fs(8.4),
leading=round(10.4 * k, 1), textColor=INK),
"cell_b": ParagraphStyle("cell_b", fontName="Serif-Bold", fontSize=fs(8.4),
leading=round(10.4 * k, 1), textColor=INK),
"cell_h": ParagraphStyle("cell_h", fontName="Sans-Bold", fontSize=fs(8.4),
leading=round(10.4 * k, 1), textColor=colors.white),
}
FORMATS = {
# A4: Handout für den Schirm; A5: Heftchen zum Danebenlegen
"a4": dict(pagesize=A4, margin_x=18, margin_top=20, margin_bot=18, scale=1.0,
weights=[0.07, 0.13, 0.19, 0.43, 0.18]),
"a5": dict(pagesize=A5, margin_x=10, margin_top=13, margin_bot=12, scale=0.80,
weights=[0.10, 0.17, 0.185, 0.375, 0.17]),
}
def configure(fmt: str = "a4") -> None:
"""Setzt Seitenmaß, Ränder und Schriftgrade für das gewählte Format."""
global PAGE_W, PAGE_H, MARGIN_X, MARGIN_TOP, MARGIN_BOT, S
cfg = FORMATS[fmt]
PAGE_W, PAGE_H = cfg["pagesize"]
MARGIN_X = cfg["margin_x"] * mm
MARGIN_TOP = cfg["margin_top"] * mm
MARGIN_BOT = cfg["margin_bot"] * mm
S = make_styles(cfg["scale"])
configure("a4")
# ---------------------------------------------------------------- Tabellen lesen
def read_table(path: Path, need_header: str) -> list[list[str]]:
"""Erste Markdown-Tabelle, deren Kopfzeile `need_header` enthält."""
if not path.exists():
raise SystemExit(f"Quelle fehlt: {path}")
lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
rows: list[list[str]] = []
collecting = False
for line in lines:
s = line.strip()
if s.startswith("|"):
cells = [c.strip() for c in s.strip("|").split("|")]
if all(re.fullmatch(r":?-{2,}:?", c) for c in cells if c):
continue
if not collecting:
if need_header.lower() in " ".join(cells).lower():
collecting = True
rows.append(cells)
continue
if any(cells):
rows.append(cells)
elif collecting and rows:
break
if not rows:
raise SystemExit(f"Tabelle mit '{need_header}' nicht gefunden in {path}")
return rows
def clean(text: str) -> str:
t = text.strip()
t = t.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
t = re.sub(r"\[\[([^\]|]+)\|([^\]]+)\]\]", r"\2", t)
t = re.sub(r"\[\[([^\]]+)\]\]", r"\1", t)
t = re.sub(r"\*\*([^*]+)\*\*", r"<b>\1</b>", t)
t = re.sub(r"\*([^*\n]+)\*", r"<i>\1</i>", t)
return t
def table_flow(rows: list[list[str]], weights: list[float]) -> Table:
cols = len(rows[0])
rows = [r + [""] * (cols - len(r)) for r in rows]
width = PAGE_W - 2 * MARGIN_X
total = sum(weights[:cols]) or 1
data = [[Paragraph(clean(c), S["cell_h" if i == 0 else ("cell_b" if j == 0 else "cell")])
for j, c in enumerate(row)] for i, row in enumerate(rows)]
t = Table(data, colWidths=[width * w / total for w in weights[:cols]],
repeatRows=1, hAlign="LEFT")
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), ACCENT),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.4, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f6f1ea")]),
("LEFTPADDING", (0, 0), (-1, -1), 4),
("RIGHTPADDING", (0, 0), (-1, -1), 4),
("TOPPADDING", (0, 0), (-1, -1), 3),
("BOTTOMPADDING", (0, 0), (-1, -1), 3),
]))
return t
def page_frame(canvas, doc):
canvas.saveState()
canvas.setFont("Sans", 7.5)
canvas.setFillColor(GREY)
canvas.drawString(MARGIN_X, PAGE_H - 12 * mm, "Spielleiter-Tabellen · Ausbrennen & Entrückung")
canvas.setStrokeColor(RULE)
canvas.setLineWidth(0.4)
canvas.line(MARGIN_X, PAGE_H - 13.5 * mm, PAGE_W - MARGIN_X, PAGE_H - 13.5 * mm)
canvas.setFont("Serif", 9)
canvas.setFillColor(ACCENT)
canvas.drawCentredString(PAGE_W / 2, 10 * mm, str(doc.page))
canvas.restoreState()
def build(outpath: Path, fmt: str = "a4") -> int:
configure(fmt)
weights = FORMATS[fmt]["weights"]
arkan = read_table(SRC_ARKAN, "wurf")
klerus = read_table(SRC_Klerus, "wurf")
doc = BaseDocTemplate(str(outpath), pagesize=(PAGE_W, PAGE_H),
leftMargin=MARGIN_X, rightMargin=MARGIN_X,
topMargin=MARGIN_TOP, bottomMargin=MARGIN_BOT,
title="Spielleiter-Tabellen: Ausbrennen & Entrückung",
author="Westreiche", subject="SL-Handout")
frame = Frame(MARGIN_X, MARGIN_BOT, PAGE_W - 2 * MARGIN_X,
PAGE_H - MARGIN_TOP - MARGIN_BOT, id="body")
doc.addPageTemplates([PageTemplate(id="body", frames=[frame], onPage=page_frame)])
story: list = [
Paragraph("Ausbrennen &amp; Entrückung", S["title"]),
Paragraph("Spielleiter-Tabellen · verdeckt würfeln · nicht an Spieler aushändigen", S["sub"]),
Spacer(1, 4 * mm),
]
story += [
Paragraph("Wann gewürfelt wird", S["h1"]),
Paragraph("Immer wenn ein Zauberwirker an einem Tag mehr Zauber wirkt, als seine "
"<b>Tages-Schwelle</b> (Stufe + Intelligenzbonus) hergibt. Es gibt kein hartes Limit – "
"der Zauber gelingt weiterhin, wenn der Spruchcheck sitzt; ab der Schwelle wird "
"zusätzlich <b>verdeckt</b> auf der passenden Tabelle gewürfelt.", S["body"]),
Paragraph("Wurf: <b>1W20 + Grad des gewirkten Zaubers</b>, verdeckt durch den SL. Arkane Magie "
"verbrennt den Körper, göttliche Liturgien entrücken den Geist – es gilt die Tabelle "
"der Klasse, nicht die des Zaubers.", S["body"]),
Spacer(1, 1 * mm),
Paragraph("Am Tisch", S["h1"]),
Paragraph("• <b>Verdeckt würfeln</b> – die Spieler sollen die Tabelle nicht sehen, sonst "
"optimieren sie gegen sie.", S["body"]),
Paragraph("• <b>Ergebnis beschreiben, nicht vorlesen:</b> &bdquo;Deine Handflächen werden heiß "
"und rot&ldquo; statt &bdquo;Sonnenbrand der Gnade, 1W4 Tage&ldquo;.", S["body"]),
Paragraph("• <b>Gnädigere Variante (klerikal):</b> Bei 19 oder höher darf der Spieler einmal "
"auf Gunst statt auf Entrückung würfeln – die Gottheit prüft lieber, als zu strafen. "
"Auf Gunststufe 0 nicht möglich.", S["body"]),
Paragraph("• <b>Materialkomponenten</b> bremsen vor der Schwelle: Wer keine Komponenten mehr "
"hat, kommt oft gar nicht bis zum Wurf.", S["body"]),
Spacer(1, 3 * mm),
]
story += [
Paragraph("Arkane Magie: Ausbrennen", S["h1t"]),
table_flow(arkan, weights),
Spacer(1, 6 * mm),
]
# A4: eigener Seitenumbruch (je eine Tabelle pro Seite, gut am Schirm).
# A5: kein Umbruch – sonst bleibt eine halbleere Heftchen-Seite stehen.
if fmt == "a4":
story.append(PageBreak())
story += [
Paragraph("Göttliche Liturgien: Entrückung", S["h1"]),
Paragraph("Der Kanal zur Gottheit bleibt zu weit offen: Wo arkane Überlastung den Körper "
"verbrennt, wird der Kleriker entrückt.", S["body"]),
table_flow(klerus, weights),
Spacer(1, 6 * mm),
]
story += [
Paragraph("Quellen: &bdquo;Es gibt kein unbegrenztes Zaubern&ldquo; (arkan) · "
"&bdquo;Liturgien und Glaubensgemeinschaften&ldquo; §9 (klerikal). Beide Dateien im "
"Vault sind SL-Wissen und werden nicht veröffentlicht.", S["note"]),
]
doc.build(story)
return doc.page
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--a5", action="store_true",
help="A5-Heftchen statt A4-Handout (Ziel: RPG/7-Prep/prep_2026-11-20/pdf_export/)")
ap.add_argument("-o", "--out", default=None)
args = ap.parse_args()
fmt = "a5" if args.a5 else "a4"
if args.out:
out = Path(args.out)
elif fmt == "a5":
out = PREP / "pdf_export" / "SL-Tabellen - Ausbrennen und Entrueckung (A5).pdf"
else:
out = PREP / "SL-Tabellen - Ausbrennen und Entrueckung.pdf"
out.parent.mkdir(parents=True, exist_ok=True)
pages = build(out, fmt)
print(f"OK: {out} ({pages} Seiten, {fmt.upper()})")
if __name__ == "__main__":
main()

View file

@ -0,0 +1,828 @@
#!/usr/bin/env python3
"""
Baut das Spieler-Handout "Arkane Zaubersprüche – Ein Summarium von Rambastulon".
Inhalt:
1. Titelblatt (mit Kopfband-Illustration `RPG/7-Prep/prep_2026-11-20/summarium_titelband.png`,
ersatzweise nur Text, falls das Bild fehlt)
2. Vorwort von Rambastulon
3. Gilden-Teil (Hausregeln + Ziele/Fokus der Gilden)
4. Zauber nach Grad (Detailbeschreibungen aus 5-Regeln/Zauber/Arkan/Grad N/*.md)
5. Alphabetische Kurzreferenz mit "wer lehrt ihn"
Voraussetzung: reportlab (z. B. `python3 -m venv .venv && .venv/bin/pip install reportlab`).
Aufruf:
.venv/bin/python tools/build_zauber_almanach.py [-o ausgabe.pdf]
(Standard-Ausgabe: RPG/7-Prep/prep_2026-11-20/Arkane Zaubersprueche - Summarium von Rambastulon.pdf)
"""
from __future__ import annotations
import argparse
import re
import subprocess
from pathlib import Path
from reportlab.lib import colors
from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
from reportlab.lib.pagesizes import A5
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import mm
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.platypus import (BaseDocTemplate, Frame, Image as RLImage,
KeepTogether, NextPageTemplate, PageBreak, PageTemplate,
Paragraph, Spacer, Table, TableStyle)
from reportlab.platypus.tableofcontents import TableOfContents
ROOT = Path(__file__).resolve().parent.parent
VAULT = ROOT / "RPG"
# Prep-Material liegt pro Prep-Session in einem eigenen Unterordner
PREP = VAULT / "7-Prep" / "prep_2026-11-20"
SPELL_DIR = VAULT / "5-Regeln" / "Zauber" / "Arkan"
TITLE_IMAGE = PREP / "summarium_titelband.png"
FONT_DIR = Path("/usr/share/fonts/truetype/dejavu")
# ---------------------------------------------------------------- Schriften
pdfmetrics.registerFont(TTFont("Serif", str(FONT_DIR / "DejaVuSerif.ttf")))
pdfmetrics.registerFont(TTFont("Serif-Bold", str(FONT_DIR / "DejaVuSerif-Bold.ttf")))
pdfmetrics.registerFont(TTFont("Sans", str(FONT_DIR / "DejaVuSans.ttf")))
pdfmetrics.registerFont(TTFont("Sans-Bold", str(FONT_DIR / "DejaVuSans-Bold.ttf")))
pdfmetrics.registerFont(TTFont("Mono", str(FONT_DIR / "DejaVuSansMono.ttf")))
pdfmetrics.registerFontFamily("Serif", normal="Serif", bold="Serif-Bold",
italic="Serif", boldItalic="Serif-Bold")
pdfmetrics.registerFontFamily("Sans", normal="Sans", bold="Sans-Bold",
italic="Sans", boldItalic="Sans-Bold")
INK = colors.HexColor("#2b2118")
ACCENT = colors.HexColor("#7a2e1e")
GREY = colors.HexColor("#6b6259")
RULE = colors.HexColor("#b9a893")
PAGE_W, PAGE_H = A5
MARGIN_X = 15 * mm
MARGIN_TOP = 17 * mm
MARGIN_BOT = 15 * mm
# ---------------------------------------------------------------- Stile
S = {}
S["title"] = ParagraphStyle("title", fontName="Serif-Bold", fontSize=27, leading=32,
textColor=INK, alignment=TA_CENTER, spaceAfter=4)
S["subtitle"] = ParagraphStyle("subtitle", fontName="Serif", fontSize=13.5, leading=18,
textColor=ACCENT, alignment=TA_CENTER, spaceAfter=2)
S["smallcaps"] = ParagraphStyle("smallcaps", fontName="Sans", fontSize=8.5, leading=12,
textColor=GREY, alignment=TA_CENTER)
# keepWithNext: Überschriften bleiben bei ihrem ersten Absatz, statt am Seitenende zu stehen.
S["h1"] = ParagraphStyle("h1", fontName="Serif-Bold", fontSize=16, leading=20, textColor=ACCENT,
spaceBefore=6, spaceAfter=8, keepWithNext=1)
S["h2"] = ParagraphStyle("h2", fontName="Serif-Bold", fontSize=12.5, leading=16, textColor=INK,
spaceBefore=10, spaceAfter=4, keepWithNext=1)
S["h3"] = ParagraphStyle("h3", fontName="Serif-Bold", fontSize=10.5, leading=14, textColor=INK,
spaceBefore=8, spaceAfter=2, keepWithNext=1)
S["h4"] = ParagraphStyle("h4", fontName="Sans-Bold", fontSize=8.5, leading=11, textColor=ACCENT,
spaceBefore=6, spaceAfter=2, keepWithNext=1)
S["body"] = ParagraphStyle("body", fontName="Serif", fontSize=9, leading=12.6, textColor=INK,
alignment=0, spaceAfter=3)
S["body_left"] = ParagraphStyle("body_left", parent=S["body"], alignment=0)
S["bullet"] = ParagraphStyle("bullet", parent=S["body"], leftIndent=9, bulletIndent=1,
spaceAfter=1.6, alignment=0)
S["meta"] = ParagraphStyle("meta", fontName="Sans", fontSize=7.8, leading=10.4, textColor=GREY,
spaceAfter=2, alignment=0)
S["quote"] = ParagraphStyle("quote", parent=S["body"], leftIndent=7, rightIndent=4,
fontSize=8.6, leading=12, textColor=colors.HexColor("#4a3f34"),
spaceBefore=2, spaceAfter=4, alignment=0)
S["cell"] = ParagraphStyle("cell", fontName="Serif", fontSize=7.4, leading=9.4, textColor=INK)
S["cell_b"] = ParagraphStyle("cell_b", parent=S["cell"], fontName="Serif-Bold")
S["cell_h"] = ParagraphStyle("cell_h", parent=S["cell"], fontName="Sans-Bold", fontSize=7.2,
textColor=colors.white)
S["toc0"] = ParagraphStyle("toc0", fontName="Serif-Bold", fontSize=9.5, leading=14,
textColor=INK, spaceBefore=5)
S["toc1"] = ParagraphStyle("toc1", fontName="Serif", fontSize=8.6, leading=12,
leftIndent=9, textColor=INK)
S["notice"] = ParagraphStyle("notice", parent=S["body"], fontName="Sans", fontSize=8,
leading=11.4, textColor=colors.HexColor("#3d3428"))
BULLET = "\u2022"
# ---------------------------------------------------------------- Markdown-Hilfen
def inline(text: str) -> str:
"""Markdown-Inline -> ReportLab-Markup (ohne Bilder, ohne Wikilink-Ziele)."""
t = text.strip()
t = t.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
t = re.sub(r"\[\[([^\]|]+)\|([^\]]+)\]\]", r"\2", t)
t = re.sub(r"\[\[([^\]]+)\]\]", r"\1", t)
t = re.sub(r"!\[\[[^\]]+\]\]", "", t)
t = re.sub(r"\*\*([^*]+)\*\*", r"<b>\1</b>", t)
t = re.sub(r"(?<![\w*])\*([^*\n]{1,120}?)\*(?![\w*])", r"<i>\1</i>", t)
t = re.sub(r"`([^`]+)`", r'<font face="Mono" size="7.6">\1</font>', t)
t = t.replace("\u2032", "'").replace("\u2033", '"')
return t
def plain(text: str) -> str:
return re.sub(r"<[^>]+>", "", inline(text))
class Heading(Paragraph):
"""Absatz, der im Inhaltsverzeichnis und PDF-Lesezeichen landet."""
def __init__(self, text, style, level=0, toc=True, key=None):
super().__init__(text, style)
self.toc_level = level if toc else None
self.toc_key = key or plain(text)
self.heading_text = plain(text)
class Rule(Spacer):
def __init__(self, width_frac=1.0, thickness=0.6, space_before=3, space_after=5,
color=RULE):
Spacer.__init__(self, PAGE_W - 2 * MARGIN_X, space_before + space_after + thickness)
self.width_frac = width_frac
self.thickness = thickness
self.space_before = space_before
self.space_after = space_after
self.color = color
def draw(self):
canv = self.canv
canv.saveState()
canv.setStrokeColor(self.color)
canv.setLineWidth(self.thickness)
w = self.width * self.width_frac
x0 = (self.width - w) / 2.0
canv.line(x0, self.space_after, x0 + w, self.space_after)
canv.restoreState()
class AlmanachDoc(BaseDocTemplate):
def afterFlowable(self, flowable):
if isinstance(flowable, Heading) and flowable.toc_level is not None:
key = f"h{self.page}_{abs(hash((flowable.toc_key, self.page)))}"
self.canv.bookmarkPage(key)
self.canv.addOutlineEntry(flowable.heading_text, key,
level=min(flowable.toc_level, 2), closed=flowable.toc_level > 0)
self.notify("TOCEntry", (flowable.toc_level, flowable.heading_text, self.page, key))
def shaded_box(flows: list, bg="#f3ece1", border=RULE) -> Table:
"""Einfacher Kasten mit hellem Hintergrund für Merksätze/Warnungen."""
width = PAGE_W - 2 * MARGIN_X
box = Table([[flows]], colWidths=[width], hAlign="LEFT")
box.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, -1), colors.HexColor(bg)),
("BOX", (0, 0), (-1, -1), 0.5, border),
("LEFTPADDING", (0, 0), (-1, -1), 6),
("RIGHTPADDING", (0, 0), (-1, -1), 6),
("TOPPADDING", (0, 0), (-1, -1), 5),
("BOTTOMPADDING", (0, 0), (-1, -1), 5),
]))
return box
def page_decoration(canvas, doc):
canvas.saveState()
canvas.setFont("Sans", 7)
canvas.setFillColor(GREY)
canvas.drawString(MARGIN_X, PAGE_H - 11 * mm, "Arkane Zaubersprüche · Summarium")
canvas.setStrokeColor(RULE)
canvas.setLineWidth(0.4)
canvas.line(MARGIN_X, PAGE_H - 12.5 * mm, PAGE_W - MARGIN_X, PAGE_H - 12.5 * mm)
canvas.setFont("Serif", 8.5)
canvas.setFillColor(ACCENT)
canvas.drawCentredString(PAGE_W / 2, 9.5 * mm, str(doc.page))
canvas.restoreState()
def title_decoration(canvas, doc):
canvas.saveState()
canvas.setStrokeColor(ACCENT)
canvas.setLineWidth(0.8)
canvas.rect(9 * mm, 9 * mm, PAGE_W - 18 * mm, PAGE_H - 18 * mm, stroke=1, fill=0)
canvas.setLineWidth(0.3)
canvas.rect(11 * mm, 11 * mm, PAGE_W - 22 * mm, PAGE_H - 22 * mm, stroke=1, fill=0)
canvas.restoreState()
# ---------------------------------------------------------------- Zauber parsen
SPELL_SECTIONS = ("Gilde", "Wirkung", "Regelhinweise", "Verwandte Zauber",
"Originaltext (Englisch)")
def parse_spell(path: Path) -> dict:
raw = path.read_text(encoding="utf-8")
lines = raw.split("\n")
spell = {
"path": path,
"title": None,
"grad": None,
"klasse": "Magier",
"englisch": None,
"dauer": "",
"reichweite": "",
"zugang": "",
"lehrt": [],
"signaturen": [],
"sections": {},
}
section = None
for line in lines:
s = line.rstrip()
if s.startswith("# ") and spell["title"] is None:
spell["title"] = s[2:].strip()
continue
if s.startswith("## "):
section = s[3:].strip()
spell["sections"].setdefault(section, [])
continue
if s.startswith("> "):
body = s[2:].strip()
m = re.search(r"\*\*Grad:\*\*\s*(\d+)", body)
if m:
spell["grad"] = int(m.group(1))
m = re.search(r"\*\*Klasse:\*\*\s*([A-Za-zÄÖÜäöüß]+)", body)
if m:
spell["klasse"] = m.group(1)
m = re.search(r"\*\*Englisch:\*\*\s*(.+)", body)
if m:
spell["englisch"] = re.sub(r"\*\*", "", m.group(1)).strip()
m = re.search(r"\*\*Dauer:\*\*\s*(.+?)\s*(?:·\s*\*\*Reichweite:\*\*|\*Reichweite)", body)
if m:
spell["dauer"] = re.sub(r"\*\*", "", m.group(1)).strip()
m = re.search(r"\*\*Reichweite:\*\*\s*(.+)", body)
if m:
spell["reichweite"] = re.sub(r"\*\*", "", m.group(1)).strip()
m = re.search(r"\*\*Zugang:\*\*\s*(.+)", body)
if m:
spell["zugang"] = re.sub(r"\*\*", "", m.group(1)).strip()
if section and section in spell["sections"]:
spell["sections"][section].append("> " + body)
continue
if section:
spell["sections"][section].append(s)
# Gilde: Signaturfassungen (exklusiv je Gilde)
for line in spell["sections"].get("Gilde", []):
m = re.match(r"-\s+\*\*Signatur \(nur hier\)\s+–\s+(.+?)\*\*\s*\((.+?)\):\s*(.+?)\.?$",
line.strip())
if m:
spell["signaturen"].append((m.group(1).strip(), m.group(2).strip(),
m.group(3).strip()))
# Gilde: gelehrt von
for line in spell["sections"].get("Gilde", []):
if "Gelehrt von" in line or "Schwerpunkt bei" in line or "Gelehrt von:" in line:
for name in re.findall(r"\*\*([^*]+)\*\*", line):
if name.lower() in ("gelehrt von:", "schwerpunkt bei:"):
continue
spell["lehrt"].append(name.strip())
spell["lehrt"] = [n for n in spell["lehrt"] if not n.endswith(":")]
return spell
def load_spells() -> list[dict]:
spells = []
for grad_dir in sorted(SPELL_DIR.glob("Grad *"), key=lambda p: int(p.name.split()[1])):
for md in sorted(grad_dir.glob("*.md")):
sp = parse_spell(md)
if sp["title"] and sp["grad"]:
sp["grad"] = sp["grad"]
spells.append(sp)
return spells
# ---------------------------------------------------------------- Markdown-Block -> Flowables
def block_flowables(lines: list[str], bullet_style=None, drop_unknown=True) -> list:
"""Wandelt Markdown-Zeilen (Bullets, Tabellen, Blockquotes, Absätze) in Flowables."""
out: list = []
bullet_style = bullet_style or S["bullet"]
table_rows: list[list[str]] = []
def flush_table():
nonlocal table_rows
if not table_rows:
return
if len(table_rows) > 1:
head = [Paragraph(inline(c), S["cell_h"]) for c in table_rows[0]]
body_rows = [[Paragraph(inline(c), S["cell"]) for c in r] for r in table_rows[1:]]
data = [head] + body_rows
width = PAGE_W - 2 * MARGIN_X
t = Table(data, colWidths=[width * 0.22, width * 0.78], hAlign="LEFT")
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), ACCENT),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.3, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f6f1ea")]),
("LEFTPADDING", (0, 0), (-1, -1), 3),
("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 2),
("BOTTOMPADDING", (0, 0), (-1, -1), 2),
]))
out.append(t)
out.append(Spacer(1, 4))
table_rows = []
for line in lines:
s = line.rstrip()
if s.startswith("|"):
cells = [c.strip() for c in s.strip("|").split("|")]
if all(re.fullmatch(r":?-{2,}:?", c) for c in cells if c):
continue
table_rows.append(cells)
continue
flush_table()
if not s.strip():
continue
if s.startswith("### "):
out.append(Heading(inline(s[4:]), S["h4"], toc=False))
continue
if s.startswith("> "):
out.append(Paragraph(inline(s[2:]), S["quote"]))
continue
m = re.match(r"^[-*]\s+(.*)$", s)
if m:
out.append(Paragraph(inline(m.group(1)), bullet_style, bulletText=BULLET))
continue
if re.fullmatch(r"-{3,}", s.strip()):
out.append(Rule(space_before=2, space_after=2))
continue
out.append(Paragraph(inline(s), S["body"]))
flush_table()
return out
# ---------------------------------------------------------------- Textbausteine
VORWORT = [
"Tarazul,",
"wenn du diese Zeilen liest, hat sich das Buch in deiner Stube materialisiert – zwischen deinen "
"Sachen, dort, wo du morgens als Erstes hinsiehst. Das ist keine Zauberei, die man erklären müsste, "
"und es ist auch kein Geschenk. Es ist eine Rechnung, die ich begleiche, und eine Frage, die ich dir "
"zurückgebe.",
"Du hast mehr gelernt, als du selbst bemerkt hast. Du hast Sprüche aus zweiter Hand übernommen, hast "
"sie abgeschrieben, hast geflucht, wenn die Tinte verschwendet war, und hast weitergemacht. Wer das "
"tut, ist kein Lehrling mehr, der auf Zuruf Formeln nachspricht. **Du bist jetzt soweit, deinen Weg "
"als Magier selbst zu beginnen.**",
"Was du hier in Händen hältst, ist kein vollständiges Werk. Es ist ein Summarium: das, was in den "
"Archiven der Westreiche als gesichert gilt, geordnet nach Grad, damit du weißt, was du anstrebst – "
"und was du dir nicht anmaßen solltest, solange deine Hände noch zittern. Am Ende findest du eine "
"alphabetische Übersicht; sie ist für den Augenblick gedacht, wenn es schnell gehen muss.",
"Der wichtigere Teil steht vorn. **Überlege dir, welcher Organisation du dich anschließen willst.** "
"Magie ist in diesen Landen kein freies Handwerk. Wer sie lernt, lernt immer auch eine Hausordnung, "
"einen Lehrplan, einen Umgang mit Behörden. Das Kollegium wird dir eine Lizenz verkaufen und dafür "
"deine Sprüche lesen wollen. Die Akademie wird dich forschen lassen und dich mit Fragen bezahlen. Die "
"Bruderschaft wird dir Bücher öffnen, wenn du für sie Übersetzungen anfertigst. Wer dir Zugang zu "
"allem verspricht, will dich benutzen.",
"Und eines noch, bevor du dich entscheidest: Ich bin Mitglied des arkanen Konvents. Das ist kein "
"Ordensname, den man im Wirtshaus ruft. Wenn du wissen willst, was ich wirklich bin, frag mich in "
"meinem Haus – und nicht in einer Schenke. Was ich dir hier aufschreibe, ist Lehrstoff, nicht "
"Bekenntnis.",
"Lies langsam. Schreibe sauber. Verbrenne keine Bücher, auch keine schlechten. Und trau keinem, der "
"behauptet, ausgelernt zu haben – auch mir nicht.",
"Rambastulon von Klingenstein",
]
LOSES_BLATT = [
"Noch etwas, das in keinem Lehrplan steht und das man dir in keiner Gildenstube sagen wird, "
"weil es sich schlecht in Gebühren ausdrücken lässt.",
"Der Anfänger glaubt, Zaubern sei eine Frage des Willens. Es ist eine Frage des Durchlasses. "
"Jeder Spruch geht durch dich hindurch wie Wasser durch einen Schlauch, und ein Schlauch hat ein "
"Maß. Solange du dich daran hältst, merkst du nichts davon – das ist das Heimtückische. Es gibt "
"keinen Schmerz, keinen Warnruf, kein Zittern der Hand, das dir sagt: jetzt ist genug.",
"Ich habe einen Magier gekannt, der in einer einzigen Nacht eine ganze Belagerung mit Blitzen "
"bestritt. Am Morgen konnte er seine Hand nicht mehr schließen; sie war schwarz bis zum Handgelenk "
"und ist es geblieben. In Ostfurt gab es einen Priester, der einen Tag lang Wunder über Wunder rief "
"und am Abend mit verdrehten Augen dastand und den Namen seiner eigenen Schwester nicht mehr "
"wusste. Und ich kannte einen, der war nur noch ein Schatten ohne Schatten – die Hunde wollten ihn "
"nicht mehr ansehen, und die Dinge in der Dunkelheit rochen ihn auf doppelte Entfernung.",
"Ich sage nicht, dass jede Übertreibung so endet. Ich sage, dass niemand vorher weiß, welche. "
"**Zähle deine Sprüche wie Münzen.** Wer am Abend nicht mehr weiß, wie viele er ausgegeben hat, "
"hat zu viele ausgegeben.",
"Wie viel zu viel ist, steht hier nicht – es ist bei jedem anders, und es hängt nicht an deinem "
"Eifer, sondern an dem, was du tragen kannst: an deiner Kraft und an deinem Verstand. Wer dir eine "
"feste Zahl nennt, kennt dich nicht. Wer dir sagt, es gebe keine Grenze, will dich loswerden.",
]
NACHSCHRIFT_MERKSAETZE = [
"Zähle mit. Kein Spruch ist umsonst, auch der gelungene nicht.",
"Das Maß ist nicht dein Wille, sondern dein Durchlass.",
"Wer die Grenze überschreitet, merkt es nicht beim Wirken – sondern danach.",
]
GILDEN = [
("Königliches Magie-Kollegium",
"Staatliche Ausbildungs- und Lizenzstätte der Krone. Ziel des Kollegiums ist es, die Magie in den "
"Westreichen zu monopolisieren und wilde, unlizenzierte Zauberei zu unterbinden – und dabei die "
"konkurrierende Akademie zu verdrängen. Wer hier lernt, erhält Zugang zur stärksten Kampf- und "
"Schutzmagie des Landes, aber auch eine Akte, einen Vorgesetzten und die Pflicht, sein Wissen "
"dienstbar zu halten.",
"Lizenz, Rang, staatliche Aufträge"),
("Arkane Akademie",
"Unabhängige Gelehrtenschule und Gegenspielerin des Kollegiums. Ihr Ziel ist es, verlorenes arkanes "
"Wissen wiederzuentdecken und zu bewahren – auch unbequeme Wahrheiten, die dem Kollegium nicht in "
"die Akten passen. Hier findet sich Erkenntnismagie, Divination, Illusion und Verwandlung; dafür "
"fehlen große Kampfzauber und Nekromantie.",
"Studium, Forschung, Empfehlung, Questen"),
("Bruderschaft des Wortes",
"Bibliothekarengilde und Herrschaft über Schrift, Sprachen, Siegel und Wände. Das wenige, was die "
"Darstellung nach außen hin nicht preisgibt, steht in ihren Regalen: Folianten, Verträge, "
"Gefälligkeiten und Adressen derer, die etwas suchen. Macht bedeutet hier nicht Feuer, sondern "
"Zugang zur richtigen Seite.",
"Mitgliedschaft, Bibliothekszugang, Gefälligkeiten"),
("Zentrum für Monsterüberwachung",
"Halbstaatliche Behörde zum Kartieren, Beobachten und Eindämmen von Monsterpopulationen. Die "
"Lehre ist Fachmagie: erkennen, festhalten, beobachten – reine Kampfmagie gehört nicht zum "
"Lehrplan. Die Behörde hat ein eigenes Interesse an seltenen Kreaturen (Häutung, Alchemie), und "
"ihre Feldtrupps sind tapfer; der größere Teil ihrer Mitglieder ist Verwaltung.",
"Behördenauftrag, Felddienst, Lizenz, Empfehlung"),
("Das arkane Konvent",
"Geheimbund für verbotene Forschung: Geist, Verwandlung und jene Grenzbereiche, die der Krone "
"nicht genehm sind. Man tritt nicht bei, man wird eingeladen – oder man wird geduldet, solange "
"man nützlich ist. Das Konvent liefert die unangenehmen Zauber der Reiche und verlangt dafür "
"Verschwiegenheit, nicht Geld.",
"Einladung, Mentor, Verschwiegenheit"),
("Zirkel der Magier",
"Elitezirkel für seltene Varianten und Meta-Magie, kein normaler Lehrbetrieb. Wer aufgenommen "
"werden will, muss eine Meisterprüfung bestehen und ein Forschungs- oder Dienstversprechen "
"ablegen. Was man dort lernt, steht in keinem Summarium – dafür wird erwartet, dass man etwas "
"zurückgibt.",
"Meisterprüfung, Einladung, Queste"),
("Meister Eldoras' Akademie in Kandelstein",
"Forschungshaus für verbotene Folianten und alte Siegel, mit Zugang zu altertümlichen Varianten, "
"Illusionsmagie und Transmutation. Man lehrt nicht für Fremde; Zugang gibt es über eine "
"Akkreditierung („Silbernes Siegel“) und über Gefälligkeiten, die gefährlich werden können. Ein "
"Türgeschäft mehr als eine Laufbahn.",
"Akkreditierung, Silbernes Siegel, gefährliche Gefälligkeiten"),
]
LEGENDE = [
("KMK", "Königliches Magie-Kollegium"),
("AA", "Arkane Akademie"),
("BdW", "Bruderschaft des Wortes"),
("ZfM", "Zentrum für Monsterüberwachung"),
("aK", "Das arkane Konvent"),
("ZdM", "Zirkel der Magier"),
("EMA", "Meister Eldoras' Akademie in Kandelstein"),
]
KURZ = {full: short for short, full in LEGENDE}
def gildenkürzel(name: str) -> str:
return KURZ.get(name.strip(), name.strip())
# ---------------------------------------------------------------- Dokument bauen
A4_SIZE = (595.276, 841.89) # in pt, = 210 × 297 mm
def als_a4(src: Path, dst: Path | None = None) -> Path:
"""Skaliert eine A5-Datei auf volle A4-Seiten (für den Druck auf A4)."""
dst = dst or src.with_name(src.stem + " (A4).pdf")
subprocess.run(["gs", "-q", "-dNOPAUSE", "-dBATCH", "-sDEVICE=pdfwrite",
"-dPDFSETTINGS=/prepress", "-dFIXEDMEDIA",
f"-dDEVICEWIDTHPOINTS={A4_SIZE[0]}",
f"-dDEVICEHEIGHTPOINTS={A4_SIZE[1]}", "-dPDFFitPage",
f"-sOutputFile={dst}", str(src)], check=True)
return dst
def build(outpath: Path):
spells = load_spells()
# Anzeigename = Titel. Doppelfälle (dieselbe Liturgie in zwei Klassen oder Graden) werden
# NICHT im Namen unterschieden – dafür stehen Grad und Klasse in der Zeile darunter bzw.
# in den Spalten der Kurzreferenz.
for sp in spells:
sp["anzeige"] = sp["title"]
doc = AlmanachDoc(
str(outpath),
pagesize=A5,
leftMargin=MARGIN_X, rightMargin=MARGIN_X,
topMargin=MARGIN_TOP, bottomMargin=MARGIN_BOT,
title="Arkane Zaubersprüche – Ein Summarium von Rambastulon",
author="Rambastulon von Klingenstein",
subject="Zauber-Almanach für Tarazul (Westreiche)",
)
frame = Frame(MARGIN_X, MARGIN_BOT, PAGE_W - 2 * MARGIN_X,
PAGE_H - MARGIN_TOP - MARGIN_BOT, id="body")
title_frame = Frame(20 * mm, 20 * mm, PAGE_W - 40 * mm, PAGE_H - 40 * mm, id="title")
doc.addPageTemplates([
PageTemplate(id="title", frames=[title_frame], onPage=title_decoration,
autoNextPageTemplate="body"),
PageTemplate(id="body", frames=[frame], onPage=page_decoration),
])
story: list = []
# --- Titelblatt
story += [Spacer(1, 8 * mm)]
if TITLE_IMAGE.exists():
story += [RLImage(str(TITLE_IMAGE), width=118 * mm, height=118 * mm * 516 / 1276),
Spacer(1, 10 * mm)]
else:
story += [Spacer(1, 20 * mm)]
story += [
Paragraph("Arkane Zaubersprüche", S["title"]),
Rule(width_frac=0.34, thickness=0.9, space_before=6, space_after=8, color=ACCENT),
Paragraph("Ein Summarium von Rambastulon", S["subtitle"]),
Spacer(1, 11 * mm),
Paragraph("Gilde. Lehrplan. Spruchwerk.", S["smallcaps"]),
Spacer(1, 3 * mm),
Paragraph("Zusammengestellt in Methaven für seinen Schüler Tarazul", S["smallcaps"]),
Spacer(1, 20 * mm),
Paragraph("Kein vollständiges Werk – ein Summarium", S["smallcaps"]),
Spacer(1, 4 * mm),
Paragraph("Handschriftlich überarbeitet – für verbleibende Irrtümer haftet der Leser",
S["smallcaps"]),
NextPageTemplate("body"),
PageBreak(),
]
# --- Inhaltsverzeichnis
story.append(Heading("Inhalt", S["h1"], level=0, toc=False, key="inhalt"))
toc = TableOfContents()
toc.levelStyles = [S["toc0"], S["toc1"]]
toc.dotsMinLevel = 0
story += [toc, PageBreak()]
# --- Vorwort
story.append(Heading("Vorwort", S["h1"], level=0, key="vorwort"))
vorwort_style = ParagraphStyle("vorwort", parent=S["body_left"], leading=12.2)
for i, para in enumerate(VORWORT):
if i == len(VORWORT) - 1:
story.append(Paragraph(inline(para), ParagraphStyle(
"sig", parent=vorwort_style, fontName="Serif-Bold", fontSize=9.5, spaceBefore=6)))
else:
story.append(Paragraph(inline(para), vorwort_style))
story.append(PageBreak())
# --- Loses Blatt: Warnung vor massenhaftem Wirken
story.append(Heading("Ein loses Blatt: Vom Maß des Wirkens", S["h1"], level=0, key="nachschrift"))
for para in LOSES_BLATT:
story.append(Paragraph(inline(para), S["body_left"]))
story.append(Spacer(1, 4 * mm))
box = [Paragraph("Rambastulons Merksätze", ParagraphStyle(
"boxhead", fontName="Sans-Bold", fontSize=8, leading=11, textColor=ACCENT,
spaceAfter=3))]
box += [Paragraph(inline(t), S["bullet"]) for t in NACHSCHRIFT_MERKSAETZE]
story.append(shaded_box(box))
story.append(PageBreak())
# --- Gilden-Teil
story.append(Heading("Die Gilden und ihre Ordnung", S["h1"], level=0, key="gilden"))
story.append(Heading("Wie Magie in den Westreichen gelehrt wird", S["h2"], level=1))
story += block_flowables([
"Nicht jeder Magier kann jeden Spruch lernen. Die Ausbildung ist gildenabhängig – und sie ist "
"streng reglementiert, weil das Können eines Magiers in diesen Landen zugleich eine Waffe, ein "
"Werkzeug und ein Politikum ist.",
])
story += block_flowables([
"### Zugang nach Spruchgrad",
"- **Grad 1–2:** Allgemeingut. Alle Gilden lehren die Standardversionen; die Grundausbildung ist "
"überall dieselbe. Wo eine Gilde ihren Schwerpunkt hat, steht bei jedem Spruch.",
"- **Ab Grad 3:** Die Lehrpläne splittern sich auf. Jede Gilde hat Schwerpunkte, Signature-Zauber "
"und eigene Varianten. Was nicht im Lehrplan steht, gibt es nur über Umwege.",
"- **Ab Grad 4:** Zugang nur für Mitglieder mit Rang (Geselle, später Meister) oder für "
"besondere Günstlinge – und gegen eine Gefälligkeit.",
"### Lernen außerhalb der eigenen Gilde",
"- **Gaststudium:** förmliche Erlaubnis einer fremden Gilde; kostet Zeit, Gold und einen Gefallen.",
"- **Abschrift aus einem Zauberbuch:** ein erbeutetes oder geliehenes Buch gewährt Zugang – die "
"Gilde kann die Herausgabe verlangen.",
"- **Forschung:** der Spruch wird aus Beschreibungen rekonstruiert; teuer, langsam, mit Risiko "
"beim Spruchwurf.",
"- **Renegaten-Mentor:** schnell, wirksam und politisch gefährlich.",
])
story.append(Spacer(1, 3 * mm))
story.append(Heading("Was ein Spruch kostet", S["h2"], level=1))
story += block_flowables([
"Für die Übertragung eines Spruchs in das eigene Buch gilt: **ein Tag pro Spruchgrad**, dazu "
"**10 Taler pro Spruchgrad** für Tinte, Pergament und Gildengebühr. Danach entscheidet ein Wurf "
"auf 1W20 gegen den Intelligenz-Wert, vermindert um **Spruchgrad − 1** (Grad 1: kein Malus, "
"Grad 2: −1, Grad 3: −2).",
"Bei Misserfolg sind Zeit und Tinte verloren, und derselbe Spruch ist **einen Monat lang gesperrt** "
"– der Geist braucht Ruhe, nicht Eifer. Für Zauber des eigenen Lehrplans gilt dieselbe Prozedur.",
"> Wildes, unlizenziertes Zaubern ist im Gebiet des Magie-Kollegiums ein Verbrechen. Illusionisten "
"fallen allerdings durch das Lizenzraster der Krone: Ihre Kunst gilt am Hof als Gaukelei, wird "
"geduldet, solange sie unauffällig bleibt – und geahndet, sobald sie staatliche Ordnung stört.",
])
story.append(Spacer(1, 4 * mm))
story.append(Heading("Wie oft ein Magier wirken kann", S["h2"], level=1))
story += block_flowables([
"Ein Magier hält **Stufe + Intelligenzbonus** Zauber bereit – er legt beim Memorieren aber "
"**nicht** fest, welche davon er wann wirkt: Er wählt im Augenblick des Wirkens aus dem "
"Zauberbuch.",
"**Die Zauberplätze sind Fehlversuche, keine Vorräte.** Ein gelungener Spruchwurf kostet "
"nichts; ein misslungener kostet **einen Platz des Grades**. Die Plätze der Stufentabelle "
"sagen also, wie viele Fehlversuche eines Grades man an einem Tag wegsteckt und trotzdem "
"weiter Zauber dieses Grades wirken kann.",
"**Das Memorieren am Morgen setzt alle Plätze wieder auf das Maximum.**",
"Ist ein Grad erschöpft, ist er für den Tag verbraucht. Wer trotzdem weitermacht, riskiert das "
"**Ausbrennen** – die Tabelle dafür würfelt der Spielleiter verdeckt.",
])
story.append(Spacer(1, 4 * mm))
story.append(Heading("Rangordnung", S["h2"], level=1))
rang = [["Rang", "Voraussetzung", "Zugang"],
["Aspirant", "Aufnahme, Grad 1–2", "Grad 1–2"],
["Geselle", "Prüfung, Grad 3–4", "Grad 3–4, Gaststudium"],
["Meister", "Meisterprüfung, Grad 5–6", "Grad 5–6, eigene Forschung"],
["Magister", "besondere Verdienste", "seltene Varianten, Zirkel"]]
data = [[Paragraph(inline(c), S["cell_h" if r == 0 else ("cell_b" if i == 0 else "cell")])
for i, c in enumerate(row)] for r, row in enumerate(rang)]
w = PAGE_W - 2 * MARGIN_X
t = Table(data, colWidths=[w * 0.24, w * 0.36, w * 0.40], hAlign="LEFT")
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), ACCENT),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.3, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f6f1ea")]),
("LEFTPADDING", (0, 0), (-1, -1), 3), ("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 2), ("BOTTOMPADDING", (0, 0), (-1, -1), 2),
]))
story += [t, Spacer(1, 6 * mm)]
story.append(Heading("Die Gilden im Einzelnen", S["h2"], level=1))
for name, text, zugang in GILDEN:
story.append(KeepTogether([
Heading(name, S["h3"], level=1, toc=False),
Paragraph(inline(text), S["body"]),
Paragraph(f"<b>Zugang:</b> {inline(zugang)}", S["meta"]),
Spacer(1, 1.5 * mm),
]))
story.append(Spacer(1, 4 * mm))
story.append(Heading("Signaturen: exklusiv ist die Fassung", S["h2"], level=1))
story += block_flowables([
"Keine Gilde hat das Monopol auf einen Spruch – aber jede hat ihre eigene **Fassung** davon, "
"und die gibt sie nicht weiter. Exklusiv ist also nicht der Zauber, sondern die Formel.",
"**Keine Signatur ist ein striktes Upgrade.** Jede hat einen Vorteil und einen spürbaren "
"Nachteil. Wer die Fassung einer fremden Gilde will, braucht Gaststudium, ein erbeutetes "
"Zauberbuch oder eigene Forschung.",
])
story.append(Spacer(1, 2 * mm))
sig_rows = [["Standardzauber", "Signatur", "Gilde", "Vorteil", "Nachteil"]]
for sp in sorted([s for s in spells if s["signaturen"]], key=lambda s: (s["grad"], s["anzeige"])):
for name, gilde_name, text in sp["signaturen"]:
vorteil, _, nachteil = text.partition("; ")
sig_rows.append([f'{sp["anzeige"]} (Grad {sp["grad"]})', name,
gildenkürzel(gilde_name), vorteil, nachteil or "–"])
data = [[Paragraph(inline(c), S["cell_h" if r == 0 else "cell"]) for c in row]
for r, row in enumerate(sig_rows)]
w = PAGE_W - 2 * MARGIN_X
t_sig = Table(data, colWidths=[w * 0.20, w * 0.22, w * 0.08, w * 0.28, w * 0.22],
repeatRows=1, hAlign="LEFT")
t_sig.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), ACCENT),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.25, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f6f1ea")]),
("LEFTPADDING", (0, 0), (-1, -1), 3), ("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 1.6), ("BOTTOMPADDING", (0, 0), (-1, -1), 1.6),
]))
story.append(t_sig)
story.append(PageBreak())
# --- Zauber nach Grad
story.append(Heading("Die Zauber nach Grad", S["h1"], level=0, key="zauber"))
story.append(Paragraph(inline(
"Die folgenden Sprüche sind nach Spruchgrad geordnet, innerhalb eines Grades alphabetisch. Alles "
"arkane Magie – ob ein Spruch auf der Magier- oder der Illusionistenliste steht, sagt die "
"Klassenangabe. Die Angabe „Gelehrt von“ nennt jene Gilde, deren Lehrplan den Spruch führt – bei "
"Grad 1–2 ist das nur ein Schwerpunkt, gelehrt wird er überall."),
S["notice"]))
story.append(Spacer(1, 3 * mm))
for grad in range(1, 7):
grade_spells = sorted([sp for sp in spells if sp["grad"] == grad],
key=lambda s: s["anzeige"].lower())
if not grade_spells:
continue
story.append(PageBreak())
story.append(Heading(f"{grad}. Grad", S["h1"], level=1, key=f"grad{grad}"))
story.append(Paragraph(
f"{len(grade_spells)} arkane Sprüche",
ParagraphStyle(
f"group{grad}", fontName="Sans-Bold", fontSize=8.5, leading=11,
textColor=colors.white, backColor=ACCENT, borderPadding=(3, 3, 2, 3),
spaceBefore=8, spaceAfter=6)))
for sp in grade_spells:
# Kein erzwungener Seitenumbruch pro Spruch (spart den Leerraum am
# Seitenende): Nur der Kopf bleibt mit den ersten Zeilen zusammen,
# der Rest darf fließen.
fl = spell_flowables(sp)
story.append(KeepTogether(fl[:3]))
story += fl[3:]
# --- Anhang: alphabetische Kurzreferenz
story.append(PageBreak())
story.append(Heading("Kurzreferenz", S["h1"], level=0, key="kurzreferenz"))
story += block_flowables([
"Alle Sprüche dieses Summariums nach Spruchgrad, innerhalb des Grades alphabetisch – mit "
"Klasse und der Gilde, die ihn "
"lehrt. Für den schnellen Blick am Spieltisch.",
])
story.append(Spacer(1, 2 * mm))
rows = [["Spruch", "Gr.", "Kl.", "Gelehrt von"]]
for sp in sorted(spells, key=lambda s: (s["grad"], s["anzeige"].lower())):
kurz = ", ".join(gildenkürzel(n) for n in sp["lehrt"])
if sp["grad"] <= 2:
lehrt_col = f"alle ({kurz})" if kurz else "alle"
else:
lehrt_col = kurz or "alle"
rows.append([sp["anzeige"], str(sp["grad"]),
"Illu" if sp["klasse"] == "Illusionist" else "Mag", lehrt_col])
data = []
for r, row in enumerate(rows):
if r == 0:
data.append([Paragraph(inline(c), S["cell_h"]) for c in row])
else:
data.append([Paragraph(inline(row[0]), S["cell"]),
Paragraph(row[1], S["cell"]),
Paragraph(row[2], S["cell"]),
Paragraph(inline(row[3]), S["cell"])])
w = PAGE_W - 2 * MARGIN_X
t = Table(data, colWidths=[w * 0.44, w * 0.08, w * 0.10, w * 0.38], repeatRows=1, hAlign="LEFT")
t.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), ACCENT),
("VALIGN", (0, 0), (-1, -1), "TOP"),
("GRID", (0, 0), (-1, -1), 0.25, RULE),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f6f1ea")]),
("LEFTPADDING", (0, 0), (-1, -1), 3), ("RIGHTPADDING", (0, 0), (-1, -1), 3),
("TOPPADDING", (0, 0), (-1, -1), 1.6), ("BOTTOMPADDING", (0, 0), (-1, -1), 1.6),
]))
story.append(t)
story.append(Spacer(1, 5 * mm))
legende_flows = block_flowables([f"- **{short}** – {full}" for short, full in LEGENDE])
story.append(KeepTogether([Paragraph("Abkürzungen der Gilden", S["h4"])] + legende_flows))
story.append(Spacer(1, 3 * mm))
story.append(Paragraph(inline(
"„alle“ bedeutet: Der Spruch ist Allgemeingut (Grad 1–2) und wird von jeder Gilde gelehrt; "
"die Spalte nennt in diesem Fall die Gilde mit dem Schwerpunkt."), S["notice"]))
doc.multiBuild(story)
return doc.page, len(spells)
def spell_flowables(sp: dict) -> list:
head = [
Heading(sp["anzeige"], S["h3"], level=2, toc=False),
Paragraph(inline(
f'Grad {sp["grad"]} · {sp["klasse"]}'
+ (f' · Dauer: {sp["dauer"]}' if sp["dauer"] else "")
+ (f' · Reichweite: {sp["reichweite"]}' if sp["reichweite"] else "")
+ (f' · Englisch: {sp["englisch"]}' if sp["englisch"] else "")), S["meta"]),
]
body: list = []
secs = sp["sections"]
gilde = []
if sp["zugang"]:
gilde.append(Paragraph(inline(sp["zugang"]), S["quote"]))
if sp["lehrt"]:
label = "**Gelehrt von:** " + ", ".join(sp["lehrt"])
if sp["grad"] <= 2:
label += " (Allgemeingut – alle Gilden lehren die Standardversion)"
gilde.append(Paragraph(inline(label), S["body"]))
elif sp["grad"] <= 2:
gilde.append(Paragraph(inline("**Gelehrt von:** alle Gilden (Allgemeingut)"), S["body"]))
if gilde:
body.append(Paragraph("Gilde", S["h4"]))
body += gilde
if sp["signaturen"]:
body.append(Paragraph("Signatur (nur hier)", S["h4"]))
for name, gilde_name, text in sp["signaturen"]:
body.append(Paragraph(inline(f"**{name}** ({gilde_name}) – {text}."), S["quote"],
bulletText=BULLET))
wirkung = [l for l in secs.get("Wirkung", []) if l.strip()]
if wirkung:
body.append(Paragraph("Wirkung", S["h4"]))
body += block_flowables(wirkung)
for extra in ("Regelhinweise", "Verwandte Zauber"):
lines = [l for l in secs.get(extra, []) if l.strip()]
if lines:
label = "Regelhinweise" if extra == "Regelhinweise" else "Verwandte Zauber"
body.append(Paragraph(label, S["h4"]))
body += block_flowables(lines)
body.append(Spacer(1, 3 * mm))
body.append(Rule(thickness=0.3, space_before=0, space_after=2))
return head + body
def main():
ap = argparse.ArgumentParser()
ap.add_argument("-o", "--out", default=str(
PREP / "Arkane Zaubersprueche - Summarium von Rambastulon.pdf"))
ap.add_argument("--a4", action="store_true",
help="zusätzlich eine A4-Version erzeugen (Inhalt auf volle Seite skaliert)")
args = ap.parse_args()
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
pages, count = build(out)
print(f"OK: {out} ({pages} Seiten, {count} Zauber)")
if args.a4:
print(f"OK: {als_a4(out)}")
if __name__ == "__main__":
main()

44
tools/deploy_web.sh Executable file
View file

@ -0,0 +1,44 @@
#!/usr/bin/env bash
# Lädt den gebauten Webauftritt (web/) per explizitem FTPS nach public_html/.
# Voraussetzung: `python3 tools/build_site.py` wurde ausgeführt.
#
# Aufruf: ./tools/deploy_web.sh [--dry-run]
set -euo pipefail
cd "$(dirname "$0")/.."
[ -f credentials.txt ] || { echo "credentials.txt fehlt" >&2; exit 1; }
[ -d web ] || { echo "web/ fehlt – erst tools/build_site.py ausführen" >&2; exit 1; }
set -a; . ./credentials.txt; set +a
DRY=0
[ "${1:-}" = "--dry-run" ] && DRY=1
TARGET="public_html"
upload() {
local src="$1" dst="$2"
if [ "$DRY" = 1 ]; then
echo "would upload $src -> ftp://$FTP_URL/$dst"
return
fi
curl -s -S --ssl-reqd --ftp-create-dirs --max-time 120 --user "$FTP_USER:$FTP_PASSWORD" \
-T "$src" "ftp://$FTP_URL/$dst" || { echo "FEHLER: $src" >&2; return 1; }
echo "ok $dst"
}
# Einzeldateien (nur was gebaut wurde – weltenauge.php fehlt, solange das
# Projekt ruht; siehe SHOW_WELTENAUGE in tools/build_site.py)
for f in index.php weltenauge.php; do
[ -f "web/$f" ] || continue
upload "web/$f" "$TARGET/$f"
done
# assets/ und westreiche/ rekursiv
while IFS= read -r -d '' file; do
rel="${file#web/}"
upload "$file" "$TARGET/$rel"
done < <(find web/assets web/westreiche -type f -print0 | sort -z)
echo "Deploy abgeschlossen ($([ "$DRY" = 1 ] && echo "dry-run" || echo "live"))."

View file

@ -0,0 +1,157 @@
#!/usr/bin/env python3
"""Erzeugt für jeden Zauber ein Schwarz/Weiß-Symbolbild über fal.ai und
bettet es in die Zauberbeschreibung ein.
Bilder landen in `RPG/zz_archiv/images/zauber-<slug>.png` (Obsidian-Attachment-
Ordner), eingebettet wird `![[zauber-<slug>.png|320]]` direkt unter dem Titel.
Aufruf:
python3 tools/generate_spell_images.py --dry-run # Prompts zeigen
python3 tools/generate_spell_images.py --limit 3 # erst testen
python3 tools/generate_spell_images.py # alle Zauber
python3 tools/generate_spell_images.py --grade 3 --force # neu erzeugen
"""
from __future__ import annotations
import argparse
import re
import subprocess
import sys
from pathlib import Path
from PIL import Image
ROOT = Path(__file__).resolve().parent.parent
SPELLS = ROOT / "RPG" / "5-Regeln" / "Zauber"
IMAGES = ROOT / "RPG" / "zz_archiv" / "images"
FAL = Path.home() / ".pi/agent/skills/fal-bild/scripts/fal_image.sh"
MODEL = "fal-ai/flux/schnell"
SIZE = "1024x1024"
STYLE = (
"Black and white ink illustration, occult woodcut engraving style, "
"one single centered symbolic motif, bold high-contrast line art, "
"pure white background, no text, no letters, no numbers, no frame, no border"
)
def slugify(name: str) -> str:
name = name.lower().replace("ä", "ae").replace("ö", "oe").replace("ü", "ue")
name = name.replace("ß", "ss")
return re.sub(r"-+", "-", re.sub(r"[^a-z0-9]+", "-", name)).strip("-")
def english_name(text: str, fallback: str) -> str:
m = re.search(r">\s*\*\*Englisch:\*\*\s*(.+)", text)
return m.group(1).strip() if m else fallback
def english_summary(text: str) -> str:
"""Kurzbeschreibung aus dem englischen Originaltext-Block."""
m = re.search(r"```\n(.*?)```", text, re.S)
raw = m.group(1) if m else ""
raw = re.sub(r"[*_>`#]", "", raw)
raw = re.sub(r"-\s*\*\*[^*]+\*\*:?", " ", raw)
raw = " ".join(raw.split())
if not raw: # Fallback: deutscher Wirkungstext
m2 = re.search(r"## Wirkung\n(.*?)\n##", text, re.S)
raw = " ".join((m2.group(1) if m2 else "").split())
return raw[:170]
def build_prompt(text: str, stem: str) -> str:
name = english_name(text, stem)
summary = english_summary(text)
subject = f"symbolizing the spell \"{name}\""
if summary:
subject += f": {summary}"
return f"{STYLE}, {subject}"
def embed(text: str, filename: str) -> str:
if f"![[{filename}" in text:
return text
lines = text.splitlines()
# nach der H1-Zeile einfügen
for i, line in enumerate(lines):
if line.startswith("# "):
lines.insert(i + 1, f"\n![[{filename}|320]]")
break
else:
return text
return "\n".join(lines) + ("\n" if text.endswith("\n") else "")
def generate(prompt: str, target: Path) -> bool:
tmp = Path("/tmp/spellimg")
tmp.mkdir(parents=True, exist_ok=True)
cmd = [
"bash", str(FAL),
"--model", MODEL, "--size", SIZE, "--num", "1",
"--out", str(tmp), "--prompt", prompt,
]
res = subprocess.run(cmd, capture_output=True, text=True)
if res.returncode != 0:
print(f" FEHLER: {res.stderr.strip()[:200]}", file=sys.stderr)
return False
paths = [ln for ln in res.stdout.splitlines() if ln.startswith("/")]
if not paths:
print(" FEHLER: kein Bildpfad in der Antwort", file=sys.stderr)
return False
img = Image.open(paths[0]).convert("L")
target.parent.mkdir(parents=True, exist_ok=True)
img.save(target)
return True
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--dry-run", action="store_true")
ap.add_argument("--force", action="store_true", help="vorhandene Bilder neu erzeugen")
ap.add_argument("--limit", type=int, default=0)
ap.add_argument("--grade", type=int, default=0)
ap.add_argument("--school", default="", choices=["", "Arkan", "Klerikal"])
args = ap.parse_args()
files = sorted(SPELLS.rglob("*.md"))
files = [f for f in files if f.parent.name.startswith("Grad ")]
if args.school:
files = [f for f in files if f"/{args.school}/" in str(f).replace("\\", "/")]
if args.grade:
files = [f for f in files if f.parent.name == f"Grad {args.grade}"]
if args.limit:
files = files[: args.limit]
done = skipped = failed = 0
for path in files:
text = path.read_text(encoding="utf-8")
slug = slugify(path.stem)
filename = f"zauber-{slug}.png"
target = IMAGES / filename
prompt = build_prompt(text, path.stem)
if args.dry_run:
print(f"\n== {path.relative_to(ROOT)}\n-> {filename}\n{prompt}")
continue
if target.exists() and not args.force:
skipped += 1
else:
if generate(prompt, target):
done += 1
print(f"ok {filename}")
else:
failed += 1
print(f"FAIL {filename}", file=sys.stderr)
continue
new_text = embed(text, filename)
if new_text != text:
path.write_text(new_text, encoding="utf-8")
if not args.dry_run:
print(f"\nfertig: {done} erzeugt, {skipped} vorhanden, {failed} fehlgeschlagen")
if __name__ == "__main__":
main()

69
tools/make_reference_odt.py Executable file
View file

@ -0,0 +1,69 @@
#!/usr/bin/env python3
"""
Erzeugt tools/a5-reference.odt aus der Pandoc-Standardreferenz,
angepasst an dein A5-Layout:
- A5 (14,801 x 21,001 cm), Ränder oben 0,8 / unten 1,0 / links 1,0 / rechts 0,7 cm
- Grundschrift Alegreya 10 pt, Überschriften Cinzel
- keine Seitennummern (Footer entfernt)
Aufruf: python3 make_reference_odt.py
"""
import io
import os
import re
import subprocess
import zipfile
TOOLS = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(TOOLS, "a5-reference.odt")
# 1) Pandoc-Standardreferenz holen
default = subprocess.check_output(
["pandoc", "--print-default-data-file", "reference.odt"]
)
zin = zipfile.ZipFile(io.BytesIO(default))
names = zin.namelist()
items = {n: zin.read(n) for n in names}
styles = items["styles.xml"].decode("utf-8")
# 2) Gezielte Ersetzungen
REPL = [
# --- Seite A5 + Ränder ---
('fo:page-width="8.5in"', 'fo:page-width="14.801cm"'),
('fo:page-height="11in"', 'fo:page-height="21.001cm"'),
('fo:margin-top="1in"', 'fo:margin-top="0.8cm"'),
('fo:margin-bottom="1in"', 'fo:margin-bottom="1cm"'),
('fo:margin-left="1in"', 'fo:margin-left="1cm"'),
('fo:margin-right="1in"', 'fo:margin-right="0.7cm"'),
# --- Schriften ---
("Times New Roman", "Alegreya"),
("Arial", "Cinzel"),
("Lucida Sans Unicode", "Cinzel"),
("Tahoma1", "Cinzel"),
("Tahoma", "Cinzel"),
# --- Grundschrift 12 pt -> 10 pt ---
('fo:font-size="12pt"', 'fo:font-size="10pt"'),
('font-size-asian="12pt"', 'font-size-asian="10pt"'),
('font-size-complex="12pt"', 'font-size-complex="10pt"'),
]
for a, b in REPL:
styles = styles.replace(a, b)
# 3) Footer (Seitennummer) aus dem Master-Page entfernen
styles = re.sub(r"<style:footer>.*?</style:footer>", "", styles, flags=re.S)
items["styles.xml"] = styles.encode("utf-8")
# 4) Neu packen: mimetype zuerst und unkomprimiert
with zipfile.ZipFile(OUT, "w") as z:
z.writestr("mimetype", items["mimetype"], compress_type=zipfile.ZIP_STORED)
for n in names:
if n == "mimetype":
continue
z.writestr(n, items[n], compress_type=zipfile.ZIP_DEFLATED)
print("OK:", OUT)

42
tools/md2odt.sh Executable file
View file

@ -0,0 +1,42 @@
#!/usr/bin/env bash
#
# Markdown (Obsidian) -> editierbares LibreOffice-ODT (A5)
#
# Aufruf:
# ./tools/md2odt.sh <datei.md> [ausgabename-ohne-endung]
#
# Ausgabe (Standard): Druckmaterial/<name>.odt
#
set -euo pipefail
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
VAULT="$ROOT/RPG"
TOOLS="$ROOT/tools"
OUTDIR="${OUTDIR:-$ROOT/Druckmaterial/autogen_inbox}"
if [ "$#" -lt 1 ]; then
echo "Aufruf: $0 <datei.md> [ausgabename]" >&2
exit 1
fi
SRC="$(realpath "$1")"
NAME="${2:-$(basename "$SRC" .md)}"
OUT="$OUTDIR/${NAME}.odt"
mkdir -p "$OUTDIR"
TMP="$(mktemp -d)"
trap 'rm -rf "$TMP"' EXIT
# 1) Obsidian-Syntax vorverarbeiten
python3 "$TOOLS/obsidian_preprocess.py" "$VAULT" < "$SRC" > "$TMP/in.md"
# 2) Markdown -> ODT (A5-Referenzvorlage; H1 bleibt als "Heading 1" erhalten)
pandoc "$TMP/in.md" \
-f markdown+raw_html \
-t odt \
--reference-doc="$TOOLS/a5-reference.odt" \
--lua-filter="$TOOLS/autowidth.lua" \
-o "$OUT"
echo "OK: $OUT"

View file

@ -0,0 +1,116 @@
#!/usr/bin/env python3
"""
Vorverarbeitung von Obsidian-Markdown zu sauberem Pandoc-Markdown.
Behandelt:
- Obsidian-Wikilinks: [[Ziel]] [[Ziel|Anzeige]] [[bild.jpg|BreitePx]]
- Emoji -> drucktaugliche Glyphen bzw. Text (dekorative Emojis werden entfernt)
- ==Markierung== -> **fett** (drucktauglicher Ersatz)
- %% Kommentare %% -> entfernt
- Variation-Selektoren (U+FE0F/U+FE0E) entfernen
Aufruf:
obsidian_preprocess.py <VAULT_ROOT> < eingabe.md > ausgabe.md
"""
import os
import re
import sys
IMG_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".svg", ".avif"}
# Emoji -> Ersatz (leerer String = entfernen)
EMOJI = {
"\U0001F449": "\u2192", # 👉 ->
"\U0001F7E1": "\u25CF", # 🟡 ●
"\u26A0": "\u26A0", # ⚠ (wird über DejaVu-Fallback gesetzt)
"\u2600": "\u2600", # ☀ (DejaVu-Fallback)
"\U0001F338": "", # 🌸
"\U0001F342": "", # 🍂
"\u2744": "", # ❄
"\U0001F324": "", # 🌤
"\U0001F5FA": "", # 🗺
"\U0001F3D4": "", # 🏔
"\U0001F5E3": "", # 🗣
"\U0001F48E": "", # 💎
"\U0001F3B2": "", # 🎲
"\u26A1": "", # ⚡
"\U0001F4C8": "", # 📈
"\U0001F4C9": "", # 📉
"\U0001F504": "", # 🔄
}
VS = {"\uFE0F", "\uFE0E"}
SKIP_DIRS = {".git", ".obsidian", ".trash", "node_modules"}
def scan_images(root: str) -> dict:
"""basename(lower) -> absoluter Pfad (nur Nicht-.trash-Pfade)."""
mapping = {}
def walk():
for dirpath, dirnames, filenames in os.walk(root):
dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
for fn in filenames:
if os.path.splitext(fn)[1].lower() in IMG_EXT:
# Absoluter Pfad, damit Pandoc das Bild unabhängig vom
# aktuellen Arbeitsverzeichnis findet.
full = os.path.abspath(os.path.join(dirpath, fn))
key = fn.lower()
mapping.setdefault(key, full)
walk()
return mapping
def px_to_cm(px: float) -> float:
return round(px / 96.0 * 2.54, 2)
def resolve_wikilink(image_map: dict, inner: str) -> str:
if "|" in inner:
target, disp = inner.split("|", 1)
else:
target, disp = inner, None
target = target.strip()
ext = os.path.splitext(target.lower())[1]
if ext in IMG_EXT:
path = image_map.get(target.lower(), target)
alt = os.path.basename(target)
if disp is not None and disp.strip().isdigit():
width = px_to_cm(int(disp.strip()))
return f"![{alt}]({path}){{width={width}cm}}"
return f"![{alt}]({path}){{width=100%}}"
# Notiz-Link -> Klartext
return (disp.strip() if disp is not None else target)
def process(text: str, image_map: dict) -> str:
# 1. Kommentare
text = re.sub(r"%%.*?%%", "", text, flags=re.DOTALL)
# 2. Wikilinks
text = re.sub(r"\[\[([^\]]+)\]\]", lambda m: resolve_wikilink(image_map, m.group(1)), text)
# 3. Variation-Selektoren
for vs in VS:
text = text.replace(vs, "")
# 4. Emoji
for k, v in EMOJI.items():
text = text.replace(k, v)
# 5. ==mark== -> **fett**
text = re.sub(r"==([^=\n]+)==", r"**\1**", text)
# 6. Leerraum glätten (nach Emoji-Entfernung), aber Tabellen/Code unberührt
out = []
for line in text.split("\n"):
stripped = line.lstrip()
if not stripped.startswith("|") and not stripped.startswith("```"):
line = re.sub(r"[ \t]{2,}", " ", line)
out.append(line)
return "\n".join(out)
def main():
root = sys.argv[1] if len(sys.argv) > 1 else "."
image_map = scan_images(root)
sys.stdout.write(process(sys.stdin.read(), image_map))
if __name__ == "__main__":
main()

170
tools/pdf_manifest.json Normal file
View file

@ -0,0 +1,170 @@
{
"version": 1,
"remote_dir": "pdf_archiv/blobs",
"files": {
"Druckmaterial/Crafting 1.0.6 - Free Version.pdf": {
"sha256": "f2f7ed7211319b309f2b1e67d5207c77ac740fff2c8c79454dcde6c6e910b19b",
"size": 15655916
},
"Druckmaterial/Monstrous Compendium/MC1-Monstrous_Compendium_01.pdf": {
"sha256": "9cfe3071edccd2738d23282a2ee18045456e396b3bc5ead7f032d265549448ba",
"size": 79936025
},
"Druckmaterial/Monstrous Compendium/MC2-Monstrous_Compendium_02.pdf": {
"sha256": "86e9185bb8c5973df93d2ccc4220ecbf39708e32590f8905650867309bd3e04c",
"size": 79642853
},
"Druckmaterial/Monstrous Compendium/Monster_Manual_(1e).pdf": {
"sha256": "a752f217eb4b5451c981227e28713bd90ee077c541db63e37db05b66760e7156",
"size": 23296799
},
"RPG/1-Sessions/generische Tabellen/Kreaturen/MC1-Monstrous_Compendium_01.pdf": {
"sha256": "9cfe3071edccd2738d23282a2ee18045456e396b3bc5ead7f032d265549448ba",
"size": 79936025
},
"RPG/1-Sessions/generische Tabellen/Kreaturen/MC2-Monstrous_Compendium_02.pdf": {
"sha256": "86e9185bb8c5973df93d2ccc4220ecbf39708e32590f8905650867309bd3e04c",
"size": 79642853
},
"RPG/1-Sessions/generische Tabellen/Shop Catalog_v2.0.2.pdf": {
"sha256": "5b7d47ff2e474d26a7504362027d9e7b91c78062be8dc4ab5790f8e443ec8adb",
"size": 2044306
},
"RPG/5-Regeln/Bücher/ACKSII_Judges_Journal.pdf": {
"sha256": "6f3adc368075c5d97a92a2ccebfbac974c91b24b89dbc5fa1ec4c9e3119ce98f",
"size": 93143313
},
"RPG/5-Regeln/Bücher/ACKSII_Revised_Rulebook.pdf": {
"sha256": "263f8677309b5feea856b227bc7cfcb5b9316f2452e0e079cd7822a6cf8a18d4",
"size": 102853293
},
"RPG/5-Regeln/Bücher/ACKS_II_Treasure_Tome.pdf": {
"sha256": "54d5406e606f5b22690a22651cc5836b92e182f934d8dcc3d9a7ed90a6ff60f9",
"size": 52324162
},
"RPG/5-Regeln/Bücher/Advanced_Fantasy_Players_Tome_v1-2.pdf": {
"sha256": "d605404768f8058616a5a27c1628e9008c450a491a26135edb5c7193c336f96e",
"size": 31488693
},
"RPG/5-Regeln/Bücher/Advanced_Fantasy_Referees_Tome_v1-2.pdf": {
"sha256": "32d3cf97e53a79e3f5ff06078d9a51361fbfacfd35961493fb45a7eba99fcca6",
"size": 31393442
},
"RPG/5-Regeln/Bücher/Dungeon_Master_s_Guide_(1e).pdf": {
"sha256": "af37452b5e7ecf4930a03d8d48fb3444ef321c06ae5d49d7b6814550e5da7c17",
"size": 13806938
},
"RPG/5-Regeln/Preislisten/D&D Shop Catalog, V-2.0.2-Refresh.pdf": {
"sha256": "5b7d47ff2e474d26a7504362027d9e7b91c78062be8dc4ab5790f8e443ec8adb",
"size": 2044306
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/40 Mulciber's Flute.pdf": {
"sha256": "b5d8fe2c08f47f1b7cb45ff827da5d80245b0798940089e49cace2c24241d1db",
"size": 4270938
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/41 Clowns.pdf": {
"sha256": "969bd7a47251126bc1c0f346ea024f99923cd0dc5cd26597416b14a08a234cce",
"size": 3630305
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/42 God Unmoving.pdf": {
"sha256": "b2d926b63db9e95dcb4fac62414c911f5803c2dc84f74798d8c563bbd94dfb72",
"size": 3381648
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/43 Do it for the Beast.pdf": {
"sha256": "70b28ff5e362ff4a8e34a035b07627db24322817fd283ab02a63ff6f5f75f371",
"size": 2069720
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/44 His Eternal Progress.pdf": {
"sha256": "13789c8454b89b62f8cd0abfc60d5155effde6aecf9984613e511941450e5613",
"size": 2458962
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/45 Sorcerer's Feast.pdf": {
"sha256": "46daacf25983f5423641528cb447a8896f4dfcaf1e4c2e687f7102cb119f6488",
"size": 1971102
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/47 Man from Before.pdf": {
"sha256": "3c657d1f435f055e4ec190d86ac1e82f11bf3610041e7fc579ceda2781b29443",
"size": 3104381
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/55 Hour of Death.pdf": {
"sha256": "bb436bcdf2659d8d7499dba6541d78306382f028cabec096c09153d1ca8e1b7f",
"size": 2202181
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/B5_Horror_on_the_Hill_(Basic).pdf": {
"sha256": "8a3513e053be651c4f58115312f9d4cc5f4d412422443496546a55acdba326ac",
"size": 11408583
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/BasilicaOfTheLeperMessiah.pdf": {
"sha256": "406c0f5c85b6b358f5ae7ec7f607550a896277631bb9bc224182a9e2ca66b11a",
"size": 1352594
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/Falkrest_Abbey_1.1.pdf": {
"sha256": "9a1e81db72a7170d6a1fac4a6ce357699b39e795c22729197eabbfb8610f6493",
"size": 13282332
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/Fogheart_the_torso_of_The_Giant_King_-_OSE_-_Spreads.pdf": {
"sha256": "82d781cd1056e9ac669cd44700d3a9f335a93741cc2f51d5285d6f6cc17f594f",
"size": 96832469
},
"RPG/7-Prep/prep_2026-11-20/Abenteuer/the-tomb-of-abysthor-sword-amp-sorcery_compress.pdf": {
"sha256": "5d2ae19a4eea0ac39106fed179fc562f13f2ff0db921481b182303a89c583fc3",
"size": 38225067
},
"RPG/7-Prep/prep_2026-11-20/Bücher/Never-Unprepared-Guide-to-Prep.pdf": {
"sha256": "21d13127b438eeddb65d8151e4889ab0670736d03cec9ede04c31a99fc237a08",
"size": 7246325
},
"RPG/7-Prep/prep_2026-11-20/Bücher/RPGPunditPresents_35_30CourtlyEvents.pdf": {
"sha256": "e30e3de813d5dff7f726186f74e116205c65f4027083067ccad645d706f1f82e",
"size": 6490332
},
"RPG/7-Prep/prep_2026-11-20/Bücher/Tome_of_Adventure_Design.pdf": {
"sha256": "9c5f8d5bcb8e2ec9c3eb40e6579fb14ef3af4b984024e6bda43995adfe52ae25",
"size": 36547030
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Carcass_Crawler_Issue_1.pdf": {
"sha256": "38fc5261281bf6ad86e929bc1985adce41d440dd0bad32fc65307450234c7475",
"size": 3988236
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Carcass_Crawler_Issue_2.pdf": {
"sha256": "a9fcb3ada9446ec7b2c1d50ad730b6acdd3cc3de6b9d88ff784398d6dae2bc55",
"size": 3815610
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Downtime_Basic_PDF.pdf": {
"sha256": "df8306ceedd09f81283269a6d969ffbac3e9bfb64f2976824863a6c73ab1f29e",
"size": 41613360
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Garys_Appendix_-_Issue_1.pdf": {
"sha256": "f38c809f6ef8e1d0ff0c315899d14352142a353cb914439392bb9b7280531260",
"size": 15276279
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Garys_Appendix_-_Issue_2.pdf": {
"sha256": "6daca0d9fbe83e4687f9a3064c005213030ae420c81ecf7c0f2672badf1c1a55",
"size": 16653504
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Garys_Appendix_-_Issue_3.pdf": {
"sha256": "c1c0a0bda6d18483ebd854d1e2d69aec59ecb266f4f0db97dbcab0198484577f",
"size": 10527484
},
"RPG/7-Prep/prep_2026-11-20/Magazine/Garys_Appendix_-_Issue_4.pdf": {
"sha256": "e98cabca0a02ab545249210bb5147124e64747c8684743c5cac616e8f6f55dcb",
"size": 16075107
},
"RPG/7-Prep/prep_2026-11-20/Magazine/MythicMagazineCompilation1.pdf": {
"sha256": "489ca3581e89626dd726d1df7eff9dbd4f283b43d387af755b63962bd93e2334",
"size": 13665177
},
"RPG/7-Prep/prep_2026-11-20/MegaDungeons/rappan-athuk-pdf-free.pdf": {
"sha256": "f9c409d446822fcee7a89f764cdaa9efe39baa2117968d2a819862e09f17c6e2",
"size": 32496958
},
"RPG/7-Prep/prep_2026-11-20/MegaDungeons/stonehell-dungeon-1-down-night-haunted-halls.pdf": {
"sha256": "714c94a95a5e1a0cacb7696d68c3eeb09c5b861933360562845a2271ceab28a0",
"size": 6634768
},
"RPG/7-Prep/prep_2026-11-20/MegaDungeons/stonehell-dungeon-2-into-the-heart-of-hellpdf.pdf": {
"sha256": "f11da4c925caf584ca4c6eb4da5770776c4eed56b953b07c67fdf6a1349291f4",
"size": 12267286
}
}
}

351
tools/pdf_sync.py Executable file
View file

@ -0,0 +1,351 @@
#!/usr/bin/env python3
"""
Hält die ausgelagerten Regelwerk-/Abenteuer-PDFs zwischen Vault und Webserver synchron.
Warum: Fremdmaterial (Regelwerke, Abenteuer, Magazine) bläht das Git-Repo auf rund
1 GB auf. Es liegt deshalb nicht mehr in Git, sondern auf dem eigenen Server –
**außerhalb von `public_html`**, also für Crawler und Direkt-URLs unerreichbar:
<FTP-Wurzel>/pdf_archiv/blobs/<sha256>.pdf
Der kleine, versionierte Manifest `tools/pdf_manifest.json` (Pfad → SHA-256 + Größe)
sagt einem frischen Checkout, welche Datei wohin gehört. Ablage ist
inhaltsadressiert: Duplikate und Umbenennungen kosten keinen zweiten Upload.
Weil der Blob-Name nur der Hash ist, liegt auf dem Server zusätzlich
`pdf_archiv/index.json` – dieselbe Pfad→Hash-Tabelle. Damit bleibt das Archiv
auch ohne Repo lesbar (`--pull` holt den Index, wenn das Manifest fehlt).
Befehle
-------
tools/pdf_sync.py --scan # Manifest aus den lokalen PDFs neu schreiben
tools/pdf_sync.py --push # fehlende Blobs hochladen
tools/pdf_sync.py --pull # fehlende Blobs herunterladen (frischer Checkout)
tools/pdf_sync.py --check # Abgleich lokal/Remote gegen Manifest
tools/pdf_sync.py --index # nur index.json hochladen
tools/pdf_sync.py --prune --yes # Remote-Blobs löschen, die im Manifest fehlen
Zugang: `credentials.txt` im Repo-Wurzel (FTP_URL, FTP_USER, FTP_PASSWORD), FTPS
explizit (`--ssl-reqd`, wie in `tools/deploy_web.sh`).
Aufgenommen werden alle PDFs über 1 MiB aus `RPG/` und `Druckmaterial/` – **außer**
den selbst erzeugten Handouts (Summarien, SL-Tabellen, SL-Schirm, pdf_export).
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
CREDENTIALS = ROOT / "credentials.txt"
MANIFEST = ROOT / "tools" / "pdf_manifest.json"
SCAN_DIRS = ["RPG", "Druckmaterial"]
MIN_SIZE = 1024 * 1024 # 1 MiB: alles Kleinere bleibt in Git
SKIP_PATH_PARTS = {"pdf_export", "SL Schirm"}
SKIP_NAME_PARTS = ("Summarium", "SL-Tabellen", "SL-Schirm")
REMOTE_DIR = os.environ.get("PDF_REMOTE_DIR", "pdf_archiv/blobs")
REMOTE_INDEX = os.environ.get("PDF_REMOTE_INDEX", "pdf_archiv/index.json")
MANIFEST_VERSION = 1
# ------------------------------------------------------------------ Hilfen
def die(msg: str) -> None:
raise SystemExit(f"FEHLER: {msg}")
def credentials() -> tuple[str, str, str]:
if not CREDENTIALS.exists():
die(f"{CREDENTIALS} fehlt (FTP_URL, FTP_USER, FTP_PASSWORD)")
werte: dict[str, str] = {}
for line in CREDENTIALS.read_text(encoding="utf-8").splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
k, v = line.split("=", 1)
werte[k.strip()] = v.strip().strip("'\"")
try:
return werte["FTP_URL"], werte["FTP_USER"], werte["FTP_PASSWORD"]
except KeyError as fehlt:
die(f"{fehlt} fehlt in credentials.txt")
def curl(args: list[str], userpass: str | None = None, verbose: bool = False) -> str:
"""curl mit FTPS; Zugangsdaten laufen über stdin-Config (nicht über argv)."""
cmd = ["curl", "-sS", "--ssl-reqd", "--retry", "3", "--retry-delay", "2",
"--connect-timeout", "20", "--ftp-create-dirs"]
if not verbose:
cmd.append("--no-progress-meter")
cmd += args
if userpass:
cmd += ["--config", "-"]
proc = subprocess.run(cmd, input=f'user = "{userpass}"\n', text=True,
capture_output=True)
else:
proc = subprocess.run(cmd, text=True, capture_output=True)
if proc.returncode != 0:
die(f"curl: {proc.stderr.strip() or proc.stdout.strip()}")
return proc.stdout
def sha256(path: Path) -> str:
h = hashlib.sha256()
with path.open("rb") as fh:
for block in iter(lambda: fh.read(1024 * 1024), b""):
h.update(block)
return h.hexdigest()
def is_archived_pdf(path: Path) -> bool:
if path.suffix.lower() != ".pdf" or not path.is_file():
return False
if path.stat().st_size <= MIN_SIZE:
return False
rel = path.relative_to(ROOT)
if any(part in SKIP_PATH_PARTS for part in rel.parts):
return False
if any(teil in path.name for teil in SKIP_NAME_PARTS):
return False
return True
def discover() -> list[Path]:
treffer: list[Path] = []
for wurzel in SCAN_DIRS:
basis = ROOT / wurzel
if basis.exists():
treffer += [p for p in basis.rglob("*.pdf") if is_archived_pdf(p)]
return sorted(treffer)
def load_manifest() -> dict:
if not MANIFEST.exists():
return {"version": MANIFEST_VERSION, "remote_dir": REMOTE_DIR, "files": {}}
return json.loads(MANIFEST.read_text(encoding="utf-8"))
def remote_listing(url: str, userpass: str) -> set[str]:
ziel = f"ftp://{url}/{REMOTE_DIR}/"
try:
ausgabe = curl(["--list-only", ziel], userpass)
except SystemExit:
return set() # Verzeichnis existiert noch nicht
return {z.strip() for z in ausgabe.splitlines() if z.strip() not in ("", ".", "..")}
def index_json(files: dict[str, dict]) -> str:
"""Serverfassung des Manifests – macht das Archiv ohne Repo lesbar."""
return json.dumps({"version": MANIFEST_VERSION, "remote_dir": REMOTE_DIR,
"hinweis": "Pfad -> SHA-256 + Groesse; Blobs liegen unter pdf_archiv/blobs/",
"files": dict(sorted(files.items()))},
indent=2, ensure_ascii=False) + "\n"
def upload_index(url: str, userpass: str, files: dict[str, dict]) -> None:
tmp = ROOT / "tools" / ".pdf_index.tmp"
tmp.write_text(index_json(files), encoding="utf-8")
try:
curl(["-T", str(tmp), f"ftp://{url}/{REMOTE_INDEX}"], userpass)
print(f"Index hochgeladen: {REMOTE_INDEX}")
finally:
tmp.unlink(missing_ok=True)
def fetch_index(url: str, userpass: str) -> dict:
tmp = ROOT / "tools" / ".pdf_index.tmp"
curl(["-o", str(tmp), f"ftp://{url}/{REMOTE_INDEX}"], userpass)
try:
return json.loads(tmp.read_text(encoding="utf-8"))
finally:
tmp.unlink(missing_ok=True)
def mb(n: int) -> str:
return f"{n / 1048576:.1f} MB"
# ------------------------------------------------------------------ Befehle
def cmd_scan(verbose: bool) -> None:
alt = load_manifest()["files"]
neu: dict[str, dict] = {}
for p in discover():
neu[p.relative_to(ROOT).as_posix()] = {"sha256": sha256(p), "size": p.stat().st_size}
geaendert = [k for k, v in neu.items() if alt.get(k, {}).get("sha256") not in (None, v["sha256"])]
dazu = [k for k in neu if k not in alt]
weg = [k for k in alt if k not in neu]
MANIFEST.write_text(json.dumps({"version": MANIFEST_VERSION, "remote_dir": REMOTE_DIR,
"files": dict(sorted(neu.items()))},
indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
blobs = {v["sha256"] for v in neu.values()}
gesamt = sum(v["size"] for v in neu.values())
print(f"Manifest: {len(neu)} Dateien, {len(blobs)} Blobs, {mb(gesamt)} → {MANIFEST.name}")
for titel, menge in (("neu", dazu), ("geändert", geaendert), ("entfernt", weg)):
if menge:
print(f" {titel}: {len(menge)}")
if verbose:
for k in menge:
print(f" {k}")
def cmd_push(verbose: bool, force: bool) -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
files = load_manifest()["files"]
if not files:
die("Manifest ist leer – zuerst --scan laufen lassen")
vorhanden = remote_listing(url, userpass)
offen = [(k, v) for k, v in files.items()
if force or f"{v['sha256']}.pdf" not in vorhanden]
blobs: dict[str, int] = {}
for k, v in offen:
blobs.setdefault(v["sha256"], v["size"])
print(f"Remote: {len(vorhanden)} Blobs · zu laden: {len(blobs)} Blobs "
f"({mb(sum(blobs.values()))}) für {len(offen)} Dateien")
for n, (digest, size) in enumerate(sorted(blobs.items()), 1):
quelle = next((ROOT / k for k, v in files.items() if v["sha256"] == digest), None)
if quelle is None or not quelle.exists():
print(f" [{n}/{len(blobs)}] übersprungen (lokal nicht vorhanden): {digest[:12]}")
continue
if verbose or n == 1 or n == len(blobs) or n % 10 == 0:
print(f" [{n}/{len(blobs)}] {quelle.name} ({mb(size)})")
curl(["-T", str(quelle), f"ftp://{url}/{REMOTE_DIR}/{digest}.pdf"], userpass)
upload_index(url, userpass, files)
print("Upload fertig.")
def cmd_pull(verbose: bool, force: bool) -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
files = load_manifest()["files"]
if not files:
print("Manifest lokal leer – hole pdf_archiv/index.json vom Server …")
files = fetch_index(url, userpass).get("files", {})
if files:
MANIFEST.write_text(index_json(files), encoding="utf-8")
print(f"Manifest aus Server-Index rekonstruiert ({len(files)} Dateien).")
if not files:
die("Manifest ist leer – zuerst --scan laufen lassen")
vorhanden = remote_listing(url, userpass)
fehlend, konflikt, geladen = [], [], 0
for rel, meta in files.items():
ziel = ROOT / rel
digest = meta["sha256"]
if ziel.exists():
if sha256(ziel) != digest:
konflikt.append(rel)
if not force:
continue
else:
continue
if f"{digest}.pdf" not in vorhanden:
fehlend.append(rel)
continue
ziel.parent.mkdir(parents=True, exist_ok=True)
tmp = ziel.with_suffix(ziel.suffix + ".part")
if verbose:
print(f" ↓ {rel}")
curl(["-o", str(tmp), f"ftp://{url}/{REMOTE_DIR}/{digest}.pdf"], userpass)
if sha256(tmp) != digest:
tmp.unlink(missing_ok=True)
die(f"Prüfsumme falsch nach Download: {rel}")
tmp.replace(ziel)
geladen += 1
print(f"Download fertig: {geladen} Dateien geladen, {len(konflikt)} Konflikte, "
f"{len(fehlend)} fehlen auf dem Server")
for rel in konflikt:
print(f" KONFLIKT (lokal anders, nicht überschrieben): {rel}")
for rel in fehlend:
print(f" FEHLT REMOTE: {rel}")
def cmd_check() -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
files = load_manifest()["files"]
vorhanden = remote_listing(url, userpass)
lokal_fehlt, lokal_anders, remote_fehlt = [], [], []
for rel, meta in files.items():
ziel = ROOT / rel
if not ziel.exists():
lokal_fehlt.append(rel)
elif sha256(ziel) != meta["sha256"]:
lokal_anders.append(rel)
if f"{meta['sha256']}.pdf" not in vorhanden:
remote_fehlt.append(rel)
ungelistet = [p.relative_to(ROOT).as_posix() for p in discover()
if p.relative_to(ROOT).as_posix() not in files]
print(f"Manifest: {len(files)} Dateien · Remote-Blobs: {len(vorhanden)}")
print(f" lokal fehlt: {len(lokal_fehlt)}")
print(f" lokal abweichend: {len(lokal_anders)}")
print(f" remote fehlt: {len(remote_fehlt)}")
print(f" nicht im Manifest: {len(ungelistet)}")
for titel, menge in (("lokal fehlt", lokal_fehlt), ("lokal abweichend", lokal_anders),
("remote fehlt", remote_fehlt),):
for rel in menge[:20]:
print(f" {titel}: {rel}")
for rel in ungelistet:
print(f" nicht im Manifest: {rel}")
def cmd_prune(yes: bool, verbose: bool) -> None:
url, user, pw = credentials()
userpass = f"{user}:{pw}"
gebraucht = {f"{v['sha256']}.pdf" for v in load_manifest()["files"].values()}
vorhanden = remote_listing(url, userpass)
ueberzaehlig = sorted(vorhanden - gebraucht)
if not ueberzaehlig:
print("Nichts zu löschen.")
return
print(f"{len(ueberzaehlig)} Blobs ohne Manifest-Eintrag:")
for name in ueberzaehlig:
print(f" {name}")
if not yes:
print("Zum Löschen mit --yes erneut aufrufen.")
return
for name in ueberzaehlig:
if verbose:
print(f" DELE {name}")
curl(["-Q", f"DELE /{REMOTE_DIR}/{name}", f"ftp://{url}/"], userpass)
print("Gelöscht.")
def main() -> None:
ap = argparse.ArgumentParser(description="PDF-Archiv zwischen Vault und Server syncen")
g = ap.add_mutually_exclusive_group()
g.add_argument("--scan", action="store_true", help="Manifest aus lokalen PDFs schreiben")
g.add_argument("--push", action="store_true", help="fehlende Blobs hochladen")
g.add_argument("--pull", action="store_true", help="fehlende Blobs herunterladen")
g.add_argument("--check", action="store_true", help="Abgleich lokal/Remote")
g.add_argument("--index", action="store_true", help="nur index.json hochladen")
g.add_argument("--prune", action="store_true", help="Remote-Blobs ohne Manifest löschen")
ap.add_argument("--force", action="store_true", help="vorhandene/gleichnamige Dateien überschreiben")
ap.add_argument("--yes", action="store_true", help="Löschen bestätigen (--prune)")
ap.add_argument("-v", "--verbose", action="store_true")
args = ap.parse_args()
if args.scan or not any([args.push, args.pull, args.check, args.prune, args.index]):
cmd_scan(args.verbose)
if args.push:
cmd_push(args.verbose, args.force)
if args.pull:
cmd_pull(args.verbose, args.force)
if args.check:
cmd_check()
if args.index:
url, user, pw = credentials()
files = load_manifest()["files"]
if not files:
die("Manifest ist leer – zuerst --scan laufen lassen")
upload_index(url, f"{user}:{pw}", files)
if args.prune:
cmd_prune(args.yes, args.verbose)
if __name__ == "__main__":
main()

View file

@ -0,0 +1,99 @@
# Prompt: Sitzungsprotokoll auf Geschehnisse kondensieren
Wiederverwendbarer Prompt für LLM-Sitzungen (Pi/Claude o. ä.), um ein WhisperX-Protokoll
der Westreiche-Runde auf die reine Spielhandlung zu reduzieren – ohne Informationsverlust.
Beispiel-Referenz: Sitzung 13 (24.10.2026), 35.891 → 1.408 Wörter (ca. 96 % Kürzung),
Ergebnis: `RPG/.../2026-10-24_..._Sitzung_13_Geschehnisse.md`.
---
## 0. Vorbereitung (optional, spart Kontext)
Zeitstempel und Sprecher-Tags entfernen und aufeinanderfolgende Turns desselben Sprechers
bündeln (ca. −35 % Volumen, bessere Lesbarkeit):
```bash
python3 - <<'EOF'
import re
src = '/pfad/zu/Sitzung.txt' # Original-Protokoll
dst = '/tmp/sitzung_merged.txt' # Arbeitsdatei
lines = open(src, encoding='utf-8').read().splitlines()
out, cur, buf = [], None, []
for l in lines:
m = re.match(r'\[(\d\d:\d\d:\d\d)\] \[(SPEAKER_\d+)\]:\s?(.*)', l)
if m:
_, s, txt = m.groups()
elif re.match(r'^\[(\d\d:\d\d:\d\d)\]', l):
continue
else:
s, txt = cur, l.strip()
if s != cur and buf:
out.append(f'{cur}: ' + ' '.join(buf)); buf = []
cur = s; buf.append(txt)
if buf:
out.append(f'{cur}: ' + ' '.join(buf))
open(dst, 'w', encoding='utf-8').write('\n'.join(out))
EOF
```
## 1. Prompt
> Schau dir das RPG-Protokoll `<DATEI>.txt` an. Prüfe, wie weit man den Inhalt auf die
> Geschehnisse kürzen kann, ohne Informationen zu verlieren.
>
> **Vorgehen**
> 1. Protokoll vollständig lesen (bei >3.000 Zeilen in Blöcken à 130 Zeilen der
> gemergten Fassung).
> 2. Inhaltlich Verdichtbares von inhaltlich Relevantem trennen.
> 3. Kondensat als Markdown-Datei `<DATEI>_Geschehnisse.md` neben dem Original ablegen.
> 4. Kürzungsquote mit `wc -l -w -c` belegen (Original vs. Kondensat).
>
> **Behalten (Pflicht)**
> - Alle Fakten der Spielwelt: Orte, NSC (mit Funktion), Gegenstände mit Eigenschaften,
> Preisen, Werten und offenen Fragen.
> - Alle Handlungsschritte in chronologischer Reihenfolge, inkl. Rückblick/Ausgangslage.
> - Visionen, Hinweise, Rätsel inkl. **Lösung** und Fehlversuchen, Gerüchte, Aufträge.
> - Wirtschafts- und Statusdaten (Kassenstand, Miete, Löhne, TP/EP, Aufstiege,
> gelernter/fehlgeschlagener Zauber, Spielzeit/Datum).
> - Offene Fäden und nächste Schritte am Ende.
> - Zeitangaben der Spielwelt (Datum, Wetter, Reisezeiten).
>
> **Weglassen (Rauschen)**
> - OOC-Talk (Essensbestellung, Filme/Serien/Streaming, YouTube, Terminorganisation).
> - Regel- und Mechanikdiskussionen, Würfelwürfe ohne Ergebniswert, Wiederholungen
> (mehrfach aufgesagte Rätselverse, Rechenwege der Gruppenkasse).
> - Meta-Talk über Aufnahme, KI-Tools, Protokollführung.
> - Smalltalk zwischen Charakteren ohne Faktenertrag („wir gehen jetzt los").
>
> **Form**
> - Überschriften je Szene/Woche, Tabellen für Loot und Preise, Stichpunkte statt Fließtext.
> - Zitate nur für wörtliche Rätsel, Passwörter und Notizen.
> - Sprache: Deutsch; Bezeichner/Namen unverändert aus dem Protokoll.
> - Zielumfang: ca. **3–5 % der Originalwortzahl**; bei sehr dichten Sitzungen bis 8 %.
> - Am Dateikopf: Quelle, Originalumfang und Hinweis, was entfernt wurde.
>
> **Sorgfaltspflichten**
> - Nichts hinzuerfinden; Unsicherheiten als „unklar/nicht bestimmt" markieren.
> - Widersprüchliche Zahlen im Protokoll so übernehmen und ggf. mit „(so protokolliert)"
> kennzeichnen, nicht glattrechnen.
> - Fehlerhafte Sprecherzuordnung der Diarisierung prüfen (Namen im Kondensat korrekt
> zuordnen, Abweichungen kurz vermerken).
>
> **Abschlussbericht (max. 3–5 Stichpunkte)**
> - Pfad des Kondensats, Kürzungsquote in Wörtern/Zeichen.
> - Was wegfiel (Anteile), was vollständig erhalten blieb.
> - Grenze der weiteren Kürzung (was nur durch Informationsverlust ginge).
> - Auffälligkeiten/Unstimmigkeiten im Protokoll.
## 2. Prüfkriterien für „ohne Informationsverlust"
Ein Kondensat ist gut, wenn ein Spielleiter allein daraus die nächste Sitzung vorbereiten
kann und ein Spieler allein daraus seinen Ausrüstungs- und Kenntnisstand rekonstruieren kann.
Konkret prüfen:
- Ist jeder Loot mit Wirkung und Verkaufspreis/Wert erfasst?
- Jede Rechnung nachvollziehbar (Kassenstand vor/nach Ausgaben)?
- Jede Vision, jedes Rätsel und jede NSC-Aussage mit Konsequenz enthalten?
- Sind alle Ortsnamen und Reisezeiten notiert?
- Bleiben Handlungsfäden offen markiert, statt stillschweigend geschlossen?