700 lines
30 KiB
TypeScript
700 lines
30 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { readFile } from "node:fs/promises";
|
|
import { gunzipSync, strFromU8 } from "fflate";
|
|
import { describe, expect, it } from "vitest";
|
|
import {
|
|
createDungeonEncounterSnapshot,
|
|
reduceDungeonEncounter,
|
|
resetDungeonEncounterSnapshot,
|
|
validateDungeonEncounterDefinition,
|
|
} from "./dungeonEncounterRuntime";
|
|
import type {
|
|
DungeonEncounterAction,
|
|
DungeonEncounterDefinition,
|
|
DungeonEncounterGuard,
|
|
DungeonEncounterSnapshot,
|
|
DungeonEncounterTrigger,
|
|
} from "./dungeonEncounterTypes";
|
|
import type { DungeonBossObjective, DungeonDefinition } from "./dungeonTypes";
|
|
import { validateDungeonWorldObject } from "./dungeonWorldObjects";
|
|
import compressedCampaign from "./generated/dungeonCampaignCatalog.compressed";
|
|
import {
|
|
WOW_WRATH_ENCOUNTER_BATCH_TWO_REVIEWS,
|
|
withWowWrathEncounterBatchTwoContent,
|
|
} from "./wowWrathEncounterBatchTwoCatalog";
|
|
|
|
const TARGETS = [
|
|
"halls-of-stone",
|
|
"pit-of-saron",
|
|
"utgarde-pinnacle",
|
|
"gundrak",
|
|
] as const;
|
|
|
|
type TargetId = typeof TARGETS[number];
|
|
|
|
const REVIEWED_TEMPLATES: Readonly<Record<TargetId, readonly number[]>> = Object.freeze({
|
|
"halls-of-stone": [193_907, 193_906, 191_296],
|
|
"pit-of-saron": [201_885, 201_848],
|
|
"utgarde-pinnacle": [191_745, 188_593, 192_173, 192_174],
|
|
gundrak: [
|
|
192_518, 192_519, 192_520,
|
|
192_564, 192_565, 192_567, 192_566,
|
|
193_188, 192_633, 192_632, 192_569,
|
|
192_568, 193_208, 193_209,
|
|
],
|
|
});
|
|
|
|
const EVENT_BOSS_NAMES: Readonly<Record<TargetId, readonly string[]>> = Object.freeze({
|
|
"halls-of-stone": ["Tribunal of Ages"],
|
|
"pit-of-saron": ["Tyrannus"],
|
|
"utgarde-pinnacle": ["Svala", "Gortok", "Skadi"],
|
|
gundrak: ["Eck"],
|
|
});
|
|
|
|
const FINAL_BOSS_NAME: Readonly<Record<TargetId, string>> = Object.freeze({
|
|
"halls-of-stone": "Sjonnir",
|
|
"pit-of-saron": "Tyrannus",
|
|
"utgarde-pinnacle": "Ymiron",
|
|
gundrak: "Gal'darah",
|
|
});
|
|
|
|
const EXPECTED_NONFINAL_CHECKPOINTS: Readonly<Record<TargetId, number>> = Object.freeze({
|
|
"halls-of-stone": 3,
|
|
"pit-of-saron": 3,
|
|
"utgarde-pinnacle": 3,
|
|
gundrak: 4,
|
|
});
|
|
|
|
function decodeBase64(value: string): Uint8Array {
|
|
const decoded = atob(value);
|
|
const bytes = new Uint8Array(decoded.length);
|
|
for (let index = 0; index < decoded.length; index += 1) bytes[index] = decoded.charCodeAt(index);
|
|
return bytes;
|
|
}
|
|
|
|
const generatedDefinitions = (
|
|
JSON.parse(strFromU8(gunzipSync(decodeBase64(compressedCampaign)))) as {
|
|
readonly definitions: readonly DungeonDefinition[];
|
|
}
|
|
).definitions;
|
|
|
|
function sourceDefinition(id: TargetId): DungeonDefinition {
|
|
const source = generatedDefinitions.find((definition) => definition.id === id);
|
|
if (!source) throw new Error(`Missing generated dungeon ${id}`);
|
|
return source;
|
|
}
|
|
|
|
function adaptedDefinition(id: TargetId): DungeonDefinition {
|
|
return withWowWrathEncounterBatchTwoContent(sourceDefinition(id));
|
|
}
|
|
|
|
function adaptedEncounter(definition: DungeonDefinition): DungeonEncounterDefinition {
|
|
const encounter = definition.encounters?.find((candidate) => (
|
|
candidate.id === `${definition.id}:wrath-batch-two-instance`
|
|
));
|
|
if (!encounter) throw new Error(`Missing batch-two encounter for ${definition.id}`);
|
|
return encounter;
|
|
}
|
|
|
|
function normalized(value: string): string {
|
|
return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
|
|
}
|
|
|
|
function objective(definition: DungeonDefinition, nameFragment: string): DungeonBossObjective {
|
|
const fragment = normalized(nameFragment);
|
|
const value = definition.bosses.find((candidate) => normalized(candidate.name).includes(fragment));
|
|
if (!value) throw new Error(`${definition.id} is missing objective matching ${nameFragment}`);
|
|
return value;
|
|
}
|
|
|
|
function group(definition: DungeonDefinition, id: string) {
|
|
const value = definition.encounterSpawnGroups?.find((candidate) => candidate.id === id);
|
|
if (!value) throw new Error(`${definition.id} is missing encounter group ${id}`);
|
|
return value;
|
|
}
|
|
|
|
function runtimeSpawnIds(definition: DungeonDefinition): readonly string[] {
|
|
return [
|
|
...definition.staticSpawns.map((spawn) => spawn.id),
|
|
...definition.roamingPacks.flatMap((pack) => (
|
|
pack.members.map((member) => `${pack.id}:${member.id}`)
|
|
)),
|
|
...(definition.encounterSpawnGroups ?? []).flatMap((spawnGroup) => (
|
|
spawnGroup.spawns.map((spawn) => spawn.id)
|
|
)),
|
|
];
|
|
}
|
|
|
|
function activeSpawnIds(
|
|
definition: DungeonDefinition,
|
|
snapshot: DungeonEncounterSnapshot,
|
|
ignoredGroupIds: ReadonlySet<string> = new Set(),
|
|
): readonly string[] {
|
|
const active = new Set(snapshot.activeSpawnGroupIds);
|
|
return (definition.encounterSpawnGroups ?? [])
|
|
.filter((spawnGroup) => active.has(spawnGroup.id) && !ignoredGroupIds.has(spawnGroup.id))
|
|
.flatMap((spawnGroup) => spawnGroup.spawns.map((spawn) => spawn.id));
|
|
}
|
|
|
|
function killIds(
|
|
encounter: DungeonEncounterDefinition,
|
|
snapshot: DungeonEncounterSnapshot,
|
|
ids: readonly string[],
|
|
now: number,
|
|
): DungeonEncounterSnapshot {
|
|
return reduceDungeonEncounter(encounter, snapshot, {
|
|
kind: "tick",
|
|
now,
|
|
facts: { registeredEntityIds: ids, deadEntityIds: ids },
|
|
}).snapshot;
|
|
}
|
|
|
|
function interact(
|
|
encounter: DungeonEncounterDefinition,
|
|
snapshot: DungeonEncounterSnapshot,
|
|
objectId: string,
|
|
now: number,
|
|
): DungeonEncounterSnapshot {
|
|
return reduceDungeonEncounter(encounter, snapshot, { kind: "interact", objectId, now }).snapshot;
|
|
}
|
|
|
|
function incompleteObjective(
|
|
definition: DungeonDefinition,
|
|
snapshot: DungeonEncounterSnapshot,
|
|
names: readonly string[],
|
|
): DungeonBossObjective | undefined {
|
|
return names
|
|
.map((name) => objective(definition, name))
|
|
.find((candidate) => !snapshot.completedObjectiveIds.includes(candidate.id));
|
|
}
|
|
|
|
function advanceOneStep(
|
|
definition: DungeonDefinition,
|
|
encounter: DungeonEncounterDefinition,
|
|
snapshot: DungeonEncounterSnapshot,
|
|
now: number,
|
|
): DungeonEncounterSnapshot {
|
|
if (snapshot.phase === "resume") {
|
|
return reduceDungeonEncounter(encounter, snapshot, { kind: "tick", now }).snapshot;
|
|
}
|
|
|
|
if (definition.id === "halls-of-stone") {
|
|
if (snapshot.phase === "tribunal-ready") {
|
|
const remaining = incompleteObjective(definition, snapshot, ["Krystallus", "Maiden"]);
|
|
return remaining
|
|
? killIds(encounter, snapshot, [remaining.id], now)
|
|
: interact(encounter, snapshot, "halls-of-stone:reviewed-tribunal-console", now);
|
|
}
|
|
if (snapshot.phase === "sjonnir-ready") {
|
|
return killIds(encounter, snapshot, [objective(definition, "Sjonnir").id], now);
|
|
}
|
|
}
|
|
|
|
if (definition.id === "pit-of-saron") {
|
|
if (snapshot.phase === "progression") {
|
|
const remaining = incompleteObjective(definition, snapshot, ["Garfrost", "Ick"]);
|
|
return remaining
|
|
? killIds(encounter, snapshot, [remaining.id], now)
|
|
: reduceDungeonEncounter(encounter, snapshot, { kind: "tick", now }).snapshot;
|
|
}
|
|
if (snapshot.phase === "gauntlet-ready") {
|
|
return interact(encounter, snapshot, "pit-of-saron:gauntlet-start", now);
|
|
}
|
|
if (snapshot.phase === "tunnel-ready") {
|
|
return interact(encounter, snapshot, "pit-of-saron:tunnel-start", now);
|
|
}
|
|
}
|
|
|
|
if (definition.id === "utgarde-pinnacle") {
|
|
if (snapshot.phase === "svala-ready") {
|
|
return interact(encounter, snapshot, "utgarde-pinnacle:svala-start", now);
|
|
}
|
|
if (snapshot.phase === "svala-phase-one-active") {
|
|
return reduceDungeonEncounter(encounter, snapshot, {
|
|
kind: "entity-health",
|
|
entityId: "utgarde-pinnacle:svala-phase-one-actor",
|
|
healthPercent: 50,
|
|
now,
|
|
}).snapshot;
|
|
}
|
|
if (snapshot.phase === "gortok-ready") {
|
|
return interact(encounter, snapshot, "utgarde-pinnacle:reviewed-stasis-sphere", now);
|
|
}
|
|
if (snapshot.phase === "skadi-ready") {
|
|
return interact(encounter, snapshot, "utgarde-pinnacle:skadi-start", now);
|
|
}
|
|
const harpoonByPhase: Readonly<Record<string, string>> = {
|
|
"harpoon-one-ready": "utgarde-pinnacle:harpoon-1",
|
|
"harpoon-two-ready": "utgarde-pinnacle:harpoon-2",
|
|
"harpoon-three-ready": "utgarde-pinnacle:harpoon-3",
|
|
};
|
|
const harpoon = harpoonByPhase[snapshot.phase];
|
|
if (harpoon) return interact(encounter, snapshot, harpoon, now);
|
|
if (snapshot.phase === "ymiron-ready") {
|
|
return killIds(encounter, snapshot, [objective(definition, "Ymiron").id], now);
|
|
}
|
|
}
|
|
|
|
if (definition.id === "gundrak") {
|
|
if (snapshot.phase === "altar-progression") {
|
|
const remaining = incompleteObjective(
|
|
definition,
|
|
snapshot,
|
|
["Slad'ran", "Moorabi", "Drakkari Colossus"],
|
|
);
|
|
if (remaining) return killIds(encounter, snapshot, [remaining.id], now);
|
|
const altar = definition.serverGameObjects.find((object) => (
|
|
object.id.startsWith("gundrak:reviewed-altar-")
|
|
&& snapshot.worldObjectStates[object.id] === "ready"
|
|
));
|
|
return altar
|
|
? interact(encounter, snapshot, altar.id, now)
|
|
: reduceDungeonEncounter(encounter, snapshot, { kind: "tick", now }).snapshot;
|
|
}
|
|
if (snapshot.phase === "bridge-activating") {
|
|
return reduceDungeonEncounter(encounter, snapshot, {
|
|
kind: "tick",
|
|
now: Math.max(now, snapshot.phaseStartedAt + 5_000),
|
|
}).snapshot;
|
|
}
|
|
if (snapshot.phase === "gal-darah-ready") {
|
|
return killIds(encounter, snapshot, [objective(definition, "Gal'darah").id], now);
|
|
}
|
|
return reduceDungeonEncounter(encounter, snapshot, { kind: "tick", now }).snapshot;
|
|
}
|
|
|
|
const spawnIds = activeSpawnIds(definition, snapshot);
|
|
if (spawnIds.length) return killIds(encounter, snapshot, spawnIds, now);
|
|
return reduceDungeonEncounter(encounter, snapshot, { kind: "tick", now }).snapshot;
|
|
}
|
|
|
|
interface FinishedEncounter {
|
|
readonly snapshot: DungeonEncounterSnapshot;
|
|
readonly phases: readonly string[];
|
|
readonly checkpoints: readonly DungeonEncounterSnapshot[];
|
|
}
|
|
|
|
function finishEncounter(
|
|
definition: DungeonDefinition,
|
|
encounter: DungeonEncounterDefinition,
|
|
initial = createDungeonEncounterSnapshot(encounter),
|
|
): FinishedEncounter {
|
|
let snapshot = initial;
|
|
const phases = [snapshot.phase];
|
|
const checkpoints: DungeonEncounterSnapshot[] = [];
|
|
const seenCheckpoints = new Set<string>();
|
|
const finalObjectiveId = objective(definition, FINAL_BOSS_NAME[definition.id as TargetId]).id;
|
|
let now = snapshot.phaseStartedAt + 1;
|
|
for (let step = 0; step < 100 && snapshot.phase !== "complete"; step += 1) {
|
|
const previous = snapshot;
|
|
snapshot = advanceOneStep(definition, encounter, snapshot, now);
|
|
now = Math.max(now + 1, snapshot.phaseStartedAt + 1);
|
|
if (snapshot.phase !== phases.at(-1)) phases.push(snapshot.phase);
|
|
if (snapshot.checkpointId
|
|
&& snapshot.checkpointId !== finalObjectiveId
|
|
&& !seenCheckpoints.has(snapshot.checkpointId)) {
|
|
seenCheckpoints.add(snapshot.checkpointId);
|
|
checkpoints.push(snapshot);
|
|
}
|
|
if (snapshot === previous) throw new Error(`${definition.id} soft locked in ${snapshot.phase}`);
|
|
}
|
|
if (snapshot.phase !== "complete") throw new Error(`${definition.id} did not complete`);
|
|
return { snapshot, phases, checkpoints };
|
|
}
|
|
|
|
function expectOrderedPhases(phases: readonly string[], expected: readonly string[]): void {
|
|
let cursor = -1;
|
|
for (const phase of expected) {
|
|
cursor = phases.indexOf(phase, cursor + 1);
|
|
expect(cursor, `missing ordered phase ${phase}`).toBeGreaterThanOrEqual(0);
|
|
}
|
|
}
|
|
|
|
function expectTriggerReferences(
|
|
trigger: DungeonEncounterTrigger,
|
|
spawnIds: ReadonlySet<string>,
|
|
objectIds: ReadonlySet<string>,
|
|
): void {
|
|
if (trigger.kind === "entity-death" || trigger.kind === "entity-engaged" || trigger.kind === "entity-health") {
|
|
expect(spawnIds, `trigger entity ${trigger.entityId}`).toContain(trigger.entityId);
|
|
}
|
|
if (trigger.kind === "entities-dead") {
|
|
for (const entityId of trigger.entityIds) expect(spawnIds, `trigger entity ${entityId}`).toContain(entityId);
|
|
}
|
|
if (trigger.kind === "interact") expect(objectIds, `trigger object ${trigger.objectId}`).toContain(trigger.objectId);
|
|
}
|
|
|
|
function expectGuardReferences(
|
|
guard: DungeonEncounterGuard,
|
|
groupIds: ReadonlySet<string>,
|
|
objectIds: ReadonlySet<string>,
|
|
objectiveIds: ReadonlySet<string>,
|
|
): void {
|
|
if (guard.kind === "spawn-group-active") expect(groupIds).toContain(guard.spawnGroupId);
|
|
if (guard.kind === "world-object-state") expect(objectIds).toContain(guard.objectId);
|
|
if (guard.kind === "objective-complete") expect(objectiveIds).toContain(guard.objectiveId);
|
|
}
|
|
|
|
function expectActionReferences(
|
|
action: DungeonEncounterAction,
|
|
groupIds: ReadonlySet<string>,
|
|
objectsById: ReadonlyMap<string, DungeonDefinition["serverGameObjects"][number]>,
|
|
objectiveIds: ReadonlySet<string>,
|
|
): void {
|
|
if (action.kind === "activate-spawn-group" || action.kind === "deactivate-spawn-group") {
|
|
expect(groupIds, `action group ${action.spawnGroupId}`).toContain(action.spawnGroupId);
|
|
}
|
|
if (action.kind === "set-world-object-state") {
|
|
const object = objectsById.get(action.objectId);
|
|
expect(object, `action object ${action.objectId}`).toBeDefined();
|
|
expect(object?.states.map((state) => state.id), `${action.objectId}:${action.state}`)
|
|
.toContain(action.state);
|
|
}
|
|
if (action.kind === "complete-objective") expect(objectiveIds).toContain(action.objectiveId);
|
|
}
|
|
|
|
describe("source-reviewed Wrath encounter batch two", () => {
|
|
it("pins every reviewed AzerothCore source file by actual SHA-256 and line/symbol anchors", async () => {
|
|
expect(WOW_WRATH_ENCOUNTER_BATCH_TWO_REVIEWS.map((review) => review.dungeonId)).toEqual(TARGETS);
|
|
for (const review of WOW_WRATH_ENCOUNTER_BATCH_TWO_REVIEWS) {
|
|
expect(review.fidelity).toBe("source-backed-adapted");
|
|
expect(review.adaptations.length).toBeGreaterThan(0);
|
|
expect(review.remainingGaps.length).toBeGreaterThan(0);
|
|
for (const source of review.sourceFiles) {
|
|
expect(source.sha256).toMatch(/^[a-f0-9]{64}$/);
|
|
expect(source.anchors.length).toBeGreaterThan(0);
|
|
expect(source.anchors.every((anchor) => /lines? \d+/i.test(anchor))).toBe(true);
|
|
const digest = createHash("sha256").update(await readFile(source.path)).digest("hex");
|
|
expect(digest, source.path).toBe(source.sha256);
|
|
}
|
|
}
|
|
});
|
|
|
|
it("attaches idempotently with unique rows, valid references, and finite event groups", () => {
|
|
for (const id of TARGETS) {
|
|
const definition = adaptedDefinition(id);
|
|
const encounter = adaptedEncounter(definition);
|
|
expect(withWowWrathEncounterBatchTwoContent(definition)).toBe(definition);
|
|
expect(encounter.source).toMatchObject({
|
|
fidelity: "source-backed-adapted",
|
|
scope: "instance-orchestration",
|
|
});
|
|
validateDungeonEncounterDefinition(encounter);
|
|
|
|
const spawnIdList = runtimeSpawnIds(definition);
|
|
expect(new Set(spawnIdList).size, `${id} duplicate runtime spawn id`).toBe(spawnIdList.length);
|
|
const groupIdList = (definition.encounterSpawnGroups ?? []).map((spawnGroup) => spawnGroup.id);
|
|
expect(new Set(groupIdList).size, `${id} duplicate group id`).toBe(groupIdList.length);
|
|
const objectIdList = definition.serverGameObjects.map((object) => object.id);
|
|
expect(new Set(objectIdList).size, `${id} duplicate object id`).toBe(objectIdList.length);
|
|
const encounterIdList = (definition.encounters ?? []).map((candidate) => candidate.id);
|
|
expect(new Set(encounterIdList).size, `${id} duplicate encounter id`).toBe(encounterIdList.length);
|
|
const sourceSpawnIds = definition.serverGameObjects
|
|
.map((object) => object.source?.spawnId)
|
|
.filter((spawnId): spawnId is number => spawnId !== undefined);
|
|
expect(new Set(sourceSpawnIds).size, `${id} duplicate source gameobject row`).toBe(sourceSpawnIds.length);
|
|
|
|
const spawnIds = new Set(spawnIdList);
|
|
const groupIds = new Set(groupIdList);
|
|
const objectIds = new Set(objectIdList);
|
|
const objectsById = new Map(definition.serverGameObjects.map((object) => [object.id, object] as const));
|
|
const objectiveIds = new Set(definition.bosses.map((boss) => boss.id));
|
|
for (const spawnGroup of definition.encounterSpawnGroups ?? []) {
|
|
for (const spawn of spawnGroup.spawns) {
|
|
expect(definition.entities[spawn.entityId], `${spawnGroup.id}:${spawn.id}`).toBeDefined();
|
|
}
|
|
}
|
|
for (const object of definition.serverGameObjects) validateDungeonWorldObject(object);
|
|
for (const rule of encounter.rules) {
|
|
expectTriggerReferences(rule.trigger, spawnIds, objectIds);
|
|
for (const guard of rule.guards ?? []) {
|
|
expectGuardReferences(guard, groupIds, objectIds, objectiveIds);
|
|
}
|
|
for (const action of rule.actions) {
|
|
expectActionReferences(action, groupIds, objectsById, objectiveIds);
|
|
}
|
|
}
|
|
|
|
const batchGroups = (definition.encounterSpawnGroups ?? [])
|
|
.filter((spawnGroup) => spawnGroup.id.startsWith(`${id}:`));
|
|
for (const spawnGroup of batchGroups) {
|
|
const completion = encounter.rules.find((rule) => (
|
|
rule.trigger.kind === "entities-dead"
|
|
&& rule.trigger.entityIds.length === spawnGroup.spawns.length
|
|
&& rule.trigger.entityIds.every((spawnId) => spawnGroup.spawns.some((spawn) => spawn.id === spawnId))
|
|
));
|
|
const isHealthGatedSvala = spawnGroup.id === "utgarde-pinnacle:svala-phase-one";
|
|
expect(Boolean(completion) || isHealthGatedSvala, `${id} finite completion for ${spawnGroup.id}`).toBe(true);
|
|
if (completion?.trigger.kind === "entities-dead") {
|
|
expect(completion.trigger.timeoutMs, `${id} timeout for ${spawnGroup.id}`).toBeGreaterThan(0);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
it("replaces each reviewed imported object by spawnId without dropping or duplicating source rows", () => {
|
|
for (const id of TARGETS) {
|
|
const source = sourceDefinition(id);
|
|
const definition = adaptedDefinition(id);
|
|
const sourceRowIds = source.serverGameObjects
|
|
.map((object) => object.source?.spawnId)
|
|
.filter((spawnId): spawnId is number => spawnId !== undefined)
|
|
.sort((left, right) => left - right);
|
|
const adaptedRowIds = definition.serverGameObjects
|
|
.map((object) => object.source?.spawnId)
|
|
.filter((spawnId): spawnId is number => spawnId !== undefined)
|
|
.sort((left, right) => left - right);
|
|
expect(adaptedRowIds, `${id} source-row inventory`).toEqual(sourceRowIds);
|
|
|
|
for (const templateId of REVIEWED_TEMPLATES[id]) {
|
|
const originalRows = source.serverGameObjects.filter((object) => object.source?.templateId === templateId);
|
|
expect(originalRows, `${id} template ${templateId}`).toHaveLength(1);
|
|
const original = originalRows[0];
|
|
expect(original.source?.spawnId).toEqual(expect.any(Number));
|
|
const replacements = definition.serverGameObjects.filter((object) => (
|
|
object.source?.spawnId === original.source?.spawnId
|
|
));
|
|
expect(replacements, `${id} spawn ${original.source?.spawnId}`).toHaveLength(1);
|
|
const replacement = replacements[0];
|
|
expect(replacement.id).not.toBe(original.id);
|
|
expect(replacement.id).toContain(":reviewed-");
|
|
expect(replacement.position).toEqual(original.position);
|
|
expect(replacement.halfExtents).toEqual(original.halfExtents);
|
|
expect(replacement.yaw).toEqual(original.yaw);
|
|
expect(replacement.visual?.hidden).not.toBe(true);
|
|
expect(replacement.source?.fidelity).toBe("source-backed-adapted");
|
|
}
|
|
}
|
|
|
|
expect(adaptedDefinition("halls-of-stone").serverGameObjects
|
|
.find((object) => object.id === "halls-of-stone:reviewed-tribunal-console")?.interaction)
|
|
.toBeDefined();
|
|
expect(adaptedDefinition("utgarde-pinnacle").serverGameObjects
|
|
.find((object) => object.id === "utgarde-pinnacle:reviewed-stasis-sphere")?.interaction)
|
|
.toBeDefined();
|
|
expect(adaptedDefinition("gundrak").serverGameObjects
|
|
.filter((object) => object.id.startsWith("gundrak:reviewed-altar-")).every((object) => object.interaction))
|
|
.toBe(true);
|
|
});
|
|
|
|
it("suppresses only source-gated event objectives and preserves exact finite cardinalities", () => {
|
|
for (const id of TARGETS) {
|
|
const definition = adaptedDefinition(id);
|
|
const staticIds = new Set(definition.staticSpawns.map((spawn) => spawn.id));
|
|
for (const name of EVENT_BOSS_NAMES[id]) {
|
|
const eventBoss = objective(definition, name);
|
|
expect(eventBoss.eventOnly, `${id}:${eventBoss.name}`).toBe(true);
|
|
expect(staticIds, `${id}:${eventBoss.name}`).not.toContain(eventBoss.id);
|
|
}
|
|
}
|
|
|
|
const halls = adaptedDefinition("halls-of-stone");
|
|
expect([
|
|
group(halls, "halls-of-stone:tribunal-protectors").spawns.length,
|
|
group(halls, "halls-of-stone:tribunal-stormcallers").spawns.length,
|
|
group(halls, "halls-of-stone:tribunal-custodian").spawns.length,
|
|
]).toEqual([3, 2, 1]);
|
|
expect(incompleteObjective(halls, createDungeonEncounterSnapshot(adaptedEncounter(halls)), ["Krystallus", "Maiden"]))
|
|
.toBeDefined();
|
|
|
|
const pit = adaptedDefinition("pit-of-saron");
|
|
expect(group(pit, "pit-of-saron:first-ambush").spawns).toHaveLength(10);
|
|
expect(group(pit, "pit-of-saron:second-ambush-normal").spawns).toHaveLength(6);
|
|
expect(group(pit, "pit-of-saron:tyrannus").spawns).toHaveLength(1);
|
|
expect(pit.staticSpawns.map((spawn) => spawn.id)).toEqual(expect.arrayContaining([
|
|
objective(pit, "Garfrost").id,
|
|
objective(pit, "Ick").id,
|
|
]));
|
|
|
|
const pinnacle = adaptedDefinition("utgarde-pinnacle");
|
|
expect(group(pinnacle, "utgarde-pinnacle:svala-ritual-channelers").spawns).toHaveLength(3);
|
|
expect(group(pinnacle, "utgarde-pinnacle:skadi-first-wave").spawns).toHaveLength(13);
|
|
expect(group(pinnacle, "utgarde-pinnacle:skadi-reinforcement-one").spawns).toHaveLength(3);
|
|
expect(group(pinnacle, "utgarde-pinnacle:skadi-reinforcement-two").spawns).toHaveLength(3);
|
|
expect(pinnacle.staticSpawns.map((spawn) => spawn.id)).toContain(objective(pinnacle, "Ymiron").id);
|
|
|
|
const gundrak = adaptedDefinition("gundrak");
|
|
expect(group(gundrak, "gundrak:eck").spawns).toHaveLength(1);
|
|
expect(group(gundrak, "gundrak:eck").spawns[0].spawnMask).toBe(2);
|
|
expect(objective(gundrak, "Eck").optional).toBe(true);
|
|
expect(gundrak.staticSpawns.map((spawn) => spawn.id)).toEqual(expect.arrayContaining([
|
|
objective(gundrak, "Slad'ran").id,
|
|
objective(gundrak, "Moorabi").id,
|
|
objective(gundrak, "Drakkari Colossus").id,
|
|
objective(gundrak, "Gal'darah").id,
|
|
]));
|
|
});
|
|
|
|
it("keeps Eck's source cadence without turning setup and Berserk spells into repeat damage", () => {
|
|
const gundrak = adaptedDefinition("gundrak");
|
|
const eck = Object.values(gundrak.entities).find((entity) => entity.combat?.serverEntry === 29_932);
|
|
expect(eck?.name).toBe("Eck the Ferocious");
|
|
expect(eck?.visual.model).toMatchObject({ groundOffset: 0, labelHeight: 7 });
|
|
const attacks = new Map(eck?.combat?.attacks.map((attack) => [attack.spellId ?? 0, attack]));
|
|
expect(attacks.get(55_813)).toMatchObject({
|
|
name: "Eck Bite", target: "primary", initialCooldownMs: [5_000, 5_000],
|
|
repeatCooldownMs: [8_000, 12_000], damageMultiplier: 1.35,
|
|
});
|
|
expect(attacks.get(55_814)).toMatchObject({
|
|
name: "Eck Spit", target: "primary", initialCooldownMs: [10_000, 37_000],
|
|
repeatCooldownMs: [8_000, 12_000], damageMultiplier: 1.35,
|
|
});
|
|
expect(attacks.get(55_815)).toMatchObject({
|
|
name: "Eck Spring", target: "random-party", initialCooldownMs: [10_000, 24_000],
|
|
repeatCooldownMs: [10_000, 24_000], damageMultiplier: 1.35,
|
|
telegraph: { shape: "circle", anchor: "target", warningMs: 750 },
|
|
});
|
|
expect(attacks.get(55_837)).toMatchObject({ target: "self", maximumCasts: 1, damageMultiplier: 0 });
|
|
expect(attacks.get(55_816)).toMatchObject({
|
|
target: "self", initialCooldownMs: [90_000, 90_000], maximumCasts: 1,
|
|
damageMultiplier: 0, effect: { kind: "aura", aura: "enrage" },
|
|
});
|
|
});
|
|
|
|
it("runs every required lifecycle through its reviewed gates and completes without renderer state", () => {
|
|
const halls = adaptedDefinition("halls-of-stone");
|
|
const hallsRun = finishEncounter(halls, adaptedEncounter(halls));
|
|
expectOrderedPhases(hallsRun.phases, [
|
|
"tribunal-protectors-active",
|
|
"tribunal-stormcallers-active",
|
|
"tribunal-custodian-active",
|
|
"sjonnir-ready",
|
|
"complete",
|
|
]);
|
|
expect(hallsRun.snapshot.worldObjectStates["halls-of-stone:reviewed-sjonnir-door"]).toBe("open");
|
|
|
|
const pit = adaptedDefinition("pit-of-saron");
|
|
const pitRun = finishEncounter(pit, adaptedEncounter(pit));
|
|
expectOrderedPhases(pitRun.phases, [
|
|
"gauntlet-ready",
|
|
"first-ambush-active",
|
|
"second-ambush-active",
|
|
"tunnel-ready",
|
|
"tyrannus-active",
|
|
"complete",
|
|
]);
|
|
expect(pitRun.snapshot.flags["gauntlet-complete"]).toBe(true);
|
|
expect(pitRun.snapshot.worldObjectStates["pit-of-saron:reviewed-portcullis"]).toBe("open");
|
|
|
|
const pinnacle = adaptedDefinition("utgarde-pinnacle");
|
|
const pinnacleRun = finishEncounter(pinnacle, adaptedEncounter(pinnacle));
|
|
expectOrderedPhases(pinnacleRun.phases, [
|
|
"svala-phase-one-active",
|
|
"svala-ritual-active",
|
|
"svala-phase-two-active",
|
|
"gortok-ready",
|
|
"stasis-worgen-active",
|
|
"stasis-furbolg-active",
|
|
"gortok-active",
|
|
"skadi-ready",
|
|
"skadi-first-wave-active",
|
|
"harpoon-one-ready",
|
|
"skadi-reinforcement-one-active",
|
|
"harpoon-two-ready",
|
|
"skadi-reinforcement-two-active",
|
|
"harpoon-three-ready",
|
|
"skadi-ground-active",
|
|
"ymiron-ready",
|
|
"complete",
|
|
]);
|
|
expect(pinnacleRun.snapshot.counters["harpoon-hits"]).toBe(3);
|
|
expect(pinnacleRun.snapshot.worldObjectStates["utgarde-pinnacle:reviewed-ymiron-door"]).toBe("open");
|
|
|
|
const gundrak = adaptedDefinition("gundrak");
|
|
const gundrakRun = finishEncounter(gundrak, adaptedEncounter(gundrak));
|
|
expectOrderedPhases(gundrakRun.phases, [
|
|
"altar-progression",
|
|
"bridge-activating",
|
|
"gal-darah-ready",
|
|
"complete",
|
|
]);
|
|
expect(gundrakRun.snapshot.counters["keys-in"]).toBe(3);
|
|
expect(gundrakRun.snapshot.flags["bridge-open"]).toBe(true);
|
|
expect(gundrakRun.snapshot.worldObjectStates["gundrak:reviewed-bridge"]).toBe("open");
|
|
expect(gundrakRun.snapshot.completedObjectiveIds).not.toContain(objective(gundrak, "Eck").id);
|
|
expect(gundrakRun.snapshot.activeSpawnGroupIds).toContain("gundrak:eck");
|
|
|
|
for (const [definition, result] of [
|
|
[halls, hallsRun],
|
|
[pit, pitRun],
|
|
[pinnacle, pinnacleRun],
|
|
[gundrak, gundrakRun],
|
|
] as const) {
|
|
expect(result.snapshot.flags["dungeon-complete"], definition.id).toBe(true);
|
|
expect(result.snapshot.completedObjectiveIds, definition.id).toEqual(expect.arrayContaining(
|
|
definition.bosses.filter((boss) => !boss.optional).map((boss) => boss.id),
|
|
));
|
|
}
|
|
});
|
|
|
|
it("recovers from both wipe scopes at every nonfinal checkpoint, including optional Eck", () => {
|
|
for (const id of TARGETS) {
|
|
const definition = adaptedDefinition(id);
|
|
const encounter = adaptedEncounter(definition);
|
|
const run = finishEncounter(definition, encounter);
|
|
expect(run.checkpoints, id).toHaveLength(EXPECTED_NONFINAL_CHECKPOINTS[id]);
|
|
for (const checkpoint of run.checkpoints) {
|
|
for (const scope of ["boss-wipe", "checkpoint"] as const) {
|
|
const reset = resetDungeonEncounterSnapshot(
|
|
encounter,
|
|
checkpoint,
|
|
scope,
|
|
checkpoint.phaseStartedAt + 10_000,
|
|
);
|
|
expect(reset.phase, `${id}:${checkpoint.checkpointId}:${scope}`).toBe("resume");
|
|
expect(reset.activeSpawnGroupIds).toEqual([]);
|
|
expect(reset.completedObjectiveIds).toEqual(checkpoint.completedObjectiveIds);
|
|
expect(reset.checkpointId).toBe(checkpoint.checkpointId);
|
|
expect(finishEncounter(definition, encounter, reset).snapshot.flags["dungeon-complete"]).toBe(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
const gundrak = adaptedDefinition("gundrak");
|
|
const encounter = adaptedEncounter(gundrak);
|
|
let eckCheckpoint = killIds(
|
|
encounter,
|
|
createDungeonEncounterSnapshot(encounter),
|
|
[objective(gundrak, "Moorabi").id],
|
|
1,
|
|
);
|
|
eckCheckpoint = killIds(
|
|
encounter,
|
|
eckCheckpoint,
|
|
group(gundrak, "gundrak:eck").spawns.map((spawn) => spawn.id),
|
|
2,
|
|
);
|
|
expect(eckCheckpoint.checkpointId).toBe(objective(gundrak, "Eck").id);
|
|
for (const scope of ["boss-wipe", "checkpoint"] as const) {
|
|
const reset = resetDungeonEncounterSnapshot(encounter, eckCheckpoint, scope, 3);
|
|
expect(reset.completedObjectiveIds).toContain(objective(gundrak, "Eck").id);
|
|
expect(finishEncounter(gundrak, encounter, reset).snapshot.flags["dungeon-complete"]).toBe(true);
|
|
}
|
|
});
|
|
|
|
it("keeps completion order-safe when a static final boss is reported dead before its event gate", () => {
|
|
for (const id of ["halls-of-stone", "utgarde-pinnacle", "gundrak"] as const) {
|
|
const definition = adaptedDefinition(id);
|
|
const encounter = adaptedEncounter(definition);
|
|
const finalBoss = objective(definition, FINAL_BOSS_NAME[id]);
|
|
const premature = killIds(encounter, createDungeonEncounterSnapshot(encounter), [finalBoss.id], 1);
|
|
expect(premature.flags["dungeon-complete"], id).toBe(false);
|
|
const completed = finishEncounter(definition, encounter, premature).snapshot;
|
|
expect(completed.flags["dungeon-complete"], id).toBe(true);
|
|
if (id === "gundrak") expect(completed.flags["bridge-open"]).toBe(true);
|
|
}
|
|
|
|
const pit = adaptedDefinition("pit-of-saron");
|
|
const pitEncounter = adaptedEncounter(pit);
|
|
const tyrannusGroup = group(pit, "pit-of-saron:tyrannus");
|
|
const prematureTyrannus = killIds(
|
|
pitEncounter,
|
|
createDungeonEncounterSnapshot(pitEncounter),
|
|
tyrannusGroup.spawns.map((spawn) => spawn.id),
|
|
1,
|
|
);
|
|
expect(prematureTyrannus.completedObjectiveIds).not.toContain(objective(pit, "Tyrannus").id);
|
|
expect(prematureTyrannus.phase).toBe("progression");
|
|
});
|
|
});
|