BlueGit

timfa questward

Files

questward / shared / world / neighborConnect.js

neighborConnect.js

neighborConnect.js 7.4 KiB Download Raw
1/**
2 * Generic neighbor-connect autotile masks (N/E/S/W, optional diagonals).
3 * Stored as block/ground `state` string for bakeable sprite variants.
4 *
5 * Cardinal-only types (tables, fences): mask `"0"`…`"15"`.
6 * Corner-aware types (stone walls): also set NE/SE/SW/NW when both adjacent
7 * cardinals join *and* the diagonal tile joins — distinguishes L-strip from solid 2×2.
8 */
9
10export const NeighborBit = Object.freeze({
11 n: 1,
12 e: 2,
13 s: 4,
14 w: 8,
15 ne: 16,
16 se: 32,
17 sw: 64,
18 nw: 128
19});
20
21export const NEIGHBOR_CONNECT_MASK_COUNT = 16;
22export const NEIGHBOR_CONNECT_CORNER_MASK_MAX = 255;
23
24export function neighborConnectMask ({
25 n = false,
26 e = false,
27 s = false,
28 w = false,
29 ne = false,
30 se = false,
31 sw = false,
32 nw = false
33} = {})
34{
35 return (n ? NeighborBit.n : 0)
36 | (e ? NeighborBit.e : 0)
37 | (s ? NeighborBit.s : 0)
38 | (w ? NeighborBit.w : 0)
39 | (ne ? NeighborBit.ne : 0)
40 | (se ? NeighborBit.se : 0)
41 | (sw ? NeighborBit.sw : 0)
42 | (nw ? NeighborBit.nw : 0);
43}
44
45export function neighborConnectStateName (mask)
46{
47 const m = Math.max(0, Math.min(NEIGHBOR_CONNECT_CORNER_MASK_MAX, mask | 0));
48 return String(m);
49}
50
51export function parseNeighborConnectMask (state)
52{
53 if (state == null || state === "")
54 { return 0; }
55 const n = Number(state);
56 if (!Number.isFinite(n))
57 { return 0; }
58 return Math.max(0, Math.min(NEIGHBOR_CONNECT_CORNER_MASK_MAX, n | 0));
59}
60
61export function hasNeighborBit (mask, bit)
62{
63 return ((mask | 0) & bit) !== 0;
64}
65
66/** Cardinal offsets in tile space (y increases south in this project). */
67export const NEIGHBOR_CARDINALS = Object.freeze([
68 Object.freeze({ bit: NeighborBit.n, dx: 0, dy: -1, key: "n" }),
69 Object.freeze({ bit: NeighborBit.e, dx: 1, dy: 0, key: "e" }),
70 Object.freeze({ bit: NeighborBit.s, dx: 0, dy: 1, key: "s" }),
71 Object.freeze({ bit: NeighborBit.w, dx: -1, dy: 0, key: "w" })
72]);
73
74/**
75 * Diagonal offsets. A diagonal bit is only meaningful when both adjacent
76 * cardinals are also connected (blob / “47-tile” corner fill).
77 */
78export const NEIGHBOR_DIAGONALS = Object.freeze([
79 Object.freeze({
80 bit: NeighborBit.ne, dx: 1, dy: -1, key: "ne",
81 needA: NeighborBit.n, needB: NeighborBit.e
82 }),
83 Object.freeze({
84 bit: NeighborBit.se, dx: 1, dy: 1, key: "se",
85 needA: NeighborBit.s, needB: NeighborBit.e
86 }),
87 Object.freeze({
88 bit: NeighborBit.sw, dx: -1, dy: 1, key: "sw",
89 needA: NeighborBit.s, needB: NeighborBit.w
90 }),
91 Object.freeze({
92 bit: NeighborBit.nw, dx: -1, dy: -1, key: "nw",
93 needA: NeighborBit.n, needB: NeighborBit.w
94 })
95]);
96
97/**
98 * @param {(dx: number, dy: number) => boolean} isConnectedNeighbor
99 * true when the adjacent tile should join (same connectable type).
100 * @param {{ corners?: boolean }} [options]
101 * when `corners`, also sample diagonals (only set if both cardinals join).
102 */
103export function computeNeighborConnectMask (isConnectedNeighbor, options = {})
104{
105 let mask = 0;
106 for (const dir of NEIGHBOR_CARDINALS)
107 {
108 if (isConnectedNeighbor(dir.dx, dir.dy))
109 { mask |= dir.bit; }
110 }
111 if (options.corners)
112 {
113 for (const dir of NEIGHBOR_DIAGONALS)
114 {
115 if ((mask & dir.needA) === 0 || (mask & dir.needB) === 0)
116 { continue; }
117 if (isConnectedNeighbor(dir.dx, dir.dy))
118 { mask |= dir.bit; }
119 }
120 }
121 return mask;
122}
123
124/**
125 * All valid blob masks: every cardinal combo, with each relevant corner free or filled.
126 * Yields 47 values (classic blob tileset).
127 */
128export function listValidNeighborConnectCornerMasks ()
129{
130 const out = [];
131 for (let cardinal = 0; cardinal < NEIGHBOR_CONNECT_MASK_COUNT; cardinal++)
132 {
133 const cornerBits = [];
134 for (const dir of NEIGHBOR_DIAGONALS)
135 {
136 if ((cardinal & dir.needA) && (cardinal & dir.needB))
137 { cornerBits.push(dir.bit); }
138 }
139 const n = cornerBits.length;
140 for (let subset = 0; subset < (1 << n); subset++)
141 {
142 let mask = cardinal;
143 for (let i = 0; i < n; i++)
144 {
145 if (subset & (1 << i))
146 { mask |= cornerBits[i]; }
147 }
148 out.push(mask);
149 }
150 }
151 return out;
152}
153
154export function definitionUsesNeighborConnect (def)
155{
156 return !!def?.neighborConnect;
157}
158
159export function definitionUsesNeighborConnectCorners (def)
160{
161 return !!def?.neighborConnect && !!def?.neighborConnectCorners;
162}
163
164export function definitionUsesMaterialNeighborConnect (def)
165{
166 return !!def?.neighborConnect && !!def?.neighborConnectByMaterial;
167}
168
169function clampCardinalMask (value)
170{
171 const n = Number(value);
172 if (!Number.isFinite(n))
173 { return 0; }
174 return Math.max(0, Math.min(15, n | 0));
175}
176
177function clampMaskForDef (value, def)
178{
179 const n = Number(value);
180 if (!Number.isFinite(n))
181 { return 0; }
182 const max = definitionUsesNeighborConnectCorners(def)
183 ? NEIGHBOR_CONNECT_CORNER_MASK_MAX
184 : 15;
185 return Math.max(0, Math.min(max, n | 0));
186}
187
188/**
189 * Tables (and similar) store `${material}-${mask}` e.g. `pine-3`.
190 * Plain masks (`"7"`) stay valid for counters / walls.
191 */
192export function parseMaterialNeighborConnectState (state, def = null)
193{
194 const fallback = def?.defaultNeighborMaterial ?? "pine";
195 const s = String(state ?? "").trim();
196 const paired = /^([a-z][a-z0-9]*)-(\d+)$/i.exec(s);
197 if (paired)
198 {
199 return {
200 material: paired[1].toLowerCase(),
201 mask: clampCardinalMask(paired[2])
202 };
203 }
204 if (/^\d+$/.test(s))
205 {
206 return { material: fallback, mask: clampCardinalMask(s) };
207 }
208 if (/^[a-z][a-z0-9]*$/i.test(s))
209 {
210 return { material: s.toLowerCase(), mask: 0 };
211 }
212 return { material: fallback, mask: 0 };
213}
214
215export function composeNeighborConnectState (def, currentState, mask)
216{
217 const m = clampMaskForDef(mask, def);
218 if (definitionUsesMaterialNeighborConnect(def))
219 {
220 const { material } = parseMaterialNeighborConnectState(currentState, def);
221 return `${material}-${m}`;
222 }
223 return neighborConnectStateName(m);
224}
225
226/** True when two blocks should join for neighbor-connect (same type; same material if required). */
227export function neighborConnectBlocksMatch (self, neighbor, def)
228{
229 if (!self || !neighbor || (self.typeId | 0) !== (neighbor.typeId | 0))
230 { return false; }
231 if (!definitionUsesMaterialNeighborConnect(def))
232 { return true; }
233 const a = parseMaterialNeighborConnectState(self.state, def).material;
234 const b = parseMaterialNeighborConnectState(neighbor.state, def).material;
235 return a === b;
236}
237
238/** Resolve the visual mask from any neighbor-connect state string. */
239export function parseNeighborConnectMaskFromState (state, def = null)
240{
241 if (definitionUsesMaterialNeighborConnect(def))
242 { return parseMaterialNeighborConnectState(state, def).mask; }
243 return parseNeighborConnectMask(state);
244}
245
246/**
247 * Map a world tile to chunk coords + local tile (handles negative world tiles).
248 * @param {number} tileX
249 * @param {number} tileY
250 * @param {number} [chunkSize=16]
251 */
252export function worldTileToChunkLocal (tileX, tileY, chunkSize = 16)
253{
254 const size = Math.max(1, chunkSize | 0 || 16);
255 const chunkX = Math.floor(tileX / size);
256 const chunkY = Math.floor(tileY / size);
257 return {
258 chunkX,
259 chunkY,
260 localX: tileX - chunkX * size,
261 localY: tileY - chunkY * size
262 };
263}
264
265/**
266 * Self + cardinal neighbors (and diagonals when `corners`) in world tile space.
267 * @param {number} tileX
268 * @param {number} tileY
269 * @param {{ corners?: boolean }} [options]
270 */
271export function neighborConnectRefreshTiles (tileX, tileY, options = {})
272{
273 const tiles = [
274 [tileX, tileY],
275 [tileX, tileY - 1],
276 [tileX + 1, tileY],
277 [tileX, tileY + 1],
278 [tileX - 1, tileY]
279 ];
280 if (options.corners)
281 {
282 tiles.push(
283 [tileX + 1, tileY - 1],
284 [tileX + 1, tileY + 1],
285 [tileX - 1, tileY + 1],
286 [tileX - 1, tileY - 1]
287 );
288 }
289 return tiles;
290}