forked from phenom/healer-man
65 lines
3.2 KiB
TypeScript
65 lines
3.2 KiB
TypeScript
import catalog from "./generated/wowDungeonMaps.generated.json";
|
|
import type { DungeonDefinition, Vector3Tuple } from "./dungeonTypes";
|
|
|
|
export interface WowMapFloor {
|
|
readonly level: number;
|
|
readonly name: string;
|
|
/** World MinX, MaxX, MinY, MaxY; X points north and Y points west. */
|
|
readonly bounds: readonly [number, number, number, number];
|
|
readonly image: string;
|
|
readonly checksum: string;
|
|
}
|
|
export interface WowDungeonMap {
|
|
readonly mapId: number;
|
|
readonly coordinateTransform: string;
|
|
readonly visualChecksum?: string;
|
|
/** Three row-major affine rows converting package position to WoW XYZ. */
|
|
readonly runtimeToWow: readonly number[];
|
|
readonly floors: readonly WowMapFloor[];
|
|
}
|
|
const maps = catalog.dungeons as unknown as Readonly<Record<string, WowDungeonMap>>;
|
|
|
|
export function wowDungeonMapFor(dungeon: DungeonDefinition): WowDungeonMap | null {
|
|
const map = maps[dungeon.contentSourceDungeonId ?? dungeon.id];
|
|
// A replacement environment must be reimported, never silently misaligned.
|
|
return map?.mapId === dungeon.mapId
|
|
&& map.coordinateTransform === dungeon.provenance.coordinateTransform
|
|
&& map.visualChecksum === dungeon.assets.visual[0]?.checksum ? map : null;
|
|
}
|
|
|
|
export function wowMapWorldPosition(map: WowDungeonMap, position: Vector3Tuple): Vector3Tuple {
|
|
return [0, 1, 2].map((row) => {
|
|
const i = row * 4;
|
|
return map.runtimeToWow[i] * position[0] + map.runtimeToWow[i + 1] * position[1]
|
|
+ map.runtimeToWow[i + 2] * position[2] + map.runtimeToWow[i + 3];
|
|
}) as unknown as Vector3Tuple;
|
|
}
|
|
|
|
export function wowMapPoint(map: WowDungeonMap, floor: WowMapFloor, position: Vector3Tuple): readonly [number, number] {
|
|
const [x, y] = wowMapWorldPosition(map, position);
|
|
const [minX, maxX, minY, maxY] = floor.bounds;
|
|
return [(maxY - y) / (maxY - minY) * 1002, (maxX - x) / (maxX - minX) * 668];
|
|
}
|
|
|
|
export function wowMapContains(map: WowDungeonMap, floor: WowMapFloor, position: Vector3Tuple): boolean {
|
|
const [x, y] = wowMapPoint(map, floor, position);
|
|
return Number.isFinite(x) && Number.isFinite(y) && x >= 0 && x <= 1002 && y >= 0 && y <= 668;
|
|
}
|
|
|
|
/** Smallest containing floor wins; stacked rooms can be selected explicitly in the map panel. */
|
|
export function wowMapFloorFor(map: WowDungeonMap, position: Vector3Tuple, level?: number | null): WowMapFloor {
|
|
const explicit = map.floors.find((floor) => floor.level === level);
|
|
if (explicit) return explicit;
|
|
const containing = map.floors.filter((floor) => floor.level !== 0 && wowMapContains(map, floor, position));
|
|
const size = (floor: WowMapFloor) => (floor.bounds[1] - floor.bounds[0]) * (floor.bounds[3] - floor.bounds[2]);
|
|
return containing.sort((a, b) => size(a) - size(b) || a.level - b.level)[0]
|
|
?? map.floors.find((floor) => floor.level === 0) ?? map.floors[0];
|
|
}
|
|
|
|
export function wowMapHeading(map: WowDungeonMap, floor: WowMapFloor, position: Vector3Tuple, yaw: number): readonly [number, number] {
|
|
const [x, y] = wowMapPoint(map, floor, position);
|
|
const [targetX, targetY] = wowMapPoint(map, floor, [position[0] + Math.sin(yaw), position[1], position[2] + Math.cos(yaw)]);
|
|
const length = Math.hypot(targetX - x, targetY - y) || 1;
|
|
return [(targetX - x) / length * 23, (targetY - y) / length * 23];
|
|
}
|