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.
285 lines
12 KiB
Python
285 lines
12 KiB
Python
#!/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("&", "&").replace("<", "<").replace(">", ">")
|
||
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 & 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> „Deine Handflächen werden heiß "
|
||
"und rot“ statt „Sonnenbrand der Gnade, 1W4 Tage“.", 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: „Es gibt kein unbegrenztes Zaubern“ (arkan) · "
|
||
"„Liturgien und Glaubensgemeinschaften“ §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()
|