@dreadwood-types/types 0.1.0

package/dist/constants.js

@@ -0,0 +1,713 @@
+export const TILE_SIZE = 1;
+export const CHAT_MAX_CHARS = 120;
+export const CHAT_MAX_WORDS = 24;
+export function clampChatText(text) {
+    const sliced = text.trim().slice(0, CHAT_MAX_CHARS);
+    if (!sliced)
+        return '';
+    const words = sliced.split(/\s+/).filter(Boolean);
+    if (words.length <= CHAT_MAX_WORDS)
+        return words.join(' ');
+    return words.slice(0, CHAT_MAX_WORDS).join(' ');
+}
+export const PLAYER_NAME_MIN = 2;
+export const PLAYER_NAME_MAX = 24;
+const PLAYER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 _'-]*$/;
+export function sanitizePlayerName(raw) {
+    return raw.trim().replace(/\s+/g, ' ').slice(0, PLAYER_NAME_MAX);
+}
+/**
+ * Pet names go through the same rules as player names — the claim dialog
+ * already validates with `playerNameError`, so the server must apply the same
+ * pair or a hand-crafted packet could park arbitrary text over someone's head.
+ * Returns null for anything unusable rather than throwing, since this also runs
+ * over whatever the database happens to hold.
+ */
+export function normalizeBeagleName(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const name = sanitizePlayerName(raw);
+    return playerNameError(name) === null ? name : null;
+}
+export function playerNameError(name) {
+    if (name.length < PLAYER_NAME_MIN) {
+        return `Names must be at least ${PLAYER_NAME_MIN} characters.`;
+    }
+    if (name.length > PLAYER_NAME_MAX) {
+        return `Names must be at most ${PLAYER_NAME_MAX} characters.`;
+    }
+    if (!PLAYER_NAME_PATTERN.test(name)) {
+        return 'Names can only use letters, numbers, spaces, hyphens, underscores and apostrophes.';
+    }
+    return null;
+}
+export const CHUNK_SIZE = 32;
+export const FARMLAND_CHUNKS_X = 8;
+export const VILLAGE_CHUNKS_X = 2;
+export const EASTLAND_CHUNKS_X = 14;
+export const PLAYABLE_CHUNKS_X = FARMLAND_CHUNKS_X + VILLAGE_CHUNKS_X + EASTLAND_CHUNKS_X;
+export const PLAYABLE_CHUNKS_Z = 3;
+export const FARMLAND_WIDTH = CHUNK_SIZE * FARMLAND_CHUNKS_X;
+export const WORLD_EAST_CHUNKS = 2;
+export const WORLD_NORTH_CHUNKS = 23;
+export const DEMO_CHUNKS_X = PLAYABLE_CHUNKS_X + WORLD_EAST_CHUNKS;
+export const DEMO_CHUNKS_Z = PLAYABLE_CHUNKS_Z + WORLD_NORTH_CHUNKS;
+export const PLAYABLE_WIDTH = CHUNK_SIZE * PLAYABLE_CHUNKS_X;
+export const PLAYABLE_HEIGHT = CHUNK_SIZE * PLAYABLE_CHUNKS_Z;
+export const WORLD_NORTH_PAD = CHUNK_SIZE * WORLD_NORTH_CHUNKS;
+export const PLAYABLE_ORIGIN_X = 0;
+export const PLAYABLE_ORIGIN_Z = WORLD_NORTH_PAD;
+export const WORLD_WIDTH = CHUNK_SIZE * DEMO_CHUNKS_X;
+export const WORLD_HEIGHT = CHUNK_SIZE * DEMO_CHUNKS_Z;
+export const MAP_WIDTH = WORLD_WIDTH;
+export const MAP_HEIGHT = WORLD_HEIGHT;
+/**
+ * Extra columns east of the overworld for underground interiors (Rat Tunnel
+ * rooms, forest-den caverns). Generated and playable, but not on the paper
+ * map — the chart is WORLD_WIDTH × WORLD_HEIGHT.
+ */
+export const UNDERGROUND_CHUNKS_X = 8;
+export const UNDERGROUND_ORIGIN_X = WORLD_WIDTH;
+export const GRID_CHUNKS_X = DEMO_CHUNKS_X + UNDERGROUND_CHUNKS_X;
+export const GRID_CHUNKS_Z = DEMO_CHUNKS_Z;
+export const GRID_WIDTH = CHUNK_SIZE * GRID_CHUNKS_X;
+export const GRID_HEIGHT = CHUNK_SIZE * GRID_CHUNKS_Z;
+export function isPaperMapChunk(cx, cz) {
+    return cx >= 0 && cz >= 0 && cx < DEMO_CHUNKS_X && cz < DEMO_CHUNKS_Z;
+}
+export const HEIGHT_STEP = 0.45;
+export const MAX_STEP_HEIGHT = 2;
+export const PLAYABLE_BEACH_START_Z = 56;
+export const PLAYABLE_BEACH_SAND_START_Z = 60;
+export const PLAYABLE_OCEAN_START_Z = 82;
+export const BEACH_START_Z = PLAYABLE_BEACH_START_Z + WORLD_NORTH_PAD;
+export const BEACH_SAND_START_Z = PLAYABLE_BEACH_SAND_START_Z + WORLD_NORTH_PAD;
+export const OCEAN_START_Z = PLAYABLE_OCEAN_START_Z + WORLD_NORTH_PAD;
+export const BEACH_GATE_X = FARMLAND_WIDTH + 16;
+export const BEACH_GATE_HALF = 4;
+export const CHUNK_VIEW_RADIUS = 2;
+export const CART_DISTURB_COOLDOWN_MS = 45000;
+export var SurfaceType;
+(function (SurfaceType) {
+    SurfaceType[SurfaceType["Grass"] = 0] = "Grass";
+    SurfaceType[SurfaceType["Path"] = 1] = "Path";
+    SurfaceType[SurfaceType["Water"] = 2] = "Water";
+    SurfaceType[SurfaceType["Sand"] = 3] = "Sand";
+    SurfaceType[SurfaceType["Ash"] = 4] = "Ash";
+    SurfaceType[SurfaceType["Dirt"] = 5] = "Dirt";
+    SurfaceType[SurfaceType["Soil"] = 6] = "Soil";
+    SurfaceType[SurfaceType["Stone"] = 7] = "Stone";
+    SurfaceType[SurfaceType["Mud"] = 8] = "Mud";
+})(SurfaceType || (SurfaceType = {}));
+export var TileType;
+(function (TileType) {
+    TileType[TileType["Grass"] = 0] = "Grass";
+    TileType[TileType["Path"] = 1] = "Path";
+    TileType[TileType["Water"] = 2] = "Water";
+    TileType[TileType["Tree"] = 3] = "Tree";
+    TileType[TileType["Sand"] = 4] = "Sand";
+    TileType[TileType["Ash"] = 5] = "Ash";
+})(TileType || (TileType = {}));
+export const SURFACE_COLORS = {
+    [SurfaceType.Grass]: '#4a7c3f',
+    [SurfaceType.Path]: '#c2a878',
+    [SurfaceType.Water]: '#3a6ea5',
+    [SurfaceType.Sand]: '#e2c98a',
+    [SurfaceType.Ash]: '#4a3f36',
+    [SurfaceType.Dirt]: '#9a7b4f',
+    [SurfaceType.Soil]: '#6b4a2c',
+    [SurfaceType.Stone]: '#8a887f',
+    [SurfaceType.Mud]: '#4a3824',
+};
+export const TILE_COLORS = {
+    [TileType.Grass]: '#4a7c3f',
+    [TileType.Path]: '#c2a878',
+    [TileType.Water]: '#3a6ea5',
+    [TileType.Tree]: '#2d5a27',
+    [TileType.Sand]: '#e2c98a',
+    [TileType.Ash]: '#4a3f36',
+};
+export function chunkKey(cx, cz) {
+    return `${cx},${cz}`;
+}
+export function worldToChunk(x, z) {
+    const cx = Math.floor(x / CHUNK_SIZE);
+    const cz = Math.floor(z / CHUNK_SIZE);
+    return {
+        cx,
+        cz,
+        lx: ((x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE,
+        lz: ((z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE,
+    };
+}
+export function toWorldZ(localZ) {
+    return localZ + WORLD_NORTH_PAD;
+}
+export function chunksAround(cx, cz, radius) {
+    const out = [];
+    for (let dz = -radius; dz <= radius; dz++) {
+        for (let dx = -radius; dx <= radius; dx++) {
+            out.push({ cx: cx + dx, cz: cz + dz });
+        }
+    }
+    return out;
+}
+export function localIndex(lx, lz) {
+    return lz * CHUNK_SIZE + lx;
+}
+export function isWalkableSurface(surface) {
+    if (surface === SurfaceType.Water)
+        return false;
+    return (surface === SurfaceType.Grass ||
+        surface === SurfaceType.Path ||
+        surface === SurfaceType.Sand ||
+        surface === SurfaceType.Ash ||
+        surface === SurfaceType.Dirt ||
+        surface === SurfaceType.Soil ||
+        surface === SurfaceType.Stone ||
+        surface === SurfaceType.Mud);
+}
+export function entityBlocksWalk(kind) {
+    return (kind === 'tree' ||
+        kind === 'rock' ||
+        kind === 'beachhut' ||
+        kind === 'farmhut' ||
+        kind === 'storagehut' ||
+        kind === 'bankchest' ||
+        kind === 'workshop' ||
+        kind === 'table' ||
+        kind === 'fence' ||
+        kind === 'tradingcart' ||
+        kind === 'signpost' ||
+        kind === 'brokenpier' ||
+        kind === 'abandonedboat' ||
+        kind === 'ship' ||
+        kind === 'campfire' ||
+        kind === 'fortwall' ||
+        kind === 'archertower' ||
+        kind === 'barbedwire' ||
+        kind === 'barricade' ||
+        kind === 'haybale' ||
+        kind === 'horse' ||
+        kind === 'trough' ||
+        kind === 'well' ||
+        kind === 'farmcart' ||
+        kind === 'logpile' ||
+        kind === 'lantern' ||
+        kind === 'bench' ||
+        kind === 'milestone' ||
+        kind === 'tent' ||
+        kind === 'mudhut' ||
+        kind === 'cargo' ||
+        kind === 'scarecrow' ||
+        kind === 'barrel' ||
+        kind === 'compost' ||
+        kind === 'farmtool' ||
+        kind === 'caveentrance' ||
+        kind === 'ranchgate' ||
+        kind === 'dungeondoor' ||
+        kind === 'silo' ||
+        kind === 'grainmill' ||
+        kind === 'pumpwindmill' ||
+        kind === 'watertower' ||
+        kind === 'packbarn' ||
+        kind === 'packcoop' ||
+        kind === 'packstable' ||
+        kind === 'rabbithutch');
+}
+/** Dungeon room-gate visual states — mirrors ranch gate open/closed styling. */
+export function isDungeonDoorOpen(style) {
+    // Dungeon gates retain their room id in the style (`gate1-open` etc.) so
+    // the renderer can select the right model.  Treat all of those as open, as
+    // well as the original generic style kept for older worlds.
+    return style === 'open' || style?.endsWith('-open') === true;
+}
+/**
+ * A dungeon gate the viewing player has earned the right to open, but which is
+ * still physically DOWN.
+ *
+ * Unlocking used to swap the style straight to `-open`, so a gate you had
+ * cleared was simply drawn permanently winched up — there was never a moment of
+ * opening it, and nobody else saw anything happen. `-ready` keeps the
+ * portcullis closed and lets the client mark it as openable (a glow), so the
+ * open is an action with an animation and a sound rather than a state you
+ * arrive to.
+ */
+export function isDungeonGateReady(style) {
+    return typeof style === 'string' && style.endsWith('-ready');
+}
+/** Goblin cell gates share personal dungeon crossing, not shared fence toggles. */
+export function isGoblinPrisonDoorStyle(style) {
+    return typeof style === 'string' && /^goblin-prison-(north|south)(?:-ready)?$/.test(style);
+}
+/** Dungeon wall torch — lantern entity with a `torch-*` facing style. */
+export function isWallTorchStyle(style) {
+    return typeof style === 'string' && style.startsWith('torch');
+}
+/** Parse farm fence gate styles such as `gate-wide-closed-ew`. */
+export function parseFenceGateStyle(style) {
+    if (typeof style !== 'string' || !style.startsWith('gate'))
+        return null;
+    let rest = style;
+    let ew = false;
+    let closed = false;
+    if (rest.endsWith('-ew')) {
+        ew = true;
+        rest = rest.slice(0, -3);
+    }
+    if (rest.endsWith('-closed')) {
+        closed = true;
+        rest = rest.slice(0, -7);
+    }
+    if (rest === 'gate' || rest === 'gate-wide' || rest === 'gate-prison') {
+        return { kind: rest, ew, closed };
+    }
+    return null;
+}
+export function formatFenceGateStyle(info) {
+    let style = info.kind;
+    if (info.closed)
+        style += '-closed';
+    if (info.ew)
+        style += '-ew';
+    return style;
+}
+/** Open fence gate styles that leave a walkable gap in a fence ring. */
+export function isOpenGateStyle(style) {
+    const gate = parseFenceGateStyle(style);
+    return gate !== null && !gate.closed;
+}
+export function isFenceGateStyle(style) {
+    return parseFenceGateStyle(style) !== null;
+}
+export function isRanchGateOpen(style) {
+    if (typeof style !== 'string' || style.length === 0)
+        return true;
+    return !style.includes('closed');
+}
+/**
+ * Storage-hut (Base Camp bank) door.
+ *
+ * Plain `'repaired'` means open, and only the explicit closed style shuts it.
+ * After repair the door starts closed; clicking the personal enter icon opens
+ * it, teleports the player through, then closes it again.
+ *
+ * The door is deliberately **not** a passage blocker. Hut repair is per-player
+ * (see World.entityForPlayer, which rewrites the style per viewer off
+ * `player.storageHutRepaired`), so the door state is per-player too — and the
+ * walkability grid is global, so a per-player door cannot gate it without one
+ * player's door blocking another player's path. Unrepaired players still see
+ * the abandoned wreck (no enter icon); repaired players use the door portal.
+ */
+export const STORAGE_HUT_DOOR_CLOSED_STYLE = 'repaired-closed';
+export function isStorageHutRepairedStyle(style) {
+    return style === 'repaired' || style === STORAGE_HUT_DOOR_CLOSED_STYLE;
+}
+export function isStorageHutDoorOpen(style) {
+    return style !== STORAGE_HUT_DOOR_CLOSED_STYLE;
+}
+export function isGateInteractable(kind, style) {
+    if (kind === 'ranchgate')
+        return true;
+    if (kind === 'fence')
+        return isFenceGateStyle(style);
+    // Dungeon doors are objectives rather than toggles, but still need an
+    // interaction so players can read why the route is blocked.
+    if (kind === 'dungeondoor')
+        return true;
+    // Only once it has been repaired — a wrecked hut has no door to swing.
+    if (kind === 'storagehut')
+        return isStorageHutRepairedStyle(style);
+    return false;
+}
+export function isGateOpen(kind, style) {
+    if (kind === 'ranchgate')
+        return isRanchGateOpen(style);
+    if (kind === 'fence')
+        return isOpenGateStyle(style);
+    if (kind === 'dungeondoor')
+        return isDungeonDoorOpen(style);
+    if (kind === 'storagehut')
+        return isStorageHutDoorOpen(style);
+    return true;
+}
+export function toggleGateStyle(kind, style) {
+    if (kind === 'ranchgate') {
+        const ns = typeof style === 'string' && style.includes('ns');
+        const closed = !isRanchGateOpen(style);
+        if (closed)
+            return ns ? 'ns' : undefined;
+        return ns ? 'ns-closed' : 'closed';
+    }
+    if (kind === 'fence') {
+        const gate = parseFenceGateStyle(style);
+        if (!gate)
+            return style;
+        return formatFenceGateStyle({ ...gate, closed: !gate.closed });
+    }
+    if (kind === 'storagehut') {
+        if (!isStorageHutRepairedStyle(style))
+            return style;
+        return isStorageHutDoorOpen(style) ? STORAGE_HUT_DOOR_CLOSED_STYLE : 'repaired';
+    }
+    return style;
+}
+/** Tile offsets a closed gate blocks relative to its entity tile. */
+export function visitGatePassageOffsets(kind, style, visit) {
+    if (kind === 'ranchgate') {
+        visit(0, 0);
+        // Default ranch gate faces E/W traffic (posts along Z). `ns` flips that.
+        if (typeof style === 'string' && style.includes('ns')) {
+            visit(-1, 0);
+            visit(1, 0);
+        }
+        else {
+            visit(0, -1);
+            visit(0, 1);
+        }
+        return;
+    }
+    if (kind === 'fence') {
+        const gate = parseFenceGateStyle(style);
+        if (!gate)
+            return;
+        visit(0, 0);
+        if (gate.kind === 'gate-wide') {
+            if (gate.ew)
+                visit(1, 0);
+            else
+                visit(0, 1);
+        }
+        if (gate.kind === 'gate-prison') {
+            if (gate.ew) {
+                visit(-1, 0);
+                visit(1, 0);
+            }
+            else {
+                visit(0, -1);
+                visit(0, 1);
+            }
+        }
+    }
+}
+/** Must match the farmhut visual multiplier in frontend assets/index.ts. */
+const FARMHUT_RENDER_SCALE = 1.15;
+/** Stable shell width from farmHut.ts configs.stable (before render scale). */
+const STABLE_MESH_WIDTH = 2.28;
+const STABLE_LEAN_WIDTH = 0.58;
+function normalizeBuildingFootprint(footprint) {
+    if (typeof footprint === 'number') {
+        const r = footprint > 0 ? footprint : 0;
+        return { radiusX: r, radiusZ: r };
+    }
+    return {
+        radiusX: footprint.radiusX > 0 ? footprint.radiusX : 0,
+        radiusZ: footprint.radiusZ > 0 ? footprint.radiusZ : 0,
+    };
+}
+function buildingScaleBracketRadius(scale) {
+    if (scale >= 4.5)
+        return 4;
+    if (scale >= 3.25)
+        return 3;
+    if (scale >= 2.5)
+        return 2;
+    return 1;
+}
+/**
+ * Tile wall-ring size for beach/farm/storage huts.
+ * Most styles use a square from scale brackets. The farm `stable` is a long
+ * barn whose mesh (×1.15 render scale) is wider than the scale bracket, so
+ * radiusX follows the mesh half-width (walls align with the visual ends).
+ * Z stays on the bracket so the south wall stays north of horse-pen gates.
+ */
+export function buildingFootprintExtents(kind, scale, style) {
+    if (kind !== 'beachhut' && kind !== 'farmhut' && kind !== 'storagehut' && kind !== 'workshop') {
+        return { radiusX: 0, radiusZ: 0 };
+    }
+    if (typeof scale !== 'number' || !Number.isFinite(scale) || scale < 2) {
+        return { radiusX: 0, radiusZ: 0 };
+    }
+    const bracket = buildingScaleBracketRadius(scale);
+    if (kind === 'farmhut' && style === 'stable') {
+        const size = scale * FARMHUT_RENDER_SCALE;
+        const halfW = (STABLE_MESH_WIDTH * size) / 2;
+        // Hollow wall ring must sit on the visual end walls (not past them), or the
+        // mesh ends become walkable "interior" tiles.
+        const radiusX = Math.max(bracket, Math.ceil(halfW - 0.35));
+        return { radiusX, radiusZ: bracket };
+    }
+    return { radiusX: bracket, radiusZ: bracket };
+}
+/** West tack-room lean-to tiles beyond the stable's main wall ring. */
+export function visitStableLeanToBlockedOffsets(scale, visit) {
+    if (typeof scale !== 'number' || !Number.isFinite(scale) || scale < 2)
+        return;
+    const fp = buildingFootprintExtents('farmhut', scale, 'stable');
+    if (fp.radiusX <= 0 || fp.radiusZ <= 0)
+        return;
+    const size = scale * FARMHUT_RENDER_SCALE;
+    const leanReach = STABLE_LEAN_WIDTH * size * 0.75;
+    const leanTiles = Math.max(1, Math.ceil(leanReach - 0.2));
+    const halfDepth = Math.max(1, fp.radiusZ - 1);
+    for (let i = 1; i <= leanTiles; i++) {
+        for (let dz = -halfDepth; dz <= halfDepth; dz++) {
+            visit(-fp.radiusX - i, dz);
+        }
+    }
+}
+/** Max axis of {@link buildingFootprintExtents} (square buildings: the ring radius). */
+export function buildingFootprintRadius(kind, scale, style) {
+    const { radiusX, radiusZ } = buildingFootprintExtents(kind, scale, style);
+    return Math.max(radiusX, radiusZ);
+}
+export function isBuildingDoorOffset(dx, dz, footprint, doorFacing = 'posZ') {
+    const { radiusX, radiusZ } = normalizeBuildingFootprint(footprint);
+    if (radiusX <= 0 || radiusZ <= 0)
+        return false;
+    if (doorFacing === 'posZ')
+        return dx === 0 && dz === radiusZ;
+    if (doorFacing === 'negZ')
+        return dx === 0 && dz === -radiusZ;
+    if (doorFacing === 'posX')
+        return dx === radiusX && dz === 0;
+    return dx === -radiusX && dz === 0;
+}
+export function buildingWallBlocksOffset(dx, dz, footprint, doorFacing = 'posZ') {
+    const { radiusX, radiusZ } = normalizeBuildingFootprint(footprint);
+    if (radiusX <= 0 || radiusZ <= 0)
+        return false;
+    if (Math.abs(dx) > radiusX || Math.abs(dz) > radiusZ)
+        return false;
+    const onWallRing = Math.abs(dx) === radiusX || Math.abs(dz) === radiusZ;
+    if (!onWallRing)
+        return false;
+    return !isBuildingDoorOffset(dx, dz, { radiusX, radiusZ }, doorFacing);
+}
+export function isBuildingInteriorOffset(dx, dz, footprint, doorFacing = 'posZ') {
+    const { radiusX, radiusZ } = normalizeBuildingFootprint(footprint);
+    if (radiusX <= 0 || radiusZ <= 0)
+        return false;
+    if (Math.abs(dx) > radiusX || Math.abs(dz) > radiusZ)
+        return false;
+    return !buildingWallBlocksOffset(dx, dz, { radiusX, radiusZ }, doorFacing);
+}
+export function boulderFootprintRadius(style, scale) {
+    if (style !== 'boulder')
+        return 0;
+    if (typeof scale !== 'number' || !Number.isFinite(scale) || scale < 1.6)
+        return 0;
+    // Boulder meshes span ~1.05*scale tiles; walkable centers sit at radius+1.
+    return Math.min(3, Math.max(1, Math.ceil(scale * 1.05 - 0.55)));
+}
+export function blockingFootprintRadius(kind, style, scale) {
+    if (kind === 'beachhut' || kind === 'farmhut' || kind === 'storagehut' || kind === 'workshop')
+        return 0;
+    if (kind === 'rock') {
+        if (style === 'boulder')
+            return boulderFootprintRadius(style, scale);
+        const s = typeof scale === 'number' && Number.isFinite(scale) ? scale : 1;
+        if (style === 'pebble')
+            return 0;
+        // Crags sit on blocked cliff tiles; one extra ring covers remaining overhang.
+        if (style === 'crag')
+            return s >= 1.6 ? 1 : 0;
+        if (s >= 2.2)
+            return 1;
+        return 0;
+    }
+    if (kind === 'tree') {
+        const s = typeof scale === 'number' && Number.isFinite(scale) ? scale : 1;
+        return s >= 1.35 ? 1 : 0;
+    }
+    if (kind === 'brokenpier' || kind === 'abandonedboat' || kind === 'ship')
+        return 1;
+    if (kind === 'fortwall' || kind === 'archertower')
+        return 0;
+    if (kind === 'fence' || kind === 'table' || kind === 'barbedwire' || kind === 'barricade') {
+        return 0;
+    }
+    // Imported decorative structures (silo, grain mill, pump windmill, water
+    // tower): sized well beyond one tile, so a bare centre block would leave
+    // players walking straight through the visible mesh. The stone grain mill
+    // (the tall "old windmill") is the largest (~9.5 tiles); the steel pump /
+    // silo / tower still need more than a 3×3 or you clip through the sails and tanks.
+    if (kind === 'grainmill')
+        return 4;
+    if (kind === 'silo' || kind === 'pumpwindmill' || kind === 'watertower')
+        return 3;
+    // Imported buildings (barn, chicken coop, stable): treated as solid
+    // exteriors, not the hollow-wall-ring-with-door system the procedural
+    // farmhut/beachhut/storagehut buildings use — nothing in the game requires
+    // walking inside these specifically (the stablemaster NPC already stands
+    // just outside the old stable's door, not in its interior).
+    if (kind === 'packbarn' || kind === 'packstable')
+        return 4;
+    if (kind === 'packcoop')
+        return 2;
+    // Sleeping / battlefield tents and goblin mudhuts are solid 5×5 (radius 2),
+    // matching map.ts claimTentFootprint. Hollow "great" craft tents keep the
+    // wall-ring carve-out from map generation instead of filling the hall.
+    if (kind === 'tent') {
+        if (typeof style === 'string' && style.includes('great'))
+            return 0;
+        return 2;
+    }
+    if (kind === 'mudhut')
+        return 2;
+    return 0;
+}
+const CAVE_ENTRANCE_FORWARD = 2;
+// The mesh's cliff/boulder backdrop (see caveEntrance.ts) renders several tiles
+// deep behind the doorway and out to the sides. Base Camp's original entrance
+// is dug into the mountain rim, so that backdrop happens to sit over terrain
+// that's already unwalkable — but forest animal dens and the dungeon exit use a
+// compact footprint so the tiny hole doesn't block a huge patch of woods.
+const CAVE_ENTRANCE_BACK = 4;
+const CAVE_ENTRANCE_HALF_WIDTH = 4;
+function caveEntranceFacing(style) {
+    if (style === 'goblin-return-north')
+        return { fx: 0, fz: -1, sx: 1, sz: 0 };
+    if (isGoblinCaveStyle(style))
+        return { fx: 1, fz: 0, sx: 0, sz: 1 };
+    const dir = style?.includes('west')
+        ? 'west'
+        : style?.includes('east')
+            ? 'east'
+            : style?.includes('north')
+                ? 'north'
+                : 'south';
+    if (dir === 'west')
+        return { fx: -1, fz: 0, sx: 0, sz: 1 };
+    if (dir === 'east')
+        return { fx: 1, fz: 0, sx: 0, sz: 1 };
+    if (dir === 'north')
+        return { fx: 0, fz: -1, sx: 1, sz: 0 };
+    return { fx: 0, fz: 1, sx: 1, sz: 0 };
+}
+export function isCaveTunnelExitStyle(style) {
+    return typeof style === 'string' && style.startsWith('exit');
+}
+export function isGoblinCaveStyle(style) {
+    return style === 'goblin-burrow' || style?.startsWith('goblin-return') === true;
+}
+/** Tiny animal-dug hole in the woods — not the Base Camp Suspicious hole. */
+export function isAnimalDenStyle(style) {
+    return typeof style === 'string' && style.startsWith('den-');
+}
+/** Crawl-out hole inside a forest den cavern. */
+export function isDenExitStyle(style) {
+    return typeof style === 'string' && style.startsWith('denexit');
+}
+export function caveEntranceApproachOffset(style) {
+    const { fx, fz } = caveEntranceFacing(style);
+    const compact = isCaveTunnelExitStyle(style) || isAnimalDenStyle(style) || isDenExitStyle(style) || isGoblinCaveStyle(style);
+    const dist = compact ? 2 : CAVE_ENTRANCE_FORWARD + 1;
+    return { dx: dist * fx, dz: dist * fz };
+}
+export function visitCaveEntranceBlockedOffsets(style, visit) {
+    if (style === 'goblin-return-north') {
+        for (let dx = -1; dx <= 1; dx++)
+            visit(dx, 0);
+        return;
+    }
+    if (style === 'goblin-return') {
+        visit(0, 0);
+        return;
+    }
+    if (style === 'goblin-burrow') {
+        // East-facing mountain shoulders, with a clear throat in front of the door.
+        for (let dx = -4; dx <= 2; dx++) {
+            for (let dz = -7; dz <= 7; dz++) {
+                if (dx <= 0 || Math.abs(dz) >= 2)
+                    visit(dx, dz);
+            }
+        }
+        return;
+    }
+    const { fx, fz, sx, sz } = caveEntranceFacing(style);
+    const den = isAnimalDenStyle(style);
+    const compact = isCaveTunnelExitStyle(style) || den || isDenExitStyle(style);
+    const forwardMax = compact ? 1 : CAVE_ENTRANCE_FORWARD;
+    const backMax = compact ? 0 : CAVE_ENTRANCE_BACK;
+    const halfW = den ? 2 : compact ? 1 : CAVE_ENTRANCE_HALF_WIDTH;
+    for (let forward = -backMax; forward <= forwardMax; forward++) {
+        for (let side = -halfW; side <= halfW; side++) {
+            visit(forward * fx + side * sx, forward * fz + side * sz);
+        }
+    }
+}
+export function visitBlockedWalkOffsets(kind, style, scale, visit, doorFacing = kind === 'storagehut' ? 'negZ' : 'posZ') {
+    if (!entityBlocksWalk(kind))
+        return;
+    if (kind === 'dungeondoor' && isGoblinPrisonDoorStyle(style)) {
+        // Unlocking is per character. Never remove shared collision for -ready.
+        for (let dz = -1; dz <= 1; dz++)
+            visit(0, dz);
+        return;
+    }
+    if (kind === 'dungeondoor' && style?.startsWith('goblin-gate')) {
+        // Personal passage: remains solid even when the viewer has earned -ready.
+        for (let dx = -3; dx <= 3; dx++)
+            visit(dx, 0);
+        return;
+    }
+    if (kind === 'caveentrance') {
+        visitCaveEntranceBlockedOffsets(style, visit);
+        return;
+    }
+    if (kind === 'fence' && isFenceGateStyle(style)) {
+        if (isOpenGateStyle(style))
+            return;
+        visitGatePassageOffsets(kind, style, visit);
+        return;
+    }
+    if (kind === 'ranchgate') {
+        if (isRanchGateOpen(style))
+            return;
+        visitGatePassageOffsets(kind, style, visit);
+        return;
+    }
+    const buildingFp = buildingFootprintExtents(kind, scale, style);
+    if (buildingFp.radiusX > 0 && buildingFp.radiusZ > 0) {
+        // Hollow buildings: only the wall ring is solid. The origin is interior
+        // floor — blocking it sealed the storage hut so you could never stand inside.
+        for (let dz = -buildingFp.radiusZ; dz <= buildingFp.radiusZ; dz++) {
+            for (let dx = -buildingFp.radiusX; dx <= buildingFp.radiusX; dx++) {
+                if (!buildingWallBlocksOffset(dx, dz, buildingFp, doorFacing))
+                    continue;
+                // Cottage is a walk-through: south porch door and north garden door.
+                if (kind === 'farmhut' &&
+                    style === 'cottage' &&
+                    isBuildingDoorOffset(dx, dz, buildingFp, 'negZ')) {
+                    continue;
+                }
+                visit(dx, dz);
+            }
+        }
+        if (kind === 'farmhut' && style === 'stable') {
+            visitStableLeanToBlockedOffsets(scale, visit);
+        }
+        return;
+    }
+    visit(0, 0);
+    const radius = blockingFootprintRadius(kind, style, scale);
+    if (radius <= 0)
+        return;
+    for (let dz = -radius; dz <= radius; dz++) {
+        for (let dx = -radius; dx <= radius; dx++) {
+            if (dx === 0 && dz === 0)
+                continue;
+            visit(dx, dz);
+        }
+    }
+}
+export function isWalkable(tile) {
+    if (tile === TileType.Water)
+        return false;
+    return (tile === TileType.Grass ||
+        tile === TileType.Path ||
+        tile === TileType.Sand ||
+        tile === TileType.Ash);
+}
+//# sourceMappingURL=constants.js.map