Main jar should compile, the tests are messed up

Essentials/src/net/ess3/bukkit/LivingEntities.java

@@ -6,8 +6,13 @@ import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.logging.Level;
 import static net.ess3.I18n._;
+import org.bukkit.Location;
+import org.bukkit.Server;
 import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
 
 
 public class LivingEntities
@@ -44,4 +49,10 @@ public class LivingEntities
 	public static String getName(int count, EntityType type) {
 		return count == 1? _(entityI18n.get(type)):_(entityI18nPlural.get(type));
 	}
+	
+	public static class MobException extends Exception
+	{
+		private static final long serialVersionUID = 1L;
+	}
+
 }

Essentials/src/net/ess3/commands/Commandspawner.java

@@ -11,6 +11,7 @@ import net.ess3.utils.Util;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.CreatureSpawner;
+import org.bukkit.entity.EntityType;
 
 
 public class Commandspawner extends EssentialsCommand
@@ -20,10 +21,10 @@ public class Commandspawner extends EssentialsCommand
 	{
 		if (args.length < 1 || args[0].length() < 2)
 		{
-			throw new NotEnoughArgumentsException(_("mobsAvailable", Util.joinList(LivingEntities.getMobList())));
+			throw new NotEnoughArgumentsException(_("mobsAvailable", Util.joinList(LivingEntities.getLivingEntityList())));
 		}
 
-		final Location target = LocationUtil.getTarget(user);
+		final Location target = LocationUtil.getTarget(user.getPlayer());
 		if (target == null || target.getBlock().getType() != Material.MOB_SPAWNER)
 		{
 			throw new Exception(_("mobSpawnTarget"));
@@ -33,22 +34,22 @@ public class Commandspawner extends EssentialsCommand
 		{
 			String name = args[0];
 
-			LivingEntities mob = null;
+			EntityType mob = null;
 			mob = LivingEntities.fromName(name);
 			if (mob == null)
 			{
 				user.sendMessage(_("invalidMob"));
 				return;
 			}
-			if (!SpawnerPermissions.getPermission(mob.name).isAuthorized(user))
+			if (!SpawnerPermissions.getPermission(mob.getName()).isAuthorized(user))
 			{
 				throw new Exception(_("unableToSpawnMob"));
 			}
-			final Trade charge = new Trade("spawner-" + mob.name.toLowerCase(Locale.ENGLISH), ess);
+			final Trade charge = new Trade("spawner-" + mob.getName().toLowerCase(Locale.ENGLISH), ess);
 			charge.isAffordableFor(user);
-			((CreatureSpawner)target.getBlock().getState()).setSpawnedType(mob.getType());
+			((CreatureSpawner)target.getBlock().getState()).setSpawnedType(mob);
 			charge.charge(user);
-			user.sendMessage(_("setSpawner", mob.name));
+			user.sendMessage(_("setSpawner", mob.getName()));
 		}
 		catch (Throwable ex)
 		{

Essentials/src/net/ess3/commands/Commandspawnmob.java

@@ -27,7 +27,7 @@ public class Commandspawnmob extends EssentialsCommand
 	{
 		if (args.length < 1)
 		{
-			final Set<String> mobList = LivingEntities.getMobList();
+			final Set<String> mobList = LivingEntities.getLivingEntityList();
 			final Set<String> availableList = new HashSet<String>();
 			for (String mob : mobList)
 			{
@@ -66,9 +66,9 @@ public class Commandspawnmob extends EssentialsCommand
 
 
 		Entity spawnedMob = null;
-		LivingEntities mob = null;
+		EntityType mob = null;
 		Entity spawnedMount = null;
-		LivingEntities mobMount = null;
+		EntityType mobMount = null;
 
 		mob = LivingEntities.fromName(mobType);
 		if (mob == null)
@@ -76,12 +76,12 @@ public class Commandspawnmob extends EssentialsCommand
 			throw new Exception(_("invalidMob"));
 		}
 
-		if (!SpawnmobPermissions.getPermission(mob.name).isAuthorized(user))
+		if (!SpawnmobPermissions.getPermission(mob.getName()).isAuthorized(user))
 		{
 			throw new Exception(_("noPermToSpawnMob"));
 		}
 
-		final Block block = LocationUtil.getTarget(user).getBlock();
+		final Block block = LocationUtil.getTarget(user.getPlayer()).getBlock();
 		if (block == null)
 		{
 			throw new Exception(_("unableToSpawnMob"));
@@ -89,15 +89,15 @@ public class Commandspawnmob extends EssentialsCommand
 		IUser otherUser = null;
 		if (args.length >= 3)
 		{
-			otherUser = getPlayer(args, 2);
+			otherUser = ess.getUserMap().getUser(args[2]);
 		}
-		final Location loc = (otherUser == null) ? block.getLocation() : otherUser.getLocation();
+		final Location loc = (otherUser == null) ? block.getLocation() : otherUser.getPlayer().getLocation();
 		final Location sloc = LocationUtil.getSafeDestination(loc);
 		try
 		{
-			spawnedMob = mob.spawn(user, server, sloc);
+			spawnedMob = user.getPlayer().getWorld().spawn(sloc, (Class<? extends LivingEntity>)mob.getEntityClass());
 		}
-		catch (MobException e)
+		catch (Exception e)
 		{
 			throw new Exception(_("unableToSpawnMob"), e);
 		}
@@ -111,15 +111,15 @@ public class Commandspawnmob extends EssentialsCommand
 				return;
 			}
 
-			if (!SpawnmobPermissions.getPermission(mobMount.name).isAuthorized(user))
+			if (!SpawnmobPermissions.getPermission(mobMount.getName()).isAuthorized(user))
 			{
 				throw new Exception(_("noPermToSpawnMob"));
 			}
 			try
 			{
-				spawnedMount = mobMount.spawn(user, server, loc);
+				spawnedMount = user.getPlayer().getWorld().spawn(loc, (Class<? extends LivingEntity>)mobMount.getEntityClass());
 			}
-			catch (MobException e)
+			catch (Exception e)
 			{
 				throw new Exception(_("unableToSpawnMob"), e);
 			}
@@ -127,11 +127,11 @@ public class Commandspawnmob extends EssentialsCommand
 		}
 		if (mobData != null)
 		{
-			changeMobData(mob.getType(), spawnedMob, mobData, user);
+			changeMobData(mob, spawnedMob, mobData, user);
 		}
 		if (spawnedMount != null && mountData != null)
 		{
-			changeMobData(mobMount.getType(), spawnedMount, mountData, user);
+			changeMobData(mobMount, spawnedMount, mountData, user);
 		}
 		if (args.length >= 2)
 		{
@@ -157,14 +157,14 @@ public class Commandspawnmob extends EssentialsCommand
 			{
 				for (int i = 1; i < mobCount; i++)
 				{
-					spawnedMob = mob.spawn(user, server, loc);
+					spawnedMob = user.getPlayer().getWorld().spawn(sloc, (Class<? extends LivingEntity>)mob.getEntityClass());
 					if (mobMount != null)
 					{
 						try
 						{
-							spawnedMount = mobMount.spawn(user, server, loc);
+							spawnedMount = user.getPlayer().getWorld().spawn(loc, (Class<? extends LivingEntity>)mobMount.getEntityClass());
 						}
-						catch (MobException e)
+						catch (Exception e)
 						{
 							throw new Exception(_("unableToSpawnMob"), e);
 						}
@@ -172,14 +172,14 @@ public class Commandspawnmob extends EssentialsCommand
 					}
 					if (mobData != null)
 					{
-						changeMobData(mob.getType(), spawnedMob, mobData, user);
+						changeMobData(mob, spawnedMob, mobData, user);
 					}
 					if (spawnedMount != null && mountData != null)
 					{
-						changeMobData(mobMount.getType(), spawnedMount, mountData, user);
+						changeMobData(mobMount, spawnedMount, mountData, user);
 					}
 				}
-				user.sendMessage(mobCount + " " + mob.name.toLowerCase(Locale.ENGLISH) + mob.suffix + " " + _("spawned"));
+				user.sendMessage(mobCount + " " + mob.getName().toLowerCase(Locale.ENGLISH) + " " + _("spawned"));
 			}
 			catch (MobException e1)
 			{
@@ -196,7 +196,7 @@ public class Commandspawnmob extends EssentialsCommand
 		}
 		else
 		{
-			user.sendMessage(mob.name + " " + _("spawned"));
+			user.sendMessage(mob.getName() + " " + _("spawned"));
 		}
 	}
 

Essentials/src/net/ess3/commands/Commandtpaccept.java

@@ -21,8 +21,8 @@ public class Commandtpaccept extends EssentialsCommand
 		final IUser target = user.getTeleportRequester();
 		if (target == null 
 			|| !target.isOnline()
-			|| (user.isTeleportRequestHere() && !Permissions.TPAHERE.isAuthorized(target))
-			|| (!user.isTeleportRequestHere() && !Permissions.TPA.isAuthorized(target) && !Permissions.TPAALL.isAuthorized(target)))
+			|| (user.isTpRequestHere() && !Permissions.TPAHERE.isAuthorized(target))
+			|| (!user.isTpRequestHere() && !Permissions.TPA.isAuthorized(target) && !Permissions.TPAALL.isAuthorized(target)))
 		{
 			throw new Exception(_("noPendingRequest"));
 		}
@@ -51,7 +51,7 @@ public class Commandtpaccept extends EssentialsCommand
 		}
 
 		final Trade charge = new Trade(commandName, ess);
-		if (user.isTeleportRequestHere())
+		if (user.isTpRequestHere())
 		{
 			charge.isAffordableFor(user);
 		}
@@ -62,13 +62,13 @@ public class Commandtpaccept extends EssentialsCommand
 		user.sendMessage(_("requestAccepted"));
 		target.sendMessage(_("requestAcceptedFrom", user.getPlayer().getDisplayName()));
 
-		if (user.isTeleportRequestHere())
+		if (user.isTpRequestHere())
 		{
-			user.getTeleport().teleport(target, charge, TeleportCause.COMMAND);
+			user.getTeleport().teleport(target.getPlayer(), charge, TeleportCause.COMMAND);
 		}
 		else
 		{
-			target.getTeleport().teleport(user, charge, TeleportCause.COMMAND);
+			target.getTeleport().teleport(user.getPlayer(), charge, TeleportCause.COMMAND);
 		}
 		user.requestTeleport(null, false);
 	}

Essentials/src/net/ess3/commands/Commandunlimited.java

@@ -5,6 +5,7 @@ import java.util.Set;
 import lombok.Cleanup;
 import static net.ess3.I18n._;
 import net.ess3.api.IUser;
+import net.ess3.craftbukkit.InventoryWorkaround;
 import net.ess3.permissions.Permissions;
 import net.ess3.permissions.UnlimitedItemPermissions;
 import org.bukkit.Material;
@@ -39,10 +40,10 @@ public class Commandunlimited extends EssentialsCommand
 		{
 			//TODO: Fix this, the clear should always work, even when the player does not have permission.
 			final Set<Material> itemList = target.getData().getUnlimited();
-			for(Material mat : itemList)
+			for (Material mat : itemList)
 			{
 				toggleUnlimited(user, target, mat.toString());
-				
+
 			}
 		}
 		else
@@ -92,9 +93,9 @@ public class Commandunlimited extends EssentialsCommand
 		{
 			message = "enableUnlimited";
 			enableUnlimited = true;
-			if (!target.getInventory().containsItem(true, true, stack))
+			if (!InventoryWorkaround.containsItem(target.getPlayer().getInventory(), true, true, stack))
 			{
-				target.getInventory().addItem(stack);
+				InventoryWorkaround.addItem(target.getPlayer().getInventory(), false, stack);
 			}
 		}
 

Essentials/src/net/ess3/listener/EssentialsPlayerListener.java

@@ -136,11 +136,11 @@ public class EssentialsPlayerListener implements Listener
 		}
 		if (user.getData().getInventory() != null)
 		{
-			user.getInventory().setContents(user.getData().getInventory().getBukkitInventory());
+			user.getPlayer().getInventory().setContents(user.getData().getInventory().getBukkitInventory());
 			user.getData().setInventory(null);
 		}
 		user.updateActivity(false);
-		user.dispose();
+		//user.getPlayer().dispose();
 	}
 
 	@EventHandler(priority = EventPriority.MONITOR)
@@ -156,20 +156,20 @@ public class EssentialsPlayerListener implements Listener
 		user.acquireWriteLock();
 
 		user.updateDisplayName();
-		user.getData().setIpAddress(user.getAddress().getAddress().getHostAddress());
+		user.getData().setIpAddress(user.getPlayer().getAddress().getAddress().getHostAddress());
 		user.updateActivity(false);
 
 		for (String p : ess.getVanishedPlayers())
 		{
 			if (!Permissions.VANISH_SEE_OTHERS.isAuthorized(user))
 			{
-				user.hidePlayer(ess.getUserMap().getUser(p).getBase());
+				user.getPlayer().hidePlayer(ess.getUserMap().getUser(p).getPlayer());
 			}
 		}
 
 		if (Permissions.SLEEPINGIGNORED.isAuthorized(user))
 		{
-			user.setSleepingIgnored(true);
+			user.getPlayer().setSleepingIgnored(true);
 		}
 
 		@Cleanup
@@ -276,8 +276,8 @@ public class EssentialsPlayerListener implements Listener
 		final ItemStack hand = new ItemStack(Material.EGG, 1);
 		if (user.getData().hasUnlimited(hand.getType()))
 		{
-			user.getInventory().addItem(hand);
-			user.updateInventory();
+			user.getPlayer().getInventory().addItem(hand);
+			user.getPlayer().updateInventory();
 		}
 	}
 
