@jjlmoya/utils-tabletop 1.24.0 → 1.26.0

package/src/tool/encounter-difficulty-calculator/dnd-5e-encounter-difficulty-calculator.css

@@ -0,0 +1,389 @@
+.encounter-calculator {
+  --n-ink: #18212b;
+  --n-muted: #5b6875;
+  --n-paper: #f7f4ed;
+  --n-card: #fff;
+  --n-line: #d9d5cb;
+  --n-accent: #bf542f;
+  --n-accent-soft: #f2d1c5;
+  --n-safe: #5e8b68;
+  --n-medium: #c18b3c;
+  --n-hard: #b8643d;
+  --n-deadly: #853e42;
+  --n-shadow: #d5cec2;
+
+  color: var(--n-ink);
+  background: var(--n-paper);
+  border: 1px solid var(--n-line);
+  border-radius: 1.75rem;
+  padding: clamp(1rem, 3vw, 2rem);
+  box-shadow: 0 1rem 0 var(--n-shadow);
+}
+
+.theme-dark .encounter-calculator {
+  --n-ink: #f7f4ed;
+  --n-muted: #b5bdc4;
+  --n-paper: #1d252d;
+  --n-card: #26313b;
+  --n-line: #44515b;
+  --n-accent: #ee8661;
+  --n-accent-soft: #633d36;
+  --n-safe: #8cb596;
+  --n-medium: #dfb265;
+  --n-hard: #e18b63;
+  --n-deadly: #dc7a7d;
+  --n-shadow: #11171c;
+}
+
+.encounter-intro,
+.rules-note {
+  color: var(--n-muted);
+  line-height: 1.6;
+}
+
+.encounter-presets {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: .5rem;
+  margin: 1.25rem 0;
+  font-size: .8rem;
+  font-weight: 700;
+}
+
+.encounter-presets span {
+  color: var(--n-muted);
+  margin-right: .25rem;
+}
+
+.encounter-presets button,
+.cr-chip,
+.reset-button {
+  color: var(--n-ink);
+  background: var(--n-card);
+  border: 1px solid var(--n-line);
+  border-radius: 999px;
+  padding: .55rem .75rem;
+  cursor: pointer;
+  font: inherit;
+}
+
+.encounter-presets button:hover,
+.cr-chip:hover,
+.reset-button:hover,
+.cr-chip.is-active {
+  color: var(--n-card);
+  background: var(--n-accent);
+  border-color: var(--n-accent);
+}
+
+.encounter-layout {
+  display: grid;
+  grid-template-columns: minmax(16rem, .75fr) minmax(20rem, 1.25fr);
+  gap: 1rem;
+}
+
+.encounter-controls,
+.encounter-result {
+  background: var(--n-card);
+  border: 1px solid var(--n-line);
+  border-radius: 1.25rem;
+  padding: 1.25rem;
+}
+
+.encounter-result {
+  align-self: start;
+}
+
+.control-group + .control-group {
+  border-top: 1px solid var(--n-line);
+  margin-top: 1.25rem;
+  padding-top: 1.25rem;
+}
+
+.group-heading,
+.orbit-labels,
+.result-head,
+.result-stats,
+.encounter-controls label {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: .75rem;
+}
+
+.group-heading {
+  font-size: .75rem;
+  letter-spacing: .12em;
+  text-transform: uppercase;
+  font-weight: 800;
+  margin-bottom: 1rem;
+}
+
+.eyebrow,
+.result-kicker {
+  color: var(--n-accent);
+  font-size: .65rem;
+  letter-spacing: .1em;
+  text-transform: uppercase;
+}
+
+.encounter-controls label {
+  margin-top: .95rem;
+  font-size: .9rem;
+  font-weight: 750;
+}
+
+.encounter-controls output {
+  min-width: 2.5rem;
+  color: var(--n-accent);
+  font-size: 1.15rem;
+  text-align: right;
+}
+
+.encounter-controls input[type='range'] {
+  accent-color: var(--n-accent);
+  width: 100%;
+  margin: .7rem 0 .25rem;
+}
+
+.encounter-controls small {
+  display: block;
+  color: var(--n-muted);
+  font-size: .75rem;
+  line-height: 1.45;
+}
+
+.cr-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: .4rem;
+  margin: .75rem 0 .35rem;
+}
+
+.cr-chip {
+  padding: .4rem .55rem;
+  font-size: .78rem;
+}
+
+.cr-chip[data-advanced='true'] {
+  display: none;
+}
+
+.cr-list.is-expanded .cr-chip[data-advanced='true'] {
+  display: inline-block;
+}
+
+.cr-more-button {
+  border: 0;
+  padding: .25rem 0;
+  color: var(--n-accent);
+  background: transparent;
+  cursor: pointer;
+  font: inherit;
+  font-size: .72rem;
+  font-weight: 800;
+}
+
+.reset-button {
+  margin-top: 1.25rem;
+  color: var(--n-muted);
+  font-size: .8rem;
+}
+
+.result-orbit {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.orbit-labels {
+  color: var(--n-muted);
+  font-size: .72rem;
+  font-weight: 800;
+  letter-spacing: .1em;
+  text-transform: uppercase;
+}
+
+.orbit-scene {
+  position: relative;
+  height: 11rem;
+  overflow: hidden;
+  border: 1px solid var(--n-line);
+  border-radius: 1rem;
+  background: var(--n-paper);
+}
+
+.orbit-line {
+  position: absolute;
+  top: 50%;
+  left: 12%;
+  right: 12%;
+  border-top: 2px solid var(--n-line);
+  transform: scaleX(var(--threat-scale));
+  transform-origin: center;
+}
+
+.party-orbit,
+.threat-orbit {
+  position: absolute;
+  top: 50%;
+  display: flex;
+  gap: .4rem;
+}
+
+.party-orbit {
+  left: 10%;
+  transform: translateY(-50%);
+}
+
+.threat-orbit {
+  right: 10%;
+  opacity: var(--threat-opacity);
+  transform: translateY(-50%) scale(var(--threat-scale));
+  transform-origin: right center;
+}
+
+.party-orbit i,
+.threat-orbit b {
+  display: block;
+  width: 1rem;
+  height: 1rem;
+  border-radius: 50%;
+  background: var(--n-safe);
+  box-shadow: 0 0 0 .35rem var(--n-card), 0 0 0 .45rem var(--n-safe);
+}
+
+.party-marker,
+.threat-marker {
+  position: relative;
+}
+
+.threat-orbit b {
+  background: var(--n-deadly);
+  box-shadow: 0 0 0 .35rem var(--n-card), 0 0 0 .45rem var(--n-deadly);
+}
+
+.result-head {
+  align-items: flex-end;
+}
+
+.result-head strong {
+  color: var(--n-accent);
+  font-size: clamp(1.5rem, 4vw, 2.4rem);
+}
+
+.result-head small {
+  color: var(--n-muted);
+  font-size: .8rem;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
+.result-hint {
+  margin: -.5rem 0 0;
+  color: var(--n-muted);
+  font-size: .78rem;
+  line-height: 1.45;
+}
+
+.threshold-track {
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+  gap: .35rem;
+}
+
+.threshold-band {
+  min-height: 4.1rem;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  padding: .55rem;
+  border-top: .25rem solid var(--n-line);
+  color: var(--n-muted);
+  font-size: .68rem;
+}
+
+.threshold-band strong {
+  color: var(--n-ink);
+  font-size: .72rem;
+}
+
+.threshold-band.easy {
+  border-color: var(--n-safe);
+}
+
+.threshold-band.medium {
+  border-color: var(--n-medium);
+}
+
+.threshold-band.hard {
+  border-color: var(--n-hard);
+}
+
+.threshold-band.deadly {
+  border-color: var(--n-deadly);
+}
+
+.threshold-band.is-active {
+  background: var(--n-accent-soft);
+  color: var(--n-ink);
+}
+
+.result-stats {
+  border-top: 1px solid var(--n-line);
+  padding-top: 1rem;
+}
+
+.result-stats span {
+  display: flex;
+  flex-direction: column;
+  gap: .25rem;
+}
+
+.result-stats small {
+  color: var(--n-muted);
+  font-size: .7rem;
+}
+
+.result-stats strong {
+  font-size: .9rem;
+}
+
+.encounter-warning {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: .7rem;
+  border-left: .25rem solid var(--n-medium);
+  padding: .7rem .8rem;
+  color: var(--n-ink);
+  background: var(--n-paper);
+}
+
+.encounter-warning span {
+  color: var(--n-medium);
+  font-weight: 800;
+  font-size: .75rem;
+}
+
+.encounter-warning p {
+  margin: 0;
+  color: var(--n-muted);
+  font-size: .78rem;
+  line-height: 1.45;
+}
+
+.rules-note {
+  margin: 1.25rem 0 0;
+  font-size: .75rem;
+}
+
+.rules-note a {
+  color: var(--n-accent);
+}
+
+@media (max-width: 760px) {
+  .encounter-layout { grid-template-columns: 1fr; }
+  .threshold-track { grid-template-columns: repeat(2, 1fr); }
+  .threshold-band:last-child { grid-column: span 2; }
+}

package/src/tool/encounter-difficulty-calculator/dom-views.ts

@@ -0,0 +1,54 @@
+import type { EncounterDifficulty, EncounterResult } from './logic';
+import { evaluateEncounter } from './evaluator';
+
+type Labels = Record<string, string>;
+
+function formatNumber(value: number): string {
+  return new Intl.NumberFormat('en-US').format(value);
+}
+
+function labelForDifficulty(key: EncounterDifficulty, labels: Labels): string {
+  return labels[key] ?? key;
+}
+
+function renderMarkers(count: number, className: string, element: string): string {
+  return Array.from({ length: count }, () => '<' + element + ' class="' + className + '"></' + element + '>').join('');
+}
+
+function renderHint(result: EncounterResult, labels: Labels): string {
+  return labels[result.difficulty + 'Hint'] ?? '';
+}
+
+function renderWarnings(result: EncounterResult, labels: Labels): string {
+  const warningText = result.warnings.map((key) => labels[key] ?? '').filter(Boolean);
+  if (warningText.length === 0) return '';
+  return '<div class="encounter-warning"><span>' + labels.warning + '</span><p>' + warningText.join(' ') + '</p></div>';
+}
+
+function renderThresholds(result: EncounterResult, labels: Labels): string {
+  const bands: EncounterDifficulty[] = ['belowEasy', 'easy', 'medium', 'hard', 'deadly'];
+  return bands.map((key) => {
+    const value = key === 'belowEasy' ? 0 : result.thresholds[key];
+    const active = key === result.difficulty ? ' is-active' : '';
+    const amount = value ? formatNumber(value) + ' XP' : '<' + formatNumber(result.thresholds.easy) + ' XP';
+    return '<div class="threshold-band ' + key + active + '"><span>' + labelForDifficulty(key, labels) + '</span><strong>' + amount + '</strong></div>';
+  }).join('');
+}
+
+export function renderResult(result: EncounterResult, labels: Labels): string {
+  const evaluation = evaluateEncounter(result);
+  const title = labelForDifficulty(evaluation.titleKey, labels);
+  const scale = Math.min(1.2, Math.max(0.7, 0.7 + evaluation.ratio * 0.5));
+  const opacity = Math.min(1, 0.8 + evaluation.ratio * 0.2);
+  const style = '--threat-scale:' + scale.toFixed(2) + ';--threat-opacity:' + opacity.toFixed(2);
+  return '<div class="result-orbit" data-difficulty="' + result.difficulty + '">'
+    + '<div class="orbit-labels"><span>' + labels.partyMarker + '</span><span>' + labels.threatMarker + '</span></div>'
+    + '<div class="orbit-scene" style="' + style + '">'
+    + '<div class="party-orbit">' + renderMarkers(result.settings.partySize, 'party-marker', 'i') + '</div>'
+    + '<div class="threat-orbit">' + renderMarkers(result.settings.monsterCount, 'threat-marker', 'b') + '</div><div class="orbit-line"></div></div>'
+    + '<div class="result-head"><span class="result-kicker">' + labels.resultSection + '</span><strong>' + title + '</strong><small>' + formatNumber(result.adjustedXp) + ' ' + labels.xpUnit + '</small></div>'
+    + '<p class="result-hint">' + renderHint(result, labels) + '</p>'
+    + '<div class="threshold-track">' + renderThresholds(result, labels) + '</div>'
+    + '<div class="result-stats"><span><small>' + labels.baseXp + '</small><strong>' + formatNumber(result.baseXp) + ' ' + labels.xpUnit + '</strong></span><span><small>' + labels.multiplier + '</small><strong>×' + result.multiplier + '</strong></span><span><small>' + labels.partyThreshold + '</small><strong>' + formatNumber(result.thresholds.medium) + ' ' + labels.xpUnit + '</strong></span></div>'
+    + renderWarnings(result, labels) + '</div>';
+}

package/src/tool/encounter-difficulty-calculator/entry.ts

@@ -0,0 +1,27 @@
+import type { TabletopToolEntry, ToolLocaleContent } from '../../types';
+import type { EncounterDifficultyUI } from './ui';
+
+export type { EncounterDifficultyUI } from './ui';
+export type EncounterDifficultyLocaleContent = ToolLocaleContent<EncounterDifficultyUI>;
+
+export const encounterDifficultyCalculator: TabletopToolEntry<EncounterDifficultyUI> = {
+  id: 'encounter-difficulty-calculator',
+  icons: { bg: 'mdi:sword-cross', fg: 'mdi:scale-balance' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/encounter-difficulty-calculator/evaluator.ts

@@ -0,0 +1,12 @@
+import type { EncounterDifficulty, EncounterResult } from './logic';
+
+export interface EncounterEvaluation {
+  titleKey: EncounterDifficulty;
+  ratio: number;
+  warningKeys: string[];
+}
+
+export function evaluateEncounter(result: EncounterResult): EncounterEvaluation {
+  const ratio = result.thresholds.deadly === 0 ? 1 : result.adjustedXp / result.thresholds.deadly;
+  return { titleKey: result.difficulty, ratio: Math.min(ratio, 1.35), warningKeys: result.warnings };
+}

package/src/tool/encounter-difficulty-calculator/i18n/de.ts

@@ -0,0 +1,155 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { EncounterDifficultyLocaleContent, EncounterDifficultyUI } from '../entry';
+
+const ui: EncounterDifficultyUI = {
+  intro: 'Stellen Sie Gruppe und Bedrohung ein. Der Rechner gleicht die Begegnung mit den D&D 5e 2014 Schwellenwerten ab.',
+  partySection: 'Die Gruppe',
+  partyLevel: 'Charakterstufe',
+  partyLevelHint: 'Verwenden Sie eine Stufe für Gruppen mit ähnlicher Charakterstufe.',
+  partySize: 'Charaktere',
+  partySizeHint: 'Die Regeln passen den Monster-Multiplikator für sehr kleine oder große Gruppen an.',
+  threatSection: 'Die Bedrohung',
+  monsterCr: 'Herausforderungsgrad (CR)',
+  monsterCrHint: 'Wählen Sie den CR eines Monsters. Gemischte Gruppen erfordern eine eigene Berechnung.',
+  moreCr: 'Höhere CR anzeigen',
+  lessCr: 'Weniger CR anzeigen',
+  monsterCount: 'Anzahl der Monster',
+  monsterCountHint: 'Mehr Kreaturen erhöhen den Aktionsdruck selbst bei moderater Basis-XP.',
+  presets: 'Mit einer Szene starten',
+  presetClassic: 'Klassische Patrouille',
+  presetBoss: 'Boss alleine',
+  presetSwarm: 'Horde von Dienern',
+  resultSection: 'Begegnungsdruck',
+  belowEasyHint: 'Eine leichte Szene zur Ressourcenschonung für spätere Herausforderungen.',
+  easyHint: 'Eine überschaubare Szene mit geringem Druck auf die Gruppe.',
+  mediumHint: 'Eine spürbare Prüfung, die Trefferpunkte oder Ressourcen kosten kann.',
+  hardHint: 'Eine gefährliche Szene, in der Taktik und Ressourcenwahl entscheiden.',
+  deadlyHint: 'Signal für tödlichen Druck. Prüfen Sie Fluchtwege, Gelände und Fehlerkosten.',
+  adjustedXp: 'Angepasste XP',
+  baseXp: 'Basis-XP',
+  multiplier: 'Gruppen-Multiplikator',
+  partyThreshold: 'Mittlere Schwelle',
+  belowEasy: 'Unter Leicht',
+  easy: 'Leicht',
+  medium: 'Mittel',
+  hard: 'Schwer',
+  deadly: 'Tödlich',
+  warning: 'Hinweis',
+  partyAdjustment: 'Der Multiplikator wurde angepasst, da die Gruppe weniger als drei oder mehr als fünf Charaktere umfasst.',
+  highCr: 'Ein Monster mit höherem CR als die Gruppenstufe kann Charaktere schnell zu Boden werfen.',
+  manyMonsters: 'Elf oder mehr Monster erschweren die Kampfverwaltung und erzeugen starke Aktionsschwankungen.',
+  rulesNote: 'Schätzung nach D&D 5e 2014 Regeln. Gelände, Taktik, Zauber und magische Gegenstände werden nicht berücksichtigt.',
+  rulesLinkLabel: 'Quellregeln lesen',
+  reset: 'Auf Beispiel zurücksetzen',
+  xpUnit: 'XP',
+  sceneLabel: 'Grafische Begegnungsdruck-Anzeige',
+  partyMarker: 'Gruppe',
+  threatMarker: 'Bedrohung',
+};
+
+const faq = [
+  {
+    question: 'Welche Regeln nutzt dieser Begegnungsrechner?',
+    answer: 'Er nutzt die D&D 5e 2014 Regeln aus den Grundregeln. Er addiert die Gruppenschwellen für leicht, mittel, schwer und tödlich und vergleicht sie mit den angepassten XP.',
+  },
+  {
+    question: 'Warum unterscheidet sich die angepasste XP von der Belohnungs-XP?',
+    answer: 'Die Regeln multiplizieren die Gesamt-XP der Monster, um die Gefahr mehrerer agierender Kreaturen abzubilden. Angepasste XP dienen nur dem Schwierigkeitsvergleich.',
+  },
+  {
+    question: 'Kann ich gemischte Monstergruppen berechnen?',
+    answer: 'Nutzen Sie das Tool als schnelle Schätzung für gleiche Monster. Für gemischte Gruppen addieren Sie die XP aller Kreaturen und wenden den Multiplikator an.',
+  },
+  {
+    question: 'Bedeutet ein tödliches Ergebnis den sicheren Tod?',
+    answer: 'Nein. Tödlich bedeutet, dass die angepasste XP die tödliche Schwelle erreicht. Taktik, Gelände, Zauber und Entscheidungen verändern das reale Ergebnis.',
+  },
+  {
+    question: 'Warum ändert die Gruppengröße den Multiplikator?',
+    answer: 'Die Grundregeln empfehlen eine Erhöhung des Multiplikators für Gruppen unter drei Charakteren und eine Verringerung für Gruppen ab sechs Charakteren.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Gruppenstufe festlegen',
+    text: 'Wählen Sie die durchschnittliche Stufe der Charaktere.',
+  },
+  {
+    name: 'Gruppengröße wählen',
+    text: 'Geben Sie die Anzahl der teilnehmenden Charaktere ein.',
+  },
+  {
+    name: 'Bedrohung beschreiben',
+    text: 'Wählen Sie den Herausforderungsgrad (CR) und die Anzahl der Monster.',
+  },
+  {
+    name: 'Druck ablesen',
+    text: 'Vergleichen Sie die angepassten XP mit den Schwellenwerten.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'D&D 5e Begegnungs-Schwierigkeitsrechner',
+  operatingSystem: 'All',
+  applicationCategory: 'GameApplication',
+  description: 'Berechnen Sie die Begegnungsschwierigkeit für D&D 5e 2014 basierend auf Stufe, Gruppengröße, Monster-CR, Anzahl und offiziellen Schwellenwerten.',
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Wie man die D&D 5e Begegnungsschwierigkeit berechnet',
+  step: howTo.map((item) => ({
+    '@type': 'HowToStep',
+    name: item.name,
+    text: item.text,
+  })),
+};
+
+export const content: EncounterDifficultyLocaleContent = {
+  slug: 'dnd-5e-begegnungs-schwierigkeitsrechner',
+  title: 'D&D 5e Begegnungs Schwierigkeitsrechner',
+  description: 'Schätzen Sie den Begegnungsdruck für D&D 5e 2014 mit Stufe, Gruppengröße, Monster-CR, Anzahl, angepassten XP und Schwellenwerten.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Begegnungsschwierigkeit vor der Initiative einschätzen', level: 2 },
+    { type: 'paragraph', html: 'Ein D&D-Kampf ist mehr als nur die gedruckte Zahl eines Monsters. Dieser Rechner wandelt Gruppengröße, Stufe, CR und Monsteranzahl in die angepassten XP nach den D&D 5e 2014 Regeln um. Das visuelle Ergebnis zeigt übersichtlich, wo die geplante Szene im Vergleich zu den Schwellenwerten für leicht, mittel, schwer und tödlich liegt.' },
+    { type: 'title', text: 'Wie die D&D 5e Begegnungsformel funktioniert', level: 2 },
+    { type: 'paragraph', html: 'Die Methode addiert die XP-Schwellenwerte jedes Charakters für jede Schwierigkeitsstufe, summiert die Monster-XP und wendet den Gruppenmultiplikator an. Gruppen mit weniger als drei Charakteren nutzen den nächsthöheren Multiplikator, während Gruppen ab sechs Charakteren den nächstniedrigeren Multiplikator verwenden.' },
+    {
+      type: 'table',
+      headers: ['Signal', 'Bedeutung am Spieltisch'],
+      rows: [
+        ['Unter Leicht', 'Die Szene dient als Aufwärmung oder zum leichten Ressourcenverbrauch.'],
+        ['Leicht', 'Die Gruppe gewinnt in der Regel ohne großen Ressourceneinsatz.'],
+        ['Mittel', 'Erwarten Sie spürbaren Druck und Entscheidungen über Ressourceneinsatz.'],
+        ['Schwer', 'Planen Sie den Verlust von Trefferpunkten und Zauberslots ein.'],
+        ['Tödlich', 'Prüfen Sie Taktik, Gelände und die Folgen schlechter Würfe.'],
+      ],
+    },
+    { type: 'title', text: 'Warum die Monsteranzahl entscheidend ist', level: 2 },
+    { type: 'paragraph', html: 'Mehrere Monster erzeugen durch mehr Aktionen und Reaktionen höhere Gefahr als ein einzelnes Monster mit gleichen Gesamt-XP. Deshalb nutzt ein Paar von Kreaturen einen höheren Multiplikator als eine einzelne Kreatur mit derselben kombinierten XP-Zahl.' },
+    { type: 'tip', title: 'Hohen CR als spezifisches Warnsignal betrachten', html: 'Ein Monster mit höherem CR als die Gruppenstufe kann Charaktere mit einem Angriff ausschalten. Prüfen Sie Schaden und Effekte genau.' },
+    { type: 'title', text: 'Das Ergebnis als Vorbereitungshilfe nutzen', level: 2 },
+    { type: 'paragraph', html: 'Prüfen Sie vor schweren oder tödlichen Begegnungen Raumgröße, Deckung und Zauberoptionen der Charaktere. Enge Räume, Überraschung, Umgebungsschaden und Erschöpfung können die tatsächliche Gefahr am Spieltisch erheblich verändern.' },
+    { type: 'tip', title: 'Gemischte Gruppen manuell anpassen', html: 'Addieren Sie für gemischte Gruppen die Basis-XP aller Kreaturen und wenden Sie den Multiplikator auf die Gesamtzahl an.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
+};