/** * Generic neighbor-connect autotile masks (N/E/S/W). * Stored as block/ground `state` for bakeable sprite variants. * * - Cardinal numeric (tables/fences/counters): `"0"`…`"15"` (or `pine-3` with material). * - Named cardinal (stone walls): `"thick-stone-wall"`, `"thick-stone-wall-esw"`, … */ export const NeighborBit = Object.freeze({ n: 1, e: 2, s: 4, w: 8 }); export const NEIGHBOR_CONNECT_MASK_COUNT = 16; export function neighborConnectMask ({ n = false, e = false, s = false, w = false } = {}) { return (n ? NeighborBit.n : 0) | (e ? NeighborBit.e : 0) | (s ? NeighborBit.s : 0) | (w ? NeighborBit.w : 0); } export function neighborConnectStateName (mask) { return String((mask | 0) & 15); } /** * Cardinal connection suffix for named wall sprites. * Opposite runs: `ns`, `we`. Three-ways clockwise from the side after the gap * (`esw` = T open north, `wne` = T open south). Full: `nesw`. Alone: `""`. */ export function cardinalConnectionSuffix (mask) { const m = (mask | 0) & 15; if (m === 0) { return ""; } const n = (m & NeighborBit.n) !== 0; const e = (m & NeighborBit.e) !== 0; const s = (m & NeighborBit.s) !== 0; const w = (m & NeighborBit.w) !== 0; const count = (n ? 1 : 0) + (e ? 1 : 0) + (s ? 1 : 0) + (w ? 1 : 0); if (count === 1) { if (n) { return "n"; } if (e) { return "e"; } if (s) { return "s"; } return "w"; } if (count === 2) { if (n && s) { return "ns"; } if (e && w) { return "we"; } if (n && e) { return "ne"; } if (e && s) { return "es"; } if (s && w) { return "sw"; } return "wn"; } if (count === 3) { const bits = [NeighborBit.n, NeighborBit.e, NeighborBit.s, NeighborBit.w]; const letters = ["n", "e", "s", "w"]; let miss = 0; for (let i = 0; i < 4; i++) { if ((m & bits[i]) === 0) { miss = i; } } return letters[(miss + 1) % 4] + letters[(miss + 2) % 4] + letters[(miss + 3) % 4]; } return "nesw"; } export function composeNamedNeighborConnectState (def, mask) { const key = def?.key ?? "block"; const suffix = cardinalConnectionSuffix(mask); return suffix ? `${key}-${suffix}` : key; } /** Parse named (`thick-stone-wall-esw`) or bare (`esw`) or legacy numeric states. */ export function parseNamedNeighborConnectMask (state, def = null) { const s = String(state ?? "").trim().toLowerCase(); if (!s) { return 0; } if (/^\d+$/.test(s)) { // Legacy numeric masks may include old diagonal bits (e.g. 19 = N|E|NE). // Keep only cardinals — do not clamp with min(15,n) (that turns 19 into 15/nesw). return (Number(s) | 0) & 15; } const key = String(def?.key ?? "").toLowerCase(); if (key && s === key) { return 0; } let suffix = s; if (key && s.startsWith(`${key}-`)) { suffix = s.slice(key.length + 1); } let mask = 0; for (const ch of suffix) { if (ch === "n") { mask |= NeighborBit.n; } else if (ch === "e") { mask |= NeighborBit.e; } else if (ch === "s") { mask |= NeighborBit.s; } else if (ch === "w") { mask |= NeighborBit.w; } } return mask; } export function parseNeighborConnectMask (state) { if (state == null || state === "") { return 0; } const n = Number(state); if (!Number.isFinite(n)) { return 0; } return (n | 0) & 15; } export function hasNeighborBit (mask, bit) { return ((mask | 0) & bit) !== 0; } /** Cardinal offsets in tile space (y increases south in this project). */ export const NEIGHBOR_CARDINALS = Object.freeze([ Object.freeze({ bit: NeighborBit.n, dx: 0, dy: -1, key: "n" }), Object.freeze({ bit: NeighborBit.e, dx: 1, dy: 0, key: "e" }), Object.freeze({ bit: NeighborBit.s, dx: 0, dy: 1, key: "s" }), Object.freeze({ bit: NeighborBit.w, dx: -1, dy: 0, key: "w" }) ]); /** * @param {(dx: number, dy: number) => boolean} isConnectedNeighbor */ export function computeNeighborConnectMask (isConnectedNeighbor) { let mask = 0; for (const dir of NEIGHBOR_CARDINALS) { if (isConnectedNeighbor(dir.dx, dir.dy)) { mask |= dir.bit; } } return mask; } export function definitionUsesNeighborConnect (def) { return !!def?.neighborConnect; } export function definitionUsesNamedNeighborConnect (def) { return !!def?.neighborConnect && !!def?.neighborConnectNamed; } export function definitionUsesMaterialNeighborConnect (def) { return !!def?.neighborConnect && !!def?.neighborConnectByMaterial; } function clampCardinalMask (value) { const n = Number(value); if (!Number.isFinite(n)) { return 0; } return (n | 0) & 15; } /** * Tables (and similar) store `${material}-${mask}` e.g. `pine-3`. * Plain masks (`"7"`) stay valid for counters. */ export function parseMaterialNeighborConnectState (state, def = null) { const fallback = def?.defaultNeighborMaterial ?? "pine"; const s = String(state ?? "").trim(); const paired = /^([a-z][a-z0-9]*)-(\d+)$/i.exec(s); if (paired) { return { material: paired[1].toLowerCase(), mask: clampCardinalMask(paired[2]) }; } if (/^\d+$/.test(s)) { return { material: fallback, mask: clampCardinalMask(s) }; } if (/^[a-z][a-z0-9]*$/i.test(s)) { return { material: s.toLowerCase(), mask: 0 }; } return { material: fallback, mask: 0 }; } export function composeNeighborConnectState (def, currentState, mask) { const m = clampCardinalMask(mask); if (definitionUsesMaterialNeighborConnect(def)) { const { material } = parseMaterialNeighborConnectState(currentState, def); return `${material}-${m}`; } if (definitionUsesNamedNeighborConnect(def)) { return composeNamedNeighborConnectState(def, m); } return neighborConnectStateName(m); } /** True when two blocks should join for neighbor-connect (same type; same material if required). */ export function neighborConnectBlocksMatch (self, neighbor, def) { if (!self || !neighbor || (self.typeId | 0) !== (neighbor.typeId | 0)) { return false; } if (!definitionUsesMaterialNeighborConnect(def)) { return true; } const a = parseMaterialNeighborConnectState(self.state, def).material; const b = parseMaterialNeighborConnectState(neighbor.state, def).material; return a === b; } /** Resolve the visual mask from any neighbor-connect state string. */ export function parseNeighborConnectMaskFromState (state, def = null) { if (definitionUsesMaterialNeighborConnect(def)) { return parseMaterialNeighborConnectState(state, def).mask; } if (definitionUsesNamedNeighborConnect(def)) { return parseNamedNeighborConnectMask(state, def); } return parseNeighborConnectMask(state); } /** * Map a world tile to chunk coords + local tile (handles negative world tiles). */ export function worldTileToChunkLocal (tileX, tileY, chunkSize = 16) { const size = Math.max(1, chunkSize | 0 || 16); const chunkX = Math.floor(tileX / size); const chunkY = Math.floor(tileY / size); return { chunkX, chunkY, localX: tileX - chunkX * size, localY: tileY - chunkY * size }; } /** Self + cardinal neighbors in world tile space (for connect mask refresh). */ export function neighborConnectRefreshTiles (tileX, tileY) { return [ [tileX, tileY], [tileX, tileY - 1], [tileX + 1, tileY], [tileX, tileY + 1], [tileX - 1, tileY] ]; }