@jjlmoya/utils-games-development 1.63.0 → 1.64.0

package/src/tool/damageFormulaLab/model.ts

@@ -0,0 +1,151 @@
+import type {
+  CombatSettings,
+  FormulaVariables,
+  ModifierOrder,
+  RoundingMode,
+  SweepRange,
+} from "./logic";
+
+export interface LabConfig {
+  version: 1;
+  formulaA: string;
+  formulaB: string;
+  variables: FormulaVariables;
+  settings: CombatSettings;
+  attackRange: SweepRange;
+  defenseRange: SweepRange;
+}
+
+export const defaultConfig: LabConfig = {
+  version: 1,
+  formulaA: "max(1, attack * power - defense)",
+  formulaB: "max(1, attack * power * 100 / (100 + defense))",
+  variables: {
+    attack: 80,
+    defense: 35,
+    level: 20,
+    power: 1.4,
+    resistance: 15,
+    flat: 3,
+    criticalChance: 20,
+    criticalMultiplier: 1.75,
+  },
+  settings: {
+    health: 450,
+    attacksPerSecond: 1.5,
+    rounding: "round",
+    modifierOrder: "resistance-first",
+  },
+  attackRange: { min: 40, max: 160, steps: 17 },
+  defenseRange: { min: 10, max: 90, steps: 9 },
+};
+
+export const formulaPresets = {
+  linear: "max(1, attack * power - defense)",
+  ratio: "max(1, attack * power * 100 / (100 + defense))",
+  level:
+    "max(1, ((2 * level + 10) / 250) * (attack / max(1, defense)) * power + 2)",
+};
+
+export const scenarios: Record<
+  string,
+  Partial<FormulaVariables> & { health: number }
+> = {
+  skirmisher: { defense: 20, resistance: 5, health: 220 },
+  guardian: { defense: 70, resistance: 25, health: 700 },
+  boss: { defense: 110, resistance: 35, health: 2200 },
+};
+
+function finite(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function rounding(value: unknown): RoundingMode {
+  if (value === "none" || value === "floor" || value === "ceil") return value;
+  return "round";
+}
+
+function order(value: unknown): ModifierOrder {
+  return value === "flat-first" ? "flat-first" : "resistance-first";
+}
+
+function variables(value: unknown): FormulaVariables {
+  const source =
+    typeof value === "object" && value
+      ? (value as Partial<FormulaVariables>)
+      : {};
+  const base = defaultConfig.variables;
+  return {
+    attack: finite(source.attack, base.attack),
+    defense: finite(source.defense, base.defense),
+    level: finite(source.level, base.level),
+    power: finite(source.power, base.power),
+    resistance: finite(source.resistance, base.resistance),
+    flat: finite(source.flat, base.flat),
+    criticalChance: finite(source.criticalChance, base.criticalChance),
+    criticalMultiplier: finite(
+      source.criticalMultiplier,
+      base.criticalMultiplier,
+    ),
+  };
+}
+
+function range(value: unknown, fallback: SweepRange): SweepRange {
+  const source =
+    typeof value === "object" && value ? (value as Partial<SweepRange>) : {};
+  return {
+    min: finite(source.min, fallback.min),
+    max: finite(source.max, fallback.max),
+    steps: finite(source.steps, fallback.steps),
+  };
+}
+
+function combatSettings(value: unknown): CombatSettings {
+  const source =
+    typeof value === "object" && value
+      ? (value as Partial<CombatSettings>)
+      : {};
+  return {
+    health: finite(source.health, defaultConfig.settings.health),
+    attacksPerSecond: finite(
+      source.attacksPerSecond,
+      defaultConfig.settings.attacksPerSecond,
+    ),
+    rounding: rounding(source.rounding),
+    modifierOrder: order(source.modifierOrder),
+  };
+}
+
+export function parseConfig(value: unknown): LabConfig {
+  if (typeof value !== "object" || !value)
+    throw new Error("Invalid configuration");
+  const source = value as Partial<LabConfig>;
+  return {
+    version: 1,
+    formulaA:
+      typeof source.formulaA === "string"
+        ? source.formulaA
+        : defaultConfig.formulaA,
+    formulaB:
+      typeof source.formulaB === "string"
+        ? source.formulaB
+        : defaultConfig.formulaB,
+    variables: variables(source.variables),
+    settings: combatSettings(source.settings),
+    attackRange: range(source.attackRange, defaultConfig.attackRange),
+    defenseRange: range(source.defenseRange, defaultConfig.defenseRange),
+  };
+}
+
+export function configFromHash(hash: string): LabConfig | undefined {
+  try {
+    if (!hash.startsWith("#damage=")) return undefined;
+    return parseConfig(JSON.parse(decodeURIComponent(hash.slice(8))));
+  } catch {
+    return undefined;
+  }
+}
+
+export function configToHash(config: LabConfig): string {
+  return `#damage=${encodeURIComponent(JSON.stringify(config))}`;
+}

package/src/tool/damageFormulaLab/seo.astro

@@ -0,0 +1,13 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import type { SEOSection } from '../../types';
+
+interface Props {
+  locale?: string;
+  sections?: SEOSection[];
+}
+
+const { locale = 'en', sections = [] } = Astro.props;
+---
+
+<SEORenderer content={{ locale, sections }} />

package/src/tool/damageFormulaLab/storage.ts

@@ -0,0 +1,62 @@
+import type { ModifierOrder, RoundingMode } from "./logic";
+
+export interface LabPreferences {
+  formulaA: string;
+  formulaB: string;
+  rounding: RoundingMode;
+  modifierOrder: ModifierOrder;
+}
+
+const STORAGE_KEY = "jjlmoya-damage-formula-lab";
+
+export const defaultPreferences: LabPreferences = {
+  formulaA: "max(1, attack * power - defense)",
+  formulaB: "max(1, attack * power * 100 / (100 + defense))",
+  rounding: "round",
+  modifierOrder: "resistance-first",
+};
+
+function isRounding(value: unknown): value is RoundingMode {
+  return (
+    value === "none" ||
+    value === "floor" ||
+    value === "round" ||
+    value === "ceil"
+  );
+}
+
+function isOrder(value: unknown): value is ModifierOrder {
+  return value === "resistance-first" || value === "flat-first";
+}
+
+export function loadPreferences(): LabPreferences {
+  try {
+    const parsed = JSON.parse(
+      localStorage.getItem(STORAGE_KEY) ?? "",
+    ) as Partial<LabPreferences>;
+    return {
+      formulaA:
+        typeof parsed.formulaA === "string"
+          ? parsed.formulaA
+          : defaultPreferences.formulaA,
+      formulaB:
+        typeof parsed.formulaB === "string"
+          ? parsed.formulaB
+          : defaultPreferences.formulaB,
+      rounding: isRounding(parsed.rounding)
+        ? parsed.rounding
+        : defaultPreferences.rounding,
+      modifierOrder: isOrder(parsed.modifierOrder)
+        ? parsed.modifierOrder
+        : defaultPreferences.modifierOrder,
+    };
+  } catch {
+    return { ...defaultPreferences };
+  }
+}
+
+export function savePreferences(preferences: LabPreferences): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(preferences));
+  } catch {}
+}

