@jjlmoya/utils-tabletop 1.7.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-tabletop",
-    "version": "1.7.0",
+    "version": "1.8.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/entries.ts

@@ -12,6 +12,8 @@ export { fantasyRunesTranslator } from './tool/fantasy-runes-translator/entry';
 export type { FantasyRunesTranslatorUI, FantasyRunesTranslatorLocaleContent } from './tool/fantasy-runes-translator/entry';
 export { investigationBoard } from './tool/investigation-board/entry';
 export type { InvestigationBoardUI, InvestigationBoardLocaleContent } from './tool/investigation-board/entry';
+export { lunarTideTracker } from './tool/lunar-tide-tracker/entry';
+export type { LunarTideUI, LunarTideLocaleContent } from './tool/lunar-tide-tracker/entry';
 export { tabletopCategory } from './category';
 
 import { diceRollerSimulator } from './tool/dice-roller-simulator/entry';
@@ -22,6 +24,17 @@ import { initiativeTracker } from './tool/rpg-initiative-tracker/entry';
 import { fantasyRunesTranslator } from './tool/fantasy-runes-translator/entry';
 import { decisionWheel } from './tool/decision-wheel/entry';
 import { investigationBoard } from './tool/investigation-board/entry';
+import { lunarTideTracker } from './tool/lunar-tide-tracker/entry';
 
-export const ALL_ENTRIES = [diceRollerSimulator, boardGameTimer, firstPlayerSelector, scoreTracker, initiativeTracker, fantasyRunesTranslator, decisionWheel, investigationBoard];
+export const ALL_ENTRIES = [
+  diceRollerSimulator,
+  boardGameTimer,
+  firstPlayerSelector,
+  scoreTracker,
+  initiativeTracker,
+  fantasyRunesTranslator,
+  decisionWheel,
+  investigationBoard,
+  lunarTideTracker,
+];
 

package/src/index.ts

@@ -5,6 +5,7 @@ export { diceRollerSimulator, DICE_ROLLER_SIMULATOR_TOOL } from './tool/dice-rol
 export { boardGameTimer, BOARD_GAME_TIMER_TOOL } from './tool/board-game-timer';
 export { fantasyRunesTranslator, FANTASY_RUNES_TRANSLATOR_TOOL } from './tool/fantasy-runes-translator';
 export { investigationBoard, INVESTIGATION_BOARD_TOOL } from './tool/investigation-board';
+export { lunarTideTracker, LUNAR_TIDE_TRACKER_TOOL } from './tool/lunar-tide-tracker';
 
 
 export type {

package/src/tests/locale_completeness.test.ts

@@ -22,7 +22,7 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(8);
+    expect(ALL_TOOLS.length).toBe(9);
   });
 
 

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { tabletopCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(8);
+      expect(ALL_TOOLS.length).toBe(9);
     });
 
 

package/src/tool/lunar-tide-tracker/bibliography.astro

@@ -0,0 +1,16 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { lunarTideTracker } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props as Props;
+const loader = lunarTideTracker.i18n[locale] || lunarTideTracker.i18n.en;
+const content = await loader?.();
+if (!content) return null;
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/lunar-tide-tracker/bibliography.ts

@@ -0,0 +1,8 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Astronomical Moon Phase Calculations',
+    url: 'https://en.wikipedia.org/wiki/Lunar_phase',
+  },
+];

package/src/tool/lunar-tide-tracker/client.ts

