summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorLeonard Kugis <leonard@kug.is>2022-04-25 18:41:24 +0200
committerLeonard Kugis <leonard@kug.is>2022-04-25 18:41:24 +0200
commit7abf31ea821a0bbddb836adb1a63d0fec2ceee4f (patch)
treead9f4f4a1e6bbf5000b8eeb78180eed3923d72e7 /src
Initial commitHEADmaster
Diffstat (limited to 'src')
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/Commander.java48
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/DereferencedBlock.java20
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/InstancedProtectedCuboidRegion.java296
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/InstancedRegions.java40
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/chunkmap/ChunkData.java16
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/chunkmap/ChunkLayer.java11
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/chunkmap/ChunkMapBuffer.java65
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/chunkmap/ChunkMapManager.java384
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/chunkmap/ChunkReader.java100
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/chunkmap/ChunkWriter.java108
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/packet/SpawnEntity.java13
-rwxr-xr-xsrc/main/java/com/encrox/instancedregions/types/BlockState.java11
-rwxr-xr-xsrc/main/resources/plugin.yml9
13 files changed, 1121 insertions, 0 deletions
diff --git a/src/main/java/com/encrox/instancedregions/Commander.java b/src/main/java/com/encrox/instancedregions/Commander.java
new file mode 100755
index 0000000..fa541d6
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/Commander.java
@@ -0,0 +1,48 @@
+package com.encrox.instancedregions;
+
+import java.util.Iterator;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import com.sk89q.worldedit.BlockVector;
+
+public class Commander implements CommandExecutor {
+
+ private Plugin plugin;
+
+ public Commander(Plugin plugin) {
+ this.plugin = plugin;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender arg0, Command arg1, String arg2, String[] arg3) {
+ if(arg0 instanceof Player) {
+ Player player = (Player)arg0;
+ switch(arg3[0]) {
+ case "create":
+ InstancedProtectedCuboidRegion rg = new InstancedProtectedCuboidRegion(plugin, player.getWorld(), "testInstance", new BlockVector(Integer.parseInt(arg3[1]),0,Integer.parseInt(arg3[2])), new BlockVector(Integer.parseInt(arg3[3]),255,Integer.parseInt(arg3[4])));
+ rg.addPlayer(player);
+ InstancedRegions.region.add(rg);
+ return true;
+ case "dispose":
+ Iterator<InstancedProtectedCuboidRegion> iter = InstancedRegions.region.iterator();
+ while(iter.hasNext())
+ iter.next().dispose();
+ return true;
+ /*case "test":
+ InstancedRegions.region.addToChangeWhitelist(new BlockVector(Integer.parseInt(arg3[1]), Integer.parseInt(arg3[2]), Integer.parseInt(arg3[3])));
+ player.sendBlockChange(new Location(player.getWorld(), Integer.parseInt(arg3[1]), Integer.parseInt(arg3[2]), Integer.parseInt(arg3[3])), Material.STONE, (byte) 0);
+ return true;*/
+ }
+ }
+ return false;
+ }
+
+}
diff --git a/src/main/java/com/encrox/instancedregions/DereferencedBlock.java b/src/main/java/com/encrox/instancedregions/DereferencedBlock.java
new file mode 100755
index 0000000..2f77a52
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/DereferencedBlock.java
@@ -0,0 +1,20 @@
+package com.encrox.instancedregions;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+
+public class DereferencedBlock {
+
+ public Material type;
+ public Location location;
+ public BlockState blockState;
+
+ public DereferencedBlock(Block block) {
+ type = block.getType();
+ location = block.getLocation();
+ blockState = block.getState();
+ }
+
+}
diff --git a/src/main/java/com/encrox/instancedregions/InstancedProtectedCuboidRegion.java b/src/main/java/com/encrox/instancedregions/InstancedProtectedCuboidRegion.java
new file mode 100755
index 0000000..3271c4d
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/InstancedProtectedCuboidRegion.java
@@ -0,0 +1,296 @@
+package com.encrox.instancedregions;
+
+import java.util.ArrayList;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.WorldType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.ProtocolManager;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.reflect.StructureModifier;
+import com.comphenix.protocol.wrappers.BlockPosition;
+import com.encrox.instancedregions.chunkmap.ChunkData;
+import com.encrox.instancedregions.chunkmap.ChunkMapManager;
+import com.encrox.instancedregions.types.BlockState;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+public class InstancedProtectedCuboidRegion extends ProtectedCuboidRegion implements Listener {
+
+ private ArrayList<Player> players;
+ private ArrayList<DereferencedBlock> blockBreaks, blockPlaces;
+ private ArrayList<BlockVector> changeWhitelist;
+ private ProtocolManager pmgr;
+ private PacketAdapter mapAdapter, spawnEntityAdapter, spawnExperienceOrbAdapter, spawnMobAdapter, spawnPlayerAdapter, blockBreakAdapter, blockChangeAdapter, multiBlockChangeAdapter;
+ private World world;
+
+ public InstancedProtectedCuboidRegion(Plugin plugin, final World world, String id, BlockVector pt1, BlockVector pt2) {
+ super(id, pt1, pt2);
+ Bukkit.getPluginManager().registerEvents(this, plugin);
+ players = new ArrayList<Player>();
+ blockBreaks = new ArrayList<DereferencedBlock>();
+ blockPlaces = new ArrayList<DereferencedBlock>();
+ changeWhitelist = new ArrayList<BlockVector>();
+ this.world = world;
+ pmgr = ProtocolLibrary.getProtocolManager();
+ //catch chunk data
+ mapAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.MAP_CHUNK){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ PacketContainer packet = event.getPacket();
+ StructureModifier<Integer> ints = packet.getIntegers();
+ StructureModifier<byte[]> byteArray = packet.getByteArrays();
+ StructureModifier<Boolean> bools = packet.getBooleans();
+ ChunkData chunkData = new ChunkData();
+ chunkData.chunkX = ints.read(0);
+ chunkData.chunkZ = ints.read(1);
+ chunkData.groundUpContinuous = bools.read(0);
+ chunkData.primaryBitMask = ints.read(2);
+ chunkData.data = byteArray.read(0);
+ chunkData.isOverworld = event.getPlayer().getWorld().getWorldType() == WorldType.NORMAL;
+ ChunkMapManager cmm = new ChunkMapManager(chunkData);
+ ArrayList<ProtectedRegion> col = new ArrayList<ProtectedRegion>();
+ col.add(new ProtectedCuboidRegion("current", new BlockVector(chunkData.chunkX<<4, 0, chunkData.chunkZ<<4), new BlockVector((chunkData.chunkX<<4)|15, 256, (chunkData.chunkZ<<4)|15)));
+ try {
+ if(getIntersectingRegions(col).isEmpty()) {
+ PacketContainer unloadPacket = new PacketContainer(PacketType.Play.Server.UNLOAD_CHUNK);
+ unloadPacket.getIntegers().write(0, chunkData.chunkX).write(1, chunkData.chunkZ);
+ pmgr.sendServerPacket(player, unloadPacket);
+ cmm.init();
+ for(int y = 0; y<16; y++) {
+ for(int z = 0; z<16; z++) {
+ for(int x = 0; x<16; x++) {
+ try {
+ cmm.readNextBlock();
+ } catch(Exception e1) {
+
+ }
+ //int blockData = cmm.readNextBlock();
+ BlockState blockState = new BlockState();
+ //ChunkMapManager.blockDataToState(blockData, blockState);
+ blockState.id = 0;
+ blockState.meta = 0;
+ //blockData = ChunkMapManager.blockStateToData(blockState);
+ cmm.writeOutputBlock(ChunkMapManager.blockStateToData(blockState));
+ }
+ }
+ }
+ cmm.finalizeOutput();
+ byteArray.write(0, cmm.createOutput());
+ }
+ } catch(Exception e) {
+
+ }
+ }
+ }
+ };
+ //catch entity objects (chests, signs ...)
+ spawnEntityAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.SPAWN_ENTITY){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ PacketContainer packet = event.getPacket();
+ StructureModifier<Double> doubles = packet.getDoubles();
+ double x = doubles.read(0);
+ double y = doubles.read(1);
+ double z = doubles.read(2);
+ if(!contains(new Vector(x, y, z))) {
+ event.setCancelled(true);
+ }
+ }
+ }
+ };
+ //catch experience orbs
+ spawnExperienceOrbAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.SPAWN_ENTITY_EXPERIENCE_ORB){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ PacketContainer packet = event.getPacket();
+ StructureModifier<Double> doubles = packet.getDoubles();
+ double x = doubles.read(0);
+ double y = doubles.read(1);
+ double z = doubles.read(2);
+ if(!contains(new Vector(x, y, z))) {
+ event.setCancelled(true);
+ }
+ }
+ }
+ };
+ //catch mobs
+ spawnMobAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.SPAWN_ENTITY_LIVING){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ PacketContainer packet = event.getPacket();
+ StructureModifier<Double> doubles = packet.getDoubles();
+ double x = doubles.read(0);
+ double y = doubles.read(1);
+ double z = doubles.read(2);
+ if(!contains(new Vector(x, y, z))) {
+ event.setCancelled(true);
+ }
+ }
+ }
+ };
+ //catch players
+ spawnPlayerAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.NAMED_ENTITY_SPAWN){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ PacketContainer packet = event.getPacket();
+ StructureModifier<UUID> uuids = packet.getUUIDs();
+ UUID uuid = uuids.read(0);
+ for(int i = 0, size = players.size(); i<size; i++) {
+ if(!players.get(i).getUniqueId().equals(uuid)) {
+ event.setCancelled(true);
+ }
+ }
+ }
+ }
+ };
+ //catch block break animations
+ blockBreakAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.BLOCK_BREAK_ANIMATION){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ PacketContainer packet = event.getPacket();
+ long position = packet.getLongs().read(0);
+ long x = position >> 38;
+ long y = (position >> 26) & 0xFFF;
+ long z = position << 38 >> 38;
+ InstancedRegions.logger.info("block break: " + x + ", " + y + ", " + z);
+ }
+ }
+ };
+ //catch block changes
+ blockChangeAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.BLOCK_CHANGE){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ //InstancedRegions.logger.info("BLOCK_CHANGE");//erst pasten, dann region newen
+ PacketContainer packet = event.getPacket();
+ StructureModifier<BlockPosition> bps = packet.getBlockPositionModifier();
+ BlockPosition bp = bps.read(0);
+ //InstancedRegions.logger.info("BLOCK_CHANGE at: " + bp.getX() + ", " + bp.getY() + ", " + bp.getZ());
+ BlockVector bv = new BlockVector(bp.getX(), bp.getY(), bp.getZ());
+ if(!contains(bv)) {
+ if(changeWhitelist.contains(bv)) {
+ changeWhitelist.remove(bv);
+ } else {
+ event.setCancelled(true);
+ }
+ }
+ }
+ }
+ };
+ //catch multi block changes
+ multiBlockChangeAdapter = new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.MULTI_BLOCK_CHANGE){
+ @Override
+ public void onPacketSending(PacketEvent event) {
+ Player player = event.getPlayer();
+ if(world.equals(player.getWorld()) && players.contains(event.getPlayer())) {
+ try {
+ //InstancedRegions.logger.info("MULTI_BLOCK_CHANGE");
+ PacketContainer packet = event.getPacket();
+ StructureModifier<int[]> ints = packet.getIntegerArrays();
+ int[] coords = ints.read(0);
+ int chunkX = coords[0];
+ int chunkZ = coords[1];
+ ArrayList<ProtectedRegion> col = new ArrayList<ProtectedRegion>();
+ col.add(new ProtectedCuboidRegion("current", new BlockVector(chunkX<<4, 0, chunkZ<<4), new BlockVector((chunkX<<4)|15, 256, (chunkZ<<4)|15)));
+ if(getIntersectingRegions(col).isEmpty()) {
+ event.setCancelled(true);
+ }
+ } catch(Exception e) {
+
+ }
+ }
+ }
+ };
+ }
+
+ public void addPlayer(Player player) {
+ players.add(player);
+ }
+
+ public void removePlayer(Player player) {
+ players.remove(player);
+ }
+
+ public void apply() {
+ pmgr.addPacketListener(mapAdapter);
+ pmgr.addPacketListener(spawnEntityAdapter);
+ pmgr.addPacketListener(spawnExperienceOrbAdapter);
+ pmgr.addPacketListener(spawnMobAdapter);
+ pmgr.addPacketListener(spawnPlayerAdapter);
+ pmgr.addPacketListener(blockBreakAdapter);
+ pmgr.addPacketListener(blockChangeAdapter);
+ pmgr.addPacketListener(multiBlockChangeAdapter);
+ }
+
+ @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+ public void onBlockBreak(BlockBreakEvent event) {
+ DereferencedBlock block = new DereferencedBlock(event.getBlock());
+ if(players.contains(event.getPlayer()) && contains(block.location.getBlockX(), block.location.getBlockY(), block.location.getBlockZ())) {
+ blockBreaks.add(block);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+ public void onBlockPlace(BlockPlaceEvent event) {
+ DereferencedBlock block = new DereferencedBlock(event.getBlock());
+ if(players.contains(event.getPlayer()) && contains(block.location.getBlockX(), block.location.getBlockY(), block.location.getBlockZ())) {
+ blockPlaces.add(block);
+ }
+ }
+
+ public void addToChangeWhitelist(BlockVector bv) {
+ changeWhitelist.add(bv);
+ }
+
+ public void dispose() {
+ DereferencedBlock current;
+ for(int i = 0, size = blockBreaks.size(); i<size; i++) {
+ current = blockBreaks.get(i);
+ world.getBlockAt(current.location).setType(current.type);
+ }
+ for(int i = 0, size = blockPlaces.size(); i<size; i++) {
+ current = blockPlaces.get(i);
+ world.getBlockAt(current.location).setType(Material.AIR);
+ }
+ pmgr.removePacketListener(mapAdapter);
+ pmgr.removePacketListener(spawnEntityAdapter);
+ pmgr.removePacketListener(spawnExperienceOrbAdapter);
+ pmgr.removePacketListener(spawnMobAdapter);
+ pmgr.removePacketListener(spawnPlayerAdapter);
+ pmgr.removePacketListener(blockBreakAdapter);
+ pmgr.removePacketListener(blockChangeAdapter);
+ pmgr.removePacketListener(multiBlockChangeAdapter);
+ }
+
+}
diff --git a/src/main/java/com/encrox/instancedregions/InstancedRegions.java b/src/main/java/com/encrox/instancedregions/InstancedRegions.java
new file mode 100755
index 0000000..320fcad
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/InstancedRegions.java
@@ -0,0 +1,40 @@
+package com.encrox.instancedregions;
+
+import java.util.ArrayList;
+import java.util.logging.Logger;
+
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.comphenix.protocol.ProtocolManager;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+
+public class InstancedRegions extends JavaPlugin {
+
+ public static Logger logger;
+ public static PluginDescriptionFile pdf;
+ public static WorldGuardPlugin wg;
+ public static WorldEditPlugin we;
+ public static ProtocolManager pmgr;
+
+ //test
+ public static ArrayList<InstancedProtectedCuboidRegion> region;
+
+ public void onEnable() {
+ pdf = getDescription();
+ logger = Logger.getLogger("Minecraft");
+ if(setupMyself()) {
+ getCommand("instance").setExecutor(new Commander(this));
+ logger.info(pdf.getName() + " " + pdf.getVersion() + " has been enabled.");
+ } else {
+ logger.info(pdf.getName() + " " + pdf.getVersion() + " has been disabled.");
+ }
+ }
+
+ private boolean setupMyself() {
+ region = new ArrayList<InstancedProtectedCuboidRegion>();
+ return true;
+ }
+
+}
diff --git a/src/main/java/com/encrox/instancedregions/chunkmap/ChunkData.java b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkData.java
new file mode 100755
index 0000000..eccac2f
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkData.java
@@ -0,0 +1,16 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.chunkmap;
+
+public class ChunkData {
+ public int chunkX;
+ public int chunkZ;
+ public boolean groundUpContinuous;
+ public int primaryBitMask;
+ public byte[] data;
+ public boolean isOverworld;
+ public boolean useCache;
+}
diff --git a/src/main/java/com/encrox/instancedregions/chunkmap/ChunkLayer.java b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkLayer.java
new file mode 100755
index 0000000..04478bd
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkLayer.java
@@ -0,0 +1,11 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.chunkmap;
+
+public class ChunkLayer {
+ public boolean hasData;
+ public int[] map;
+}
diff --git a/src/main/java/com/encrox/instancedregions/chunkmap/ChunkMapBuffer.java b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkMapBuffer.java
new file mode 100755
index 0000000..e138c9f
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkMapBuffer.java
@@ -0,0 +1,65 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.chunkmap;
+
+public class ChunkMapBuffer {
+ private static final int BITS_PER_BLOCK_SIZE = 1;
+ private static final int PALETTE_LENGTH_SIZE = 5;
+ private static final int DATA_ARRAY_LENGTH_SIZE = 5;
+ private static final int BLOCKS_PER_CHUNK_SECTION = 16 * 16 * 16;
+ private static final int DATA_ARRAY_SIZE = BLOCKS_PER_CHUNK_SECTION * 13 / 8;
+ private static final int BLOCK_LIGHT_SIZE = BLOCKS_PER_CHUNK_SECTION / 2;
+ private static final int SKY_LIGHT_SIZE = BLOCKS_PER_CHUNK_SECTION / 2;
+ private static final int COLUMNS_PER_CHUNK = 16;
+
+ private static final int MAX_BYTES_PER_CHUNK =
+ COLUMNS_PER_CHUNK *
+ (
+ BITS_PER_BLOCK_SIZE
+ + PALETTE_LENGTH_SIZE
+ + DATA_ARRAY_LENGTH_SIZE
+ + DATA_ARRAY_SIZE
+ + BLOCK_LIGHT_SIZE
+ + SKY_LIGHT_SIZE
+ );
+
+ public int[] palette;
+ public byte[] output;
+ public int[] outputPalette;
+ public byte[] outputPaletteMap;
+ public ChunkWriter writer;
+ public ChunkLayer prevLayer;
+ public ChunkLayer curLayer;
+ public ChunkLayer nextLayer;
+
+ public int bitsPerBlock;
+ public int paletteLength;
+ public int dataArrayLength;
+ public int lightArrayLength;
+ public int dataArrayStartIndex;
+ public int outputPaletteLength;
+ public int outputBitsPerBlock;
+
+ public ChunkMapBuffer() {
+ this.palette = new int[256];
+ this.output = new byte[MAX_BYTES_PER_CHUNK];
+ this.outputPalette = new int[256];
+ this.outputPaletteMap = new byte[65536];
+ this.writer = new ChunkWriter(this.output);
+ this.prevLayer = new ChunkLayer();
+ this.prevLayer.map = new int[16 * 16];
+ this.curLayer = new ChunkLayer();
+ this.curLayer.map = new int[16 * 16];
+ this.nextLayer = new ChunkLayer();
+ this.nextLayer.map = new int[16 * 16];
+ }
+
+ public void clearLayers() {
+ this.prevLayer.hasData = false;
+ this.curLayer.hasData = false;
+ this.nextLayer.hasData = false;
+ }
+} \ No newline at end of file
diff --git a/src/main/java/com/encrox/instancedregions/chunkmap/ChunkMapManager.java b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkMapManager.java
new file mode 100755
index 0000000..87fb3a1
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkMapManager.java
@@ -0,0 +1,384 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.chunkmap;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+import com.encrox.instancedregions.types.BlockState;
+
+public class ChunkMapManager {
+ private static final ThreadLocal<ChunkMapBuffer> _buffer = new ThreadLocal<ChunkMapBuffer>() {
+ @Override
+ protected ChunkMapBuffer initialValue() {
+ return new ChunkMapBuffer();
+ }
+ };
+
+ private ChunkMapBuffer buffer;
+ private ChunkData chunkData;
+ private ChunkReader reader;
+ private int sectionCount;
+ private int sectionIndex;
+ private int y;
+ private int minX;
+ private int maxX;
+ private int minZ;
+ private int maxZ;
+ private int blockIndex;
+
+ public int getSectionCount() {
+ return this.sectionCount;
+ }
+
+ public int getY() {
+ return this.y;
+ }
+
+ public ChunkData getChunkData() {
+ return this.chunkData;
+ }
+
+ public ChunkMapManager(ChunkData chunkData) {
+ this.buffer = _buffer.get();
+ this.chunkData = chunkData;
+ }
+
+ public void init() throws IOException {
+ this.reader = new ChunkReader(this.chunkData.data);
+ this.sectionCount = 0;
+ this.sectionIndex = -1;
+ this.minX = this.chunkData.chunkX << 4;
+ this.maxX = this.minX + 15;
+ this.minZ = this.chunkData.chunkZ << 4;
+ this.maxZ = this.minZ + 15;
+
+ this.buffer.lightArrayLength = 2048;
+
+ if(this.chunkData.isOverworld) {
+ this.buffer.lightArrayLength <<= 1;
+ }
+
+ this.buffer.writer.init();
+
+ int mask = this.chunkData.primaryBitMask;
+
+ while(mask != 0) {
+ if((mask & 0x1) != 0) {
+ this.sectionCount++;
+ }
+
+ mask >>>= 1;
+ }
+
+ this.buffer.clearLayers();
+
+ moveToNextLayer();
+ }
+
+ public boolean inputHasNonAirBlock() {
+ return this.buffer.paletteLength > 1 || this.buffer.palette[0] != 0;
+ }
+
+ public static void blockDataToState(int blockData, BlockState blockState) {
+ blockState.id = blockData >>> 4;
+ blockState.meta = blockData & 0xf;
+ }
+
+ public static int getBlockIdFromData(int blockData) {
+ return blockData >>> 4;
+ }
+
+ public static int getBlockMetaFromData(int blockData) {
+ return blockData & 0xf;
+ }
+
+ public static int blockStateToData(BlockState blockState) {
+ return (blockState.id << 4) | blockState.meta;
+ }
+
+ public static int getBlockDataFromId(int id) {
+ return id << 4;
+ }
+
+ public boolean initOutputPalette() {
+ if(this.buffer.paletteLength == 0 || this.buffer.paletteLength == 255) {
+ this.buffer.outputPaletteLength = 0;
+ return false;
+ }
+
+ Arrays.fill(this.buffer.outputPaletteMap, (byte)-1);
+
+ this.buffer.outputPaletteLength = this.buffer.paletteLength;
+
+ for(int i = 0; i < this.buffer.paletteLength; i++) {
+ int blockData = this.buffer.palette[i];
+
+ this.buffer.outputPalette[i] = blockData;
+
+ if(blockData >= 0) {
+ this.buffer.outputPaletteMap[blockData] = (byte)i;
+ }
+ }
+
+ return true;
+ }
+
+ public boolean addToOutputPalette(int blockData) {
+ if(this.buffer.outputPaletteMap[blockData] >= 0) return true;
+
+ //255 (-1 for byte) is special code in my algorithm
+ if(this.buffer.outputPaletteLength == 254) {
+ this.buffer.outputPaletteLength = 0;
+ return false;
+ }
+
+ this.buffer.outputPalette[this.buffer.outputPaletteLength] = blockData;
+ this.buffer.outputPaletteMap[blockData] = (byte)this.buffer.outputPaletteLength;
+
+ this.buffer.outputPaletteLength++;
+
+ return true;
+ }
+
+ public void initOutputSection() throws IOException {
+ calcOutputBitsPerBlock();
+
+ this.buffer.writer.setBitsPerBlock(this.buffer.outputBitsPerBlock);
+
+ //Bits Per Block
+ this.buffer.writer.writeByte((byte)this.buffer.outputBitsPerBlock);
+
+ //Palette Length
+ this.buffer.writer.writeVarInt(this.buffer.outputPaletteLength);
+
+ //Palette
+ for(int i = 0; i < this.buffer.outputPaletteLength; i++) {
+ this.buffer.writer.writeVarInt(this.buffer.outputPalette[i]);
+ }
+
+ int dataArrayLengthInBits = this.buffer.outputBitsPerBlock << 12;// multiply by 4096
+ int outputDataArrayLength = dataArrayLengthInBits >>> 6;//divide by 64
+
+ if((dataArrayLengthInBits & 0x3f) != 0) {
+ outputDataArrayLength++;
+ }
+
+ //Data Array Length
+ this.buffer.writer.writeVarInt(outputDataArrayLength);
+
+ //Copy Block Light and Sky Light arrays
+ int lightArrayStartIndex = this.buffer.dataArrayStartIndex + (this.buffer.dataArrayLength << 3);
+ int outputLightArrayStartIndex = this.buffer.writer.getByteIndex() + (outputDataArrayLength << 3);
+
+ System.arraycopy(
+ this.chunkData.data,
+ lightArrayStartIndex,
+ this.buffer.output,
+ outputLightArrayStartIndex,
+ this.buffer.lightArrayLength
+ );
+ }
+
+ public void writeOutputBlock(int blockData) throws IOException {
+ if(this.buffer.outputPaletteLength > 0) {
+ long paletteIndex = this.buffer.outputPaletteMap[blockData] & 0xffL;
+
+ if(paletteIndex == 255) {
+ BlockState blockState = new BlockState();
+ blockDataToState(blockData, blockState);
+ throw new IllegalArgumentException("Block " + blockState.id + ":" + blockState.meta + " is absent in output palette.");
+ }
+
+ this.buffer.writer.writeBlockBits(paletteIndex);
+ } else {
+ this.buffer.writer.writeBlockBits(blockData);
+ }
+ }
+
+ public void finalizeOutput() throws IOException {
+ if(this.buffer.writer.getByteIndex() == 0) return;
+
+ this.buffer.writer.save();
+ this.buffer.writer.skip(this.buffer.lightArrayLength);
+ }
+
+ public byte[] createOutput() {
+ int readerByteIndex = this.reader.getByteIndex();
+ int writerByteIndex = this.buffer.writer.getByteIndex();
+ int biomesSize = this.chunkData.data.length - readerByteIndex;
+ byte[] output = new byte[writerByteIndex + biomesSize];
+
+ System.arraycopy(this.buffer.output, 0, output, 0, writerByteIndex);
+
+ if(biomesSize > 0) {
+ System.arraycopy(
+ this.chunkData.data,
+ readerByteIndex,
+ output,
+ writerByteIndex,
+ biomesSize
+ );
+ }
+
+ return output;
+ }
+
+ private void calcOutputBitsPerBlock() {
+ if(this.buffer.outputPaletteLength == 0) {
+ this.buffer.outputBitsPerBlock = 13;
+ } else {
+ byte mask = (byte)this.buffer.outputPaletteLength;
+ int index = 0;
+
+ while((mask & 0x80) == 0) {
+ index++;
+ mask <<= 1;
+ }
+
+ this.buffer.outputBitsPerBlock = 8 - index;
+
+ if(this.buffer.outputBitsPerBlock < 4) {
+ this.buffer.outputBitsPerBlock = 4;
+ }
+ }
+ }
+
+ public int readNextBlock() throws IOException {
+ if(this.blockIndex == 16 * 16) {
+ if(!moveToNextLayer()) return -1;
+ }
+
+ return this.buffer.curLayer.map[this.blockIndex++];
+ }
+
+ public int get(int x, int y, int z) throws IOException {
+ if(x < minX || x > maxX
+ || z < minZ || z > maxZ
+ || y > 255 || y < this.y - 1 || y > this.y + 1
+ ) {
+ return -1;
+ }
+
+ ChunkLayer layer;
+
+ if(y == this.y) layer = this.buffer.curLayer;
+ else if(y == this.y - 1) layer = this.buffer.prevLayer;
+ else layer = this.buffer.nextLayer;
+
+ if(!layer.hasData) return -1;
+
+ int blockIndex = ((z - this.minZ) << 4) | (x - this.minX);
+
+ return layer.map[blockIndex];
+ }
+
+ private boolean moveToNextLayer() throws IOException {
+ if(!increaseY()) return false;
+
+ shiftLayersDown();
+
+ if(!this.buffer.curLayer.hasData) {
+ readLayer(this.buffer.curLayer);
+ }
+
+ if(((this.y + 1) >>> 4) > this.sectionIndex) {
+ int oldSectionIndex = this.sectionIndex;
+
+ moveToNextSection();
+
+ if(this.sectionIndex < 16 && oldSectionIndex + 1 == this.sectionIndex) {
+ readLayer(this.buffer.nextLayer);
+ }
+ } else {
+ readLayer(this.buffer.nextLayer);
+ }
+
+ this.blockIndex = 0;
+
+ return true;
+ }
+
+ private boolean increaseY() throws IOException {
+ if(this.sectionIndex < 0) {
+ if(!moveToNextSection()) return false;
+
+ this.y = this.sectionIndex << 4;
+ }
+ else {
+ this.y++;
+
+ if((this.y & 0xf) == 0) {
+ if(this.sectionIndex > 15) return false;
+
+ if((this.y >>> 4) != this.sectionIndex) {
+ this.buffer.clearLayers();
+ this.y = this.sectionIndex << 4;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ private void shiftLayersDown() {
+ ChunkLayer temp = this.buffer.prevLayer;
+
+ this.buffer.prevLayer = this.buffer.curLayer;
+ this.buffer.curLayer = this.buffer.nextLayer;
+ this.buffer.nextLayer = temp;
+ this.buffer.nextLayer.hasData = false;
+ }
+
+ private boolean moveToNextSection() throws IOException {
+ if(this.sectionIndex >= 0) {
+ this.reader.skip(this.buffer.lightArrayLength);
+ }
+
+ do {
+ this.sectionIndex++;
+ } while(this.sectionIndex < 16 && (this.chunkData.primaryBitMask & (1 << this.sectionIndex)) == 0);
+
+ if(this.sectionIndex >= 16) return false;
+
+ readSectionHeader();
+
+ return true;
+ }
+
+ private void readLayer(ChunkLayer layer) throws IOException {
+ for(int i = 0; i < 16 * 16; i++) {
+ int blockData = this.reader.readBlockBits();
+
+ if(this.buffer.paletteLength > 0) {
+ blockData = blockData >= 0 && blockData < this.buffer.paletteLength
+ ? this.buffer.palette[blockData]
+ : 0;
+ }
+
+ layer.map[i] = blockData;
+ }
+
+ layer.hasData = true;
+ }
+
+ private void readSectionHeader() throws IOException {
+ this.buffer.bitsPerBlock = this.reader.readByte();
+ this.buffer.paletteLength = this.reader.readVarInt();
+
+ for(int i = 0; i < this.buffer.paletteLength; i++) {
+ int paletteData = this.reader.readVarInt();
+
+ this.buffer.palette[i] = paletteData;
+ }
+
+ this.buffer.dataArrayLength = this.reader.readVarInt();
+
+ this.buffer.dataArrayStartIndex = this.reader.getByteIndex();
+
+ this.reader.setBitsPerBlock(this.buffer.bitsPerBlock);
+ }
+} \ No newline at end of file
diff --git a/src/main/java/com/encrox/instancedregions/chunkmap/ChunkReader.java b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkReader.java
new file mode 100755
index 0000000..a05fa7a
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkReader.java
@@ -0,0 +1,100 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.chunkmap;
+
+import java.io.IOException;
+
+public class ChunkReader {
+ private byte[] data;
+ private int bitsPerBlock;
+ private long maxValueMask;
+ private int byteIndex;
+ private int bitIndex;
+ private long buffer;
+
+ public ChunkReader(byte[] data) {
+ this.data = data;
+ this.byteIndex = 0;
+ this.bitIndex = 0;
+ }
+
+ public int getByteIndex() {
+ return this.byteIndex;
+ }
+
+ public void skip(int count) {
+ this.byteIndex += count;
+ this.bitIndex = 0;
+ }
+
+ public void setBitsPerBlock(int bitsPerBlock) {
+ this.bitsPerBlock = bitsPerBlock;
+ this.maxValueMask = (1L << this.bitsPerBlock) - 1;
+ }
+
+ public int readBlockBits() throws IOException {
+ if(this.bitIndex == 0 || this.bitIndex >= 64) {
+ readLong();
+ this.bitIndex = 0;
+ }
+
+ int leftBits = 64 - this.bitIndex;
+ long result = this.buffer >>> this.bitIndex;
+
+ if(leftBits >= this.bitsPerBlock) {
+ this.bitIndex += this.bitsPerBlock;
+ } else {
+ readLong();
+
+ result |= this.buffer << leftBits;
+
+ this.bitIndex = this.bitsPerBlock - leftBits;
+ }
+
+ return (int)(result & this.maxValueMask);
+ }
+
+ private void readLong() throws IOException {
+ if(this.byteIndex + 7 >= this.data.length) {
+ throw new IOException("No data to read.");
+ }
+
+ this.buffer = ((this.data[this.byteIndex] & 0xffL) << 56)
+ | ((this.data[this.byteIndex + 1] & 0xffL) << 48)
+ | ((this.data[this.byteIndex + 2] & 0xffL) << 40)
+ | ((this.data[this.byteIndex + 3] & 0xffL) << 32)
+ | ((this.data[this.byteIndex + 4] & 0xffL) << 24)
+ | ((this.data[this.byteIndex + 5] & 0xffL) << 16)
+ | ((this.data[this.byteIndex + 6] & 0xffL) << 8)
+ | (this.data[this.byteIndex + 7] & 0xffL);
+
+ this.byteIndex += 8;
+ }
+
+ public int readVarInt() throws IOException {
+ int value = 0;
+ int size = 0;
+ int b;
+
+ while(((b = readByte()) & 0x80) == 0x80) {
+ value |= (b & 0x7F) << (size++ * 7);
+
+ if(size > 5) {
+ throw new IOException("Invalid VarInt.");
+ }
+ }
+
+ return value | ((b & 0x7F) << (size * 7));
+ }
+
+ public int readByte() throws IOException {
+ if(this.byteIndex >= this.data.length) {
+ throw new IOException("No data to read.");
+ }
+
+ return this.data[this.byteIndex++] & 0xff;
+ }
+}
diff --git a/src/main/java/com/encrox/instancedregions/chunkmap/ChunkWriter.java b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkWriter.java
new file mode 100755
index 0000000..398cb25
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/chunkmap/ChunkWriter.java
@@ -0,0 +1,108 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.chunkmap;
+
+import java.io.IOException;
+
+public class ChunkWriter {
+ private byte[] data;
+ private int bitsPerBlock;
+ private int byteIndex;
+ private int bitIndex;
+ private long buffer;
+
+ public ChunkWriter(byte[] data) {
+ this.data = data;
+ }
+
+ public int getByteIndex() {
+ return this.byteIndex;
+ }
+
+ public void init() {
+ this.byteIndex = 0;
+ this.bitIndex = 0;
+ this.buffer = 0;
+ }
+
+ public void setBitsPerBlock(int bitsPerBlock) {
+ this.bitsPerBlock = bitsPerBlock;
+ }
+
+ public void save() throws IOException {
+ writeLong();
+ }
+
+ public void skip(int count) {
+ this.byteIndex += count;
+ this.bitIndex = 0;
+ }
+
+ public void writeBytes(byte[] source, int index, int length) throws IOException {
+ if(this.byteIndex + length > this.data.length) {
+ throw new IOException("No space to write.");
+ }
+
+ System.arraycopy(source, index, this.data, this.byteIndex, length);
+
+ this.byteIndex += length;
+ }
+
+ public void writeBlockBits(long bits) throws IOException {
+ if(this.bitIndex >= 64) {
+ writeLong();
+ this.bitIndex = 0;
+ }
+
+ int leftBits = 64 - this.bitIndex;
+
+ this.buffer |= bits << this.bitIndex;
+
+ if(leftBits >= this.bitsPerBlock) {
+ this.bitIndex += this.bitsPerBlock;
+ } else {
+ writeLong();
+
+ this.buffer = bits >>> leftBits;
+
+ this.bitIndex = this.bitsPerBlock - leftBits;
+ }
+ }
+
+ private void writeLong() throws IOException {
+ if(this.byteIndex + 7 >= this.data.length) {
+ throw new IOException("No space to write.");
+ }
+
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 56);
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 48);
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 40);
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 32);
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 24);
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 16);
+ this.data[this.byteIndex++] = (byte)(this.buffer >> 8);
+ this.data[this.byteIndex++] = (byte)this.buffer;
+
+ this.buffer = 0;
+ }
+
+ public void writeVarInt(int value) throws IOException {
+ while((value & ~0x7F) != 0) {
+ writeByte((value & 0x7F) | 0x80);
+ value >>>= 7;
+ }
+
+ writeByte(value);
+ }
+
+ public void writeByte(int value) throws IOException {
+ if(this.byteIndex >= this.data.length) {
+ throw new IOException("No space to write.");
+ }
+
+ this.data[this.byteIndex++] = (byte)value;
+ }
+}
diff --git a/src/main/java/com/encrox/instancedregions/packet/SpawnEntity.java b/src/main/java/com/encrox/instancedregions/packet/SpawnEntity.java
new file mode 100755
index 0000000..3e9d77d
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/packet/SpawnEntity.java
@@ -0,0 +1,13 @@
+package com.encrox.instancedregions.packet;
+
+import java.util.UUID;
+
+public class SpawnEntity {
+
+ public int id, data;
+ public UUID uuid;
+ public byte type, pitch, yaw;
+ public double x, y, z;
+ public short velX, velY, velZ;
+
+}
diff --git a/src/main/java/com/encrox/instancedregions/types/BlockState.java b/src/main/java/com/encrox/instancedregions/types/BlockState.java
new file mode 100755
index 0000000..689f382
--- /dev/null
+++ b/src/main/java/com/encrox/instancedregions/types/BlockState.java
@@ -0,0 +1,11 @@
+/**
+ * @author Aleksey Terzi
+ *
+ */
+
+package com.encrox.instancedregions.types;
+
+public class BlockState {
+ public int id;
+ public int meta;
+} \ No newline at end of file
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml
new file mode 100755
index 0000000..5ca6510
--- /dev/null
+++ b/src/main/resources/plugin.yml
@@ -0,0 +1,9 @@
+main: com.encrox.instancedregions.InstancedRegions
+name: InstancedRegions
+version: 1.0
+depend: [ProtocolLib, WorldGuard, WorldEdit]
+
+commands:
+ instance:
+ description: Instance test command.
+ usage: /instance create/dispose [<x1> <z1> <x2> <z2>] \ No newline at end of file