Handouts, Ferrum-Signatur und SL-Karte 10 (Tore & Frostpfad)

- tools/build_spieler_handouts.py: druckfertige A4-Handouts (Notiz, Frachtbrief,
  verschluesselte Tagebuchseite + SL-Uebertragung), generierte Assets im Vault
- Ferrum: bekehrtes Eisen sieht wie Silber aus (drei Sorten, Erkenntnismerkmale,
  Schleuse am Siegel); Gruenspan in 'Die drei Tore im Gruenen' auf Bronzefugen reduziert
- Tore im Gruenen: Lage Unterfeld, Frost-Querung des Moors, verbotene Reihenfolge
  und Radis Reim als Kanon
- SL-Schirm: neue Karte 10 (Tore & Frostpfad), Kalender- und Reveal-Eintraege aktualisiert
This commit is contained in:
torsten 2026-11-20 18:33:26 +01:00
parent 613a9d8d1d
commit 90f16984a3
9 changed files with 679 additions and 18 deletions

View file

@ -0,0 +1,598 @@
#!/usr/bin/env python3
"""Druckfertige Spieler-Handouts (A4) aus dem Vault erzeugen.
Erzeugt drei Einzel-PDFs im Zielordner (Standard:
``RPG/7-Prep/prep_2026-11-20/Handouts``):
* ``Handout - Notiz Das dritte Tor im Gruenen.pdf`` (Höhlenbeute, Sitzung 013)
* ``Handout - Frachtbrief Nordtor.pdf`` (Schmuggelroute Garana → Norden)
* ``Handout - Tagebuchseite verschluesselt.pdf`` (echtes, lösbares Schlüsselalphabet)
Alle Texte sind *echte* Schrift (kein KI-Bild), damit sie lesbar bleiben. Die
Inhalte stützen sich auf Kanon: ``Geheimnisse/Die drei Tore im Grünen.md``,
``Geheimnisse/Ferrum – die schleichende Korruption.md``,
``Siedlungen/Garana/Events.md``.
Aufruf:
.venv/bin/python tools/build_spieler_handouts.py [--out DIR]
"""
from __future__ import annotations
import argparse
import random
from pathlib import Path
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import mm
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.pdfgen import canvas
import sys
sys.path.insert(0, str(Path(__file__).resolve().parent))
from fontpicker import font_dir # noqa: E402
FONT_DIR = font_dir()
HAND_FALLBACKS = (
"~/Library/Fonts/Bradley Hand Bold.ttf",
"/System/Library/Fonts/Supplemental/Bradley Hand Bold.ttf",
"/System/Library/Fonts/Supplemental/Chalkduster.ttf",
)
PAPER = (0.955, 0.925, 0.855)
INK = (0.13, 0.11, 0.09)
FADED = (0.42, 0.36, 0.29)
STAMP = (0.55, 0.13, 0.11)
def register_fonts() -> None:
pdfmetrics.registerFont(TTFont("Serif", str(FONT_DIR / "DejaVuSerif.ttf")))
pdfmetrics.registerFont(TTFont("Serif-Bold", str(FONT_DIR / "DejaVuSerif-Bold.ttf")))
pdfmetrics.registerFont(TTFont("Serif-Italic", str(FONT_DIR / "DejaVuSerif-Italic.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.registerFont(TTFont("Mono-Bold", str(FONT_DIR / "DejaVuSansMono-Bold.ttf")))
hand = None
for candidate in HAND_FALLBACKS:
path = Path(candidate).expanduser()
if path.is_file():
hand = path
break
pdfmetrics.registerFont(TTFont("Hand", str(hand) if hand else str(FONT_DIR / "DejaVuSerif-Italic.ttf")))
def paper(c: canvas.Canvas, seed: int = 7, stains: int = 26) -> None:
"""Vergilbtes Papier mit Flecken und dunklerem Rand."""
w, h = A4
c.setFillColorRGB(*PAPER)
c.rect(0, 0, w, h, stroke=0, fill=1)
rnd = random.Random(seed)
for _ in range(stains):
x, y = rnd.uniform(0, w), rnd.uniform(0, h)
r = rnd.uniform(4, 34)
c.setFillColorRGB(0.62, 0.52, 0.34)
c.setFillAlpha(rnd.uniform(0.02, 0.06))
c.circle(x, y, r, stroke=0, fill=1)
c.setFillAlpha(0.10)
c.setFillColorRGB(0.45, 0.33, 0.18)
for i in range(9):
edge = i * 2.2 * mm
c.setLineWidth(3 * mm)
c.setStrokeAlpha(0.012)
c.rect(edge, edge, w - 2 * edge, h - 2 * edge, stroke=1, fill=0)
c.setFillAlpha(1)
c.setStrokeAlpha(1)
def cutmarks(c: canvas.Canvas, margin: float = 12 * mm) -> None:
"""Scheidehilfe: gestrichelter Rahmen."""
w, h = A4
c.saveState()
c.setStrokeColorRGB(*FADED)
c.setDash(3, 4)
c.setLineWidth(0.5)
c.rect(margin, margin, w - 2 * margin, h - 2 * margin, stroke=1, fill=0)
c.restoreState()
def footer(c: canvas.Canvas, text: str) -> None:
c.setFont("Sans", 6.5)
c.setFillColorRGB(*FADED)
c.drawCentredString(A4[0] / 2, 7 * mm, text)
c.setFillColorRGB(*INK)
def wrap(c: canvas.Canvas, text: str, width: float, font: str, size: float) -> list[str]:
words, lines, line = text.split(), [], ""
for word in words:
probe = f"{line} {word}".strip()
if pdfmetrics.stringWidth(probe, font, size) <= width:
line = probe
else:
lines.append(line)
line = word
if line:
lines.append(line)
return lines
# --------------------------------------------------------------------------- #
# 1 – Notiz „Das dritte Tor im Grünen"
# --------------------------------------------------------------------------- #
def torn_rect(c: canvas.Canvas, x: float, y: float, w: float, h: float,
seed: int = 3, jitter: float = 1.6) -> None:
"""Rechteck mit ausgefranstem Rand (gerissene Papierkante)."""
rnd = random.Random(seed)
punkte: list[tuple[float, float]] = []
schritte = 26
for i in range(schritte): # unten
punkte.append((x + w * i / schritte, y + rnd.uniform(-jitter, jitter) * mm))
for i in range(int(schritte * h / max(w, 1))): # rechts
punkte.append((x + w + rnd.uniform(-jitter, jitter) * mm, y + h * i / max(1, int(schritte * h / max(w, 1)))))
for i in range(schritte): # oben
punkte.append((x + w - w * i / schritte, y + h + rnd.uniform(-jitter, jitter) * mm))
for i in range(int(schritte * h / max(w, 1))): # links
punkte.append((x + rnd.uniform(-jitter, jitter) * mm, y + h - h * i / max(1, int(schritte * h / max(w, 1)))))
pfad = c.beginPath()
pfad.moveTo(*punkte[0])
for px, py in punkte[1:]:
pfad.lineTo(px, py)
pfad.close()
c.setFillColorRGB(0.978, 0.958, 0.910)
c.setStrokeColorRGB(0.78, 0.73, 0.61)
c.setLineWidth(0.5)
c.drawPath(pfad, stroke=1, fill=1)
def ink_line(c: canvas.Canvas, x1: float, y1: float, x2: float, y2: float,
width: float = 0.9, alpha: float = 0.75, seed: int = 0) -> None:
"""Handgezogene Tuschelinie (leicht zittrig)."""
rnd = random.Random(seed)
c.setStrokeColorRGB(0.17, 0.14, 0.11)
c.setStrokeAlpha(alpha)
c.setLineWidth(width)
c.setLineCap(1)
for i in range(3):
j = 0.35 * i
c.line(x1 + rnd.uniform(-j, j), y1 + rnd.uniform(-j, j),
x2 + rnd.uniform(-j, j), y2 + rnd.uniform(-j, j))
c.setStrokeAlpha(1)
def draw_key(c: canvas.Canvas, x: float, y: float, size: float = 1.0,
angle: float = -8) -> None:
"""Skizze eines ziselierten Schlüssels mit Halbedelsteinen."""
c.saveState()
c.translate(x, y)
c.rotate(angle)
c.scale(size, size)
# Ring (Reide)
c.setStrokeColorRGB(0.17, 0.14, 0.11)
c.setStrokeAlpha(0.8)
c.setLineWidth(1.4)
c.circle(0, 0, 11 * mm, stroke=1, fill=0)
c.setLineWidth(0.8)
c.circle(0, 0, 8.6 * mm, stroke=1, fill=0)
# Ziselierung im Ring
for winkel in range(0, 360, 30):
from math import cos, radians, sin
ink_line(c, 8.8 * mm * cos(radians(winkel)), 8.8 * mm * sin(radians(winkel)),
10.8 * mm * cos(radians(winkel)), 10.8 * mm * sin(radians(winkel)),
width=0.7, alpha=0.6, seed=winkel)
# Schaft (zwei Linien, damit er Körper hat)
ink_line(c, 10.5 * mm, 1.5 * mm, 66 * mm, 1.5 * mm, width=1.5, alpha=0.85, seed=11)
ink_line(c, 10.5 * mm, -1.5 * mm, 66 * mm, -1.5 * mm, width=1.5, alpha=0.85, seed=12)
ink_line(c, 10.5 * mm, 1.5 * mm, 10.5 * mm, -1.5 * mm, width=1.0, alpha=0.8, seed=13)
# Bart: Umriss mit zwei Zähnen
c.setStrokeColorRGB(0.17, 0.14, 0.11)
c.setStrokeAlpha(0.85)
c.setLineWidth(1.3)
c.setLineCap(0)
pfad = c.beginPath()
for i, (px, py) in enumerate(((46, -1.5), (46, -10), (52, -10), (52, -6.5),
(57, -6.5), (57, -13), (64, -13), (64, -1.5))):
if i == 0:
pfad.moveTo(px * mm, py * mm)
else:
pfad.lineTo(px * mm, py * mm)
c.drawPath(pfad, stroke=1, fill=0)
c.setStrokeAlpha(1)
# Halbedelsteine auf Ring, Schaft und Bart
for sx, sy, r in ((-7.3, 8.2, 1.7), (20, 1.5, 1.3), (35, 1.5, 1.1), (54.5, -9.7, 1.4)):
c.setFillColorRGB(0.30, 0.36, 0.40)
c.setFillAlpha(0.8)
c.circle(sx * mm, sy * mm, r * mm, stroke=0, fill=1)
c.setFillAlpha(1)
c.setStrokeColorRGB(0.17, 0.14, 0.11)
c.setStrokeAlpha(0.7)
c.setLineWidth(0.5)
c.circle(sx * mm, sy * mm, r * mm, stroke=1, fill=0)
c.setStrokeAlpha(1)
c.restoreState()
def handout_notiz(path: Path) -> None:
c = canvas.Canvas(str(path), pagesize=A4)
c.setTitle("Handout – Notiz: Das dritte Tor im Grünen")
paper(c, seed=13)
w, h = A4
note_w, note_h = 158 * mm, 112 * mm
x0 = (w - note_w) / 2
y0 = (h - note_h) / 2 - 8 * mm
c.saveState()
c.translate(x0 + note_w / 2, y0 + note_h / 2)
c.rotate(-2.4)
torn_rect(c, -note_w / 2, -note_h / 2, note_w, note_h, seed=5)
c.setFillColorRGB(*INK)
c.setFont("Hand", 27)
c.drawCentredString(0, 34 * mm, "Das dritte Tor im Grünen")
c.setFont("Hand", 20)
c.setFillColorRGB(*FADED)
c.drawCentredString(0, 24 * mm, "III.")
# Schlüsselskizze
draw_key(c, -4 * mm, -12 * mm, size=0.95, angle=-7)
# Kohle-/Rußfinger
c.setFillColorRGB(0.16, 0.13, 0.10)
for fx, fy, fr, fa in ((62, 44, 5.0, 0.16), (68, 38, 2.4, 0.20), (-64, -44, 4.2, 0.13)):
c.setFillAlpha(fa)
c.circle(fx * mm, fy * mm, fr * mm, stroke=0, fill=1)
c.setFillAlpha(1)
c.restoreState()
cutmarks(c)
footer(c, "Westreiche · Handout zur Höhlenbeute (Sitzung 013) · ausschneiden, falten, auf den Tisch legen")
c.showPage()
c.save()
# --------------------------------------------------------------------------- #
# 2 – Frachtbrief Nordtor
# --------------------------------------------------------------------------- #
def handout_frachtbrief(path: Path) -> None:
c = canvas.Canvas(str(path), pagesize=A4)
c.setTitle("Handout – Frachtbrief Nordtor")
paper(c, seed=31, stains=20)
w, h = A4
left, right = 18 * mm, w - 18 * mm
top = h - 24 * mm
c.setFillColorRGB(*INK)
c.setFont("Serif-Bold", 17)
c.drawString(left, top, "HAUS DER MÜNZE ZU GARANA")
c.setFont("Serif", 10.5)
c.setFillColorRGB(*FADED)
c.drawString(left, top - 6.5 * mm, "Fuhrregister · Ausfuhr über das Nordtor · Woche des Frostmonds")
c.setFillColorRGB(*INK)
c.setStrokeColorRGB(*INK)
c.setLineWidth(1.2)
c.line(left, top - 9.5 * mm, right, top - 9.5 * mm)
y = top - 18 * mm
c.setFont("Serif", 9)
c.drawString(left, y, "Fuhre Nr. 217")
c.drawString(left + 55 * mm, y, "Fuhrmann: H. Kemmerer")
c.drawString(left + 120 * mm, y, "Begleitzettel: keiner")
cols = {
"fuder": (left, 14 * mm),
"ware": (left + 16 * mm, 66 * mm),
"ziel": (left + 84 * mm, 48 * mm),
"anweisung": (left + 134 * mm, right - left - 134 * mm),
}
heads = (("fuder", "Fuhren"), ("ware", "Ware"), ("ziel", "Bestimmungsort"),
("anweisung", "Anweisung"))
rows = [
("14", "Alteisen, unsortiert (Ofenrohre, Besteck, Werkzeug, Türbänder)",
"Nordtor, weiter in die Nordmark", "nicht wiegen"),
("2", "Fässer Tran, gesalzen", "dito", "kühl halten"),
("1", "Kiste, versiegelt, ohne Zeichen", "dito", "nur bei Frost öffnen"),
("1", "Fass Pech, halb", "dito", "—"),
]
def zeile(werte: tuple[str, str, str, str], y: float, font: str = "Serif",
size: float = 8.5) -> float:
"""Eine Tabellenzeile mit Umbruch; liefert die neue y-Position."""
c.setFont(font, size)
spalten = []
for (schluessel, _), wert in zip(heads, werte):
x, breite = cols[schluessel]
spalten.append((x, wrap(c, wert, breite - 2 * mm, font, size) or [""]))
hoehe = max(len(zeilen) for _, zeilen in spalten)
for x, zeilen in spalten:
for i, text in enumerate(zeilen):
c.drawString(x, y - i * 4 * mm, text)
y -= hoehe * 4 * mm + 1.5 * mm
c.setStrokeColorRGB(*FADED)
c.setLineWidth(0.7)
c.line(left, y + 2.5 * mm, right, y + 2.5 * mm)
return y
y -= 8 * mm
c.setStrokeColorRGB(*FADED)
c.setLineWidth(0.7)
c.line(left, y + 3 * mm, right, y + 3 * mm)
c.setFont("Serif-Bold", 7.5)
for schluessel, head in heads:
c.drawString(cols[schluessel][0], y - 1 * mm, head.upper())
y -= 6 * mm
c.line(left, y + 3 * mm, right, y + 3 * mm)
for werte in rows:
y = zeile(werte, y)
y -= 10 * mm
c.setFillColorRGB(*INK)
c.setFont("Serif-Bold", 11)
c.drawString(left, y, "RÜCKFRACHT")
y -= 7 * mm
y = zeile(("3", "Silber (so geschrieben), in Tuch, kalt",
"Garana, Haus der Münze, Hinterhof",
"nicht wiegen · nicht auf den Wagenboden stellen"), y)
# Stempel
c.saveState()
c.translate(right - 26 * mm, y - 30 * mm)
c.rotate(9)
c.setStrokeColorRGB(*STAMP)
c.setLineWidth(1.6)
c.setStrokeAlpha(0.75)
c.circle(0, 0, 17 * mm, stroke=1, fill=0)
c.setFont("Serif-Bold", 7.5)
c.setFillColorRGB(*STAMP)
c.setFillAlpha(0.75)
c.drawCentredString(0, 5 * mm, "ZOLL NORDTOR")
c.drawCentredString(0, 0.5 * mm, "GEBÜHR BEZAHLT")
c.setFont("Serif", 6.5)
c.drawCentredString(0, -4 * mm, "ohne Nachschau")
c.restoreState()
# Unterschrift und Bemerkungen
c.setFillColorRGB(*INK)
c.setStrokeColorRGB(*FADED)
c.setLineWidth(0.4)
c.setFont("Sans", 7)
c.drawString(left, y - 22 * mm, "Bemerkungen des Fuhrmanns:")
for i in range(3):
c.line(left, y - (27 + i * 6) * mm, left + 100 * mm, y - (27 + i * 6) * mm)
c.line(right - 62 * mm, y - 22 * mm, right, y - 22 * mm)
c.setFont("Serif-Italic", 7)
c.drawString(right - 62 * mm, y - 25 * mm, "Zeichen des Hauses")
# handschriftliche Randnotiz
c.saveState()
c.setFillColorRGB(0.22, 0.18, 0.14)
c.setFillAlpha(0.85)
c.rotate(-1.6)
c.setFont("Hand", 17)
c.drawString(left + 6 * mm, h * 0.30, "Zweimal nachgewogen: zurück sind die Fuhren schwerer.")
c.setFont("Hand", 15)
c.drawString(left + 6 * mm, h * 0.30 - 9 * mm, "Es ist nicht dasselbe Metall. Es hat nur dieselbe Form.")
c.setFont("Hand", 14)
c.setFillColorRGB(*FADED)
c.drawString(left + 6 * mm, h * 0.30 - 17 * mm, "— Kemmerer, und ich melde das nicht noch einmal")
c.restoreState()
# Kleingedrucktes
c.setFont("Serif-Italic", 7.5)
c.setFillColorRGB(*FADED)
note = ("Zeichen des Hauses genügt. Wer die Fuhren öffnet, haftet mit eigenem Gut. "
"Befunde sind dem Haus schriftlich anzuzeigen, nicht der Wache.")
yy = 34 * mm
for zeile in wrap(c, note, right - left, "Serif-Italic", 7.5):
c.drawString(left, yy, zeile)
yy -= 4 * mm
c.setFillColorRGB(*INK)
cutmarks(c)
footer(c, "Westreiche · Handout Frachtbrief (Nordtor, Woche des Frostmonds)")
c.showPage()
c.save()
# --------------------------------------------------------------------------- #
# 3 – Verschlüsselte Tagebuchseite (echtes Schlüsselalphabet)
# --------------------------------------------------------------------------- #
def chiffre(text: str, keyword: str = "FERRUM") -> str:
"""Einfache Schlüsselalphabet-Chiffre; nur Buchstaben werden verschlüsselt."""
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
key = "".join(dict.fromkeys(keyword.upper() + alphabet))
table = str.maketrans(alphabet, key[:26])
return "".join(ch for ch in text.upper() if ch.isalpha()).translate(table)
KLARTEXT = (
"WER DAS LIEST IST ZU SPAET DIE DREI TORE LIEGEN DREI TAGESMAERSCHE SUEDLICH "
"VON GARANA HINTER DEM MOOR IM GRUENEN LAND BEI UNTERFELD "
"DAS ERSTE STEHT OFFEN UND MERKT SICH DEIN GESICHT "
"DAS ZWEITE OEFFNET DER GOLDENE SCHLUESSEL MIT DEN HALBEDELSTEINEN "
"ER LIEGT NOCH IN MEINEN BEUTELN IM SCHNEE "
"DAS DRITTE BRAUCHT DENSELBEN SCHLUESSEL UND EIN PASSWORT IN DRACHENSCHRIFT "
"NUR EINE DRACHENKEHLE SPRICHT ES AUS "
"GEH NIE ZUERST ZUM DRITTEN SONST WECKST DU DEN WAECHTER IM STEIN "
"HINTER DEM DRITTEN LIEGT DER HORT VON UNTERFELD "
"DAS MOOR IST NUR BEI HARTEM FROST ZU QUEREN ICH GEHE ALLEIN"
)
# Lesbare Fassung mit korrekter Groß-/Kleinschreibung (Übertragung, nicht Chiffretext)
KLARTEXT_LESBAR = (
"Wer das liest, ist zu spät.\n"
"Die drei Tore liegen drei Tagesmärsche südlich von Garana, hinter dem Moor, "
"im Grünen Land bei Unterfeld.\n"
"Das erste steht offen und merkt sich dein Gesicht.\n"
"Das zweite öffnet der goldene Schlüssel mit den Halbedelsteinen — er liegt noch "
"in meinen Beuteln im Schnee.\n"
"Das dritte braucht denselben Schlüssel und ein Passwort in Drachenschrift; "
"nur eine Drachenkehle spricht es aus.\n"
"Geh nie zuerst zum dritten, sonst weckst du den Wächter im Stein.\n"
"Hinter dem dritten liegt der Hort von Unterfeld.\n"
"Das Moor ist nur bei hartem Frost zu queren — im Tauwetter kommst du nicht durch.\n"
"Ich gehe allein."
)
def handout_tagebuch(path: Path) -> None:
c = canvas.Canvas(str(path), pagesize=A4)
c.setTitle("Handout – Tagebuchseite des Nekromanten (verschlüsselt)")
paper(c, seed=57, stains=34)
w, h = A4
left, right = 22 * mm, w - 22 * mm
top = h - 26 * mm
c.setFillColorRGB(*INK)
c.setFont("Serif-Bold", 12)
c.drawString(left, top, "Aus den Tagebuchseiten des Nekromanten")
c.setFont("Serif-Italic", 8.5)
c.setFillColorRGB(*FADED)
c.drawString(left, top - 6 * mm, "Magierschrift · Zifferngruppen zu fünf Buchstaben · Abschrift, nicht Original")
c.setFillColorRGB(*INK)
geheim = chiffre(KLARTEXT)
gruppen = [geheim[i:i + 5] for i in range(0, len(geheim), 5)]
y = top - 16 * mm
c.setFont("Mono", 10.5)
for i, gruppe in enumerate(gruppen):
col = i % 6
if col == 0 and i:
y -= 6.4 * mm
c.drawString(left + col * 27 * mm, y, gruppe)
# Notiz des Abschreibers
y -= 16 * mm
c.setFont("Serif-Italic", 8)
c.setFillColorRGB(*FADED)
for zeile in ("Am Rand der Seite drei Zeichen in anderer Tinte: ein Zahnrad, ein Rabe, ein Schlüssel. "
"Das letzte Fünferglied ist durchgestrichen und darunter zweimal nachgeschrieben.").split(". "):
c.drawString(left, y, zeile.strip() + ".")
y -= 4.2 * mm
c.setFillColorRGB(*INK)
# Leerzeilen zum Mitschreiben
y -= 4 * mm
c.setFont("Sans", 7.5)
c.drawString(left, y, "Platz für die Lösung:")
c.setStrokeColorRGB(*FADED)
c.setLineWidth(0.4)
for _ in range(16):
y -= 6.5 * mm
c.line(left, y, right, y)
cutmarks(c)
footer(c, "Westreiche · Handout Tagebuchseite (Abschrift, nicht Original)")
c.showPage()
c.save()
def handout_tagebuch_uebersetzt(path: Path) -> None:
"""Übertragene Fassung der Tagebuchseite – SL-Version, nicht für Spieler."""
c = canvas.Canvas(str(path), pagesize=A4)
c.setTitle("Handout – Tagebuchseite, übertragen (SL)")
paper(c, seed=71, stains=14)
w, h = A4
left, right = 20 * mm, w - 20 * mm
top = h - 22 * mm
c.setFillColorRGB(*INK)
c.setFont("Serif-Bold", 14)
c.drawString(left, top, "Tagebuchseiten des Nekromanten – Übertragung")
c.setFont("Serif-Italic", 8.5)
c.setFillColorRGB(*FADED)
c.drawString(left, top - 6 * mm,
"Lösung des Handouts „Tagebuchseite verschlüsselt“ · Schlüsselalphabet mit dem Schlüsselwort FERRUM · SL-Version")
c.setFillColorRGB(*INK)
# Alphabet-Tabelle
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
schluessel = "".join(dict.fromkeys("FERRUM" + alphabet))
y = top - 16 * mm
c.setFont("Mono-Bold", 7.5)
c.drawString(left, y, "Klartext:")
c.setFont("Mono", 7.5)
c.drawString(left + 22 * mm, y, " ".join(alphabet))
c.setFont("Mono-Bold", 7.5)
c.drawString(left, y - 4.5 * mm, "Chiffre:")
c.setFont("Mono", 7.5)
c.drawString(left + 22 * mm, y - 4.5 * mm, " ".join(schluessel))
# Übertragener Text
y -= 16 * mm
c.setFont("Serif-Bold", 9)
c.drawString(left, y, "Übertragung")
y -= 7 * mm
c.setFont("Serif", 11)
for absatz in KLARTEXT_LESBAR.split("\n"):
for zeile in wrap(c, absatz, right - left, "Serif", 11):
c.drawString(left, y, zeile)
y -= 6 * mm
y -= 1.5 * mm
# Anmerkungen
y -= 6 * mm
c.setStrokeColorRGB(*FADED)
c.setLineWidth(0.5)
c.line(left, y + 2 * mm, right, y + 2 * mm)
c.setFont("Serif-Italic", 8.5)
c.setFillColorRGB(*FADED)
anmerkungen = (
"Anmerkungen für den SL: Einstieg beim Knacken ist der Anfang „WER DAS LIEST …“ (Crib); "
"häufigster Geheimtextbuchstabe ist E, im Deutschen also M. Wer das Schlüsselwort FERRUM errät, "
"hat das Alphabet in einer Minute. Inhaltlich liefert das Blatt vier Handlungsschritte: Ort (drei "
"Tagesmärsche südlich von Garana, hinter dem Moor bei Unterfeld), Reihenfolge (nie das dritte "
"zuerst), Werkzeug (der goldene Schlüssel in ihren eigenen Beuteln) und Zeitfenster (das Moor ist "
"nur bei hartem Frost zu queren – das Fenster ist der Winter, nicht das Frühjahr). NEU und noch in "
"keiner Weltdatei: Unterfeld als Lage der Tore, die Frost-Querung des Moors und Alodans Alleingang."
)
yy = y - 4 * mm
for zeile in wrap(c, anmerkungen, right - left, "Serif-Italic", 8.5):
c.drawString(left, yy, zeile)
yy -= 4.4 * mm
c.setFillColorRGB(*INK)
cutmarks(c)
footer(c, "Westreiche · SL-Version der Tagebuchseite · enthält die Lösung, nicht an Spieler aushändigen")
c.showPage()
c.save()
def main() -> None:
parser = argparse.ArgumentParser(description="Druckfertige Spieler-Handouts erzeugen.")
parser.add_argument(
"--out",
type=Path,
default=Path("RPG/7-Prep/prep_2026-11-20/Handouts"),
help="Zielordner (Standard: RPG/7-Prep/prep_2026-11-20/Handouts)",
)
args = parser.parse_args()
out = args.out
out.mkdir(parents=True, exist_ok=True)
register_fonts()
ziele = [
(out / "Handout - Notiz Das dritte Tor im Gruenen.pdf", handout_notiz),
(out / "Handout - Frachtbrief Nordtor.pdf", handout_frachtbrief),
(out / "Handout - Tagebuchseite verschluesselt.pdf", handout_tagebuch),
(out / "Handout - Tagebuchseite uebersetzt (SL).pdf", handout_tagebuch_uebersetzt),
]
for ziel, bauer in ziele:
bauer(ziel)
print(ziel)
if __name__ == "__main__":
main()