azeroth-shell 0.1.1 → 0.2.0

package/src/domain/rotation/classes/paladin.ts

@@ -47,26 +47,31 @@ export function finalizePaladinSealJudge(
 
   const pri = sealKindPriority(spec);
   // Kind first (resolved effects); rank only ties same kind (highest rank wins).
-  const best = [...sealRules].sort((a, b) => {
-    const kindA = sealKindOf(resolvedSealDef(a.def));
-    const kindB = sealKindOf(resolvedSealDef(b.def));
+  const bySpec = (a: SpellDef, b: SpellDef): number => {
+    const kindA = sealKindOf(resolvedSealDef(a));
+    const kindB = sealKindOf(resolvedSealDef(b));
     return (pri[kindB] ?? -1) - (pri[kindA] ?? -1)
-      || (b.def.rank ?? 0) - (a.def.rank ?? 0);
-  })[0]!;
-  const bestId = best.def.id;
-  const dropSealIds = new Set(
-    sealRules.filter((s) => s.def.id !== bestId).map((s) => s.def.id),
-  );
+      || (b.rank ?? 0) - (a.rank ?? 0);
+  };
+  // The pick is among every seal the paladin KNOWS, not only the ones the pack wrote down. The
+  // 20-39 Retribution band authored Seal of Righteousness alone, so a Ret who took Seal of Command
+  // at 20 kept casting the trainer seal until the 40 band named Command. The rule the pack placed is
+  // kept where it sits; only the seal it casts changes.
+  const knownSeals = [...knownById.values()].filter((d) => isSealSpell(d));
+  const authored = sealRules.map((s) => s.def);
+  const best = [...(knownSeals.length ? knownSeals : authored)].sort(bySpec)[0]!;
+  const bestId = best.id;
+  const authoredIds = new Set(authored.map((d) => d.id));
 
   const out: RotationRule[] = [];
   let keptBestSeal = false;
   for (const r of combat) {
-    if (r.action.kind === 'spell' && dropSealIds.has(r.action.spellId)) continue;
-    if (r.action.kind === 'spell' && r.action.spellId === bestId) {
+    if (r.action.kind === 'spell' && authoredIds.has(r.action.spellId)) {
       if (keptBestSeal) continue; // one seal upkeep rule only
       keptBestSeal = true;
       out.push({
         ...r,
+        action: { ...r.action, spellId: bestId },
         conditions: [cond('self', 'buffPresent', '==', 0, bestId)],
       });
       continue;

package/src/domain/rotation/evaluate.ts

@@ -1000,6 +1000,9 @@ function pullSequenceAction(
     const condSnap = snapForAction(snap, action);
     if (!conditionsPass(condSnap, conditionsForEval(rule))) continue; // not needed this pull
     if (!actionUsable(snap, action)) {
+      // An immune target never makes the opener usable: waiting on it held a fire mage at range
+      // forever against a Fire Elemental. Step past it like a spent row.
+      if (action.kind === 'spell' && snap.target?.immuneSpellIds?.has(action.spellId)) continue;
       const inMelee = snap.self.inMelee === true
         || (!!snap.enemyDists && snap.enemyDists.some((d) => d <= IN_MELEE_YD));
       if (inMelee || snap.enemyCount === 0) continue;

package/src/engine/combat/applySpell.ts

@@ -281,7 +281,17 @@ export type installApplySpellDeps = {
 };
 
 export function installApplySpell(ctx: CombatContext, deps: installApplySpellDeps): void {
-  const push = (e: any) => ctx.push(e);
+  // One aura row per holder, spell and instant. The push sits in the per-effect loop, so a two-effect
+  // buff (Dampen Magic: spell and healing taken) read "You gain" twice for one cast.
+  let lastAuraKey = '';
+  const push = (e: any) => {
+    if (e.kind === 'aura') {
+      const key = e.applied && e.spellId != null ? `${e.t}|${e.actor}|${e.spellId}` : '';
+      if (key && key === lastAuraKey) return;
+      lastAuraKey = key;
+    }
+    ctx.push(e);
+  };
   const player = ctx.player;
   const pet = ctx.pet;
   const effects = ctx.effects;
@@ -2220,7 +2230,8 @@ export function installApplySpell(ctx: CombatContext, deps: installApplySpellDep
         };
         // One-target apply, hoisted so the area-aura maintain pass can RE-apply it when an ally walks
         // back into radius. Idempotent: an existing row refreshes duration and never re-adds flat mods.
-        const applyBuffToTarget = (buffTgt: Fighter): void => {
+        // `now` is that pass's clock for the log; the expiry stays on the cast's (the holder's remaining life).
+        const applyBuffToTarget = (buffTgt: Fighter, now = t): void => {
           // Totem.cpp:282-287: mixed-hit school damage still lands; the APPLY_AURA index does not.
           const hostileBuff = isHostileBuffEffect(eff, baseAmount);
           if (
@@ -2353,10 +2364,10 @@ export function installApplySpell(ctx: CombatContext, deps: installApplySpellDep
               });
             }
             buffTgt.buffActive.add(spell.id);
-            push({ t, kind: 'aura', actor: buffTgt.side, name: spell.name, applied: true, spellId: spell.id });
+            push({ t: now, kind: 'aura', actor: buffTgt.side, name: spell.name, applied: true, spellId: spell.id });
             if (buffTgt.side !== src.side) {
               push({
-                t, kind: 'spell_hit', actor: src.side, target: buffTgt.side,
+                t: now, kind: 'spell_hit', actor: src.side, target: buffTgt.side,
                 spellId: spell.id, name: spell.name, result: 'hit', amount: 0, school: spell.school,
               });
             }
@@ -2424,7 +2435,7 @@ export function installApplySpell(ctx: CombatContext, deps: installApplySpellDep
                   }
                   buffTgt.buffActive.delete(row.spellId);
                   effects.splice(at, 1);
-                  push({ t, kind: 'aura', actor: buffTgt.side, name: row.name, applied: false });
+                  push({ t: now, kind: 'aura', actor: buffTgt.side, name: row.name, applied: false });
                 }
               }
             }
@@ -2457,10 +2468,10 @@ export function installApplySpell(ctx: CombatContext, deps: installApplySpellDep
               });
               // The aura row lives on the target's buff bar. Also emit a spell_hit for the caster so a
               // damageless hostile debuff shows in the fight log as a cast.
-              push({ t, kind: 'aura', actor: buffTgt.side, name: spell.name, applied: true, spellId: spell.id });
+              push({ t: now, kind: 'aura', actor: buffTgt.side, name: spell.name, applied: true, spellId: spell.id });
               if (buffTgt.side !== src.side) {
                 push({
-                  t, kind: 'spell_hit', actor: src.side, target: buffTgt.side,
+                  t: now, kind: 'spell_hit', actor: src.side, target: buffTgt.side,
                   spellId: spell.id, name: spell.name, result: 'hit', amount: 0, school: spell.school,
                 });
               }
@@ -2530,9 +2541,9 @@ export function installApplySpell(ctx: CombatContext, deps: installApplySpellDep
             exclusionGroup: spell.exclusionGroup,
             // AreaAura::Update applies the MISSING rank only. An unguarded re-apply emitted 50 events
             // for one Blood Pact in a 2.5 s fight — the totem kit path guards the same way.
-            apply: (m: Fighter) => {
+            apply: (m: Fighter, now: number) => {
               if (hasAreaAuraRow(ctx.effectsOn(m.side), m, spell.id, src.side)) return;
-              applyBuffToTarget(m);
+              applyBuffToTarget(m, now);
             },
             strip: (m: Fighter) => {
               stripAreaAuraRowsFrom(effects, m, spell.id, src.side, reverseActiveEffect, ctx.effectsOn(m.side));

package/src/engine/combat/applySpellLate.ts

@@ -216,7 +216,11 @@ if (eff.kind === 'summon_totem') {
           };
           // Register the kit aura as a live class-A holder so the maintain pass keeps re-checking the
           // totem-to-ally distance. The origin is the TOTEM; the mod owner is the shaman.
-          const registerTotemAreaAura = (abil: SpellDef, apply: (fr: Fighter) => void): void => {
+          // Each kit closure takes `now` (default: the summon's `t`): the maintain pass calls it later for an
+          // ally walking into radius, and the summon-time clock put that row's first tick in the past, so
+          // every missed Healing Stream tick landed at once.
+          // Expiry stays on the totem's clock, the holder's remaining life.
+          const registerTotemAreaAura = (abil: SpellDef, apply: (fr: Fighter, now: number) => void): void => {
             registerAreaAuraSource?.({
               holderSide: built.side,
               spellId: abil.id,
@@ -256,7 +260,7 @@ if (eff.kind === 'summon_totem') {
                     isWithinRadiusYd(posOf?.(built.side), posOf?.(en.side), kitRadiusYd(abil) ?? 10),
                   )
                   : (ae.applyTo === 'self' ? [player] : inRadiusParty(abil));
-                const applyKitBuff = (fr: Fighter): void => {
+                const applyKitBuff = (fr: Fighter, now = t): void => {
                   if (dead(fr)) return;
                   if (hasAreaAuraRow(rowsOn(fr), fr, abil.id, built.side)) return;
                   applyBuffMod(fr, ae.mod, amount);
@@ -265,7 +269,7 @@ if (eff.kind === 'summon_totem') {
                     kind: 'buff', source: built.side, target: fr.side, spellId: abil.id, name: abil.name,
                     mod: ae.mod, amount, expiresAt: t + dur, fromTotem: built.side,
                   });
-                  push({ t, kind: 'aura', actor: fr.side, name: abil.name, applied: true });
+                  push({ t: now, kind: 'aura', actor: fr.side, name: abil.name, applied: true });
                 };
                 // continue (not return): one dead friendly must not abort party aura reach.
                 // Cite: Totem.cpp UnSummon party strip :145–157; APPLY_AREA_AURA_PARTY effect 35.
@@ -278,7 +282,7 @@ if (eff.kind === 'summon_totem') {
                 // Cite: APPLY_AREA_AURA_PARTY; Totem.cpp UnSummon removes aura on all subgroup members.
                 const tickMs = Math.max(1, ae.tickMs);
                 const kitPower = ae.kind === 'restore_power' ? (ae.powerType ?? POWER_MANA) | 0 : undefined;
-                const applyKitTick = (fr: Fighter): void => {
+                const applyKitTick = (fr: Fighter, now = t): void => {
                   if (dead(fr)) return;
                   if (hasAreaAuraRow(rowsOn(fr), fr, abil.id, built.side)) return;
                   // The aura lands on every living party member for strip symmetry; the pool it pays
@@ -286,11 +290,11 @@ if (eff.kind === 'summon_totem') {
                   fr.buffActive.add(abil.id);
                   effects.push({
                     kind: ae.kind, source: built.side, target: fr.side, spellId: abil.id, name: abil.name,
-                    amountPerTick: ae.amountPerTick, pctOfMax: ae.pctOfMax, tickMs, nextTickAt: t + tickMs,
+                    amountPerTick: ae.amountPerTick, pctOfMax: ae.pctOfMax, tickMs, nextTickAt: now + tickMs,
                     ...(kitPower != null ? { powerType: kitPower } : {}),
                     expiresAt: t + built.durationMs, fromTotem: built.side,
                   });
-                  push({ t, kind: 'aura', actor: fr.side, name: abil.name, applied: true });
+                  push({ t: now, kind: 'aura', actor: fr.side, name: abil.name, applied: true });
                 };
                 // Healing Stream / Mana Spring only tick on allies standing in the totem's
                 // radius — walk out and the stream stops for you (§4.9.1).
@@ -315,7 +319,7 @@ if (eff.kind === 'summon_totem') {
               } else if (ae.kind === 'resist') {
                 // MOD_RESISTANCE party aura — the Frost, Fire and Nature Resistance Totems. Same party
                 // reach and strip symmetry as the stat buffs; without it they were summoned decoration.
-                const applyKitResist = (fr: Fighter): void => {
+                const applyKitResist = (fr: Fighter, now = t): void => {
                   if (dead(fr)) return;
                   if (hasAreaAuraRow(rowsOn(fr), fr, abil.id, built.side)) return;
                   applyResistMod(fr, ae.school, ae.amount);
@@ -325,7 +329,7 @@ if (eff.kind === 'summon_totem') {
                     name: abil.name, school: ae.school, amount: ae.amount,
                     expiresAt: t + built.durationMs, fromTotem: built.side,
                   });
-                  push({ t, kind: 'aura', actor: fr.side, name: abil.name, applied: true });
+                  push({ t: now, kind: 'aura', actor: fr.side, name: abil.name, applied: true });
                 };
                 for (const fr of inRadiusParty(abil)) applyKitResist(fr);
                 registerTotemAreaAura(abil, applyKitResist);
@@ -335,10 +339,10 @@ if (eff.kind === 'summon_totem') {
                 applyFlatThreat(tot, ae.amount, abil as unknown as SpellDef);
               } else if (ae.kind === 'spell_magnet') {
                 const magnetDur = ae.durationMs > 0 ? ae.durationMs : built.durationMs;
-                const applyKitMagnet = (fr: Fighter): void => {
+                const applyKitMagnet = (fr: Fighter, now = t): void => {
                   applySpellMagnetToParty({
                     effects, effectsOn, party: [fr], source: built.side, spell: abil,
-                    expiresAt: t + magnetDur, t, push, touchEffect,
+                    expiresAt: t + magnetDur, t: now, push, touchEffect,
                   });
                 };
                 for (const fr of inRadiusParty(abil)) applyKitMagnet(fr);
@@ -374,11 +378,11 @@ if (eff.kind === 'summon_totem') {
             const magnetFx = trig.effects.find((e) => e.kind === 'spell_magnet');
             if (!magnetFx || magnetFx.kind !== 'spell_magnet') continue;
             const magnetDur = magnetFx.durationMs > 0 ? magnetFx.durationMs : built.durationMs;
-            const applyTrigMagnet = (fr: Fighter): void => {
+            const applyTrigMagnet = (fr: Fighter, now = t): void => {
               applySpellMagnetToParty({
                 effects, effectsOn, party: [fr], source: built.side,
                 spell: { id: trig.id, name: trig.name, procCharges: magnetFx.charges },
-                expiresAt: t + magnetDur, t, push, touchEffect,
+                expiresAt: t + magnetDur, t: now, push, touchEffect,
               });
             };
             for (const fr of inRadiusParty(trig)) applyTrigMagnet(fr);