azeroth-shell 0.0.0-stage → 0.1.0

package/src/domain/bots/autoConsumables.ts

@@ -0,0 +1,285 @@
+// Out-of-combat auto-consumables — player-picked food, drink and buff items that regenTick re-uses,
+// mirroring pet autoFeed. Food and drink fire on low vitals, buffs when the aura is missing.
+import type { DataStore } from '../../data/dataStore.ts';
+import type { ItemDef } from '../../data/schema.ts';
+import type { Character } from '../character/character.ts';
+import { getActiveBuffIds, maxHealth, maxPower, powerType } from '../character/character.ts';
+import type { Inventory } from '../items/inventory.ts';
+import { countItem } from '../items/inventory.ts';
+
+/** HP/mana fraction at or below which auto food/drink fires. */
+export const AUTO_CONSUMABLE_VITAL_THRESHOLD = 0.7;
+
+export type AutoConsumableKind = 'food' | 'drink' | 'buff' | 'heal' | 'other';
+
+export interface AutoConsumablePrefs {
+  /** Food item entry — auto when HP ≤ threshold. */
+  food?: number;
+  /** Drink item entry — auto when mana ≤ threshold (mana users only). */
+  drink?: number;
+  /** Buff consumables (elixirs/scrolls/flasks) — auto when aura/mod missing. */
+  buffs?: number[];
+}
+
+export function emptyAutoConsumables(): AutoConsumablePrefs {
+  return {};
+}
+
+export function normalizeAutoConsumables(raw: unknown): AutoConsumablePrefs | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const r = raw as Record<string, unknown>;
+  const out: AutoConsumablePrefs = {};
+  if (typeof r.food === 'number' && r.food > 0) out.food = r.food;
+  if (typeof r.drink === 'number' && r.drink > 0) out.drink = r.drink;
+  if (Array.isArray(r.buffs)) {
+    const buffs = r.buffs.filter((x): x is number => typeof x === 'number' && x > 0);
+    if (buffs.length) out.buffs = [...new Set(buffs)];
+  }
+  return out.food != null || out.drink != null || (out.buffs && out.buffs.length)
+    ? out
+    : undefined;
+}
+
+/** Classify a bag item for the auto-consumable picker. */
+export function classifyConsumable(it: ItemDef, char: Character): AutoConsumableKind | null {
+  // Only a real consumable qualifies. "Recipe: Elixir of Fortitude" matched the elixir heuristic
+  // below, so the picker ate the book. Cite: item_template.class 0 ITEM_CLASS_CONSUMABLE.
+  if (it.itemClass !== 0 && it.consumable == null && it.useBuff == null) return null;
+  if (it.consumable?.effect === 'food') return 'food';
+  if (it.consumable?.effect === 'drink') return 'drink';
+  // useSpell restore paths often bake food/drink without consumable{}
+  if (it.useSpell != null && !it.useBuff && !it.useInCombat && it.consumable) {
+    return it.consumable.effect;
+  }
+  if (it.useBuff) return 'buff';
+  if (it.useInCombat?.effect === 'restore_health') return 'heal';
+  if (it.useInCombat?.effect === 'restore_power') return 'drink';
+  // useSpell-only: buff / restore / heal — treat buff-like as buff for auto
+  if (it.useSpell != null) {
+    // Food/drink named items with useSpell only
+    const n = (it.name ?? '').toLowerCase();
+    if (/\b(food|bread|meat|cheese|fish|steak|rib|haunch|sausage|pie|cake|muffin|apple)\b/.test(n)
+      || it.foodType != null) {
+      return 'food';
+    }
+    if (/\b(water|juice|milk|tea|refreshing|sweet nectar|moonberry|melon juice)\b/.test(n)) {
+      return 'drink';
+    }
+    if (/\b(elixir|flask|scroll|potion of|oil of|juju)\b/.test(n)) return 'buff';
+    if (/\bpotion\b/.test(n)) return 'heal';
+    // Unrecognised on-use is NOT a buff. Defaulting to one auto-fired 2,575 items nothing asked
+    // for: 1,571 recipes, mounts, armour kits, and quest items (4941 Glue, 4945 Skull).
+    return null;
+  }
+  if (char && it.slot) return null; // equippable gear is not a bag consumable for this panel
+  return null;
+}
+
+/** True when this item is a reasonable auto-use candidate from bags. */
+export function isAutoConsumableCandidate(it: ItemDef, char: Character): boolean {
+  if (char.level < (it.requiredLevel || 1)) return false;
+  // Quest-provided items are never auto-consumables. The useSpell fallthrough classifies any
+  // unrecognised on-use item as a buff, which pulled the Taming the Beast rods into the picker.
+  if (it.questItem) return false;
+  const kind = classifyConsumable(it, char);
+  if (!kind || kind === 'other') return false;
+  if (kind === 'drink' && powerType(char) !== 'mana') return false;
+  // Combat-only heal pots are still useful OOC; allow them as heal.
+  return true;
+}
+
+// Whether the character already has the buff this consumable would apply. Matches by useSpell aura id, or
+// by useBuff.mod when no spell id is present.
+export function hasMatchingConsumableBuff(
+  char: Character,
+  it: ItemDef,
+  ds: DataStore,
+  now = Date.now(),
+): boolean {
+  const active = new Set(getActiveBuffIds(char, now, ds));
+  const useSp = it.useSpell;
+  if (useSp != null && useSp > 0 && active.has(useSp)) return true;
+
+  // Pure useBuff without useSpell: match by effect mod on any active spell that grants it,
+  // or treat as present when any aura is a "consumable-shaped" match is unavailable — use mod scan.
+  const mod = it.useBuff?.mod;
+  if (mod) {
+    for (const id of active) {
+      const sp = ds.spell(id);
+      if (!sp) continue;
+      for (const e of sp.effects ?? []) {
+        if (e.kind === 'buff' && (e as { mod?: string }).mod === mod) return true;
+      }
+    }
+    // useBuff with pseudo-aura id 0 may not land in getActiveBuffIds the same way;
+    // also check activeAuras for spellId 0 + recent consume (rare). Skip false positive.
+  }
+  return false;
+}
+
+export function needsAutoFood(char: Character, ds: DataStore): boolean {
+  const max = maxHealth(char, ds);
+  if (max <= 0) return false;
+  return char.health / max <= AUTO_CONSUMABLE_VITAL_THRESHOLD;
+}
+
+export function needsAutoDrink(char: Character, ds: DataStore): boolean {
+  if (powerType(char) !== 'mana') return false;
+  const max = maxPower(char, ds);
+  if (max <= 0) return false;
+  return char.power / max <= AUTO_CONSUMABLE_VITAL_THRESHOLD;
+}
+
+export type AutoConsumeAction =
+  | { kind: 'food' | 'drink' | 'heal'; entry: number }
+  | { kind: 'buff'; entry: number };
+
+// Decide which auto-consumable to use this tick (at most one). Priority: food (if low HP) → drink (if low
+// mana) → first missing buff.
+export function pickAutoConsume(
+  char: Character,
+  inv: Inventory,
+  ds: DataStore,
+  prefs: AutoConsumablePrefs | undefined,
+  now = Date.now(),
+): AutoConsumeAction | null {
+  if (!prefs) return null;
+
+  if (prefs.food != null && needsAutoFood(char, ds) && countItem(inv, prefs.food) > 0) {
+    const it = ds.item(prefs.food);
+    if (it && isAutoConsumableCandidate(it, char)) {
+      return { kind: 'food', entry: prefs.food };
+    }
+  }
+
+  if (prefs.drink != null && needsAutoDrink(char, ds) && countItem(inv, prefs.drink) > 0) {
+    const it = ds.item(prefs.drink);
+    if (it && isAutoConsumableCandidate(it, char)) {
+      return { kind: 'drink', entry: prefs.drink };
+    }
+  }
+
+  for (const entry of prefs.buffs ?? []) {
+    if (countItem(inv, entry) <= 0) continue;
+    const it = ds.item(entry);
+    if (!it || !isAutoConsumableCandidate(it, char)) continue;
+    const kind = classifyConsumable(it, char);
+    if (kind === 'heal') {
+      if (needsAutoFood(char, ds)) return { kind: 'heal', entry };
+      continue;
+    }
+    if (kind === 'buff' || kind === 'other') {
+      if (!hasMatchingConsumableBuff(char, it, ds, now)) {
+        return { kind: 'buff', entry };
+      }
+    }
+  }
+  return null;
+}
+
+/** Inventory rows eligible for the auto-consumable picker. */
+export function listAutoConsumableOptions(
+  char: Character,
+  inv: Inventory,
+  ds: DataStore,
+): { entry: number; count: number; kind: AutoConsumableKind; item: ItemDef }[] {
+  const counts = new Map<number, number>();
+  for (const s of inv.stacks) {
+    counts.set(s.item, (counts.get(s.item) ?? 0) + s.count);
+  }
+  const out: { entry: number; count: number; kind: AutoConsumableKind; item: ItemDef }[] = [];
+  for (const [entry, count] of counts) {
+    const item = ds.item(entry);
+    if (!item) continue;
+    if (!isAutoConsumableCandidate(item, char)) continue;
+    const kind = classifyConsumable(item, char);
+    if (!kind) continue;
+    out.push({ entry, count, kind, item });
+  }
+  return out.sort((a, b) =>
+    a.kind.localeCompare(b.kind)
+    || (b.item.itemLevel ?? 0) - (a.item.itemLevel ?? 0)
+    || a.item.name.localeCompare(b.item.name));
+}
+
+export function isAutoFood(prefs: AutoConsumablePrefs | undefined, entry: number): boolean {
+  return prefs?.food === entry;
+}
+export function isAutoDrink(prefs: AutoConsumablePrefs | undefined, entry: number): boolean {
+  return prefs?.drink === entry;
+}
+export function isAutoBuff(prefs: AutoConsumablePrefs | undefined, entry: number): boolean {
+  return !!prefs?.buffs?.includes(entry);
+}
+
+// Prefs entries with no row in `listAutoConsumableOptions` — the item left the bags or stopped
+// being eligible. Rendering them is what gives a stuck pref a way off. Undefined item = not baked.
+export function staleAutoConsumables(
+  prefs: AutoConsumablePrefs | undefined,
+  char: Character,
+  inv: Inventory,
+  ds: DataStore,
+): { entry: number; slot: 'food' | 'drink' | 'buff'; item?: ItemDef }[] {
+  if (!prefs) return [];
+  const live = new Set(listAutoConsumableOptions(char, inv, ds).map((o) => o.entry));
+  const out: { entry: number; slot: 'food' | 'drink' | 'buff'; item?: ItemDef }[] = [];
+  const add = (entry: number, slot: 'food' | 'drink' | 'buff'): void => {
+    if (live.has(entry)) return;
+    out.push({ entry, slot, ...(ds.item(entry) ? { item: ds.item(entry)! } : {}) });
+  };
+  if (prefs.food != null) add(prefs.food, 'food');
+  if (prefs.drink != null) add(prefs.drink, 'drink');
+  for (const e of prefs.buffs ?? []) add(e, 'buff');
+  return out;
+}
+
+// Remove an entry from every slot, whatever it was set as. `toggleAutoConsumable` needs a `kind`
+// from the live item def, which fails exactly when clearing matters most.
+export function clearAutoConsumable(
+  prefs: AutoConsumablePrefs | undefined,
+  entry: number,
+): AutoConsumablePrefs | undefined {
+  if (!prefs) return undefined;
+  const cur: AutoConsumablePrefs = { ...prefs };
+  if (cur.food === entry) delete cur.food;
+  if (cur.drink === entry) delete cur.drink;
+  if (cur.buffs) {
+    const buffs = cur.buffs.filter((e) => e !== entry);
+    if (buffs.length) cur.buffs = buffs;
+    else delete cur.buffs;
+  }
+  return normalizeAutoConsumables(cur);
+}
+
+/** Toggle food/drink (single slot) or buff list membership. Returns next prefs (or undefined if empty). */
+export function toggleAutoConsumable(
+  prefs: AutoConsumablePrefs | undefined,
+  entry: number,
+  kind: AutoConsumableKind,
+): AutoConsumablePrefs | undefined {
+  const cur = { ...(prefs ?? {}) };
+  if (kind === 'food' || kind === 'heal') {
+    // heal pots share the food slot when used as OOC top-up, but buffs stay separate
+    if (kind === 'heal') {
+      // heal pots go on buffs list so they re-use when low HP via pickAutoConsume
+      const set = new Set(cur.buffs ?? []);
+      if (set.has(entry)) set.delete(entry);
+      else set.add(entry);
+      cur.buffs = set.size ? [...set] : undefined;
+      if (!cur.buffs?.length) delete cur.buffs;
+    } else {
+      cur.food = cur.food === entry ? undefined : entry;
+      if (cur.food == null) delete cur.food;
+    }
+  } else if (kind === 'drink') {
+    cur.drink = cur.drink === entry ? undefined : entry;
+    if (cur.drink == null) delete cur.drink;
+  } else {
+    const set = new Set(cur.buffs ?? []);
+    if (set.has(entry)) set.delete(entry);
+    else set.add(entry);
+    cur.buffs = set.size ? [...set] : undefined;
+    if (!cur.buffs?.length) delete cur.buffs;
+  }
+  return normalizeAutoConsumables(cur);
+}

