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.
828 lines
40 KiB
Python
828 lines
40 KiB
Python
#!/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("&", "&").replace("<", "<").replace(">", ">")
|
||
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()
|