/** * Generic neighbor-connect autotile masks (N/E/S/W). * Stored as block/ground `state` string `"0"`…`"15"` for bakeable sprite variants. * Same pattern can later apply to walls and selected grounds. */ 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) { const m = Math.max(0, Math.min(15, mask | 0)); return String(m); } export function parseNeighborConnectMask (state) { if (state == null || state === "") { return 0; } const n = Number(state); if (!Number.isFinite(n)) { return 0; } return Math.max(0, Math.min(15, n | 0)); } 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 * true when the adjacent tile should join (same connectable type). */ 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 definitionUsesMaterialNeighborConnect (def) { return !!def?.neighborConnect && !!def?.neighborConnectByMaterial; } function clampMask (value) { const n = Number(value); if (!Number.isFinite(n)) { return 0; } return Math.max(0, Math.min(15, n | 0)); } /** * 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: clampMask(paired[2]) }; } if (/^\d+$/.test(s)) { return { material: fallback, mask: clampMask(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 = clampMask(mask); if (definitionUsesMaterialNeighborConnect(def)) { const { material } = parseMaterialNeighborConnectState(currentState, def); return `${material}-${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; } return parseNeighborConnectMask(state); }