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