@jjlmoya/utils-tabletop 1.25.0 → 1.26.0

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>[],
+};

package/src/tool/encounter-difficulty-calculator/i18n/en.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: 'Set the party and the threat. The calculator weighs the encounter against the D&D 5e 2014 thresholds so you can spot the pressure before initiative starts.',
+  partySection: 'The party',
+  partyLevel: 'Character level',
+  partyLevelHint: 'Use one level for a party with characters of similar level.',
+  partySize: 'Characters',
+  partySizeHint: 'The rules adjust the monster multiplier for very small or large groups.',
+  threatSection: 'The threat',
+  monsterCr: 'Monster challenge rating',
+  monsterCrHint: 'Choose the CR of one repeated monster. Mixed groups need a separate calculation.',
+  moreCr: 'Show higher CR',
+  lessCr: 'Show fewer CR values',
+  monsterCount: 'Number of monsters',
+  monsterCountHint: 'More creatures increase the action pressure even when their total XP is modest.',
+  presets: 'Start with a scene',
+  presetClassic: 'Classic patrol',
+  presetBoss: 'Boss alone',
+  presetSwarm: 'Crowd of minions',
+  resultSection: 'Encounter pressure',
+  belowEasyHint: 'A light scene that may preserve resources for what comes next.',
+  easyHint: 'A manageable scene with limited pressure on the party.',
+  mediumHint: 'A meaningful test that may cost hit points or useful resources.',
+  hardHint: 'A dangerous scene where tactics and resource choices matter.',
+  deadlyHint: 'A lethal pressure signal. Check escape routes, terrain, and the cost of one bad round.',
+  adjustedXp: 'Adjusted XP',
+  baseXp: 'Base XP',
+  multiplier: 'Group multiplier',
+  partyThreshold: 'Medium threshold',
+  belowEasy: 'Below easy',
+  easy: 'Easy',
+  medium: 'Medium',
+  hard: 'Hard',
+  deadly: 'Deadly',
+  warning: 'Read this',
+  partyAdjustment: 'The monster multiplier has been adjusted because the party has fewer than three or more than five characters.',
+  highCr: 'A monster with a CR above the party level can drop a character quickly. Treat this label as a danger signal, not a prediction.',
+  manyMonsters: 'Eleven or more monsters can make a fight much harder to run and can create swingy action economy.',
+  rulesNote: 'This is an estimate for the D&D 5e 2014 encounter method. It does not account for terrain, tactics, spells, magic items, or player experience.',
+  rulesLinkLabel: 'Read the source rules',
+  reset: 'Reset to the sample',
+  xpUnit: 'XP',
+  sceneLabel: 'Encounter pressure visual',
+  partyMarker: 'Party',
+  threatMarker: 'Threat',
+};
+
+const faq = [
+  {
+    question: 'What rules does this encounter difficulty calculator use?',
+    answer: 'It uses the D&D 5e 2014 method from the Basic Rules. It adds the party thresholds for easy, medium, hard, and deadly encounters, then compares them with the adjusted XP of the monsters.',
+  },
+  {
+    question: 'Why is adjusted XP different from the XP awarded by a monster?',
+    answer: 'The rules multiply the total monster XP to reflect the danger of several creatures acting in the same round. Adjusted XP is a comparison value for encounter difficulty, not the XP characters receive.',
+  },
+  {
+    question: 'Can I use this for a mixed group of monsters?',
+    answer: 'Use it as a quick estimate for repeated monsters. For a mixed group, add the XP of each creature and apply the multiplier to the total number of meaningful monsters. The calculator keeps one CR visible so the input stays fast and easy to read.',
+  },
+  {
+    question: 'Does a deadly result mean the party will die?',
+    answer: 'No. Deadly means the adjusted XP reaches the deadly threshold in this rules method. Terrain, tactics, rests, spells, magic items, monster abilities, and player decisions can change the actual result.',
+  },
+  {
+    question: 'Why does party size change the multiplier?',
+    answer: 'The Basic Rules recommend increasing the multiplier for parties of fewer than three characters and decreasing it for parties of six or more. This accounts for the different action economy of unusually small or large groups.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Set the party level',
+    text: 'Choose the level shared by most characters in the party. If levels vary widely, treat the result as a starting point and check the lowest level separately.',
+  },
+  {
+    name: 'Set the group size',
+    text: 'Choose the number of characters who will enter the encounter. Small and large parties receive a multiplier adjustment.',
+  },
+  {
+    name: 'Describe the threat',
+    text: 'Choose one monster challenge rating and the number of meaningful monsters. Use the scene presets when you want a fast baseline.',
+  },
+  {
+    name: 'Read the pressure',
+    text: 'Compare adjusted XP with the threshold bands. Use warnings as prompts to inspect high CR, action economy, terrain, and the resources available before the fight.',
+  },
+];
+
+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 Encounter Difficulty Calculator',
+  operatingSystem: 'All',
+  applicationCategory: 'GameApplication',
+  description: 'Estimate encounter difficulty for a D&D 5e 2014 party using character level, party size, monster challenge rating, monster count, XP, and official threshold bands.',
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'How to estimate D&D 5e encounter difficulty',
+  step: howTo.map((item) => ({
+    '@type': 'HowToStep',
+    name: item.name,
+    text: item.text,
+  })),
+};
+
+export const content: EncounterDifficultyLocaleContent = {
+  slug: 'dnd-5e-encounter-difficulty-calculator',
+  title: 'D&D 5e Encounter Difficulty Calculator',
+  description: 'Estimate encounter pressure for D&D 5e 2014 using party level, group size, monster CR, monster count, adjusted XP, and official difficulty thresholds.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Read Encounter Difficulty Before Initiative Starts', level: 2 },
+    { type: 'paragraph', html: 'A D&D encounter is more than the number printed beside a monster. This calculator turns party size, character level, challenge rating, and monster count into the adjusted XP value used by the D&D 5e 2014 encounter method. The visual result shows where the scene sits against the easy, medium, hard, and deadly thresholds.' },
+    { type: 'title', text: 'How the D&D 5e Encounter Formula Works', level: 2 },
+    { type: 'paragraph', html: 'The method first adds one XP threshold for every character at each difficulty band. It then adds the XP values of the monsters and applies a multiplier based on the number of meaningful creatures. Parties with fewer than three characters use the next higher multiplier, while parties of six or more use the next lower multiplier.' },
+    {
+      type: 'table',
+      headers: ['Signal', 'What to inspect at the table'],
+      rows: [
+        ['Below easy', 'The encounter may be a warm up, a travel beat, or a resource saving scene.'],
+        ['Easy', 'The party should usually win without spending many resources.'],
+        ['Medium', 'Expect pressure and at least one meaningful choice about resources.'],
+        ['Hard', 'Plan for characters to lose hit points, spell slots, or position.'],
+        ['Deadly', 'Check tactics, terrain, escape routes, and the cost of one bad round.'],
+      ],
+    },
+    { type: 'title', text: 'Why Monster Count Matters', level: 2 },
+    { type: 'paragraph', html: 'Several monsters can create more danger than their base XP suggests because they bring more attacks, reactions, positions, and chances to focus fire. That is why a pair of creatures uses a higher multiplier than one creature with the same combined XP. The result is a warning light for action economy, not a promise about how the encounter will feel.' },
+    { type: 'tip', title: 'Treat High CR as a Specific Danger Signal', html: 'A monster whose CR is above the party level may be able to remove a character with one strong action. Inspect its damage, control effects, saving throw difficulty, and mobility instead of relying on the final difficulty word alone.' },
+    { type: 'title', text: 'Use the Result as a Preparation Prompt', level: 2 },
+    { type: 'paragraph', html: 'Before using a hard or deadly encounter, look at the full situation. A cramped room, cover, surprise, environmental damage, concentration spells, legendary actions, and an exhausted party can all move the real danger away from the table value. A lower result can still become memorable when the objective, terrain, or time pressure creates a meaningful choice.' },
+    { type: 'tip', title: 'Mixed Monster Groups Need a Wider Check', html: 'This quick calculator keeps one CR visible so the interface stays fast. For a mixed group, total the XP of every meaningful monster, apply the multiplier to that total, and compare the adjusted XP with the same party thresholds.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
+};

