@jjlmoya/utils-tabletop 1.28.0 → 1.30.0

package/src/tool/rpg-settlement-exploration-map-generator/dom-views.ts

@@ -0,0 +1,174 @@
+import type { Building, Point, SettlementMap, ServiceType } from './logic';
+import type { SettlementMapUI } from './ui';
+
+function serviceLabel(service: ServiceType, ui: SettlementMapUI): string {
+  const labels: Record<string, string> = { tavern: ui.serviceTavern, smithy: ui.serviceSmithy, temple: ui.serviceTemple, market: ui.serviceMarket, stable: ui.serviceStable, hall: ui.serviceHall };
+  return labels[service] ?? service;
+}
+
+function escapeSvgText(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[character] ?? character);
+}
+
+function roofSvg(building: Building, style: string): string {
+  const base = building.y + 0.39;
+  const left = building.x - 0.15;
+  const right = building.x + building.width + 0.15;
+  const peak = building.x + building.width / 2;
+  if (style === 'edo') return `<path class="rsm-house-roof" d="M${left} ${base}Q${building.x + 0.55} ${building.y - 0.05} ${peak} ${building.y + 0.08}Q${building.x + building.width - 0.55} ${building.y - 0.05} ${right} ${base}Z" />`;
+  if (style === 'sahelian') return `<path class="rsm-house-roof" d="M${building.x + 0.05} ${base}H${building.x + building.width - 0.05}V${building.y + 0.68}H${building.x + 0.05}Z" />`;
+  return `<polygon class="rsm-house-roof" points="${left},${base} ${peak},${building.y - (style === 'highland' ? 0.62 : 0.48)} ${right},${base}" />`;
+}
+
+function buildingDetails(building: Building, style: string): string {
+  if (style === 'timber') return `<path class="rsm-house-frame" d="M${building.x + 0.38} ${building.y + 0.5}V${building.y + building.height - 0.25}M${building.x + building.width - 0.38} ${building.y + 0.5}V${building.y + building.height - 0.25}M${building.x + 0.25} ${building.y + 0.72}H${building.x + building.width - 0.25}" />`;
+  if (style === 'edo') return `<path class="rsm-house-wood-slats" d="M${building.x + 0.42} ${building.y + 0.52}V${building.y + building.height - 0.25}M${building.x + 0.72} ${building.y + 0.52}V${building.y + building.height - 0.25}M${building.x + building.width - 0.72} ${building.y + 0.52}V${building.y + building.height - 0.25}M${building.x + building.width - 0.42} ${building.y + 0.52}V${building.y + building.height - 0.25}" />`;
+  if (style === 'stone' || style === 'medieval') return `<path class="rsm-house-masonry" d="M${building.x + 0.25} ${building.y + 1.05}H${building.x + building.width - 0.25}M${building.x + 0.25} ${building.y + 1.42}H${building.x + building.width - 0.25}M${building.x + 0.65} ${building.y + 0.7}V${building.y + 1.05}M${building.x + building.width - 0.65} ${building.y + 1.42}V${building.y + 1.78}" />`;
+  if (style === 'coastal') return `<path class="rsm-house-awning" d="M${building.x + 0.2} ${building.y + 0.42}H${building.x + building.width - 0.2}" />`;
+  if (style === 'sahelian') return `<path class="rsm-house-sunband" d="M${building.x + 0.25} ${building.y + 0.82}H${building.x + building.width - 0.25}" />`;
+  return `<path class="rsm-house-chimney" d="M${building.x + building.width - 0.8} ${building.y - 0.35}V${building.y + 0.2}H${building.x + building.width - 0.42}V${building.y - 0.25}" />`;
+}
+
+function getSignFontSize(size?: string): number {
+  if (size === 'town') return 1.05;
+  if (size === 'village') return 0.92;
+  return 0.84;
+}
+
+function serviceSignSvg(building: Building, map: SettlementMap, service: string): string {
+  if (!service) return '';
+  const signFontSize = getSignFontSize(map.config.size);
+  const signWidth = Math.min(8, Math.max(2.1, service.length * signFontSize * 0.58 + 0.72));
+  const signX = building.x + building.width / 2 - signWidth / 2;
+  const signHeight = signFontSize + 0.34;
+  const signY = building.y - signHeight - 0.58;
+  return `<g class="rsm-service-sign rsm-service-sign-${map.config.size}"><path class="rsm-service-stem" d="M${building.x + building.width / 2} ${signY + signHeight}V${building.y - 0.49}" /><rect class="rsm-service-plaque" x="${signX}" y="${signY}" width="${signWidth}" height="${signHeight}" rx="0.12" /><text class="rsm-building-glyph" x="${building.x + building.width / 2}" y="${signY + signHeight / 2}" font-size="${signFontSize}" dominant-baseline="middle">${service}</text></g>`;
+}
+
+function buildingSvg(building: Building, map: SettlementMap, ui: SettlementMapUI): string {
+  const style = map.config.style ?? 'medieval';
+  const roof = roofSvg(building, style);
+  const windowY = building.y + 0.82;
+  const leftWindowX = building.x + 0.48;
+  const rightWindowX = building.x + building.width - 0.86;
+  const doorX = building.x + building.width / 2 - 0.23;
+  const doorY = building.y + building.height - 0.9;
+  const windows = `<rect class="rsm-house-window" x="${leftWindowX}" y="${windowY}" width="0.38" height="0.42" rx="0.05" />${building.width > 2.5 ? `<rect class="rsm-house-window" x="${rightWindowX}" y="${windowY}" width="0.38" height="0.42" rx="0.05" />` : ''}`;
+  const details = buildingDetails(building, style);
+  const service = building.service ? escapeSvgText(serviceLabel(building.service, ui)) : '';
+  const title = building.service ? `<title>${serviceLabel(building.service, ui)}</title>` : '<title>Home</title>';
+  const serviceMark = serviceSignSvg(building, map, service);
+  return `<g class="rsm-building rsm-house-style-${style}" data-building-id="${building.id}" data-cell-x="${building.x}" data-cell-y="${building.y}">${title}<rect class="rsm-house-body" x="${building.x + 0.12}" y="${building.y + 0.35}" width="${building.width - 0.24}" height="${building.height - 0.35}" rx="0.18" />${roof}${details}${windows}<rect class="rsm-house-door" x="${doorX}" y="${doorY}" width="0.46" height="0.8" rx="0.06" />${serviceMark}</g>`;
+}
+
+function waterComponents(points: Point[]): Point[][] {
+  const remaining = new Set(points.map((point) => `${point.x},${point.y}`));
+  const components: Point[][] = [];
+  while (remaining.size) {
+    const first = [...remaining][0]!;
+    const queue = [first.split(',').map(Number) as [number, number]];
+    const component: Point[] = [];
+    remaining.delete(first);
+    while (queue.length) {
+      const [x, y] = queue.shift()!;
+      component.push({ x, y });
+      [{ x: x + 1, y }, { x: x - 1, y }, { x, y: y + 1 }, { x, y: y - 1 }].forEach((neighbor) => {
+        const key = `${neighbor.x},${neighbor.y}`;
+        if (remaining.delete(key)) queue.push([neighbor.x, neighbor.y]);
+      });
+    }
+    components.push(component);
+  }
+  return components;
+}
+
+function waterKind(component: Point[]): string {
+  if (component.length <= 2) return 'river';
+  if (component.length === 3) return 'pond';
+  return 'lake';
+}
+
+function waterSvg(map: SettlementMap): string {
+  return waterComponents(map.water).map((component) => `<g class="rsm-water-component rsm-water-${waterKind(component)}" data-water-size="${component.length}">${component.map((point) => `<rect x="${point.x}" y="${point.y}" width="1" height="1" />`).join('')}</g>`).join('');
+}
+
+interface RoadCell { point: Point; neighbors: Point[] }
+
+function roadCell(cells: Map<string, RoadCell>, point: Point): RoadCell {
+  const key = `${point.x},${point.y}`;
+  const existing = cells.get(key);
+  if (existing) return existing;
+  const created = { point, neighbors: [] };
+  cells.set(key, created);
+  return created;
+}
+
+function roadNetwork(map: SettlementMap): Map<string, RoadCell> {
+  const cells = new Map<string, RoadCell>();
+  map.paths.forEach((path) => {
+    path.points.forEach((point) => roadCell(cells, point));
+    path.points.slice(1).forEach((point, index) => {
+      const previous = path.points[index]!;
+      roadCell(cells, previous).neighbors.push(point);
+      roadCell(cells, point).neighbors.push(previous);
+    });
+  });
+  return cells;
+}
+
+function roadCellPath(cell: RoadCell): string {
+  const center = `${cell.point.x + 0.5},${cell.point.y + 0.5}`;
+  if (!cell.neighbors.length) return `M${center}h0`;
+  return cell.neighbors.map((neighbor) => `M${center}L${neighbor.x + 0.5},${neighbor.y + 0.5}`).join('');
+}
+
+function pathSvg(map: SettlementMap): string {
+  return [...roadNetwork(map).values()].map((cell) => `<path class="rsm-road-base" d="${roadCellPath(cell)}" /><path class="rsm-road-line" d="${roadCellPath(cell)}" />`).join('');
+}
+
+function getTreeStyle(env: string, style?: string): string {
+  if (env === 'coast') return 'coastal';
+  if (env === 'mountain') return 'highland';
+  return style ?? 'medieval';
+}
+
+function treeSvg(point: Point, map: SettlementMap): string {
+  const x = point.x + 0.5;
+  const y = point.y + 0.5;
+  const style = getTreeStyle(map.config.environment, map.config.style);
+  const edoBlossom = (point.x * 7 + point.y * 11) % 3 === 0 ? 'green' : 'pink';
+  const shapes: Record<string, string> = {
+    coastal: '<path d="M0 .65V.05" /><path d="M0 .08C-.16-.2-.58-.27-.62-.52M0 .08C.16-.2.58-.27.62-.52M0 .08C-.05-.22.1-.5.22-.7" />',
+    highland: '<path d="M0 .65V.1" /><path d="M-.48 .15L0-.72 .48 .15Z" /><path d="M-.34-.18L0-.88 .34-.18Z" />',
+    edo: '<path d="M0 .65V.08" /><path d="M-.52 .08Q0-.48 .52 .08Q0 .27-.52 .08Z" /><path d="M-.34-.22Q0-.68 .34-.22Q0-.08-.34-.22Z" />',
+    sahelian: '<path d="M0 .65V.02" /><path d="M-.65 .02Q0-.48 .65 .02Q0 .2-.65 .02Z" />',
+    medieval: '<path d="M0 .65V.1" /><path d="M-.55 .14L0-.58 .55 .14Q0 .28-.55 .14Z" /><path d="M-.34-.15L0-.72 .34-.15Z" />',
+    timber: '<path d="M0 .65V.1" /><path d="M-.5 .12Q0-.48 .5 .12Q0 .28-.5 .12Z" /><path d="M-.3-.2Q0-.7 .3-.2Q0-.05-.3-.2Z" />',
+    stone: '<path d="M0 .65V.1" /><path d="M-.5 .12Q0-.5 .5 .12Q0 .28-.5 .12Z" /><path d="M-.3-.2Q0-.7 .3-.2Q0-.05-.3-.2Z" />',
+  };
+  const blossomClass = style === 'edo' ? ` rsm-tree-edo-${edoBlossom}` : '';
+  return `<g class="rsm-tree rsm-tree-${style}${blossomClass}" transform="translate(${x} ${y})">${shapes[style] ?? shapes.medieval}</g>`;
+}
+
+function wildSvg(map: SettlementMap): string { return map.wild.map((point) => treeSvg(point, map)).join(''); }
+
+function plazaSvg(map: SettlementMap): string {
+  const plaza = map.plaza ?? { x: Math.floor(map.width / 2) - 3, y: Math.floor(map.height / 2) - 2, width: 6, height: 4 };
+  return `<g class="rsm-plaza"><rect x="${plaza.x}" y="${plaza.y}" width="${plaza.width}" height="${plaza.height}" rx="0.3" /><path d="M${plaza.x + 1} ${plaza.y + 1}H${plaza.x + plaza.width - 1}M${plaza.x + 1} ${plaza.y + plaza.height - 1}H${plaza.x + plaza.width - 1}" /></g>`;
+}
+
+function gridSvg(map: SettlementMap): string {
+  const vertical = Array.from({ length: map.width + 1 }, (_, index) => `<path d="M${index} 0V${map.height}" />`).join('');
+  const horizontal = Array.from({ length: map.height + 1 }, (_, index) => `<path d="M0 ${index}H${map.width}" />`).join('');
+  return `<g class="rsm-grid">${vertical}${horizontal}</g>`;
+}
+
+function environmentClass(environment: string): string { return `rsm-environment-${environment}`; }
+
+export function buildMapSvg(map: SettlementMap, ui: SettlementMapUI): string {
+  return `<svg class="rsm-map-svg ${environmentClass(map.config.environment)}" data-settlement-map viewBox="0 0 ${map.width} ${map.height}" role="img" aria-label="Settlement map"><rect class="rsm-paper" x="0" y="0" width="${map.width}" height="${map.height}" rx="0.5" />${gridSvg(map)}${waterSvg(map)}${plazaSvg(map)}${wildSvg(map)}${pathSvg(map)}${map.buildings.map((building) => buildingSvg(building, map, ui)).join('')}</svg>`;
+}
+
+export function updateMapHost(host: HTMLElement, map: SettlementMap, ui: SettlementMapUI): void { host.innerHTML = buildMapSvg(map, ui); }
+export function svgToDataUrl(svg: string): string { return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`; }
+export function downloadFile(content: string | Blob, filename: string, type?: string): void { const blob = typeof content === 'string' ? new Blob([content], { type: type ?? 'text/plain' }) : content; const url = URL.createObjectURL(blob); const anchor = document.createElement('a'); anchor.href = url; anchor.download = filename; anchor.click(); URL.revokeObjectURL(url); }

package/src/tool/rpg-settlement-exploration-map-generator/editor.ts

@@ -0,0 +1,85 @@
+import type { EditTool } from './logic';
+
+interface CellPoint {
+  x: number;
+  y: number;
+}
+
+type EditHandler = (point: CellPoint, tool: EditTool) => void;
+
+function svgCell(event: MouseEvent, svg: SVGSVGElement): CellPoint | null {
+  const point = svg.createSVGPoint();
+  point.x = event.clientX;
+  point.y = event.clientY;
+  const matrix = svg.getScreenCTM();
+  if (!matrix) return null;
+  const local = point.matrixTransform(matrix.inverse());
+  return { x: Math.floor(local.x), y: Math.floor(local.y) };
+}
+
+function openContextMenu(root: HTMLElement, menu: HTMLElement, event: MouseEvent): CellPoint | null {
+  const svg = (event.target as Element).closest<SVGSVGElement>('[data-settlement-map]');
+  if (!svg || !root.querySelector<HTMLElement>('.rsm-map-frame')) return null;
+  const cell = svgCell(event, svg);
+  if (!cell) return null;
+  const edge = 8;
+  const gap = 6;
+  menu.hidden = false;
+  const menuBounds = menu.getBoundingClientRect();
+  const left = Math.min(Math.max(edge, event.clientX), window.innerWidth - menuBounds.width - edge);
+  const opensBelow = event.clientY + gap + menuBounds.height <= window.innerHeight - edge;
+  const preferredTop = opensBelow ? event.clientY + gap : event.clientY - menuBounds.height - gap;
+  const top = Math.min(Math.max(edge, preferredTop), window.innerHeight - menuBounds.height - edge);
+  menu.style.left = `${left}px`;
+  menu.style.top = `${top}px`;
+  menu.querySelector<HTMLButtonElement>('button')?.focus();
+  return cell;
+}
+
+interface PointerOptions {
+  host: HTMLElement;
+  root: HTMLElement;
+  menu: HTMLElement;
+  flags: PointerFlags;
+  onOpen: (cell: CellPoint | null) => void;
+}
+
+function bindPointerEvents(opts: PointerOptions): void {
+  let timer: number | undefined;
+  opts.host.addEventListener('pointerdown', (event) => {
+    if (event.pointerType === 'mouse') return;
+    timer = window.setTimeout(() => {
+      opts.flags.ignoreNextContext = true;
+      opts.flags.ignoreNextClick = true;
+      opts.onOpen(openContextMenu(opts.root, opts.menu, event));
+    }, 520);
+  });
+  const cancel = () => { if (timer) window.clearTimeout(timer); timer = undefined; };
+  opts.host.addEventListener('pointerup', cancel);
+  opts.host.addEventListener('pointercancel', cancel);
+  opts.host.addEventListener('pointerleave', cancel);
+}
+
+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: CellPoint | null = null;
+  const flags: PointerFlags = { ignoreNextContext: false, ignoreNextClick: false };
+  host.addEventListener('contextmenu', (event) => {
+    event.preventDefault();
+    if (flags.ignoreNextContext) { flags.ignoreNextContext = false; return; }
+    selected = openContextMenu(root, menu, event);
+  });
+  bindPointerEvents({ host, root, menu, flags, onOpen: (cell) => { selected = cell; } });
+  menu.querySelectorAll<HTMLButtonElement>('[data-context-tool]').forEach((btn) => btn.addEventListener('click', () => {
+    if (selected) onEdit(selected, btn.dataset.contextTool as EditTool);
+    menu.hidden = true;
+  }));
+  document.addEventListener('click', (event) => {
+    if (flags.ignoreNextClick) { flags.ignoreNextClick = false; return; }
+    if (!menu.contains(event.target as Node)) menu.hidden = true;
+  });
+  window.addEventListener('resize', () => { menu.hidden = true; });
+  window.addEventListener('scroll', () => { menu.hidden = true; }, true);
+}

package/src/tool/rpg-settlement-exploration-map-generator/entry.ts

@@ -0,0 +1,27 @@
+import type { TabletopToolEntry, ToolLocaleContent } from '../../types';
+import type { SettlementMapUI } from './ui';
+
+export type { SettlementMapUI } from './ui';
+export type SettlementMapLocaleContent = ToolLocaleContent<SettlementMapUI>;
+
+export const rpgSettlementExplorationMapGenerator: TabletopToolEntry<SettlementMapUI> = {
+  id: 'rpg-settlement-exploration-map-generator',
+  icons: { bg: 'mdi:map-marker-radius-outline', fg: 'mdi:home-city-outline' },
+  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/rpg-settlement-exploration-map-generator/evaluator.ts

@@ -0,0 +1,8 @@
+import type { SettlementMap } from './logic';
+import type { SettlementMapUI } from './ui';
+
+export interface SettlementEvaluation { buildingCount: number; pathCount: number; serviceCount: number; waterCount: number; badge: string; terrainLabel: string }
+
+export function evaluateSettlement(map: SettlementMap, ui: SettlementMapUI): SettlementEvaluation {
+  return { buildingCount: map.buildings.length, pathCount: map.paths.length, serviceCount: map.buildings.filter((building) => building.service).length, waterCount: map.water.length, badge: ui.readyBadge, terrainLabel: ui[map.config.environment] ?? map.config.environment };
+}

package/src/tool/rpg-settlement-exploration-map-generator/i18n/de.ts

@@ -0,0 +1,152 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { SettlementMapLocaleContent, SettlementMapUI } from '../entry';
+
+const ui: SettlementMapUI = {
+  intro: 'Gestalten Sie eine erkundbare Siedlungskarte für Ihre Rollenspiele. Wählen Sie Landschaft, Siedlungstyp und Baustil und passen Sie Zellen per Rechtsklick an.',
+  seedLabel: 'Startwert und Dorfname',
+  seedHint: 'Der Startwert erzeugt ein deterministisches Layout für Straßen und Gebäude.',
+  randomSeed: 'Neuer Name',
+  environmentLabel: 'Landschaft',
+  forest: 'Wald',
+  plains: 'Ebene',
+  coast: 'Küste',
+  river: 'Fluss',
+  mountain: 'Gebirge',
+  styleLabel: 'Architekturstil',
+  styleHint: 'Ändert Dächer, Materialien, Fassaden und regionale Vegetation.',
+  styleTimber: 'Fachwerk',
+  styleStone: 'Stein',
+  styleCoastal: 'Küstenstil',
+  styleHighland: 'Hochland',
+  styleMedieval: 'Mittelalter',
+  styleEdo: 'Edo',
+  styleSahelian: 'Sahel',
+  sizeLabel: 'Siedlungsgröße',
+  hamlet: 'Weiler',
+  hamletHint: 'Kleine Raststätte',
+  village: 'Dorf',
+  villageHint: 'Lokaler Stützpunkt',
+  town: 'Stadt',
+  townHint: 'Belebter Knotenpunkt',
+  homesLabel: 'Wohnhäuser',
+  homesHint: 'Passen Sie die Anzahl der Häuser an die gewählte Grundfläche an.',
+  servicesLabel: 'Gebäude und Orte',
+  serviceListHint: 'Wählen Sie Vorlagen oder fügen Sie eigene Wahrzeichen hinzu.',
+  newServicePlaceholder: 'Ort oder Dienst hinzufügen',
+  addService: 'Hinzufügen',
+  removeService: 'Entfernen',
+  serviceTavern: 'Taverne',
+  serviceSmithy: 'Schmiede',
+  serviceTemple: 'Tempel',
+  serviceMarket: 'Markt',
+  serviceStable: 'Stallung',
+  serviceHall: 'Rathaus',
+  generate: 'Karte neu erzeugen',
+  mapRegionLabel: 'Bearbeitbare RPG Siedlungskarte',
+  mapSummary: 'Siedlungsplan',
+  buildings: 'Gebäude',
+  paths: 'Wege',
+  services: 'Dienste',
+  terrain: 'Wasser',
+  legendLabel: 'Kartenlegende',
+  legendHome: 'Haus',
+  legendService: 'Dienst',
+  legendPath: 'Weg',
+  legendWater: 'Wasser',
+  legendWild: 'Wald',
+  editLabel: 'Direkte Kartenbearbeitung',
+  toolSelect: 'Inspektion',
+  toolBuilding: 'Gebäude',
+  toolPath: 'Weg',
+  toolWater: 'Wasser',
+  toolTree: 'Baum',
+  toolErase: 'Löschen',
+  serviceSelectLabel: 'Neues Gebäudesymbol',
+  clickHint: 'Rechtsklick oder langes Drücken zum Bearbeiten einer Zelle.',
+  selectedHint: 'Zelle ausgewählt bei',
+  shareLink: 'Link kopieren',
+  linkCopied: 'Link in Zwischenablage kopiert',
+  exportPng: 'PNG',
+  exportSvg: 'SVG',
+  exportJson: 'JSON speichern',
+  importJson: 'JSON öffnen',
+  importError: 'Datei ist keine gültige Siedlungskarte.',
+  mapData: 'Kartendaten',
+  readyBadge: 'Bereit zur Erkundung',
+  serviceNone: 'Kein Symbol',
+  contextMenuLabel: 'Zellenaktionen',
+  contextInspect: 'Zelle prüfen',
+  contextBuilding: 'Gebäude bauen',
+  contextPath: 'Weg anlegen',
+  contextWater: 'Wasser zeichnen',
+  contextTree: 'Baum pflanzen',
+  contextErase: 'Zelle leeren',
+};
+
+const faq = [
+  { question: 'Was erzeugt dieser RPG Siedlungskartengenerator?', answer: 'Er erstellt reproduzierbare Übersichtskarten für Weiler, Dörfer und Städte mit Gebäuden, Wegen, Gewässern und Wahrzeichen für Pen and Paper Rollenspiele.' },
+  { question: 'Verändert der Startwert das Layout tatsächlich?', answer: 'Ja. Der Startwert steuert die Anordnung von Straßen und Häusern deterministisch. Der gleiche Wert erzeugt exakt dieselbe Startkarte.' },
+  { question: 'Welche Siedlungsgrößen stehen zur Auswahl?', answer: 'Weiler, Dorf und Stadt bieten unterschiedliche Maße und Gebäudezahlen.' },
+  { question: 'Kann der Baustil angepasst werden?', answer: 'Ja. Zur Wahl stehen Mittelalter, Edo, Sahel, Fachwerk, Stein, Küstenstil und Hochland.' },
+  { question: 'Kann die Landschaft gewählt werden?', answer: 'Ja. Sie können Wald, Ebene, Küste, Fluss oder Gebirge festlegen.' },
+  { question: 'Wie werden wichtige Gebäude platziert?', answer: 'Dienste wie Taverne, Schmiede oder Rathaus werden mit gewichteter Logik im Zentrum oder am Rand platziert.' },
+  { question: 'Können eigene Wahrzeichen hinzugefügt werden?', answer: 'Ja. Eigene Orte können ergänzt und im Browser sowie in Freigabelinks gespeichert werden.' },
+  { question: 'Kann die Karte direkt bearbeitet werden?', answer: 'Ja. Per Rechtsklick oder langem Drücken lässt sich jede Zelle anpassen oder löschen.' },
+  { question: 'Wie verhalten sich Wege und Wasser beim Bearbeiten?', answer: 'Wege verbinden sich automatisch an Kreuzungen und Wasserzellen fügen sich zu Flüssen oder Seen zusammen.' },
+  { question: 'Wie kann eine Karte geteilt werden?', answer: 'Über den Freigabelink oder als JSON Datei bleibt die Karte vollständig bearbeitbar.' },
+  { question: 'Welche Exportformate sind am besten geeignet?', answer: 'PNG für schnelle Bilder, SVG für Druck und Vektoren sowie JSON für vollständige Speicherung.' },
+];
+
+const howTo = [
+  { name: 'Startwert wählen', text: 'Nutzen Sie den zufälligen Namen oder geben Sie einen eigenen Begriff ein.' },
+  { name: 'Umgebung und Stil festlegen', text: 'Wählen Sie Landschaft und Architekturstil passend zur Spielwelt.' },
+  { name: 'Größe bestimmen', text: 'Wählen Sie zwischen Weiler, Dorf und Stadt.' },
+  { name: 'Orte platzieren', text: 'Aktivieren Sie wichtige Vorlagen oder fügen Sie eigene Wahrzeichen hinzu.' },
+  { name: 'Karte anpassen', text: 'Bearbeiten Sie einzelne Zellen direkt über das Kontextmenü.' },
+  { name: 'Speichern und teilen', text: 'Nutzen Sie den Freigabelink oder exportieren Sie als PNG, SVG 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: 'RPG Siedlungskarten Generator', operatingSystem: 'All', applicationCategory: 'GameApplication', description: 'Karten-Generator für Rollenspielsiedlungen mit deterministischen Werten und Bearbeitungsmodus.' };
+const howToSchema: WithContext<HowTo> = { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Wie man eine RPG Siedlungskarte erstellt', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) };
+
+const schemas: WithContext<SoftwareApplication | FAQPage | HowTo>[] = [faqSchema, appSchema, howToSchema];
+
+export const content: SettlementMapLocaleContent = {
+  slug: 'rpg-siedlungs-erkundungskarten-generator',
+  title: 'RPG Siedlungskarten Generator für Rollenspiele',
+  description: 'Erstellen Sie RPG Siedlungskarten für Weiler, Dörfer und Städte mit verschiedenen Baustilen, Umgebungen und Zelleneditor.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Lebendige Siedlungskarten für Rollenspiele Erzeugen', level: 2 },
+    { type: 'paragraph', html: 'Erschaffen Sie Siedlungen, die Ihren Spielern echte Orte zum Erkunden bieten und nicht nur eine Ansammlung isolierter Häuser darstellen. Dieser browserbasierte Kartengenerator für Pen-and-Paper-Rollenspiele erstellt Übersichtskarten, auf denen Wohngebäude, Straßennetze, Marktplätze, Gewässer und Baumgruppen harmonisch zusammenwirken. Nutzen Sie das Werkzeug für spontane Zwischenstopps im Dorf, von Fraktionen geprägte Städte, abgelegene Weiler oder als ersten Entwurf für Orte, die Sie im Laufe einer Kampagne weiterentwickeln möchten.' },
+    { type: 'title', text: 'Deterministische Startwerte für Wiederholbare Karten', level: 2 },
+    { type: 'paragraph', html: 'Jede erzeugte Siedlung basiert auf einem einprägsamen Namens-Startwert. Dieser Wert steuert deterministisch das gesamte Layout, einschließlich Straßenführung, Gebäudeabständen, Dienstzuweisungen und der umgebenden Vegetation. Wenn Sie denselben Startwert und dieselben Optionen erneut eingeben, wird die exakt gleiche Karte rekonstruiert, was sich hervorragend für Spielleiternotizen und spätere Spielrunden eignet.' },
+    { type: 'list', items: ['Unterschiedliche Startwerte erzeugen neue Siedlungsmuster innerhalb des gewählten Typs.', 'Das Ergebnis bleibt vollständig reproduzierbar statt unkontrolliert zufällig zu sein.', 'Die Siedlung behält ihre charakteristische Struktur als Weiler, Dorf oder Stadt bei.', 'Der gleiche Startwert kann als stabile Basis für die gemeinsame Kampagnenplanung geteilt werden.'] },
+    { type: 'title', text: 'Unterschiedliche Maßstäbe vom Weiler bis zur Stadt', level: 2 },
+    { type: 'paragraph', html: 'Der Größenwähler ist keine bloße optische Skalierung. Weiler, Dörfer und Städte nutzen unterschiedliche Bauarten, Dichten und Erwartungen an Dienstleistungen. Ein Weiler bleibt mit unter zehn Häusern überschaubar, während eine Stadt Raum für längere Wege, mehr Gebäude und eine ausgeprägte zentrale Struktur bietet.' },
+    { type: 'table', headers: ['Grundfläche', 'Häuserzahl', 'Charakter', 'Bester Einsatz in der Kampagne'], rows: [['Weiler', '3 bis 18', 'Klein, spärlich und auf einen Blick erfassbar', 'Rastort am Wegesrand oder isolierte Gemeinschaft'], ['Dorf', '4 bis 28', 'Lokales Zentrum mit Wegen und Wahrzeichen', 'Wiederkehrende Heimatbasis oder Fraktionsknoten'], ['Stadt', '6 bis 42', 'Breites Netzwerk mit vielen Diensten und Wegen', 'Regionales Handelszentrum oder Ermittlungsort']] },
+    { type: 'title', text: 'Sieben Ausprägbare Architekturstile', level: 2 },
+    { type: 'paragraph', html: 'Verleihen Sie der Siedlung vor der Platzierung von Details eine eigene Identität. Fachwerk, Stein, Küstenstil, Hochland, Mittelalter, Edo und Sahel verändern Dächer, Wandfarben, Fenster, Türen und Strukturen. Auch die Baumarten passen sich der Region an, von Palmen an der Küste bis hin zu Nadelbäumen im Hochland.' },
+    { type: 'list', items: ['Mittelalter und Fachwerk passen zu Märchen dörfern und Waldgemeinschaften.', 'Stein und Hochland eignen sich für rauere, befestigte oder bergelegene Orte.', 'Küstenstil bringt eine maritime Note mit passender Küstenvegetation ein.', 'Edo verleiht Straßen und Häusern eine historische ostasiatische Silhouette.', 'Sahel bietet trockenen Regionen eine authentische Architektur und Farbpalette.'] },
+    { type: 'title', text: 'Intelligente Verteilung Wichtiger Gebäude', level: 2 },
+    { type: 'paragraph', html: 'Wichtige Orte wie Taverne, Schmiede, Tempel, Markt, Stallung und Rathaus werden mit gewichteter Logik platziert. Öffentliche Gebäude neigen zum Zentrum, während Ställe und Schmieden eher an den Außenwegen liegen. Zudem können Sie eigene Wahrzeichen definieren, die mit vollständigem Namen auf Schildern über den Dächern angezeigt werden.' },
+    { type: 'title', text: 'Die Landschaft als Teil der Geschichte', level: 2 },
+    { type: 'paragraph', html: 'Wählen Sie Wald, Ebene, Küste, Fluss oder Gebirge und betten Sie die Siedlung in diese Umgebung ein. Das Gelände verleiht dem Ort Kontext: Ein Fluss kann die Anreise prägen, während ein dichter Wald verborgene Pfade verbergen kann.' },
+    { type: 'title', text: 'Direkte Bearbeitung Zelle für Zelle', level: 2 },
+    { type: 'paragraph', html: 'Die erzeugte Karte ist ein starker Ausgangspunkt, den Sie über das Kontextmenü per Rechtsklick oder langem Drücken individuell anpassen können. Fügen Sie Gebäude, Wege, Wasserstellen oder Bäume hinzu oder löschen Sie unerwünschte Elemente direkt auf der Karte.' },
+    { type: 'list', items: ['Fügen Sie fehlende Häuser, Brücken oder Wachtürme hinzu.', 'Passen Sie Wege ohne externe Zeichenprogramme direkt im Browser an.', 'Behalten Sie manuelle Änderungen im gleichen Kartenstatus bei.', 'Funktioniert nahtlos auf PCs sowie Touch-Geräten.'] },
+    { type: 'title', text: 'Reaktive Wege und Wasserflächen', level: 2 },
+    { type: 'paragraph', html: 'Wege bilden saubere Kreuzungen, wenn mehrere Pfade aufeinandertreffen. Das Zeichnen von Wasser ist ebenfalls reaktiv: Benachbarte Wasserzellen verbinden sich automatisch zu Flüssen, Teichen oder größeren Seen.' },
+    { type: 'title', text: 'Teilen und Wiederverwenden von Karten', level: 2 },
+    { type: 'paragraph', html: 'Kopieren Sie den Freigabelink, um die vollständige bearbeitbare Karte an Mitspieler oder Spielleiter zu senden. Alle Einstellungen, Gebäude, Wege und manuellen Änderungen bleiben dabei erhalten. Alternativ lässt sich der Zustand als JSON sichern.' },
+    { type: 'title', text: 'Exportformate für Jeden Einsatzzweck', level: 2 },
+    { type: 'table', headers: ['Format', 'Geeignet für', 'Erhaltene Inhalte'], rows: [['PNG', 'Virtuelle Spieltische und schnelle Handouts', 'Sofort anzeigbares Bild der aktuellen Karte'], ['SVG', 'Druck und Vektorbearbeitung', 'Scharfe skaliersbare Vektorgrafik für große Pläne'], ['JSON', 'Kampagnenarchive und spätere Editiermodi', 'Vollständiger bearbeitbarer Zustand der Siedlung']] },
+    { type: 'tip', title: 'Praktischer Ablauf für den Spielabend', html: 'Wählen Sie zuerst Startwert, Grundfläche und Stil. Fügen Sie wichtige Wahrzeichen hinzu und verfeinern Sie die Karte anschließend mit dem Zelleneditor vor Beginn der Spielrunde.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};

package/src/tool/rpg-settlement-exploration-map-generator/i18n/en.ts

@@ -0,0 +1,63 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { SettlementMapLocaleContent, SettlementMapUI } from '../entry';
+
+const ui: SettlementMapUI = {
+  intro: 'Lay out a place worth exploring. Pick the landscape, settlement type, and building character, then correct the generated map with a right click or long press.', seedLabel: 'Village name seed', seedHint: 'The seed chooses a different deterministic layout pattern within the selected settlement type.', randomSeed: 'Create a new village name', environmentLabel: 'Landscape', forest: 'Forest', plains: 'Plains', coast: 'Coast', river: 'River', mountain: 'Mountain', styleLabel: 'Village character', styleHint: 'Choose an architectural identity: era, geography, roofs, materials, and details all change.', styleTimber: 'Timber', styleStone: 'Stone', styleCoastal: 'Coastal', styleHighland: 'Highland', styleMedieval: 'Medieval', styleEdo: 'Edo', styleSahelian: 'Sahelian', sizeLabel: 'Settlement footprint', hamlet: 'Hamlet', hamletHint: 'Small stop', village: 'Village', villageHint: 'Local base', town: 'Town', townHint: 'Busy hub', homesLabel: 'Homes', homesHint: 'Each footprint has its own starting size and core services. Fine tune the homes after choosing one.', servicesLabel: 'Services to place', serviceListHint: 'Choose presets or add a named landmark for this settlement. Custom services stay in this browser.', newServicePlaceholder: 'Add a service or landmark', addService: 'Add', removeService: 'Remove', serviceTavern: 'Tavern', serviceSmithy: 'Smithy', serviceTemple: 'Temple', serviceMarket: 'Market', serviceStable: 'Stable', serviceHall: 'Hall', generate: 'Regenerate map', mapRegionLabel: 'Editable RPG settlement map', mapSummary: 'Village plan', buildings: 'Buildings', paths: 'Paths', services: 'Services', terrain: 'Water cells', legendLabel: 'Map legend', legendHome: 'Home', legendService: 'Service mark', legendPath: 'Road', legendWater: 'Water', legendWild: 'Trees', editLabel: 'Edit the map directly', toolSelect: 'Inspect', toolBuilding: 'Building', toolPath: 'Road', toolWater: 'Water', toolTree: 'Tree', toolErase: 'Erase', serviceSelectLabel: 'New building mark', clickHint: 'Right click or long press the plan to edit a cell.', selectedHint: 'Cell selected at', shareLink: 'Copy share link', linkCopied: 'Share link copied', exportPng: 'PNG', exportSvg: 'SVG', exportJson: 'Save JSON', importJson: 'Open JSON', importError: 'That file is not a valid settlement map.', mapData: 'Map data', readyBadge: 'Ready to explore', serviceNone: 'No mark', contextMenuLabel: 'Map cell actions', contextInspect: 'Inspect cell', contextBuilding: 'Add building', contextPath: 'Add road', contextWater: 'Add water', contextTree: 'Add tree', contextErase: 'Erase cell',
+};
+
+const faq = [
+  { question: 'What does this RPG settlement map generator create?', answer: 'It creates a reproducible overhead exploration map for a hamlet, village, or town. The map combines a settlement footprint with homes, roads, services, plazas, water, trees, and the surrounding landscape, so the place feels like part of a wider region instead of a disconnected pile of buildings. It is designed for RPG worldbuilding, campaign preparation, travel scenes, clues, factions, and points of interest rather than tactical combat grids.' },
+  { question: 'Does the seed really change the settlement layout?', answer: 'Yes. The seed is not only a name. It drives a deterministic layout variant inside the selected settlement type, so two seeds can produce different road patterns, house positions, spacing, service assignments, and wild growth while still respecting the urban grammar of a hamlet, village, or town. Reusing the same seed and settings rebuilds the same starting map.' },
+  { question: 'Which settlement sizes are available?', answer: 'Hamlet, village, and town each have a different footprint and starting logic. Hamlets support small communities, villages create a more developed local base, and towns make room for denser routes, more services, and broader exploration. The home count reacts to the selected footprint, while still allowing a smaller or larger result within that type range.' },
+  { question: 'Can I choose the architectural style of the settlement?', answer: 'Yes. Choose Timber, Stone, Coastal, Highland, Medieval, Edo, or Sahelian. The style changes the visual language of houses, including roof shape, wall treatment, doors, windows, texture, colour accents, and the way nearby trees are drawn. It gives the same settlement generator a different regional or historical identity.' },
+  { question: 'Can I choose the landscape around the settlement?', answer: 'Yes. Choose forest, plains, coast, river, or mountain. The landscape remains the visual context around the settlement and influences water, vegetation, and terrain details, so the village does not always become the only thing on the map. Forest and wild growth can occupy the surrounding space while the settlement stays readable at the centre.' },
+  { question: 'How are services placed?', answer: 'Built-in services include Tavern, Smithy, Temple, Market, Stable, and Hall, and you can add named custom services or landmarks. The generator assigns them with deterministic weights instead of always attaching them to the first few houses: Hall and similar civic services tend toward the centre, while Stable and Smithy tend toward the edge and outer roads, with controlled variation so every settlement does not follow the exact same pattern. Service labels use the full name and appear on readable signs above the building.' },
+  { question: 'Can I add my own services and keep them in a shared map?', answer: 'Yes. Add a custom service or landmark to the dynamic list and it is saved in local storage for later maps. Custom entries can be removed whenever you want, while the built-in service presets remain available. When you copy a share link or save JSON, the custom service catalog and the marks already placed on the map travel with the settlement.' },
+  { question: 'Can I edit the generated RPG map directly?', answer: 'Yes. Right-click a map cell on desktop or long-press it on touch devices to open the contextual editor. From there you can inspect the cell, add a building, draw a road, paint water, add a tree, or erase it. The contextual menu repositions itself when it would otherwise be clipped by the map or viewport.' },
+  { question: 'How do roads and water behave when I edit them?', answer: 'Roads are built as a connected graph with clean junctions, including places where three or four paths meet. Painting water affects the exact selected cell. Adjacent water cells join visually into a river, a small pond, or a broader lake shape as the component grows, so manual edits respond to their neighbours instead of leaving isolated marks.' },
+  { question: 'How can I share or reproduce a settlement for another session?', answer: 'Copy the share link to send a complete editable settlement to another person. It preserves the seed, landscape, footprint, home count, architectural style, selected services, custom service list, generated buildings, roads, water, trees, and manual edits. The same state can also be saved as JSON and reopened later.' },
+  { question: 'Which export should I use for a campaign handout?', answer: 'PNG is convenient for notes, virtual tabletops, and quick sharing. SVG stays sharp for printing and further vector editing. JSON is the full editable map state, so it is the best option when you want to preserve every generated and manually painted detail rather than only export a picture.' },
+];
+const howTo = [
+  { name: 'Start with a memorable seed', text: 'Use the generated compound settlement name or type your own seed. The seed controls a repeatable layout variation, so it changes the arrangement without abandoning the selected settlement type.' },
+  { name: 'Choose the landscape and character', text: 'Select forest, plains, coast, river, or mountain, then choose an architectural identity such as Medieval, Edo, Sahelian, Timber, Stone, Coastal, or Highland. The surrounding wild growth and the houses use the selected visual language.' },
+  { name: 'Set the settlement footprint and homes', text: 'Choose hamlet, village, or town. Each footprint reacts with its own map scale, home range, layout grammar, and core services, then you can fine tune the number of homes to match the location in your campaign.' },
+  { name: 'Add meaningful services', text: 'Select built-in services such as Tavern, Smithy, Temple, Market, Stable, and Hall, or add your own landmarks. Placement uses weighted centre and edge preferences with seeded variation, while custom services persist in the browser and in shared map data.' },
+  { name: 'Correct the map in context', text: 'Right-click or long-press any cell. Add buildings, roads, water, or trees, inspect what is already there, or erase a cell. Roads repair their junctions and adjacent water cells recompute their river, pond, or lake shape as you paint.' },
+  { name: 'Share and export the finished place', text: 'Copy a link for a complete editable version, save JSON as a source file, or export PNG for a handout and SVG for crisp printing. The map stays useful as both a worldbuilding draft and a practical exploration reference.' },
+];
+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: 'RPG Settlement and Exploration Map Generator', operatingSystem: 'All', applicationCategory: 'GameApplication', description: 'A browser based RPG settlement map generator with deterministic layouts, five landscapes, seven architectural styles, weighted services, connected roads, reactive water, contextual editing, share links, local storage, and PNG, SVG, and JSON exports.' };
+const howToSchema: WithContext<HowTo> = { '@context': 'https://schema.org', '@type': 'HowTo', name: 'How to make an RPG settlement exploration map', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) };
+
+export const content: SettlementMapLocaleContent = {
+  slug: 'rpg-settlement-exploration-map-generator', title: 'RPG Settlement and Exploration Map Generator', description: 'Generate a deterministic RPG settlement map with landscapes, architectural styles, smart services, connected roads, reactive water, contextual editing, share links, and PNG, SVG, and JSON export.', ui,
+  seo: [
+    { type: 'title', text: 'Generate a Living RPG Settlement Map', level: 2 },
+    { type: 'paragraph', html: 'Build a settlement that gives players somewhere to go, not just a picture of houses. This browser based RPG map generator creates an overhead exploration map where homes, roads, services, plazas, water, trees, and open terrain work together as a place with shape and purpose. Use it for a quick village stop, a faction filled town, a remote hamlet, or the first draft of a location you will keep developing during a campaign.' },
+    { type: 'title', text: 'A Seed That Changes the Town Without Losing Its Character', level: 2 },
+    { type: 'paragraph', html: 'Every generated settlement starts from a memorable compound name seed. The seed does more than rename the map: it selects a deterministic variation of the layout, including road rhythm, house spacing, service assignment, and surrounding wild growth. Change the seed to explore a new arrangement, then reuse the same seed and settings whenever you need to rebuild the same starting map for your notes, players, or future sessions.' },
+    { type: 'list', items: ['Different seeds create different patterns inside the chosen settlement type.', 'The result stays reproducible instead of becoming an untraceable random roll.', 'The settlement remains readable as a hamlet, village, or town while its internal arrangement changes.', 'The same seed can be shared as a stable starting point for collaborative campaign preparation.'] },
+    { type: 'title', text: 'Hamlet Village and Town Use Different Urban Grammars', level: 2 },
+    { type: 'paragraph', html: 'The footprint selector is not a cosmetic size switch. Hamlets, villages, and towns use different construction patterns, spacing, home ranges, and service expectations. A hamlet can stay under ten houses without looking like a shrunken town, while a town has room for longer routes, more destinations, and a stronger central structure. The home count reacts to the selected footprint so the generated place keeps the right scale.' },
+    { type: 'table', headers: ['Footprint', 'Home range', 'Character', 'Best campaign use'], rows: [['Hamlet', '3 to 18', 'Small, sparse, and easy to read at a glance', 'A roadside stop, isolated community, or village edge'], ['Village', '4 to 28', 'A local centre with several routes and landmarks', 'A recurring base, mystery location, or faction hub'], ['Town', '6 to 42', 'A broader network with more services and detours', 'A regional hub, investigation space, or starting settlement']] },
+    { type: 'title', text: 'Choose an Architectural Identity', level: 2 },
+    { type: 'paragraph', html: 'Give the settlement a visual identity before you start placing details. Timber, Stone, Coastal, Highland, Medieval, Edo, and Sahelian styles alter the houses with different roof profiles, wall colours, doors, windows, textures, and decorative details. The tree language changes with the setting too, from coastal palms and highland conifers to rounded Edo silhouettes, broad medieval canopies, and Sahelian acacia forms. The style makes the map feel like a region, era, or culture rather than a recoloured template.' },
+    { type: 'list', items: ['Medieval and Timber support storybook villages, frontier settlements, and woodland communities.', 'Stone and Highland suit rugged, elevated, defensive, or weather exposed places.', 'Coastal introduces a brighter maritime identity with vegetation that belongs near the shore.', 'Edo provides a distinct historical and regional silhouette for streets, houses, and trees.', 'Sahelian gives dryland communities their own architecture, palette, and tree shapes.'] },
+    { type: 'title', text: 'Place Services Where They Make Sense', level: 2 },
+    { type: 'paragraph', html: 'Services are story anchors with spatial logic. Tavern, Smithy, Temple, Market, Stable, and Hall are not blindly assigned to the first five buildings. Seeded weights choose among suitable candidates, with civic buildings tending toward the centre, stables and smithies favouring outer roads, and other services receiving a useful middle ground with enough variation to avoid a repeated pattern. Add custom services such as a watch post, apothecary, shrine, guildhall, ferry office, or whatever your adventure needs. Full service names appear on large signs above the houses so they stay legible in a town and remain visually attached to the correct building.' },
+    { type: 'title', text: 'Let the Landscape Be Part of the Story', level: 2 },
+    { type: 'paragraph', html: 'Choose Forest, Plains, Coast, River, or Mountain and let the settlement sit inside that context. The map gives the surrounding landscape room to breathe, with wild growth and terrain framing the populated area instead of turning the village into the only protagonist. A river can define an approach, a forest can hide a path or landmark, and the open ground around a hamlet can communicate isolation before a single encounter is written.' },
+    { type: 'title', text: 'Edit the Map Cell by Cell', level: 2 },
+    { type: 'paragraph', html: 'The generated plan is a strong starting point, but the contextual editor is where it becomes your location. Right-click on desktop or long-press on a touch screen to open the cell actions exactly where you are working. Inspect a cell, add a building, draw a road, paint water, add a tree, or erase an unwanted mark. The menu repositions itself when the edge of the map would clip it, keeping the editing action available without covering the workspace.' },
+    { type: 'list', items: ['Add a missing house, bridge approach, shrine, watch post, field, or other point of interest.', 'Move from generated structure to campaign-specific detail without opening a separate drawing toolbar.', 'Keep manual edits in the same map state as the generated content.', 'Use the same interaction on desktop and touch devices with right click or long press.'] },
+    { type: 'title', text: 'Roads and Water Respond to Their Neighbours', level: 2 },
+    { type: 'paragraph', html: 'Roads are generated as connected routes rather than decorative disconnected lines. Intersections are drawn cleanly when three or four paths meet, giving the settlement a usable circulation pattern. Water painting is equally reactive: a painted cell remains an exact edit, adjacent cells join into a river or pond, and larger connected groups resolve into a broader lake shape. This makes it practical to sketch a stream bend, extend a shoreline, add a crossing, or reshape a water feature directly on the map.' },
+    { type: 'title', text: 'Keep Your Services and Share the Complete Place', level: 2 },
+    { type: 'paragraph', html: 'Custom services are saved in local storage so a useful landmark list can grow across maps. Remove custom entries when they no longer belong; built-in presets remain available. When you copy a share link, the recipient gets the complete editable state: seed, footprint, home count, landscape, architectural style, service catalog, service marks, buildings, roads, water, trees, and manual edits. Nothing important is reduced to a screenshot.' },
+    { type: 'title', text: 'Export for Notes, Printing, or Continued Editing', level: 2 },
+    { type: 'table', headers: ['Format', 'Useful for', 'What it preserves'], rows: [['PNG', 'Virtual tabletops, notes, and quick handouts', 'A ready to view image of the current map'], ['SVG', 'Printing and vector workflows', 'A sharp scalable drawing for larger layouts'], ['JSON', 'Campaign archives and future edits', 'The complete editable settlement state']] },
+    { type: 'tip', title: 'A Practical Workflow for Game Night', html: 'Start with a seed, footprint, landscape, and architectural style. Add only the services that can create scenes or clues, then use the contextual editor to place the one bridge, road, tree line, water cell, or outlying house that makes the adventure yours. Copy the share link for the editable master and export a PNG or SVG when you need a clean reference at the table.' },
+  ], faq, bibliography, howTo, schemas: [faqSchema, appSchema, howToSchema] as unknown as Record<string, unknown>[],
+};