diff options
author | Leonard Kugis <leonard@kug.is> | 2022-04-25 18:41:24 +0200 |
---|---|---|
committer | Leonard Kugis <leonard@kug.is> | 2022-04-25 18:41:24 +0200 |
commit | 7abf31ea821a0bbddb836adb1a63d0fec2ceee4f (patch) | |
tree | ad9f4f4a1e6bbf5000b8eeb78180eed3923d72e7 |
22 files changed, 1437 insertions, 0 deletions
diff --git a/.classpath b/.classpath new file mode 100755 index 0000000..16c89cc --- /dev/null +++ b/.classpath @@ -0,0 +1,36 @@ +<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" output="target/classes" path="src/main/java">
+ <attributes>
+ <attribute name="optional" value="true"/>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+ <attributes>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="src" output="target/test-classes" path="src/test/java">
+ <attributes>
+ <attribute name="optional" value="true"/>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+ <attributes>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+ <attributes>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+ <attributes>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="output" path="target/classes"/>
+</classpath>
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9d02df8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,171 @@ + +# Created by https://www.toptal.com/developers/gitignore/api/eclipse,java,windows,linux,macos +# Edit at https://www.toptal.com/developers/gitignore?templates=eclipse,java,windows,linux,macos + +### Eclipse ### +.metadata +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.settings/ +.loadpath +.recommenders + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# PyDev specific (Python IDE for Eclipse) +*.pydevproject + +# CDT-specific (C/C++ Development Tooling) +.cproject + +# CDT- autotools +.autotools + +# Java annotation processor (APT) +.factorypath + +# PDT-specific (PHP Development Tools) +.buildpath + +# sbteclipse plugin +.target + +# Tern plugin +.tern-project + +# TeXlipse plugin +.texlipse + +# STS (Spring Tool Suite) +.springBeans + +# Code Recommenders +.recommenders/ + +# Annotation Processing +.apt_generated/ +.apt_generated_test/ + +# Scala IDE specific (Scala & Java development for Eclipse) +.cache-main +.scala_dependencies +.worksheet + +# Uncomment this line if you wish to ignore the project description file. +# Typically, this file would be tracked if it contains build/dependency configurations: +#.project + +### Eclipse Patch ### +# Spring Boot Tooling +.sts4-cache/ + +### Java ### +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* +replay_pid* + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### macOS Patch ### +# iCloud generated files +*.icloud + +### Windows ### +# Windows thumbnail cache files +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# End of https://www.toptal.com/developers/gitignore/api/eclipse,java,windows,linux,macos diff --git a/.project b/.project new file mode 100755 index 0000000..8de38d9 --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ +<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>instancedregions</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.m2e.core.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.m2e.core.maven2Nature</nature>
+ </natures>
+</projectDescription>
@@ -0,0 +1,60 @@ +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>com.encrox</groupId>
+ <artifactId>instancedregions</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+ <name>InstancedRegions</name>
+ <repositories>
+ <repository>
+ <id>bukkit-repo</id>
+ <url>http://repo.bukkit.org/content/groups/public/</url>
+ </repository>
+ </repositories>
+ <dependencies>
+ <dependency>
+ <groupId>org.bukkit</groupId>
+ <artifactId>craftbukkit</artifactId>
+ <version>LATEST</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.sk89q</groupId>
+ <artifactId>worledit</artifactId>
+ <version>6.1</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.sk89q</groupId>
+ <artifactId>worldguard</artifactId>
+ <version>6.1</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.comphenix</groupId>
+ <artifactId>protocollib</artifactId>
+ <version>4.2.0</version>
+ <scope>provided</scope>
+ </dependency>
+ </dependencies>
+ <build>
+ <resources>
+ <resource>
+ <directory>src/main/resources</directory>
+ <includes>
+ <include>plugin.yml</include>
+ </includes>
+ </resource>
+ </resources>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.6.0</version>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
\ No newline at end of file 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 diff --git a/target/classes/plugin.yml b/target/classes/plugin.yml new file mode 100755 index 0000000..5ca6510 --- /dev/null +++ b/target/classes/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 diff --git a/target/maven-archiver/pom.properties b/target/maven-archiver/pom.properties new file mode 100755 index 0000000..70d7179 --- /dev/null +++ b/target/maven-archiver/pom.properties @@ -0,0 +1,5 @@ +#Generated by Maven
+#Fri Dec 23 21:13:55 CET 2016
+version=0.0.1-SNAPSHOT
+groupId=com.encrox
+artifactId=instancedregions
diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst new file mode 100755 index 0000000..e69de29 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst new file mode 100755 index 0000000..3a7a8e9 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst @@ -0,0 +1,12 @@ +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\InstancedProtectedCuboidRegion.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\InstancedRegions.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\chunkmap\ChunkMapBuffer.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\chunkmap\ChunkWriter.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\types\BlockState.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\chunkmap\ChunkLayer.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\chunkmap\ChunkMapManager.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\packet\SpawnEntity.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\chunkmap\ChunkData.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\Commander.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\chunkmap\ChunkReader.java +C:\Users\Superleo1810\workspace\instancedregions\src\main\java\com\encrox\instancedregions\DereferencedBlock.java diff --git a/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst new file mode 100755 index 0000000..e69de29 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst |