azeroth-shell 0.1.2 → 0.2.0

package/src/engine/combat/pickAction.ts

@@ -2320,6 +2320,38 @@ export function installPickAction(ctx: CombatContext, deps: installPickActionDep
     return snap;
   };
 
+  // A rotation whose damage rows the focus is immune to returns nothing, and a null pick is white
+  // swings a caster holding at range never throws: the fire mage stood off a Fire Elemental forever.
+  // Only then does the kit speak, in the class heuristics' order: a DoT not yet ticking, an instant,
+  // a cast nuke, the wand. Single-target before ground AoE (Blizzard is a dot), and never a self AoE:
+  // Hellfire burned a warlock to death. Healers keep their idle GCDs. Cite: Unit.cpp IsImmuneToSpell ~7329.
+  // Only a SCHOOL wall, only a mana caster, only out of form: a bleed-immune mob is most mobs, and a
+  // cat pooling energy against one shifted out to Wrath (feral vs Mana Surge 19 s -> 49 s).
+  const IMMUNE_FILLER_ROLES = ['dot', 'instant_nuke', 'nuke'] as const;
+  const immuneFallbackFiller = (f: Fighter, foe: Fighter): SpellDef | null => {
+    if (f.spec.groupRole === 'healer' || foe === f || dead(foe)) return null;
+    if (f.spec.powerType !== 'mana' || f.form) return null;
+    if (((foe.immunity?.schoolImmuneMask ?? 0) | (foe.immunity?.damageImmuneMask ?? 0)
+      | (foe.spec.schoolImmuneMask ?? 0)) === 0) return null;
+    if (!targetImmunityIdsFor(foe, f).spells?.size) return null;
+    // A reach, too: Hellfire is a self channel that passes the foe test and burns its caster.
+    const usable = (s: SpellDef): boolean =>
+      (s.rangeMax ?? 0) > 0 && isFoeDirectedOffense(s) && !isTriggeredCompanion(f, s)
+      && !isNonCastableTalentProc(s) && canCastSpell(f, foe, s);
+    for (const aoe of [false, true]) {
+      for (const role of IMMUNE_FILLER_ROLES) {
+        // Any of our DoTs already ticking is skipped, hybrids too: Immolate went out 30 times a fight.
+        const hit = f.spec.spells.find((s) => roleOf(s) === role && !!s.aoe === aoe && usable(s)
+          && !(s.effects.some((e) => e.kind === 'dot') && ctx.effectsOn(foe.side).some(
+            (e) => e.kind === 'dot' && e.spellId === s.id && e.source === f.side,
+          )));
+        if (hit) return hit;
+      }
+    }
+    const shoot = f.spec.spells.find((s) => isRangedAutoRepeatToggle(s) && usable(s));
+    return shoot && f.spec.ranged && f.mode !== 'ranged' ? shoot : null;
+  };
+
   const pickAction = (f: Fighter, foe: Fighter): SpellDef | null => {
     const t = ctx.t;
     // E6: MT/OT focus from the raid plan (boss-a / boss-b by stable side order — no entry id).
@@ -2912,6 +2944,7 @@ export function installPickAction(ctx: CombatContext, deps: installPickActionDep
           return sp;
         }
       }
+      if (pick == null && !f.haltDpsSchool) return immuneFallbackFiller(f, foe);
       return null;
     };
 
