package com.chunkcleaner.mca; import com.chunkcleaner.ChunkCleanerPlugin; import com.chunkcleaner.tracker.ChunkKey; import java.io.*; import java.nio.file.Path; import java.util.*; import java.util.zip.GZIPInputStream; import java.util.zip.Inflater; import java.util.zip.DataFormatException; /** * Deletes chunks from Minecraft Anvil (.mca) region files by zeroing their * entries in the 8 KiB file header (locations table + timestamps table). * * MCA format overview: * Bytes 0–4095 : Location table — 1024 entries × 4 bytes * Each entry: [3-byte sector offset][1-byte sector count] * A zero entry means the chunk does not exist. * Bytes 4096–8191: Timestamp table — 1024 entries × 4 bytes * Bytes 8192+ : Chunk data in 4096-byte sectors * * Chunk index within a region = (chunkX & 31) + (chunkZ & 31) * 32 * * InhabitedTime NBT: * Every generated chunk stores a TAG_Long named "InhabitedTime" (1.18+) * or inside a "Level" compound (pre-1.18) counting cumulative ticks that * players have been nearby. This pre-dates any plugin installation and is * the authoritative source for historical dwell time. */ public class MCAChunkDeleter { private static final int LOCATION_TABLE_SIZE = 4096; private static final int HEADER_SIZE = 8192; private static final byte[] ZERO_ENTRY = new byte[4]; // NBT tag type constants private static final int TAG_END = 0; private static final int TAG_BYTE = 1; private static final int TAG_SHORT = 2; private static final int TAG_INT = 3; private static final int TAG_LONG = 4; private static final int TAG_FLOAT = 5; private static final int TAG_DOUBLE = 6; private static final int TAG_BYTE_ARRAY = 7; private static final int TAG_STRING = 8; private static final int TAG_LIST = 9; private static final int TAG_COMPOUND = 10; private static final int TAG_INT_ARRAY = 11; private static final int TAG_LONG_ARRAY = 12; private final ChunkCleanerPlugin plugin; public MCAChunkDeleter(ChunkCleanerPlugin plugin) { this.plugin = plugin; } // ========================================================================= // Deletion // ========================================================================= /** * Deletes all specified chunks from the MCA files of the given world directory. * * @param worldFolder the world's root folder (e.g., plugins/../world) * @param dimensionPath region sub-path relative to worldFolder (e.g., "region" or "DIM-1/region") * @param chunks list of [chunkX, chunkZ] pairs to delete * @return number of chunks successfully deleted */ public int deleteChunks(File worldFolder, String dimensionPath, List chunks) { Map> byRegion = new HashMap<>(); for (long[] coord : chunks) { int chunkX = (int) coord[0]; int chunkZ = (int) coord[1]; int regionX = Math.floorDiv(chunkX, 32); int regionZ = Math.floorDiv(chunkZ, 32); long regionKey = ((long) regionX << 32) | (regionZ & 0xFFFFFFFFL); byRegion.computeIfAbsent(regionKey, k -> new ArrayList<>()).add(coord); } File regionDir = new File(worldFolder, dimensionPath); if (!regionDir.exists()) { plugin.getLogger().warning("Region directory not found: " + regionDir.getPath()); return 0; } int deleted = 0; for (Map.Entry> entry : byRegion.entrySet()) { long regionKey = entry.getKey(); int regionX = (int) (regionKey >> 32); int regionZ = (int) (regionKey & 0xFFFFFFFFL); File mcaFile = new File(regionDir, "r." + regionX + "." + regionZ + ".mca"); if (!mcaFile.exists()) { deleted += entry.getValue().size(); continue; } deleted += deleteChunksFromRegionFile(mcaFile, entry.getValue()); } return deleted; } private int deleteChunksFromRegionFile(File mcaFile, List chunks) { int deleted = 0; boolean deleteEntireFile = false; try (RandomAccessFile raf = new RandomAccessFile(mcaFile, "rw")) { if (raf.length() < HEADER_SIZE) return 0; // Read the full location and timestamp tables byte[] locationTable = new byte[LOCATION_TABLE_SIZE]; byte[] timestampTable = new byte[LOCATION_TABLE_SIZE]; raf.seek(0); raf.readFully(locationTable); raf.readFully(timestampTable); // Build a set of local indices to delete Set toDelete = new HashSet<>(); for (long[] coord : chunks) { int chunkX = (int) coord[0]; int chunkZ = (int) coord[1]; int localX = ((chunkX % 32) + 32) % 32; int localZ = ((chunkZ % 32) + 32) % 32; toDelete.add(localX + localZ * 32); } record SectorEntry(int index, int sectorOffset, int sectorCount) {} List surviving = new ArrayList<>(); for (int i = 0; i < 1024; i++) { int b0 = locationTable[i * 4] & 0xFF; int b1 = locationTable[i * 4 + 1] & 0xFF; int b2 = locationTable[i * 4 + 2] & 0xFF; int b3 = locationTable[i * 4 + 3] & 0xFF; int sectorOffset = (b0 << 16) | (b1 << 8) | b2; int sectorCount = b3; if (sectorOffset == 0 && sectorCount == 0) continue; if (toDelete.contains(i)) { locationTable[i * 4] = 0; locationTable[i * 4 + 1] = 0; locationTable[i * 4 + 2] = 0; locationTable[i * 4 + 3] = 0; timestampTable[i * 4] = 0; timestampTable[i * 4 + 1] = 0; timestampTable[i * 4 + 2] = 0; timestampTable[i * 4 + 3] = 0; deleted++; } else { surviving.add(new SectorEntry(i, sectorOffset, sectorCount)); } } if (surviving.isEmpty()) { // Signal to delete the whole file after the RAF is closed deleteEntireFile = true; } else { // Compact: repack surviving sectors contiguously starting at sector 2 surviving.sort(Comparator.comparingInt(SectorEntry::sectorOffset)); int nextSector = 2; for (SectorEntry entry : surviving) { long srcByte = (long) entry.sectorOffset() * 4096; int byteLen = entry.sectorCount() * 4096; long destByte = (long) nextSector * 4096; if (srcByte != destByte) { byte[] data = new byte[byteLen]; raf.seek(srcByte); raf.readFully(data); raf.seek(destByte); raf.write(data); } locationTable[entry.index() * 4] = (byte) ((nextSector >> 16) & 0xFF); locationTable[entry.index() * 4 + 1] = (byte) ((nextSector >> 8) & 0xFF); locationTable[entry.index() * 4 + 2] = (byte) ( nextSector & 0xFF); nextSector += entry.sectorCount(); } raf.seek(0); raf.write(locationTable); raf.write(timestampTable); raf.setLength((long) nextSector * 4096); } } catch (IOException e) { plugin.getLogger().severe("Error compacting " + mcaFile.getName() + ": " + e.getMessage()); return deleted; } if (deleteEntireFile) { mcaFile.delete(); if (plugin.getConfig().getBoolean("verbose", false)) { plugin.getLogger().info("[Delete] Region file removed entirely: " + mcaFile.getName()); } } return deleted; } // ========================================================================= // MCA existence check // ========================================================================= public boolean chunkExistsInMCA(File worldFolder, String dimensionPath, int chunkX, int chunkZ) { int regionX = Math.floorDiv(chunkX, 32); int regionZ = Math.floorDiv(chunkZ, 32); File mcaFile = new File(worldFolder, dimensionPath + "/r." + regionX + "." + regionZ + ".mca"); if (!mcaFile.exists()) return false; int localX = ((chunkX % 32) + 32) % 32; int localZ = ((chunkZ % 32) + 32) % 32; int index = localX + localZ * 32; try (RandomAccessFile raf = new RandomAccessFile(mcaFile, "r")) { raf.seek(index * 4); return raf.readInt() != 0; } catch (IOException e) { return false; } } public List getAllExistingChunks(File worldFolder, String dimensionPath) { File regionDir = new File(worldFolder, dimensionPath); if (!regionDir.exists()) return Collections.emptyList(); List result = new ArrayList<>(); File[] mcaFiles = regionDir.listFiles((dir, name) -> name.endsWith(".mca")); if (mcaFiles == null) return Collections.emptyList(); for (File mcaFile : mcaFiles) { String name = mcaFile.getName(); String[] parts = name.replace("r.", "").replace(".mca", "").split("\\."); if (parts.length != 2) continue; try { int regionX = Integer.parseInt(parts[0]); int regionZ = Integer.parseInt(parts[1]); readExistingChunksFromRegion(mcaFile, regionX, regionZ, result); } catch (NumberFormatException ignored) {} } return result; } private void readExistingChunksFromRegion(File mcaFile, int regionX, int regionZ, List out) { try (RandomAccessFile raf = new RandomAccessFile(mcaFile, "r")) { if (raf.length() < HEADER_SIZE) return; byte[] header = new byte[LOCATION_TABLE_SIZE]; raf.readFully(header); for (int i = 0; i < 1024; i++) { int b0 = header[i * 4] & 0xFF; int b1 = header[i * 4 + 1] & 0xFF; int b2 = header[i * 4 + 2] & 0xFF; int b3 = header[i * 4 + 3] & 0xFF; int offset = (b0 << 16) | (b1 << 8) | b2; int sectorCount = b3; if (offset == 0 && sectorCount == 0) continue; int localX = i % 32; int localZ = i / 32; int chunkX = regionX * 32 + localX; int chunkZ = regionZ * 32 + localZ; out.add(new long[]{chunkX, chunkZ}); } } catch (IOException e) { // Skip unreadable files silently } } // ========================================================================= // InhabitedTime scanning // ========================================================================= /** * Scans all MCA files in the given dimension and returns a map from * ChunkKey-encoded long → InhabitedTime ticks for every generated chunk. * * Minecraft natively maintains InhabitedTime for the full lifetime of a * chunk, so this covers all history before the plugin was installed. */ public Map getAllInhabitedTicks(File worldFolder, String dimensionPath) { File regionDir = new File(worldFolder, dimensionPath); if (!regionDir.exists()) return Collections.emptyMap(); File[] mcaFiles = regionDir.listFiles((dir, name) -> name.endsWith(".mca")); if (mcaFiles == null) return Collections.emptyMap(); Map result = new HashMap<>(); for (File mcaFile : mcaFiles) { String name = mcaFile.getName(); String[] parts = name.replace("r.", "").replace(".mca", "").split("\\."); if (parts.length != 2) continue; try { int regionX = Integer.parseInt(parts[0]); int regionZ = Integer.parseInt(parts[1]); readInhabitedTicksFromRegion(mcaFile, regionX, regionZ, result); } catch (NumberFormatException ignored) {} } return result; } /** * Returns the InhabitedTime ticks for one specific chunk from its MCA file, * or -1 if the chunk doesn't exist or cannot be read. */ public long getInhabitedTicks(File worldFolder, String dimensionPath, int chunkX, int chunkZ) { int regionX = Math.floorDiv(chunkX, 32); int regionZ = Math.floorDiv(chunkZ, 32); File mcaFile = new File(worldFolder, dimensionPath + "/r." + regionX + "." + regionZ + ".mca"); if (!mcaFile.exists()) return -1; int localX = ((chunkX % 32) + 32) % 32; int localZ = ((chunkZ % 32) + 32) % 32; int index = localX + localZ * 32; try (RandomAccessFile raf = new RandomAccessFile(mcaFile, "r")) { return readInhabitedTicksAtIndex(raf, index); } catch (IOException e) { return -1; } } private void readInhabitedTicksFromRegion(File mcaFile, int regionX, int regionZ, Map out) { try (RandomAccessFile raf = new RandomAccessFile(mcaFile, "r")) { if (raf.length() < HEADER_SIZE) return; // Read location table upfront to know which slots are populated byte[] locationTable = new byte[LOCATION_TABLE_SIZE]; raf.readFully(locationTable); for (int i = 0; i < 1024; i++) { int b0 = locationTable[i * 4] & 0xFF; int b1 = locationTable[i * 4 + 1] & 0xFF; int b2 = locationTable[i * 4 + 2] & 0xFF; int b3 = locationTable[i * 4 + 3] & 0xFF; int sectorOffset = (b0 << 16) | (b1 << 8) | b2; int sectorCount = b3; if (sectorOffset == 0 && sectorCount == 0) continue; long ticks = readInhabitedTicksAtIndex(raf, i); if (ticks < 0) ticks = 0; int localX = i % 32; int localZ = i / 32; int chunkX = regionX * 32 + localX; int chunkZ = regionZ * 32 + localZ; out.put(ChunkKey.of(chunkX, chunkZ), ticks); } } catch (IOException e) { // Skip unreadable region files silently } } /** * Reads and decompresses a chunk's NBT data located at the given slot index * within an already-open MCA RandomAccessFile, then extracts InhabitedTime. */ private long readInhabitedTicksAtIndex(RandomAccessFile raf, int index) throws IOException { raf.seek((long) index * 4); int locationEntry = raf.readInt(); if (locationEntry == 0) return -1; int sectorOffset = (locationEntry >> 8) & 0xFFFFFF; raf.seek((long) sectorOffset * 4096); int dataLength = raf.readInt(); if (dataLength <= 1) return -1; int compressionType = raf.readByte() & 0xFF; byte[] compressed = new byte[dataLength - 1]; raf.readFully(compressed); byte[] nbtData = decompress(compressed, compressionType); if (nbtData == null) return -1; try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(nbtData))) { return parseInhabitedTime(dis); } catch (IOException e) { return -1; } } private byte[] decompress(byte[] data, int compressionType) { try { ByteArrayOutputStream baos = new ByteArrayOutputStream(data.length * 3); byte[] buf = new byte[8192]; if (compressionType == 2) { // zlib / deflate Inflater inflater = new Inflater(); inflater.setInput(data); while (!inflater.finished()) { int n; try { n = inflater.inflate(buf); } catch (DataFormatException e) { return null; } if (n == 0) break; baos.write(buf, 0, n); } inflater.end(); } else if (compressionType == 1) { // gzip try (GZIPInputStream gzip = new GZIPInputStream(new ByteArrayInputStream(data))) { int n; while ((n = gzip.read(buf)) != -1) baos.write(buf, 0, n); } } else { // compressionType 3 = uncompressed (since 24w04a) return data; } return baos.toByteArray(); } catch (IOException e) { return null; } } // ========================================================================= // Minimal NBT parser — only extracts InhabitedTime // ========================================================================= /** * Parses an NBT stream and returns the value of the first TAG_Long named * "InhabitedTime" found at the top level or inside a "Level" compound * (pre-1.18 format). Returns -1 if not found. */ private long parseInhabitedTime(DataInputStream dis) throws IOException { int type = dis.readUnsignedByte(); if (type != TAG_COMPOUND) return -1; skipNbtString(dis); // root compound has an (usually empty) name return scanCompoundForInhabitedTime(dis); } /** * Scans a TAG_Compound payload (already past its type+name) looking for * InhabitedTime. Handles one level of nesting for the pre-1.18 "Level" * compound. All other tags are skipped efficiently. */ private long scanCompoundForInhabitedTime(DataInputStream dis) throws IOException { while (true) { int type = dis.readUnsignedByte(); if (type == TAG_END) return -1; String name = readNbtString(dis); if (type == TAG_LONG && "InhabitedTime".equals(name)) { return dis.readLong(); } // Pre-1.18: InhabitedTime lives inside the "Level" compound if (type == TAG_COMPOUND && "Level".equals(name)) { long val = scanCompoundForInhabitedTime(dis); if (val >= 0) return val; // scanCompoundForInhabitedTime already consumed the compound continue; } skipNbtPayload(dis, type); } } private void skipNbtPayload(DataInputStream dis, int type) throws IOException { switch (type) { case TAG_BYTE -> dis.skipBytes(1); case TAG_SHORT -> dis.skipBytes(2); case TAG_INT -> dis.skipBytes(4); case TAG_LONG -> dis.skipBytes(8); case TAG_FLOAT -> dis.skipBytes(4); case TAG_DOUBLE -> dis.skipBytes(8); case TAG_BYTE_ARRAY -> dis.skipBytes(dis.readInt()); case TAG_STRING -> skipNbtString(dis); case TAG_INT_ARRAY -> dis.skipBytes(dis.readInt() * 4); case TAG_LONG_ARRAY -> dis.skipBytes(dis.readInt() * 8); case TAG_LIST -> { int elemType = dis.readUnsignedByte(); int elemCount = dis.readInt(); for (int i = 0; i < elemCount; i++) skipNbtPayload(dis, elemType); } case TAG_COMPOUND -> { // Skip entire nested compound int t; while ((t = dis.readUnsignedByte()) != TAG_END) { skipNbtString(dis); skipNbtPayload(dis, t); } } } } private String readNbtString(DataInputStream dis) throws IOException { int len = dis.readUnsignedShort(); byte[] bytes = new byte[len]; dis.readFully(bytes); return new String(bytes, java.nio.charset.StandardCharsets.UTF_8); } private void skipNbtString(DataInputStream dis) throws IOException { dis.skipBytes(dis.readUnsignedShort()); } }