forked from phenom/healer-man
516 lines
30 KiB
TypeScript
516 lines
30 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { readFileSync } from "node:fs";
|
|
import { resolve } from "node:path";
|
|
import { gunzipSync, strFromU8 } from "fflate";
|
|
import { describe, expect, it } from "vitest";
|
|
import {
|
|
createDungeonEncounterSnapshot,
|
|
reduceDungeonEncounter,
|
|
resetDungeonEncounterSnapshot,
|
|
validateDungeonEncounterDefinition,
|
|
} from "./dungeonEncounterRuntime";
|
|
import type { DungeonDefinition, DungeonEncounterSpawnGroupDefinition } from "./dungeonTypes";
|
|
import type { DungeonEncounterDefinition, DungeonEncounterSnapshot } from "./dungeonEncounterTypes";
|
|
import { validateDungeonWorldObject } from "./dungeonWorldObjects";
|
|
import compressedCampaign from "./generated/dungeonCampaignCatalog.compressed";
|
|
import { withWowEncounterContent } from "./wowEncounterContentCatalog";
|
|
import {
|
|
WOW_CLASSIC_ENCOUNTER_BATCH_THREE_REVIEWS,
|
|
withWowClassicEncounterBatchThree,
|
|
} from "./wowClassicEncounterBatchThreeCatalog";
|
|
|
|
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 campaign = JSON.parse(strFromU8(gunzipSync(decodeBase64(compressedCampaign)))) as {
|
|
readonly definitions: readonly DungeonDefinition[];
|
|
};
|
|
|
|
function original(id: string): DungeonDefinition {
|
|
const definition = campaign.definitions.find((candidate) => candidate.id === id);
|
|
if (!definition) throw new Error(`Missing generated dungeon ${id}`);
|
|
return definition;
|
|
}
|
|
|
|
function preadapted(id: string): DungeonDefinition {
|
|
return withWowEncounterContent(original(id));
|
|
}
|
|
|
|
function adapted(id: string): DungeonDefinition {
|
|
return withWowClassicEncounterBatchThree(preadapted(id));
|
|
}
|
|
|
|
function encounter(definition: DungeonDefinition): DungeonEncounterDefinition {
|
|
const value = definition.encounters?.find((candidate) => candidate.id === `${definition.id}:classic-batch-three`);
|
|
if (!value) throw new Error(`Missing Classic batch-three encounter for ${definition.id}`);
|
|
return value;
|
|
}
|
|
|
|
function group(definition: DungeonDefinition, id: string): DungeonEncounterSpawnGroupDefinition {
|
|
const value = definition.encounterSpawnGroups?.find((candidate) => candidate.id === id);
|
|
if (!value) throw new Error(`Missing encounter group ${id}`);
|
|
return value;
|
|
}
|
|
|
|
function objectBySpawn(definition: DungeonDefinition, spawnId: number) {
|
|
const matches = definition.serverGameObjects.filter((object) => object.source?.spawnId === spawnId);
|
|
if (matches.length !== 1) throw new Error(`${definition.id} expected one source object ${spawnId}, found ${matches.length}`);
|
|
return matches[0];
|
|
}
|
|
|
|
function killGroup(
|
|
scripted: DungeonEncounterDefinition,
|
|
snapshot: DungeonEncounterSnapshot,
|
|
spawnGroup: DungeonEncounterSpawnGroupDefinition,
|
|
now: number,
|
|
): DungeonEncounterSnapshot {
|
|
const ids = spawnGroup.spawns.map((spawn) => spawn.id);
|
|
return reduceDungeonEncounter(scripted, snapshot, {
|
|
kind: "tick",
|
|
now,
|
|
facts: { registeredEntityIds: ids, deadEntityIds: ids },
|
|
}).snapshot;
|
|
}
|
|
|
|
function staticEntries(definition: DungeonDefinition): readonly number[] {
|
|
return definition.staticSpawns.flatMap((spawn) => {
|
|
const entry = definition.entities[spawn.entityId]?.combat?.serverEntry;
|
|
return entry === undefined ? [] : [entry];
|
|
});
|
|
}
|
|
|
|
describe("Classic source-backed encounter batch three", () => {
|
|
it("pins sources, validates references, suppresses event actors, remains idempotent, and preserves Solakar", () => {
|
|
const cases = [
|
|
["gnomeregan", [7_998]],
|
|
["dire-maul", [11_496]],
|
|
["blackrock-spire", [9_816, 10_316, 10_429, 10_264]],
|
|
] as const;
|
|
expect(WOW_CLASSIC_ENCOUNTER_BATCH_THREE_REVIEWS.map((review) => review.dungeonId))
|
|
.toEqual(cases.map(([id]) => id));
|
|
|
|
const checkedPaths = new Set<string>();
|
|
for (const review of WOW_CLASSIC_ENCOUNTER_BATCH_THREE_REVIEWS) {
|
|
expect(review.fidelity).toBe("source-backed-adapted");
|
|
expect(review.adaptations.length).toBeGreaterThan(0);
|
|
expect(review.remainingGaps.length).toBeGreaterThan(0);
|
|
for (const sourceFile of review.sourceFiles) {
|
|
expect(sourceFile.sha256).toMatch(/^[a-f0-9]{64}$/);
|
|
expect(sourceFile.anchors.length).toBeGreaterThan(0);
|
|
expect(sourceFile.anchors.every((anchor) => /lines? \d+/.test(anchor))).toBe(true);
|
|
if (!checkedPaths.has(sourceFile.path)) {
|
|
expect(createHash("sha256").update(readFileSync(resolve(sourceFile.path))).digest("hex"), sourceFile.path)
|
|
.toBe(sourceFile.sha256);
|
|
checkedPaths.add(sourceFile.path);
|
|
}
|
|
}
|
|
}
|
|
|
|
const priorBRS = preadapted("blackrock-spire");
|
|
const priorSolakarEncounter = priorBRS.encounters?.find((value) => value.id === "blackrock-spire:wow-instance");
|
|
const priorSolakarGroups = priorBRS.encounterSpawnGroups?.filter((value) => value.id.startsWith("blackrock-spire:solakar"));
|
|
const priorFatherFlame = priorBRS.serverGameObjects.find((value) => value.source?.templateId === 175_245);
|
|
expect(priorSolakarEncounter).toBeDefined();
|
|
expect(priorSolakarGroups).toHaveLength(6);
|
|
expect(priorFatherFlame).toBeDefined();
|
|
|
|
for (const [id, suppressed] of cases) {
|
|
const definition = adapted(id);
|
|
const scripted = encounter(definition);
|
|
validateDungeonEncounterDefinition(scripted);
|
|
expect(scripted.source?.scope).toBe("instance-orchestration");
|
|
expect(withWowClassicEncounterBatchThree(definition)).toBe(definition);
|
|
expect(staticEntries(definition)).not.toEqual(expect.arrayContaining([...suppressed]));
|
|
|
|
const spawnIds = new Set([
|
|
...definition.staticSpawns.map((spawn) => spawn.id),
|
|
...(definition.encounterSpawnGroups ?? []).flatMap((spawnGroup) => spawnGroup.spawns.map((spawn) => spawn.id)),
|
|
]);
|
|
const groupIds = new Set(definition.encounterSpawnGroups?.map((spawnGroup) => spawnGroup.id));
|
|
const objectIds = new Set(definition.serverGameObjects.map((object) => object.id));
|
|
const objectiveIds = new Set(definition.bosses.map((objective) => objective.id));
|
|
expect(objectIds.size).toBe(definition.serverGameObjects.length);
|
|
expect(groupIds.size).toBe(definition.encounterSpawnGroups?.length ?? 0);
|
|
const actionIds = new Set<string>();
|
|
for (const spawnGroup of definition.encounterSpawnGroups ?? []) {
|
|
for (const spawn of spawnGroup.spawns) expect(definition.entities[spawn.entityId], `${id}:${spawn.id}`).toBeDefined();
|
|
}
|
|
for (const rule of scripted.rules) {
|
|
if (rule.trigger.kind === "interact") expect(objectIds.has(rule.trigger.objectId), `${id}:${rule.id}`).toBe(true);
|
|
if (rule.trigger.kind === "entity-death" || rule.trigger.kind === "entity-engaged" || rule.trigger.kind === "entity-health") {
|
|
expect(spawnIds.has(rule.trigger.entityId), `${id}:${rule.id}:${rule.trigger.entityId}`).toBe(true);
|
|
}
|
|
if (rule.trigger.kind === "entities-dead") {
|
|
expect(rule.trigger.entityIds.every((entityId) => spawnIds.has(entityId)), `${id}:${rule.id}`).toBe(true);
|
|
}
|
|
for (const action of rule.actions) {
|
|
expect(actionIds.has(action.id), `${id}:duplicate action ${action.id}`).toBe(false);
|
|
actionIds.add(action.id);
|
|
if (action.kind === "activate-spawn-group" || action.kind === "deactivate-spawn-group") {
|
|
expect(groupIds.has(action.spawnGroupId), `${id}:${rule.id}:${action.id}`).toBe(true);
|
|
}
|
|
if (action.kind === "set-world-object-state") {
|
|
const object = definition.serverGameObjects.find((candidate) => candidate.id === action.objectId);
|
|
expect(object, `${id}:${rule.id}:${action.id}`).toBeDefined();
|
|
expect(object?.states.some((state) => state.id === action.state), `${id}:${rule.id}:${action.id}`).toBe(true);
|
|
}
|
|
if (action.kind === "complete-objective") {
|
|
expect(objectiveIds.has(action.objectiveId), `${id}:${rule.id}:${action.id}`).toBe(true);
|
|
}
|
|
}
|
|
}
|
|
const sourceSpawnIds = definition.serverGameObjects.flatMap((object) => (
|
|
object.source?.spawnId === undefined ? [] : [object.source.spawnId]
|
|
));
|
|
expect(new Set(sourceSpawnIds).size).toBe(sourceSpawnIds.length);
|
|
for (const object of definition.serverGameObjects.filter((candidate) => (
|
|
scripted.initialState?.worldObjectStates?.[candidate.id] !== undefined
|
|
))) {
|
|
validateDungeonWorldObject(object);
|
|
expect(object.visual?.hidden).not.toBe(true);
|
|
}
|
|
expect(definition.validation.warnings.some((warning) => warning.includes("remain"))).toBe(true);
|
|
}
|
|
|
|
const brs = adapted("blackrock-spire");
|
|
expect(brs.encounters?.find((value) => value.id === "blackrock-spire:wow-instance")).toEqual(priorSolakarEncounter);
|
|
expect(brs.encounterSpawnGroups?.filter((value) => value.id.startsWith("blackrock-spire:solakar")))
|
|
.toEqual(priorSolakarGroups);
|
|
expect(brs.serverGameObjects.find((value) => value.source?.templateId === 175_245)).toEqual(priorFatherFlame);
|
|
});
|
|
|
|
it("ports Gyth and Urok's pinned combat schedules instead of leaving event bosses basic-only", () => {
|
|
const definition = adapted("blackrock-spire");
|
|
const byEntry = (entry: number) => Object.values(definition.entities)
|
|
.find((entity) => entity.combat?.serverEntry === entry)!;
|
|
const gyth = byEntry(10_339);
|
|
const urok = byEntry(10_584);
|
|
|
|
expect(gyth.combat?.attacks.filter((attack) => attack.id !== "basic-attack").map((attack) => ({
|
|
id: attack.id,
|
|
spellId: attack.spellId,
|
|
initial: attack.initialCooldownMs,
|
|
repeat: attack.repeatCooldownMs,
|
|
}))).toEqual([
|
|
{ id: "corrosive-acid-16359", spellId: 16_359, initial: [8_000, 16_000], repeat: [10_000, 16_000] },
|
|
{ id: "freeze-16350", spellId: 16_350, initial: [8_000, 16_000], repeat: [10_000, 16_000] },
|
|
{ id: "flame-breath-16390", spellId: 16_390, initial: [8_000, 16_000], repeat: [10_000, 16_000] },
|
|
{ id: "knock-away-10101", spellId: 10_101, initial: [12_000, 18_000], repeat: [14_000, 20_000] },
|
|
]);
|
|
expect(gyth.combat?.mechanicIds).toEqual([
|
|
"corrosive-acid-16359",
|
|
"freeze-16350",
|
|
"flame-breath-16390",
|
|
"knock-away-10101",
|
|
]);
|
|
expect(gyth.combat?.attacks.find((attack) => attack.id === "corrosive-acid-16359"))
|
|
.toMatchObject({
|
|
target: "nearby-party",
|
|
school: "nature",
|
|
range: 20,
|
|
radius: 20,
|
|
telegraph: { shape: "cone", anchor: "source", length: 20, angleDegrees: 90 },
|
|
});
|
|
expect(gyth.combat?.attacks.find((attack) => attack.id === "freeze-16350"))
|
|
.toMatchObject({
|
|
target: "nearby-party",
|
|
school: "frost",
|
|
range: 20,
|
|
radius: 20,
|
|
effect: { kind: "control", mechanic: "stun", durationMs: 10_000, damageMultiplier: 0.8 },
|
|
telegraph: { shape: "cone", anchor: "source", length: 20, angleDegrees: 90 },
|
|
});
|
|
expect(gyth.combat?.attacks.find((attack) => attack.id === "flame-breath-16390"))
|
|
.toMatchObject({
|
|
target: "nearby-party",
|
|
school: "fire",
|
|
range: 20,
|
|
radius: 20,
|
|
telegraph: { shape: "cone", anchor: "source", length: 20, angleDegrees: 90 },
|
|
});
|
|
|
|
expect(urok.combat?.attacks.filter((attack) => attack.id !== "basic-attack").map((attack) => ({
|
|
id: attack.id,
|
|
spellId: attack.spellId,
|
|
initial: attack.initialCooldownMs,
|
|
repeat: attack.repeatCooldownMs,
|
|
}))).toEqual([
|
|
{ id: "rend-16509", spellId: 16_509, initial: [17_000, 20_000], repeat: [8_000, 10_000] },
|
|
{ id: "strike-15580", spellId: 15_580, initial: [10_000, 12_000], repeat: [8_000, 10_000] },
|
|
{ id: "intimidating-roar-16508", spellId: 16_508, initial: [25_000, 30_000], repeat: [40_000, 45_000] },
|
|
]);
|
|
expect(urok.combat?.attacks.find((attack) => attack.id === "intimidating-roar-16508"))
|
|
.toMatchObject({
|
|
target: "nearby-party",
|
|
range: 8,
|
|
radius: 8,
|
|
effect: { kind: "control", mechanic: "fear", durationMs: 8_000 },
|
|
telegraph: { shape: "circle", anchor: "source", radius: 8 },
|
|
});
|
|
|
|
const review = WOW_CLASSIC_ENCOUNTER_BATCH_THREE_REVIEWS.find((candidate) => (
|
|
candidate.dungeonId === "blackrock-spire"
|
|
))!;
|
|
expect(review.remainingGaps.join(" ")).toContain("Freeze periodic damage");
|
|
expect(review.remainingGaps.join(" ")).toContain("split primary-root/nearby-fear targeting");
|
|
});
|
|
|
|
it("ports Crystal Fang's exact death summon while keeping the source-faithful rare boss melee-only", () => {
|
|
const definition = adapted("blackrock-spire");
|
|
const scripted = encounter(definition);
|
|
const crystalFang = definition.staticSpawns.find((spawn) => (
|
|
definition.entities[spawn.entityId]?.combat?.serverEntry === 10_376
|
|
))!;
|
|
const spiderling = group(definition, "blackrock-spire:batch-three:crystal-fang-spiderling");
|
|
expect(crystalFang.spawnChance).toBe(0.15);
|
|
expect(spiderling.spawns).toHaveLength(1);
|
|
expect(spiderling.spawns[0]).toMatchObject({
|
|
entityId: expect.stringContaining("entry-10375"),
|
|
position: crystalFang.position,
|
|
});
|
|
|
|
const snapshot = reduceDungeonEncounter(scripted, createDungeonEncounterSnapshot(scripted), {
|
|
kind: "entity-death",
|
|
entityId: crystalFang.id,
|
|
now: 1,
|
|
}).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(spiderling.id);
|
|
});
|
|
|
|
it("runs Gnomeregan's exact Emi group counts, cave-ins, retry, doors, and persistent Grubbis gate", () => {
|
|
const definition = adapted("gnomeregan");
|
|
const scripted = encounter(definition);
|
|
const groups = ["ambushers-1", "ambushers-2", "ambushers-3a", "ambushers-3b", "grubbis"]
|
|
.map((name) => group(definition, `gnomeregan:batch-three:${name}`));
|
|
expect(groups.map((value) => value.spawns.length)).toEqual([10, 4, 5, 5, 2]);
|
|
expect(groups[2].spawns.map((spawn) => spawn.position)).toEqual(groups[3].spawns.map((spawn) => spawn.position));
|
|
const emi = definition.serverGameObjects.find((object) => object.id === "gnomeregan:batch-three:emi-shortfuse")!;
|
|
const caveOne = objectBySpawn(definition, 6_447);
|
|
const caveTwo = objectBySpawn(definition, 17_633);
|
|
const workshop = objectBySpawn(definition, 12_003);
|
|
const finalDoor = objectBySpawn(definition, 6_910);
|
|
let snapshot = createDungeonEncounterSnapshot(scripted);
|
|
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: workshop.id, now: 0 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: finalDoor.id, now: 1 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: emi.id, now: 2 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(groups[0].id);
|
|
snapshot = killGroup(scripted, snapshot, groups[0], 3);
|
|
snapshot = resetDungeonEncounterSnapshot(scripted, snapshot, "boss-wipe", 4);
|
|
expect(snapshot).toMatchObject({ phase: "idle", activeSpawnGroupIds: [] });
|
|
expect(snapshot.worldObjectStates[emi.id]).toBe("ready");
|
|
expect(snapshot.worldObjectStates[caveTwo.id]).toBe("closed");
|
|
expect(snapshot.worldObjectStates[workshop.id]).toBe("open");
|
|
expect(snapshot.worldObjectStates[finalDoor.id]).toBe("open");
|
|
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: emi.id, now: 10 }).snapshot;
|
|
snapshot = killGroup(scripted, snapshot, groups[0], 11);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 5_011 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(groups[1].id);
|
|
snapshot = killGroup(scripted, snapshot, groups[1], 5_012);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 45_012 }).snapshot;
|
|
expect(snapshot.worldObjectStates[caveTwo.id]).toBe("open");
|
|
expect(snapshot.activeSpawnGroupIds).toContain(groups[2].id);
|
|
snapshot = killGroup(scripted, snapshot, groups[2], 45_013);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 48_013 }).snapshot;
|
|
snapshot = killGroup(scripted, snapshot, groups[3], 48_014);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 108_014 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(groups[4].id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, {
|
|
kind: "entity-death",
|
|
entityId: "gnomeregan:batch-three:grubbis",
|
|
now: 108_015,
|
|
}).snapshot;
|
|
expect(snapshot.completedObjectiveIds).toContain("gnomeregan:batch-three:grubbis");
|
|
expect(snapshot.worldObjectStates[caveOne.id]).toBe("open");
|
|
expect(snapshot.worldObjectStates[emi.id]).toBe("complete");
|
|
expect(snapshot.checkpointId).toBe("gnomeregan-grubbis");
|
|
|
|
snapshot = resetDungeonEncounterSnapshot(scripted, snapshot, "boss-wipe", 108_016);
|
|
expect(snapshot.completedObjectiveIds).toContain("gnomeregan:batch-three:grubbis");
|
|
expect(snapshot.worldObjectStates[caveOne.id]).toBe("open");
|
|
const fleet = definition.encounters?.find((value) => value.id === "gnomeregan:boss-progression")!;
|
|
const completion = fleet.rules.find((rule) => rule.id === "all-required-bosses-defeated")!;
|
|
expect(completion.guards).toContainEqual({
|
|
kind: "objective-complete",
|
|
objectiveId: "gnomeregan:batch-three:grubbis",
|
|
equals: true,
|
|
});
|
|
});
|
|
|
|
it("runs Dire Maul's pylons, Immol'thar recovery, east-wing wall, doors, and six tribute tiers", () => {
|
|
const definition = adapted("dire-maul");
|
|
const scripted = encounter(definition);
|
|
const pylons = [29_742, 29_743, 29_744, 29_745, 29_746].map((id) => objectBySpawn(definition, id));
|
|
const forcefield = objectBySpawn(definition, 29_747);
|
|
const courtyard = objectBySpawn(definition, 29_750);
|
|
const inner = objectBySpawn(definition, 29_756);
|
|
const conservatory = objectBySpawn(definition, 268_275);
|
|
const wall = objectBySpawn(definition, 268_276);
|
|
const ironbark = definition.serverGameObjects.find((object) => object.id === "dire-maul:batch-three:old-ironbark")!;
|
|
const tribute = definition.serverGameObjects.find((object) => object.id === "dire-maul:batch-three:gordok-tribute")!;
|
|
const immol = group(definition, "dire-maul:batch-three:immolthar");
|
|
const alzzin = group(definition, "dire-maul:batch-three:alzzin");
|
|
let snapshot = createDungeonEncounterSnapshot(scripted);
|
|
|
|
pylons.forEach((pylon, index) => {
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: pylon.id, now: index }).snapshot;
|
|
});
|
|
expect(snapshot.counters["pylons-off"]).toBe(5);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 10 }).snapshot;
|
|
expect(snapshot.worldObjectStates[forcefield.id]).toBe("open");
|
|
expect(snapshot.activeSpawnGroupIds).toContain(immol.id);
|
|
snapshot = resetDungeonEncounterSnapshot(scripted, snapshot, "boss-wipe", 11);
|
|
expect(snapshot.activeSpawnGroupIds).not.toContain(immol.id);
|
|
expect(snapshot.counters["pylons-off"]).toBe(5);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 12 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(immol.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: immol.spawns[0].id, now: 13 }).snapshot;
|
|
expect(snapshot.completedObjectiveIds).toContain(immol.spawns[0].id);
|
|
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: "creature-248429", now: 20 }).snapshot;
|
|
expect(snapshot.worldObjectStates[ironbark.id]).toBe("ready");
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: ironbark.id, now: 21 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 7_021 }).snapshot;
|
|
expect(snapshot.worldObjectStates[conservatory.id]).toBe("open");
|
|
expect(snapshot.activeSpawnGroupIds).toContain(alzzin.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-health", entityId: alzzin.spawns[0].id, healthPercent: 51, now: 7_022 }).snapshot;
|
|
expect(snapshot.worldObjectStates[wall.id]).toBe("closed");
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-health", entityId: alzzin.spawns[0].id, healthPercent: 50, now: 7_023 }).snapshot;
|
|
expect(snapshot.worldObjectStates[wall.id]).toBe("open");
|
|
snapshot = resetDungeonEncounterSnapshot(scripted, snapshot, "boss-wipe", 7_024);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 7_025 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(alzzin.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: alzzin.spawns[0].id, now: 7_026 }).snapshot;
|
|
expect(snapshot.completedObjectiveIds).toContain("dire-maul:batch-three:alzzin");
|
|
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: courtyard.id, now: 8_000 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: inner.id, now: 8_001 }).snapshot;
|
|
expect(snapshot.worldObjectStates[courtyard.id]).toBe("open");
|
|
expect(snapshot.worldObjectStates[inner.id]).toBe("open");
|
|
for (const id of ["creature-248079", "creature-248080"]) {
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: id, now: snapshot.revision + 8_010 }).snapshot;
|
|
}
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: "creature-248076", now: 9_000 }).snapshot;
|
|
expect(snapshot.counters["tribute-penalties"]).toBe(2);
|
|
expect(snapshot.worldObjectStates[tribute.id]).toBe("tier-4");
|
|
|
|
let perfect = createDungeonEncounterSnapshot(scripted);
|
|
perfect = reduceDungeonEncounter(scripted, perfect, { kind: "entity-death", entityId: "creature-248076", now: 1 }).snapshot;
|
|
expect(perfect.worldObjectStates[tribute.id]).toBe("tier-6");
|
|
const optionalIds = new Set(["creature-248077", "creature-248079", "creature-248080", "creature-248081", "creature-248082"]);
|
|
expect(definition.bosses.filter((boss) => optionalIds.has(boss.id)).every((boss) => boss.optional)).toBe(true);
|
|
const fleetCompletion = definition.encounters?.find((value) => value.id === "dire-maul:boss-progression")
|
|
?.rules.find((rule) => rule.id === "all-required-bosses-defeated");
|
|
expect(fleetCompletion?.guards?.some((guard) => guard.kind === "objective-complete" && optionalIds.has(guard.objectiveId)))
|
|
.toBe(false);
|
|
});
|
|
|
|
it("runs Blackrock Spire's runes, Emberseer reset, exact stadium, Drakkisath doors, and Urok retry", () => {
|
|
const definition = adapted("blackrock-spire");
|
|
const scripted = encounter(definition);
|
|
const hallRunes = [87_827, 87_829, 87_825, 87_830, 87_828, 87_826, 87_824].map((id) => objectBySpawn(definition, id));
|
|
const emberRunes = [87_831, 87_832, 87_833, 87_834, 87_835, 87_836, 87_837].map((id) => objectBySpawn(definition, id));
|
|
const emberIn = objectBySpawn(definition, 87_839);
|
|
const emberOut = objectBySpawn(definition, 87_841);
|
|
const emberDoors = objectBySpawn(definition, 87_842);
|
|
const emberTrigger = definition.serverGameObjects.find((object) => object.id === "blackrock-spire:batch-three:emberseer-trigger")!;
|
|
const incarcerators = group(definition, "blackrock-spire:batch-three:incarcerators");
|
|
const emberseer = group(definition, "blackrock-spire:batch-three:emberseer");
|
|
const runeMobs = [
|
|
["creature-137869", "creature-137871", "creature-137928", "creature-137930"],
|
|
["creature-137872", "creature-137896", "creature-137898"],
|
|
["creature-137870", "creature-137886", "creature-137929"],
|
|
["creature-137873", "creature-137892", "creature-137897", "creature-137903", "creature-137904", "creature-137905", "creature-137931", "creature-137934"],
|
|
["creature-137878", "creature-137911", "creature-137912", "creature-137939"],
|
|
["creature-137880", "creature-137881", "creature-137942", "creature-137943"],
|
|
["creature-137877", "creature-137908", "creature-137909", "creature-137910", "creature-137938"],
|
|
];
|
|
let snapshot = createDungeonEncounterSnapshot(scripted);
|
|
runeMobs.forEach((ids, index) => {
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, {
|
|
kind: "tick",
|
|
now: index + 1,
|
|
facts: { registeredEntityIds: ids, deadEntityIds: ids },
|
|
}).snapshot;
|
|
});
|
|
expect(snapshot.counters["dragonspire-runes"]).toBe(7);
|
|
expect(hallRunes.every((rune) => snapshot.worldObjectStates[rune.id] === "inactive")).toBe(true);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 8 }).snapshot;
|
|
expect(snapshot.worldObjectStates[emberIn.id]).toBe("open");
|
|
expect(snapshot.worldObjectStates[emberDoors.id]).toBe("open");
|
|
expect(snapshot.worldObjectStates[emberTrigger.id]).toBe("ready");
|
|
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: emberTrigger.id, now: 10 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 2_010 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(incarcerators.id);
|
|
snapshot = resetDungeonEncounterSnapshot(scripted, snapshot, "boss-wipe", 2_011);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 2_012 }).snapshot;
|
|
expect(snapshot.worldObjectStates[emberTrigger.id]).toBe("ready");
|
|
expect(snapshot.worldObjectStates[emberIn.id]).toBe("open");
|
|
expect(snapshot.activeSpawnGroupIds).not.toContain(incarcerators.id);
|
|
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: emberTrigger.id, now: 3_000 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 5_000 }).snapshot;
|
|
snapshot = killGroup(scripted, snapshot, incarcerators, 5_001);
|
|
expect(emberRunes.every((rune) => snapshot.worldObjectStates[rune.id] === "growing")).toBe(true);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 30_001 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(emberseer.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: emberseer.spawns[0].id, now: 30_002 }).snapshot;
|
|
expect(snapshot.completedObjectiveIds).toContain("creature-137817");
|
|
expect(snapshot.worldObjectStates[emberOut.id]).toBe("open");
|
|
expect(emberRunes.every((rune) => snapshot.worldObjectStates[rune.id] === "released")).toBe(true);
|
|
|
|
const stadiumEntry = objectBySpawn(definition, 87_845);
|
|
const stadiumWaveDoor = objectBySpawn(definition, 87_843);
|
|
const stadiumExit = objectBySpawn(definition, 87_844);
|
|
const waves = Array.from({ length: 6 }, (_, index) => group(definition, `blackrock-spire:batch-three:stadium-wave-${index + 1}`));
|
|
expect(waves.map((value) => value.spawns.length)).toEqual([4, 3, 4, 4, 5, 5]);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: stadiumEntry.id, now: 31_000 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: 42_000 }).snapshot;
|
|
for (let index = 0; index < waves.length; index += 1) {
|
|
expect(snapshot.activeSpawnGroupIds).toContain(waves[index].id);
|
|
snapshot = killGroup(scripted, snapshot, waves[index], snapshot.phaseStartedAt + 1);
|
|
if (index < waves.length - 1) {
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: snapshot.phaseStartedAt + 13_000 }).snapshot;
|
|
}
|
|
}
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: snapshot.phaseStartedAt + 18_000 }).snapshot;
|
|
const gyth = group(definition, "blackrock-spire:batch-three:gyth");
|
|
const rend = group(definition, "blackrock-spire:batch-three:rend");
|
|
expect(snapshot.activeSpawnGroupIds).toContain(gyth.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-health", entityId: gyth.spawns[0].id, healthPercent: 26, now: snapshot.phaseStartedAt + 1 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).not.toContain(rend.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-health", entityId: gyth.spawns[0].id, healthPercent: 25, now: snapshot.phaseStartedAt + 2 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(rend.id);
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: gyth.spawns[0].id, now: snapshot.phaseStartedAt + 3 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: rend.spawns[0].id, now: snapshot.phaseStartedAt + 4 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "tick", now: snapshot.phaseStartedAt + 5 }).snapshot;
|
|
expect(snapshot.completedObjectiveIds).toContain("creature-137968");
|
|
expect(snapshot.worldObjectStates[stadiumEntry.id]).toBe("complete");
|
|
expect(snapshot.worldObjectStates[stadiumWaveDoor.id]).toBe("open");
|
|
expect(snapshot.worldObjectStates[stadiumExit.id]).toBe("open");
|
|
|
|
const drakkDoors = [objectBySpawn(definition, 87_854), objectBySpawn(definition, 87_855)];
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: "creature-137971", now: snapshot.phaseStartedAt + 6 }).snapshot;
|
|
expect(drakkDoors.every((door) => snapshot.worldObjectStates[door.id] === "open")).toBe(true);
|
|
|
|
const pile = objectBySpawn(definition, 99_791);
|
|
const urok = group(definition, "blackrock-spire:batch-three:urok");
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: pile.id, now: snapshot.phaseStartedAt + 7 }).snapshot;
|
|
expect(snapshot.activeSpawnGroupIds).toContain(urok.id);
|
|
snapshot = resetDungeonEncounterSnapshot(scripted, snapshot, "boss-wipe", snapshot.phaseStartedAt + 8);
|
|
expect(snapshot.worldObjectStates[pile.id]).toBe("ready");
|
|
expect(snapshot.completedObjectiveIds).toContain("creature-137817");
|
|
expect(snapshot.completedObjectiveIds).toContain("creature-137968");
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "interact", objectId: pile.id, now: snapshot.phaseStartedAt + 9 }).snapshot;
|
|
snapshot = reduceDungeonEncounter(scripted, snapshot, { kind: "entity-death", entityId: urok.spawns[0].id, now: snapshot.phaseStartedAt + 10 }).snapshot;
|
|
expect(snapshot.completedObjectiveIds).toContain("blackrock-spire:batch-three:urok-doomhowl");
|
|
expect(snapshot.worldObjectStates[pile.id]).toBe("complete");
|
|
});
|
|
});
|