@jjlmoya/utils-games-development 1.63.0 → 1.65.0

package/src/tool/damageFormulaLab/dom-views.ts

@@ -0,0 +1,193 @@
+import { buildCurve, buildHeatmap } from "./logic";
+import type { FormulaResult, SamplePoint } from "./logic";
+import { inspectFormula, inspectSweep } from "./evaluator";
+import type { LabConfig } from "./model";
+import type { DamageFormulaLabUI } from "./ui";
+
+function query(root: HTMLElement, selector: string): HTMLElement | null {
+  return root.querySelector<HTMLElement>(selector);
+}
+
+function format(value: number, digits = 1): string {
+  return Number.isFinite(value)
+    ? value.toLocaleString("en", { maximumFractionDigits: digits })
+    : "∞";
+}
+
+function setText(root: HTMLElement, selector: string, value: string): void {
+  const target = query(root, selector);
+  if (target) target.textContent = value;
+}
+
+function resultText(
+  result: FormulaResult | undefined,
+  key: keyof FormulaResult,
+  suffix = "",
+): string {
+  return result ? `${format(result[key])}${suffix}` : "Error";
+}
+
+function setResult(
+  root: HTMLElement,
+  prefix: string,
+  result: FormulaResult | undefined,
+): void {
+  setText(
+    root,
+    `[data-result="${prefix}-damage"]`,
+    resultText(result, "roundedDamage"),
+  );
+  setText(
+    root,
+    `[data-result="${prefix}-hits"]`,
+    resultText(result, "hitsToKill"),
+  );
+  setText(
+    root,
+    `[data-result="${prefix}-ttk"]`,
+    resultText(result, "timeToKill", " s"),
+  );
+}
+
+function pointPath(points: SamplePoint[], maximum: number): string {
+  return points
+    .map((point, index) => {
+      const x = points.length === 1 ? 0 : (index * 100) / (points.length - 1);
+      const y = 100 - Math.min(point.roundedDamage / maximum, 1) * 84 - 8;
+      return `${index === 0 ? "M" : "L"} ${x.toFixed(2)} ${y.toFixed(2)}`;
+    })
+    .join(" ");
+}
+
+function renderCurve(
+  root: HTMLElement,
+  a: SamplePoint[],
+  b: SamplePoint[],
+): void {
+  const maximum = Math.max(
+    1,
+    ...a.map((point) => point.roundedDamage),
+    ...b.map((point) => point.roundedDamage),
+  );
+  const pathA = root.querySelector<SVGPathElement>('[data-curve="a"]');
+  const pathB = root.querySelector<SVGPathElement>('[data-curve="b"]');
+  if (pathA) pathA.setAttribute("d", pointPath(a, maximum));
+  if (pathB) pathB.setAttribute("d", pointPath(b, maximum));
+  setText(root, "[data-curve-max]", format(maximum));
+}
+
+function renderHeatmap(root: HTMLElement, rows: SamplePoint[][]): void {
+  const target = query(root, "[data-heatmap]");
+  if (!target) return;
+  const maximum = Math.max(
+    1,
+    ...rows.flat().map((point) => point.roundedDamage),
+  );
+  target.replaceChildren(
+    ...rows.flat().map((point) => {
+      const cell = document.createElement("span");
+      cell.className = "damage-lab-heat-cell";
+      cell.style.setProperty(
+        "--damage-intensity",
+        String(Math.max(0.06, point.roundedDamage / maximum)),
+      );
+      cell.textContent = format(point.roundedDamage, 0);
+      cell.title = `Attack ${format(point.attack)} · Defense ${format(point.defense)}`;
+      return cell;
+    }),
+  );
+}
+
+function renderDiagnostics(
+  root: HTMLElement,
+  config: LabConfig,
+  ui: DamageFormulaLabUI,
+): void {
+  const target = query(root, "[data-diagnostics]");
+  if (!target) return;
+  const a = inspectFormula(config.formulaA, config.variables, config.settings);
+  const b = inspectFormula(config.formulaB, config.variables, config.settings);
+  const messages = [
+    ...a.diagnostics.map((item) => `A: ${item}`),
+    ...b.diagnostics.map((item) => `B: ${item}`),
+    ...inspectSweep(
+      config.formulaA,
+      config.variables,
+      config.settings,
+      config.attackRange,
+    ),
+  ];
+  const output = messages.length > 0 ? messages : [ui.statusBalanced];
+  target.replaceChildren(
+    ...output.map((message) => {
+      const item = document.createElement("li");
+      item.textContent = message;
+      return item;
+    }),
+  );
+  target.dataset.state = diagnosticState(a.kind, b.kind, messages.length);
+}
+
+function diagnosticState(a: string, b: string, count: number): string {
+  if (a === "error" || b === "error") return "error";
+  return count > 0 ? "warning" : "ok";
+}
+
+function renderGap(
+  root: HTMLElement,
+  a: FormulaResult | undefined,
+  b: FormulaResult | undefined,
+): void {
+  const gap = a && b ? b.roundedDamage - a.roundedDamage : Number.NaN;
+  const sign = gap > 0 ? "+" : "";
+  setText(
+    root,
+    '[data-result="gap"]',
+    Number.isFinite(gap) ? `${sign}${format(gap)}` : "Error",
+  );
+}
+
+export function renderLab(
+  root: HTMLElement,
+  config: LabConfig,
+  ui: DamageFormulaLabUI,
+): void {
+  const a = inspectFormula(config.formulaA, config.variables, config.settings);
+  const b = inspectFormula(config.formulaB, config.variables, config.settings);
+  setResult(root, "a", a.result);
+  setResult(root, "b", b.result);
+  renderGap(root, a.result, b.result);
+  renderDiagnostics(root, config, ui);
+  renderVisuals(root, config);
+}
+
+function renderVisuals(root: HTMLElement, config: LabConfig): void {
+  try {
+    const curveA = buildCurve(
+      config.formulaA,
+      config.variables,
+      config.settings,
+      config.attackRange,
+    );
+    const curveB = buildCurve(
+      config.formulaB,
+      config.variables,
+      config.settings,
+      config.attackRange,
+    );
+    renderCurve(root, curveA, curveB);
+    renderHeatmap(
+      root,
+      buildHeatmap({
+        expression: config.formulaA,
+        variables: config.variables,
+        settings: config.settings,
+        attackRange: { ...config.attackRange, steps: 9 },
+        defenseRange: config.defenseRange,
+      }),
+    );
+  } catch {
+    renderCurve(root, [], []);
+    renderHeatmap(root, []);
+  }
+}