@@ -295,7 +295,7 @@ public class EssentialsPlayerListener implements Listener
 				@Override
 				public void run()
 				{
-					user.updateInventory();
+					user.getPlayer().updateInventory();
 				}
 			});
 		}
@@ -316,7 +316,7 @@ public class EssentialsPlayerListener implements Listener
 				spyer.acquireReadLock();
 				if (spyer.getData().isSocialspy() && !user.equals(spyer))
 				{
-					player.sendMessage(user.getDisplayName() + " : " + event.getMessage());
+					player.sendMessage(user.getPlayer().getDisplayName() + " : " + event.getMessage());
 				}
 			}
 		}
@@ -395,7 +395,7 @@ public class EssentialsPlayerListener implements Listener
 
 	private boolean usePowertools(final IUser user)
 	{
-		final ItemStack is = user.getItemInHand();
+		final ItemStack is = user.getPlayer().getItemInHand();
 		int id;
 		if (is == null || (id = is.getTypeId()) == 0)
 		{
@@ -419,7 +419,7 @@ public class EssentialsPlayerListener implements Listener
 			else if (command.startsWith("c:"))
 			{
 				used = true;
-				user.chat(command.substring(2));
+				user.getPlayer().chat(command.substring(2));
 			}
 			else
 			{
@@ -430,7 +430,7 @@ public class EssentialsPlayerListener implements Listener
 							@Override
 							public void run()
 							{
-								user.getServer().dispatchCommand(user.getBase(), command);
+								user.getServer().dispatchCommand(user.getPlayer(), command);
 							}
 						});
 			}

