BlueGit

timfa questward

Files

questward / server / src / world / chunkData.js

chunkData.js

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