BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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