package/src/tool/damageFormulaLab/transfers.ts

@@ -0,0 +1,89 @@
+import { buildCurve } from "./logic";
+import { configToHash } from "./model";
+import type { LabConfig } from "./model";
+
+export function download(name: string, type: string, body: BlobPart): void {
+  const link = document.createElement("a");
+  link.href = URL.createObjectURL(new Blob([body], { type }));
+  link.download = name;
+  link.click();
+  URL.revokeObjectURL(link.href);
+}
+
+function curveRows(config: LabConfig): Array<Array<number | undefined>> {
+  const a = buildCurve(
+    config.formulaA,
+    config.variables,
+    config.settings,
+    config.attackRange,
+  );
+  const b = buildCurve(
+    config.formulaB,
+    config.variables,
+    config.settings,
+    config.attackRange,
+  );
+  return a.map((point, index) => [
+    point.attack,
+    point.defense,
+    point.roundedDamage,
+    point.hitsToKill,
+    point.timeToKill,
+    b[index]?.roundedDamage,
+    b[index]?.hitsToKill,
+    b[index]?.timeToKill,
+  ]);
+}
+
+export function exportCsv(config: LabConfig): void {
+  const header = [
+    "attack",
+    "defense",
+    "formula_a_damage",
+    "formula_a_hits",
+    "formula_a_ttk",
+    "formula_b_damage",
+    "formula_b_hits",
+    "formula_b_ttk",
+  ];
+  const body = [header, ...curveRows(config)]
+    .map((row) => row.join(","))
+    .join("\n");
+  download("damage-formula-sweep.csv", "text/csv", body);
+}
+
+export function exportJson(config: LabConfig): void {
+  download(
+    "damage-formula-lab.json",
+    "application/json",
+    JSON.stringify(config, null, 2),
+  );
+}
+
+function drawPng(image: HTMLImageElement): void {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1200;
+  canvas.height = 700;
+  const context = canvas.getContext("2d");
+  if (!context) return;
+  context.fillStyle = "#f7f4ee";
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  context.drawImage(image, 70, 70, 1060, 560);
+  canvas.toBlob((blob) => {
+    if (blob) download("damage-formula-curve.png", "image/png", blob);
+  }, "image/png");
+}
+
+export function exportChartPng(root: HTMLElement): void {
+  const svg = root.querySelector<SVGSVGElement>("[data-chart]");
+  if (!svg) return;
+  const source = new XMLSerializer().serializeToString(svg);
+  const image = new Image();
+  image.onload = () => drawPng(image);
+  image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(source)}`;
+}
+
+export async function copyShareLink(config: LabConfig): Promise<void> {
+  const url = `${location.origin}${location.pathname}${configToHash(config)}`;
+  await navigator.clipboard.writeText(url);
+}

package/src/tool/damageFormulaLab/ui.ts

@@ -0,0 +1,62 @@
+export interface DamageFormulaLabUI extends Record<string, string> {
+  onboarding: string;
+  localNote: string;
+  formulaDeck: string;
+  formulaALabel: string;
+  formulaBLabel: string;
+  formulaHint: string;
+  formulaFunctions: string;
+  presetLinear: string;
+  presetRatio: string;
+  presetLevel: string;
+  combatInputs: string;
+  attackLabel: string;
+  defenseLabel: string;
+  levelLabel: string;
+  powerLabel: string;
+  resistanceLabel: string;
+  flatLabel: string;
+  criticalChanceLabel: string;
+  criticalMultiplierLabel: string;
+  healthLabel: string;
+  cadenceLabel: string;
+  roundingLabel: string;
+  roundingNone: string;
+  roundingFloor: string;
+  roundingRound: string;
+  roundingCeil: string;
+  orderLabel: string;
+  resistanceFirst: string;
+  flatFirst: string;
+  runLabel: string;
+  resultDamage: string;
+  resultHits: string;
+  resultTtk: string;
+  resultDifference: string;
+  formulaAName: string;
+  formulaBName: string;
+  curveTitle: string;
+  curveCaption: string;
+  heatmapTitle: string;
+  heatmapCaption: string;
+  attackAxis: string;
+  defenseAxis: string;
+  scenariosTitle: string;
+  scenarioSkirmisher: string;
+  scenarioGuardian: string;
+  scenarioBoss: string;
+  scenarioCustom: string;
+  diagnosticsTitle: string;
+  statusBalanced: string;
+  exportTitle: string;
+  copyLink: string;
+  exportCsv: string;
+  exportJson: string;
+  importJson: string;
+  exportPng: string;
+  reset: string;
+  privacyDisclosure: string;
+  limitationDisclosure: string;
+  importError: string;
+  copiedStatus: string;
+}

package/src/tools.ts

@@ -11,6 +11,7 @@ import { RETRO_SFX_GENERATOR_TOOL } from './tool/retroSfxGenerator';
 import { PIXEL_ART_PALETTE_SWAPPER_TOOL } from './tool/pixelArtPaletteSwapper';
 import { GAME_UI_ACCESSIBILITY_TESTER_TOOL } from './tool/gameUIAccessibilityTester';
 import { HITBOX_HURTBOX_ANIMATOR_TOOL } from './tool/hitboxHurtboxAnimator';
+import { DAMAGE_FORMULA_LAB_TOOL } from './tool/damageFormulaLab';
 
 export const ALL_TOOLS: ToolDefinition[] = [
   STEAM_CAPSULE_GENERATOR_TOOL,
@@ -24,4 +25,5 @@ export const ALL_TOOLS: ToolDefinition[] = [
   PIXEL_ART_PALETTE_SWAPPER_TOOL,
   GAME_UI_ACCESSIBILITY_TESTER_TOOL,
   HITBOX_HURTBOX_ANIMATOR_TOOL,
+  DAMAGE_FORMULA_LAB_TOOL,
 ];