azeroth-shell 0.1.2 → 0.3.0

package/src/domain/bg/strategies.ts

@@ -27,6 +27,19 @@ const enemyBase = (view: BgView): BgPos => {
   return { x: g.x, y: g.y };
 };
 
+// Each side's flag runs keep to one edge of the field, past the brawl at the mid point: Alliance
+// along the north side, Horde along the south, so the two runs never cross each other either.
+// A run straight through mid put the carrier inside the mid fight's 30 yd shard every time.
+const LANE_DY: Record<BgTeam, number> = { alliance: 90, horde: -90 };
+const laneWaypoint = (team: BgTeam): BgPos => ({ x: WSG_GEOMETRY.mid.x, y: WSG_GEOMETRY.mid.y + LANE_DY[team] });
+/** Toward `to` by the lane: the lane point while it is still ahead on the way, then `to` itself. */
+const viaLane = (unit: BgUnitView, team: BgTeam, to: BgPos): BgPos => {
+  const wp = laneWaypoint(team);
+  const dir = Math.sign(to.x - unit.pos.x);
+  if (dir !== 0 && Math.sign(wp.x - unit.pos.x) === dir && Math.abs(wp.x - unit.pos.x) > 15) return wp;
+  return to;
+};
+
 const ourFlag = (view: BgView) => view.objectives.find((o) => o.id === flagObjectiveId(view.team));
 const theirFlag = (view: BgView) =>
   view.objectives.find((o) => o.id === flagObjectiveId(OTHER_TEAM[view.team]));
@@ -37,6 +50,21 @@ const ourCarrier = (view: BgView): BgUnitView | undefined =>
 const theirCarrier = (view: BgView): BgUnitView | undefined =>
   view.enemies.find((u) => u.carryingFlag && u.alive);
 
+// Both flags carried: neither side can score until the other carrier dies and the flag returns. Left to
+// escorting and holding, both teams sat on their own carrier at home and a 25-minute match had two
+// pickups. The field goes to kill their carrier; the defenders stay with ours.
+const doubleCarry = (view: BgView): boolean => !!ourCarrier(view) && !!theirCarrier(view);
+
+const nearestOf = <T extends { pos: BgPos }>(from: BgPos, list: readonly T[]): T | undefined => {
+  let best: T | undefined;
+  let bd = Infinity;
+  for (const o of list) {
+    const d = dist(from, o.pos);
+    if (d < bd) { bd = d; best = o; }
+  }
+  return best;
+};
+
 const nearestVisibleEnemy = (unit: BgUnitView, view: BgView): BgUnitView | undefined => {
   let best: BgUnitView | undefined;
   let bd = Infinity;
@@ -55,7 +83,7 @@ const runFlagHome: BgAction = {
   name: 'runFlagHome',
   relevance: () => 100,
   available: (unit) => !!unit.carryingFlag,
-  order: (_unit, view) => ({ kind: 'move', to: homeBase(view) }),
+  order: (unit, view) => ({ kind: 'move', to: viaLane(unit, view.team, homeBase(view)) }),
 };
 
 // Our own flag is on the ground: touching it returns it. Urgent — a dropped flag returns itself in 10 s,
@@ -70,18 +98,38 @@ const returnOurFlag: BgAction = {
   },
 };
 
+/** How far the flag runner will step aside to help kill the enemy carrier; beyond it they keep running. */
+const RUNNER_PEEL_YD = 60;
+/** An enemy carrier this close pulls a body out of the fight it is in. */
+const CARRIER_PEEL_YD = 60;
+/** A carrier of ours this close does too. */
+const CARRIER_HELP_YD = 100;
+
 // Chase whoever has our flag. Its FLOOR must stay above holdOurBase (70): at 50, defenders
 // preferred an already-safe base over retrieving the flag, and both teams sat at 0-0 forever.
