@jjlmoya/utils-tabletop 1.32.0 → 1.34.0

package/src/tool/dungeon-map-generator/dom-views.ts

@@ -1,144 +1,144 @@
-import { evaluateMap } from './evaluator';
-import type { DungeonEdit } from './document';
-import type { Door, DungeonMap, Tile } from './logic';
-import type { DungeonMapGeneratorUI } from './ui';
-
-interface RenderContext {
-  map: DungeonMap;
-  root: HTMLElement;
-  ui: DungeonMapGeneratorUI;
-}
-
-const CELL = 20;
-
-export function buildMapSvg(map: DungeonMap, standalone = false, isPrint = false): string {
-  const width = map.config.columns * CELL;
-  const height = map.config.rows * CELL;
-  const style = isPrint ? 'print' : map.config.style;
-  const cells = map.tiles.flatMap((row, y) =>
-    row.map((tile, x) => tileSvg(tile, x, y, style))).join('');
-  const palette = standalone ? standaloneStyle(style) : '';
-  const doors = map.doors.map(doorSvg).join('');
-  const hitGrid = standalone ? '' : interactionGridSvg(map);
-  return `<svg class="dmg-map dmg-map-${style}" viewBox="0 0 ${width} ${height}" role="img" aria-label="Generated dungeon map" xmlns="http://www.w3.org/2000/svg">${palette}<rect class="dmg-map-void" width="${width}" height="${height}"/>${cells}${doors}${compassSvg(width, height)}${hitGrid}</svg>`;
-}
-
-function tileSvg(tile: Tile, x: number, y: number, style: string): string {
-  if (tile === 0) return '';
-  const px = x * CELL;
-  const py = y * CELL;
-  const radius = style === 'cavern' ? 7 : 1;
-  return `<rect class="dmg-map-floor" x="${px}" y="${py}" width="${CELL + 0.5}" height="${CELL + 0.5}" rx="${radius}"/>`;
-}
-
-function doorSvg(door: Door): string {
-  const x = door.x * CELL;
-  const y = door.y * CELL;
-  if (door.orientation === 'vertical') {
-    return `<g class="dmg-map-door"><line x1="${x + 10}" y1="${y + 2}" x2="${x + 10}" y2="${y + 18}"/><circle cx="${x + 10}" cy="${y + 4}" r="1.5"/></g>`;
-  }
-  return `<g class="dmg-map-door"><line x1="${x + 2}" y1="${y + 10}" x2="${x + 18}" y2="${y + 10}"/><circle cx="${x + 4}" cy="${y + 10}" r="1.5"/></g>`;
-}
-
-function compassSvg(width: number, height: number): string {
-  if (width < 400 || height < 300) return '';
-  const x = width - 34;
-  const y = height - 34;
-  return `<g class="dmg-map-compass" transform="translate(${x} ${y})"><circle r="18"/><path d="M0 -14 L4 0 L0 14 L-4 0 Z"/><circle r="3"/></g>`;
-}
-
-function interactionGridSvg(map: DungeonMap): string {
-  return map.tiles.flatMap((row, y) => row.map((_tile, x) =>
-    `<rect class="dmg-map-hit" data-cell data-x="${x}" data-y="${y}" x="${x * CELL}" y="${y * CELL}" width="${CELL}" height="${CELL}"/>`)).join('');
-}
-
-function standaloneStyle(style: string): string {
-  if (style === 'print') {
-    return `<style>.dmg-map-void{fill:#ffffff}.dmg-map-floor{fill:#ffffff;stroke:#333333;stroke-width:.6}.dmg-map-door line{stroke:#000000;stroke-width:4}.dmg-map-door circle{fill:#000000}.dmg-map-compass circle{fill:#ffffff;stroke:#000000;stroke-width:1}.dmg-map-compass path{fill:#000000}</style>`;
-  }
-  const floor = style === 'scifi' ? '#d9f6f0' : '#ead9b7';
-  const door = style === 'cavern' ? '#d7774f' : '#b98142';
-  return `<style>.dmg-map-void{fill:#171b22}.dmg-map-floor{fill:${floor};stroke:#6d6253;stroke-width:.7}.dmg-map-door line{stroke:${door};stroke-width:4}.dmg-map-door circle{fill:#fff}.dmg-map-compass circle{fill:#171b22;stroke:#c5a25c;stroke-width:1}.dmg-map-compass path{fill:#c5a25c}</style>`;
-}
-
-export function renderMap(context: RenderContext): void {
-  const { map, root } = context;
-  root.dataset.style = map.config.style;
-  const mapHost = root.querySelector<HTMLElement>('[data-map-host]');
-  if (mapHost) mapHost.innerHTML = buildMapSvg(map);
-  setText(root, '[data-map-seed]', map.config.seed);
-  setText(root, '[data-room-count]', String(map.rooms.length));
-  setText(root, '[data-door-count]', String(map.doorCount));
-  renderEvaluation(context);
-}
-
-function renderEvaluation(context: RenderContext): void {
-  const evaluation = evaluateMap(context.map, context.ui);
-  setText(context.root, '[data-floor-percent]', `${evaluation.coverage}%`);
-  setText(context.root, '[data-evaluation-label]', evaluation.label);
-  setText(context.root, '[data-evaluation-hint]', evaluation.hint);
-  const badge = context.root.querySelector<HTMLElement>('[data-evaluation]');
-  if (badge) badge.dataset.pace = evaluation.pace;
-}
-
-function setText(root: HTMLElement, selector: string, value: string): void {
-  const element = root.querySelector<HTMLElement>(selector);
-  if (element) element.textContent = value;
-}
-
-function downloadBlob(blob: Blob, filename: string): void {
-  const url = URL.createObjectURL(blob);
-  const link = document.createElement('a');
-  link.href = url;
-  link.download = filename;
-  link.click();
-  URL.revokeObjectURL(url);
-}
-
-function filename(map: DungeonMap, extension: string, suffix = ''): string {
-  const seed = map.config.seed.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-  return `dungeon-${seed || 'map'}${suffix}.${extension}`;
-}
-
-export function exportSvg(map: DungeonMap, isPrint = false): void {
-  const svg = buildMapSvg(map, true, isPrint);
-  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
-  downloadBlob(blob, filename(map, 'svg', isPrint ? '-print' : ''));
-}
-
-export function exportJson(map: DungeonMap, edits: DungeonEdit[]): void {
-  const data = JSON.stringify({ version: 1, config: map.config, edits }, null, 2);
-  downloadBlob(new Blob([data], { type: 'application/json' }), filename(map, 'json'));
-}
-
-export async function exportPng(map: DungeonMap, isPrint = false): Promise<void> {
-  const svg = buildMapSvg(map, true, isPrint);
-  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
-  const source = URL.createObjectURL(blob);
-  try {
-    await drawPng(map, source, isPrint ? '-print' : '');
-  } finally {
-    URL.revokeObjectURL(source);
-  }
-}
-
-async function drawPng(map: DungeonMap, source: string, suffix = ''): Promise<void> {
-  const image = await loadImage(source);
-  const canvas = document.createElement('canvas');
-  canvas.width = map.config.columns * CELL * 2;
-  canvas.height = map.config.rows * CELL * 2;
-  const context = canvas.getContext('2d');
-  if (!context) return;
-  context.drawImage(image, 0, 0, canvas.width, canvas.height);
-  const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));
-  if (blob) downloadBlob(blob, filename(map, 'png', suffix));
-}
-
-function loadImage(source: string): Promise<HTMLImageElement> {
-  return new Promise((resolve, reject) => {
-    const image = new Image();
-    image.onload = () => resolve(image);
-    image.onerror = () => reject(new Error('Unable to render map image'));
-    image.src = source;
-  });
-}
+import { evaluateMap } from './evaluator';
+import type { DungeonEdit } from './document';
+import type { Door, DungeonMap, Tile } from './logic';
+import type { DungeonMapGeneratorUI } from './ui';
+
+interface RenderContext {
+  map: DungeonMap;
+  root: HTMLElement;
+  ui: DungeonMapGeneratorUI;
+}
+
+const CELL = 20;
+
+export function buildMapSvg(map: DungeonMap, standalone = false, isPrint = false): string {
+  const width = map.config.columns * CELL;
+  const height = map.config.rows * CELL;
+  const style = isPrint ? 'print' : map.config.style;
+  const cells = map.tiles.flatMap((row, y) =>
+    row.map((tile, x) => tileSvg(tile, x, y, style))).join('');
+  const palette = standalone ? standaloneStyle(style) : '';
+  const doors = map.doors.map(doorSvg).join('');
+  const hitGrid = standalone ? '' : interactionGridSvg(map);
+  return `<svg class="dmg-map dmg-map-${style}" viewBox="0 0 ${width} ${height}" role="img" aria-label="Generated dungeon map" xmlns="http://www.w3.org/2000/svg">${palette}<rect class="dmg-map-void" width="${width}" height="${height}"/>${cells}${doors}${compassSvg(width, height)}${hitGrid}</svg>`;
+}
+
+function tileSvg(tile: Tile, x: number, y: number, style: string): string {
+  if (tile === 0) return '';
+  const px = x * CELL;
+  const py = y * CELL;
+  const radius = style === 'cavern' ? 7 : 1;
+  return `<rect class="dmg-map-floor" x="${px}" y="${py}" width="${CELL + 0.5}" height="${CELL + 0.5}" rx="${radius}"/>`;
+}
+
+function doorSvg(door: Door): string {
+  const x = door.x * CELL;
+  const y = door.y * CELL;
+  if (door.orientation === 'vertical') {
+    return `<g class="dmg-map-door"><line x1="${x + 10}" y1="${y + 2}" x2="${x + 10}" y2="${y + 18}"/><circle cx="${x + 10}" cy="${y + 4}" r="1.5"/></g>`;
+  }
+  return `<g class="dmg-map-door"><line x1="${x + 2}" y1="${y + 10}" x2="${x + 18}" y2="${y + 10}"/><circle cx="${x + 4}" cy="${y + 10}" r="1.5"/></g>`;
+}
+
+function compassSvg(width: number, height: number): string {
+  if (width < 400 || height < 300) return '';
+  const x = width - 34;
+  const y = height - 34;
+  return `<g class="dmg-map-compass" transform="translate(${x} ${y})"><circle r="18"/><path d="M0 -14 L4 0 L0 14 L-4 0 Z"/><circle r="3"/></g>`;
+}
+
+function interactionGridSvg(map: DungeonMap): string {
+  return map.tiles.flatMap((row, y) => row.map((_tile, x) =>
+    `<rect class="dmg-map-hit" data-cell data-x="${x}" data-y="${y}" x="${x * CELL}" y="${y * CELL}" width="${CELL}" height="${CELL}"/>`)).join('');
+}
+
+function standaloneStyle(style: string): string {
+  if (style === 'print') {
+    return `<style>.dmg-map-void{fill:#ffffff}.dmg-map-floor{fill:#ffffff;stroke:#333333;stroke-width:.6}.dmg-map-door line{stroke:#000000;stroke-width:4}.dmg-map-door circle{fill:#000000}.dmg-map-compass circle{fill:#ffffff;stroke:#000000;stroke-width:1}.dmg-map-compass path{fill:#000000}</style>`;
+  }
+  const floor = style === 'scifi' ? '#d9f6f0' : '#ead9b7';
+  const door = style === 'cavern' ? '#d7774f' : '#b98142';
+  return `<style>.dmg-map-void{fill:#171b22}.dmg-map-floor{fill:${floor};stroke:#6d6253;stroke-width:.7}.dmg-map-door line{stroke:${door};stroke-width:4}.dmg-map-door circle{fill:#fff}.dmg-map-compass circle{fill:#171b22;stroke:#c5a25c;stroke-width:1}.dmg-map-compass path{fill:#c5a25c}</style>`;
+}
+
+export function renderMap(context: RenderContext): void {
+  const { map, root } = context;
+  root.dataset.style = map.config.style;
+  const mapHost = root.querySelector<HTMLElement>('[data-map-host]');
+  if (mapHost) mapHost.innerHTML = buildMapSvg(map);
+  setText(root, '[data-map-seed]', map.config.seed);
+  setText(root, '[data-room-count]', String(map.rooms.length));
+  setText(root, '[data-door-count]', String(map.doorCount));
+  renderEvaluation(context);
+}
+
+function renderEvaluation(context: RenderContext): void {
+  const evaluation = evaluateMap(context.map, context.ui);
+  setText(context.root, '[data-floor-percent]', `${evaluation.coverage}%`);
+  setText(context.root, '[data-evaluation-label]', evaluation.label);
+  setText(context.root, '[data-evaluation-hint]', evaluation.hint);
+  const badge = context.root.querySelector<HTMLElement>('[data-evaluation]');
+  if (badge) badge.dataset.pace = evaluation.pace;
+}
+
+function setText(root: HTMLElement, selector: string, value: string): void {
+  const element = root.querySelector<HTMLElement>(selector);
+  if (element) element.textContent = value;
+}
+
+function downloadBlob(blob: Blob, filename: string): void {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  link.click();
+  URL.revokeObjectURL(url);
+}
+
+function filename(map: DungeonMap, extension: string, suffix = ''): string {
+  const seed = map.config.seed.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  return `dungeon-${seed || 'map'}${suffix}.${extension}`;
+}
+
+export function exportSvg(map: DungeonMap, isPrint = false): void {
+  const svg = buildMapSvg(map, true, isPrint);
+  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
+  downloadBlob(blob, filename(map, 'svg', isPrint ? '-print' : ''));
+}
+
+export function exportJson(map: DungeonMap, edits: DungeonEdit[]): void {
+  const data = JSON.stringify({ version: 1, config: map.config, edits }, null, 2);
+  downloadBlob(new Blob([data], { type: 'application/json' }), filename(map, 'json'));
+}
+
+export async function exportPng(map: DungeonMap, isPrint = false): Promise<void> {
+  const svg = buildMapSvg(map, true, isPrint);
+  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
+  const source = URL.createObjectURL(blob);
+  try {
+    await drawPng(map, source, isPrint ? '-print' : '');
+  } finally {
+    URL.revokeObjectURL(source);
+  }
+}
+
+async function drawPng(map: DungeonMap, source: string, suffix = ''): Promise<void> {
+  const image = await loadImage(source);
+  const canvas = document.createElement('canvas');
+  canvas.width = map.config.columns * CELL * 2;
+  canvas.height = map.config.rows * CELL * 2;
+  const context = canvas.getContext('2d');
+  if (!context) return;
+  context.drawImage(image, 0, 0, canvas.width, canvas.height);
+  const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));
+  if (blob) downloadBlob(blob, filename(map, 'png', suffix));
+}
+
+function loadImage(source: string): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error('Unable to render map image'));
+    image.src = source;
+  });
+}