Essentials/src/net/ess3/settings/General.java

@@ -1,29 +1,15 @@
 package net.ess3.settings;
 
-import java.util.HashMap;
-import java.util.Map;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import net.ess3.storage.Comment;
 import net.ess3.storage.StorageObject;
-import org.bukkit.entity.EntityType;
 
 
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class General implements StorageObject
 {
-	public General()
-	{
-		//Populate creature spawn values
-		for (EntityType t : EntityType.values())
-		{
-			if (t.isAlive())
-			{
-				creatureSpawn.put(t, false);
-			}
-		}
-	}
 	@Comment("Backup runs a command while saving is disabled")
 	private Backup backup = new Backup();
 	@Comment("You can disable the death messages of minecraft.")
@@ -92,21 +78,4 @@ public class General implements StorageObject
 		return loginAttackDelay * 1000;
 	}
 	public boolean metricsEnabled = true;
-//todo remove this
-	@Comment("Prevent creatures spawning")
-	private Map<EntityType, Boolean> creatureSpawn = new HashMap<EntityType, Boolean>();
-
-	public boolean getPreventSpawn(String creatureName)
-	{
-		return getPreventSpawn(EntityType.fromName(creatureName));
-	}
-
-	public boolean getPreventSpawn(EntityType creature)
-	{
-		if (creatureSpawn == null)
-		{
-			return false;
-		}
-		return creatureSpawn.get(creature);
-	}
 }

Essentials/src/net/ess3/settings/SpawnsHolder.java

@@ -180,7 +180,7 @@ public class SpawnsHolder extends AsyncStorageObjectHolder<Spawns> implements IE
 		acquireReadLock();
 		try
 		{
-			return getData().getNewPlayerAnnouncement().replace('&', '§').replace("§§", "&").replace("{PLAYER}", user.getDisplayName()).replace("{DISPLAYNAME}", user.getDisplayName()).replace("{GROUP}", ess.getRanks().getMainGroup(user)).replace("{USERNAME}", user.getName()).replace("{ADDRESS}", user.getAddress().toString());
+			return getData().getNewPlayerAnnouncement().replace('&', '§').replace("§§", "&").replace("{PLAYER}", user.getPlayer().getDisplayName()).replace("{DISPLAYNAME}", user.getPlayer().getDisplayName()).replace("{GROUP}", ess.getRanks().getMainGroup(user)).replace("{USERNAME}", user.getName()).replace("{ADDRESS}", user.getPlayer().getAddress().toString());
 		}
 		finally
 		{
@@ -249,7 +249,7 @@ public class SpawnsHolder extends AsyncStorageObjectHolder<Spawns> implements IE
 				}
 				else
 				{
-					home = user.getHome(user.getLocation());
+					home = user.getHome(user.getPlayer().getLocation());
 				}
 				if (home != null)
 				{
@@ -299,7 +299,7 @@ public class SpawnsHolder extends AsyncStorageObjectHolder<Spawns> implements IE
 			@Override
 			public void run()
 			{
-				if (user.getBase() instanceof OfflinePlayer)
+				if (user.getPlayer() instanceof OfflinePlayer)
 				{
 					return;
 				}

Essentials/src/net/ess3/settings/WorldOptions.java

@@ -1,14 +1,47 @@
 package net.ess3.settings;
 
+import java.util.HashMap;
+import java.util.Map;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import net.ess3.storage.Comment;
 import net.ess3.storage.StorageObject;
+import org.bukkit.entity.EntityType;
 
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class WorldOptions implements StorageObject
 {
+	
+	public WorldOptions()
+	{
+		//Populate creature spawn values
+		for (EntityType t : EntityType.values())
+		{
+			if (t.isAlive())
+			{
+				creatureSpawn.put(t, false);
+			}
+		}
+	}
+	
 	@Comment("Disables godmode for all players if they teleport to this world.")
 	private boolean godmode = true;
+	
+	@Comment("Prevent creatures spawning")
+	private Map<EntityType, Boolean> creatureSpawn = new HashMap<EntityType, Boolean>();
+
+	public boolean getPreventSpawn(String creatureName)
+	{
+		return getPreventSpawn(EntityType.fromName(creatureName));
+	}
+
+	public boolean getPreventSpawn(EntityType creature)
+	{
+		if (creatureSpawn == null)
+		{
+			return false;
+		}
+		return creatureSpawn.get(creature);
+	}
 }

Essentials/src/net/ess3/user/User.java

@@ -13,6 +13,7 @@ import net.ess3.Console;
 import static net.ess3.I18n._;
 import net.ess3.Teleport;
 import net.ess3.api.*;
+import net.ess3.craftbukkit.InventoryWorkaround;
 import net.ess3.economy.register.Method;
 import net.ess3.permissions.Permissions;
 import net.ess3.utils.DateUtil;
@@ -650,11 +651,11 @@ public class User extends UserBase implements IUser
 			settings.acquireReadLock();
 			int oversizedStackSize = settings.getData().getGeneral().getOversizedStacksize();
 
-			overfilled = getPlayer().getInventory().addItem(true, oversizedStackSize, itemStack);
+			overfilled = InventoryWorkaround.addItem(getPlayer().getInventory(), true, oversizedStackSize, itemStack);
 		}
 		else
 		{
-			overfilled = getPlayer().getInventory().addItem(true, itemStack);
+			overfilled = InventoryWorkaround.addItem(getPlayer().getInventory(), true, itemStack);
 		}
 		if (canSpew)
 		{

Essentials/src/net/ess3/utils/Util.java

@@ -339,7 +339,7 @@ public final class Util
 			return null;
 		}
 		String message;
-		if (Permissions.hasPermission(user.getBase(), permBase + ".color"))
+		if (Permissions.hasPermission(user.getPlayer(), permBase + ".color"))
 		{
 			message = Util.replaceColor(input, REPLACE_COLOR_PATTERN);
 		}
@@ -347,7 +347,7 @@ public final class Util
 		{
 			message = Util.stripColor(input, VANILLA_COLOR_PATTERN);
 		}
-		if (Permissions.hasPermission(user.getBase(), permBase + ".magic"))
+		if (Permissions.hasPermission(user.getPlayer(), permBase + ".magic"))
 		{
 			message = Util.replaceColor(message, REPLACE_MAGIC_PATTERN);
 		}
@@ -355,7 +355,7 @@ public final class Util
 		{
 			message = Util.stripColor(message, VANILLA_MAGIC_PATTERN);
 		}
-		if (Permissions.hasPermission(user.getBase(), permBase + ".format"))
+		if (Permissions.hasPermission(user.getPlayer(), permBase + ".format"))
 		{
 			message = Util.replaceColor(message, REPLACE_FORMAT_PATTERN);
 		}
@@ -373,7 +373,7 @@ public final class Util
 			return null;
 		}
 		String message = formatString(user, permBase, input);
