@jjlmoya/utils-games-development 1.63.0 → 1.64.0

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

@@ -0,0 +1,231 @@
+import type {
+  FAQPage,
+  HowTo,
+  SoftwareApplication,
+  WithContext,
+} from "schema-dts";
+import type { ToolLocaleContent } from "../../../types";
+import type { DamageFormulaLabUI } from "../ui";
+import { bibliographyEntries } from "../bibliography";
+
+const faq = [
+  {
+    question: "What does the damage formula calculator compare?",
+    answer:
+      "It runs two safe mathematical expressions against the same combat variables. You can compare damage curves, hit count breakpoints, time to kill, rounding, resistance order, and a two variable attack and defense heatmap without executing JavaScript.",
+  },
+  {
+    question: "Which variables and functions can I use?",
+    answer:
+      "Available variables are attack, defense, level, power, resistance, flat, criticalChance, and criticalMultiplier. Safe functions are min, max, clamp, abs, sqrt, pow, floor, round, and ceil. Operators include addition, subtraction, multiplication, division, exponentiation, and parentheses.",
+  },
+  {
+    question: "How is time to kill calculated?",
+    answer:
+      "Hits to kill is target health divided by rounded expected damage, rounded upward. Time to kill is the interval between the first and final hit, so the tool uses hits minus one divided by attacks per second. A one hit kill therefore has a time to kill of zero seconds.",
+  },
+  {
+    question: "Why can resistance order change the result?",
+    answer:
+      "Applying a flat modifier before percentage resistance also reduces that flat amount. Applying resistance first leaves the later flat modifier untouched. The lab exposes both pipelines because engines and combat designs may intentionally choose different orders.",
+  },
+  {
+    question: "Does a smoother curve mean the game is balanced?",
+    answer:
+      "No. A curve can reveal cliffs, zero damage zones, and breakpoints, but balance depends on goals, player choices, encounter context, feedback, and playtesting. The lab reports numerical behavior and never presents a universal balance verdict.",
+  },
+];
+
+const howTo = [
+  {
+    name: "Choose two formulas",
+    text: "Start from the linear, ratio, or level scaled presets, then edit Formula A and Formula B with the documented variables and safe functions.",
+  },
+  {
+    name: "Set one combat state",
+    text: "Enter attack, defense, level, power, resistance, flat adjustment, critical settings, target health, and attack cadence.",
+  },
+  {
+    name: "Make engine rules explicit",
+    text: "Choose how damage is rounded and whether resistance applies before or after the flat modifier.",
+  },
+  {
+    name: "Read curves and breakpoints",
+    text: "Compare the impact trajectory, attack sweep, defense heatmap, hit count, time to kill, and diagnostic warnings.",
+  },
+  {
+    name: "Preserve the experiment",
+    text: "Copy a shareable URL fragment or download the configuration, CSV samples, or chart image. All processing remains in the browser.",
+  },
+];
+
+const softwareApplication: WithContext<SoftwareApplication> = {
+  "@context": "https://schema.org",
+  "@type": "SoftwareApplication",
+  name: "Damage Formula Lab with TTK Charts",
+  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: "How to compare game damage formulas and time to kill",
+  step: howTo.map((step) => ({
+    "@type": "HowToStep",
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+export const content: ToolLocaleContent<DamageFormulaLabUI> = {
+  slug: "game-damage-formula-calculator-ttk",
+  title: "Damage Formula Lab with TTK Charts",
+  description:
+    "Compare safe game damage formulas through live curves, attack and defense heatmaps, rounding breakpoints, criticals, hits to kill, and time to kill.",
+  ui: {
+    onboarding:
+      "Write the damage rule you use now, place an alternative beside it, then tune one combat state. The proving ground shows where each formula lands and how it behaves beyond the comfortable middle.",
+    localNote: "Private combat model. Formulas and files stay in this browser.",
+    formulaDeck: "Formula chamber",
+    formulaALabel: "Formula A current model",
+    formulaBLabel: "Formula B challenger",
+    formulaHint:
+      "Variables: attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier",
+    formulaFunctions:
+      "Safe functions: min, max, clamp, abs, sqrt, pow, floor, round, ceil",
+    presetLinear: "Linear guard",
+    presetRatio: "Ratio armor",
+    presetLevel: "Level scale",
+    combatInputs: "Combat state",
+    attackLabel: "Attack",
+    defenseLabel: "Defense",
+    levelLabel: "Level",
+    powerLabel: "Power coefficient",
+    resistanceLabel: "Resistance percent",
+    flatLabel: "Flat modifier",
+    criticalChanceLabel: "Critical chance percent",
+    criticalMultiplierLabel: "Critical multiplier",
+    healthLabel: "Target health",
+    cadenceLabel: "Attacks per second",
+    roundingLabel: "Damage rounding",
+    roundingNone: "Keep decimals",
+    roundingFloor: "Floor",
+    roundingRound: "Nearest integer",
+    roundingCeil: "Ceiling",
+    orderLabel: "Modifier order",
+    resistanceFirst: "Resistance then flat",
+    flatFirst: "Flat then resistance",
+    runLabel: "Live impact comparison",
+    resultDamage: "Expected damage",
+    resultHits: "Hits to defeat",
+    resultTtk: "Time to defeat",
+    resultDifference: "Damage gap",
+    formulaAName: "Current",
+    formulaBName: "Challenger",
+    curveTitle: "Attack trajectory",
+    curveCaption:
+      "Attack sweeps from half to twice the current value while defense stays fixed.",
+    heatmapTitle: "Pressure field",
+    heatmapCaption:
+      "Each tile shows Formula A expected damage across attack and defense combinations.",
+    attackAxis: "Attack increases to the right",
+    defenseAxis: "Defense increases downward",
+    scenariosTitle: "Combat silhouettes",
+    scenarioSkirmisher: "Skirmisher",
+    scenarioGuardian: "Guardian",
+    scenarioBoss: "Boss",
+    scenarioCustom: "Current setup",
+    diagnosticsTitle: "Breakpoint watch",
+    statusBalanced:
+      "No numerical hazard detected in this sweep. This is not a balance verdict.",
+    exportTitle: "Carry the experiment",
+    copyLink: "Copy share link",
+    exportCsv: "Download CSV",
+    exportJson: "Download JSON",
+    importJson: "Import JSON",
+    exportPng: "Download chart PNG",
+    reset: "Reset model",
+    privacyDisclosure:
+      "The share link stores configuration in the URL fragment. It is not sent to a server by this tool.",
+    limitationDisclosure:
+      "Expected critical damage is an average, not a random combat simulation. Animation locks, reloads, misses, status effects, player decisions, and encounter rules are outside this model.",
+    importError: "That file is not a compatible damage lab configuration.",
+    copiedStatus: "Share link copied to the clipboard.",
+  },
+  seo: [
+    {
+      type: "title",
+      level: 2,
+      text: "Compare game damage formulas before they become combat rules",
+    },
+    {
+      type: "paragraph",
+      html: "A damage formula may feel reasonable at one attack and defense pair while collapsing at progression extremes. This lab evaluates two formulas against the same state, then repeats the calculation across a controlled sweep. It makes zero damage regions, sudden jumps, rounding thresholds, and hit count breakpoints visible before the rule is embedded in a game engine.",
+    },
+    {
+      type: "title",
+      level: 2,
+      text: "Use a restricted expression language instead of executable code",
+    },
+    {
+      type: "paragraph",
+      html: "The formula field accepts named combat variables, arithmetic operators, parentheses, and a short list of mathematical functions. It does not evaluate JavaScript, access browser APIs, or call arbitrary functions. Division by zero and non finite output become visible errors instead of silently contaminating the chart and exports.",
+    },
+    {
+      type: "table",
+      headers: ["Output", "Calculation", "Design question"],
+      rows: [
+        [
+          "Expected damage",
+          "Base formula with expected critical factor, modifier order, resistance, and selected rounding",
+          "Does the same rule behave sensibly for weak and strong combatants?",
+        ],
+        [
+          "Hits to defeat",
+          "Target health divided by rounded damage, rounded upward",
+          "Where does one stat point remove an entire required hit?",
+        ],
+        [
+          "Time to defeat",
+          "Intervals between required hits divided by attacks per second",
+          "Does cadence create the intended combat rhythm?",
+        ],
+        [
+          "Pressure field",
+          "Formula A sampled across attack and defense ranges",
+          "Are there dead zones, cliffs, or unexpectedly flat regions?",
+        ],
+      ],
+    },
+    {
+      type: "title",
+      level: 2,
+      text: "Separate arithmetic evidence from a balance verdict",
+    },
+    {
+      type: "paragraph",
+      html: "A smooth graph is not proof that combat is fair, expressive, or enjoyable. Numeric relationships only gain meaning beside health, cadence, progression, encounter roles, player options, and the intended experience. Use the lab to find questions worth playtesting, preserve reproducible configurations, and compare implementation rules without presenting one universal formula as correct.",
+    },
+    {
+      type: "tip",
+      title: "Inspect both damage and hit count",
+      html: "A small damage change can look harmless on a curve but cross a health breakpoint and remove a full attack. Compare the damage line with hits to defeat and time to defeat whenever you adjust rounding, criticals, resistance, or attack cadence.",
+    },
+  ],
+  faq,
+  bibliographyTitle: "Damage modelling references",
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};

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

@@ -0,0 +1,181 @@
+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 = 'calculadora-formulas-dano-juegos-ttk';
+const title = 'Laboratorio de Fórmulas de Daño y Gráficos TTK';
+const description = 'Compara fórmulas de daño para videojuegos en tiempo real mediante curvas, mapas de calor, puntos de redondeo, críticos y tiempo para derrotar al objetivo (TTK).';
+
+const faq = [
+  {
+    question: '¿Qué compara la calculadora de fórmulas de daño?',
+    answer: 'Evalúa dos expresiones matemáticas seguras contra las mismas variables de combate. Permite comparar curvas de daño, saltos en cantidad de golpes, tiempo para derrotar (TTK), reglas de redondeo, orden de resistencias y mapas de calor sin ejecutar JavaScript.',
+  },
+  {
+    question: '¿Qué variables y funciones puedo utilizar?',
+    answer: 'Las variables disponibles son attack, defense, level, power, resistance, flat, criticalChance y criticalMultiplier. Las funciones seguras son min, max, clamp, abs, sqrt, pow, floor, round y ceil. Admite operadores aritméticos y paréntesis.',
+  },
+  {
+    question: '¿Cómo se calcula el tiempo para derrotar (TTK)?',
+    answer: 'Los golpes necesarios resultan de dividir la vida del objetivo entre el daño esperado redondeado (hacia arriba). El TTK mide el intervalo entre el primer y el último golpe, por lo que usa (golpes - 1) / ataques por segundo. Si se elimina de un golpe, el TTK es 0 segundos.',
+  },
+  {
+    question: '¿Por qué influye el orden de aplicación de la resistencia?',
+    answer: 'Aplicar un modificador plano antes del porcentaje de resistencia también reduce ese valor plano. Aplicar la resistencia primero deja el modificador plano posterior intacto. El laboratorio expone ambos flujos porque distintos motores de juego eligen reglas diferentes.',
+  },
+  {
+    question: '¿Una curva suave asegura que el juego esté equilibrado?',
+    answer: 'No. Una curva revela zonas de daño cero, acantilados y saltos de efectividad, pero el equilibrio depende del contexto del encuentro, roles, ritmo e iteración en pruebas de juego. La herramienta ofrece datos numéricos y nunca un veredicto universal.',
+  },
+];
+
+const howTo = [
+  { name: 'Elegir dos fórmulas', text: 'Selecciona una plantilla de partida (lineal, ratio o escalado por nivel) o escribe tus propias fórmulas A y B.' },
+  { name: 'Ajustar el estado de combate', text: 'Ingresa los valores de ataque, defensa, nivel, coeficiente de poder, porcentaje de resistencia, modificador plano, críticos, vida y cadencia.' },
+  { name: 'Definir las reglas del motor', text: 'Configura cómo se redondea el daño y si la resistencia se aplica antes o después del modificador plano.' },
+  { name: 'Analizar curvas y umbrales', text: 'Compara la trayectoria del impacto, el barrido de ataque, el mapa de calor defensivo, los golpes necesarios y los avisos de diagnóstico.' },
+  { name: 'Preservar el experimento', text: 'Copia un enlace compartible o descarga la configuración en JSON, la tabla en CSV o la imagen PNG del gráfico.' },
+];
+
+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: 'Escribe la regla de daño actual, coloca una alternativa al lado y ajusta el estado de combate. El laboratorio muestra cómo se comportan ambas fórmulas en los extremos de progresión.',
+    localNote: 'Modelo de combate privado. Las fórmulas y archivos se mantienen en este navegador.',
+    formulaDeck: 'Cámara de fórmulas',
+    formulaALabel: 'Fórmula A (Modelo actual)',
+    formulaBLabel: 'Fórmula B (Alternativa)',
+    formulaHint: 'Variables: attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier',
+    formulaFunctions: 'Funciones seguras: min, max, clamp, abs, sqrt, pow, floor, round, ceil',
+    presetLinear: 'Protección lineal',
+    presetRatio: 'Armadura por ratio',
+    presetLevel: 'Escalado por nivel',
+    combatInputs: 'Estado de combate',
+    attackLabel: 'Ataque',
+    defenseLabel: 'Defensa',
+    levelLabel: 'Nivel',
+    powerLabel: 'Coeficiente de poder',
+    resistanceLabel: 'Porcentaje de resistencia',
+    flatLabel: 'Modificador plano',
+    criticalChanceLabel: 'Probabilidad de crítico (%)',
+    criticalMultiplierLabel: 'Multiplicador de crítico',
+    healthLabel: 'Vida del objetivo',
+    cadenceLabel: 'Ataques por segundo',
+    roundingLabel: 'Redondeo del daño',
+    roundingNone: 'Conservar decimales',
+    roundingFloor: 'Redondear hacia abajo (Floor)',
+    roundingRound: 'Entero más cercano',
+    roundingCeil: 'Redondear hacia arriba (Ceil)',
+    orderLabel: 'Orden de modificadores',
+    resistanceFirst: 'Resistencia y luego plano',
+    flatFirst: 'Plano y luego resistencia',
+    runLabel: 'Comparativa de impacto en vivo',
+    resultDamage: 'Daño esperado',
+    resultHits: 'Golpes para derrotar',
+    resultTtk: 'Tiempo para derrotar (TTK)',
+    resultDifference: 'Diferencia de daño',
+    formulaAName: 'Actual',
+    formulaBName: 'Alternativa',
+    curveTitle: 'Trayectoria por nivel de ataque',
+    curveCaption: 'El ataque se barre desde la mitad hasta el doble del valor actual mientras la defensa se mantiene fija.',
+    heatmapTitle: 'Campo de presión',
+    heatmapCaption: 'Cada celda muestra el daño esperado de la Fórmula A en combinaciones de ataque y defensa.',
+    attackAxis: 'El ataque aumenta hacia la derecha',
+    defenseAxis: 'La defensa aumenta hacia abajo',
+    scenariosTitle: 'Siluetas de combate',
+    scenarioSkirmisher: 'Hostigador',
+    scenarioGuardian: 'Guardián',
+    scenarioBoss: 'Jefe final',
+    scenarioCustom: 'Ajuste actual',
+    diagnosticsTitle: 'Puntos críticos y saltos',
+    statusBalanced: 'No se detectan anomalías numéricas en este barrido. Esto no constituye un veredicto de equilibrio.',
+    exportTitle: 'Exportar experimento',
+    copyLink: 'Copiar enlace compartible',
+    exportCsv: 'Descargar CSV',
+    exportJson: 'Descargar JSON',
+    importJson: 'Importar JSON',
+    exportPng: 'Descargar gráfico PNG',
+    reset: 'Restablecer modelo',
+    privacyDisclosure: 'El enlace compartible guarda la configuración en el fragmento de la URL y no se envía a servidores.',
+    limitationDisclosure: 'El daño crítico esperado es un promedio y no una simulación estocástica. Bloqueos de animación, recargas, fallos y estados no están incluidos.',
+    importError: 'El archivo seleccionado no es una configuración válida del laboratorio de daño.',
+    copiedStatus: 'Enlace compartible copiado al portapapeles.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Compara fórmulas de daño en juegos antes de integrarlas en tu motor',
+    },
+    {
+      type: 'paragraph',
+      html: 'Una fórmula de daño puede parecer equilibrada en un par concreto de ataque y defensa pero romperse en los extremos de la progresión. Este laboratorio evalúa dos fórmulas contra el mismo estado y analiza su comportamiento a lo largo de un rango controlado, asegurando que las anomalías sean visibles antes de programar las reglas.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Lenguaje de expresiones restringido y seguro',
+    },
+    {
+      type: 'paragraph',
+      html: 'El campo de fórmula acepta variables numéricas con nombre, operadores aritméticos y funciones matemáticas estándar. No evalúa código JavaScript ejecutable, evitando riesgos de seguridad y permitiendo la estabilidad de las gráficas.',
+    },
+    {
+      type: 'table',
+      headers: ['Métrica', 'Cálculo realizado', 'Pregunta de diseño'],
+      rows: [
+        ['Daño esperado', 'Fórmula base con factor de crítico esperado, orden de modificadores y redondeo', '¿La regla responde de forma coherente en personajes débiles y fuertes?'],
+        ['Golpes para derrotar', 'Vida del objetivo dividida entre el daño redondeado (hacia arriba)', '¿Un solo punto de estadística elimina un golpe completo requerido?'],
+        ['Tiempo para derrotar (TTK)', 'Intervalos entre golpes divididos entre los ataques por segundo', '¿La cadencia crea el ritmo de combate deseado?'],
+        ['Campo de presión', 'Muestra de la Fórmula A en combinaciones de ataque y defensa', '¿Existen zonas muertas, acantilados o mesetas inesperadas?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Diferenciar la evidencia aritmética del veredicto de diseño',
+    },
+    {
+      type: 'paragraph',
+      html: 'Un gráfico limpio no demuestra por sí solo que un combate sea divertido o justo. Las relaciones numéricas adquieren significado al contrastarse con los roles de combate, la curva de nivel y las pruebas con jugadores.',
+    },
+    {
+      type: 'tip',
+      title: 'Examina tanto el daño por impacto como la cantidad de golpes',
+      html: 'Un cambio pequeño en la cifra de daño puede parecer insignificante en la curva pero cruzar un umbral de vida y reducir un golpe entero. Compara siempre el daño con los golpes para derrotar y el TTK.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Referencias de diseño de combate y matemáticas',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};

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

@@ -0,0 +1,181 @@
+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 = 'calculateur-formules-degats-jeux-ttk';
+const title = 'Laboratoire de Formules de Dégâts et Graphiques TTK';
+const description = 'Comparez des formules de dégâts pour jeux vidéo avec des courbes en direct, cartes thermiques, arrondis, coups critiques et temps pour éliminer (TTK).';
+
+const faq = [
+  {
+    question: 'Que permet de comparer ce calculateur de dégâts ?',
+    answer: 'Il évalue deux expressions mathématiques sécurisées face aux mêmes variables de combat. Vous pouvez comparer les courbes de dégâts, les seuils de coups, le temps pour éliminer (TTK), le comportement de l arrondi et l ordre d application des résistances.',
+  },
+  {
+    question: 'Quelles variables et fonctions sont disponibles ?',
+    answer: 'Les variables disponibles sont attack, defense, level, power, resistance, flat, criticalChance et criticalMultiplier. Les fonctions sécurisées sont min, max, clamp, abs, sqrt, pow, floor, round et ceil.',
+  },
+  {
+    question: 'Comment le temps pour éliminer (TTK) est-il calculé ?',
+    answer: 'Le nombre de coups nécessaires est la santé de la cible divisée par les dégâts attendus arrondis (arrondi au supérieur). Le TTK mesure l intervalle entre le premier et le dernier coup: (coups - 1) / attaques par seconde.',
+  },
+  {
+    question: 'Pourquoi l ordre d application de la résistance est-il important ?',
+    answer: 'Appliquer un modificateur plat avant la résistance en pourcentage réduit également ce montant plat. Appliquer la résistance en premier laisse le modificateur plat intact. Le laboratoire permet de tester les deux configurations.',
+  },
+  {
+    question: 'Une courbe régulière garantit-elle un équilibre parfait ?',
+    answer: 'Non. Une courbe permet de détecter des seuils et des zones à dégâts nuls, mais l équilibrage dépend du contexte de jeu, des rôles et des tests utilisateurs.',
+  },
+];
+
+const howTo = [
+  { name: 'Choisir deux formules', text: 'Partez d un modèle prédéfini (linéaire, ratio ou niveau) ou saisissez vos propres formules A et B.' },
+  { name: 'Régler l état de combat', text: 'Ajustez les valeurs d attaque, défense, niveau, puissance, résistance, dégâts plats, critiques, santé et cadence.' },
+  { name: 'Définir les règles du moteur', text: 'Choisissez le mode d arrondi et précisez si la résistance s applique avant ou après le modificateur plat.' },
+  { name: 'Analyser les courbes et seuils', text: 'Observez la trajectoire de l attaque, la carte thermique, les coups nécessaires et les alertes de diagnostic.' },
+  { name: 'Exporter l expérience', text: 'Copiez un lien de partage ou téléchargez la configuration en JSON, le tableau CSV ou l image PNG du graphique.' },
+];
+
+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: 'Saisissez votre formule actuelle, placez une alternative en regard et ajustez les paramètres de combat.',
+    localNote: 'Modèle privé. Les formules restent dans votre navigateur.',
+    formulaDeck: 'Espace des formules',
+    formulaALabel: 'Formule A (Modèle actuel)',
+    formulaBLabel: 'Formule B (Alternative)',
+    formulaHint: 'Variables: attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier',
+    formulaFunctions: 'Fonctions: min, max, clamp, abs, sqrt, pow, floor, round, ceil',
+    presetLinear: 'Protection linéaire',
+    presetRatio: 'Armure par ratio',
+    presetLevel: 'Échelle de niveau',
+    combatInputs: 'Paramètres de combat',
+    attackLabel: 'Attaque',
+    defenseLabel: 'Défense',
+    levelLabel: 'Niveau',
+    powerLabel: 'Coefficient de puissance',
+    resistanceLabel: 'Résistance (%)',
+    flatLabel: 'Modificateur plat',
+    criticalChanceLabel: 'Chances de coup critique (%)',
+    criticalMultiplierLabel: 'Multiplicateur critique',
+    healthLabel: 'Santé de la cible',
+    cadenceLabel: 'Attaques par seconde',
+    roundingLabel: 'Arrondi des dégâts',
+    roundingNone: 'Conserver les décimales',
+    roundingFloor: 'Arrondi inférieur (Floor)',
+    roundingRound: 'Entier le plus proche',
+    roundingCeil: 'Arrondi supérieur (Ceil)',
+    orderLabel: 'Ordre des modificateurs',
+    resistanceFirst: 'Résistance puis plat',
+    flatFirst: 'Plat puis résistance',
+    runLabel: 'Comparaison en direct',
+    resultDamage: 'Dégâts attendus',
+    resultHits: 'Coups nécessaires',
+    resultTtk: 'Temps pour éliminer (TTK)',
+    resultDifference: 'Écart de dégâts',
+    formulaAName: 'Actuel',
+    formulaBName: 'Alternative',
+    curveTitle: 'Trajectoire de l attaque',
+    curveCaption: 'L attaque varie de la moitié au double de sa valeur pendant que la défense reste fixe.',
+    heatmapTitle: 'Carte thermique de pression',
+    heatmapCaption: 'Chaque case montre les dégâts attendus de la Formule A selon l attaque et la défense.',
+    attackAxis: 'L attaque augmente vers la droite',
+    defenseAxis: 'La défense augmente vers le bas',
+    scenariosTitle: 'Profils de combat',
+    scenarioSkirmisher: 'Escrimeur',
+    scenarioGuardian: 'Gardien',
+    scenarioBoss: 'Boss',
+    scenarioCustom: 'Configuration actuelle',
+    diagnosticsTitle: 'Points de rupture',
+    statusBalanced: 'Aucune anomalie mathématique détectée sur cette plage d essai.',
+    exportTitle: 'Exporter le projet',
+    copyLink: 'Copier le lien',
+    exportCsv: 'Télécharger le CSV',
+    exportJson: 'Télécharger le JSON',
+    importJson: 'Importer un JSON',
+    exportPng: 'Télécharger le PNG du graphique',
+    reset: 'Réinitialiser le modèle',
+    privacyDisclosure: 'Le lien de partage enregistre la configuration dans le fragment d URL sans envoi vers un serveur.',
+    limitationDisclosure: 'Les dégâts critiques attendus sont une moyenne et non une simulation aléatoire.',
+    importError: 'Ce fichier n est pas une configuration valide.',
+    copiedStatus: 'Lien copié dans le presse-papier.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Tester les formules de dégâts avant de les intégrer au moteur',
+    },
+    {
+      type: 'paragraph',
+      html: 'Une formule de dégâts peut sembler équilibrée sur quelques valeurs moyennes mais générer des absurdités aux extrêmes. Ce laboratoire permet de détecter rapidement les zones mortes et les décalages de puissance.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Un langage d évaluation sécurisé et restreint',
+    },
+    {
+      type: 'paragraph',
+      html: 'Le champ de saisie accepte uniquement des variables prédéfinies et des fonctions mathématiques sûres sans exécuter de code arbitraire.',
+    },
+    {
+      type: 'table',
+      headers: ['Indicateur', 'Calcul effectué', 'Question de design'],
+      rows: [
+        ['Dégâts attendus', 'Formule de base incluant le facteur critique et l ordre de résistance', 'La formule reste-t-elle cohérente sur des personnages faibles et puissants ?'],
+        ['Coups nécessaires', 'Santé de la cible divisée par les dégâts arrondis', 'Un point de stat supplémentaire fait-il disparaître un coup entier ?'],
+        ['Temps pour éliminer (TTK)', 'Intervalle entre les coups divisé par la cadence d attaque', 'La cadence crée-t-elle le rythme de jeu souhaité ?'],
+        ['Carte thermique', 'Échantillonnage de la Formule A sur l attaque et la défense', 'Existe-t-il des seuils ou des ruptures anormales ?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Séparer la logique mathématique des choix d équilibrage',
+    },
+    {
+      type: 'paragraph',
+      html: 'Une courbe fluide n est pas une preuve de plaisir de jeu. Utilisez ce laboratoire pour identifier les valeurs à tester lors des sessions de playtest.',
+    },
+    {
+      type: 'tip',
+      title: 'Observer conjointement les dégâts et le nombre de coups',
+      html: 'Une légère variation de dégâts peut franchir un seuil de santé et supprimer un coup complet. Comparez toujours les dégâts avec le nombre de coups et le TTK.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Références sur la modélisation des dégâts',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};