package/src/tool/dungeon-map-generator/i18n/de.ts

@@ -1,172 +1,172 @@
-import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
-import { bibliography } from '../bibliography';
-import type { DungeonMapGeneratorLocaleContent, DungeonMapGeneratorUI } from '../entry';
-
-const ui: DungeonMapGeneratorUI = {
-  intro: 'Wählen Sie einen Seed, stellen Sie das Raster ein und wählen Sie einen Stil. Generieren Sie eine verbundene Karte für Notizen, Druck oder VTT.',
-  seedLabel: 'Karten-Seed',
-  seedHint: 'Verwenden Sie denselben Seed bei gleichen Einstellungen, um die exakt gleiche Karte zu erstellen.',
-  randomSeed: 'Neuer Seed',
-  sizeLabel: 'Expeditionsgröße',
-  sizeCompact: 'One-Shot',
-  sizeSession: 'Sitzung',
-  sizeStronghold: 'Festung',
-  fineTuneGrid: 'Raster und Dichte feinabstimmen',
-  columnsLabel: 'Spalten',
-  rowsLabel: 'Zeilen',
-  densityLabel: 'Raumdichte',
-  densityHint: 'Höhere Dichte erzeugt mehr Räume und nutzbare Bodenfläche.',
-  styleLabel: 'Kartenarchitektur',
-  dungeonStyle: 'Dungeon',
-  dungeonStyleHint: 'Steinräume mit einfachen Gängen.',
-  cavernStyle: 'Höhle',
-  cavernStyleHint: 'Unregelmäßige Räume mit weichen Kanten.',
-  scifiStyle: 'Sci-Fi',
-  scifiStyleHint: 'Breite Module mit doppelten Verbindungsgängen.',
-  generate: 'Karte zeichnen',
-  mapRegionLabel: 'Generierte Dungeon-Karte und Export-Steuerung',
-  connectedBadge: 'Alle Räume verbunden',
-  roomsLabel: 'Räume',
-  doorsLabel: 'Türen',
-  floorLabel: 'Bodenabdeckung',
-  legendFloor: 'Begehbarer Boden',
-  legendWall: 'Feste Wand',
-  legendDoor: 'Tür oder Schott',
-  editHint: 'Rechtsklick auf eine Zelle zum Bearbeiten',
-  editCell: 'Zelle bearbeiten',
-  paintFloor: 'Boden',
-  paintWall: 'Wand',
-  paintDoor: 'Tür',
-  mapData: 'Kartendaten',
-  copyLink: 'Link kopieren',
-  linkCopied: 'Link kopiert',
-  exportPng: 'PNG herunterladen',
-  exportSvg: 'SVG herunterladen',
-  exportJson: 'JSON speichern',
-  importJson: 'JSON öffnen',
-  importError: 'Diese Datei enthält keine gültige Dungeon-Konfiguration.',
-  compactMap: 'Angespannte Erkundung',
-  balancedMap: 'Ausgewogene Expedition',
-  sprawlingMap: 'Offene Festung',
-  compactHint: 'Längere Übergänge lassen mehr unbekannten Raum zwischen Räumen.',
-  balancedHint: 'Räume und Gänge teilen sich die Fläche gleichmäßig.',
-  sprawlingHint: 'Große Bodenfläche begünstigt Begegnungen und schnelle Bewegung.',
-  mapReady: 'Kartenlegende',
-  dimensionsUnit: 'Rasterzellen',
-};
-
-const faq = [
-  {
-    question: 'Erzeugt derselbe Seed immer dieselbe Dungeon-Karte?',
-    answer: 'Ja. Seed, Rasterabmessungen, Dichte und Stil bilden eine deterministische Konfiguration. Die Wiederverwendung aller vier Einstellungen baut exakt dieselben Räume und Türen auf.',
-  },
-  {
-    question: 'Sind alle generierten Räume erreichbar?',
-    answer: 'Ja. Die Räume werden nach der Platzierung über eine Hauptroute verbunden, sodass jeder begehbare Bereich zu einer einzigen verbundenen Karte gehört.',
-  },
-  {
-    question: 'Was unterscheidet Dungeon-, Höhlen- und Sci-Fi-Stile?',
-    answer: 'Dungeons nutzen regelmäßige Steinräume. Höhlen erzeugen unregelmäßige, abgerundete Kammern. Sci-Fi-Karten bevorzugen breite Module mit doppelten Schotts.',
-  },
-  {
-    question: 'Welches Format eignet sich für ein Virtual Tabletop (VTT)?',
-    answer: 'PNG ist für die meisten VTTs am einfachsten. SVG bleibt bei jeder Skalierung scharf und lässt sich in Vektorprogrammen leicht bearbeiten.',
-  },
-  {
-    question: 'Kann jemand anderes meine Dungeon-Karte regenerieren?',
-    answer: 'Ja. Kopieren Sie den Link oder senden Sie die JSON-Datei. Der Empfänger kann dieselbe Konfiguration sofort laden.',
-  },
-  {
-    question: 'Fügt dieser Generator Monster, Fallen oder Schätze hinzu?',
-    answer: 'Nein. Er erstellt einen neutralen Grundriss, den Sie für jedes Regelwerk anpassen können. Die Ausgestaltung obliegt dem Spielleiter.',
-  },
-];
-
-const howTo = [
-  {
-    name: 'Rasterabmessungen festlegen',
-    text: 'Wählen Sie Spalten und Zeilen passend für Ihre Notizen oder VTT-Szene.',
-  },
-  {
-    name: 'Architektur wählen',
-    text: 'Wählen Sie Dungeon, Höhle oder Sci-Fi und passen Sie die Raumdichte an.',
-  },
-  {
-    name: 'Generieren und prüfen',
-    text: 'Geben Sie einen Seed ein, zeichnen Sie die Karte und prüfen Sie die Übersicht.',
-  },
-  {
-    name: 'Exportieren oder teilen',
-    text: 'Laden Sie PNG oder SVG herunter oder speichern Sie die Konfiguration per Link oder JSON.',
-  },
-];
-
-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: 'Zufalls-Dungeon-Kartengenerator',
-  operatingSystem: 'All',
-  applicationCategory: 'UtilitiesApplication',
-  description: 'Ein deterministischer Generator für Dungeon-Karten mit verbundenen Räumen, Türen und lokalen Exporten.',
-};
-
-const howToSchema: WithContext<HowTo> = {
-  '@context': 'https://schema.org',
-  '@type': 'HowTo',
-  name: 'So generieren Sie eine verbundene Dungeon-Karte',
-  step: howTo.map((item) => ({
-    '@type': 'HowToStep',
-    name: item.name,
-    text: item.text,
-  })),
-};
-
-export const content: DungeonMapGeneratorLocaleContent = {
-  slug: 'zufalls-dungeon-karten-generator',
-  title: 'Dungeon Kartengenerator für Rollenspiele',
-  description: 'Erstellen Sie reproduzierbare Dungeon-, Höhlen- und Sci-Fi-Karten mit verbundenen Räumen, Türen und PNG/SVG-Export.',
-  ui,
-  seo: [
-    { type: 'title', text: 'Erstellen Sie eine spielbare Dungeon-Karte aus einem wiederverwendbaren Seed', level: 2 },
-    { type: 'paragraph', html: 'Eine nützliche Zufalls-Dungeon-Karte erfordert mehr als beliebiges visuelles Rauschen. Jede Kammer muss erreichbar sein, das Raster muss zur Spielfläche passen und das Ergebnis muss jederzeit wiederherstellbar sein. Dieser Generator behandelt Seed und Einstellungen als deterministische Kartenspezifikation. Dieselben Einstellungen erzeugen stets denselben Plan.' },
-    { type: 'title', text: 'Rasterabmessungen für Druck und Virtual Tabletops wählen', level: 2 },
-    { type: 'paragraph', html: 'Die Wahl der Rastergröße ist der erste praktische Schritt. Ein kleineres Raster lässt sich leicht ausdrucken und eignet sich für kurze Abenteuer, während ein großes Raster Raum für Erkundungen bietet. Das exportierte Bild behält quadratische Zellen bei, um sich nahtlos an VTT-Raster anzupassen.' },
-    {
-      type: 'table',
-      headers: ['Rastergröße', 'Typische Nutzung', 'Start-Dichte', 'Planungshinweis'],
-      rows: [
-        ['20 mal 16 Zellen', 'One-Shot Ort', '35 bis 45', 'Schnell zu lesen und einfach zu drucken'],
-        ['36 mal 26 Zellen', 'Sitzungs-Dungeon', '45 bis 55', 'Ausgewogener Rhythmus zwischen Raum und Gang'],
-        ['52 mal 38 Zellen', 'Mehrteiliger Komplex', '50 bis 65', 'Viel Platz für Fraktionen und optionale Wege'],
-      ],
-    },
-    { type: 'tip', title: 'Passen Sie die Karte an die Begegnungsgröße an', html: 'Berechnen Sie den benötigten Platz für große Begegnungen vor der Größenwahl. Ein großer Dungeon mit winzigen Räumen wirkt eng, während ein kompakter Plan mit einem großzügigen Hauptraum einprägsame Szenen ermöglicht.' },
-    { type: 'title', text: 'Bodenabdeckung als Tempo-Signal verstehen', level: 2 },
-    { type: 'paragraph', html: 'Die Bodenabdeckung beschreibt den Prozentsatz der begehbaren Fläche. Geringe Abdeckung betont Isolation und unentdeckten Raum. Mittlere Abdeckung sorgt für stetigen Spielfluss. Hohe Abdeckung schafft komplexe Festungen mit dynamischen Kämpfen.' },
-    {
-      type: 'list',
-      items: [
-        '<strong>Angespannte Erkundung:</strong> Nutzen Sie leeren Raum für Isolation oder Geheimgänge.',
-        '<strong>Ausgewogene Expedition:</strong> Wechseln Sie Räume und Verbindungswege ab.',
-        '<strong>Offene Festung:</strong> Planen Sie Sichtlinien und Patrouillenwege ein.',
-      ],
-    },
-    { type: 'title', text: 'Vom neutralen Grundriss zum Abenteuerort', level: 2 },
-    { type: 'paragraph', html: 'Die generierte Karte liefert die reine Architektur. Weisen Sie Räumen erzählerische Funktionen zu und platzieren Sie Hinweise, Fallen und Schätze entsprechend.' },
-    { type: 'tip', title: 'Konfiguration vor dem Ausgestalten sichern', html: 'Kopieren Sie den Link oder speichern Sie das JSON vor dem Hinzufügen von Notizen, um den Spielern eine saubere Karte ohne Spielleiter-Notizen zu geben.' },
-  ],
-  faq,
-  bibliography,
-  howTo,
-  schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
-};
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { DungeonMapGeneratorLocaleContent, DungeonMapGeneratorUI } from '../entry';
+
+const ui: DungeonMapGeneratorUI = {
+  intro: 'Wählen Sie einen Seed, stellen Sie das Raster ein und wählen Sie einen Stil. Generieren Sie eine verbundene Karte für Notizen, Druck oder VTT.',
+  seedLabel: 'Karten-Seed',
+  seedHint: 'Verwenden Sie denselben Seed bei gleichen Einstellungen, um die exakt gleiche Karte zu erstellen.',
+  randomSeed: 'Neuer Seed',
+  sizeLabel: 'Expeditionsgröße',
+  sizeCompact: 'One-Shot',
+  sizeSession: 'Sitzung',
+  sizeStronghold: 'Festung',
+  fineTuneGrid: 'Raster und Dichte feinabstimmen',
+  columnsLabel: 'Spalten',
+  rowsLabel: 'Zeilen',
+  densityLabel: 'Raumdichte',
+  densityHint: 'Höhere Dichte erzeugt mehr Räume und nutzbare Bodenfläche.',
+  styleLabel: 'Kartenarchitektur',
+  dungeonStyle: 'Dungeon',
+  dungeonStyleHint: 'Steinräume mit einfachen Gängen.',
+  cavernStyle: 'Höhle',
+  cavernStyleHint: 'Unregelmäßige Räume mit weichen Kanten.',
+  scifiStyle: 'Sci-Fi',
+  scifiStyleHint: 'Breite Module mit doppelten Verbindungsgängen.',
+  generate: 'Karte zeichnen',
+  mapRegionLabel: 'Generierte Dungeon-Karte und Export-Steuerung',
+  connectedBadge: 'Alle Räume verbunden',
+  roomsLabel: 'Räume',
+  doorsLabel: 'Türen',
+  floorLabel: 'Bodenabdeckung',
+  legendFloor: 'Begehbarer Boden',
+  legendWall: 'Feste Wand',
+  legendDoor: 'Tür oder Schott',
+  editHint: 'Rechtsklick auf eine Zelle zum Bearbeiten',
+  editCell: 'Zelle bearbeiten',
+  paintFloor: 'Boden',
+  paintWall: 'Wand',
+  paintDoor: 'Tür',
+  mapData: 'Kartendaten',
+  copyLink: 'Link kopieren',
+  linkCopied: 'Link kopiert',
+  exportPng: 'PNG herunterladen',
+  exportSvg: 'SVG herunterladen',
+  exportJson: 'JSON speichern',
+  importJson: 'JSON öffnen',
+  importError: 'Diese Datei enthält keine gültige Dungeon-Konfiguration.',
+  compactMap: 'Angespannte Erkundung',
+  balancedMap: 'Ausgewogene Expedition',
+  sprawlingMap: 'Offene Festung',
+  compactHint: 'Längere Übergänge lassen mehr unbekannten Raum zwischen Räumen.',
+  balancedHint: 'Räume und Gänge teilen sich die Fläche gleichmäßig.',
+  sprawlingHint: 'Große Bodenfläche begünstigt Begegnungen und schnelle Bewegung.',
+  mapReady: 'Kartenlegende',
+  dimensionsUnit: 'Rasterzellen',
+};
+
+const faq = [
+  {
+    question: 'Erzeugt derselbe Seed immer dieselbe Dungeon-Karte?',
+    answer: 'Ja. Seed, Rasterabmessungen, Dichte und Stil bilden eine deterministische Konfiguration. Die Wiederverwendung aller vier Einstellungen baut exakt dieselben Räume und Türen auf.',
+  },
+  {
+    question: 'Sind alle generierten Räume erreichbar?',
+    answer: 'Ja. Die Räume werden nach der Platzierung über eine Hauptroute verbunden, sodass jeder begehbare Bereich zu einer einzigen verbundenen Karte gehört.',
+  },
+  {
+    question: 'Was unterscheidet Dungeon-, Höhlen- und Sci-Fi-Stile?',
+    answer: 'Dungeons nutzen regelmäßige Steinräume. Höhlen erzeugen unregelmäßige, abgerundete Kammern. Sci-Fi-Karten bevorzugen breite Module mit doppelten Schotts.',
+  },
+  {
+    question: 'Welches Format eignet sich für ein Virtual Tabletop (VTT)?',
+    answer: 'PNG ist für die meisten VTTs am einfachsten. SVG bleibt bei jeder Skalierung scharf und lässt sich in Vektorprogrammen leicht bearbeiten.',
+  },
+  {
+    question: 'Kann jemand anderes meine Dungeon-Karte regenerieren?',
+    answer: 'Ja. Kopieren Sie den Link oder senden Sie die JSON-Datei. Der Empfänger kann dieselbe Konfiguration sofort laden.',
+  },
+  {
+    question: 'Fügt dieser Generator Monster, Fallen oder Schätze hinzu?',
+    answer: 'Nein. Er erstellt einen neutralen Grundriss, den Sie für jedes Regelwerk anpassen können. Die Ausgestaltung obliegt dem Spielleiter.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Rasterabmessungen festlegen',
+    text: 'Wählen Sie Spalten und Zeilen passend für Ihre Notizen oder VTT-Szene.',
+  },
+  {
+    name: 'Architektur wählen',
+    text: 'Wählen Sie Dungeon, Höhle oder Sci-Fi und passen Sie die Raumdichte an.',
+  },
+  {
+    name: 'Generieren und prüfen',
+    text: 'Geben Sie einen Seed ein, zeichnen Sie die Karte und prüfen Sie die Übersicht.',
+  },
+  {
+    name: 'Exportieren oder teilen',
+    text: 'Laden Sie PNG oder SVG herunter oder speichern Sie die Konfiguration per Link oder JSON.',
+  },
+];
+
+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: 'Zufalls-Dungeon-Kartengenerator',
+  operatingSystem: 'All',
+  applicationCategory: 'UtilitiesApplication',
+  description: 'Ein deterministischer Generator für Dungeon-Karten mit verbundenen Räumen, Türen und lokalen Exporten.',
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'So generieren Sie eine verbundene Dungeon-Karte',
+  step: howTo.map((item) => ({
+    '@type': 'HowToStep',
+    name: item.name,
+    text: item.text,
+  })),
+};
+
+export const content: DungeonMapGeneratorLocaleContent = {
+  slug: 'zufalls-dungeon-karten-generator',
+  title: 'Dungeon Kartengenerator für Rollenspiele',
+  description: 'Erstellen Sie reproduzierbare Dungeon-, Höhlen- und Sci-Fi-Karten mit verbundenen Räumen, Türen und PNG/SVG-Export.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Erstellen Sie eine spielbare Dungeon-Karte aus einem wiederverwendbaren Seed', level: 2 },
+    { type: 'paragraph', html: 'Eine nützliche Zufalls-Dungeon-Karte erfordert mehr als beliebiges visuelles Rauschen. Jede Kammer muss erreichbar sein, das Raster muss zur Spielfläche passen und das Ergebnis muss jederzeit wiederherstellbar sein. Dieser Generator behandelt Seed und Einstellungen als deterministische Kartenspezifikation. Dieselben Einstellungen erzeugen stets denselben Plan.' },
+    { type: 'title', text: 'Rasterabmessungen für Druck und Virtual Tabletops wählen', level: 2 },
+    { type: 'paragraph', html: 'Die Wahl der Rastergröße ist der erste praktische Schritt. Ein kleineres Raster lässt sich leicht ausdrucken und eignet sich für kurze Abenteuer, während ein großes Raster Raum für Erkundungen bietet. Das exportierte Bild behält quadratische Zellen bei, um sich nahtlos an VTT-Raster anzupassen.' },
+    {
+      type: 'table',
+      headers: ['Rastergröße', 'Typische Nutzung', 'Start-Dichte', 'Planungshinweis'],
+      rows: [
+        ['20 mal 16 Zellen', 'One-Shot Ort', '35 bis 45', 'Schnell zu lesen und einfach zu drucken'],
+        ['36 mal 26 Zellen', 'Sitzungs-Dungeon', '45 bis 55', 'Ausgewogener Rhythmus zwischen Raum und Gang'],
+        ['52 mal 38 Zellen', 'Mehrteiliger Komplex', '50 bis 65', 'Viel Platz für Fraktionen und optionale Wege'],
+      ],
+    },
+    { type: 'tip', title: 'Passen Sie die Karte an die Begegnungsgröße an', html: 'Berechnen Sie den benötigten Platz für große Begegnungen vor der Größenwahl. Ein großer Dungeon mit winzigen Räumen wirkt eng, während ein kompakter Plan mit einem großzügigen Hauptraum einprägsame Szenen ermöglicht.' },
+    { type: 'title', text: 'Bodenabdeckung als Tempo-Signal verstehen', level: 2 },
+    { type: 'paragraph', html: 'Die Bodenabdeckung beschreibt den Prozentsatz der begehbaren Fläche. Geringe Abdeckung betont Isolation und unentdeckten Raum. Mittlere Abdeckung sorgt für stetigen Spielfluss. Hohe Abdeckung schafft komplexe Festungen mit dynamischen Kämpfen.' },
+    {
+      type: 'list',
+      items: [
+        '<strong>Angespannte Erkundung:</strong> Nutzen Sie leeren Raum für Isolation oder Geheimgänge.',
+        '<strong>Ausgewogene Expedition:</strong> Wechseln Sie Räume und Verbindungswege ab.',
+        '<strong>Offene Festung:</strong> Planen Sie Sichtlinien und Patrouillenwege ein.',
+      ],
+    },
+    { type: 'title', text: 'Vom neutralen Grundriss zum Abenteuerort', level: 2 },
+    { type: 'paragraph', html: 'Die generierte Karte liefert die reine Architektur. Weisen Sie Räumen erzählerische Funktionen zu und platzieren Sie Hinweise, Fallen und Schätze entsprechend.' },
+    { type: 'tip', title: 'Konfiguration vor dem Ausgestalten sichern', html: 'Kopieren Sie den Link oder speichern Sie das JSON vor dem Hinzufügen von Notizen, um den Spielern eine saubere Karte ohne Spielleiter-Notizen zu geben.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
+};