azeroth-shell 0.1.2 → 0.3.0

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;
@@ -246,7 +248,18 @@ export function createChaseArm(deps: ChaseDeps): {
     if (isEnemySide(f.side)) {
       // The GRADE is the full contact ring while the PARK is half of it, which is the split the C++
       // makes — and it retires the knife edge where one ULP of step error triggered a full-HP evade.
-      const reach = Math.max(pairContact, longestOffenseRangeYd(f) + EVADE_REACH_EPS_YD);
+      let reach = Math.max(pairContact, longestOffenseRangeYd(f) + EVADE_REACH_EPS_YD);
+      // With no ranged kit the park below stops at the short offense, so grade against it too. A
+      // Razormane Scout's Shoot 6660 infers instant_nuke: it parked at 24 yd, shot, and reset every 5 s.
+      // Scheduled spells only, so a kit row the mob never casts still lets it evade.
+      if (dist > reach) {
+        const castable = castableKitIds(f, ctx.spellOf);
+        for (const s of shortOffenseList(f)) {
+          if (castable && !castable.has(s.id | 0)) continue;
+          if (!spellTargetTypeAllowed(s, tgt.creatureType ?? 0) || focusImmunityBlocksSpell(s, tgt, 1)) continue;
+          reach = Math.max(reach, (s.rangeMax ?? 0) + EVADE_REACH_EPS_YD);
+        }
+      }
       const prev = unreachableFrom.get(f.side);
       const victimMoved = !!prev && (
         to.z != null && prev.victimZ != null
@@ -773,10 +786,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/engine/game/loadReconcile.ts

@@ -48,7 +48,7 @@ import { emptyInventory } from '../../domain/items/inventory.ts';
 import { trimSoulShards } from '../../domain/bots/soulShardCap.ts';
 import { companionLevel } from '../../domain/bots/squad.ts';
 import { syncCompanionProfessionTools } from './companionTraining.ts';
-import { petHasHappiness, reconcilePetPartyAuras } from '../../domain/pet/pet.ts';
+import { petHasHappiness, reconcilePetPartyAuras, tpSpentOnKnown } from '../../domain/pet/pet.ts';
 import { playerbotJunkItem } from '../../domain/bots/playerbotItemEligibility.ts';
 import type { EquippedMap } from '../../domain/character/character.ts';
 import { createAliveDeathFlow, isPlayerAlive } from '../../domain/run/death.ts';
@@ -324,6 +324,26 @@ export function applyLoadReconcile(ds: DataStore, state: GameState, opts?: impor
     }
   }
 
+  // A pet tamed before the bake dropped its rank-1 filler was charged training points for rank 1 of
+  // every family chain on top of its real kit, and may still queue those ranks to teach. Refund the
+  // difference once and keep the queue to the real kit. Cite: Pet.cpp:1955-1998 InitPetCreateSpells.
+  {
+    for (const p of [state.char.pet, state.char.storedPet, ...(state.char.stablePets ?? [])]) {
+      if (!p || p.innateKit) continue;
+      const cdef = ds.creature(p.creature);
+      if (!cdef || !petHasHappiness(cdef)) continue;
+      const kit = cdef.petDefaultSpells ?? [];
+      const filler = (cdef.petSpells ?? []).filter((id) => {
+        const s = ds.spell(id);
+        return !!s && !s.passive && (s.rank | 0) <= 1;
+      });
+      const refund = tpSpentOnKnown([...kit, ...filler], ds) - tpSpentOnKnown(kit, ds);
+      if (refund > 0 && p.trainingPoints != null) p.trainingPoints += refund;
+      if (p.teachSpells) p.teachSpells = p.teachSpells.filter((id) => kit.includes(id));
+      p.innateKit = [...kit];
+    }
+  }
+
   // Action bars: normalize any loaded/legacy shape, and for a save that predates them
   // (empty) seed bar 1 with the player's usable abilities so combat isn't blank.
   state.actionBars = normalizeBars(state.actionBars);

package/src/engine/game/pets.ts

@@ -3,7 +3,7 @@
 
 import {
   newPet, petHasHappiness, petTaughtIds, petRepertoireHas,
-  feedPetHappinessGain, petDiet, isPetFood, tpForSpell, hasTpForSpell,
+  feedPetHappinessGain, petDiet, isPetFood, tpForSpell, hasTpForSpell, petUntrainCost, untrainPetState,
   LOYALTY_REBELLIOUS, FEED_PET_DURATION_S,
   autoFeedThreshold, AUTO_FEED_TARGET, HAPPINESS_MAX,
   applyPetPartyAuras, stripPetPartyAuras, petPartyAuraSpellIds, reconcilePetPartyAuras,
@@ -156,6 +156,8 @@ export function createPetsModule(ctx: GameCtx, extras: PetsExtras): Pick<
   | 'setPetAutoFeed'
   | 'buyPetSpell'
   | 'teachPetSpell'
+  | 'untrainPet'
+  | 'untrainPetCost'
   | 'togglePetAutocast'
   | 'setPetCommand'
   | 'setPetReact'
@@ -319,6 +321,36 @@ export function createPetsModule(ctx: GameCtx, extras: PetsExtras): Pick<
       return { ok: true };
     },
 
+    untrainPetCost(nowMs) {
+      const pet = state.char.pet;
+      const cdef = pet ? ds.creature(pet.creature) : undefined;
+      if (!pet || !cdef || !petHasHappiness(cdef)) return null;
+      return petUntrainCost(pet, nowMs ?? Date.now());
+    },
+
+    untrainPet(trainerEntry, nowMs) {
+      const trainer = ds.trainer(trainerEntry);
+      if (!trainer || !(trainer.subname ?? '').toLowerCase().includes('pet trainer')) {
+        return { ok: false, reason: 'That is not a pet trainer' };
+      }
+      if (!canInteractWithCreature(ds, state.char.race, trainerEntry)) {
+        return { ok: false, reason: 'They refuse to deal with you.' };
+      }
+      const pet = state.char.pet;
+      if (!pet) return { ok: false, reason: 'You have no pet' };
+      if (pet.health <= 0) return { ok: false, reason: 'Your pet is dead' };
+      const cdef = ds.creature(pet.creature);
+      if (!cdef || !petHasHappiness(cdef)) return { ok: false, reason: 'Only a hunter pet can be untrained' };
+      if (!petTaughtIds(state.char, cdef).length) return { ok: false, reason: `${pet.name} has nothing to forget` };
+      const now = nowMs ?? Date.now();
+      const cost = petUntrainCost(pet, now);
+      if (state.char.gold < cost) return { ok: false, reason: 'Not enough money' };
+      state.char.gold -= cost;
+      state.char.pet = { ...untrainPetState(pet, cdef, state.char.level, ds), resetTalentsCost: cost, resetTalentsTime: now };
+      log(`${pet.name} forgets its training for ${moneyMarked(cost)} - ${state.char.pet.trainingPoints} training points to spend again.`);
+      return { ok: true, spent: cost };
+    },
+
     togglePetAutocast(spellId) {
       const pet = state.char.pet;
       if (!pet) return { ok: false, reason: 'You have no pet' };

package/src/engine/game/types.ts

@@ -768,6 +768,10 @@ export interface Game {
   // Beast Training (spell 5149): teach the CURRENT pet a rank from the repertoire, spending ITS training
   // points (chain-aware). Cite: Pet.cpp GetTPForSpell/learnSpell.
   teachPetSpell(spellId: number): ActionResult;
+  // Untrain the current hunter pet at a pet trainer: forget every taught ability, training points back
+  // to level × (loyalty − 1), for the escalating fee petUntrainCost reads. Cite: HandlePetUnlearnOpcode.
+  untrainPet(trainerEntry: number, nowMs?: number): ActionResult<{ spent: number }>;
+  untrainPetCost(nowMs?: number): number | null;
   // Toggle autocast for a pet ability (right-click on the pet bar). Rank-agnostic by name chain; disabled
   // abilities stay learned but leave the combat kit (buildPet).
   togglePetAutocast(spellId: number): ActionResult<{ enabled: boolean }>;

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(