/** * Generic neighbor-connect autotile masks (N/E/S/W, optional diagonals). * Stored as block/ground `state` string for bakeable sprite variants. * * Cardinal-only types (tables, fences): mask `"0"`…`"15"`. * Corner-aware types (stone walls): also set NE/SE/SW/NW when both adjacent * cardinals join *and* the diagonal tile joins — distinguishes L-strip from solid 2×2. */ export const NeighborBit = Object.freeze({ n: 1, e: 2, s: 4, w: 8, ne: 16, se: 32, sw: 64, nw: 128 }); export const NEIGHBOR_CONNECT_MASK_COUNT = 16; export const NEIGHBOR_CONNECT_CORNER_MASK_MAX = 255; export function neighborConnectMask ({ n = false, e = false, s = false, w = false, ne = false, se = false, sw = false, nw = false } = {}) { return (n ? NeighborBit.n : 0) | (e ? NeighborBit.e : 0) | (s ? NeighborBit.s : 0) | (w ? NeighborBit.w : 0) | (ne ? NeighborBit.ne : 0) | (se ? NeighborBit.se : 0) | (sw ? NeighborBit.sw : 0) | (nw ? NeighborBit.nw : 0); } export function neighborConnectStateName (mask) { const m = Math.max(0, Math.min(NEIGHBOR_CONNECT_CORNER_MASK_MAX, 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(NEIGHBOR_CONNECT_CORNER_MASK_MAX, 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" }) ]); /** * Diagonal offsets. A diagonal bit is only meaningful when both adjacent * cardinals are also connected (blob / “47-tile” corner fill). */ export const NEIGHBOR_DIAGONALS = Object.freeze([ Object.freeze({ bit: NeighborBit.ne, dx: 1, dy: -1, key: "ne", needA: NeighborBit.n, needB: NeighborBit.e }), Object.freeze({ bit: NeighborBit.se, dx: 1, dy: 1, key: "se", needA: NeighborBit.s, needB: NeighborBit.e }), Object.freeze({ bit: NeighborBit.sw, dx: -1, dy: 1, key: "sw", needA: NeighborBit.s, needB: NeighborBit.w }), Object.freeze({ bit: NeighborBit.nw, dx: -1, dy: -1, key: "nw", needA: NeighborBit.n, needB: NeighborBit.w }) ]); /** * @param {(dx: number, dy: number) => boolean} isConnectedNeighbor * true when the adjacent tile should join (same connectable type). * @param {{ corners?: boolean }} [options] * when `corners`, also sample diagonals (only set if both cardinals join). */ export function computeNeighborConnectMask (isConnectedNeighbor, options = {}) { let mask = 0; for (const dir of NEIGHBOR_CARDINALS) { if (isConnectedNeighbor(dir.dx, dir.dy)) { mask |= dir.bit; } } if (options.corners) { for (const dir of NEIGHBOR_DIAGONALS) { if ((mask & dir.needA) === 0 || (mask & dir.needB) === 0) { continue; } if (isConnectedNeighbor(dir.dx, dir.dy)) { mask |= dir.bit; } } } return mask; } /** * All valid blob masks: every cardinal combo, with each relevant corner free or filled. * Yields 47 values (classic blob tileset). */ export function listValidNeighborConnectCornerMasks () { const out = []; for (let cardinal = 0; cardinal < NEIGHBOR_CONNECT_MASK_COUNT; cardinal++) { const cornerBits = []; for (const dir of NEIGHBOR_DIAGONALS) { if ((cardinal & dir.needA) && (cardinal & dir.needB)) { cornerBits.push(dir.bit); } } const n = cornerBits.length; for (let subset = 0; subset < (1 << n); subset++) { let mask = cardinal; for (let i = 0; i < n; i++) { if (subset & (1 << i)) { mask |= cornerBits[i]; } } out.push(mask); } } return out; } export function definitionUsesNeighborConnect (def) { return !!def?.neighborConnect; } export function definitionUsesNeighborConnectCorners (def) { return !!def?.neighborConnect && !!def?.neighborConnectCorners; } export function definitionUsesMaterialNeighborConnect (def) { return !!def?.neighborConnect && !!def?.neighborConnectByMaterial; } function clampCardinalMask (value) { const n = Number(value); if (!Number.isFinite(n)) { return 0; } return Math.max(0, Math.min(15, n | 0)); } function clampMaskForDef (value, def) { const n = Number(value); if (!Number.isFinite(n)) { return 0; } const max = definitionUsesNeighborConnectCorners(def) ? NEIGHBOR_CONNECT_CORNER_MASK_MAX : 15; return Math.max(0, Math.min(max, n | 0)); } /** * Tables (and similar) store `${material}-${mask}` e.g. `pine-3`. * Plain masks (`"7"`) stay valid for counters / walls. */ 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 = clampMaskForDef(mask, def); 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); } /** * Map a world tile to chunk coords + local tile (handles negative world tiles). * @param {number} tileX * @param {number} tileY * @param {number} [chunkSize=16] */ 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 (and diagonals when `corners`) in world tile space. * @param {number} tileX * @param {number} tileY * @param {{ corners?: boolean }} [options] */ export function neighborConnectRefreshTiles (tileX, tileY, options = {}) { const tiles = [ [tileX, tileY], [tileX, tileY - 1], [tileX + 1, tileY], [tileX, tileY + 1], [tileX - 1, tileY] ]; if (options.corners) { tiles.push( [tileX + 1, tileY - 1], [tileX + 1, tileY + 1], [tileX - 1, tileY + 1], [tileX - 1, tileY - 1] ); } return tiles; }