@jjlmoya/utils-games-development 1.63.0 → 1.64.0

package/src/tool/damageFormulaLab/i18n/tr.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 = 'oyun-hasar-formulu-hesaplayici-ttk';
+const title = 'Oyun Hasar Formülü Laboratuvarı ve TTK Grafikleri';
+const description = 'Güvenli matematiksel formüllerle oyun hasar kurallarını canlı grafikler, ısı haritaları, yuvarlama kuralları ve Time to Kill (TTK) ile karşılaştırın.';
+
+const faq = [
+  {
+    question: 'Hasar formülü hesaplayıcısı neleri karşılaştırır?',
+    answer: 'Aynı savaş değerleri üzerinde iki güvenli matematiksel formülü çalıştırır. Hasar eğrilerini, vuruş eşiklerini, time to kill (TTK) süresini ve direnç sırasını JavaScript çalıştırmadan güvenle test edebilirsiniz.',
+  },
+  {
+    question: 'Hangi değişkenleri ve fonksiyonları kullanabilirim?',
+    answer: 'Kullanılabilir değişkenler: attack, defense, level, power, resistance, flat, criticalChance ve criticalMultiplier. Güvenli fonksiyonlar: min, max, clamp, abs, sqrt, pow, floor, round ve ceil.',
+  },
+  {
+    question: 'Time to Kill (TTK) nasıl hesaplanır?',
+    answer: 'Gerekli vuruş sayısı, hedefin canının yuvarlanmış beklenen hasara bölünmesiyle (yukarı yuvarlama) bulunur. TTK ilk ve son vuruş arasındaki süreyi ölçer: (vuruş - 1) / saniyedeki saldırı sayısı.',
+  },
+  {
+    question: 'Direnç sırası neden sonucu değiştirir?',
+    answer: 'Sabit çarpanı yüzde dirençten önce uygulamak o sabit değeri de azaltır. Direncin önce uygulanması ise sonraki sabit çarpanı etkisiz bırakır.',
+  },
+  {
+    question: 'Düzgün bir eğri oyunun dengeli olduğu anlamına gelir mi?',
+    answer: 'Hayır. Grafik eşik değerleri ve sıfır hasar bölgelerini gösterir, ancak denge oyunun bağlamına, rollere ve oyuncu testlerine bağlıdır.',
+  },
+];
+
+const howTo = [
+  { name: 'İki formül seçin', text: 'Hazır şablonlardan (doğrusal, oran, seviye ölçekli) başlayın veya iki özel formül yazın.' },
+  { name: 'Savaş değerlerini ayarlayın', text: 'Saldırı, savunma, seviye, güç katsayısı, direnç, sabit çarpan, kritik değerleri, can ve saldırı hızını girin.' },
+  { name: 'Motor kurallarını belirleyin', text: 'Hasarın nasıl yuvarlanacağını ve direnç sırasını seçin.' },
+  { name: 'Grafik ve eşikleri inceleyin', text: 'Hasar eğrisini, savunma ısı haritasını, gerekli vuruş sayısını ve uyarıları karşılaştırın.' },
+  { name: 'Deneysel verileri kaydedin', text: 'Paylaşım bağlantısını kopyalayın veya JSON, CSV ve PNG grafiğini indirin.' },
+];
+
+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: 'Mevcut hasar kuralınızı girin, yanına bir alternatif ekleyin ve savaş değerlerini ayarlayın.',
+    localNote: 'Özel model. Formüller ve veriler bu tarayıcıda kalır.',
+    formulaDeck: 'Formül Bölümü',
+    formulaALabel: 'Formül A (Mevcut Model)',
+    formulaBLabel: 'Formül B (Alternatif)',
+    formulaHint: 'Değişkenler: attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier',
+    formulaFunctions: 'Güvenli fonksiyonlar: min, max, clamp, abs, sqrt, pow, floor, round, ceil',
+    presetLinear: 'Doğrusal Koruma',
+    presetRatio: 'Orantılı Zırh',
+    presetLevel: 'Seviye Ölçekleme',
+    combatInputs: 'Savaş Değerleri',
+    attackLabel: 'Saldırı',
+    defenseLabel: 'Savunma',
+    levelLabel: 'Seviye',
+    powerLabel: 'Güç Katsayısı',
+    resistanceLabel: 'Direnç (%)',
+    flatLabel: 'Sabit Çarpan',
+    criticalChanceLabel: 'Kritik Şansı (%)',
+    criticalMultiplierLabel: 'Kritik Çarpanı',
+    healthLabel: 'Hedef Canı',
+    cadenceLabel: 'Saniyedeki Saldırı Sayısı',
+    roundingLabel: 'Hasar Yuvarlama',
+    roundingNone: 'Ondalıkları Korur',
+    roundingFloor: 'Aşağı Yuvarla (Floor)',
+    roundingRound: 'En Yakın Tam Sayı',
+    roundingCeil: 'Yukarı Yuvarla (Ceil)',
+    orderLabel: 'Çarpan Sırası',
+    resistanceFirst: 'Önce Direnç Sonra Sabit',
+    flatFirst: 'Önce Sabit Sonra Direnç',
+    runLabel: 'Canlı Etki Karşılaştırması',
+    resultDamage: 'Beklenen Hasar',
+    resultHits: 'Yenmek İçin Vuruş',
+    resultTtk: 'Time to Kill (TTK)',
+    resultDifference: 'Hasar Farkı',
+    formulaAName: 'Mevcut',
+    formulaBName: 'Alternatif',
+    curveTitle: 'Saldırı Gelişim Eğrisi',
+    curveCaption: 'Savunma sabit tutulurken saldırı değeri yarıdan iki katına kadar taranır.',
+    heatmapTitle: 'Baskı Alanı Isı Haritası',
+    heatmapCaption: 'Formül A beklenen hasarını saldırı ve savunma kombinasyonlarında gösterir.',
+    attackAxis: 'Saldırı sağa doğru artar',
+    defenseAxis: 'Savunma aşağı doğru artar',
+    scenariosTitle: 'Savaş Profilleri',
+    scenarioSkirmisher: 'Avcı',
+    scenarioGuardian: 'Muhafız',
+    scenarioBoss: 'Patron (Boss)',
+    scenarioCustom: 'Mevcut Ayar',
+    diagnosticsTitle: 'Eşik ve Uyarı Kontrolü',
+    statusBalanced: 'Bu test aralığında olağandışı bir matematiksel sıçrama tespit edilmedi.',
+    exportTitle: 'Deneysel Verileri Aktar',
+    copyLink: 'Bağlantıyı Kopyala',
+    exportCsv: 'CSV İndir',
+    exportJson: 'JSON İndir',
+    importJson: 'JSON İçe Aktar',
+    exportPng: 'PNG Grafiği İndir',
+    reset: 'Modeli Sıfırla',
+    privacyDisclosure: 'Paylaşım bağlantısı ayarları URL içinde saklar ve sunucuya veri göndermez.',
+    limitationDisclosure: 'Beklenen kritik hasar bir ortalamadır, rastgele bir simülasyon değildir.',
+    importError: 'Seçilen dosya geçerli bir konfigürasyon değil.',
+    copiedStatus: 'Bağlantı panoya kopyalandı.',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Oyun motoruna entegre etmeden önce hasar formüllerini test edin',
+    },
+    {
+      type: 'paragraph',
+      html: 'Bir hasar formülü varsayılan değerlerde dengeli görünebilir ancak yüksek seviyelerde bozulabilir. Bu laboratuvar olası eşikleri erkenden tespit etmenizi sağlar.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Güvenli ve sınırlandırılmış matematiksel ifade dili',
+    },
+    {
+      type: 'paragraph',
+      html: 'Girdi alanı yalnızca tanımlı değişkenleri ve güvenli fonksiyonları kabul eder, güvensiz kod çalıştırmaz.',
+    },
+    {
+      type: 'table',
+      headers: ['Metrik', 'Hesaplama', 'Tasarım Sorusu'],
+      rows: [
+        ['Beklanan Hasar', 'Kritik faktör ve direnç dahil temel formül', 'Kural zayıf ve güçlü birimlerde mantıklı çalışıyor mu?'],
+        ['Yenmek İçin Vuruş', 'Hedef canının yuvarlanmış hasara bölünmesi', 'Fazladan 1 stat puanı bir vuruşu tamamen ortadan kaldırıyor mu?'],
+        ['Time to Kill (TTK)', 'Vuruş aralığının saldırı hızına bölünmesi', 'Saldırı hızı istenen savaş temposunu oluşturuyor mu?'],
+        ['Isı Haritası', 'Formül A nın saldırı ve savunma üzerindeki örneklemesi', 'Beklenmeyen eşikler veya ölü bölgeler var mı?'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Matematiksel verileri oyun tasarımı kararlarından ayırmak',
+    },
+    {
+      type: 'paragraph',
+      html: 'Düzgün bir grafik oyunun eğlenceli olduğunu tek başına garanti etmez. Laboratuvarı test süreçlerinde doğrulanacak soruları bulmak için kullanın.',
+    },
+    {
+      type: 'tip',
+      title: 'Hasar ve vuruş sayısını daima birlikte inceleyin',
+      html: 'Hasardaki küçük bir değişim bir can eşiğini geçerek vuruş sayısını 1 azaltabilir. Hasarı daima TTK ile karşılaştırın.',
+    },
+  ],
+  faq,
+  bibliographyTitle: 'Oyunlarda hasar matematiği referansları',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};

