# versions 2 revision 1

# version 2 revision 1

"{0} is not a directory or does not exist. World path is probably wrong."="{0} не є директорією або не існує. Скоріш за все, шлях до світу невірний."
"{0} is not a regular file."="{0} не є звичайним файлом."
"{0} is not writable for me. Cannot operate further."="Не можу записати в {0}. Припиняю роботу."

package ua.com.minersstudios.whomine.util.misc;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import lombok.RequiredArgsConstructor;
/**
 * Interface to communicate with region file in one way only.
 */
final class WorldRegion extends RandomAccessFile
{
	WorldRegion(File file, String mode) throws FileNotFoundException
	{
		super(file, mode);
	}
	WorldRegion(String name, String mode) throws FileNotFoundException
	{
		super(name, mode);
	}
	private final int fourKiBSector = 4096;
	// all in bytes.
	private final int offsetSize = 3;
	private final int timestampSize = 4;
	private final int lengthSize = 4;
	private final int sectorSizeStartsAfter = 3;
	private final int compressionTypeStartsAfter = 4;
	private final int dataStartsAfter = 5;
	/// Header
	// took from Minecraft wiki.
	private int locateChunkInsideHeader(final int x, final int z) { return 4 * ((x & 31) + (z & 31) * 32); }
	/**
	 * Read given chunk's offset inside the region file from the header of the file itself.
	 * @param x chunk longitude
	 * @param z chunk latitude
	 * @return chunk offset in 4 KiB sectors
	 */
	int getChunkOffset(final int x, final int z) throws IOException
	{
		byte[] rawChunkOffset = new byte[offsetSize];
		readFully(rawChunkOffset, rawChunkOffset.length, locateChunkInsideHeader(x, z));
		return ByteBuffer.allocate(rawChunkOffset.length).order(ByteOrder.BIG_ENDIAN).put(rawChunkOffset).getInt();
	}
	/**
	 * Read given chunk's disk space size from the region file.
	 * @param x chunk longitude
	 * @param z chunk latitude
	 * @return chunk disk space size in 4 KiB sectors
	 */
	byte getChunkSectorCount(final int x, final int z) throws IOException
	{
		final long previousFilePointer = getFilePointer();
		seek(locateChunkInsideHeader(x, z) + sectorSizeStartsAfter);
		byte chunkSectorCount = readByte();
		seek(previousFilePointer);
		return chunkSectorCount;
	}
	/**
	 * Read given chunk's modification date from the region file.
	 * @param x chunk longitude
	 * @param z chunk latitude
	 * @return chunk modification date in epoch seconds
	 */
	int getChunkModificationDate(final int x, final int z) throws IOException
	{
		byte[] rawChunkModificationDate = new byte[timestampSize];
		readFully(rawChunkModificationDate, rawChunkModificationDate.length, fourKiBSector | locateChunkInsideHeader(x, z));
		return ByteBuffer.allocate(rawChunkModificationDate.length).order(ByteOrder.BIG_ENDIAN).put(rawChunkModificationDate).getInt();
	}
	/// Data
	private int getChunkRemainingLength(final int x, final int z) throws IOException
	{
		byte[] rawChunkRemainingSize = new byte[lengthSize];
		readFully(rawChunkRemainingSize, rawChunkRemainingSize.length, getChunkOffset(x, z) * fourKiBSector);
		return ByteBuffer.allocate(rawChunkRemainingSize.length).order(ByteOrder.BIG_ENDIAN).put(rawChunkRemainingSize).getInt();
	}
	/**
	 * Read given chunk's compression type from the region file.
	 * @param x chunk longitude
	 * @param z chunk latitude
	 * @return chunk compression scheme
	 */
	CompressionType getChunkCompressionType(final int x, final int z) throws IOException
	{
		final long previousFilePointer = getFilePointer();
		seek(getChunkOffset(x, z) * fourKiBSector + compressionTypeStartsAfter);
		byte rawChunkCompressionType = readByte();
		seek(previousFilePointer);
		return CompressionType.valueOf(rawChunkCompressionType);
	}
	/**
	 * Read given chunk's raw data from the region file.
	 * @param x chunk longitude
	 * @param z chunk latitude
	 * @return chunk data as is
	 */
	byte[] getChunkDataPadded(final int x, final int z) throws IOException
	{
		byte[] rawChunkData = new byte[getChunkSectorCount(x, z) * fourKiBSector];
		readFully(rawChunkData, rawChunkData.length, getChunkOffset(x, z) * fourKiBSector);
		return rawChunkData;
	}
	/**
	 * Read given chunk's compressed data from the region file.
	 * @param x chunk longitude
	 * @param z chunk latitude
	 * @return chunk data in NBT data
	 */
	byte[] getChunkData(final int x, final int z) throws IOException
	{
		assert getChunkCompressionType(x, z) != CompressionType.External;
		byte[] rawChunkData = new byte[getChunkRemainingLength(x, z) - 1];
		readFully(rawChunkData, rawChunkData.length, getChunkOffset(x, z) * fourKiBSector + dataStartsAfter);
		return rawChunkData;
	}
	/**
	 * Characterises compression type being used in the region file.
	 * Where External means that chunk's data is moved into a separate file.
	 */
	@RequiredArgsConstructor
	enum CompressionType
	{
		RFC1952(1),
		RFC1950(2),
		None(3),
		External(129);
		private final int value;
		public static CompressionType valueOf(final int value)
		{
			return value < External.ordinal() ? values()[value] : External;
		}
	}
}

