import { CHUNK_SIZE, DEFAULT_WORLD_SETTINGS } from "../../../shared/protocol/constants.js"; import { BlockType, GroundType, isBlockPassable, blockLightOcclusionForBlock, LightOcclusion, isGroundPassable, blockBlocksRangedAttacks, blockLightRange, normalizeGround, normalizeBlock } from "../../../shared/definitions/tiles.js"; import { isDoorTraversable } from "../../../shared/world/doors.js"; import { tileLightOcclusionAt, bakeChunkOcclusion, ensureChunkOcclusion } from "../../../shared/lighting/chunkOcclusion.js"; import { flowerBlockState, flowerColorIdFromBlockState, flowerColorIdForTile } from "../../../shared/definitions/dyes.js"; import { normalizeSpawnerConfig } from "../../../shared/definitions/mobs.js"; import { tileIndex } from "./coordinates.js"; export function createEmptyChunkData (groundTypeId = DEFAULT_WORLD_SETTINGS.defaultGroundTypeId) { const tileCount = CHUNK_SIZE * CHUNK_SIZE; const grounds = new Array(tileCount).fill(null).map(() => normalizeGround(groundTypeId, groundTypeId)); const blocks = new Array(tileCount).fill(null); const light = new Array(tileCount).fill(0); return { open: false, grounds, blocks, light, spawners: [] }; } export function cloneChunkData (data) { return { open: data.open, grounds: data.grounds.map((ground) => normalizeGround(ground)), blocks: data.blocks.map((block) => structuredClone(normalizeBlock(block))), light: data.light.slice(), occlusion: ensureChunkOcclusion(data).slice(), spawners: (data.spawners ?? []).map((entry) => normalizeSpawner(entry)).filter(Boolean) }; } export function encodeChunkBlob (data) { const normalized = { open: !!data.open, grounds: data.grounds.map((ground) => normalizeGround(ground)), blocks: data.blocks.map((block) => normalizeBlock(block)), light: data.light, spawners: (data.spawners ?? []).map((entry) => normalizeSpawner(entry)).filter(Boolean) }; normalized.occlusion = bakeChunkOcclusion(normalized); return JSON.stringify(normalized); } export function decodeChunkBlob (blob, groundTypeId = DEFAULT_WORLD_SETTINGS.defaultGroundTypeId, chunkX = 0, chunkY = 0) { if (!blob) { return createEmptyChunkData(groundTypeId); } const parsed = typeof blob === "string" ? JSON.parse(blob) : blob; const fallback = createEmptyChunkData(groundTypeId); const tileCount = CHUNK_SIZE * CHUNK_SIZE; const grounds = Array.isArray(parsed.grounds) ? parsed.grounds.slice(0, tileCount) : fallback.grounds; const blocks = Array.isArray(parsed.blocks) ? parsed.blocks.slice(0, tileCount) : fallback.blocks.slice(); const light = Array.isArray(parsed.light) ? parsed.light.slice(0, tileCount) : fallback.light; const occlusionRaw = Array.isArray(parsed.occlusion) ? parsed.occlusion.slice(0, tileCount) : null; while (grounds.length < tileCount) { grounds.push(normalizeGround(groundTypeId, groundTypeId)); } while (blocks.length < tileCount) { blocks.push(null); } while (light.length < tileCount) { light.push(0); } const spawners = migrateLegacySpawners(blocks, Array.isArray(parsed.spawners) ? parsed.spawners : [], parsed); const originX = (chunkX | 0) * CHUNK_SIZE; const originY = (chunkY | 0) * CHUNK_SIZE; const decoded = { open: !!parsed.open, grounds: grounds.map((ground) => normalizeGround(ground, groundTypeId)), blocks: blocks.map((block, index) => { const normalized = normalizeBlock(block); if (normalized?.typeId === BlockType.spawner) { return null; } if (normalized?.typeId === BlockType.flower && !flowerColorIdFromBlockState(normalized.state)) { const localX = index % CHUNK_SIZE; const localY = (index / CHUNK_SIZE) | 0; normalized.state = flowerBlockState( flowerColorIdForTile(originX + localX, originY + localY) ); } return normalized; }), light, spawners }; decoded.occlusion = occlusionRaw?.length === tileCount ? occlusionRaw.map((value) => value | 0) : bakeChunkOcclusion(decoded); return decoded; } export function normalizeSpawner (value) { if (!value || !Number.isInteger(value.localX) || !Number.isInteger(value.localY)) { return null; } if (value.localX < 0 || value.localY < 0 || value.localX >= CHUNK_SIZE || value.localY >= CHUNK_SIZE) { return null; } const config = value.config && typeof value.config === "object" ? value.config : {}; const spawnerId = typeof config.spawnerId === "string" && config.spawnerId ? config.spawnerId : `${value.localX},${value.localY}`; return { localX: value.localX, localY: value.localY, config: normalizeSpawnerConfig(config, spawnerId) }; } export function spawnerAt (data, localX, localY) { return (data.spawners ?? []).find((entry) => entry.localX === localX && entry.localY === localY) ?? null; } export function setSpawner (data, localX, localY, config) { if (!Array.isArray(data.spawners)) { data.spawners = []; } const next = normalizeSpawner({ localX, localY, config }); data.spawners = data.spawners.filter((entry) => entry.localX !== localX || entry.localY !== localY); if (next) { data.spawners.push(next); } return next; } export function clearSpawner (data, localX, localY) { if (!Array.isArray(data.spawners)) { return; } data.spawners = data.spawners.filter((entry) => entry.localX !== localX || entry.localY !== localY); } export function getTile (data, localX, localY) { const index = tileIndex(localX, localY); const ground = normalizeGround(data.grounds[index]); return { groundTypeId: ground.typeId, groundState: ground.state, block: data.blocks[index], light: data.light[index], spawner: spawnerAt(data, localX, localY) }; } export function setGround (data, localX, localY, groundTypeId, state = null) { data.grounds[tileIndex(localX, localY)] = normalizeGround({ typeId: groundTypeId, state }); } export function setBlock (data, localX, localY, block) { data.blocks[tileIndex(localX, localY)] = normalizeBlock(block); } export function isChunkTilePassable (data, localX, localY, { canOpenDoors = false } = {}) { const index = tileIndex(localX, localY); const ground = normalizeGround(data.grounds[index]); if (!isGroundPassable(ground.typeId)) { return false; } const block = data.blocks[index]; if (!block) { return true; } if ((block.typeId | 0) === BlockType.door) { return isDoorTraversable(block, { canOpenDoors }); } return isBlockPassable(block.typeId, block.state); } /** Light occlusion level for a chunk tile (ground impassable → solid). */ export function chunkTileLightOcclusion (data, localX, localY) { return tileLightOcclusionAt(data.grounds, data.blocks, localX, localY); } /** True when light rays are not solid-stopped (partial canopy still clears). */ export function isChunkTileClearForLight (data, localX, localY) { return chunkTileLightOcclusion(data, localX, localY) !== LightOcclusion.solid; } /** True when ranged attacks and spell casts may trace a ray through this tile. */ export function isChunkTileClearForRangedAttacks (data, localX, localY) { const index = tileIndex(localX, localY); const ground = normalizeGround(data.grounds[index]); if (!isGroundPassable(ground.typeId)) { return false; } const block = data.blocks[index]; return !blockBlocksRangedAttacks(block?.typeId ?? null, block?.state ?? null); } export function collectLightSources (chunkX, chunkY, data) { const sources = []; for (let localY = 0; localY < CHUNK_SIZE; localY++) { for (let localX = 0; localX < CHUNK_SIZE; localX++) { const block = data.blocks[tileIndex(localX, localY)]; const range = blockLightRange(block?.typeId ?? null); if (range > 0) { sources.push({ tileX: chunkX * CHUNK_SIZE + localX, tileY: chunkY * CHUNK_SIZE + localY, range }); } } } return sources; } function migrateLegacySpawners (blocks, authored, parsedHint) { const byKey = new Map(); for (const entry of authored) { const normalized = normalizeSpawner(entry); if (normalized) { byKey.set(`${normalized.localX},${normalized.localY}`, normalized); } } for (let index = 0; index < blocks.length; index++) { const block = normalizeBlock(blocks[index]); if (block?.typeId !== BlockType.spawner) { continue; } const localX = index % CHUNK_SIZE; const localY = Math.floor(index / CHUNK_SIZE); const key = `${localX},${localY}`; if (!byKey.has(key)) { const spawnerId = block.config?.spawnerId ?? (parsedHint?.chunkX != null ? `${parsedHint.chunkX}:${parsedHint.chunkY}:${index}` : key); byKey.set(key, normalizeSpawner({ localX, localY, config: { spawnerId, ...(block.config ?? {}) } })); } blocks[index] = null; } return [...byKey.values()].filter(Boolean); } export { GroundType, normalizeGround, normalizeBlock };