diff options
Diffstat (limited to 'src/main/java/com/encrox/instanceddungeons')
7 files changed, 750 insertions, 0 deletions
diff --git a/src/main/java/com/encrox/instanceddungeons/Commander.java b/src/main/java/com/encrox/instanceddungeons/Commander.java new file mode 100644 index 0000000..0bc8ce9 --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/Commander.java @@ -0,0 +1,40 @@ +package com.encrox.instanceddungeons; + +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.json.JSONObject; + +public class Commander implements CommandExecutor { + + @Override + public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if(sender instanceof Player) { + Player player = (Player)sender; + try { + switch(args[0]) { + case "open": + break; + case "invite": + break; + case "join": + break; + case "close": + break; + case "random": + Dungeon dungeon = new Dungeon(player, args[1], Integer.parseInt(args[2])); + InstancedDungeons.dungeons.add(dungeon); + return true; + } + } catch(Exception e) { + e.printStackTrace(); + } + } else { + sender.sendMessage("no player"); + } + return false; + } + +} diff --git a/src/main/java/com/encrox/instanceddungeons/Direction.java b/src/main/java/com/encrox/instanceddungeons/Direction.java new file mode 100644 index 0000000..05f391e --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/Direction.java @@ -0,0 +1,10 @@ +package com.encrox.instanceddungeons; + +public class Direction { + + public static final byte NORTH = 0; + public static final byte EAST = 1; + public static final byte SOUTH = 2; + public static final byte WEST = 3; + +} diff --git a/src/main/java/com/encrox/instanceddungeons/Dungeon.java b/src/main/java/com/encrox/instanceddungeons/Dungeon.java new file mode 100644 index 0000000..69cd847 --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/Dungeon.java @@ -0,0 +1,48 @@ +package com.encrox.instanceddungeons; + +import java.util.ArrayList; + +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; +import org.json.JSONObject; + +import com.sk89q.worldedit.BlockVector; + +public class Dungeon { + + private Section section; + private String id; + private int depth; + private ArrayList<Player> players; + + public Dungeon(Player player, String id, int depth) { + this.id = id; + this.depth = depth; + section = new Section(InstancedDungeons.startDescriptors.getJSONObject((int)Math.round(Math.random()*(InstancedDungeons.startDescriptors.length()-1))), 0, depth); + try { + section.load(); + section.instantiate(); + BlockVector[] destinations = section.getAbsoluteExits(); + BlockVector destination = destinations[(int)Math.round(Math.random()*(destinations.length-1))]; + addPlayer(player); + player.teleport(new Location(InstancedDungeons.dungeonWorld.getWorld(), destination.getBlockX(), destination.getBlockY(), destination.getBlockZ())); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void addPlayer(Player player) { + section.addPlayer(player); + } + + public void removePlayer(Player player) { + section.removePlayer(player); + } + + public String getId() { + return id; + } + +} diff --git a/src/main/java/com/encrox/instanceddungeons/DungeonWorld.java b/src/main/java/com/encrox/instanceddungeons/DungeonWorld.java new file mode 100644 index 0000000..643c787 --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/DungeonWorld.java @@ -0,0 +1,50 @@ +package com.encrox.instanceddungeons; + +import java.util.ArrayList; + +import org.bukkit.World; +import org.bukkit.plugin.Plugin; + +import com.encrox.instancedregions.InstancedProtectedCuboidRegion; +import com.sk89q.worldedit.BlockVector; +import com.sk89q.worldedit.BlockVector2D; +import com.sk89q.worldedit.regions.CuboidRegion; +import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; +import com.sk89q.worldguard.protection.regions.ProtectedRegion; + +public class DungeonWorld { + + private Plugin plugin; + private World world; + private ArrayList<ProtectedRegion> regions; + private int lastX; + + public DungeonWorld(Plugin plugin, World world) { + this.world = world; + this.plugin = plugin; + regions = new ArrayList<ProtectedRegion>(); + lastX = 0; + } + + public InstancedProtectedCuboidRegion allocate(int width, int length) { + BlockVector min, max; + InstancedProtectedCuboidRegion region; + for(int i = 0; true; i+=16) { + if(new ProtectedCuboidRegion("current", (min = new BlockVector(lastX+i, 0, 0)), (max = new BlockVector(lastX+i+width, 255, length))).getIntersectingRegions(regions).isEmpty()) { + region = new InstancedProtectedCuboidRegion(plugin, world, ""+min.getBlockX(), min, max); + regions.add(region); + return region; + } + } + } + + //YOU STILL HAVE TO DISPOSE THE INSTANCED REGION MANUALLY! + public void deallocate(InstancedProtectedCuboidRegion region) { + regions.remove(region); + } + + public World getWorld() { + return world; + } + +} diff --git a/src/main/java/com/encrox/instanceddungeons/InstancedDungeons.java b/src/main/java/com/encrox/instanceddungeons/InstancedDungeons.java new file mode 100644 index 0000000..7064aa1 --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/InstancedDungeons.java @@ -0,0 +1,253 @@ +package com.encrox.instanceddungeons; + +import java.io.BufferedInputStream; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.Properties; +import java.util.logging.Logger; + +import org.bukkit.Bukkit; +import org.bukkit.plugin.Plugin; +import org.bukkit.plugin.PluginDescriptionFile; +import org.bukkit.plugin.java.JavaPlugin; +import org.json.JSONArray; +import org.json.JSONObject; + +public class InstancedDungeons extends JavaPlugin { + + public static Plugin plugin; + public static Logger logger; + public static PluginDescriptionFile pdf; + //public static Properties lang; + public static JSONObject config; + public static JSONArray resetDungeons, schematicDescriptors, startDescriptors, endDescriptors, normalDescriptors; + public static DungeonWorld dungeonWorld; + public static File schematicsDirectory; + public static ArrayList<Dungeon> dungeons; + + public void onEnable() { + pdf = getDescription(); + logger = Logger.getLogger("Minecraft"); + if(setupMyself()) { + plugin = this; + getCommand("dungeon").setExecutor(new Commander()); + logger.info(pdf.getName() + " " + pdf.getVersion() + " has been enabled."); + } else { + logger.info(pdf.getName() + " " + pdf.getVersion() + " has been disabled."); + } + } + + public boolean setupMyself() { + if(!this.getDataFolder().exists()) + this.getDataFolder().mkdirs(); + schematicsDirectory = new File(this.getDataFolder(), "schematics"); + if(!schematicsDirectory.exists()) + schematicsDirectory.mkdirs(); + File configFile = new File(this.getDataFolder(), "config.json"); + if(!configFile.exists()) { + BufferedInputStream bis; + FileOutputStream out; + try { + bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("config.json")); + out = new FileOutputStream(configFile); + int current; + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch (Exception e) { + e.printStackTrace(); + return false; + } + } + BufferedReader br; + StringBuilder sb = new StringBuilder(); + String line; + try { + br = new BufferedReader(new FileReader(configFile)); + while((line = br.readLine()) != null) + sb.append(line); + br.close(); + } catch (Exception e1) { + e1.printStackTrace(); + return false; + } + config = new JSONObject(sb.toString()); + resetDungeons = config.getJSONArray("resetDungeons"); + File schematicDescriptorFile = new File(schematicsDirectory, "descriptor.json"); + if(!schematicDescriptorFile.exists()) { + int current; + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("descriptor.json")); + FileOutputStream out = new FileOutputStream(schematicDescriptorFile); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/endBottom.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "endBottom.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/endSide.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "endSide.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/endTop.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "endTop.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/startBottom.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "startBottom.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/startSide.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "startSide.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/startTop.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "startTop.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + try { + BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream("schematics/test.schematic")); + FileOutputStream out = new FileOutputStream(new File(schematicsDirectory, "test.schematic")); + while((current = bis.read()) != -1) { + out.write(current); + } + bis.close(); + out.close(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + } + sb = new StringBuilder(); + try { + br = new BufferedReader(new FileReader(schematicDescriptorFile)); + while((line = br.readLine()) != null) + sb.append(line); + br.close(); + } catch (Exception e1) { + e1.printStackTrace(); + return false; + } + schematicDescriptors = new JSONObject(sb.toString()).getJSONArray("schematics"); + startDescriptors = new JSONArray(); + endDescriptors = new JSONArray(); + normalDescriptors = new JSONArray(); + JSONObject current; + for(int i = 0, length = schematicDescriptors.length(); i<length; i++) { + switch((current = schematicDescriptors.getJSONObject(i)).getInt("modifier")) { + case 0: + normalDescriptors.put(current); + break; + case 1: + startDescriptors.put(current); + break; + case 2: + endDescriptors.put(current); + break; + } + } + /*lang = new Properties(); + try { + //TODO + lang.load(getClass().getClassLoader().getResourceAsStream("lang/" + config.getString("locale"))); + } catch (FileNotFoundException e) { + e.printStackTrace(); + return false; + } catch (IOException e) { + e.printStackTrace(); + return false; + } + */ + dungeonWorld = new DungeonWorld(this, Bukkit.getWorld(config.getString("world"))); + dungeons = new ArrayList<Dungeon>(); + return true; + } + + public void onDisable() { + logger.info(pdf.getName() + " " + pdf.getVersion() + " has been disabled."); + } + + private void addClassPath(final URL url) throws IOException { + final URLClassLoader sysloader = (URLClassLoader) ClassLoader + .getSystemClassLoader(); + final Class<URLClassLoader> sysclass = URLClassLoader.class; + try { + final Method method = sysclass.getDeclaredMethod("addURL", + new Class[] { URL.class }); + method.setAccessible(true); + method.invoke(sysloader, new Object[] { url }); + } catch (final Throwable t) { + t.printStackTrace(); + throw new IOException("Error adding " + url + + " to system classloader"); + } + } + +} diff --git a/src/main/java/com/encrox/instanceddungeons/Schematic.java b/src/main/java/com/encrox/instanceddungeons/Schematic.java new file mode 100644 index 0000000..c20d83a --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/Schematic.java @@ -0,0 +1,86 @@ +/* + * Dynamic Schematic object + * + * Currently not supporting entities. + */ + +package com.encrox.instanceddungeons; + +import java.io.BufferedInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.util.List; +import java.util.Map; + +import org.bukkit.Material; +import org.jnbt.ByteArrayTag; +import org.jnbt.CompoundTag; +import org.jnbt.ListTag; +import org.jnbt.NBTInputStream; +import org.jnbt.ShortTag; +import org.jnbt.StringTag; +import org.jnbt.Tag; + +public class Schematic { + + public int width, height, length, readIndex, writeIndex; + public String materials; + public byte[] blocks, data; + public List<Tag> entities, tileEntities; + + public Schematic(int width, int height, int length, String materials, byte[] blocks, byte[] data, List<Tag> entities, List<Tag> tileEntities) { + this.width = width; + this.height = height; + this.length = length; + this.materials = materials; + this.blocks = blocks; + this.data = data; + this.entities = entities; + this.tileEntities = tileEntities; + readIndex = -1; + writeIndex = -1; + } + + public Schematic(File file) { + CompoundTag schematicTag = null; + try { + NBTInputStream in = new NBTInputStream(new FileInputStream(file)); + schematicTag = (CompoundTag)in.readTag(); + in.close(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + Map<String,Tag> schematic = schematicTag.getValue(); + width = ((ShortTag)schematic.get("Width")).getValue(); + height = ((ShortTag)schematic.get("Height")).getValue(); + length = ((ShortTag)schematic.get("Length")).getValue(); + materials = ((StringTag)schematic.get("Materials")).getValue(); + blocks = ((ByteArrayTag)schematic.get("Blocks")).getValue(); + data = ((ByteArrayTag)schematic.get("Data")).getValue(); + entities = ((ListTag)schematic.get("Entities")).getValue(); + tileEntities = ((ListTag)schematic.get("TileEntities")).getValue(); + } + + public byte getBlockIdAt(int x, int y, int z) { + return blocks[(y*length + z)*width + x]; + } + + public byte getNextBlock() { + return blocks[readIndex++]; + } + + public void setBlockIdAt(int x, int y, int z, byte blockId) { + blocks[(y*length + z)*width + x] = blockId; + } + + public void setNextBlock(byte blockId) { + blocks[writeIndex++] = blockId; + } + + public void write(File file) { + + } + +} diff --git a/src/main/java/com/encrox/instanceddungeons/Section.java b/src/main/java/com/encrox/instanceddungeons/Section.java new file mode 100644 index 0000000..0c40b24 --- /dev/null +++ b/src/main/java/com/encrox/instanceddungeons/Section.java @@ -0,0 +1,263 @@ +package com.encrox.instanceddungeons; + +import java.io.File; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.HandlerList; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerMoveEvent; +import org.bukkit.plugin.Plugin; +import org.json.JSONArray; +import org.json.JSONObject; + +import com.encrox.instancedregions.InstancedProtectedCuboidRegion; +import com.sk89q.worldedit.BlockVector; + +public class Section { + + private Schematic schematic; + private String schematicFileName; + private Map<BlockVector,Section> exitMap; + private ArrayList<Player> players; + private BlockVector[] exits; + private BlockVector size; + private int index, depth; + private InstancedProtectedCuboidRegion region; + private Listener moveOutOfLoadingZoneListener, moveIntoLoadingZoneListener; + private volatile boolean justEntered, portal; + + public Section(JSONObject descriptor, int index, int depth) { + this.index = index; + this.depth = depth; + players = new ArrayList<Player>(); + schematicFileName = descriptor.getString("file"); + JSONArray size = descriptor.getJSONArray("size"); + this.size = new BlockVector(size.getInt(0), size.getInt(1), size.getInt(2)); + JSONArray exits = descriptor.getJSONArray("exits"); + this.exits = new BlockVector[exits.length()]; + for(int i = 0; i<this.exits.length; i++) { + JSONArray current = exits.getJSONArray(i); + this.exits[i] = new BlockVector(current.getInt(0), current.getInt(1), current.getInt(2)); + } + } + + public void load() throws Exception { + exitMap = new HashMap<BlockVector,Section>(); + this.schematic = new Schematic(new File(InstancedDungeons.schematicsDirectory, schematicFileName)); + if(index <= depth) { + Section next; + ArrayList<Section> usable = new ArrayList<Section>(); + for(int i = 0; i<exits.length; i++) { + if(exits[i].getBlockX() == 0 || exits[i].getBlockX() == size.getBlockX()-1 || exits[i].getBlockZ() == 0 || exits[i].getBlockZ() == size.getBlockZ()-1) { + if(index == depth) { + for(int c = 0, length = InstancedDungeons.endDescriptors.length(); c<length; c++) { + if((next = new Section(InstancedDungeons.endDescriptors.getJSONObject(c), index+1, depth)).hasSideExit()) { + usable.add(next); + } + } + } else { + for(int c = 0, length = InstancedDungeons.normalDescriptors.length(); c<length; c++) { + if((next = new Section(InstancedDungeons.normalDescriptors.getJSONObject(c), index+1, depth)).hasSideExit()) { + usable.add(next); + } + } + } + } else if(exits[i].getBlockY() == 0) { + if(index == depth) { + for(int c = 0, length = InstancedDungeons.endDescriptors.length(); c<length; c++) { + if((next = new Section(InstancedDungeons.endDescriptors.getJSONObject(c), index+1, depth)).hasTopExit()) { + usable.add(next); + } + } + } else { + for(int c = 0, length = InstancedDungeons.normalDescriptors.length(); c<length; c++) { + if((next = new Section(InstancedDungeons.normalDescriptors.getJSONObject(c), index+1, depth)).hasTopExit()) { + usable.add(next); + } + } + } + } else if(exits[i].getBlockY() == size.getBlockY()-1) { + if(index == depth) { + for(int c = 0, length = InstancedDungeons.endDescriptors.length(); c<length; c++) { + if((next = new Section(InstancedDungeons.endDescriptors.getJSONObject(c), index+1, depth)).hasBottomExit()) { + usable.add(next); + } + } + } else { + for(int c = 0, length = InstancedDungeons.normalDescriptors.length(); c<length; c++) { + if((next = new Section(InstancedDungeons.normalDescriptors.getJSONObject(c), index+1, depth)).hasBottomExit()) { + usable.add(next); + } + } + } + } else { + throw new Exception("No schematic with a valid exit found."); + } + exitMap.put(exits[i], usable.get((int)Math.round(Math.random()*(usable.size()-1)))); + } + } + } + + public BlockVector[] getAbsoluteExits() { + BlockVector[] out = new BlockVector[exits.length]; + BlockVector min = region.getMinimumPoint(); + for(int i = 0; i<exits.length; i++) { + out[i] = new BlockVector(min.getBlockX()+exits[i].getBlockX(), 128+exits[i].getBlockY(), min.getBlockZ()+exits[i].getBlockZ()); + } + return out; + } + + public void instantiate() { + justEntered = true; + portal = false; + region = InstancedDungeons.dungeonWorld.allocate(size.getBlockX(), size.getBlockZ()); + //write schematic to map + final BlockVector min = region.getMinimumPoint(); + byte next; + for(int y = 0; y<schematic.height; y++) { + for(int z = 0; z<schematic.length; z++) { + for(int x = 0; x<schematic.width; x++) { + next = schematic.getNextBlock(); + region.addToChangeWhitelist(new BlockVector(min.getBlockX()+x, 128+y, min.getBlockZ()+z)); + InstancedDungeons.dungeonWorld.getWorld().getBlockAt(min.getBlockX()+x, 128+y, min.getBlockZ()+z).setType(Material.getMaterial(next)); + region.addToChangeWhitelist(new BlockVector(min.getBlockX()+x, 128+y, min.getBlockZ()+z)); + + for(int i = 0, size = players.size(); i<size; i++) { + players.get(i).sendBlockChange(new Location(InstancedDungeons.dungeonWorld.getWorld(), min.getBlockX()+x, 128+y, min.getBlockZ()+z), Material.getMaterial(next), (byte) 0); + } + + } + } + } + Bukkit.getScheduler().scheduleSyncDelayedTask(InstancedDungeons.plugin, new Runnable() { + @Override + public void run() { + InstancedDungeons.logger.info("portal activated"); + justEntered = false; + portal = true; + } + }, 40L); + moveOutOfLoadingZoneListener = new Listener() { + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = false) + public void onMove(PlayerMoveEvent event) { + InstancedDungeons.logger.info("Player moved"); + Location to = event.getTo(); + for(int i = 0; i<exits.length; i++) { + if((!justEntered) && (!(to.getWorld().equals(InstancedDungeons.dungeonWorld.getWorld()) + && to.getBlockX() == min.getBlockX() + exits[i].getBlockX() + && to.getBlockY() == 128 + exits[i].getBlockY() + && to.getBlockZ() == min.getBlockZ() + exits[i].getBlockZ()))) { + InstancedDungeons.logger.info("Player exited loading zone"); + moveIntoLoadingZoneListener = new Listener() { + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = false) + public void onMove(PlayerMoveEvent event) { + Location to = event.getTo(); + for(int i = 0; i<exits.length; i++) { + if(portal && (!justEntered) && (to.getWorld().equals(InstancedDungeons.dungeonWorld.getWorld()) + && to.getBlockX() == min.getBlockX() + exits[i].getBlockX() + && to.getBlockY() == 128 + exits[i].getBlockY() + && to.getBlockZ() == min.getBlockZ() + exits[i].getBlockZ())) { + InstancedDungeons.logger.info("Player in loading zone"); + portal = false; + Section next = exitMap.get(exits[i]); + try { + HandlerList.unregisterAll(moveIntoLoadingZoneListener); + next.load(); + next.instantiate(); + for(int c = 0, size = players.size(); c<size; c++) { + next.addPlayer(players.get(c)); + } + BlockVector[] destinations = next.getAbsoluteExits(); + BlockVector destination = destinations[(int)Math.round(Math.random()*destinations.length)]; + event.getPlayer().teleport(new Location(InstancedDungeons.dungeonWorld.getWorld(), -10000, 200, -10000)); + event.getPlayer().teleport(new Location(InstancedDungeons.dungeonWorld.getWorld(), destination.getBlockX(), destination.getBlockY(), destination.getBlockZ())); + region.dispose(); + InstancedDungeons.dungeonWorld.deallocate(region); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + } + }; + Bukkit.getPluginManager().registerEvents(moveIntoLoadingZoneListener, InstancedDungeons.plugin); + HandlerList.unregisterAll(moveOutOfLoadingZoneListener); + } + } + } + }; + Bukkit.getPluginManager().registerEvents(moveOutOfLoadingZoneListener, InstancedDungeons.plugin); + } + + public Schematic getSchematic() { + return schematic; + } + + public void activateExits() { + + } + + public boolean hasSideExit() { + for(int i = 0; i<exits.length; i++) { + if(exits[i].getBlockX() == 0 + || exits[i].getBlockX() == size.getBlockX()-1 + || exits[i].getBlockZ() == 0 + || exits[i].getBlockZ() == size.getBlockZ()-1) { + return true; + } + } + return false; + } + + public boolean hasTopExit() { + for(int i = 0; i<exits.length; i++) { + if(exits[i].getBlockY() == size.getBlockY()-1) { + return true; + } + } + return false; + } + + public boolean hasBottomExit() { + for(int i = 0; i<exits.length; i++) { + if(exits[i].getBlockY() == 0) { + return true; + } + } + return false; + } + + public void addPlayer(Player player) { + players.add(player); + if(region != null) + region.addPlayer(player); + if(exitMap != null) { + Iterator<Section> sections = exitMap.values().iterator(); + while(sections.hasNext()) + sections.next().addPlayer(player); + } + } + + public void removePlayer(Player player) { + players.add(player); + if(region != null) + region.removePlayer(player); + if(exitMap != null) { + Iterator<Section> sections = exitMap.values().iterator(); + while(sections.hasNext()) + sections.next().removePlayer(player); + } + } + +} |