azeroth-shell 0.0.0-stage → 0.1.1

package/src/domain/quests/talkDeliver.ts

@@ -0,0 +1,170 @@
+// QI5 talk and deliver class: predicate credit with no id lists. Empty-trackable talk, empty flag-2
+// event-talk and item-deliver complete via Speak, a same-zone arrival, or a GO-ender interact.
+import type { QuestDef } from '../../data/schema.ts';
+import type { Inventory } from '../items/inventory.ts';
+import {
+  accept,
+  emptyQuestLog,
+  getQuest,
+  hasGoEnder,
+  isDeliverQuest,
+  isEventTalkQuest,
+  isTalkToNpcQuest,
+  itemsMet,
+  questComplete,
+  recordGoEnderInteract,
+  recordSameZoneTalkOrDeliver,
+  recordTalkToNpc,
+  talkMet,
+  type QuestLog,
+} from './questlog.ts';
+
+export type TalkDeliverKind = 'talk' | 'eventTalk' | 'deliver';
+
+export function talkDeliverKind(quest: QuestDef): TalkDeliverKind | null {
+  if (isTalkToNpcQuest(quest)) return 'talk';
+  if (isEventTalkQuest(quest)) return 'eventTalk';
+  if (isDeliverQuest(quest)) return 'deliver';
+  return null;
+}
+
+/** Ender identity only (deliver must not credit the starter). */
+export function npcMatchesDeliverEnder(
+  quest: QuestDef,
+  opts: { npcName?: string; creatureEntry?: number },
+  creatureNameOf?: (entry: number) => string | undefined,
+): boolean {
+  const ender = (quest.enderName ?? '').trim();
+  if (opts.npcName && ender && opts.npcName.trim() === ender) return true;
+  const entry = opts.creatureEntry;
+  if (entry != null && (quest.enderCreatureEntries ?? []).includes(entry)) return true;
+  if (entry != null && creatureNameOf) {
+    const cn = (creatureNameOf(entry) ?? '').trim();
+    if (cn && ender && cn === ender) return true;
+  }
+  return false;
+}
+
+// TalkedToCreature for DELIVER: speaking to the ender with the items in bags sets `talked`.
+// GO enders stay on recordGoEnderInteract. Cite: Player.cpp TalkedToCreature :13603.
+export function recordDeliverTalk(
+  log: QuestLog,
+  questOf: (entry: number) => QuestDef | undefined,
+  opts: { npcName?: string; creatureEntry?: number },
+  inv: Inventory,
+  creatureNameOf?: (entry: number) => string | undefined,
+): QuestLog {
+  let touched = false;
+  const quests = log.quests.map((q) => {
+    if (q.status === 'turnedIn' || q.talked) return q;
+    const quest = questOf(q.entry);
+    if (!quest || !isDeliverQuest(quest) || hasGoEnder(quest)) return q;
+    if (!itemsMet(quest, inv)) return q;
+    if (!npcMatchesDeliverEnder(quest, opts, creatureNameOf)) return q;
+    touched = true;
+    return { ...q, talked: true };
+  });
+  return touched ? { quests } : log;
+}
+
+export type TalkDeliverPath = 'speak' | 'zone' | 'go';
+
+export interface TalkDeliverSatisfy {
+  ok: boolean;
+  kind: TalkDeliverKind;
+  path?: TalkDeliverPath;
+}
+
+// True when some class path (Speak / same-zone / GO) makes questComplete true. `standingFor` is required
+// for interpreter rep-objective rows (Player.cpp:12288).
+export function canSatisfyTalkDeliver(
+  quest: QuestDef,
+  inv: Inventory,
+  opts?: {
+    standingFor?: (factionId: number) => number;
+    goNameOf?: (entry: number) => string | undefined;
+  },
+): TalkDeliverSatisfy {
+  const kind = talkDeliverKind(quest);
+  if (!kind) return { ok: true, kind: 'talk' };
+  const standingFor = opts?.standingFor ?? (() => 999999);
+  const name = (quest.enderName || quest.starterName || '').trim();
+
+  if (hasGoEnder(quest)) {
+    const go = quest.goEnder || (quest.goEnderEntries ?? []).find((e) => e > 0) || 0;
+    let log = accept(emptyQuestLog(), quest);
+    log = recordGoEnderInteract(log, go, (e) => (e === quest.entry ? quest : undefined), inv, {
+      goName: opts?.goNameOf?.(go),
+    });
+    const st = getQuest(log, quest.entry);
+    if (st && questComplete(quest, st, inv, { standingFor })) {
+      return { ok: true, kind, path: 'go' };
+    }
+  }
+
+  if (name) {
+    let log = accept(emptyQuestLog(), quest);
+    log = recordTalkToNpc(log, (e) => (e === quest.entry ? quest : undefined), { npcName: name });
+    if (kind === 'deliver') {
+      log = recordDeliverTalk(log, (e) => (e === quest.entry ? quest : undefined), { npcName: name }, inv);
+    }
+    const st = getQuest(log, quest.entry);
+    if (st && questComplete(quest, st, inv, { standingFor })) {
+      return { ok: true, kind, path: 'speak' };
+    }
+  }
+
+  const zones = quest.enderZones ?? [];
+  if (zones.length > 0 && !hasGoEnder(quest)) {
+    let log = accept(emptyQuestLog(), quest);
+    log = recordSameZoneTalkOrDeliver(log, zones[0]!, (e) => (e === quest.entry ? quest : undefined), inv);
+    const st = getQuest(log, quest.entry);
+    if (st && (questComplete(quest, st, inv, { standingFor }) || talkMet(st, quest) || st.explored)) {
+      if (st && questComplete(quest, st, inv, { standingFor })) {
+        return { ok: true, kind, path: 'zone' };
+      }
+    }
+  }
+
+  // Deliver with no enderZones: talkMet is vacuously true (cannot soft-lock). Items + interpreter.
+  if (kind === 'deliver' && zones.length === 0 && !hasGoEnder(quest)) {
+    const log = accept(emptyQuestLog(), quest);
+    const st = getQuest(log, quest.entry);
+    if (st && questComplete(quest, st, inv, { standingFor })) {
+      return { ok: true, kind, path: 'speak' };
+    }
+  }
+
+  return { ok: false, kind };
+}
+
+export interface TalkDeliverCensus {
+  talk: number;
+  eventTalk: number;
+  deliver: number;
+  remaining: number;
+  dead: Array<{ entry: number; title: string; kind: TalkDeliverKind }>;
+}
+
+export function censusTalkDeliver(
+  quests: readonly QuestDef[],
+  invFor: (quest: QuestDef) => Inventory,
+  opts?: { goNameOf?: (entry: number) => string | undefined },
+): TalkDeliverCensus {
+  const out: TalkDeliverCensus = { talk: 0, eventTalk: 0, deliver: 0, remaining: 0, dead: [] };
+  for (const q of quests) {
+    const kind = talkDeliverKind(q);
+    if (!kind) continue;
+    if (kind === 'talk') out.talk++;
+    else if (kind === 'eventTalk') out.eventTalk++;
+    else out.deliver++;
+    // The 897-class gate is talk + eventTalk. Deliver uses items+zone (QI2.5) / GO (qofid).
+    if (kind === 'deliver') continue;
+    const sat = canSatisfyTalkDeliver(q, invFor(q), opts);
+    if (!sat.ok) {
+      out.remaining++;
+      if (out.dead.length < 40) out.dead.push({ entry: q.entry, title: q.title, kind });
+    }
+  }
+  return out;
+}

