import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs"; import { dirname, join } from "node:path"; import { normalizeDimensionId } from "../../../shared/world/dimensions.js"; import { MINIMAP_CHUNK_PIXELS, MINIMAP_SPAN_CHUNKS, minimapRadius, renderChunkMinimapRgba } from "../../../shared/render/chunkMinimap.js"; import { decodeChunkBlob } from "../world/chunkData.js"; const RGBA_BYTES = MINIMAP_CHUNK_PIXELS * MINIMAP_CHUNK_PIXELS * 4; /** * Per-dimension minimap images, one uncompressed RGBA file per saved chunk. * * Lives under the server data directory next to `world.sqlite`: * `minimap//_.rgba` * (16×16×4 bytes while chunks are 16 tiles square). * * A file is written when that chunk is saved, and created on read when it is * missing but the chunk exists. Chunks with no row are drawn as empty by the * client and any stale file for them is removed. Changing sprite colours * (see `color-stamp.txt`) deletes every cached image so the next read rebuilds * them. The editor asks for a window of chunks; only cache misses load the * chunk blob. */ export class MinimapCache { constructor (rootDir, worldDb) { this.rootDir = rootDir; this.worldDb = worldDb; } pathFor (dimensionId, chunkX, chunkY) { const dim = normalizeDimensionId(dimensionId); return join(this.rootDir, dim, `${chunkX | 0}_${chunkY | 0}.rgba`); } /** * Drop cached images when the sprite-colour stamp changes (new or edited art). * @param {string} stamp */ syncColorStamp (stamp) { mkdirSync(this.rootDir, { recursive: true }); const file = join(this.rootDir, "color-stamp.txt"); const next = String(stamp ?? ""); let previous = null; try { previous = readFileSync(file, "utf8"); } catch { previous = null; } if (previous === next) { return; } let entries = []; try { entries = readdirSync(this.rootDir, { withFileTypes: true }); } catch { entries = []; } for (const entry of entries) { if (!entry.isDirectory()) { continue; } rmSync(join(this.rootDir, entry.name), { recursive: true, force: true }); } writeFileSync(file, next); } removeDimensions (dimensionIds) { for (const dimensionId of dimensionIds ?? []) { rmSync(join(this.rootDir, normalizeDimensionId(dimensionId)), { recursive: true, force: true }); } } /** * @param {string} dimensionId * @param {number} chunkX * @param {number} chunkY * @param {object} chunkData * @param {number} defaultGroundTypeId * @returns {Buffer} */ write (dimensionId, chunkX, chunkY, chunkData, defaultGroundTypeId) { const rgba = renderChunkMinimapRgba(chunkData, defaultGroundTypeId); const file = this.pathFor(dimensionId, chunkX, chunkY); mkdirSync(dirname(file), { recursive: true }); const buffer = Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength); writeFileSync(file, buffer); return buffer; } /** * @returns {Buffer | null} cached or freshly built image, or null when the chunk is not saved */ readOrCreate (dimensionId, chunkX, chunkY, revisionId, defaultGroundTypeId) { const file = this.pathFor(dimensionId, chunkX, chunkY); const cached = this.#readValid(file); const saved = this.worldDb.hasChunkVersion(chunkX, chunkY, revisionId, dimensionId); if (!saved) { if (cached) { unlinkSync(file); } return null; } if (cached) { return cached; } const row = this.worldDb.getChunkVersion(chunkX, chunkY, revisionId, dimensionId); if (!row) { return null; } const data = decodeChunkBlob(row.data_blob, defaultGroundTypeId, chunkX, chunkY); return this.write(dimensionId, chunkX, chunkY, data, defaultGroundTypeId); } /** * 25×25 chunk window centred on `centerChunkX` / `centerChunkY`. * Present chunks are raw RGBA, base64. Missing chunks are omitted. */ window (dimensionId, centerChunkX, centerChunkY, revisionId, defaultGroundTypeId) { const dim = normalizeDimensionId(dimensionId); const centerX = centerChunkX | 0; const centerY = centerChunkY | 0; const radius = minimapRadius(MINIMAP_SPAN_CHUNKS); const chunks = {}; for (let dy = -radius; dy <= radius; dy++) { for (let dx = -radius; dx <= radius; dx++) { const chunkX = centerX + dx; const chunkY = centerY + dy; try { const image = this.readOrCreate(dim, chunkX, chunkY, revisionId, defaultGroundTypeId); if (image) { chunks[`${chunkX},${chunkY}`] = image.toString("base64"); } } catch (error) { console.error( `[minimap] skipped ${dim} ${chunkX},${chunkY}:`, error?.message ?? error ); } } } return { dimensionId: dim, chunkX: centerX, chunkY: centerY, chunkPixels: MINIMAP_CHUNK_PIXELS, span: MINIMAP_SPAN_CHUNKS, chunks }; } #readValid (file) { if (!existsSync(file)) { return null; } const buffer = readFileSync(file); if (buffer.length !== RGBA_BYTES) { unlinkSync(file); return null; } return buffer; } }