@@ -0,0 +1,264 @@
+import type { Moon, MoonPhaseType } from './types';
+import { calculateMoonPhase, calculateCombinedTide, generateForecast } from './logic';
+
+const tideLabelMap: Record<string, string> = {
+  neap: 'Neap Tide', low: 'Low Tide', normal: 'Normal Tide', high: 'High Tide', spring: 'Spring Tide',
+};
+
+let moons: Moon[] = [{ id: '1', name: 'Solaria', period: 28, offset: 0, color: '#f59e0b' }];
+let currentDay = 0;
+
+const phaseUiKeys: Record<MoonPhaseType, string> = {
+  new: 'newMoon', waxing_crescent: 'waxingCrescent', first_quarter: 'firstQuarter',
+  waxing_gibbous: 'waxingGibbous', full: 'fullMoon', waning_gibbous: 'waningGibbous',
+  last_quarter: 'lastQuarter', waning_crescent: 'waningCrescent',
+};
+
+const phaseDefault: Record<MoonPhaseType, string> = {
+  new: 'New Moon', waxing_crescent: 'Waxing Crescent', first_quarter: 'First Quarter',
+  waxing_gibbous: 'Waxing Gibbous', full: 'Full Moon', waning_gibbous: 'Waning Gibbous',
+  last_quarter: 'Last Quarter', waning_crescent: 'Waning Crescent',
+};
+
+const presets: Record<string, () => Moon[]> = {
+  'lunar-preset-single': () => [{ id: '1', name: 'Solaria', period: 28, offset: 0, color: '#f59e0b' }],
+  'lunar-preset-double': () => [
+    { id: '1', name: 'Solaria', period: 20, offset: 0, color: '#a78bfa' },
+    { id: '2', name: 'Lunaria', period: 30, offset: 10, color: '#3b82f6' },
+  ],
+  'lunar-preset-triple': () => [
+    { id: '1', name: 'Solaria', period: 15, offset: 0, color: '#f87171' },
+    { id: '2', name: 'Lunaria', period: 25, offset: 5, color: '#3b82f6' },
+    { id: '3', name: 'Astraria', period: 40, offset: 15, color: '#34d399' },
+  ],
+};
+
+function getCssVar(name: string, fallback: string): string {
+  return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback;
+}
+
+function getUI(): Record<string, string> {
+  const el = document.querySelector('.ltt-root');
+  if (!el) return {};
+  try { return JSON.parse(el.getAttribute('data-ui') || '{}'); } catch { return {}; }
+}
+
+function getPhaseLabel(phase: MoonPhaseType, ui: Record<string, string>): string {
+  return ui[phaseUiKeys[phase]] || phaseDefault[phase];
+}
+
+function spawnParticle(x: number, y: number, text: string): void {
+  const p = document.createElement('div');
+  p.style.cssText = `position:fixed;left:${x}px;top:${y}px;transform:translate(-50%,-50%);pointer-events:none;color:#a78bfa;font-weight:700;font-size:0.9rem;text-shadow:0 0 8px rgba(139,92,246,0.7);animation:ltt-particle 0.8s ease-out forwards;z-index:9999`;
+  p.innerText = text;
+  document.body.appendChild(p);
+  setTimeout(() => p.remove(), 800);
+}
+
+function getSweep(isOuter: boolean, isWaxing: boolean): number {
+  if (isOuter && !isWaxing) return 1;
+  if (!isOuter && isWaxing) return 1;
+  return 0;
+}
+
+function buildPhasePath(pct: number, cx: number, cy: number, r: number): string {
+  if (pct <= 0.01 || pct >= 0.99) return '';
+  const isWaxing = pct < 0.5;
+  const base = isWaxing ? pct : pct - 0.5;
+  const rx = r * Math.abs(1 - 4 * base);
+  const isOuter = pct < 0.25 || pct >= 0.75;
+  const sweep = getSweep(isOuter, isWaxing);
+  return `M ${cx},${cy - r} A ${r},${r} 0 0,1 ${cx},${cy + r} A ${rx},${r} 0 0,${sweep} ${cx},${cy - r}`;
+}
+
+function renderMoonOrbs(): void {
+  const el = document.getElementById('ltt-moon-orbs');
+  if (!el) return;
+  const ui = getUI();
+  const orbRadius = 100;
+  const moonR = 8;
+  const angleStep = (2 * Math.PI) / moons.length;
+  const moonBg = getCssVar('--ltt-moon-bg', '#0f172a');
+  const moonStroke = getCssVar('--ltt-moon-stroke', 'rgba(255,255,255,0.1)');
+  el.innerHTML = moons.map((moon, i) => {
+    const angle = i * angleStep - Math.PI / 2;
+    const mx = 120 + orbRadius * Math.cos(angle);
+    const my = 120 + orbRadius * Math.sin(angle);
+    const info = calculateMoonPhase(currentDay, moon.period, moon.offset);
+    const phasePath = buildPhasePath(info.percentage, mx, my, moonR);
+    const pathSvg = phasePath ? `<path d="${phasePath}" fill="${moon.color}" style="filter:drop-shadow(0 0 3px ${moon.color})" />` : '';
+    return `<g><circle cx="${mx}" cy="${my}" r="${moonR}" fill="${moonBg}" stroke="${moonStroke}" stroke-width="0.5" />${pathSvg}<circle cx="${mx}" cy="${my}" r="${moonR}" fill="none" stroke="${moon.color}" stroke-width="0.5" opacity="0.4" /><title>${moon.name}: ${getPhaseLabel(info.phase, ui)}</title></g>`;
+  }).join('');
+}
+
+function updateCoreGlow(intensity: number): void {
+  const core = document.getElementById('ltt-core');
+  if (!core) return;
+  let glow = '2';
+  if (intensity > 75) glow = '8';
+  else if (intensity > 40) glow = '4';
+  core.style.filter = `drop-shadow(0 0 ${glow}px rgba(139,92,246,${intensity / 100}))`;
+}
+
+function updateCorePhase(): void {
+  const pathEl = document.getElementById('ltt-phase-path');
+  if (!pathEl) return;
+  if (moons.length === 1) {
+    const info = calculateMoonPhase(currentDay, moons[0].period, moons[0].offset);
+    const d = buildPhasePath(info.percentage, 120, 120, 60);
+    pathEl.setAttribute('d', d || '');
+    pathEl.setAttribute('fill', d ? moons[0].color : 'transparent');
+    if (d) pathEl.setAttribute('style', `filter:drop-shadow(0 0 8px ${moons[0].color})`);
+  } else {
+    pathEl.setAttribute('d', '');
+    pathEl.setAttribute('fill', 'transparent');
+  }
+}
+
+function renderPortalCore(): void {
+  const tide = calculateCombinedTide(currentDay, moons);
+  updateCoreGlow(tide.intensity);
+  updateCorePhase();
+}
+
+function renderTideStatus(): void {
+  const tide = calculateCombinedTide(currentDay, moons);
+  const bar = document.getElementById('ltt-tide-bar');
+  const pct = document.getElementById('ltt-tide-pct');
+  const lbl = document.getElementById('ltt-tide-label');
+  if (bar) bar.style.width = `${tide.intensity}%`;
+  if (pct) pct.innerText = `${tide.intensity}%`;
+  if (lbl) lbl.innerText = tideLabelMap[tide.labelKey] || tide.labelKey;
+}
+
+function renderMoonsList(): void {
+  const container = document.getElementById('ltt-moons-list');
+  if (!container) return;
+  const ui = getUI();
+  const moonBg = getComputedStyle(document.documentElement).getPropertyValue('--ltt-moon-bg').trim() || '#0f172a';
+  container.innerHTML = moons.map((moon) => {
+    const info = calculateMoonPhase(currentDay, moon.period, moon.offset);
+    const label = getPhaseLabel(info.phase, ui);
+    const path = buildPhasePath(info.percentage, 12, 12, 11);
+    return `
+      <div class="ltt-moon-row" data-id="${moon.id}">
+        <svg class="ltt-moon-vis-mini" viewBox="0 0 24 24">
+          <circle cx="12" cy="12" r="11" fill="${moonBg}" stroke="${getCssVar('--ltt-moon-stroke', 'rgba(255,255,255,0.1)')}" stroke-width="0.5"/>
+          ${path ? `<path d="${path}" fill="${moon.color}" style="filter:drop-shadow(0 0 2px ${moon.color})"/>` : ''}
+        </svg>
+        <input type="text" class="ltt-moon-input ltt-moon-name" value="${moon.name}" placeholder="${ui.moonName || 'Name'}" />
+        <input type="number" class="ltt-moon-num ltt-moon-period" value="${moon.period}" min="1" title="${ui.orbitalPeriod || 'Period'}" />
+        <input type="number" class="ltt-moon-num ltt-moon-offset" value="${moon.offset}" title="${ui.startingOffset || 'Offset'}" />
+        <input type="color" class="ltt-color-swatch" value="${moon.color}" />
+        <button type="button" class="ltt-remove-btn" data-id="${moon.id}" title="${ui.removeMoon || 'Remove'}">x</button>
+      </div>
+      <div class="ltt-phase-tag"><span class="ltt-phase-dot" style="background:${moon.color};"></span>${moon.name}: ${label} (${Math.round(info.percentage * 100)}%)</div>
+    `;
+  }).join('');
+  bindMoonRowEvents(container);
+}
+
+function bindMoonRowEvents(container: HTMLElement): void {
+  container.querySelectorAll('.ltt-remove-btn').forEach((btn) => {
+    btn.addEventListener('click', (e) => {
+      const id = (e.currentTarget as HTMLElement).getAttribute('data-id');
+      if (moons.length > 1) { moons = moons.filter((m) => m.id !== id); updateAll(); }
+    });
+  });
+  container.querySelectorAll('.ltt-moon-row').forEach((row) => {
+    const id = row.getAttribute('data-id');
+    const moon = moons.find((m) => m.id === id);
+    if (!moon) return;
+    bindSingleMoon(row as HTMLElement, moon);
+  });
+}
+
+function bindSingleMoon(row: HTMLElement, moon: Moon): void {
+  row.querySelector('.ltt-moon-name')?.addEventListener('input', (e) => {
+    moon.name = (e.target as HTMLInputElement).value;
+    renderMoonsList(); renderMoonOrbs();
+  });
+  row.querySelector('.ltt-moon-period')?.addEventListener('input', (e) => {
+    const v = parseInt((e.target as HTMLInputElement).value);
+    moon.period = isNaN(v) || v < 1 ? 1 : v; renderAll();
+  });
+  row.querySelector('.ltt-moon-offset')?.addEventListener('input', (e) => {
+    const v = parseInt((e.target as HTMLInputElement).value);
+    moon.offset = isNaN(v) ? 0 : v; renderAll();
+  });
+  row.querySelector('.ltt-color-swatch')?.addEventListener('input', (e) => {
+    moon.color = (e.target as HTMLInputElement).value; renderAll();
+  });
+}
+
+function renderForecast(): void {
+  const container = document.getElementById('ltt-forecast');
+  if (!container) return;
+  const ui = getUI();
+  const forecast = generateForecast(currentDay, 10, moons);
+  container.innerHTML = forecast.map((item) => {
+    const isPeak = item.tideLevel >= 80;
+    const dots = item.moons.map((m) => {
+      const src = moons.find((mn) => mn.id === m.moonId);
+      const col = src ? src.color : '#fff';
+      const op = m.phase === 'new' ? '0.15' : '1';
+      return `<div class="ltt-fc-dot" style="background:${col};opacity:${op};" title="${src?.name}: ${m.phase}"></div>`;
+    }).join('');
+    return `<div class="ltt-fc-cell${isPeak ? ' ltt-fc-peak' : ''}"><div class="ltt-fc-day">${ui.dayLabel || 'D'}${item.day}</div><div class="ltt-fc-dots">${dots}</div><div class="ltt-fc-pct">${item.tideLevel}%</div></div>`;
+  }).join('');
+}
+
+function renderAll(): void {
+  renderPortalCore();
+  renderMoonOrbs();
+  renderTideStatus();
+  renderMoonsList();
+  renderForecast();
+}
+
+function updateAll(): void {
+  const dayVal = document.getElementById('ltt-day-val');
+  const slider = document.getElementById('ltt-slider') as HTMLInputElement;
+  if (dayVal) dayVal.innerText = currentDay.toString();
+  if (slider) slider.value = currentDay.toString();
+  renderAll();
+}
+
+function bindStepButtons(): void {
+  const steps = [
+    { id: 'lunar-btn-prev7', delta: -7 }, { id: 'lunar-btn-prev1', delta: -1 },
+    { id: 'lunar-btn-next1', delta: 1 }, { id: 'lunar-btn-next7', delta: 7 },
+  ];
+  steps.forEach(({ id, delta }) => {
+    document.getElementById(id)?.addEventListener('click', (e) => {
+      currentDay = Math.max(0, currentDay + delta);
+      spawnParticle(e.clientX, e.clientY, `${delta > 0 ? '+' : ''}${delta}`);
+      updateAll();
+    });
+  });
+  document.getElementById('ltt-slider')?.addEventListener('input', (e) => {
+    currentDay = parseInt((e.target as HTMLInputElement).value) || 0;
+    updateAll();
+  });
+  document.getElementById('lunar-btn-reset')?.addEventListener('click', () => { currentDay = 0; updateAll(); });
+}
+
+function bindPresetsAndMoon(): void {
+  Object.entries(presets).forEach(([id, fn]) => {
+    const btn = document.getElementById(id);
+    btn?.addEventListener('click', () => {
+      moons = fn();
+      document.querySelectorAll('.ltt-preset-btn').forEach((b) => b.classList.remove('active'));
+      btn.classList.add('active');
+      updateAll();
+    });
+  });
+  document.getElementById('ltt-add-moon')?.addEventListener('click', () => {
+    if (moons.length >= 3) return;
+    const colors = ['#a78bfa', '#60a5fa', '#34d399'];
+    moons.push({ id: Date.now().toString(), name: `Moon ${moons.length + 1}`, period: 30, offset: 0, color: colors[moons.length % 3] });
+    updateAll();
+  });
+}
+
+document.addEventListener('DOMContentLoaded', () => { bindStepButtons(); bindPresetsAndMoon(); updateAll(); });

