@jjlmoya/utils-tabletop 1.29.0 → 1.30.0

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

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

@@ -0,0 +1,233 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { SettlementMapLocaleContent, SettlementMapUI } from '../entry';
+
+const ui: SettlementMapUI = {
+  intro: 'Diseña un mapa de exploración de asentamiento para tus partidas. Elige el paisaje, el tipo de poblado y el estilo arquitectónico, y ajusta celdas con clic derecho o pulsación prolongada.',
+  seedLabel: 'Semilla y nombre de la aldea',
+  seedHint: 'La semilla genera un patrón determinista único para la distribución de caminos y edificios.',
+  randomSeed: 'Generar nuevo nombre',
+  environmentLabel: 'Paisaje circundante',
+  forest: 'Bosque',
+  plains: 'Llanura',
+  coast: 'Costa',
+  river: 'Río',
+  mountain: 'Montaña',
+  styleLabel: 'Estilo arquitectónico',
+  styleHint: 'Cambia la identidad estética: tejados, materiales, estructuras y vegetación regional.',
+  styleTimber: 'Entramado',
+  styleStone: 'Piedra',
+  styleCoastal: 'Costero',
+  styleHighland: 'Alta montaña',
+  styleMedieval: 'Medieval',
+  styleEdo: 'Edo',
+  styleSahelian: 'Saheliano',
+  sizeLabel: 'Tamaño del asentamiento',
+  hamlet: 'Aldea',
+  hamletHint: 'Poblado pequeño',
+  village: 'Pueblo',
+  villageHint: 'Base local',
+  town: 'Villa',
+  townHint: 'Núcleo urbano',
+  homesLabel: 'Viviendas',
+  homesHint: 'Ajusta la cantidad de casas respetando el tamaño y espacio disponible.',
+  servicesLabel: 'Servicios e hitos',
+  serviceListHint: 'Elige servicios predefinidos o añade puntos de interés personalizados.',
+  newServicePlaceholder: 'Añadir servicio o lugar',
+  addService: 'Añadir',
+  removeService: 'Eliminar',
+  serviceTavern: 'Taberna',
+  serviceSmithy: 'Herrería',
+  serviceTemple: 'Templo',
+  serviceMarket: 'Mercado',
+  serviceStable: 'Establo',
+  serviceHall: 'Ayuntamiento',
+  generate: 'Regenerar mapa',
+  mapRegionLabel: 'Mapa de asentamiento ROL editable',
+  mapSummary: 'Plano del poblado',
+  buildings: 'Edificios',
+  paths: 'Caminos',
+  services: 'Servicios',
+  terrain: 'Agua',
+  legendLabel: 'Leyenda del mapa',
+  legendHome: 'Casa',
+  legendService: 'Servicio',
+  legendPath: 'Camino',
+  legendWater: 'Agua',
+  legendWild: 'Bosque',
+  editLabel: 'Edición directa de mapa',
+  toolSelect: 'Inspeccionar',
+  toolBuilding: 'Edificio',
+  toolPath: 'Camino',
+  toolWater: 'Agua',
+  toolTree: 'Árbol',
+  toolErase: 'Borrar',
+  serviceSelectLabel: 'Nueva marca de servicio',
+  clickHint: 'Clic derecho o pulsación prolongada para editar una celda.',
+  selectedHint: 'Celda seleccionada en',
+  shareLink: 'Copiar enlace',
+  linkCopied: 'Enlace copiado al portapapeles',
+  exportPng: 'PNG',
+  exportSvg: 'SVG',
+  exportJson: 'Guardar JSON',
+  importJson: 'Abrir JSON',
+  importError: 'El archivo no es un mapa válido.',
+  mapData: 'Datos del mapa',
+  readyBadge: 'Listo para explorar',
+  serviceNone: 'Sin marca',
+  contextMenuLabel: 'Acciones de celda',
+  contextInspect: 'Inspeccionar celda',
+  contextBuilding: 'Añadir edificio',
+  contextPath: 'Añadir camino',
+  contextWater: 'Añadir agua',
+  contextTree: 'Añadir árbol',
+  contextErase: 'Borrar celda',
+};
+
+const faq = [
+  {
+    question: '¿Qué genera este generador de mapas de asentamientos para ROL?',
+    answer: 'Crea mapas cenitales interactivos y reproducibles para aldeas, pueblos y villas en juegos de rol. Genera viviendas, caminos conectados, fuentes de agua, vegetación y servicios con lógica urbanística.',
+  },
+  {
+    question: '¿La semilla modifica realmente el diseño del mapa?',
+    answer: 'Sí. La semilla genera una distribución determinista de calles, casas y servicios. Utilizar la misma semilla y configuración reconstruirá exactamente el mismo mapa.',
+  },
+  {
+    question: '¿Qué tamaños de asentamiento están disponibles?',
+    answer: 'Aldea, pueblo y villa. Cada uno amplía la escala del mapa, la densidad de caminos y la capacidad de viviendas.',
+  },
+  {
+    question: '¿Se puede cambiar el estilo arquitectónico?',
+    answer: 'Sí. Incluye estilos Medieval, Edo, Saheliano, Entramado, Piedra, Costero y Alta montaña, adaptando tejados, paredes y árboles al entorno.',
+  },
+  {
+    question: '¿Es posible elegir el entorno natural?',
+    answer: 'Sí. Puedes seleccionar bosque, llanura, costa, río o montaña para enmarcar el poblado en la geografía deseada.',
+  },
+  {
+    question: '¿Cómo se distribuyen los servicios en el poblado?',
+    answer: 'Los servicios predefinidos como taberna, herrería, templo, mercado, establo y ayuntamiento se ubican con pesos lógicos: el ayuntamiento hacia el centro y los establos o herrerías hacia los bordes.',
+  },
+  {
+    question: '¿Puedo añadir mis propios puntos de interés?',
+    answer: 'Sí. Puedes añadir lugares de interés personalizados que se guardan en el navegador y se incluyen en los enlaces compartidos y archivos JSON.',
+  },
+  {
+    question: '¿Se puede editar el mapa celda por celda?',
+    answer: 'Sí. Al hacer clic derecho o pulsación prolongada sobre cualquier celda puedes cambiar su contenido entre edificio, camino, agua, árbol o borrarla.',
+  },
+  {
+    question: '¿Cómo reaccionan los caminos y el agua al editar?',
+    answer: 'Los caminos conectan automáticamente las cruces e intersecciones adyacentes, y las celdas de agua se unen formando ríos, estanques o lagos.',
+  },
+  {
+    question: '¿Cómo comparto un asentamiento con mis jugadores?',
+    answer: 'Copia el enlace compartido o exporta el mapa en JSON. Ambos métodos conservan la configuración y todas las ediciones manuales.',
+  },
+  {
+    question: '¿Qué formato de exportación es el más adecuado?',
+    answer: 'PNG para imágenes rápidas, SVG para impresión y edición vectorial, y JSON para guardar el estado editable completo.',
+  },
+];
+
+const howTo = [
+  {
+    name: 'Elige una semilla',
+    text: 'Usa el nombre generado o escribe una semilla propia para controlar la distribución inicial del poblado.',
+  },
+  {
+    name: 'Selecciona entorno y estilo',
+    text: 'Ajusta el paisaje entre bosque, llanura, costa, río o montaña, y elige una arquitectura como Medieval, Edo o Saheliano.',
+  },
+  {
+    name: 'Define la escala',
+    text: 'Selecciona aldea, pueblo o villa y ajusta el número de viviendas deseadas.',
+  },
+  {
+    name: 'Añade servicios e hitos',
+    text: 'Activa servicios clave como taberna o herrería, o crea tus propios nombres de lugares de interés.',
+  },
+  {
+    name: 'Edita el plano celda a celda',
+    text: 'Haz clic derecho o mantén pulsado sobre el mapa para modificar caminos, agua, edificios o árboles.',
+  },
+  {
+    name: 'Exporta y comparte',
+    text: 'Obtén el enlace compartido, guarda en JSON o descarga el mapa en PNG o SVG para tus sesiones.',
+  },
+];
+
+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: 'Generador de Mapas de Asentamientos ROL',
+  operatingSystem: 'All',
+  applicationCategory: 'GameApplication',
+  description: 'Generador de mapas de exploración de poblados para juegos de rol con semillas deterministas, estilos arquitectónicos y edición directa.',
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Cómo crear un mapa de asentamiento para ROL',
+  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: 'generador-mapas-asentamientos-rol-exploracion',
+  title: 'Generador de Mapas de Asentamientos para ROL',
+  description: 'Genera mapas de exploración de aldeas, pueblos y villas para ROL con semillas deterministas, 7 estilos arquitectónicos, servicios e interacción celda a celda.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Crea Asentamientos Vivos para tus Partidas de ROL', level: 2 },
+    { type: 'paragraph', html: 'Diseña poblados completos que ofrezcan a tus jugadores un lugar real que explorar, en lugar de una simple acumulación de casas sin contexto. Este generador de mapas de rol para navegador crea planos cenitales donde viviendas, caminos, plazas, fuentes de agua, vegetación y terreno abierto trabajan juntos como un espacio coherente con estructura y propósito. Utilízalo para un alto rápido en el camino, una villa llena de facciones, una aldea remota o el primer borrador de una ubicación clave en tu campaña.' },
+    { type: 'title', text: 'Semillas Deterministas para Mapas Reproducibles', level: 2 },
+    { type: 'paragraph', html: 'Cada poblado generado parte de una semilla basada en un nombre compuesto y memorable. La semilla no solo nombra el plano: selecciona una variante determinista de la distribución, incluyendo el ritmo de los caminos, el espacio entre viviendas, la asignación de servicios e hitos, y la densidad del bosque circundante. Cambiar la semilla genera una nueva ordenación, y reutilizar la misma combinación en el futuro reconstruye de forma exacta el mismo mapa de inicio.' },
+    { type: 'list', items: ['Diferentes semillas crean patrones propios para cada tipo de asentamiento.', 'Los mapas son 100% reproducibles para tus notas de campaña o futuras partidas.', 'Mantiene la coherencia urbanística en aldeas, pueblos y villas.', 'Permite compartir semillas exactas con otros directores de juego para la preparación de campañas.'] },
+    { type: 'title', text: 'Escala Adaptable de Aldea a Villa', level: 2 },
+    { type: 'paragraph', html: 'La selección de tamaño no es un mero cambio cosmético. Aldeas, pueblos y villas emplean patrones de construcción, distancias, capacidades de viviendas y expectativas de servicios diferentes. Una aldea puede mantenerse por debajo de diez casas sin parecer una villa encogida, mientras que una villa dispone de espacio para rutas más largas, mayor número de destinos y una estructura central marcada. El contador de viviendas reacciona al tamaño elegido para asegurar la escala adecuada.' },
+    { type: 'table', headers: ['Escala', 'Viviendas', 'Carácter', 'Uso en campaña'], rows: [['Aldea', '3 a 18', 'Pequeña, dispersa y fácil de abarcar a simple vista', 'Alto en el camino, comunidad aislada o borde del poblado'], ['Pueblo', '4 a 28', 'Centro local con varios caminos e hitos destacados', 'Base recurrente, lugar de misterio o núcleo de facción'], ['Villa', '6 a 42', 'Red amplia con múltiples servicios, rutas y desvíos', 'Centro comercial regional, lugar de investigación o poblado inicial']] },
+    { type: 'title', text: 'Siete Estilos Arquitectónicos', level: 2 },
+    { type: 'paragraph', html: 'Otorga una identidad visual propia al poblado antes de colocar los detalles. Los estilos Medieval, Edo, Saheliano, Entramado, Piedra, Costero y Alta montaña modifican las casas con diferentes pérfiles de tejados, tonos de pared, puertas, ventanas, texturas y detalles decorativos. La vegetación también se adapta al entorno, desde palmeras costeras hasta coníferas de montaña o copas redondeadas de inspiración oriental.' },
+    { type: 'list', items: ['Medieval y Entramado para fantasía clásica, poblados fronterizos y comunidades del bosque.', 'Piedra y Alta montaña para entornos rocosos, fortificados o expuestos al clima.', 'Costero para una identidad marítima luminosa con vegetación propia de litoral.', 'Edo para una silueta histórica y regional reconocible en calles, tejados y vegetación.', 'Saheliano para comunidades de clima seco con una arquitectura y paleta propias.'] },
+    { type: 'title', text: 'Ubicación Inteligente de Servicios', level: 2 },
+    { type: 'paragraph', html: 'Los servicios son anclas narrativas con lógica espacial. Tabernas, herrerías, templos, mercados, establos y ayuntamientos no se asignan a ciegas a las primeras casas. Pesos algorítmicos situán los edificios cívicos hacia el centro del asentamiento, mientras que establos y herrerías tienden hacia los caminos exteriores. Puedes añadir nombres personalizados para puestos de guardia, boticarios, santuarios o gremios, apareciendo en carteles sobre los tejados para ser perfectamente legibles.' },
+    { type: 'title', text: 'Integración en el Entorno Natural', level: 2 },
+    { type: 'paragraph', html: 'Selecciona entornos de bosque, llanura, costa, río o montaña para integrar el poblado en su entorno geográfico. El mapa otorga al paisaje espacio para respirar, permitiendo que la vegetación silvestre y la topografía enmarquen la zona habitada en lugar de convertir el mapa en un único bloque de casas.' },
+    { type: 'title', text: 'Edición Directa Celda a Celda', level: 2 },
+    { type: 'paragraph', html: 'El plano generado es un excelente punto de partida, pero el editor contextual lo transforma en tu ubicación concreta. Haz clic derecho en ordenador o mantén pulsado en dispositivos táctiles para abrir el menú de acciones directamente en la celda donde estás trabajando. Inspecciona celdas, añade viviendas, dibuja caminos, pinta agua, planta árboles o borra elementos indeseados.' },
+    { type: 'list', items: ['Añade casas faltantes, accesos a puentes, santuarios o puestos de guardia.', 'Modifica rutas sin necesidad de herramientas de dibujo externas.', 'Conserva todas las ediciones manuales en el mismo estado del mapa.', 'Misma interacción intuitiva en ordenadores y dispositivos táctiles.'] },
+    { type: 'title', text: 'Caminos y Agua Dinámicos', level: 2 },
+    { type: 'paragraph', html: 'Los caminos se generan como rutas conectadas y sus cruces se dibujan de forma limpia cuando se cruzan tres o cuatro vías. El pintado de agua reacciona al entorno: celdas adyacentes se unen formando ríos, estanques o lagos más amplios a medida que expandes el área de agua.' },
+    { type: 'title', text: 'Guarda y Comparte tus Mapas', level: 2 },
+    { type: 'paragraph', html: 'Genera enlaces para compartir la versión editable completa con tus jugadores o con otro director de juego. Se conserva la semilla, el tamaño, el estilo arquitectónico, la lista de servicios, los caminos, las celdas de agua y todas las modificaciones manuales realizadas. También puedes exportar el mapa completo como archivo JSON.' },
+    { type: 'title', text: 'Formatos de Exportación Adaptados', level: 2 },
+    { type: 'table', headers: ['Formato', 'Uso recomendado', 'Contenido conservado'], rows: [['PNG', 'Mesas virtuales y notas rápidas', 'Imagen lista del plano actual'], ['SVG', 'Impresión y diseño vectorial', 'Gráficos escalables de alta definición'], ['JSON', 'Archivo y edición futura', 'Estado editable completo del mapa']] },
+    { type: 'tip', title: 'Flujo Recomendado para Sesiones', html: 'Empieza eligiendo semilla, tamaño y estilo. Añade los servicios narrativos clave y utiliza el editor contextual para dar el toque final a los caminos o edificios antes de la partida.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};