BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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