package/src/domain/bots/betweenPullRest.ts

@@ -0,0 +1,239 @@
+// Between-pull rest as a real OOC consume loop: eat and drink from bags, then plain spirit regen
+// for the remainder up to SQUAD_PACING.restTo. Never assigns vitals without consume() or regen().
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { ItemDef } from '../../data/schema.ts';
+import {
+  effectiveStats,
+  equippedStatBonuses,
+  maxHealth,
+  maxPower,
+  powerType,
+  type Character,
+} from '../character/character.ts';
+import {
+  isAutoConsumableCandidate,
+  listAutoConsumableOptions,
+  type AutoConsumablePrefs,
+} from './autoConsumables.ts';
+import { countItem, type Inventory } from '../items/inventory.ts';
+import { SQUAD_PACING, type SquadStrategy } from './squad.ts';
+import { downtimeToFullSec } from '../run/dungeonRun.ts';
+import { consume, healthRegenPercentMultiplier, regen } from '../../progression/rest.ts';
+import { healthRegenPerSec, updateManaRegen, TUNING } from '../../engine/combat/formulas.ts';
+import { petMaxHealth } from '../pet/pet.ts';
+import { isPlayerAlive, type DeathFlowState } from '../run/death.ts';
+
+export interface BetweenPullRestResult {
+  char: Character;
+  inventory: Inventory;
+  /** Modeled downtime seconds for scoring (consumable channel + leftover regen). */
+  seconds: number;
+  /** True when HP was below rest target and no food was available. */
+  outOfFood: boolean;
+  /** True when mana was below rest target and no water/drink was available. */
+  outOfWater: boolean;
+  /** Feed lines (e.g. "Out of food/water", "Ate Freshly Baked Bread"). */
+  messages: string[];
+  ateEntry?: number;
+  drankEntry?: number;
+}
+
+/** Channel duration in whole seconds for a food/drink item (0 when unknown). */
+export function consumableChannelSec(it: ItemDef | undefined, ds: DataStore): number {
+  if (!it) return 0;
+  if (it.consumable?.durationMs != null && it.consumable.durationMs > 0) {
+    return Math.ceil(it.consumable.durationMs / 1000);
+  }
+  if (it.useSpell != null) {
+    const sp = ds.spell(it.useSpell);
+    for (const e of sp?.effects ?? []) {
+      if (
+        (e.kind === 'restore_health' || e.kind === 'restore_power')
+        && typeof (e as { durationMs?: number }).durationMs === 'number'
+      ) {
+        const d = (e as { durationMs: number }).durationMs;
+        if (d > 0) return Math.ceil(d / 1000);
+      }
+    }
+  }
+  return 0;
+}
+
+/** Prefer auto-consumable food pref, else first bag food. */
+export const pickFoodEntry = (
+  char: Character,
+  inv: Inventory,
+  ds: DataStore,
+  prefs: AutoConsumablePrefs | undefined,
+): number | undefined => {
+  if (prefs?.food != null && countItem(inv, prefs.food) > 0) {
+    const it = ds.item(prefs.food);
+    if (it && isAutoConsumableCandidate(it, char)) return prefs.food;
+  }
+  const opt = listAutoConsumableOptions(char, inv, ds).find((o) => o.kind === 'food');
+  return opt?.entry;
+};
+
+/** Prefer auto-consumable drink pref, else first bag drink (mana users only). */
+export const pickDrinkEntry = (
+  char: Character,
+  inv: Inventory,
+  ds: DataStore,
+  prefs: AutoConsumablePrefs | undefined,
+): number | undefined => {
+  if (powerType(char) !== 'mana') return undefined;
+  if (prefs?.drink != null && countItem(inv, prefs.drink) > 0) {
+    const it = ds.item(prefs.drink);
+    if (it && isAutoConsumableCandidate(it, char)) return prefs.drink;
+  }
+  const opt = listAutoConsumableOptions(char, inv, ds).find((o) => o.kind === 'drink');
+  return opt?.entry;
+};
+
+// Run one between-pull rest: consume food/water when carried, then OOC regen for any remaining deficit up
+// to SQUAD_PACING[strategy].restTo. Pure inputs → new char/inventory; no free vitals snap.
+export function betweenPullConsumeLoop(args: {
+  char: Character;
+  inventory: Inventory;
+  ds: DataStore;
+  strategy?: SquadStrategy | null;
+  /** Ghost/corpse gate — HP-only misses BuildPlayerRepop SetHealth(1). */
+  deathFlow?: Pick<DeathFlowState, 'deathState'> | null;
+}): BetweenPullRestResult {
+  const ds = args.ds;
+  const deathFlow = args.deathFlow;
+  // Unknown / corrupt strategy keys fall back to careful — never throw mid-run (KI-687).
+  const strategyKey = args.strategy ?? 'careful';
+  const pacing = SQUAD_PACING[strategyKey as SquadStrategy] ?? SQUAD_PACING.careful;
+  const restTo = pacing.restTo;
+  let char: Character = { ...args.char };
+  let inventory: Inventory = args.inventory;
+  const prefs = char.autoConsumables;
+  const messages: string[] = [];
+  let ateEntry: number | undefined;
+  let drankEntry: number | undefined;
+  let outOfFood = false;
+  let outOfWater = false;
+  let channelSec = 0;
+
+  // Dead/ghost stays dead through between-pull rest (KI-948). Cite: Player.cpp:1515–1519 IsAlive;
+  // ghost HP=1 (Player.cpp:4288 BuildPlayerRepop) needs deathFlow, not health alone.
+  if (!isPlayerAlive(char.health, deathFlow)) {
+    return {
+      char,
+      inventory,
+      seconds: 0,
+      outOfFood: false,
+      outOfWater: false,
+      messages,
+    };
+  }
+
+  const mh = maxHealth(char, ds);
+  const mp = maxPower(char, ds);
+  const pt = powerType(char);
+  const hpTarget = Math.ceil(mh * restTo);
+  const powerTarget = pt === 'rage' ? 0 : Math.ceil(mp * restTo);
+
+  // --- Food (HP) ------------------------------------------------------------
+  if (char.health < hpTarget) {
+    const entry = pickFoodEntry(char, inventory, ds, prefs);
+    if (entry != null) {
+      const res = consume(char, inventory, ds, entry, deathFlow);
+      if (res.ok) {
+        char = res.char;
+        inventory = res.inventory;
+        ateEntry = entry;
+        const it = ds.item(entry);
+        channelSec = Math.max(channelSec, consumableChannelSec(it, ds));
+        messages.push(`Ate ${it?.name ?? `item ${entry}`}${res.restored > 0 ? ` (+${res.restored} HP)` : ''}`);
+      } else {
+        outOfFood = true;
+      }
+    } else {
+      outOfFood = true;
+    }
+  }
+
+  // --- Drink (mana) ---------------------------------------------------------
+  if (pt === 'mana' && char.power < powerTarget) {
+    const entry = pickDrinkEntry(char, inventory, ds, prefs);
+    if (entry != null) {
+      const res = consume(char, inventory, ds, entry, deathFlow);
+      if (res.ok) {
+        char = res.char;
+        inventory = res.inventory;
+        drankEntry = entry;
+        const it = ds.item(entry);
+        channelSec = Math.max(channelSec, consumableChannelSec(it, ds));
+        messages.push(`Drank ${it?.name ?? `item ${entry}`}${res.restored > 0 ? ` (+${res.restored} mana)` : ''}`);
+      } else {
+        outOfWater = true;
+      }
+    } else {
+      outOfWater = true;
+    }
+  }
+
+  if (outOfFood || outOfWater) {
+    const parts: string[] = [];
+    if (outOfFood && char.health < hpTarget) parts.push('food');
+    if (outOfWater && pt === 'mana' && char.power < powerTarget) parts.push('water');
+    if (parts.length) messages.push(`Out of ${parts.join('/')}`);
+  }
+
+  // --- Remaining deficit: plain OOC regen (never free-snap) -----------------
+  const spi = effectiveStats(char, ds).spi;
+  const mp5 = equippedStatBonuses(char, ds).mp5 ?? 0;
+  // OOC: spirit × MOD_HEALTH_REGEN_PERCENT (88) × sit. Cite: Player.cpp:2392-2398.
+  const hpPerSec = healthRegenPerSec(spi, char.level, char.cls)
+    * healthRegenPercentMultiplier(char, ds) * TUNING.sitRegenMult;
+  const manaPerSec = pt === 'mana' ? updateManaRegen(char.cls, spi, mp5, 0).modManaRegen : 0;
+  const energyPerSec = pt === 'energy' ? TUNING.energyPerSec : 0;
+
+  const missingHp = Math.max(0, hpTarget - char.health);
+  const missingMana = pt === 'mana' ? Math.max(0, powerTarget - char.power) : 0;
+  const missingEnergy = pt === 'energy' ? Math.max(0, powerTarget - char.power) : 0;
+
+  const regenSec = downtimeToFullSec({
+    missingHp,
+    hpPerSec,
+    ...(pt === 'mana' ? { missingMana, manaPerSec } : {}),
+    ...(pt === 'energy' ? { missingEnergy, energyPerSec } : {}),
+  });
+
+  if (regenSec > 0) {
+    char = regen(char, ds, regenSec, true /* sitting */, deathFlow);
+    // Cap at the rest target so careful/aggressive/sip land on the dial — regen can overshoot from
+    // rounding toward full. Only clamp down; never snap up past what regen produced.
+    if (char.health > hpTarget) char = { ...char, health: hpTarget };
+    if (pt !== 'rage' && char.power > powerTarget) char = { ...char, power: powerTarget };
+  } else if (pt === 'rage' && char.power > 0) {
+    // Rage empties on rest (Player.cpp OOC rage decay); regen() handles it when
+    // seconds > 0 — force a decay tick when already at rest target with leftover rage.
+    char = regen(char, ds, 1, true, deathFlow);
+  }
+
+  // Pet: OOC regen toward full (regen() already tops pet HP/power when seconds > 0). When no regen time was
+  // needed for the player but pet is hurt, apply a short sit tick so the pet is not free-snapped either.
+  if (char.pet && char.pet.health > 0 && ds.creature(char.pet.creature)) {
+    const pmh = petMaxHealth(char, ds);
+    if (char.pet.health < pmh && regenSec <= 0 && channelSec <= 0) {
+      char = regen(char, ds, 1, true, deathFlow);
+    }
+  }
+
+  const seconds = Math.max(channelSec, regenSec);
+
+  return {
+    char,
+    inventory,
+    seconds,
+    outOfFood,
+    outOfWater,
+    messages,
+    ...(ateEntry != null ? { ateEntry } : {}),
+    ...(drankEntry != null ? { drankEntry } : {}),
+  };
+}