import java.io.RandomAccessFile;

import ua.com.minersstudios.whomine.util.misc.WorldRegion;
import static org.bukkit.Bukkit.getLogger;
import static org.bukkit.Bukkit.getVersion;
import static ua.com.minersstudios.whomine.util.i18n.*;

// TODO: Handle this edge case:
// "If the value of compression scheme increases by 128, the compressed
// data is saved in a file called c.x.z.mcc, where x and z are the
// chunk's coordinates, instead of the usual position."

	private boolean worldCleanEnabled = false;	// read from config, leave false as default. also WIP.
	public final int latestWorkingVersion = "1.20";
	if (!Bukkit.getVersion().contains(latestWorkingVersion))
	{
		enabled = false;
		getLogger().warning(i18n("All ChunkDegenerator instances are disabled. Request testing and patching from others, to return this functionality." + "\n" +
		i18n("This is a protection against world corrupting from implementation changes, feel free to ignore this, if you're not a user of World Cleaners."));
	}
	@Getter

		File worldRegions = new File("./{}/region", worldFolder);
		if (!worldRegions.isDirectory())

		File regionsDir = new File(MessageFormat.format("{0}/region", worldFolder));
		if (!regionsDir.isDirectory())

			throw new FileNotFoundException(MessageFormat.format("{0} is not a directory or does not exist. World path is probably wrong.", worldRegions.getAbsolute()));

			throw new FileNotFoundException(MessageFormat.format(i18n("{0} is not a directory or does not exist. World path is probably wrong."), new Object[] { worldRegions.getAbsolute() }));

		for (File f : worldRegions.listFiles())

		ArrayList<WorldRegion> worldRegions = new ArrayList<>();
		for (File f : regionsDir.listFiles())

				throw new FileNotFoundException(MessageFormat.format("{0} is not a regular file.", f.getAbsolute()));
				if (!(f.canRead() && f.canWrite()))
				{
					throw new SecurityException(MessageFormat.format("{} is not writable for me. Cannot operate further.", f.getAbsolute()));
				}

				throw new FileNotFoundException(MessageFormat.format(i18n("{0} is not a regular file."), new Object[] { f.getAbsolute() }));
			}
			if (!(f.canRead() && f.canWrite()))
			{
				throw new SecurityException(MessageFormat.format(i18n("{0} is not writable for me. Cannot operate further."), new Object[] { f.getAbsolute() }));

			RandomAccessFile worldRegion = new RandomAccessFile(f, "rw");

			worldRegions.add(new RandomAccessFile(f, "rw"));

*.sublime-*