package/src/tool/damageFormulaLab/i18n/zh.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 = 'game-damage-formula-calculator-ttk';
+const title = '游戏伤害公式与 TTK 击杀时间实验室';
+const description = '在安全环境下对比游戏伤害公式，通过实时曲线、攻防热力图、舍入断点、暴击收益及击杀所需时间 (TTK) 进行数值平衡分析。';
+
+const faq = [
+  {
+    question: '伤害公式计算器主要对比哪些数据？',
+    answer: '它在同一套战斗变量下安全运行两条数学公式，帮助您对比伤害曲线、击杀所需攻击次数、击杀时间 (TTK)、舍入规则、减伤顺序及攻防热力图，全过程无需执行 JavaScript。',
+  },
+  {
+    question: '支持哪些变量与数学函数？',
+    answer: '支持的变量有 attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier。安全的函数包括 min, max, clamp, abs, sqrt, pow, floor, round, ceil，同时支持加减乘除与括号。',
+  },
+  {
+    question: '击杀时间 (TTK) 是如何计算的？',
+    answer: '击杀所需次数为目标血量除以舍入后的期望伤害（向上取整）。TTK 计算的是从首次攻击到致死攻击的时间间隔，即 (击杀次数 - 1) / 每秒攻击次数。若一击必杀则 TTK 为 0 秒。',
+  },
+  {
+    question: '为什么减伤顺序会影响计算结果？',
+    answer: '先应用固定减伤再应用百分比抗性，会使固定减伤数值同样受到百分比衰减；而先应用百分比抗性，则后续的固定减伤保持原值。本工具支持两种计算顺序以匹配不同引擎的物理规则。',
+  },
+  {
+    question: '平滑的伤害曲线是否意味着游戏数值绝对平衡？',
+    answer: '并非如此。曲线能揭示零伤害死区和陡峭断点，但平衡性取决于玩法目标、角色定位、玩家选择及实机测试。本工具仅提供数值行为分析，不作绝对判决。',
+  },
+];
+
+const howTo = [
+  { name: '选择两条公式', text: '从线性、比例或等级缩放预设开始，或自定义输入公式 A 与公式 B。' },
+  { name: '设定战斗状态', text: '输入攻击力、防御力、等级、系数、抗性百分比、固定修正、暴击参数、目标血量及攻击频率。' },
+  { name: '指定引擎规则', text: '选择伤害舍入方式，并指定百分比抗性与固定修正值的先后计算顺序。' },
+  { name: '分析曲线与断点', text: '对比伤害推移曲线、防御热力图、击杀次数、TTK 及诊断警告。' },
+  { name: '保存实验数据', text: '复制分享链接，或导出 JSON 配置文件、CSV 数据表及 PNG 曲线图。' },
+];
+
+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: '输入您现有的伤害规则，在其旁放置对比公式，调整战斗状态以观察数值在极端情况下的表现。',
+    localNote: '私密战斗模型。公式与数据完全在本地浏览器内处理。',
+    formulaDeck: '公式实验室 Chamber',
+    formulaALabel: '公式 A (当前模型)',
+    formulaBLabel: '公式 B (对比模型)',
+    formulaHint: '支持变量: attack, defense, level, power, resistance, flat, criticalChance, criticalMultiplier',
+    formulaFunctions: '安全函数: min, max, clamp, abs, sqrt, pow, floor, round, ceil',
+    presetLinear: '线性减伤',
+    presetRatio: '比例护甲',
+    presetLevel: '等级缩放',
+    combatInputs: '战斗状态参数',
+    attackLabel: '攻击力 (Attack)',
+    defenseLabel: '防御力 (Defense)',
+    levelLabel: '等级 (Level)',
+    powerLabel: '技能威力系数',
+    resistanceLabel: '抗性百分比 (%)',
+    flatLabel: '固定加减修正值',
+    criticalChanceLabel: '暴击率 (%)',
+    criticalMultiplierLabel: '暴击伤害倍率',
+    healthLabel: '目标生命值 (Health)',
+    cadenceLabel: '每秒攻击次数 (APS)',
+    roundingLabel: '伤害舍入规则',
+    roundingNone: '保留小数',
+    roundingFloor: '向下取整 (Floor)',
+    roundingRound: '四舍五入 (Round)',
+    roundingCeil: '向上取整 (Ceil)',
+    orderLabel: '修正计算顺序',
+    resistanceFirst: '先计算抗性后计算固定值',
+    flatFirst: '先计算固定值后计算抗性',
+    runLabel: '实时影响对比',
+    resultDamage: '期望伤害',
+    resultHits: '击杀所需次数',
+    resultTtk: '击杀时间 (TTK)',
+    resultDifference: '伤害差值',
+    formulaAName: '当前公式',
+    formulaBName: '对比公式',
+    curveTitle: '攻击力推移曲线',
+    curveCaption: '在防御力固定的情况下，攻击力从当前值的一半扫掠至两倍。',
+    heatmapTitle: '压力场热力图',
+    heatmapCaption: '展示公式 A 在不同攻击力与防御力组合下的期望伤害。',
+    attackAxis: '攻击力向右递增',
+    defenseAxis: '防御力向下递增',
+    scenariosTitle: '战斗目标预设',
+    scenarioSkirmisher: '游侠 / 刺客',
+    scenarioGuardian: '重装战士',
+    scenarioBoss: '首领 Boss',
+    scenarioCustom: '当前自定义',
+    diagnosticsTitle: '断点与风险诊断',
+    statusBalanced: '在此扫掠范围内未检测到数值异常突变。',
+    exportTitle: '导出实验成果',
+    copyLink: '复制分享链接',
+    exportCsv: '下载 CSV 数据',
+    exportJson: '下载 JSON 配置',
+    importJson: '导入 JSON 配置',
+    exportPng: '下载 PNG 图形',
+    reset: '重置模型',
+    privacyDisclosure: '分享链接将配置保存在 URL 哈希中，不会发送至服务器。',
+    limitationDisclosure: '期望暴击伤害为统计平均值，非随机抽样模拟。',
+    importError: '所选文件不是有效的伤害实验室配置文件。',
+    copiedStatus: '分享链接已复制到剪贴板。',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: '在代码实装前验证游戏伤害公式',
+    },
+    {
+      type: 'paragraph',
+      html: '一条伤害公式可能在常规数值下表现良好，但在等级或装备极端增长时失效。本实验室能帮助您提前发现零伤害区与数值断层。',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: '受限且安全的表达式解析',
+    },
+    {
+      type: 'paragraph',
+      html: '公式输入框仅解析预设变量与安全数学函数，杜绝任意 JavaScript 代码执行风险。',
+    },
+    {
+      type: 'table',
+      headers: ['评估指标', '计算逻辑', '设计思考'],
+      rows: [
+        ['期望伤害', '包含暴击期待、抗性与舍入规则的基础伤害', '公式在强弱单位间是否均具备合理响应？'],
+        ['击杀次数', '目标生命值除以舍入后的伤害', '增加 1 点属性是否会导致所需攻击次数减少一次？'],
+        ['击杀时间 (TTK)', '攻击间隔除以每秒攻击频率', '攻击频率是否符合预期的战斗节奏？'],
+        ['压力热力图', '公式 A 在攻防矩阵上的采样', '是否存在不合理的停滞区或陡峭断层？'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: '区分算术客观事实与数值平衡主观判断',
+    },
+    {
+      type: 'paragraph',
+      html: '平滑的曲线并不直接等同于出色的游戏体验。请将本实验室作为发现实测问题与试玩验证的辅助工具。',
+    },
+    {
+      type: 'tip',
+      title: '同时观察伤害数值与击杀次数',
+      html: '伤害数值的微小变化可能会跨越血量阈值，从而使所需攻击次数减少一次。请务必结合 TTK 进行综合评估。',
+    },
+  ],
+  faq,
+  bibliographyTitle: '游戏伤害数值设计参考资料',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas: [softwareApplication, faqPage, howToSchema],
+};