package/src/tool/lunar-tide-tracker/component.astro

@@ -0,0 +1,103 @@
+---
+import './lunar-tide-tracker.css';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui } = Astro.props;
+---
+
+<div class="ltt-root" data-ui={JSON.stringify(ui)}>
+
+  <div class="ltt-presets">
+    <button type="button" id="lunar-preset-single" class="ltt-preset-btn" data-key="0">{ui.presetSingle || 'Classic Moon'}</button>
+    <button type="button" id="lunar-preset-double" class="ltt-preset-btn" data-key="1">{ui.presetDouble || 'Twin Moons'}</button>
+    <button type="button" id="lunar-preset-triple" class="ltt-preset-btn" data-key="2">{ui.presetTriple || 'Triple Eclipse'}</button>
+  </div>
+
+  <div class="ltt-body">
+
+    <div class="ltt-portal-col">
+      <div class="ltt-portal-wrap">
+        <svg class="ltt-portal-svg" viewBox="0 0 240 240" aria-hidden="true">
+          <defs>
+            <radialGradient id="ltt-core-grad" cx="50%" cy="50%" r="50%">
+              <stop offset="0%" stop-color="#f0e6ff" />
+              <stop offset="40%" stop-color="#a78bfa" />
+              <stop offset="100%" stop-color="#1e0a3c" />
+            </radialGradient>
+            <radialGradient id="ltt-halo-grad" cx="50%" cy="50%" r="50%">
+              <stop offset="60%" stop-color="transparent" />
+              <stop offset="100%" stop-color="rgba(139,92,246,0.25)" />
+            </radialGradient>
+            <filter id="ltt-glow">
+              <feGaussianBlur stdDeviation="4" result="blur" />
+              <feMerge><feMergeNode in="blur" /><feMergeNode in="SourceGraphic" /></feMerge>
+            </filter>
+          </defs>
+          <circle cx="120" cy="120" r="118" fill="url(#ltt-halo-grad)" />
+          <circle cx="120" cy="120" r="108" fill="none" stroke="rgba(139,92,246,0.12)" stroke-width="1" stroke-dasharray="3 6" class="ltt-ring ltt-ring-a" />
+          <circle cx="120" cy="120" r="90" fill="none" stroke="rgba(167,139,250,0.2)" stroke-width="1" class="ltt-ring ltt-ring-b" />
+          <circle cx="120" cy="120" r="72" fill="none" stroke="rgba(139,92,246,0.35)" stroke-width="1.5" class="ltt-ring ltt-ring-c" />
+          <circle id="ltt-core" cx="120" cy="120" r="60" fill="url(#ltt-core-grad)" filter="url(#ltt-glow)" />
+          <path id="ltt-phase-path" fill="transparent" />
+          <g id="ltt-moon-orbs"></g>
+        </svg>
+        <div class="ltt-tide-badge">
+          <div class="ltt-tide-label" id="ltt-tide-label">Full Tide</div>
+          <div class="ltt-tide-bar-wrap"><div class="ltt-tide-bar" id="ltt-tide-bar"></div></div>
+          <div class="ltt-tide-pct" id="ltt-tide-pct">50%</div>
+        </div>
+      </div>
+    </div>
+
+    <div class="ltt-controls-col">
+
+      <div class="ltt-day-block">
+        <div class="ltt-day-row">
+          <span class="ltt-label">{ui.currentDay || 'Campaign Day'}</span>
+          <span class="ltt-day-val" id="ltt-day-val">0</span>
+        </div>
+        <input type="range" id="ltt-slider" class="ltt-slider" min="0" max="365" value="0" />
+        <div class="ltt-step-row">
+          <button type="button" id="lunar-btn-prev7" class="ltt-step-btn">-7</button>
+          <button type="button" id="lunar-btn-prev1" class="ltt-step-btn">-1</button>
+          <button type="button" id="lunar-btn-next1" class="ltt-step-btn ltt-step-pos">+1</button>
+          <button type="button" id="lunar-btn-next7" class="ltt-step-btn ltt-step-pos">+7</button>
+          <button type="button" id="lunar-btn-reset" class="ltt-reset-btn">{ui.resetButton || 'Day 0'}</button>
+        </div>
+      </div>
+
+      <div class="ltt-moons-block">
+        <div class="ltt-moons-header">
+          <span class="ltt-label">{ui.moonsTitle || 'Moons'}</span>
+          <button type="button" id="ltt-add-moon" class="ltt-add-btn">+ {ui.addMoon || 'Add'}</button>
+        </div>
+        <div id="ltt-moons-list" class="ltt-moons-list"></div>
+      </div>
+
+    </div>
+  </div>
+
+  <div class="ltt-forecast-wrap">
+    <div class="ltt-forecast-label">{ui.forecastTitle || 'Forecast'}</div>
+    <div id="ltt-forecast" class="ltt-forecast"></div>
+  </div>
+
+</div>
+
+<script src="./client.ts"></script>
+
+<style>
+  @keyframes ltt-particle {
+    0% {
+      opacity: 1;
+      transform: translate(-50%, -50%) translateY(0) scale(1);
+    }
+    100% {
+      opacity: 0;
+      transform: translate(-50%, -50%) translateY(-36px) scale(0.5);
+    }
+  }
+</style>

