BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

chunkData.js 8.5 KiB Download Raw
1import { CHUNK_SIZE, DEFAULT_WORLD_SETTINGS } from "../../../shared/protocol/constants.js";
2import {
3 BlockType,
4 GroundType,
5 isBlockPassable,
6 blockLightOcclusionForBlock,
7 LightOcclusion,
8 isGroundPassable,
9 blockBlocksRangedAttacks,
10 blockLightRange,
11 normalizeGround,
12 normalizeBlock
13} from "../../../shared/definitions/tiles.js";
14import { isDoorTraversable } from "../../../shared/world/doors.js";
15import { tileLightOcclusionAt, bakeChunkOcclusion, ensureChunkOcclusion } from "../../../shared/lighting/chunkOcclusion.js";
16import {
17 flowerBlockState,
18 flowerColorIdFromBlockState,
19 flowerColorIdForTile
20} from "../../../shared/definitions/dyes.js";
21import { normalizeSpawnerConfig } from "../../../shared/definitions/mobs.js";
22import { tileIndex } from "./coordinates.js";
23
24export function createEmptyChunkData (groundTypeId = DEFAULT_WORLD_SETTINGS.defaultGroundTypeId)
25{
26 const tileCount = CHUNK_SIZE * CHUNK_SIZE;
27 const grounds = new Array(tileCount).fill(null).map(() => normalizeGround(groundTypeId, groundTypeId));
28 const blocks = new Array(tileCount).fill(null);
29 const light = new Array(tileCount).fill(0);
30 return {
31 open: false,
32 grounds,
33 blocks,
34 light,
35 spawners: []
36 };
37}
38
39export function cloneChunkData (data)
40{
41 return {
42 open: data.open,
43 grounds: data.grounds.map((ground) => normalizeGround(ground)),
44 blocks: data.blocks.map((block) => structuredClone(normalizeBlock(block))),
45 light: data.light.slice(),
46 occlusion: ensureChunkOcclusion(data).slice(),
47 spawners: (data.spawners ?? []).map((entry) => normalizeSpawner(entry)).filter(Boolean)
48 };
49}
50
51export function encodeChunkBlob (data)
52{
53 const normalized = {
54 open: !!data.open,
55 grounds: data.grounds.map((ground) => normalizeGround(ground)),
56 blocks: data.blocks.map((block) => normalizeBlock(block)),
57 light: data.light,
58 spawners: (data.spawners ?? []).map((entry) => normalizeSpawner(entry)).filter(Boolean)
59 };
60 normalized.occlusion = bakeChunkOcclusion(normalized);
61 return JSON.stringify(normalized);
62}
63
64export function decodeChunkBlob (blob, groundTypeId = DEFAULT_WORLD_SETTINGS.defaultGroundTypeId, chunkX = 0, chunkY = 0)
65{
66 if (!blob)
67 { return createEmptyChunkData(groundTypeId); }
68
69 const parsed = typeof blob === "string" ? JSON.parse(blob) : blob;
70 const fallback = createEmptyChunkData(groundTypeId);
71 const tileCount = CHUNK_SIZE * CHUNK_SIZE;
72 const grounds = Array.isArray(parsed.grounds) ? parsed.grounds.slice(0, tileCount) : fallback.grounds;
73 const blocks = Array.isArray(parsed.blocks) ? parsed.blocks.slice(0, tileCount) : fallback.blocks.slice();
74 const light = Array.isArray(parsed.light) ? parsed.light.slice(0, tileCount) : fallback.light;
75 const occlusionRaw = Array.isArray(parsed.occlusion) ? parsed.occlusion.slice(0, tileCount) : null;
76
77 while (grounds.length < tileCount)
78 { grounds.push(normalizeGround(groundTypeId, groundTypeId)); }
79 while (blocks.length < tileCount)
80 { blocks.push(null); }
81 while (light.length < tileCount)
82 { light.push(0); }
83
84 const spawners = migrateLegacySpawners(blocks, Array.isArray(parsed.spawners) ? parsed.spawners : [], parsed);
85 const originX = (chunkX | 0) * CHUNK_SIZE;
86 const originY = (chunkY | 0) * CHUNK_SIZE;
87
88 const decoded = {
89 open: !!parsed.open,
90 grounds: grounds.map((ground) => normalizeGround(ground, groundTypeId)),
91 blocks: blocks.map((block, index) =>
92 {
93 const normalized = normalizeBlock(block);
94 if (normalized?.typeId === BlockType.spawner)
95 { return null; }
96 if (normalized?.typeId === BlockType.flower && !flowerColorIdFromBlockState(normalized.state))
97 {
98 const localX = index % CHUNK_SIZE;
99 const localY = (index / CHUNK_SIZE) | 0;
100 normalized.state = flowerBlockState(
101 flowerColorIdForTile(originX + localX, originY + localY)
102 );
103 }
104 return normalized;
105 }),
106 light,
107 spawners
108 };
109 decoded.occlusion = occlusionRaw?.length === tileCount
110 ? occlusionRaw.map((value) => value | 0)
111 : bakeChunkOcclusion(decoded);
112 return decoded;
113}
114
115export function normalizeSpawner (value)
116{
117 if (!value || !Number.isInteger(value.localX) || !Number.isInteger(value.localY))
118 { return null; }
119 if (value.localX < 0 || value.localY < 0 || value.localX >= CHUNK_SIZE || value.localY >= CHUNK_SIZE)
120 { return null; }
121 const config = value.config && typeof value.config === "object" ? value.config : {};
122 const spawnerId = typeof config.spawnerId === "string" && config.spawnerId
123 ? config.spawnerId
124 : `${value.localX},${value.localY}`;
125 return {
126 localX: value.localX,
127 localY: value.localY,
128 config: normalizeSpawnerConfig(config, spawnerId)
129 };
130}
131
132export function spawnerAt (data, localX, localY)
133{
134 return (data.spawners ?? []).find((entry) => entry.localX === localX && entry.localY === localY) ?? null;
135}
136
137export function setSpawner (data, localX, localY, config)
138{
139 if (!Array.isArray(data.spawners))
140 { data.spawners = []; }
141 const next = normalizeSpawner({ localX, localY, config });
142 data.spawners = data.spawners.filter((entry) => entry.localX !== localX || entry.localY !== localY);
143 if (next)
144 { data.spawners.push(next); }
145 return next;
146}
147
148export function clearSpawner (data, localX, localY)
149{
150 if (!Array.isArray(data.spawners))
151 { return; }
152 data.spawners = data.spawners.filter((entry) => entry.localX !== localX || entry.localY !== localY);
153}
154
155export function getTile (data, localX, localY)
156{
157 const index = tileIndex(localX, localY);
158 const ground = normalizeGround(data.grounds[index]);
159 return {
160 groundTypeId: ground.typeId,
161 groundState: ground.state,
162 block: data.blocks[index],
163 light: data.light[index],
164 spawner: spawnerAt(data, localX, localY)
165 };
166}
167
168export function setGround (data, localX, localY, groundTypeId, state = null)
169{
170 data.grounds[tileIndex(localX, localY)] = normalizeGround({ typeId: groundTypeId, state });
171}
172
173export function setBlock (data, localX, localY, block)
174{
175 data.blocks[tileIndex(localX, localY)] = normalizeBlock(block);
176}
177
178export function isChunkTilePassable (data, localX, localY, { canOpenDoors = false } = {})
179{
180 const index = tileIndex(localX, localY);
181 const ground = normalizeGround(data.grounds[index]);
182 if (!isGroundPassable(ground.typeId))
183 { return false; }
184 const block = data.blocks[index];
185 if (!block)
186 { return true; }
187 if ((block.typeId | 0) === BlockType.door)
188 { return isDoorTraversable(block, { canOpenDoors }); }
189 return isBlockPassable(block.typeId, block.state);
190}
191
192/** Light occlusion level for a chunk tile (ground impassable → solid). */
193export function chunkTileLightOcclusion (data, localX, localY)
194{
195 return tileLightOcclusionAt(data.grounds, data.blocks, localX, localY);
196}
197
198/** True when light rays are not solid-stopped (partial canopy still clears). */
199export function isChunkTileClearForLight (data, localX, localY)
200{
201 return chunkTileLightOcclusion(data, localX, localY) !== LightOcclusion.solid;
202}
203
204/** True when ranged attacks and spell casts may trace a ray through this tile. */
205export function isChunkTileClearForRangedAttacks (data, localX, localY)
206{
207 const index = tileIndex(localX, localY);
208 const ground = normalizeGround(data.grounds[index]);
209 if (!isGroundPassable(ground.typeId))
210 { return false; }
211 const block = data.blocks[index];
212 return !blockBlocksRangedAttacks(block?.typeId ?? null, block?.state ?? null);
213}
214
215export function collectLightSources (chunkX, chunkY, data)
216{
217 const sources = [];
218 for (let localY = 0; localY < CHUNK_SIZE; localY++)
219 {
220 for (let localX = 0; localX < CHUNK_SIZE; localX++)
221 {
222 const block = data.blocks[tileIndex(localX, localY)];
223 const range = blockLightRange(block?.typeId ?? null);
224 if (range > 0)
225 {
226 sources.push({
227 tileX: chunkX * CHUNK_SIZE + localX,
228 tileY: chunkY * CHUNK_SIZE + localY,
229 range
230 });
231 }
232 }
233 }
234 return sources;
235}
236
237function migrateLegacySpawners (blocks, authored, parsedHint)
238{
239 const byKey = new Map();
240 for (const entry of authored)
241 {
242 const normalized = normalizeSpawner(entry);
243 if (normalized)
244 { byKey.set(`${normalized.localX},${normalized.localY}`, normalized); }
245 }
246
247 for (let index = 0; index < blocks.length; index++)
248 {
249 const block = normalizeBlock(blocks[index]);
250 if (block?.typeId !== BlockType.spawner)
251 { continue; }
252 const localX = index % CHUNK_SIZE;
253 const localY = Math.floor(index / CHUNK_SIZE);
254 const key = `${localX},${localY}`;
255 if (!byKey.has(key))
256 {
257 const spawnerId = block.config?.spawnerId
258 ?? (parsedHint?.chunkX != null
259 ? `${parsedHint.chunkX}:${parsedHint.chunkY}:${index}`
260 : key);
261 byKey.set(key, normalizeSpawner({
262 localX,
263 localY,
264 config: { spawnerId, ...(block.config ?? {}) }
265 }));
266 }
267 blocks[index] = null;
268 }
269
270 return [...byKey.values()].filter(Boolean);
271}
272
273export { GroundType, normalizeGround, normalizeBlock };