package/src/tool/damageFormulaLab/index.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from "../../types";
+import { damageFormulaLab } from "./entry";
+
+export * from "./entry";
+
+export const DAMAGE_FORMULA_LAB_TOOL: ToolDefinition = {
+  entry: damageFormulaLab,
+  Component: () => import("./component.astro"),
+  SEOComponent: () => import("./seo.astro"),
+  BibliographyComponent: () => import("./bibliography.astro"),
+};

package/src/tool/damageFormulaLab/logic.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCurve,
+  buildHeatmap,
+  evaluateExpression,
+  evaluateFormula,
+  makeRange,
+  roundDamage,
+} from "./logic";
+import type { CombatSettings, FormulaVariables } from "./logic";
+
+const variables: FormulaVariables = {
+  attack: 80,
+  defense: 30,
+  level: 12,
+  power: 1.5,
+  resistance: 20,
+  flat: 4,
+  criticalChance: 25,
+  criticalMultiplier: 2,
+};
+
+const settings: CombatSettings = {
+  health: 500,
+  attacksPerSecond: 2,
+  rounding: "round",
+  modifierOrder: "resistance-first",
+};
+
+describe("damage formula parser", () => {
+  it("evaluates precedence, unary values, exponentiation and variables", () => {
+    expect(evaluateExpression("attack + defense * 2", variables)).toBe(140);
+    expect(evaluateExpression("-(2 + 3) ^ 2", variables)).toBe(-25);
+  });
+
+  it("evaluates the documented safe functions", () => {
+    expect(evaluateExpression("min(9, max(2, 7)) + abs(-3)", variables)).toBe(
+      10,
+    );
+    expect(
+      evaluateExpression("floor(2.9) + ceil(2.1) + round(2.5)", variables),
+    ).toBe(8);
+    expect(
+      evaluateExpression("sqrt(16) + pow(2, 3) + clamp(20, 0, 10)", variables),
+    ).toBe(22);
+  });
+
+  it("rejects empty, unknown and non-finite expressions", () => {
+    expect(() => evaluateExpression("", variables)).toThrow(
+      "Enter a damage formula",
+    );
+    expect(() => evaluateExpression("mystery + 1", variables)).toThrow(
+      "Unknown variable",
+    );
+    expect(() => evaluateExpression("attack / 0", variables)).toThrow(
+      "non-finite",
+    );
+    expect(() => evaluateExpression("attack; alert(1)", variables)).toThrow(
+      "Unsupported character",
+    );
+  });
+
+  it("rejects malformed syntax and unsupported functions", () => {
+    expect(() => evaluateExpression("(attack + 1", variables)).toThrow(
+      "Expected )",
+    );
+    expect(() => evaluateExpression("noise(1)", variables)).toThrow(
+      "Unknown function",
+    );
+    expect(() => evaluateExpression("attack defense", variables)).toThrow(
+      "Unexpected token",
+    );
+  });
+});
+
+describe("combat modelling", () => {
+  it("calculates expected damage, hit count and time to kill", () => {
+    const result = evaluateFormula(
+      "attack * power - defense",
+      variables,
+      settings,
+    );
+    expect(result.baseDamage).toBe(90);
+    expect(result.expectedDamage).toBe(94);
+    expect(result.roundedDamage).toBe(94);
+    expect(result.hitsToKill).toBe(6);
+    expect(result.timeToKill).toBe(2.5);
+  });
+
+  it("makes modifier order and rounding explicit", () => {
+    const flatFirst = evaluateFormula("100", variables, {
+      ...settings,
+      modifierOrder: "flat-first",
+      rounding: "floor",
+    });
+    const resistanceFirst = evaluateFormula("100", variables, {
+      ...settings,
+      modifierOrder: "resistance-first",
+      rounding: "ceil",
+    });
+    expect(flatFirst.roundedDamage).toBe(103);
+    expect(resistanceFirst.roundedDamage).toBe(104);
+    expect(roundDamage(2.4, "none")).toBe(2.4);
+    expect(roundDamage(2.4, "floor")).toBe(2);
+    expect(roundDamage(2.4, "round")).toBe(2);
+    expect(roundDamage(2.4, "ceil")).toBe(3);
+  });
+
+  it("reports unreachable kills for zero damage or cadence", () => {
+    expect(evaluateFormula("-100", variables, settings).hitsToKill).toBe(
+      Number.POSITIVE_INFINITY,
+    );
+    expect(
+      evaluateFormula("100", variables, { ...settings, attacksPerSecond: 0 })
+        .timeToKill,
+    ).toBe(Number.POSITIVE_INFINITY);
+  });
+
+  it("builds bounded curves and heatmaps from the same evaluator", () => {
+    expect(makeRange({ min: 10, max: 20, steps: 1 })).toEqual([10, 20]);
+    expect(makeRange({ min: 10, max: 20, steps: 50 })).toHaveLength(25);
+    const curve = buildCurve("attack - defense", variables, settings, {
+      min: 40,
+      max: 60,
+      steps: 3,
+    });
+    const heatmap = buildHeatmap({
+      expression: "attack - defense",
+      variables,
+      settings,
+      attackRange: { min: 40, max: 60, steps: 3 },
+      defenseRange: { min: 10, max: 20, steps: 2 },
+    });
+    expect(curve.map((point) => point.attack)).toEqual([40, 50, 60]);
+    expect(heatmap).toHaveLength(2);
+    expect(heatmap[0]).toHaveLength(3);
+  });
+});