package/src/tool/encounter-difficulty-calculator/i18n/es.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: 'Ajusta el grupo y la amenaza. La calculadora mide el encuentro con los umbrales de D&D 5e 2014 para detectar la presión antes de la iniciativa.',
+  partySection: 'El grupo',
+  partyLevel: 'Nivel del personaje',
+  partyLevelHint: 'Usa un nivel uniforme para un grupo con personajes de nivel similar.',
+  partySize: 'Personajes',
+  partySizeHint: 'Las reglas ajustan el multiplicador de monstruos para grupos muy pequeños o grandes.',
+  threatSection: 'La amenaza',
+  monsterCr: 'Desafío del monstruo (CR)',
+  monsterCrHint: 'Elige el CR de un monstruo repetido. Los grupos mixtos requieren un cálculo independiente.',
+  moreCr: 'Mostrar más CR',
+  lessCr: 'Mostrar menos CR',
+  monsterCount: 'Cantidad de monstruos',
+  monsterCountHint: 'Más criaturas aumentan la presión de acciones aunque su experiencia base sea modesta.',
+  presets: 'Empezar con una escena',
+  presetClassic: 'Patrulla clásica',
+  presetBoss: 'Jefe en solitario',
+  presetSwarm: 'Horda de esbirros',
+  resultSection: 'Presión del encuentro',
+  belowEasyHint: 'Una escena ligera que permite conservar recursos para los siguientes retos.',
+  easyHint: 'Una escena asequible con poca presión sobre el grupo.',
+  mediumHint: 'Una prueba significativa que puede costar puntos de golpe o recursos.',
+  hardHint: 'Una escena peligrosa donde la táctica y la gestión de recursos importan.',
+  deadlyHint: 'Señal de presión mortal. Revisa rutas de escape, terreno y el coste de un mal asalto.',
+  adjustedXp: 'XP Ajustada',
+  baseXp: 'XP Base',
+  multiplier: 'Multiplicador de grupo',
+  partyThreshold: 'Umbral Medio',
+  belowEasy: 'Inferior a fácil',
+  easy: 'Fácil',
+  medium: 'Medio',
+  hard: 'Difícil',
+  deadly: 'Mortal',
+  warning: 'Ten en cuenta',
+  partyAdjustment: 'Se ha ajustado el multiplicador de monstruos porque el grupo tiene menos de tres o más de cinco personajes.',
+  highCr: 'Un monstruo con CR superior al nivel del grupo puede derribar a un personaje rápidamente. Trata esta etiqueta como una alerta.',
+  manyMonsters: 'Once o más monstruos pueden dificultar la gestión del combate y crear gran volatilidad en la economía de acciones.',
+  rulesNote: 'Esta estimación se basa en las reglas de D&D 5e 2014. No contempla terreno, táctica, conjuros, objetos mágicos o experiencia del jugador.',
+  rulesLinkLabel: 'Leer las reglas de origen',
+  reset: 'Restablecer ejemplo',
+  xpUnit: 'XP',
+  sceneLabel: 'Gráfico visual de presión',
+  partyMarker: 'Grupo',
+  threatMarker: 'Amenaza',
+};
+
+const faq = [
+  {
+    question: '¿Qué reglas utiliza esta calculadora de dificultad de encuentros?',
+    answer: 'Utiliza el método oficial de D&D 5e 2014 de las Reglas Básicas. Suma los umbrales del grupo para encuentros fáciles, medios, difíciles y mortales, y los compara con la XP ajustada de los monstruos.',
+  },
+  {
+    question: '¿Por qué la XP ajustada es diferente de la XP que otorga un monstruo?',
+    answer: 'Las reglas multiplican la XP total de los monstruos para reflejar el peligro de varias criaturas actuando en el mismo asalto. La XP ajustada es un valor comparativo de dificultad, no la XP que reciben los personajes.',
+  },
+  {
+    question: '¿Puedo usar esto para un grupo mixto de monstruos?',
+    answer: 'Úsala como una estimación rápida para monstruos idénticos. Para grupos mixtos, suma la XP de cada criatura y aplica el multiplicador al número total de monstruos significativos.',
+  },
+  {
+    question: '¿Un resultado mortal significa que el grupo morirá?',
+    answer: 'No. Mortal significa que la XP ajustada alcanza el umbral mortal en las reglas. El terreno, las tácticas, los descansos, conjuros, objetos mágicos y decisiones pueden alterar el resultado real.',
+  },
+  {
+    question: '¿Por qué el tamaño del grupo cambia el multiplicador?',
+    answer: 'Las Reglas Básicas recomiendan aumentar el multiplicador para grupos de menos de tres personajes y reducirlo para grupos de seis o más, equilibrando la economía de acciones.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Establece el nivel del grupo',
+    text: 'Elige el nivel predominante de los personajes. Si los niveles varían mucho, toma el resultado como orientación y evalúa el nivel más bajo por separado.',
+  },
+  {
+    name: 'Indica el tamaño del grupo',
+    text: 'Introduce el número de personajes en el encuentro. Los grupos pequeños y grandes reciben un ajuste en el multiplicador.',
+  },
+  {
+    name: 'Describe la amenaza',
+    text: 'Selecciona el desafío (CR) y la cantidad de monstruos. Usa las plantillas predefinidas para una comprobación rápida.',
+  },
+  {
+    name: 'Interpreta la presión',
+    text: 'Compara la XP ajustada con las franjas de umbral y revisa las advertencias sobre economía de acciones, terreno y recursos antes del combate.',
+  },
+];
+
+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: 'Calculadora de Dificultad de Encuentros D&D 5e',
+  operatingSystem: 'All',
+  applicationCategory: 'GameApplication',
+  description: 'Calcula la dificultad de encuentros para grupos de D&D 5e 2014 basándote en nivel, tamaño de grupo, desafío de monstruos (CR), cantidad, XP y umbrales oficiales.',
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Cómo calcular la dificultad de un encuentro en D&D 5e',
+  step: howTo.map((item) => ({
+    '@type': 'HowToStep',
+    name: item.name,
+    text: item.text,
+  })),
+};
+
+export const content: EncounterDifficultyLocaleContent = {
+  slug: 'calculadora-dificultad-encuentros-dnd-5e',
+  title: 'Calculadora de Dificultad de Encuentros D&D 5e',
+  description: 'Estima la presión de encuentros en D&D 5e 2014 mediante nivel del grupo, tamaño, CR de monstruos, cantidad, XP ajustada y umbrales oficiales.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Analiza la dificultad del combate antes de tirar iniciativa', level: 2 },
+    { type: 'paragraph', html: 'Un encuentro de D&D es más que el número impreso junto a un monstruo. Esta calculadora convierte el tamaño del grupo, nivel, desafío (CR) y número de monstruos en el valor de XP ajustada utilizado por el sistema oficial de D&D 5e 2014.' },
+    { type: 'title', text: 'Cómo funciona la fórmula de encuentros de D&D 5e', level: 2 },
+    { type: 'paragraph', html: 'El método suma el umbral de XP de cada personaje para cada nivel de dificultad. Luego suma la XP base de los monstruos y aplica un multiplicador según el número de criaturas. Los grupos de menos de tres personajes usan un multiplicador superior y los de seis o más usan uno inferior.' },
+    {
+      type: 'table',
+      headers: ['Señal', 'Qué evaluar en la mesa'],
+      rows: [
+        ['Inferior a fácil', 'El encuentro puede ser un calentamiento, un evento de viaje o una escena de desgaste menor.'],
+        ['Fácil', 'El grupo debería ganar sin gastar apenas recursos.'],
+        ['Medio', 'Espera cierta presión y al menos una decisión importante sobre el uso de recursos.'],
+        ['Difícil', 'Planifica que los personajes pierdan puntos de golpe, espacio de conjuros o posición.'],
+        ['Mortal', 'Revisa tácticas, terreno, vías de escape y el impacto de un mal turno.'],
+      ],
+    },
+    { type: 'title', text: 'Por qué importa la cantidad de monstruos', level: 2 },
+    { type: 'paragraph', html: 'Varios monstruos crean más peligro del que indica su XP base porque aportan más ataques, reacciones y capacidad de concentrar el daño sobre un personaje. Por eso dos criaturas aplican un multiplicador mayor que una sola con la misma XP acumulada.' },
+    { type: 'tip', title: 'Considera un CR alto como una alerta específica', html: 'Un monstruo cuyo CR supere el nivel del grupo puede dejar KO a un personaje en una sola acción potente. Revisa su daño, efectos de control y movilidad en lugar de confiar solo en la palabra de dificultad final.' },
+    { type: 'title', text: 'Utiliza el resultado como guía de preparación', level: 2 },
+    { type: 'paragraph', html: 'Antes de plantear un encuentro difícil o mortal, evalúa el contexto general. Habitaciones estrechas, coberturas, sorpresa, trampas ambientales y conjuros de concentración pueden modificar sustancialmente el peligro real.' },
+    { type: 'tip', title: 'Los grupos mixtos requieren un ajuste manual', html: 'Esta calculadora mantiene un único CR para agilizar la entrada de datos. Si el combate incluye criaturas distintas, suma la XP base de cada una, aplica el multiplicador al total de monstruos y compáralo con los umbrales del grupo.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
+};