-		if (!Permissions.hasPermission(user.getBase(), permBase + ".url"))
+		if (!Permissions.hasPermission(user.getPlayer(), permBase + ".url"))
 		{
 			message = Util.blockURL(message);
 		}

Essentials/src/net/ess3/utils/textreader/KeywordReplacer.java

@@ -38,19 +38,19 @@ public class KeywordReplacer implements IText
 		if (sender instanceof Player)
 		{
 			@Cleanup
-			final IUser user = ((Player)sender).getUser();
+			final IUser user = ess.getUserMap().getUser((Player)sender);
 			user.acquireReadLock();
 			user.setDisplayNick();
-			displayName = user.getDisplayName();
-			userName = user.getName();
-			ipAddress = user.getAddress() == null || user.getAddress().getAddress() == null ? "" : user.getAddress().getAddress().toString();
-			address = user.getAddress() == null ? "" : user.getAddress().toString();
+			displayName = user.getPlayer().getDisplayName();
+			userName = user.getPlayer().getName();
+			ipAddress = user.getPlayer().getAddress() == null || user.getPlayer().getAddress().getAddress() == null ? "" : user.getPlayer().getAddress().getAddress().toString();
+			address = user.getPlayer().getAddress() == null ? "" : user.getPlayer().getAddress().toString();
 			balance = Double.toString(user.getMoney());
 			mails = Integer.toString(user.getData().getMails() == null ? 0 : user.getData().getMails().size());
-			world = user.getLocation() == null || user.getLocation().getWorld() == null ? "" : user.getLocation().getWorld().getName();
-			worldTime12 = DescParseTickFormat.format12(user.getWorld() == null ? 0 : user.getWorld().getTime());
-			worldTime24 = DescParseTickFormat.format24(user.getWorld() == null ? 0 : user.getWorld().getTime());
-			worldDate = DateFormat.getDateInstance(DateFormat.MEDIUM, ess.getI18n().getCurrentLocale()).format(DescParseTickFormat.ticksToDate(user.getWorld() == null ? 0 : user.getWorld().getFullTime()));
+			world = user.getPlayer().getLocation() == null || user.getPlayer().getLocation().getWorld() == null ? "" : user.getPlayer().getLocation().getWorld().getName();
+			worldTime12 = DescParseTickFormat.format12(user.getPlayer().getWorld() == null ? 0 : user.getPlayer().getWorld().getTime());
+			worldTime24 = DescParseTickFormat.format24(user.getPlayer().getWorld() == null ? 0 : user.getPlayer().getWorld().getTime());
+			worldDate = DateFormat.getDateInstance(DateFormat.MEDIUM, ess.getI18n().getCurrentLocale()).format(DescParseTickFormat.ticksToDate(user.getPlayer().getWorld() == null ? 0 : user.getPlayer().getWorld().getFullTime()));
 		}
 		else
 		{
@@ -60,12 +60,12 @@ public class KeywordReplacer implements IText
 		int playerHidden = 0;
 		for (Player p : ess.getServer().getOnlinePlayers())
 		{
-			if (p.getUser().isHidden())
+			if (ess.getUserMap().getUser(p).isHidden())
 			{
 				playerHidden++;
 			}
 		}
-		online = Integer.toString(ess.getServer().getOnlinePlayers().size() - playerHidden);
+		online = Integer.toString(ess.getServer().getOnlinePlayers().length - playerHidden);
 		unique = Integer.toString(ess.getUserMap().getUniqueUsers());
 
 		final StringBuilder worldsBuilder = new StringBuilder();
@@ -82,7 +82,7 @@ public class KeywordReplacer implements IText
 		final StringBuilder playerlistBuilder = new StringBuilder();
 		for (Player p : ess.getServer().getOnlinePlayers())
 		{
-			if (p.getUser().isHidden())
+			if (ess.getUserMap().getUser(p).isHidden())
 			{
 				continue;
 			}

Essentials/test/net/ess3/FakeServer.java

@@ -7,6 +7,7 @@ import java.util.concurrent.Callable;
 import java.util.concurrent.Future;
 import java.util.logging.Logger;
 import org.bukkit.*;
+import org.bukkit.Warning.WarningState;
 import org.bukkit.World.Environment;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.ConsoleCommandSender;
@@ -931,4 +932,10 @@ public class FakeServer implements Server
 	{
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
+
+	@Override
+	public WarningState getWarningState()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
 }

Essentials/test/net/ess3/FakeWorld.java

@@ -675,4 +675,28 @@ public class FakeWorld implements World
 	{
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
+
+	@Override
+	public boolean isChunkInUse(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public FallingBlock spawnFallingBlock(Location lctn, Material mtrl, byte b) throws IllegalArgumentException
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public FallingBlock spawnFallingBlock(Location lctn, int i, byte b) throws IllegalArgumentException
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void playSound(Location lctn, Sound sound, float f, float f1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
 }

Essentials/test/net/ess3/StorageTest.java

@@ -1,13 +1,13 @@
 package net.ess3;
 
 import java.io.*;
-import net.ess3.api.server.Location;
 import net.ess3.settings.Settings;
 import net.ess3.storage.ObjectLoadException;
 import net.ess3.storage.StorageObject;
 import net.ess3.storage.YamlStorageReader;
 import net.ess3.storage.YamlStorageWriter;
 import net.ess3.utils.ExecuteTimer;
+import org.bukkit.Location;
 import org.junit.Test;
 
 
@@ -75,7 +75,7 @@ public class StorageTest extends EssentialsTest
 
 			for (int j = 0; j < 10000; j++)
 			{
-				userdata.getHomes().put("home", new net.ess3.storage.StoredLocation(Location.create(world, j, j, j)));
+				userdata.getHomes().put("home", new net.ess3.storage.StoredLocation(new Location(world, j, j, j)));
 			}
 			ext.mark("change home 10000 times");
 			final ByteArrayOutputStream baos = new ByteArrayOutputStream();

Essentials/test/net/ess3/testserver/TestPlugin.java

@@ -1,14 +1,46 @@
 package net.ess3.testserver;
 
+import com.avaje.ebean.EbeanServer;
 import java.io.File;
 import java.io.InputStream;
 import java.util.logging.Logger;
-import net.ess3.api.server.Location;
-import net.ess3.api.server.Player;
-import net.ess3.api.server.Plugin;
-import net.ess3.api.server.Server;
+import net.ess3.api.IEssentials;
+import net.ess3.api.IPlugin;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.PluginLoader;
 
-public class TestPlugin implements Plugin {
+public class TestPlugin implements IPlugin {
+
+	
+	@Override
+	public File getDataFolder()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+	
+	@Override
+	public InputStream getResource(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+	@Override
+	public Server getServer()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public IEssentials getEssentials()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
 
 	@Override
 	public int scheduleAsyncDelayedTask(Runnable run)
@@ -35,13 +67,13 @@ public class TestPlugin implements Plugin {
 	}
 
 	@Override
-	public File getRootFolder()
+	public int scheduleAsyncRepeatingTask(Runnable run, long delay, long period)
 	{
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
 	@Override
-	public File getDataFolder()
+	public File getRootFolder()
 	{
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
@@ -64,18 +96,6 @@ public class TestPlugin implements Plugin {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
-	@Override
-	public InputStream getResource(String string)
-	{
-		throw new UnsupportedOperationException("Not supported yet.");
-	}
-
-	@Override
-	public int scheduleAsyncRepeatingTask(Runnable run, long delay, long period)
-	{
-		throw new UnsupportedOperationException("Not supported yet.");
-	}
-
 	@Override
 	public Location callRespawnEvent(Player player, Location loc, boolean bedSpawn)
 	{
@@ -88,6 +108,96 @@ public class TestPlugin implements Plugin {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
+	@Override
+	public PluginDescriptionFile getDescription()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public FileConfiguration getConfig()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void saveConfig()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void saveDefaultConfig()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void saveResource(String string, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void reloadConfig()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public PluginLoader getPluginLoader()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isEnabled()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void onDisable()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void onLoad()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void onEnable()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isNaggable()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setNaggable(boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public EbeanServer getDatabase()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public ChunkGenerator getDefaultWorldGenerator(String string, String string1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
 	@Override
 	public Logger getLogger()
 	{
@@ -95,7 +205,13 @@ public class TestPlugin implements Plugin {
 	}
 
 	@Override
-	public Server getServer()
+	public String getName()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean onCommand(CommandSender cs, Command cmnd, String string, String[] strings)
 	{
 		throw new UnsupportedOperationException("Not supported yet.");
 	}

Essentials/test/net/ess3/testserver/TestServer.java

@@ -1,13 +1,36 @@
 package net.ess3.testserver;
 
-import java.util.Collection;
+import com.avaje.ebean.config.ServerConfig;
+import java.io.File;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.logging.Logger;
+import org.bukkit.GameMode;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.Server;
+import org.bukkit.Warning.WarningState;
 import org.bukkit.World;
+import org.bukkit.WorldCreator;
 import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.help.HelpMap;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.Recipe;
+import org.bukkit.map.MapView;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.ServicesManager;
+import org.bukkit.plugin.messaging.Messenger;
+import org.bukkit.scheduler.BukkitScheduler;
 
 public class TestServer implements Server {
 
@@ -87,4 +110,430 @@ public class TestServer implements Server {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
+	@Override
+	public String getName()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getBukkitVersion()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getMaxPlayers()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getPort()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getViewDistance()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getIp()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getServerName()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getServerId()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getWorldType()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getGenerateStructures()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getAllowEnd()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getAllowNether()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean hasWhitelist()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setWhitelist(boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Set<OfflinePlayer> getWhitelistedPlayers()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void reloadWhitelist()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getUpdateFolder()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public File getUpdateFolderFile()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public long getConnectionThrottle()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getTicksPerAnimalSpawns()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getTicksPerMonsterSpawns()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Player getPlayerExact(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<Player> matchPlayer(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public PluginManager getPluginManager()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public BukkitScheduler getScheduler()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public ServicesManager getServicesManager()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public World createWorld(WorldCreator wc)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadWorld(String string, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadWorld(World world, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public World getWorld(UUID uuid)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public MapView getMap(short s)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public MapView createMap(World world)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void reload()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Logger getLogger()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public PluginCommand getPluginCommand(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void savePlayers()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void configureDbConfig(ServerConfig sc)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean addRecipe(Recipe recipe)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<Recipe> getRecipesFor(ItemStack is)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Iterator<Recipe> recipeIterator()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void clearRecipes()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void resetRecipes()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Map<String, String[]> getCommandAliases()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getSpawnRadius()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setSpawnRadius(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getOnlineMode()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getAllowFlight()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean useExactLoginLocation()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void shutdown()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int broadcast(String string, String string1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public OfflinePlayer getOfflinePlayer(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Set<String> getIPBans()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Set<OfflinePlayer> getBannedPlayers()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Set<OfflinePlayer> getOperators()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public GameMode getDefaultGameMode()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setDefaultGameMode(GameMode gm)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public File getWorldContainer()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public OfflinePlayer[] getOfflinePlayers()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Messenger getMessenger()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public HelpMap getHelpMap()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Inventory createInventory(InventoryHolder ih, InventoryType it)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Inventory createInventory(InventoryHolder ih, int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Inventory createInventory(InventoryHolder ih, int i, String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getMonsterSpawnLimit()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getAnimalSpawnLimit()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getWaterAnimalSpawnLimit()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isPrimaryThread()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public String getMotd()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public WarningState getWarningState()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void sendPluginMessage(Plugin plugin, String string, byte[] bytes)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Set<String> getListeningPluginChannels()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
 }

Essentials/test/net/ess3/testserver/TestWorld.java

@@ -1,10 +1,38 @@
 package net.ess3.testserver;
 
+import java.io.File;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 import java.util.UUID;
+import org.bukkit.BlockChangeDelegate;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Difficulty;
+import org.bukkit.Effect;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
 import org.bukkit.World;
 import org.bukkit.TreeType;
+import org.bukkit.WorldType;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.CreatureType;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LightningStrike;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.util.Vector;
 
 public class TestWorld implements World {
 
@@ -26,12 +54,6 @@ public class TestWorld implements World {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
-	@Override
-	public ItemStack dropItem(Location loc, ItemStack stack)
-	{
-		throw new UnsupportedOperationException("Not supported yet.");
-	}
-
 	@Override
 	public UUID getUID()
 	{
@@ -44,12 +66,6 @@ public class TestWorld implements World {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
-	@Override
-	public void dropItemNaturally(Location location, ItemStack overflowStack)
-	{
-		throw new UnsupportedOperationException("Not supported yet.");
-	}
-
 	@Override
 	public void setStorm(boolean b)
 	{
@@ -74,4 +90,622 @@ public class TestWorld implements World {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
+	@Override
+	public Block getBlockAt(int i, int i1, int i2)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Block getBlockAt(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getBlockTypeIdAt(int i, int i1, int i2)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getBlockTypeIdAt(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getHighestBlockYAt(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Block getHighestBlockAt(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Block getHighestBlockAt(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Chunk getChunkAt(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Chunk getChunkAt(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Chunk getChunkAt(Block block)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isChunkLoaded(Chunk chunk)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Chunk[] getLoadedChunks()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void loadChunk(Chunk chunk)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isChunkLoaded(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isChunkInUse(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void loadChunk(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean loadChunk(int i, int i1, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadChunk(Chunk chunk)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadChunk(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadChunk(int i, int i1, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadChunk(int i, int i1, boolean bln, boolean bln1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadChunkRequest(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean unloadChunkRequest(int i, int i1, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean regenerateChunk(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean refreshChunk(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Item dropItem(Location lctn, ItemStack is)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Item dropItemNaturally(Location lctn, ItemStack is)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Arrow spawnArrow(Location lctn, Vector vector, float f, float f1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean generateTree(Location lctn, TreeType tt, BlockChangeDelegate bcd)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Entity spawnEntity(Location lctn, EntityType et)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public LivingEntity spawnCreature(Location lctn, EntityType et)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public LivingEntity spawnCreature(Location lctn, CreatureType ct)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public LightningStrike strikeLightning(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public LightningStrike strikeLightningEffect(Location lctn)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<Entity> getEntities()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<LivingEntity> getLivingEntities()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public <T extends Entity> Collection<T> getEntitiesByClass(Class<T>... types)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public <T extends Entity> Collection<T> getEntitiesByClass(Class<T> type)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Collection<Entity> getEntitiesByClasses(Class<?>... types)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<Player> getPlayers()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setTime(long l)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public long getFullTime()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setFullTime(long l)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean hasStorm()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getWeatherDuration()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isThundering()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setThundering(boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getThunderDuration()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setThunderDuration(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean createExplosion(double d, double d1, double d2, float f)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean createExplosion(double d, double d1, double d2, float f, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean createExplosion(Location lctn, float f)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean createExplosion(Location lctn, float f, boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Environment getEnvironment()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public long getSeed()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getPVP()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setPVP(boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public ChunkGenerator getGenerator()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void save()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<BlockPopulator> getPopulators()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public <T extends Entity> T spawn(Location lctn, Class<T> type) throws IllegalArgumentException
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public FallingBlock spawnFallingBlock(Location lctn, Material mtrl, byte b) throws IllegalArgumentException
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public FallingBlock spawnFallingBlock(Location lctn, int i, byte b) throws IllegalArgumentException
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void playEffect(Location lctn, Effect effect, int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void playEffect(Location lctn, Effect effect, int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public <T> void playEffect(Location lctn, Effect effect, T t)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public <T> void playEffect(Location lctn, Effect effect, T t, int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public ChunkSnapshot getEmptyChunkSnapshot(int i, int i1, boolean bln, boolean bln1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setSpawnFlags(boolean bln, boolean bln1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getAllowAnimals()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getAllowMonsters()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Biome getBiome(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setBiome(int i, int i1, Biome biome)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public double getTemperature(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public double getHumidity(int i, int i1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getMaxHeight()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getSeaLevel()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean getKeepSpawnInMemory()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setKeepSpawnInMemory(boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isAutoSave()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setAutoSave(boolean bln)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setDifficulty(Difficulty dfclt)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Difficulty getDifficulty()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public File getWorldFolder()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public WorldType getWorldType()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean canGenerateStructures()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public long getTicksPerAnimalSpawns()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setTicksPerAnimalSpawns(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public long getTicksPerMonsterSpawns()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setTicksPerMonsterSpawns(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getMonsterSpawnLimit()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setMonsterSpawnLimit(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getAnimalSpawnLimit()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setAnimalSpawnLimit(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public int getWaterAnimalSpawnLimit()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setWaterAnimalSpawnLimit(int i)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void playSound(Location lctn, Sound sound, float f, float f1)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void sendPluginMessage(Plugin plugin, String string, byte[] bytes)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Set<String> getListeningPluginChannels()
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void setMetadata(String string, MetadataValue mv)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public List<MetadataValue> getMetadata(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean hasMetadata(String string)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void removeMetadata(String string, Plugin plugin)
+	{
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
 }