@jjlmoya/utils-tabletop 1.20.0 → 1.22.0

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

@@ -0,0 +1,139 @@
+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): string {
+  const width = map.config.columns * CELL;
+  const height = map.config.rows * CELL;
+  const cells = map.tiles.flatMap((row, y) =>
+    row.map((tile, x) => tileSvg(tile, x, y, map.config.style))).join('');
+  const palette = standalone ? standaloneStyle(map.config.style) : '';
+  const doors = map.doors.map(doorSvg).join('');
+  const hitGrid = standalone ? '' : interactionGridSvg(map);
+  return `<svg class="dmg-map dmg-map-${map.config.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 {
+  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): string {
+  const seed = map.config.seed.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  return `dungeon-${seed || 'map'}.${extension}`;
+}
+
+export function exportSvg(map: DungeonMap): void {
+  const blob = new Blob([buildMapSvg(map, true)], { type: 'image/svg+xml;charset=utf-8' });
+  downloadBlob(blob, filename(map, 'svg'));
+}
+
+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): Promise<void> {
+  const svg = buildMapSvg(map, true);
+  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
+  const source = URL.createObjectURL(blob);
+  try {
+    await drawPng(map, source);
+  } finally {
+    URL.revokeObjectURL(source);
+  }
+}
+
+async function drawPng(map: DungeonMap, source: string): 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'));
+}
+
+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/editor.ts

@@ -0,0 +1,57 @@
+import type { Tile } from './logic';
+
+type EditHandler = (x: number, y: number, tile: Tile) => void;
+
+interface CellPosition {
+  x: number;
+  y: number;
+}
+
+export function bindContextEditor(root: HTMLElement, onEdit: EditHandler): void {
+  const host = root.querySelector<HTMLElement>('[data-map-host]');
+  const menu = root.querySelector<HTMLElement>('[data-context-menu]');
+  if (!host || !menu) return;
+  let selected: CellPosition | undefined;
+  let holdTimer = 0;
+  host.addEventListener('contextmenu', (event) => {
+    event.preventDefault();
+    selected = openCellMenu(root, menu, event);
+  });
+  host.addEventListener('pointerdown', (event) => {
+    holdTimer = window.setTimeout(() => { selected = openCellMenu(root, menu, event); }, 550);
+  });
+  host.addEventListener('pointerup', () => window.clearTimeout(holdTimer));
+  host.addEventListener('pointercancel', () => window.clearTimeout(holdTimer));
+  menu.querySelectorAll<HTMLButtonElement>('[data-context-tool]').forEach((button) => {
+    button.addEventListener('click', () => {
+      if (selected) onEdit(selected.x, selected.y, tileForTool(button.dataset.contextTool));
+      closeMenu(menu);
+    });
+  });
+  document.addEventListener('click', (event) => {
+    if (!menu.contains(event.target as Node)) closeMenu(menu);
+  });
+}
+
+function openCellMenu(root: HTMLElement, menu: HTMLElement, event: MouseEvent | PointerEvent): CellPosition | undefined {
+  const cell = (event.target as Element).closest<SVGElement>('[data-cell]');
+  if (!cell) return undefined;
+  const frame = root.querySelector<HTMLElement>('.dmg-map-frame');
+  if (!frame) return undefined;
+  const bounds = frame.getBoundingClientRect();
+  menu.style.left = `${event.clientX - bounds.left}px`;
+  menu.style.top = `${event.clientY - bounds.top}px`;
+  menu.hidden = false;
+  menu.querySelector<HTMLButtonElement>('button')?.focus();
+  return { x: Number(cell.dataset.x), y: Number(cell.dataset.y) };
+}
+
+function tileForTool(tool: string | undefined): Tile {
+  if (tool === 'wall') return 0;
+  if (tool === 'door') return 2;
+  return 1;
+}
+
+function closeMenu(menu: HTMLElement): void {
+  menu.hidden = true;
+}

package/src/tool/dungeon-map-generator/entry.ts

@@ -0,0 +1,28 @@
+import type { TabletopToolEntry, ToolLocaleContent } from '../../types';
+import type { DungeonMapGeneratorUI } from './ui';
+
+export type { DungeonMapGeneratorUI } from './ui';
+export type DungeonMapGeneratorLocaleContent = ToolLocaleContent<DungeonMapGeneratorUI>;
+
+export const dungeonMapGenerator: TabletopToolEntry<DungeonMapGeneratorUI> = {
+  id: 'dungeon-map-generator',
+  icons: { bg: 'mdi:map-outline', fg: 'mdi:castle' },
+  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/dungeon-map-generator/evaluator.ts

@@ -0,0 +1,40 @@
+import type { DungeonMap } from './logic';
+import type { DungeonMapGeneratorUI } from './ui';
+
+export type MapPace = 'compact' | 'balanced' | 'sprawling';
+
+export interface MapEvaluation {
+  pace: MapPace;
+  label: string;
+  hint: string;
+  coverage: number;
+}
+
+export function evaluateMap(map: DungeonMap, ui: DungeonMapGeneratorUI): MapEvaluation {
+  const coverage = Math.round((map.floorCount / (map.config.columns * map.config.rows)) * 100);
+  const pace = getPace(coverage);
+  return {
+    pace,
+    coverage,
+    label: getLabel(pace, ui),
+    hint: getHint(pace, ui),
+  };
+}
+
+function getPace(coverage: number): MapPace {
+  if (coverage < 24) return 'compact';
+  if (coverage > 38) return 'sprawling';
+  return 'balanced';
+}
+
+function getLabel(pace: MapPace, ui: DungeonMapGeneratorUI): string {
+  if (pace === 'compact') return ui.compactMap;
+  if (pace === 'sprawling') return ui.sprawlingMap;
+  return ui.balancedMap;
+}
+
+function getHint(pace: MapPace, ui: DungeonMapGeneratorUI): string {
+  if (pace === 'compact') return ui.compactHint;
+  if (pace === 'sprawling') return ui.sprawlingHint;
+  return ui.balancedHint;
+}

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

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

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

@@ -0,0 +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: 'Choose a seed, set the grid, and select an architectural language. Generate a connected map, then take it to your notes, print layout, or virtual tabletop.',
+  seedLabel: 'Map seed',
+  seedHint: 'Reuse a seed with the same settings to rebuild the exact map.',
+  randomSeed: 'New seed',
+  sizeLabel: 'Expedition size',
+  sizeCompact: 'One Shot',
+  sizeSession: 'Session',
+  sizeStronghold: 'Stronghold',
+  fineTuneGrid: 'Fine tune grid and density',
+  columnsLabel: 'Columns',
+  rowsLabel: 'Rows',
+  densityLabel: 'Room density',
+  densityHint: 'Higher density adds more chambers and usable floor.',
+  styleLabel: 'Map architecture',
+  dungeonStyle: 'Dungeon',
+  dungeonStyleHint: 'Stone rooms with single width passages.',
+  cavernStyle: 'Cavern',
+  cavernStyleHint: 'Irregular chambers with softened edges.',
+  scifiStyle: 'Sci Fi',
+  scifiStyleHint: 'Wide modules with double width connectors.',
+  generate: 'Draw this map',
+  mapRegionLabel: 'Generated dungeon map and export controls',
+  connectedBadge: 'All rooms connected',
+  roomsLabel: 'Rooms',
+  doorsLabel: 'Doors',
+  floorLabel: 'Floor coverage',
+  legendFloor: 'Walkable floor',
+  legendWall: 'Solid wall',
+  legendDoor: 'Door or bulkhead',
+  editHint: 'Right click a cell to edit',
+  editCell: 'Edit this cell',
+  paintFloor: 'Floor',
+  paintWall: 'Wall',
+  paintDoor: 'Door',
+  mapData: 'Map data',
+  copyLink: 'Copy map link',
+  linkCopied: 'Link copied',
+  exportPng: 'Download PNG',
+  exportSvg: 'Download SVG',
+  exportJson: 'Save setup JSON',
+  importJson: 'Open setup JSON',
+  importError: 'This file does not contain a valid dungeon map setup.',
+  compactMap: 'Tense exploration',
+  balancedMap: 'Balanced expedition',
+  sprawlingMap: 'Open stronghold',
+  compactHint: 'Longer transitions leave more unknown space between rooms.',
+  balancedHint: 'Rooms and passages share the plan without crowding each other.',
+  sprawlingHint: 'Generous floor coverage favors encounters and rapid movement.',
+  mapReady: 'Map tile legend',
+  dimensionsUnit: 'grid cells',
+};
+
+const faq = [
+  {
+    question: 'Does the same seed always create the same dungeon map?',
+    answer: 'Yes. The seed, grid dimensions, density, and architecture style form one deterministic setup. Reusing all four settings rebuilds the same rooms, corridors, and doors.',
+  },
+  {
+    question: 'Are all generated rooms reachable?',
+    answer: 'Yes. Rooms are connected in a spanning route after placement, so every walkable region belongs to one connected map. Doors mark the transition between rooms and corridors.',
+  },
+  {
+    question: 'What changes between dungeon, cavern, and Sci Fi styles?',
+    answer: 'Dungeon maps use regular stone rooms and narrow corridors. Caverns carve irregular rounded chambers. Sci Fi maps favor wider modules and double width connectors for bulkhead style layouts.',
+  },
+  {
+    question: 'Which format should I export for a virtual tabletop?',
+    answer: 'PNG is the simplest option for most virtual tabletops. SVG stays sharp at any scale and is easier to edit in vector software. Both exports preserve the square grid geometry.',
+  },
+  {
+    question: 'Can another person regenerate my random dungeon map?',
+    answer: 'Yes. Copy the map link to include the full setup in the URL, or send the JSON setup file. The recipient can load the same deterministic configuration without an account.',
+  },
+  {
+    question: 'Does this generator add monsters, traps, or treasure?',
+    answer: 'No. It creates a neutral architectural floor plan so you can stock it for any ruleset. Encounter design, secrets, hazards, and narrative meaning remain under the game master\'s control.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Set the map footprint',
+    text: 'Choose the number of columns and rows to match the space available in your notes, print page, or virtual tabletop scene.',
+  },
+  {
+    name: 'Choose an architecture',
+    text: 'Select dungeon, cavern, or Sci Fi, then adjust room density for a tighter or more open expedition.',
+  },
+  {
+    name: 'Generate and inspect',
+    text: 'Enter a memorable seed or request a new one, draw the map, and read the room, door, and floor coverage summary.',
+  },
+  {
+    name: 'Export or share',
+    text: 'Download PNG or SVG for play, or preserve the exact configuration through a map link or JSON setup file.',
+  },
+];
+
+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: 'Dungeon Map Generator',
+  operatingSystem: 'All',
+  applicationCategory: 'UtilitiesApplication',
+  description: 'A deterministic random dungeon map generator with connected rooms, corridors, doors, grid sizing, and local exports.',
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'How to generate a connected dungeon map',
+  step: howTo.map((item) => ({
+    '@type': 'HowToStep',
+    name: item.name,
+    text: item.text,
+  })),
+};
+
+export const content: DungeonMapGeneratorLocaleContent = {
+  slug: 'random-dungeon-map-generator',
+  title: 'Random Dungeon Map Generator for Tabletop Games',
+  description: 'Create reproducible dungeon, cavern, and Sci Fi maps with connected rooms, doors, grid controls, and PNG or SVG export.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Build a Playable Dungeon Map from a Reusable Seed', level: 2 },
+    { type: 'paragraph', html: 'A useful random dungeon map needs more than visual noise. Every chamber must be reachable, the grid must fit the intended play surface, and the result must be recoverable when a session moves between devices. This generator treats the seed and controls as a compact map specification. Keep the same seed, columns, rows, density, and architecture to reproduce the exact plan later.' },
+    { type: 'title', text: 'Choose Grid Dimensions for Print and Virtual Tabletops', level: 2 },
+    { type: 'paragraph', html: 'Start with the destination. A smaller grid is easier to print and produces a focused delve, while a larger grid leaves room for exploration, encounter staging, and optional branches. The exported image preserves square cells, so you can align it with the grid controls in a virtual tabletop instead of stretching the map by eye.' },
+    {
+      type: 'table',
+      headers: ['Grid size', 'Typical use', 'Density starting point', 'Planning note'],
+      rows: [
+        ['20 by 16', 'One shot location', '35 to 45', 'Fast to read and easy to print'],
+        ['36 by 26', 'Session dungeon', '45 to 55', 'Balanced room and corridor rhythm'],
+        ['52 by 38', 'Multi session complex', '50 to 65', 'More space for factions and optional routes'],
+      ],
+    },
+    { type: 'tip', title: 'Match the Map to the Encounter Scale', html: 'Count the cells required by the largest planned encounter before choosing the full map size. A large dungeon with undersized rooms can still feel cramped, while a compact plan with one generous chamber may support a memorable set piece.' },
+    { type: 'title', text: 'Read Floor Coverage as a Pacing Signal', level: 2 },
+    { type: 'paragraph', html: 'Floor coverage describes how much of the rectangular canvas is walkable. Lower coverage emphasizes uncertain movement and separation between rooms. Midrange coverage supports a steady expedition rhythm. High coverage creates a stronghold or facility where encounters can spill across connected spaces. It is not a difficulty score; it is a prompt for how the location may feel at the table.' },
+    {
+      type: 'list',
+      items: [
+        '<strong>Tense exploration:</strong> use the empty space to imply depth, isolation, or concealed areas.',
+        '<strong>Balanced expedition:</strong> alternate investigation rooms, connective passages, and encounter spaces.',
+        '<strong>Open stronghold:</strong> prepare sight lines, patrol routes, and encounters that can attract nearby groups.',
+      ],
+    },
+    { type: 'title', text: 'Turn a Neutral Layout into an Adventure Location', level: 2 },
+    { type: 'paragraph', html: 'The generated plan intentionally stops at architecture. Assign a purpose to each major room, then place clues, hazards, creatures, and treasure according to that purpose. Use doors as decision points rather than decoration. A locked door can advertise value, a broken door can reveal prior violence, and an open bulkhead can connect two encounters into one larger problem.' },
+    { type: 'tip', title: 'Preserve the Setup Before Stocking Rooms', html: 'Copy the map link or save the JSON setup before adding encounter notes. That gives the group a stable architectural reference and lets you regenerate a clean player version without exposing game master annotations.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
+};