package/src/tool/damageFormulaLab/logic.ts

@@ -0,0 +1,138 @@
+import { evaluateExpression } from "./expression";
+
+export { evaluateExpression } from "./expression";
+
+export type RoundingMode = "none" | "floor" | "round" | "ceil";
+export type ModifierOrder = "resistance-first" | "flat-first";
+
+export interface FormulaVariables {
+  attack: number;
+  defense: number;
+  level: number;
+  power: number;
+  resistance: number;
+  flat: number;
+  criticalChance: number;
+  criticalMultiplier: number;
+}
+
+export interface CombatSettings {
+  health: number;
+  attacksPerSecond: number;
+  rounding: RoundingMode;
+  modifierOrder: ModifierOrder;
+}
+
+export interface FormulaResult {
+  baseDamage: number;
+  expectedDamage: number;
+  roundedDamage: number;
+  hitsToKill: number;
+  timeToKill: number;
+}
+
+export interface SamplePoint extends FormulaResult {
+  attack: number;
+  defense: number;
+}
+
+export interface SweepRange {
+  min: number;
+  max: number;
+  steps: number;
+}
+
+export interface HeatmapRequest {
+  expression: string;
+  variables: FormulaVariables;
+  settings: CombatSettings;
+  attackRange: SweepRange;
+  defenseRange: SweepRange;
+}
+
+function applyModifiers(
+  value: number,
+  variables: FormulaVariables,
+  order: ModifierOrder,
+): number {
+  const resistanceMultiplier =
+    1 - Math.min(Math.max(variables.resistance, 0), 100) / 100;
+  if (order === "flat-first")
+    return (value + variables.flat) * resistanceMultiplier;
+  return value * resistanceMultiplier + variables.flat;
+}
+
+export function roundDamage(value: number, mode: RoundingMode): number {
+  if (mode === "floor") return Math.floor(value);
+  if (mode === "ceil") return Math.ceil(value);
+  if (mode === "round") return Math.round(value);
+  return value;
+}
+
+export function evaluateFormula(
+  expression: string,
+  variables: FormulaVariables,
+  settings: CombatSettings,
+): FormulaResult {
+  const baseDamage = evaluateExpression(expression, variables);
+  const chance = Math.min(Math.max(variables.criticalChance, 0), 100) / 100;
+  const criticalFactor = 1 + chance * (variables.criticalMultiplier - 1);
+  const modified = applyModifiers(
+    baseDamage * criticalFactor,
+    variables,
+    settings.modifierOrder,
+  );
+  const expectedDamage = Math.max(0, modified);
+  const roundedDamage = Math.max(
+    0,
+    roundDamage(expectedDamage, settings.rounding),
+  );
+  const hitsToKill =
+    roundedDamage > 0
+      ? Math.ceil(settings.health / roundedDamage)
+      : Number.POSITIVE_INFINITY;
+  const validCadence =
+    Number.isFinite(hitsToKill) && settings.attacksPerSecond > 0;
+  const timeToKill = validCadence
+    ? Math.max(0, hitsToKill - 1) / settings.attacksPerSecond
+    : Number.POSITIVE_INFINITY;
+  return { baseDamage, expectedDamage, roundedDamage, hitsToKill, timeToKill };
+}
+
+export function makeRange(range: SweepRange): number[] {
+  const steps = Math.min(Math.max(Math.round(range.steps), 2), 25);
+  const span = range.max - range.min;
+  return Array.from(
+    { length: steps },
+    (_, index) => range.min + (span * index) / (steps - 1),
+  );
+}
+
+export function buildCurve(
+  expression: string,
+  variables: FormulaVariables,
+  settings: CombatSettings,
+  range: SweepRange,
+): SamplePoint[] {
+  return makeRange(range).map((attack) => ({
+    attack,
+    defense: variables.defense,
+    ...evaluateFormula(expression, { ...variables, attack }, settings),
+  }));
+}
+
+export function buildHeatmap(request: HeatmapRequest): SamplePoint[][] {
+  const { expression, variables, settings, attackRange, defenseRange } =
+    request;
+  return makeRange(defenseRange).map((defense) =>
+    makeRange(attackRange).map((attack) => ({
+      attack,
+      defense,
+      ...evaluateFormula(
+        expression,
+        { ...variables, attack, defense },
+        settings,
+      ),
+    })),
+  );
+}