Update Healer Man server

src/game/wowDungeonEnvironment.test.ts

@@ -1,15 +1,21 @@
 import { describe, expect, it } from "vitest";
-import { DUNGEON_DEFINITIONS, requireDungeonDefinition } from "./dungeonRegistry";
+import { DUNGEON_DEFINITIONS, prepareDungeonSessionDefinition, requireDungeonDefinition } from "./dungeonRegistry";
 import { FORSAKEN_ABBEY_DEFINITION } from "./dungeons/forsakenAbbey";
 import { WOW_DUNGEON_LIGHTING, withWowDungeonEnvironment, wowDungeonLightingProfile } from "./wowDungeonEnvironment";
+import { materializeBiteSizedLayout } from "./biteSizedLayoutRuntime";
 import stairs from "./generated/wowDungeonStairs.generated.json";
 import stockadesOverride from "../../dungeon-pipeline/runtime-overrides/stormwind-stockade.json";
-import { isBiteSizedDungeonId } from "./dungeonContentSource";
+import { BITE_SIZED_DEFAULT_CONFIG, selectBiteSizedRun } from "../../shared/bite-sized-layouts.mjs";
+import { DUNGEON_REGISTRY } from "./dungeonRegistry";
+import { dungeonContentSourceId, isBiteSizedDungeonId } from "./dungeonContentSource";
 
 describe("fleet-wide WoW dungeon environment policy", () => {
   const wowDungeons = DUNGEON_DEFINITIONS.filter((dungeon) => (
     dungeon.expansion !== "runewaker" && !isBiteSizedDungeonId(dungeon.id)
   ));
+  const wowBiteSizedDungeons = DUNGEON_DEFINITIONS.filter((dungeon) => (
+    dungeon.expansion !== "runewaker" && isBiteSizedDungeonId(dungeon.id)
+  ));
 
   it("gives every WoW dungeon readable ambient and hemisphere fill without changing fog draw distance or material roles", () => {
     expect(wowDungeons).toHaveLength(54);
@@ -17,6 +23,10 @@ describe("fleet-wide WoW dungeon environment policy", () => {
       const profile = WOW_DUNGEON_LIGHTING[wowDungeonLightingProfile(dungeon.id)];
       expect(dungeon.presentation.ambientLight).toEqual(profile.ambientLight);
       expect(dungeon.presentation.hemisphereLight).toEqual(profile.hemisphereLight);
+      expect(dungeon.presentation.directionalLight).toEqual(profile.directionalLight);
+      expect(dungeon.presentation.background).toBe(profile.background);
+      expect(dungeon.presentation.fog.color).toBe(profile.fog.color);
+      expect(dungeon.presentation.fog.near).toBe(profile.fog.near);
       expect(dungeon.presentation.fog.far).toBeGreaterThan(dungeon.presentation.fog.near);
       const updated = withWowDungeonEnvironment(dungeon);
       expect(updated.presentation.materials).toBe(dungeon.presentation.materials);
@@ -25,6 +35,122 @@ describe("fleet-wide WoW dungeon environment policy", () => {
     }
   });
 
+  it("preserves adapted source lighting on every WoW Bite-Sized catalog and prepared definition", () => {
+    expect(wowBiteSizedDungeons.map((dungeon) => dungeon.id).sort()).toEqual([
+      "bite-sized-deadmines-ship",
+      "bite-sized-stormwind-stockade",
+      "bite-sized-utgarde-pinnacle-skadi",
+      "bite-sized-wailing-caverns",
+      "randomized-bite-sized-stormwind-stockade",
+      "randomized-bite-sized-stormwind-stockade-available",
+    ]);
+
+    const presentationLighting = (definition: typeof wowBiteSizedDungeons[number]) => ({
+      background: definition.presentation.background,
+      fog: {
+        color: definition.presentation.fog.color,
+        near: definition.presentation.fog.near,
+        far: definition.presentation.fog.far,
+      },
+      ambientLight: definition.presentation.ambientLight,
+      hemisphereLight: definition.presentation.hemisphereLight,
+      directionalLight: definition.presentation.directionalLight,
+    });
+
+    for (const catalogDefinition of wowBiteSizedDungeons) {
+      const source = requireDungeonDefinition(dungeonContentSourceId(catalogDefinition.id));
+      const expectedLighting = presentationLighting(source);
+      expect(presentationLighting(catalogDefinition), catalogDefinition.id).toEqual(expectedLighting);
+
+      const prepared = prepareDungeonSessionDefinition(catalogDefinition.id, `lighting-${catalogDefinition.id}`);
+      expect(prepared, catalogDefinition.id).not.toBeNull();
+      const preparedSource = requireDungeonDefinition(
+        prepared!.contentSourceDungeonId ?? dungeonContentSourceId(catalogDefinition.id),
+      );
+      expect(prepared!.expansion, `${catalogDefinition.id} prepared expansion`).toBe(preparedSource.expansion);
+      const sourceSlice = wowBiteSizedDungeons.find((definition) => (
+        !definition.id.startsWith("randomized-")
+        && dungeonContentSourceId(definition.id) === preparedSource.id
+      )) ?? DUNGEON_DEFINITIONS.find((definition) => (
+        definition.expansion === preparedSource.expansion
+        && isBiteSizedDungeonId(definition.id)
+        && !definition.id.startsWith("randomized-")
+        && dungeonContentSourceId(definition.id) === preparedSource.id
+      ));
+      expect(sourceSlice, `${catalogDefinition.id} source slice ${preparedSource.id}`).toBeDefined();
+      expect(presentationLighting(prepared!), `${catalogDefinition.id} prepared from ${preparedSource.id}`)
+        .toEqual(presentationLighting(sourceSlice!));
+      if (preparedSource.id === dungeonContentSourceId(catalogDefinition.id)) {
+        expect(presentationLighting(prepared!), `${catalogDefinition.id} prepared`).toEqual(expectedLighting);
+      }
+    }
+  });
+
+  it("uses the selected source lighting and point lights when a custom layout baseline belongs elsewhere", () => {
+    const source = requireDungeonDefinition("wailing-caverns");
+    const pointLights = [{ position: [3, 4, 5] as const, color: "#80d8ff", intensity: 2, distance: 12 }];
+    const customSource = {
+      ...source,
+      presentation: { ...source.presentation, pointLights },
+    };
+    const baseline = requireDungeonDefinition("bite-sized-paspers-shrine-hafiz");
+    const selection = selectBiteSizedRun(
+      BITE_SIZED_DEFAULT_CONFIG,
+      "bite-sized-wailing-caverns",
+      "cross-source-environment-test",
+    );
+    const materialized = materializeBiteSizedLayout(
+      customSource,
+      baseline,
+      selection,
+      DUNGEON_REGISTRY,
+    );
+
+    expect(materialized.presentation.background).toBe(source.presentation.background);
+    expect(materialized.presentation.fog).toEqual(source.presentation.fog);
+    expect(materialized.presentation.ambientLight).toEqual(source.presentation.ambientLight);
+    expect(materialized.presentation.hemisphereLight).toEqual(source.presentation.hemisphereLight);
+    expect(materialized.presentation.directionalLight).toEqual(source.presentation.directionalLight);
+    expect(materialized.presentation.pointLights).toEqual(pointLights);
+    expect(materialized.presentation.theme).toBe("Bite-Sized Dungeon");
+  });
+
+  it("keeps tuned lighting from a custom baseline whose explicit source matches", () => {
+    const source = requireDungeonDefinition("wailing-caverns");
+    const selection = selectBiteSizedRun(
+      BITE_SIZED_DEFAULT_CONFIG,
+      "bite-sized-wailing-caverns",
+      "explicit-baseline-source-test",
+    );
+    const tunedPresentation = {
+      ...source.presentation,
+      background: "#101820",
+      ambientLight: { color: "#c1d2c2", intensity: 0.91 },
+      hemisphereLight: { skyColor: "#abc4b5", groundColor: "#1f2a23", intensity: 1.23 },
+      directionalLight: { ...source.presentation.directionalLight, color: "#d9ecc8", intensity: 1.34 },
+      pointLights: [{ position: [6, 7, 8] as const, color: "#b8f1ff", intensity: 1.8, distance: 14 }],
+    };
+    const customBaseline = {
+      ...requireDungeonDefinition("bite-sized-paspers-shrine-hafiz"),
+      id: "custom-lighting-baseline",
+      contentSourceDungeonId: source.id,
+      presentation: tunedPresentation,
+    };
+    const materialized = materializeBiteSizedLayout(
+      source,
+      customBaseline,
+      selection,
+      DUNGEON_REGISTRY,
+    );
+
+    expect(materialized.presentation.background).toBe(tunedPresentation.background);
+    expect(materialized.presentation.ambientLight).toEqual(tunedPresentation.ambientLight);
+    expect(materialized.presentation.hemisphereLight).toEqual(tunedPresentation.hemisphereLight);
+    expect(materialized.presentation.directionalLight).toEqual(tunedPresentation.directionalLight);
+    expect(materialized.presentation.pointLights).toEqual(tunedPresentation.pointLights);
+    expect(materialized.presentation.location).toContain(selection.spot.name);
+  });
+
   it("keeps Stockades' reviewed lighting, ramps and navigation links intact", () => {
     const stockades = requireDungeonDefinition("stormwind-stockade");
     // The existing campaign compiler stores package vectors at four decimals.