+// The flag runner is the exception: a cross-carry is how a stalemate breaks, so they only peel onto
+// a carrier who runs past them.
 const chaseEnemyCarrier: BgAction = {
   name: 'chaseEnemyCarrier',
   relevance: (unit, view) => {
     const c = theirCarrier(view);
     if (!c) return 0;
-    // Closer chasers care more, so the whole team does not peel onto one runner — but even
-    // the furthest chaser outranks holding a base.
-    return 95 - Math.min(20, dist(unit.pos, c.pos) / 40);
+    if (unit.role === 'flag-carrier') return 90;
+    // A carrier passing close outranks everything but the flag actions; a far one still outranks
+    // holding a base (70), but not the fight this body is in (82): with every mid fighter peeling
+    // onto a carrier 200 yd away, the whole brawl migrated and the runs always died in it.
+    return dist(unit.pos, c.pos) < CARRIER_PEEL_YD ? 95 : 75;
+  },
+  available: (unit, view) => {
+    if (unit.carryingFlag) return false;
+    const c = theirCarrier(view);
+    if (!c) return false;
+    const d = dist(unit.pos, c.pos);
+    if (unit.role === 'flag-carrier') return d < RUNNER_PEEL_YD;
+    // In a double carry a defender guards our carrier instead of crossing the map.
+    if (unit.role === 'defense' && doubleCarry(view)) return d < CARRIER_PEEL_YD;
+    return true;
   },
-  available: (unit, view) => !unit.carryingFlag && !!theirCarrier(view),
   // `follow`, NOT attack-move to a position: the strategy layer runs at 1 Hz, so a position order
   // sends an equal-speed chaser to where the carrier was a second ago and never closes.
   order: (_unit, view) => {
@@ -92,13 +140,18 @@ const chaseEnemyCarrier: BgAction = {
 
 // Stay on our carrier and kill what touches them. Open to every non-defense role: with escorts
 // alone a carrier ran 620 yd through the enemy team by itself and died within ~50 yd every time.
+// A carrier within reach outranks the fight a body is in (82), as a passing enemy carrier does;
+// one far away does not, so the mid fight is not abandoned for a run on the other side of the map.
 const escortCarrier: BgAction = {
   name: 'escortCarrier',
-  relevance: () => 80,
+  relevance: (unit, view) => {
+    const c = ourCarrier(view);
+    return c && dist(unit.pos, c.pos) < CARRIER_HELP_YD ? 84 : 80;
+  },
   available: (unit, view) => {
     if (unit.carryingFlag) return false;
     if (unit.role === 'defense') return false;
-    return !!ourCarrier(view);
+    return !!ourCarrier(view) && !theirCarrier(view);
   },
   order: (_unit, view) => {
     const c = ourCarrier(view);
@@ -106,18 +159,73 @@ const escortCarrier: BgAction = {
   },
 };
 
-/** Go take their flag. */
+// Our flag runner, alive and not yet carrying: the body the escorts walk in with.
+const ourRunner = (view: BgView): BgUnitView | undefined =>
+  view.own.find((u) => u.role === 'flag-carrier' && u.alive && !u.carryingFlag);
+
+// Walk in with the runner. Escorts used to wait at mid for a carrier to exist, so the runner went
+// into the enemy flag room alone, picked up, and died to the two defenders before anyone arrived.
+const escortRunner: BgAction = {
+  name: 'escortRunner',
+  relevance: () => 58,
+  available: (unit, view) => !unit.carryingFlag && !ourCarrier(view) && !!ourRunner(view) && ourRunner(view)!.id !== unit.id,
+  order: (_unit, view) => {
+    const r = ourRunner(view);
+    return r ? { kind: 'follow', target: r.id } : null;
+  },
+};
+
+/** An escort this close is with the runner; farther, the runner goes back for them. */
+const ESCORT_WITH_YD = 25;
+/** An escort farther than this from the runner is somebody the runner should wait for. */
+const ESCORT_FAR_YD = 40;
+
+/** Our living escorts who are not carrying anything. */
+const ourEscorts = (view: BgView): BgUnitView[] =>
+  view.own.filter((u) => u.role === 'fc-escort' && u.alive && !u.carryingFlag);
+
+// The runner does not walk into the enemy flag room alone. With escorts alive but elsewhere (held in
+// a fight at mid, or just back from the graveyard) the runner goes to the nearest one; once an escort
+// is beside them, grabEnemyFlag takes over and the group walks in together. Alone, a level-22 runner
+// picked up and died to the two defenders in nine seconds, sixteen times in a row: 0-0 after 20 min.
+const waitForEscort: BgAction = {
+  name: 'waitForEscort',
+  relevance: () => 86,
+  available: (unit, view) => {
+    if (unit.role !== 'flag-carrier' || unit.carryingFlag) return false;
+    const escorts = ourEscorts(view).filter((e) => e.id !== unit.id);
+    if (!escorts.length) return false;
+    if (escorts.some((e) => dist(e.pos, unit.pos) < ESCORT_WITH_YD)) return false;
+    return escorts.some((e) => dist(e.pos, unit.pos) > ESCORT_FAR_YD);
+  },
+  order: (unit, view) => {
+    const e = nearestOf(unit.pos, ourEscorts(view).filter((o) => o.id !== unit.id));
+    return e ? { kind: 'follow', target: e.id } : null;
+  },
+};
+
+/** A dropped flag this close is anyone's to pick up before it returns itself in 10 s. */
+const GROUND_FLAG_REACH_YD = 60;
+
+// Go take their flag. The runner walks across the map for it; a fighter in reach of a dropped one
+// picks it up (a pass, in WSG terms); everyone else only takes it from the ground when it is near.
 const grabEnemyFlag: BgAction = {
   name: 'grabEnemyFlag',
-  relevance: (unit) => (unit.role === 'flag-carrier' ? 85 : unit.role === 'offense' ? 60 : 20),
+  relevance: (unit, view) => {
+    const f = theirFlag(view);
+    if (f?.state === 'ground' && unit.role !== 'defense' && dist(unit.pos, f.pos) < GROUND_FLAG_REACH_YD) return 90;
+    return unit.role === 'flag-carrier' ? 85 : unit.role === 'offense' ? 42 : 20;
+  },
   available: (unit, view) => {
     if (unit.carryingFlag) return false;
     const f = theirFlag(view);
     return f?.state === 'base' || f?.state === 'ground';
   },
-  order: (_unit, view) => {
+  order: (unit, view) => {
     const f = theirFlag(view);
-    return f ? { kind: 'attack-move', to: f.pos } : { kind: 'attack-move', to: enemyBase(view) };
+    const to = f ? f.pos : enemyBase(view);
+    // The runner walks the lane in; a dropped flag is wherever it fell, so it is walked to straight.
+    return { kind: 'attack-move', to: unit.role === 'flag-carrier' && f?.state !== 'ground' ? viaLane(unit, view.team, to) : to };
   },
 };
 
@@ -138,21 +246,38 @@ const holdOurBase: BgAction = {
   },
 };
 
-/** Contest the middle — where the two flag runs cross. */
+/** Standing this close to the mid point is holding it. */
+const MID_HELD_YD = 40;
+
+// Contest the middle — where the two flag runs cross. Walking there outranks an enemy in reach;
+// once there, an enemy in reach outranks standing on the point, or two groups stood 50 yd apart
+// at mid for a whole match and watched each other's runners walk past.
 const contestMid: BgAction = {
   name: 'contestMid',
-  relevance: (unit) => (unit.role === 'mid' ? 55 : 25),
+  relevance: (unit) => {
+    if (unit.role !== 'mid') return 25;
+    return dist(unit.pos, WSG_GEOMETRY.mid) > MID_HELD_YD ? 55 : 30;
+  },
   available: (unit) => !unit.carryingFlag,
   order: () => ({ kind: 'attack-move', to: { ...WSG_GEOMETRY.mid } }),
 };
 
-/** Fight what is in front of you. The floor action — always available, always lowest. */
+/** Touching distance: a fight you are in. */
+const ENGAGE_CONTACT_YD = 25;
+/** An enemy this close is worth walking over to. */
+const ENGAGE_REACH_YD = 60;
+
+// Fight what is in front of you. In contact it outranks escorting (80) and the offense grab (42), so
+// a body finishes the fight it is in instead of walking off mid-swing with the enemy on its back; it
+// stays under the runner's grab (85), the carrier chase and the flag actions. In reach it outranks
+// holding mid; far away it is the floor.
 const engageNearest: BgAction = {
   name: 'engageNearest',
   relevance: (unit, view) => {
     const foe = nearestVisibleEnemy(unit, view);
     if (!foe) return 0;
-    return dist(unit.pos, foe.pos) < 25 ? 50 : 10;
+    const d = dist(unit.pos, foe.pos);
+    return d < ENGAGE_CONTACT_YD ? 82 : d < ENGAGE_REACH_YD ? 45 : 10;
   },
   available: (unit, view) => !unit.carryingFlag && !!nearestVisibleEnemy(unit, view),
   // Same reason as chaseEnemyCarrier: track the unit, not a one-second-old point.
@@ -174,7 +299,7 @@ const carrierDisengage: BgAction = {
     );
     return !helpNear;
   },
-  order: (_unit, view) => ({ kind: 'retreat', to: homeBase(view) }),
+  order: (unit, view) => ({ kind: 'retreat', to: viaLane(unit, view.team, homeBase(view)) }),
 };
 
 // ---- Arathi Basin: nodes, not flags ----------------------------------------
@@ -192,16 +317,6 @@ const takeableNodes = (view: BgView) =>
 const nodesUnderAssault = (view: BgView) =>
   nodes(view).filter((o) => o.state === 'assaulted' && o.prevOwner === view.team);
 
-const nearestOf = <T extends { pos: BgPos }>(from: BgPos, list: readonly T[]): T | undefined => {
-  let best: T | undefined;
-  let bd = Infinity;
-  for (const o of list) {
-    const d = dist(from, o.pos);
-    if (d < bd) { bd = d; best = o; }
-  }
-  return best;
-};
-
 const abHome = (view: BgView): BgPos => {
   const s = AB_GEOMETRY.start[view.team];
   return { x: s.x, y: s.y };
@@ -475,7 +590,7 @@ export const AV_MID: BgPos = { ...AV_GEOMETRY.mid };
 export const BG_STRATEGIES = {
   'wsg.offense': {
     name: '~wsg.offense',
-    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, grabEnemyFlag, engageNearest, contestMid],
+    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, waitForEscort, grabEnemyFlag, engageNearest, contestMid],
   },
   'wsg.defense': {
     name: '~wsg.defense',
@@ -483,11 +598,11 @@ export const BG_STRATEGIES = {
   },
   'wsg.fc-escort': {
     name: '~wsg.fc-escort',
-    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, engageNearest, contestMid],
+    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, grabEnemyFlag, escortRunner, engageNearest, contestMid],
   },
   'wsg.mid': {
     name: '~wsg.mid',
-    actions: [returnOurFlag, chaseEnemyCarrier, escortCarrier, contestMid, engageNearest],
+    actions: [runFlagHome, carrierDisengage, returnOurFlag, chaseEnemyCarrier, escortCarrier, grabEnemyFlag, contestMid, engageNearest],
   },
   // Arathi Basin. No flag actions at all: the WSG bundles walk to WSG_GEOMETRY, which is map 489,
   // so an AB unit on one of them marched off the plate and never touched a banner.

package/src/domain/bg/types.ts

@@ -75,6 +75,8 @@ export interface BgUnit {
   order: BgOrder;
   /** Combat spec — only needed when a shard is folded into a real createSession. */
   spec?: CombatantSpec;
+  /** Does this seat heal? The attrition resolver reads it; absent, it falls back to the class. */
+  heals?: boolean;
   /** Movement speed, yards/second. */
   speedYd: number;
   /** Set while this unit carries an enemy flag (the aura id, 23333 / 23335). */

package/src/domain/bg/wsg.ts

@@ -178,27 +178,19 @@ export function installWsg(world: BgWorld): WsgEvent[] {
 
       if (obj.state !== 'base' && obj.state !== 'ground') continue;
 
-      // Someone standing on it either takes it (enemy) or returns it (owner, dropped only).
-      for (const u of w.units.values()) {
-        if (!w.alive(u)) continue;
-        if (detHypot(u.pos.x - obj.pos.x, u.pos.y - obj.pos.y) > WS_FLAG_INTERACT_YD) continue;
-
-        if (u.team === team) {
-          // Your own flag: on the ground → return it. At base → nothing.
-          if (obj.state === 'ground') {
-            returnFlag(team, u);
-            break;
-          }
-          continue;
-        }
-        // Enemy flag: pick it up. One flag per unit.
-        if (u.carryingFlag) continue;
-        obj.state = 'carried';
-        obj.carrier = u.id;
-        u.carryingFlag = flagSpellCarriedBy(u.team);
-        log({ t: w.t, kind: 'pickup', team: u.team, unit: u.id });
-        break;
+      // Someone standing on it either takes it (enemy) or returns it (owner, dropped only). With
+      // both sides on a dropped flag the nearest hand wins; the first body in roster order used to,
+      // so the team added to the world first won every contested flag and every match.
+      const u = flagToucher(w, obj, team);
+      if (!u) continue;
+      if (u.team === team) {
+        returnFlag(team, u);
+        continue;
       }
+      obj.state = 'carried';
+      obj.carrier = u.id;
+      u.carryingFlag = flagSpellCarriedBy(u.team);
+      log({ t: w.t, kind: 'pickup', team: u.team, unit: u.id });
     }
 
     // A carrier standing on its OWN flag, with that flag at base, scores.
@@ -257,6 +249,29 @@ export function installWsg(world: BgWorld): WsgEvent[] {
   return events;
 }
 
+// The body that gets a flag everyone within reach wants. The owner's side can only return a dropped
+// flag; the other side's runner is preferred over its escorts at the base, since a pickup by the
+// escort sent the runner home empty-handed. Exact ties (bodies stacked on one point) alternate by
+// tick, so neither side is favoured by roster order.
+function flagToucher(w: BgWorld, obj: { pos: BgPos; state: string }, owner: BgTeam): BgUnit | null {
+  let best: BgUnit | null = null;
+  let bd = Infinity;
+  let bestRunner = false;
+  const odd = Math.floor(w.t / Math.max(1, w.tickMs)) % 2 === 1;
+  for (const u of w.units.values()) {
+    if (!w.alive(u)) continue;
+    const own = u.team === owner;
+    if (own ? obj.state !== 'ground' : !!u.carryingFlag) continue;
+    const d = detHypot(u.pos.x - obj.pos.x, u.pos.y - obj.pos.y);
+    if (d > WS_FLAG_INTERACT_YD) continue;
+    const runner = !own && u.role === 'flag-carrier';
+    if (!best || (runner && !bestRunner) || (runner === bestRunner && (d < bd || (d === bd && odd)))) {
+      best = u; bd = d; bestRunner = runner;
+    }
+  }
+  return best;
+}
+
 /** Where a dead unit of `team` comes back. Cite: world_safe_locs 771 / 772. */
 export function wsgGraveyard(team: BgTeam): BgPos {
   const gy = WSG_GEOMETRY.graveyard[team];

package/src/domain/character/character.ts

@@ -195,6 +195,9 @@ export interface PetState {
   loyaltyPoints?: number;
   /** Unspent training points for pet-trainer abilities. */
   trainingPoints?: number;
+  // Pet untrain fee ladder: the last fee paid (copper) and when (epoch ms). Pet::m_resetTalentsCost/Time.
+  resetTalentsCost?: number;
+  resetTalentsTime?: number;
   /** Owner XP remaining before the next loyalty level-up is allowed (SetRequiredXpForNextLoyaltyLevel). */
   loyaltyXpRequired?: number;
   // Ability ids the player right-click-disabled on the pet bar, rank-agnostic by name chain.
@@ -206,6 +209,9 @@ export interface PetState {
   // Hunter pets: innate ability ids the OWNER can still learn from this pet, each cast rolling 10%
   // to enter the Beast Training repertoire. Mirrors Pet::m_teachspells.
   teachSpells?: number[];
+  // Hunter pets: the innate kit its tame charged training points for (InitPetCreateSpells). Absent on
+  // a pet tamed while the bake still handed every beast rank 1 of each family chain.
+  innateKit?: number[];
   // Pet bar command: 'follow' (default) or 'stay'. 'attack' is a one-shot order and is never stored. Cite:
   // Unit.h:819-824 CommandStates; PetActionBarFrame.lua PET_FOLLOW/PET_WAIT.
   command?: 'follow' | 'stay';

package/src/domain/pet/pet.ts

@@ -667,6 +667,36 @@ export function grantPetLevelTrainingPoints(
   return { ...pet, trainingPoints: (pet.trainingPoints ?? 0) + gain };
 }
 
+const PET_UNTRAIN_DAY_MS = 24 * 60 * 60 * 1000;
+
+// Next pet-untrain fee in copper, Pet::resetTalentsCost: 10s, then 50s, then 1g, then +1g to a 10g
+// cap; a day since the last untrain drops it back to 10s. Cite: Pet.cpp resetTalentsCost.
+export function petUntrainCost(pet: PetState, nowMs: number): number {
+  const prev = pet.resetTalentsCost ?? 0;
+  const days = Math.floor((nowMs - (pet.resetTalentsTime ?? 0)) / PET_UNTRAIN_DAY_MS);
+  if (prev < 1000 || days > 0) return 1000;
+  if (prev < 5000) return 5000;
+  if (prev < 10000) return 10000;
+  return Math.min(100000, prev + 10000);
+}
+
+// HandlePetUnlearnOpcode: every taught ability goes and TP resets to level × (loyalty − 1). The innate
+// kit is the creature's here (petKnownSpells reads petDefaultSpells), so it stays and keeps its tame
+// charge, where CMaNGOS unlearns it too. Cite: PetHandler.cpp HandlePetUnlearnOpcode; Pet.cpp SetTP.
+export function untrainPetState(pet: PetState, cdef: CreatureDef, petLevel: number, ds: DataStore): PetState {
+  const innate = pet.innateKit ?? cdef.petDefaultSpells ?? [];
+  const loyalty = pet.loyalty ?? LOYALTY_REBELLIOUS;
+  const { autocastOff, ...rest } = pet;
+  const keptOff = (autocastOff ?? []).filter((id) => innate.some((k) => ds.spell(k)?.name === ds.spell(id)?.name));
+  return {
+    ...rest,
+    ...(keptOff.length ? { autocastOff: keptOff } : {}),
+    loyalty,
+    taughtSpells: [],
+    trainingPoints: petLevel * (loyalty - 1) - tpSpentOnKnown(innate, ds),
+  };
+}
+
 // Abilities the active pet can cast: the innate kit plus taught ranks, intersected with the
 // creature's petSpells, highest LEVEL-ELIGIBLE rank per name. Generic-line passives are excluded.
 export function petKnownSpells(char: Character, cdef: CreatureDef, ds: DataStore): SpellDef[] {
@@ -863,6 +893,7 @@ export function newPet(creature: number, ds: DataStore, char: Character): PetSta
     // Training repertoire are taught per-pet for TP (game.teachPetSpell).
     taughtSpells: [],
     teachSpells,
+    innateKit: [...innate],
   };
 }
 

package/src/domain/quests/doQuest.ts

@@ -44,6 +44,8 @@ import { auraIdsForSnapshot, itemGrantsAdCommissionAura, snapshotHasAdCommission
 import {
   lootDropAllowed,
   compareQuestDroppers,
+  pickQuestDropper,
+  dropperPickSalt,
   creatureFarmLevel,
   creatureFarmRank,
   canTakeQuestForCondition,
@@ -935,6 +937,8 @@ function fightStep(
   const skip = opts?.skipCreatures;
   const hunt = huntableCreatures(ds, state.char.zoneId, state.questlog, state.char.race);
   const summoned = new Set(corpseUseSummonedEntries(ds, def));
+  const salt = dropperPickSalt(state);
+  const killable: { entry: number; level: number; chance: number; rank: number }[] = [];
   for (const kt of creatureCreditTargets(def)) {
     if ((qs.kills[String(kt.creatureEntry)] ?? 0) >= kt.count) continue;
     if (skip?.has(kt.creatureEntry)) continue;
@@ -949,7 +953,17 @@ function fightStep(
     // Friendly + noXp: beginFight refuses it as script credit, so proposing it strands the quest.
     if (isScriptCreditOnlyTarget(ds, kt.creatureEntry, state.questlog)) continue;
     // Named kill target is the quest — fight it even when it is not on zone.huntable.
-    if (ds.creature(kt.creatureEntry)) return { kind: 'fight', creatureEntry: kt.creatureEntry };
+    const cr = ds.creature(kt.creatureEntry);
+    if (cr) killable.push({ entry: kt.creatureEntry, level: creatureFarmLevel(cr), chance: 0, rank: creatureFarmRank(cr) });
+  }
+  if (killable.length > 0) {
+    // Several unmet kill objectives: rotate among the near-equal ones that are actually here, so a
+    // multi-template objective does not open on its first-listed entry every pull.
+    const here = new Set(hunt.map((c) => c.entry));
+    const local = killable.filter((k) => here.has(k.entry));
+    if (local.length === 0) return { kind: 'fight', creatureEntry: killable[0].entry };
+    local.sort((a, b) => compareQuestDroppers(a, b, state.char.level) || a.entry - b.entry);
+    return { kind: 'fight', creatureEntry: pickQuestDropper(local, state.char.level, salt)!.entry };
   }
   const farm = corpseUseFightEntries(ds, def, qs, state.inventory);
   if (farm.length) {
@@ -986,7 +1000,8 @@ function fightStep(
   }
   const usable = [...byEntry.values()];
   usable.sort((a, b) => compareQuestDroppers(a, b, state.char.level) || a.entry - b.entry);
-  if (usable[0]) return { kind: 'fight', creatureEntry: usable[0].entry };
+  const dropper = pickQuestDropper(usable, state.char.level, salt);
+  if (dropper) return { kind: 'fight', creatureEntry: dropper.entry };
   if (unmetItems.length === 0) return null;
   // farm[] is one union over every itemTarget, and many named templates are not on zone.huntable.
   // Prefer an entry that drops what we still need; 40 of 1366 farm quests gate it behind a condition.
@@ -1008,7 +1023,8 @@ function fightStep(
     ? farmDrop
     : farmScored.filter((s) => !farmCandidateIsHopeless(ds, def, s.ce, unmetItems, owned, snap));
   farmPool.sort((a, b) => compareQuestDroppers(a, b, state.char.level) || a.ce - b.ce);
-  if (farmPool[0]) return { kind: 'fight', creatureEntry: farmPool[0].ce };
+  const farmPick = pickQuestDropper(farmPool, state.char.level, salt);
+  if (farmPick) return { kind: 'fight', creatureEntry: farmPick.ce };
   for (const it of unmetItems) {
     const fight = pickFightable(ds, state, creatureDroppersForItem(ds, it.item, snap, state.char.level), skip);
     if (fight != null) return { kind: 'fight', creatureEntry: fight };
@@ -1055,13 +1071,14 @@ function dungeonOnlyWork(
 }
 
 // Farm entries for one item, ordered the way fightStep picks: noise floor first, then compareQuestDroppers,
-// so the travel hop names the mob the fight will actually open on.
+// then the salted pick moved to the front, so the travel hop names the mob the fight will actually open on.
 function rankFarmForItem(
   ds: DataStore,
   farm: readonly number[],
   itemId: number,
   snap: ConditionSnapshot,
   playerLevel: number,
+  salt: number,
 ): number[] {
   const scored: { ce: number; chance: number; level: number; rank: number }[] = [];
   const floor = dropperNoiseFloor(ds, itemId, snap);
@@ -1079,7 +1096,8 @@ function rankFarmForItem(
   const drops = scored.filter((s) => s.chance > 0);
   const pool = drops.length > 0 ? drops : scored;
   pool.sort((a, b) => compareQuestDroppers(a, b, playerLevel) || a.ce - b.ce);
-  return pool.map((s) => s.ce);
+  const first = pickQuestDropper(pool, playerLevel, salt);
+  return first ? [first.ce, ...pool.filter((s) => s !== first).map((s) => s.ce)] : [];
 }
 
 function farmTravelStep(
@@ -1108,7 +1126,7 @@ function farmTravelStep(
     if (countItem(ownedOf(state), it.item) >= it.count) continue;
     if (isProvidedItem(def, it.item)) continue;
     const ces = (def.farm ?? []).length
-      ? rankFarmForItem(ds, def.farm ?? [], it.item, snap, state.char.level)
+      ? rankFarmForItem(ds, def.farm ?? [], it.item, snap, state.char.level, dropperPickSalt(state))
       : creatureDroppersForItem(ds, it.item, snap, state.char.level);
     for (const ce of ces) {
       if (opts?.skipCreatures?.has(ce)) continue;