package/src/tool/damageFormulaLab/entry.ts

@@ -0,0 +1,28 @@
+import type { GamesToolEntry, ToolLocaleContent } from "../../types";
+import type { DamageFormulaLabUI } from "./ui";
+
+export type { DamageFormulaLabUI };
+export type DamageFormulaLabLocaleContent =
+  ToolLocaleContent<DamageFormulaLabUI>;
+
+export const damageFormulaLab: GamesToolEntry<DamageFormulaLabUI> = {
+  id: "damage-formula-lab",
+  icons: { bg: "mdi:sword-cross", fg: "mdi:function-variant" },
+  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/damageFormulaLab/evaluator.ts

@@ -0,0 +1,84 @@
+import { buildCurve, evaluateExpression, evaluateFormula } from "./logic";
+import type {
+  CombatSettings,
+  FormulaResult,
+  FormulaVariables,
+  SamplePoint,
+  SweepRange,
+} from "./logic";
+
+export type DiagnosticKind = "ok" | "warning" | "error";
+
+export interface FormulaEvaluation {
+  result?: FormulaResult;
+  diagnostics: string[];
+  kind: DiagnosticKind;
+}
+
+function curveDiagnostics(points: SamplePoint[]): string[] {
+  const messages: string[] = [];
+  if (points.some((point) => point.roundedDamage <= 0))
+    messages.push("The sweep contains a zero damage region.");
+  const cliffs = points.slice(1).filter((point, index) => {
+    const previous = points[index]?.roundedDamage ?? 0;
+    return (
+      previous > 0 && Math.abs(point.roundedDamage - previous) / previous > 0.5
+    );
+  });
+  if (cliffs.length > 0)
+    messages.push("The sweep contains a damage jump above 50%.");
+  const ttkSteps = new Set(points.map((point) => point.hitsToKill));
+  if (ttkSteps.size > Math.ceil(points.length * 0.65))
+    messages.push(
+      "Small attack changes create frequent hit count breakpoints.",
+    );
+  return messages;
+}
+
+export function inspectFormula(
+  expression: string,
+  variables: FormulaVariables,
+  settings: CombatSettings,
+): FormulaEvaluation {
+  try {
+    const raw = evaluateExpression(expression, variables);
+    const result = evaluateFormula(expression, variables, settings);
+    const diagnostics: string[] = [];
+    if (raw < 0)
+      diagnostics.push(
+        "The formula is negative before modifiers and clamping.",
+      );
+    if (result.roundedDamage <= 0)
+      diagnostics.push("This setup cannot damage the target.");
+    if (Math.abs(result.expectedDamage - result.roundedDamage) >= 0.5)
+      diagnostics.push("Rounding changes expected damage by at least 0.5.");
+    return {
+      result,
+      diagnostics,
+      kind: diagnostics.length > 0 ? "warning" : "ok",
+    };
+  } catch (error) {
+    const message =
+      error instanceof Error
+        ? error.message
+        : "The formula could not be evaluated";
+    return { diagnostics: [message], kind: "error" };
+  }
+}
+
+export function inspectSweep(
+  expression: string,
+  variables: FormulaVariables,
+  settings: CombatSettings,
+  range: SweepRange,
+): string[] {
+  try {
+    return curveDiagnostics(buildCurve(expression, variables, settings, range));
+  } catch (error) {
+    return [
+      error instanceof Error
+        ? error.message
+        : "The sweep could not be evaluated",
+    ];
+  }
+}

package/src/tool/damageFormulaLab/expression.ts

@@ -0,0 +1,191 @@
+import type { FormulaVariables } from "./logic";
+
+type Token =
+  | { kind: "number"; value: number }
+  | { kind: "name"; value: string }
+  | { kind: "symbol"; value: string };
+
+const FUNCTIONS: Record<string, (...values: number[]) => number> = {
+  abs: Math.abs,
+  ceil: Math.ceil,
+  clamp: (value, min, max) => Math.min(Math.max(value, min), max),
+  floor: Math.floor,
+  max: Math.max,
+  min: Math.min,
+  pow: Math.pow,
+  round: Math.round,
+  sqrt: Math.sqrt,
+};
+
+const PRECEDENCE: Record<string, number> = {
+  "+": 1,
+  "-": 1,
+  "*": 2,
+  "/": 2,
+  "^": 3,
+  neg: 3,
+};
+
+function readNumber(expression: string, start: number): [Token, number] {
+  const match = expression
+    .slice(start)
+    .match(/^(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?/i);
+  if (!match) throw new Error(`Invalid number at position ${start + 1}`);
+  return [{ kind: "number", value: Number(match[0]) }, start + match[0].length];
+}
+
+function readName(expression: string, start: number): [Token, number] {
+  const match = expression.slice(start).match(/^[a-z][a-z0-9_]*/i);
+  if (!match) throw new Error(`Invalid name at position ${start + 1}`);
+  return [{ kind: "name", value: match[0] }, start + match[0].length];
+}
+
+export function tokenize(expression: string): Token[] {
+  const tokens: Token[] = [];
+  let index = 0;
+  while (index < expression.length) {
+    const character = expression[index] ?? "";
+    if (/\s/.test(character)) index += 1;
+    else if (/[\d.]/.test(character)) {
+      const [token, next] = readNumber(expression, index);
+      tokens.push(token);
+      index = next;
+    } else if (/[a-z_]/i.test(character)) {
+      const [token, next] = readName(expression, index);
+      tokens.push(token);
+      index = next;
+    } else if ("+-*/^(),".includes(character)) {
+      tokens.push({ kind: "symbol", value: character });
+      index += 1;
+    } else throw new Error(`Unsupported character at position ${index + 1}`);
+  }
+  if (tokens.length === 0) throw new Error("Enter a damage formula");
+  return tokens;
+}
+
+class Parser {
+  private index = 0;
+  constructor(
+    private readonly tokens: Token[],
+    private readonly variables: FormulaVariables,
+  ) {}
+
+  parse(): number {
+    const value = this.expression(0);
+    if (this.index !== this.tokens.length) throw new Error("Unexpected token");
+    return value;
+  }
+
+  private expression(minimum: number): number {
+    let left = this.prefix();
+    while (this.isBinary() && this.precedence() >= minimum) {
+      const operator = this.takeSymbol();
+      const nextMinimum =
+        (PRECEDENCE[operator] ?? 0) + (operator === "^" ? 0 : 1);
+      left = calculate(operator, left, this.expression(nextMinimum));
+    }
+    return left;
+  }
+
+  private prefix(): number {
+    const token = this.tokens[this.index];
+    if (!token) throw new Error("Formula ended unexpectedly");
+    if (token.kind === "number") {
+      this.index += 1;
+      return token.value;
+    }
+    if (token.kind === "name") return this.nameValue(token.value);
+    if (token.kind === "symbol") return this.symbolValue(token.value);
+    throw new Error("Expected a number, variable, function, or group");
+  }
+
+  private symbolValue(symbol: string): number {
+    if (symbol === "-") {
+      this.index += 1;
+      return -this.expression(PRECEDENCE.neg ?? 3);
+    }
+    if (symbol === "(") return this.group();
+    throw new Error("Expected a number, variable, function, or group");
+  }
+
+  private nameValue(name: string): number {
+    this.index += 1;
+    const next = this.tokens[this.index];
+    if (next?.kind === "symbol" && next.value === "(")
+      return this.callFunction(name);
+    if (!(name in this.variables)) throw new Error(`Unknown variable: ${name}`);
+    return this.variables[name as keyof FormulaVariables];
+  }
+
+  private callFunction(name: string): number {
+    const callable = FUNCTIONS[name];
+    if (!callable) throw new Error(`Unknown function: ${name}`);
+    this.index += 1;
+    const values: number[] = [];
+    if (!this.isSymbol(")")) {
+      values.push(this.expression(0));
+      while (this.isSymbol(",")) {
+        this.index += 1;
+        values.push(this.expression(0));
+      }
+    }
+    this.expect(")");
+    return callable(...values);
+  }
+
+  private group(): number {
+    this.index += 1;
+    const value = this.expression(0);
+    this.expect(")");
+    return value;
+  }
+
+  private expect(symbol: string): void {
+    if (!this.isSymbol(symbol)) throw new Error(`Expected ${symbol}`);
+    this.index += 1;
+  }
+
+  private takeSymbol(): string {
+    const token = this.tokens[this.index];
+    if (token?.kind !== "symbol") throw new Error("Expected an operator");
+    this.index += 1;
+    return token.value;
+  }
+
+  private isSymbol(symbol: string): boolean {
+    const token = this.tokens[this.index];
+    return token?.kind === "symbol" && token.value === symbol;
+  }
+
+  private isBinary(): boolean {
+    const token = this.tokens[this.index];
+    return (
+      token?.kind === "symbol" &&
+      token.value in PRECEDENCE &&
+      token.value !== "neg"
+    );
+  }
+
+  private precedence(): number {
+    const token = this.tokens[this.index];
+    return token?.kind === "symbol" ? (PRECEDENCE[token.value] ?? -1) : -1;
+  }
+}
+
+function calculate(operator: string, left: number, right: number): number {
+  if (operator === "+") return left + right;
+  if (operator === "-") return left - right;
+  if (operator === "*") return left * right;
+  if (operator === "/") return left / right;
+  return left ** right;
+}
+
+export function evaluateExpression(
+  expression: string,
+  variables: FormulaVariables,
+): number {
+  const result = new Parser(tokenize(expression), variables).parse();
+  if (!Number.isFinite(result))
+    throw new Error("Formula produced a non-finite value");
+  return result;
+}

package/src/tool/damageFormulaLab/i18n/de.ts

@@ -0,0 +1,194 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { DamageFormulaLabUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+const slug = 'spiel-schadensformel-rechner-ttk';
+const title = 'Damage Formula Lab mit TTK Diagrammen';
+const description = 'Vergleichen Sie sichere Schadensformeln für Spiele mit Echtzeit-Kurven, Heatmaps, Rundungs-Breakpoints, Trefferanzahl und Time-to-Kill (TTK).';
+
+const faq = [
+  {
+    question: 'Was vergleicht der Schadensformel-Rechner?',
+    answer: 'Er führt zwei mathematische Formeln sicher gegen dieselben Kampfwerte aus. Sie können Schadenskurven, Trefferschwellen, Time to Kill (TTK), Rundungsregeln und Rüstungs-Heatmaps ohne JavaScript-Ausführung vergleichen.',
+  },
+  {
+    question: 'Welche Variablen und Funktionen stehen zur Verfügung?',
+    answer: 'Verfügbare Variablen sind attack, defense, level, power, resistance, flat, criticalChance und criticalMultiplier. Sichere Funktionen sind min, max, clamp, abs, sqrt, pow, floor, round und ceil.',
+  },
+  {
+    question: 'Wie wird die Time to Kill (TTK) berechnet?',
+    answer: 'Erforderliche Treffer sind die Ziel-Gesundheit geteilt durch den gerundeten Erwartungsschaden (aufgerundet). TTK misst das Intervall zwischen erstem und letztem Treffer: (Treffer - 1) / Angriffe pro Sekunde.',
+  },
+  {
+    question: 'Warum spielt die Reihenfolge der Widerstände eine Rolle?',
+    answer: 'Wird ein flacher Modifikator vor der prozentualen Resistenz angewendet, reduziert die Resistenz auch diesen Wert. Wird die Resistenz zuerst angewendet, bleibt der flache Modifikator unberührt.',
+  },
+  {
+    question: 'Bedeutet eine glatte Schadenskurve ein ausbalanciertes Spiel?',
+    answer: 'Nein. Eine Kurve zeigt Schwellenwerte und Nullschadenszonen, aber Balance hängt vom Spielkontext, Feedback und Spieltests ab.',
+  },
+];
+
+const howTo = [
+  { name: 'Zwei Formeln wählen', text: 'Starten Sie mit einer Vorlage (linear, Verhältnis, Level-Skalierung) oder geben Sie zwei eigene Formeln ein.' },
+  { name: 'Kampfzustand einstellen', text: 'Geben Sie Werte für Angriff, Verteidigung, Level, Kraftkoeffizient, Resistenz, flachen Modifikator, Krit-Werte, Gesundheit und Kadenz ein.' },
+  { name: 'Engine-Regeln festlegen', text: 'Bestimmen Sie, wie der Schaden gerundet wird und ob Resistenzen vor oder nach dem flachen Modifikator wirken.' },
+  { name: 'Kurven und Schwellen analysieren', text: 'Vergleichen Sie Schadensverlauf, Angriffs-Sweep, Verteidigungs-Heatmap, Trefferanzahl und Warnhinweise.' },
+  { name: 'Experiment speichern', text: 'Kopieren Sie einen Freigabelink oder laden Sie die Konfiguration als JSON, CSV oder Diagramm-PNG herunter.' },
+];
+
+const softwareApplication: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+};
+
+const faqPage: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+};
+
+export const content: ToolLocaleContent<DamageFormulaLabUI> = {
+  slug,
+  title,
+  description,
+  ui: {
+    onboarding: 'Geben Sie Ihre aktuelle Schadensregel ein, stellen Sie eine Alternative gegenüber und passen Sie die Kampfwerte an.',
+    localNote: 'Privates Modell. Formeln und Daten verbleiben in diesem Browser.',
+    formulaDeck: 'Formelkammer',
+    formulaALabel: 'Formel A (Aktuelles Modell)',
+    formulaBLabel: 'Formel B (Herausforderer)',
+    formulaHint: 'Variablen: attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier',
+    formulaFunctions: 'Funktionen: min, max, clamp, abs, sqrt, pow, floor, round, ceil',
+    presetLinear: 'Linearer Schutz',
+    presetRatio: 'Verhältnis-Rüstung',
+    presetLevel: 'Level-Skalierung',
+    combatInputs: 'Kampfzustand',
+    attackLabel: 'Angriff',
+    defenseLabel: 'Verteidigung',
+    levelLabel: 'Level',
+    powerLabel: 'Kraftkoeffizient',
+    resistanceLabel: 'Resistenz (%)',
+    flatLabel: 'Flacher Modifikator',
+    criticalChanceLabel: 'Kritische Chance (%)',
+    criticalMultiplierLabel: 'Kritischer Multiplikator',
+    healthLabel: 'Ziel-Gesundheit',
+    cadenceLabel: 'Angriffe pro Sekunde',
+    roundingLabel: 'Schadensrundung',
+    roundingNone: 'Dezimalstellen behalten',
+    roundingFloor: 'Abrunden (Floor)',
+    roundingRound: 'Nächste Ganzzahl',
+    roundingCeil: 'Aufrunden (Ceil)',
+    orderLabel: 'Modifikator-Reihenfolge',
+    resistanceFirst: 'Resistenz dann Flach',
+    flatFirst: 'Flach dann Resistenz',
+    runLabel: 'Vergleich im Live-Modell',
+    resultDamage: 'Erwarteter Schaden',
+    resultHits: 'Treffer bis Besiegung',
+    resultTtk: 'Time to Kill (TTK)',
+    resultDifference: 'Schadensdifferenz',
+    formulaAName: 'Aktuell',
+    formulaBName: 'Herausforderer',
+    curveTitle: 'Angriffs-Verlaufskurve',
+    curveCaption: 'Der Angriffswert wird von der Hälfte bis zum Doppelten variiert, während die Verteidigung fest bleibt.',
+    heatmapTitle: 'Druckfeld-Heatmap',
+    heatmapCaption: 'Zeigt den Erwartungsschaden von Formel A über verschiedene Angriff- und Verteidigungskombinationen.',
+    attackAxis: 'Angriff steigt nach rechts',
+    defenseAxis: 'Verteidigung steigt nach unten',
+    scenariosTitle: 'Kampfszenarien',
+    scenarioSkirmisher: 'Plänkler',
+    scenarioGuardian: 'Wächter',
+    scenarioBoss: 'Boss',
+    scenarioCustom: 'Aktuelles Setup',
+    diagnosticsTitle: 'Schwellenwerte & Warnungen',
+    statusBalanced: 'Keine auffälligen mathematischen Sprünge im Testbereich erkannt.',
+    exportTitle: 'Experiment exportieren',
+    copyLink: 'Freigabelink kopieren',
+    exportCsv: 'CSV herunterladen',
+    exportJson: 'JSON herunterladen',
+    importJson: 'JSON importieren',
+    exportPng: 'Diagramm PNG herunterladen',
+    reset: 'Modell zurücksetzen',
+    privacyDisclosure: 'Der Freigabelink speichert die Konfiguration in der URL-Hash und sendet sie nicht an Server.',
+    limitationDisclosure: 'Der kritische Erwartungsschaden ist ein Durchschnitt und keine stochastische Simulation.',
+    importError: 'Die Datei ist keine gültige Konfiguration.',
+    copiedStatus: 'Freigabelink in die Zwischenablage kopiert.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Schadensformeln vor der Implementierung in der Spiel-Engine testen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine Schadensformel kann bei einzelnen Beispielwerten gut funktionieren, aber bei extremen Fortschrittswerten zusammenbrechen. Dieses Labor zeigt Schwellenwerte und Nullschadenszonen frühzeitig auf.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Sichere mathematische Auswertung ohne Code-Risiken',
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Formelfeld akzeptiert vordefinierte Variablen und mathematische Funktionen ohne Ausführung von ungesichertem Code.',
+    },
+    {
+      type: 'table',
+      headers: ['Messwert', 'Berechnung', 'Designfrage'],
+      rows: [
+        ['Erwarteter Schaden', 'Grundformel inklusive Krit-Faktor und Widerstand', 'Verhält sich die Regel bei schwachen und starken Einheiten sinnvoll?'],
+        ['Treffer bis Besiegung', 'Ziel-Gesundheit geteilt durch gerundeten Schaden', 'Führt ein einziger Statuspunkt zum Wegfall eines kompletten Treffers?'],
+        ['Time to Kill (TTK)', 'Intervalle zwischen Treffern geteilt durch Kadenz', 'Erzeugt die Frequenz den gewünschten Kampfrhythmus?'],
+        ['Druckfeld', 'Rasteranalyse von Formel A über Angriff und Verteidigung', 'Gibt es abrupte Schwellen oder tote Zonen?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Mathematische Daten von Game-Design-Entscheidungen trennen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein mathematisch sauberer Graph garantiert noch kein unterhaltsames Spiel. Nutzen Sie das Labor, um Annahmen gezielt in Spieltests zu überprüfen.',
+    },
+    {
+      type: 'tip',
+      title: 'Schaden und Trefferanzahl stets gemeinsam betrachten',
+      html: 'Eine kleine Schadensänderung kann eine gesundheitsbezogene Schwelle überschreiten und einen Treffer einsparen. Vergleichen Sie Schadenswerte immer mit Treffern und TTK.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Rundung und Widerstandsreihenfolge sichtbar machen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die gleiche Formel kann je nach Rundung und Reihenfolge der Modifikatoren ein anderes Kampfergebnis liefern. Prüfen Sie deshalb nicht nur den mittleren Kurvenbereich, sondern auch kleine Trefferwerte, hohe Verteidigung und die Schwelle, an der ein weiterer Treffer nötig wird.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die TTK-Anzeige ist eine mathematische Projektion auf Basis der eingegebenen Angriffskadenz. Sie berücksichtigt keine Ausweichbewegung, Cooldowns, Zufallsfolgen oder Unterbrechungen; verwenden Sie die Kurven als Designhilfe und validieren Sie die Regel anschließend im Spieltest.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Referenzen zur Schadensberechnung in Spielen',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};