package/src/domain/raid/globalActionBar.ts

@@ -0,0 +1,195 @@
+// Raid action bar: one empty-by-default bar whose slots every living raid member at least tries.
+// Keys stay unbound and a single Settings keybind fires the whole bar. Cite: actionbar.ts.
+
+import type { ItemDef } from '../../data/schema.ts';
+import {
+  SLOTS_PER_BAR,
+  slotAt,
+  emptyItems,
+  emptyMacros,
+  emptyOutfits,
+  type ActionBar,
+  type SlotContent,
+} from '../character/actionbar.ts';
+import { countItem, type Inventory } from '../items/inventory.ts';
+import { classHasParallelMana } from '../character/forms.ts';
+import { classPowerType } from '../core/ids.ts';
+
+export type GlobalItemKind = 'restore_health' | 'restore_power' | 'buff' | 'other';
+
+/** Per-member snapshot the try-gate reads. Built by the game module from bags / the live session. */
+export interface GlobalMemberSnap {
+  alive: boolean;
+  classId: number;
+  health: number;
+  maxHealth: number;
+  power: number;
+  maxPower: number;
+  itemCount: number;
+  canUse: boolean;
+  hasOutfit: boolean;
+}
+
+function outfitNameAt(v: unknown): string | null {
+  return typeof v === 'string' && v.trim() ? v.trim() : null;
+}
+
+/** Empty raid bar. No default spells, items, outfits, or keys. */
+export function emptyGlobalBar(): ActionBar {
+  return {
+    slots: Array(SLOTS_PER_BAR).fill(null),
+    keys: Array(SLOTS_PER_BAR).fill(null),
+    items: emptyItems(),
+    macros: emptyMacros(),
+    outfits: emptyOutfits(),
+  };
+}
+
+/** Load/migrate: keep items + outfits, drop spells/macros/keys (this bar has one global bind). */
+export function normalizeGlobalBar(bar: unknown): ActionBar {
+  if (!bar || typeof bar !== 'object') return emptyGlobalBar();
+  const b = bar as { items?: unknown; outfits?: unknown };
+  const items = Array.isArray(b.items) ? b.items : [];
+  const outfits = Array.isArray(b.outfits) ? b.outfits : [];
+  return {
+    slots: Array(SLOTS_PER_BAR).fill(null),
+    keys: Array(SLOTS_PER_BAR).fill(null),
+    items: Array.from({ length: SLOTS_PER_BAR }, (_, i) => {
+      const v = items[i];
+      return typeof v === 'number' ? v : null;
+    }),
+    macros: emptyMacros(),
+    outfits: Array.from({ length: SLOTS_PER_BAR }, (_, i) => outfitNameAt(outfits[i])),
+  };
+}
+
+export function globalBarHasContent(bar: ActionBar | undefined | null): boolean {
+  const b = normalizeGlobalBar(bar);
+  for (let i = 0; i < SLOTS_PER_BAR; i++) if (slotAt(b, i) != null) return true;
+  return false;
+}
+
+/** Opt-in dock: a bound key or any filled slot. Neither → the combat dock stays blank. */
+export function showGlobalActionBar(
+  bar: ActionBar | undefined | null,
+  keybind: string | null | undefined,
+): boolean {
+  if (globalBarHasContent(bar)) return true;
+  return typeof keybind === 'string' && keybind.trim().length > 0;
+}
+
+export function firstEmptyGlobalSlot(bar: ActionBar | undefined | null): number | null {
+  const b = normalizeGlobalBar(bar);
+  for (let i = 0; i < SLOTS_PER_BAR; i++) if (slotAt(b, i) == null) return i;
+  return null;
+}
+
+export function setGlobalBarItem(
+  bar: ActionBar | undefined | null,
+  slot: number,
+  entry: number | null,
+): ActionBar {
+  const next = normalizeGlobalBar(bar);
+  if (slot < 0 || slot >= SLOTS_PER_BAR) return next;
+  if (entry != null) {
+    for (let i = 0; i < SLOTS_PER_BAR; i++) if (next.items![i] === entry) next.items![i] = null;
+    next.outfits![slot] = null;
+  }
+  next.items![slot] = entry;
+  return next;
+}
+
+export function setGlobalBarOutfit(
+  bar: ActionBar | undefined | null,
+  slot: number,
+  name: string | null,
+): ActionBar {
+  const next = normalizeGlobalBar(bar);
+  if (slot < 0 || slot >= SLOTS_PER_BAR) return next;
+  const trimmed = name && name.trim() ? name.trim() : null;
+  if (trimmed) {
+    const low = trimmed.toLowerCase();
+    for (let i = 0; i < SLOTS_PER_BAR; i++) {
+      if (next.outfits![i]?.toLowerCase() === low) next.outfits![i] = null;
+    }
+    next.items![slot] = null;
+  }
+  next.outfits![slot] = trimmed;
+  return next;
+}
+
+export function clearGlobalBarSlot(bar: ActionBar | undefined | null, slot: number): ActionBar {
+  const next = normalizeGlobalBar(bar);
+  if (slot < 0 || slot >= SLOTS_PER_BAR) return next;
+  next.items![slot] = null;
+  next.outfits![slot] = null;
+  return next;
+}
+
+export function globalItemKind(it: Pick<ItemDef, 'useInCombat' | 'useBuff'> | undefined): GlobalItemKind | null {
+  if (!it) return null;
+  const fx = it.useInCombat?.effect;
+  if (fx === 'restore_health' || fx === 'restore_power') return fx;
+  if (it.useBuff) return 'buff';
+  return 'other';
+}
+
+export function classUsesMana(classId: number): boolean {
+  return classPowerType(classId) === 'mana' || classHasParallelMana(classId);
+}
+
+// Whether this member should attempt the slot. Count 0 is "do not have it"; give flasks only to the people
+// who should drink them.
+export function shouldTryGlobalAction(
+  content: SlotContent,
+  member: GlobalMemberSnap,
+  kind: GlobalItemKind | null,
+): boolean {
+  if (!content || !member.alive) return false;
+  if (content.kind === 'outfit') return member.hasOutfit;
+  if (content.kind !== 'item') return false;
+  if (member.itemCount <= 0) return false;
+  if (!member.canUse) return false;
+  if (kind === 'restore_power' && !classUsesMana(member.classId)) return false;
+  if (kind === 'restore_health') {
+    if (member.maxHealth <= 0) return false;
+    if (member.health / member.maxHealth >= 0.99) return false;
+  }
+  if (kind === 'restore_power') {
+    if (member.maxPower <= 0) return false;
+    if (member.power / member.maxPower >= 0.99) return false;
+  }
+  return true;
+}
+
+/** The engine's own accept gate (game/globalActionBar.ts setGlobalItemSlot): an on-use consumable. */
+export function isGlobalBarItem(
+  it: Pick<ItemDef, 'useInCombat' | 'useBuff' | 'useSpell'> | undefined,
+): boolean {
+  return !!it && !!(it.useInCombat || it.useBuff || it.useSpell != null);
+}
+
+export interface GlobalBarCandidate {
+  entry: number;
+  count: number;
+}
+
+// Every on-use consumable the raid is carrying, held-count first. This is the list a player picks from; it
+// runs the same gate `setGlobalItemSlot` does so it can never offer a row the engine then silently refuses.
+export function globalBarCandidates(
+  bags: readonly (Inventory | undefined | null)[],
+  lookup: (entry: number) => Pick<ItemDef, 'useInCombat' | 'useBuff' | 'useSpell'> | undefined,
+): GlobalBarCandidate[] {
+  const seen = new Set<number>();
+  for (const inv of bags) {
+    if (!inv) continue;
+    for (const st of inv.stacks) if (isGlobalBarItem(lookup(st.item))) seen.add(st.item);
+  }
+  const out: GlobalBarCandidate[] = [];
+  for (const entry of seen) {
+    let count = 0;
+    for (const inv of bags) if (inv) count += countItem(inv, entry);
+    if (count > 0) out.push({ entry, count });
+  }
+  return out.sort((a, b) => (b.count - a.count) || (a.entry - b.entry));
+}

