Release Healer Man 0.1.22

src/game/tbcDifficultyContract.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import campaign from "../../dungeon-pipeline/dungeon-campaign.json";
+import { requireDungeonDefinition } from "./dungeonRegistry";
+import type { DungeonDifficultyVariant, DungeonSourceRecipe } from "./dungeonTypes";
+
+const recipeModules = import.meta.glob<DungeonSourceRecipe>(
+  "../../dungeon-pipeline/recipes/*.json",
+  { eager: true, import: "default" },
+);
+
+const TBC_DUNGEON_IDS = campaign.dungeons
+  .filter((dungeon) => dungeon.source === "burning-crusade")
+  .map((dungeon) => dungeon.slug);
+
+function requireRecipe(dungeonId: string): DungeonSourceRecipe {
+  const path = `../../dungeon-pipeline/recipes/${dungeonId}.json`;
+  const recipe = recipeModules[path];
+  if (!recipe) throw new Error(`Missing Burning Crusade recipe: ${path}`);
+  return recipe;
+}
+
+function expectSelectableDifficultyContract(
+  label: string,
+  variants: readonly DungeonDifficultyVariant[],
+): void {
+  const normal = variants.find((variant) => variant.id === "normal");
+  const heroic = variants.find((variant) => variant.id === "heroic");
+
+  expect(normal, `${label}:normal`).toMatchObject({
+    difficulty: "normal",
+    spawnMask: 1,
+  });
+  expect(heroic, `${label}:heroic`).toMatchObject({
+    difficulty: "heroic",
+    spawnMask: 2,
+    levelRange: [70, 70],
+  });
+  expect(new Set(variants.map((variant) => variant.id)).size, `${label}:unique-ids`)
+    .toBe(variants.length);
+}
+
+describe("Burning Crusade difficulty contract", () => {
+  it("advertises selectable normal and level-70 heroic variants in every recipe and compiled definition", () => {
+    expect(TBC_DUNGEON_IDS).toHaveLength(14);
+
+    for (const dungeonId of TBC_DUNGEON_IDS) {
+      const recipe = requireRecipe(dungeonId);
+      const definition = requireDungeonDefinition(dungeonId);
+
+      expect(recipe.slug, dungeonId).toBe(dungeonId);
+      expect(recipe.expansion, dungeonId).toBe("burning-crusade");
+      expectSelectableDifficultyContract(`${dungeonId}:recipe`, recipe.difficultyVariants);
+      expectSelectableDifficultyContract(`${dungeonId}:runtime`, definition.difficultyVariants);
+    }
+  });
+
+  it("only uses encounter difficulty guards that players can select", () => {
+    for (const dungeonId of TBC_DUNGEON_IDS) {
+      const definition = requireDungeonDefinition(dungeonId);
+      const selectableDifficultyIds = new Set(
+        definition.difficultyVariants.map((variant) => variant.id),
+      );
+
+      for (const encounter of definition.encounters ?? []) {
+        for (const rule of encounter.rules) {
+          for (const guard of rule.guards ?? []) {
+            if (guard.kind !== "difficulty") continue;
+            expect(guard.difficultyIds.length, `${dungeonId}:${encounter.id}:${rule.id}`)
+              .toBeGreaterThan(0);
+            for (const difficultyId of guard.difficultyIds) {
+              expect(
+                selectableDifficultyIds.has(difficultyId),
+                `${dungeonId}:${encounter.id}:${rule.id}:${difficultyId}`,
+              ).toBe(true);
+            }
+          }
+        }
+      }
+    }
+  });
+});