BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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