package/src/domain/raid/instanceRoster.ts

@@ -0,0 +1,194 @@
+// Who walks into an instance from the companions you own. The raid template is a recipe of class
+// and role seats, not a second roster: this matches those seats against the squad and bench.
+
+import { CLASS } from '../../data/schema.ts';
+import {
+  ensureClassSeat,
+  instanceWantsWaterMage,
+  raidRoleQuota,
+  type RaidSeat,
+} from './raidComp.ts';
+import { maxCompanionsFor, type SquadRole } from '../bots/squad.ts';
+
+export interface RosterPickBody {
+  id: string;
+  cls: number;
+  role: SquadRole;
+  level: number;
+}
+
+/** 5-man is 1 tank / 1 healer / rest dps. Larger sizes use the raid quota. */
+export function instanceRoleQuota(size: number): { tanks: number; healers: number; dps: number } {
+  const n = Math.max(1, Math.floor(size));
+  if (n <= 5) {
+    const tanks = Math.min(1, n);
+    const healers = Math.min(1, Math.max(0, n - tanks));
+    return { tanks, healers, dps: Math.max(0, n - tanks - healers) };
+  }
+  return raidRoleQuota(n);
+}
+
+function better(a: RosterPickBody, b: RosterPickBody): boolean {
+  return a.level !== b.level ? a.level > b.level : a.id.localeCompare(b.id) < 0;
+}
+
+function takeBest(
+  pool: readonly RosterPickBody[],
+  taken: ReadonlySet<string>,
+  pred: (c: RosterPickBody) => boolean,
+): RosterPickBody | undefined {
+  let best: RosterPickBody | undefined;
+  for (const c of pool) {
+    if (taken.has(c.id) || !pred(c)) continue;
+    if (!best || better(c, best)) best = c;
+  }
+  return best;
+}
+
+function seatsFromQuota(
+  quota: { tanks: number; healers: number; dps: number },
+  playerRole: SquadRole,
+): RaidSeat[] {
+  const want = {
+    tanks: quota.tanks,
+    healers: quota.healers,
+    dps: quota.dps,
+  };
+  if (playerRole === 'tank') want.tanks = Math.max(0, want.tanks - 1);
+  else if (playerRole === 'healer') want.healers = Math.max(0, want.healers - 1);
+  else want.dps = Math.max(0, want.dps - 1);
+  const out: RaidSeat[] = [];
+  for (let i = 0; i < want.tanks; i++) out.push({ cls: 0, role: 'tank' });
+  for (let i = 0; i < want.healers; i++) out.push({ cls: 0, role: 'healer' });
+  for (let i = 0; i < want.dps; i++) out.push({ cls: 0, role: 'dps' });
+  return out;
+}
+
+function swapInClass(
+  ids: string[],
+  owned: readonly RosterPickBody[],
+  cls: number,
+  cap: number,
+): string[] {
+  if (ids.some((id) => owned.find((c) => c.id === id)?.cls === cls)) return ids;
+  const mage = takeBest(owned, new Set(ids), (c) => c.cls === cls);
+  if (!mage) return ids;
+  if (ids.length < cap) return [...ids, mage.id];
+  const byId = new Map(owned.map((c) => [c.id, c]));
+  // Drop the lowest-level DPS who is not that class.
+  let worst = -1;
+  let worstLevel = Infinity;
+  for (let i = ids.length - 1; i >= 0; i--) {
+    const c = byId.get(ids[i]!);
+    if (!c || c.role !== 'dps' || c.cls === cls) continue;
+    if (c.level <= worstLevel) {
+      worst = i;
+      worstLevel = c.level;
+    }
+  }
+  if (worst < 0) return ids;
+  const out = ids.slice();
+  out[worst] = mage.id;
+  return out;
+}
+
+// Pick up to `cap` owned companions. With the raid template, match class and role, then class,
+// then role; without it, a role quota. UBRS still swaps a DPS for an owned mage.
+export function fillOwnedInstanceRoster(args: {
+  dungeonId: string;
+  /** Companion seats — instance maxPlayers minus the player. */
+  cap: number;
+  owned: readonly RosterPickBody[];
+  playerCls: number;
+  playerRole: SquadRole;
+  /** Template companion seats. Empty/omitted → role quota. */
+  seats?: readonly RaidSeat[] | null;
+}): string[] {
+  const cap = Math.max(0, Math.floor(args.cap));
+  if (cap <= 0 || !args.owned.length) return [];
+  const wantMage = instanceWantsWaterMage(args.dungeonId);
+  let seats: RaidSeat[] = args.seats && args.seats.length
+    ? [...args.seats]
+    : seatsFromQuota(instanceRoleQuota(cap + 1), args.playerRole);
+  if (wantMage) seats = ensureClassSeat(seats, CLASS.MAGE, args.playerCls);
+
+  const taken = new Set<string>();
+  const ids: string[] = [];
+  const take = (c: RosterPickBody | undefined): void => {
+    if (!c || taken.has(c.id) || ids.length >= cap) return;
+    taken.add(c.id);
+    ids.push(c.id);
+  };
+
+  for (const seat of seats) {
+    if (ids.length >= cap) break;
+    if (seat.cls > 0) {
+      take(
+        takeBest(args.owned, taken, (c) => c.cls === seat.cls && c.role === seat.role)
+        ?? takeBest(args.owned, taken, (c) => c.cls === seat.cls)
+        ?? takeBest(args.owned, taken, (c) => c.role === seat.role),
+      );
+    } else {
+      take(takeBest(args.owned, taken, (c) => c.role === seat.role));
+    }
+  }
+  while (ids.length < cap) {
+    const next = takeBest(args.owned, taken, () => true);
+    if (!next) break;
+    take(next);
+  }
+  if (wantMage && args.playerCls !== CLASS.MAGE) {
+    return swapInClass(ids, args.owned, CLASS.MAGE, cap);
+  }
+  return ids;
+}
+
+/** Cap and de-dupe a hand-edited lineup against the owned set. */
+export function clampRosterPicks(
+  ids: readonly string[],
+  ownedIds: ReadonlySet<string>,
+  cap: number,
+): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const id of ids) {
+    if (out.length >= cap) break;
+    if (!ownedIds.has(id) || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
+/** Player-count sizes a raid lineup can be built for. Companion seats = size − 1. */
+export const RAID_LINEUP_SIZES = [10, 20, 40] as const;
+export type RaidLineupSize = (typeof RAID_LINEUP_SIZES)[number];
+
+export function isRaidLineupSize(n: number): n is RaidLineupSize {
+  return (RAID_LINEUP_SIZES as readonly number[]).includes(n);
+}
+
+/** Companion seats for a 10/20/40-man raid lineup. Cite: squad.ts maxCompanionsFor. */
+export function raidLineupCap(size: number): number {
+  return maxCompanionsFor(size);
+}
+
+// Who walks in from owned companions: a per-dungeon door pick wins, else a raid-sized enter uses
+// the Companions-tab lineup. Null means auto — party for a 5-man, role quota for a raid.
+export function resolveOwnedLineup(args: {
+  dungeonId: string;
+  cap: number;
+  asRaid: boolean;
+  ownedIds: ReadonlySet<string>;
+  dungeonPicks?: { dungeonId: string; ids: readonly string[] } | null;
+  raidLineup?: { size: number; ids: readonly string[] } | null;
+}): string[] | null {
+  const dungeon = args.dungeonPicks;
+  if (dungeon && dungeon.dungeonId === args.dungeonId) {
+    return clampRosterPicks(dungeon.ids, args.ownedIds, args.cap);
+  }
+  if (args.asRaid && args.raidLineup) {
+    return clampRosterPicks(args.raidLineup.ids, args.ownedIds, args.cap);
+  }
+  return null;
+}