@@ -3174,7 +3207,12 @@ export function installPickAction(ctx: CombatContext, deps: installPickActionDep
     const seals = f.spec.spells.filter((s) => roleOf(s) === 'seal');
     if (seals.length) {
       if (!f.activeSeal) {
-        const best = seals.find((s) => s.effects.some((e) => e.kind === 'seal' && (e.seal === 'command' || e.seal === 'righteousness'))) ?? seals[0];
+        // Command before Righteousness: the talent seal is the stronger swing proc, and the order the
+        // spell list happens to come in must not decide which one a Ret paladin keeps up.
+        const sealKind = (s: SpellDef): string => { const e = s.effects.find((x) => x.kind === 'seal'); return e && e.kind === 'seal' ? e.seal : ''; };
+        const best = seals.find((s) => sealKind(s) === 'command')
+          ?? seals.find((s) => sealKind(s) === 'righteousness')
+          ?? seals[0];
         if (best && canAfford(f, best) && !onCooldown(f, best)) return best;
       } else {
         const judge = find(f, 'judgement');

package/src/engine/combat/procsDamage.ts

@@ -19,7 +19,7 @@ import {
   spellCritChance,
   ccResistChance,
 } from './formulas.ts';
-import { fighterSpellCrit, fighterEffectiveArmor, applyBuffMod } from './fighterFactory.ts';
+import { fighterSpellCrit, fighterEffectiveArmor, applyBuffMod, SPELL_DAMAGE_MOD_SCHOOL } from './fighterFactory.ts';
 import {
   powerOfType, maxPowerOfType, setPowerOfType, casterPowerTypeId, powerTypeName,
 } from './powerPools.ts';
@@ -267,6 +267,35 @@ export function installProcsDamage(ctx: CombatContext, deps: installProcsDamageD
     }
   };
 
+  // A charged stat buff with DEAL spell flags (Chaos Fire 24389: "your next Fire spell") spends a
+  // charge when the bearer lands a damaging spell. Aura 13 has no proc handler, so the generic path
+  // drops the charge. A one-school damage mod only takes a spell of that school (24389 SchoolMask 0x04).
+  // Cite: UnitAuraProcHandler.cpp:46,:500-509; sql/archive/0.10/5019_mangos_spell_proc_event.sql.
+  const consumeChargedBuffsOnDealHit = (src: Fighter, fromSpell: SpellDef): void => {
+    const t = ctx.t;
+    const dealFlags = harmfulSpellDealFlags();
+    const mine = ctx.effectsOn(src.side);
+    for (let i = mine.length - 1; i >= 0; i--) {
+      const e = mine[i]!;
+      if (e.kind !== 'buff') continue;
+      if (e.charges == null || e.charges <= 0) continue;
+      if (e.expiresAt <= t) continue;
+      // An aura cannot spend its own charge. Cite: UnitAuraProcHandler.cpp:543.
+      if (e.spellId === fromSpell.id) continue;
+      const pf = (e.procFlags ?? 0) | 0;
+      if (pf === 0 || (pf & dealFlags) === 0) continue;
+      const modSchool = e.mod ? SPELL_DAMAGE_MOD_SCHOOL[e.mod as keyof typeof SPELL_DAMAGE_MOD_SCHOOL] : undefined;
+      if (modSchool && fromSpell.school !== modSchool) continue;
+      const { remaining, remove } = consumeProcCharge(e.charges);
+      if (remove) {
+        ctx.removeAurasDueToSpell?.(src, e.spellId);
+      } else {
+        e.charges = remaining;
+        ctx.touchEffect(e);
+      }
+    }
+  };
+
   // Proc support: match the flags and the per-minute rate, then fire the trigger spell's effects as a
   // free, instant, no-cost side effect. The injected rng keeps it deterministic, and procs do not nest.
   const triggerProcs = (
@@ -290,6 +319,7 @@ export function installProcsDamage(ctx: CombatContext, deps: installProcsDamageD
         else syncCombustionChip(src);
       }
     }
+    if (flagsHint === 'spell' && fromSpell) consumeChargedBuffsOnDealHit(src, fromSpell);
     const procs = src.procs || [];
     if (!procs.length) return;
     const procCtx = makeProcCtx(src, wasCrit, flagsHint, fromSpell);

package/src/engine/combat/sessionChase.ts

@@ -32,7 +32,7 @@ import {
   isChaseInsideModel,
   type ChaseClosenessState,
 } from './chaseCloseness.ts';
-import { rangedAutoMinYards, spellTargetTypeAllowed } from './predicates.ts';
+import { focusImmunityBlocksSpell, rangedAutoMinYards, spellTargetTypeAllowed } from './predicates.ts';
 import { CREATURE_FAMILY_ASSISTANCE_RADIUS } from '../../domain/creature/creatureAiConstants.ts';
 import type { MotionOwner } from './motionClaim.ts';
 import type { MotionGenerator } from './motionGenerator.ts';
@@ -47,6 +47,8 @@ import type { UnitNavPath, PathToOpts } from './sessionPathTo.ts';
 const RANGED_MIN_CLEARANCE_YD = 2;
 /** Stay this far inside an unpulled mob's detection so the step does not graze aggro. */
 const UNPULLED_AGGRO_MARGIN_YD = 1.5;
+/** Park this far inside a cast's rangeMax, past the walk order's 0.25 yd arrival slack. */
+const CAST_REACH_SLACK_YD = 0.5;
 // How far inside the bad arc a melee DPS must be before it starts a flank slide (~20 deg). A dead band, not
 // a tolerance: the arc's own edge is what moves under it every tick.
 const MELEE_SLOT_ENTRY_MARGIN_RAD = 0.35;
@@ -773,10 +775,14 @@ export function createChaseArm(deps: ChaseDeps): {
       for (const s of shortOffenseList(f)) {
         if (onCooldown(f, s) || !canAfford(f, s)) continue;
         if (!spellTargetTypeAllowed(s, tgt.creatureType ?? 0)) continue;
+        if (focusImmunityBlocksSpell(s, tgt, 1)) continue;
         const r = s.rangeMax ?? 0;
         if (r > fireR) fireR = r;
       }
       if (fireR > 0) {
+        // Inside the reach, not on it: a walk order arrives within ARRIVE_YD (0.25) of its dest, and
+        // a shaman parked at 20.2 yd never got the 20 yd Flame Shock off.
+        fireR -= CAST_REACH_SLACK_YD;
         stopAt = stopAt > 0 ? Math.min(stopAt, fireR) : fireR;
       } else {
         // Healer off-aggro may keep a stamped stand for heals; solo MH must not freeze.

package/src/engine/combat/sessionMotionKit.ts

@@ -10,6 +10,7 @@ import { effectiveSpeeds, type SpeedEffect } from '../../domain/nav/speed.ts';
 import { MIN_AGGRO_DISTANCE } from '../../domain/creature/creatureAi.ts';
 import { woundedSlowdownFactor } from '../../domain/creature/creatureAiConstants.ts';
 import { roleOf } from './roles.ts';
+import { focusImmunityBlocksSpell } from './predicates.ts';
 import { triggeredIdsOf } from './triggeredCompanion.ts';
 import type { CombatContext } from './context.ts';
 import type { Fighter } from './types.ts';
@@ -132,8 +133,42 @@ export function createMotionKit(deps: MotionKitDeps): MotionKit {
     return r;
   };
 
-  const longestOffenseRangeYd = (f: Fighter): number =>
-    rangedOffenseKit(f, (f.spec.weapon?.dmgMax ?? 0) > 0, rangedPlan(f)).maxRangeYd;
+  // The focus when it can refuse a school, else null. Almost nothing can, so the kit walks below
+  // only run against an elemental or a bubble, and every other tick pays one mask read.
+  const schoolImmuneFoeOf = (f: Fighter): Fighter | null => {
+    const foe = ctx.foeOf?.(f);
+    if (!foe || foe === f) return null;
+    const masks = (foe.immunity?.schoolImmuneMask ?? 0) | (foe.immunity?.damageImmuneMask ?? 0)
+      | (foe.spec.schoolImmuneMask ?? 0);
+    return masks !== 0 ? foe : null;
+  };
+
+  // A focus that refuses the WHOLE offense kit (Vek'nilash to a frost mage) changes nothing: the
+  // caster holds where it stood, which is what a raid wants. Only a partial wall re-aims motion at
+  // what still lands. Cite: twinUppercut capability (casters at 30 yd take no Uppercut).
+  const immuneFoeWithAnOpening = (f: Fighter): Fighter | null => {
+    const foe = schoolImmuneFoeOf(f);
+    if (!foe) return null;
+    for (const s of rangedOffenseKit(f, (f.spec.weapon?.dmgMax ?? 0) > 0, rangedPlan(f)).list) {
+      if (!focusImmunityBlocksSpell(s, foe, 1)) return foe;
+    }
+    for (const s of shortOffenseList(f)) if (!focusImmunityBlocksSpell(s, foe, 1)) return foe;
+    return null;
+  };
+
+  // Reach of what can actually land: a shaman parked at Lightning Bolt's 40 yd from a Rock Elemental
+  // never came inside Flame Shock's 20.
+  const longestOffenseRangeYd = (f: Fighter): number => {
+    const kit = rangedOffenseKit(f, (f.spec.weapon?.dmgMax ?? 0) > 0, rangedPlan(f));
+    const foe = immuneFoeWithAnOpening(f);
+    if (!foe) return kit.maxRangeYd;
+    let r = 0;
+    for (const s of kit.list) {
+      if (focusImmunityBlocksSpell(s, foe, 1)) continue;
+      if ((s.rangeMax ?? 0) > r) r = s.rangeMax ?? 0;
+    }
+    return r;
+  };
 
   /** Judgement / Holy Shock — foe offense not in rangedOffenseKit (nuke/dot/shoot only). */
   type ShortOffenseKit = { len: number; list: SpellDef[] };
@@ -159,9 +194,12 @@ export function createMotionKit(deps: MotionKitDeps): MotionKit {
     const rangedAuto = rangedPlan(f);
     // Only cooldown/cost are live here; which spells even COUNT as ranged offense is a bake
     // constant, and re-deriving it walked the whole kit through roleOf per unit per tick.
+    // Immunity is live too: a Fireball the focus shrugs off held a fire mage at range forever.
+    const foe = immuneFoeWithAnOpening(f);
     for (const s of rangedOffenseKit(f, hasRealMelee, rangedAuto).list) {
       if (onCooldown(f, s)) continue;
       if (!canAfford(f, s)) continue;
+      if (foe && focusImmunityBlocksSpell(s, foe, 1)) continue;
       return true;
     }
     return false;

package/src/quests/quests.ts

@@ -534,6 +534,66 @@ export function compareQuestDroppers(
   return a.level - b.level;
 }
 
+/** A dropper counts as "as good" as the best one when its chance is at least this share of it. */
+export const SIMILAR_DROPPER_RATIO = 0.75;
+/** ...and its level is at most this far below the best one's (and never gray to the player). */
+export const SIMILAR_DROPPER_LEVELS_BELOW = 3;
+/** ...and at most this far above the player (a harder mob than the best is never the pool's gain). */
+export const SIMILAR_DROPPER_LEVELS_OVER = 1;
+
+/**
+ * The entries worth pulling interchangeably with the top-ranked one: same elite class, a drop
+ * chance at least SIMILAR_DROPPER_RATIO of its chance, a level no more than SIMILAR_DROPPER_LEVELS_OVER
+ * above the player (or the best, when the whole set is above the player), no more than
+ * SIMILAR_DROPPER_LEVELS_BELOW under the best, and not gray unless the best is. Kill objectives
+ * carry chance 0, so every credited entry in the level band qualifies. `ranked` is ordered by
+ * compareQuestDroppers already, so ranked[0] is the best.
+ */
+export function similarQuestDroppers<T extends { level: number; chance: number; rank?: number }>(
+  ranked: readonly T[],
+  playerLevel: number,
+): T[] {
+  const best = ranked[0];
+  if (!best) return [];
+  const bestElite = (best.rank ?? 0) > 0;
+  const haveLevel = playerLevel > 0;
+  const ceiling = Math.max(best.level, haveLevel ? playerLevel + SIMILAR_DROPPER_LEVELS_OVER : best.level);
+  const floor = best.level - SIMILAR_DROPPER_LEVELS_BELOW;
+  const bestGray = haveLevel && difficultyTier(best.level, playerLevel) === 'gray';
+  return ranked.filter((c) => {
+    if (((c.rank ?? 0) > 0) !== bestElite) return false;
+    if (c.chance < best.chance * SIMILAR_DROPPER_RATIO) return false;
+    if (c.level > ceiling || c.level < floor) return false;
+    return bestGray || !haveLevel || difficultyTier(c.level, playerLevel) !== 'gray';
+  });
+}
+
+/**
+ * One pull among the similar droppers, chosen by `salt` so the same state names the same mob and
+ * the next fight (state.fightCounter moved) can name another. Always picking the comparator's
+ * winner sent every Murloc quest at the Oracle and every collect quest at one template; a pool
+ * of near-equal mobs spreads the kills without touching the ranking the smokes pin.
+ */
+export function pickQuestDropper<T extends { level: number; chance: number; rank?: number }>(
+  ranked: readonly T[],
+  playerLevel: number,
+  salt: number,
+): T | undefined {
+  const pool = similarQuestDroppers(ranked, playerLevel);
+  if (pool.length <= 1) return pool[0] ?? ranked[0];
+  // A short integer mix so consecutive salts do not walk the pool in order.
+  let h = (salt ^ 0x9e3779b9) >>> 0;
+  h = Math.imul(h ^ (h >>> 16), 0x85ebca6b) >>> 0;
+  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+  h = (h ^ (h >>> 16)) >>> 0;
+  return pool[h % pool.length];
+}
+
+/** The salt pickQuestDropper takes for a save: the fight nonce under the save's seed. */
+export function dropperPickSalt(state: { rngSeed: number; fightCounter: number }): number {
+  return ((state.rngSeed | 0) * 31 + (state.fightCounter | 0)) | 0;
+}
+
 // The best eligible loot chance for an item on this creature, 0 for none. An equal-chance group row
 // scores as one so it beats a near-zero free row. Cite: domain/items/loot.ts.
 export function lootChanceForItem(