BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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