BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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