BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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