package/src/tool/lunar-tide-tracker/entry.ts

@@ -0,0 +1,26 @@
+import type { TabletopToolEntry, ToolLocaleContent } from '../../types';
+import type { LunarTideUI } from './types';
+
+export type LunarTideLocaleContent = ToolLocaleContent<LunarTideUI>;
+
+export const lunarTideTracker: TabletopToolEntry<LunarTideUI> = {
+  id: 'lunar-tide-tracker',
+  icons: { bg: 'mdi:weather-night', fg: 'mdi:moon-waning-crescent' },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/lunar-tide-tracker/i18n/de.ts

@@ -0,0 +1,156 @@
+import { bibliography } from '../bibliography';
+import type { LunarTideLocaleContent } from '../entry';
+
+export const content: LunarTideLocaleContent = {
+  slug: 'mondphasen-gezeiten-rechner',
+  title: 'Mondphasenrechner für Tabletop RPG: Eigene Fantasiemonde und Gezeitenzyklen berechnen',
+  description: 'Mondphasen für jede Fantasywelt mit eigenen Umlaufzeiten berechnen. Bis zu drei Monde gleichzeitig verfolgen, 10-Tage-Prognosen abrufen und einen Gezeitenstand für Magie- und Wettersysteme in D&D, Pathfinder oder anderen Rollenspielen ermitteln.',
+  ui: {
+    title: 'Mondphasen und Gezeitenrechner',
+    moonsTitle: 'Mondkonfiguration',
+    addMoon: 'Mond hinzufügen',
+    removeMoon: 'Mond entfernen',
+    moonName: 'Mondname',
+    orbitalPeriod: 'Umlaufzeit (Tage)',
+    startingOffset: 'Startversatz (Tage)',
+    timelineTitle: 'Zeitsteuerung',
+    currentDay: 'Aktueller Kampagnentag',
+    tideTitle: 'Mystischer Gezeitenstand',
+    tideLevel: 'Gezeitenenergie',
+    magicModifier: 'Magischer Gezeiteneffekt',
+    forecastTitle: 'Mondphasen- und Gezeitenprognose',
+    dayLabel: 'Tag',
+    resetButton: 'Auf Tag 0 zurücksetzen',
+    presetTitle: 'Kampagnen-Voreinstellungen',
+    presetSingle: 'Klassischer Mond',
+    presetDouble: 'Zwillingsmonde der Magie',
+    presetTriple: 'Dreifaches Finsternisreich',
+    newMoon: 'Neumond',
+    waxingCrescent: 'Zunehmende Sichel',
+    firstQuarter: 'Erstes Viertel',
+    waxingGibbous: 'Zunehmender Gibbous',
+    fullMoon: 'Vollmond',
+    waningGibbous: 'Abnehmender Gibbous',
+    lastQuarter: 'Letztes Viertel',
+    waningCrescent: 'Abnehmende Sichel',
+  },
+  seo: [
+    { type: 'title', text: 'Mondphasen in Tabletop-Rollenspielen verfolgen', level: 2 },
+    { type: 'paragraph', html: 'Die meisten Fantasywelten haben Monde mit anderen Umlaufzeiten als der reale Mond mit seinen 29,5 Tagen. Das Feld <strong>Umlaufzeit</strong> legt fest, wie viele Spieltage ein Mond für einen vollständigen Zyklus benötigt. Die Eberron-Welt verwendet 28 Tage, Mittelerde liegt bei ca. 30. Stellen Sie den Wert so ein, wie es das Lore Ihrer Welt vorgibt, oder wählen Sie einen Wert zwischen 5 und 60 Tagen.' },
+    {
+      type: 'stats',
+      items: [
+        { value: '3', label: 'Gleichzeitige Monde' },
+        { value: '10', label: 'Tage Prognose' },
+        { value: '5', label: 'Gezeitenstufen' }
+      ],
+      columns: 3
+    },
+    { type: 'title', text: 'Was der Startversatz bewirkt', level: 2 },
+    { type: 'paragraph', html: 'Der <strong>Startversatz</strong> verschiebt die Ausgangsphase eines Mondes am Kampagnentag 0. Ein Versatz von 0 beginnt beim Neumond. Ein Versatz von der Hälfte der Umlaufzeit startet beim Vollmond. Nutzen Sie dies, um die in Ihrer Einstiegsszene beschriebene Phase zu reproduzieren, oder damit zwei Monde nicht immer gleichzeitig stehen.' },
+    { type: 'title', text: 'Was der Gezeitenstand im Spiel bedeutet', level: 2 },
+    { type: 'paragraph', html: 'Der Gezeitenstand kombiniert die Anziehungskraft aller aktiven Monde anhand ihrer aktuellen Phasen. Eine <strong>Springflut</strong> (über 75%) entsteht, wenn Monde nahezu ausgerichtet sind. Eine <strong>Nipptide</strong> (unter 30%) tritt auf, wenn Monde entgegengesetzte Phasen haben. Binden Sie dies an Spielmechaniken: Rettungswurf-Boni, Werwolf-Verwandlungen oder Sturmschwere auf Küstenkarten.' },
+    {
+      type: 'comparative',
+      items: [
+        {
+          title: 'Einzelner Mond',
+          description: 'Ideal für Welten ähnlich der realen Welt oder mit einem dominanten Mond. Einfacher 8-Phasen-Zyklus.',
+          icon: 'mdi:moon-full',
+          highlight: false,
+          points: [
+            'D&D Vergessene Reiche (Selune, 30 Tage)',
+            'Werwolf- und Lykanthropie-Kampagnen',
+            'Horror-Sitzungen beim Vollmond'
+          ]
+        },
+        {
+          title: 'Zwillingsmonde',
+          description: 'Häufig in High-Fantasy-Settings. Erzeugt interessante Teilausrichtungen und abwechslungsreiche Gezeiten.',
+          icon: 'mdi:moon-waxing-crescent',
+          highlight: true,
+          points: [
+            'Eberron (Rhaan 28T + Aryth 12T)',
+            'Vorhersagbare Finsterniszeiten',
+            'Gut für druidische Magiesysteme'
+          ]
+        },
+        {
+          title: 'Drei Monde',
+          description: 'Seltene Dreifachausrichtungen erzeugen unvorhersehbare Energieschübe. Dramatisch nützlich für wilde Magieereignisse.',
+          icon: 'mdi:moon-waning-crescent',
+          highlight: false,
+          points: [
+            'Wilde-Magie-Tabellen bei Ausrichtung',
+            'Pathfinder Golarion-Komplexität',
+            'Langperiodische Zyklen für epische Kampagnen'
+          ]
+        }
+      ],
+      columns: 3
+    },
+    { type: 'title', text: 'Häufige Umlaufzeiten für Fantasywelten', level: 3 },
+    {
+      type: 'glossary',
+      items: [
+        { term: 'Selune (Vergessene Reiche)', definition: '30-tägige Umlaufzeit, einzelner Mond. Versatz 15 für Vollmond am ersten Spielabend.' },
+        { term: 'Eberron-Monde', definition: 'Eberron hat 12 Monde mit Umlaufzeiten von 9 bis 28 Tagen. Die zwei handlungsrelevantesten als separate Mond-Instanzen verwenden.' },
+        { term: 'Golarion (Pathfinder)', definition: 'Golarion hat einen Mond, Somal, mit einem 29-Tage-Zyklus. Zweiter Mond mit kurzem Zyklus modelliert Finstere Tapisserie-Ereignisse.' },
+        { term: 'Eigene Welt', definition: 'Ein 15-Tage-Mond erzeugt 24 Vollmonde pro Spieljahr. Ein 45-Tage-Mond nur 8. Kürzere Zyklen bedeuten häufigere Ereignisse, aber weniger Dramatik.' }
+      ]
+    },
+    {
+      type: 'diagnostic',
+      variant: 'info',
+      title: 'Tipp: Bestimmte Phase für Sitzung 1 einrichten',
+      icon: 'mdi:information-outline',
+      badge: 'SETUP-TIPP',
+      html: 'Für eine Sichel am Spielbeginn: Versatz auf etwa 20 % der Umlaufzeit setzen. Für Vollmond: 50 % der Umlaufzeit als Versatz verwenden. Beispiel: 28-Tage-Mond, Vollmond-Start: Versatz 14. Tageszähler auf den aktuellen Kampagnentag stellen und die Prognose zeigt automatisch die nächsten 10 Tage.'
+    }
+  ],
+  faq: [
+    { question: 'Welche Umlaufzeit sollte ich für meine Fantasywelt verwenden?', answer: 'Falls Ihr Setting nichts vorgibt, funktionieren 28 bis 30 Tage gut für einen einzelnen Mond. Für mehrere Monde wählen Sie Zeiten, die keine einfachen Vielfachen voneinander sind, damit Ausrichtungen nicht zu häufig vorkommen.' },
+    { question: 'Wie bringe ich zwei Monde an einem bestimmten Kampagnenmoment zur Ausrichtung?', answer: 'Setzen Sie beide Monde auf denselben Versatzwert. Sie richten sich bei jedem gemeinsamen Vielfachen ihrer Umlaufzeiten neu aus. Für versetzten Start gibt der zweite Mond einen Versatz von der Hälfte seiner Umlaufzeit.' },
+    { question: 'Was bedeutet Springflut in Spielmechaniken?', answer: 'Springflut bedeutet, dass alle aktiven Monde maximale Gezeitenenergie erzeugen. Nutzen Sie dies für wilde Magieauslöser, verstärkte Heilzauber, schwerere Stürme oder als heilige Nacht für religiöse Fraktionen.' },
+    { question: 'Was bedeutet Nipptide in Spielmechaniken?', answer: 'Nipptide tritt auf, wenn Monde sich gegenseitig abschwächen. Gut für Antimagie-Effekte, Totenstille auf See oder für Antagonisten, die verlässliche Magieunterdrückung für ihre Pläne benötigen.' },
+    { question: 'Kann ich dies für Cthulhu- oder Horror-Kampagnen verwenden?', answer: 'Ja. Einen 29-Tage-Mond verwenden und Versatz so setzen, dass der Vollmond auf den Sitzungshöhepunkt fällt. Der Gezeitenstand kann Mythos-Einfluss oder Höhepunkte der psychischen Empfindlichkeit darstellen.' },
+    { question: 'Wie funktioniert die 10-Tage-Prognose?', answer: 'Die Prognose zeigt die Mondphase jedes aktiven Mondes als farbigen Punkt für jeden der nächsten 10 Kampagnentage. Der Prozentsatz ist der kombinierte Gezeitenstand. Hohe Werte eignen sich für dramatische Begegnungen.' },
+    { question: 'Kann ich einen Mond mit sehr kurzem Zyklus, z. B. 7 Tagen, verfolgen?', answer: 'Ja. Umlaufzeit auf 7 setzen. Der Mond durchläuft alle 8 Phasen in einer Spielwoche. Nützlich für magische Systeme, die wöchentlich zurückgesetzt werden.' },
+    { question: 'Wie gleiche ich die Mondphase aus einem veröffentlichten Abenteuermodul ab?', answer: 'Bestimmen Sie, welcher Phase im Abenteuer der beschriebene Zustand entspricht, und teilen Sie diesen Tageszähler durch die Umlaufzeit. Beispiel: Halbmond am Tag 0 eines 28-Tage-Mondes bedeutet Versatz 7.' }
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Umlaufzeit festlegen', text: 'Anzahl der Spieltage eingeben, die der Mond für einen vollständigen Zyklus benötigt.' },
+    { name: 'Startversatz festlegen', text: 'Startphase durch einen Tagesversatz verschieben. Hälfte der Umlaufzeit entspricht Vollmond-Start.' },
+    { name: 'Tageszähler vorrücken', text: 'Schaltflächen oder Schieberegler auf den aktuellen Kampagnentag stellen und Phase sowie Gezeitenstand ablesen.' }
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      'name': 'Mondphasenrechner für Tabletop RPG: Eigene Fantasiemonde und Gezeitenzyklen berechnen',
+      'operatingSystem': 'All',
+      'applicationCategory': 'UtilitiesApplication',
+      'browserRequirements': 'Requires JavaScript.'
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      'mainEntity': [
+        { '@type': 'Question', 'name': 'Welche Umlaufzeit sollte ich für meine Fantasywelt verwenden?', 'acceptedAnswer': { '@type': 'Answer', 'text': 'Falls Ihr Setting nichts vorgibt, funktionieren 28 bis 30 Tage gut für einen einzelnen Mond. Für mehrere Monde wählen Sie Zeiten, die keine einfachen Vielfachen voneinander sind.' } },
+        { '@type': 'Question', 'name': 'Was bedeutet Springflut in Spielmechaniken?', 'acceptedAnswer': { '@type': 'Answer', 'text': 'Springflut bedeutet maximale Gezeitenenergie. Nutzen Sie dies für wilde Magieauslöser, verstärkte Heilzauber oder als heilige Nacht für religiöse Fraktionen.' } }
+      ]
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      'name': 'Mondphasen in einer Tabletop-RPG-Kampagne verfolgen',
+      'step': [
+        { '@type': 'HowToStep', 'name': 'Umlaufzeit festlegen', 'text': 'Anzahl der Spieltage eingeben, die der Mond für einen vollständigen Zyklus benötigt.' },
+        { '@type': 'HowToStep', 'name': 'Startversatz festlegen', 'text': 'Startphase durch einen Tagesversatz verschieben.' },
+        { '@type': 'HowToStep', 'name': 'Tageszähler vorrücken', 'text': 'Schieberegler auf den aktuellen Kampagnentag stellen und Phase ablesen.' }
+      ]
+    }
+  ]
+};
+export default content;