BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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