Update Healer Man server

src/game/romRogueEnergizedHandsRuntime.ts

@@ -0,0 +1,103 @@
+import type { ActiveAura, AuraDefinition, AuraModifier } from "./combatAuras";
+import type { AbilityEffect } from "./abilityCatalog";
+
+export const ROM_ROGUE_ENERGIZED_HANDS_SKILL_ID = 490347;
+export const ROM_ROGUE_ENERGIZED_HANDS_AURA_TAG = "rom-energized-hands";
+export const ROM_ROGUE_POISONOUS_HANDS_EXCLUSIVE_GROUP = "rom-rogue-hands";
+export const ROM_ROGUE_ENERGIZED_HANDS_DURATION_MS = 900_000;
+export const ROM_ROGUE_ENERGIZED_HANDS_COOLDOWN_REDUCTION_MS = 100;
+export const ROM_ROGUE_ENERGIZED_HANDS_MAX_ENERGY_PERCENT = 50;
+export const ROM_ROGUE_ENERGIZED_HANDS_REGENERATION_PERCENT = 100;
+export const ROM_ROGUE_ENERGIZED_HANDS_COST_PERCENT = 20;
+
+export const ROM_ROGUE_ENERGIZED_HANDS_DESCRIPTION =
+  "Increases Energy recovery by 100%, reduces skill cooldowns by 0.1 seconds, and increases maximum Energy by 50%, but increases Energy costs by 20% for 900 seconds. Mutually exclusive with Poisonous Hands.";
+
+export const ROM_ROGUE_POISONOUS_HANDS_DESCRIPTION =
+  "Uses 1 Poison Bottle. For 900 seconds, regular attacks have a 50% chance to apply Poisonous Hands to the target, reducing damage dealt by the target by 8%. Each successful application stacks up to 10 times and grants you 1% Physical Attack Speed per stack applied to your current target. Attacking a new target resets this attack-speed sequence. Mutually exclusive with Energized Hands.";
+
+export function romRogueEnergizedHandsAuraDefinition(): AuraDefinition {
+  const modifiers: readonly AuraModifier[] = [
+    {
+      kind: "resource",
+      resource: "energy",
+      property: "maximum",
+      operation: "percent",
+      value: ROM_ROGUE_ENERGIZED_HANDS_MAX_ENERGY_PERCENT / 100,
+    },
+    {
+      kind: "resource",
+      resource: "energy",
+      property: "regeneration",
+      operation: "percent",
+      value: ROM_ROGUE_ENERGIZED_HANDS_REGENERATION_PERCENT / 100,
+    },
+    {
+      kind: "resource",
+      resource: "energy",
+      property: "cost",
+      operation: "percent",
+      value: ROM_ROGUE_ENERGIZED_HANDS_COST_PERCENT / 100,
+    },
+  ];
+  return {
+    id: "rom-rogue-energized-hands",
+    name: "Energized Hands",
+    description: ROM_ROGUE_ENERGIZED_HANDS_DESCRIPTION,
+    disposition: "buff",
+    durationMs: ROM_ROGUE_ENERGIZED_HANDS_DURATION_MS,
+    exclusiveGroup: ROM_ROGUE_POISONOUS_HANDS_EXCLUSIVE_GROUP,
+    utilityTags: [ROM_ROGUE_ENERGIZED_HANDS_AURA_TAG],
+    modifiers,
+  };
+}
+
+export function romRogueEnergizedHandsApplyEffect(): AbilityEffect {
+  return {
+    kind: "apply-aura",
+    recipient: "caster",
+    sourceEffectType: 6,
+    sourceAuraType: 0,
+    miscValue: 0,
+    triggerSpellId: 0,
+    aura: romRogueEnergizedHandsAuraDefinition(),
+  };
+}
+
+export function romRogueEnergizedHandsActive(
+  auras: readonly ActiveAura[],
+  actorId: string,
+  now?: number,
+): boolean {
+  return auras.some((aura) => aura.targetId === actorId
+    && aura.definition.utilityTags?.includes(ROM_ROGUE_ENERGIZED_HANDS_AURA_TAG)
+    && (now === undefined || aura.expiresAt === null || aura.expiresAt > now));
+}
+
+/**
+ * Translate the current max-Energy aura between snapshots without changing
+ * current Energy. The stored pool maximum is the runtime authority, so apply
+ * only the ratio of the old and new aura modifiers (refreshes remain neutral).
+ */
+export function romRogueEnergyMaximumAfterAuraTransition(
+  currentMaximum: number,
+  previousAuras: readonly ActiveAura[],
+  nextAuras: readonly ActiveAura[],
+  targetId: string,
+): number {
+  const maximumModifier = (auras: readonly ActiveAura[]) => auras
+    .filter((aura) => aura.targetId === targetId)
+    .reduce((total, aura) => {
+      const hasEnergizedHands = aura.definition.utilityTags?.includes(ROM_ROGUE_ENERGIZED_HANDS_AURA_TAG);
+      if (!hasEnergizedHands) return total;
+      const percent = (aura.definition.modifiers ?? []).reduce((value, modifier) => (
+        modifier.kind === "resource" && modifier.resource === "energy" && modifier.property === "maximum"
+          ? value + (modifier.operation === "percent" ? modifier.value : 0)
+          : value
+      ), 0);
+      return total * (1 + percent);
+    }, 1);
+  const previous = maximumModifier(previousAuras);
+  const next = maximumModifier(nextAuras);
+  return Math.max(0, Math.round(currentMaximum * next / Math.max(0.0001, previous)));
+}