WIP: Converted to a mutli-world/mutli-game type model

This branch adds a world aspect to almost all commands. Although the
Bukkit World class is used for reference, the world includes any nether
or end worlds too. By enabling multiworld, things like the protection
grid will operate independently in different world groups. The idea is
to enable one plugin to run mutliple worlds. For example run AcidIsland,
ASkyGrid and BSkyBlock at the same time.

In addition to this big change, I added an admin command to copy and
paste "simple" schematics that I called "schems". It does not work
completely correctly right now, especially for chest contents.

src/main/java/us/tastybento/bskyblock/api/commands/CompositeCommand.java

@@ -11,6 +11,7 @@ import java.util.Set;
 import java.util.UUID;
 import java.util.logging.Logger;
 
+import org.bukkit.World;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.PluginIdentifiableCommand;
@@ -225,11 +226,12 @@ public abstract class CompositeCommand extends Command implements PluginIdentifi
 
     /**
      * Convenience method to obtain team members
+     * @param world - world to check
      * @param user - the User
      * @return set of UUIDs of all team members
      */
-    protected Set<UUID> getMembers(User user) {
-        return plugin.getIslands().getMembers(user.getUniqueId());
+    protected Set<UUID> getMembers(World world, User user) {
+        return plugin.getIslands().getMembers(world, user.getUniqueId());
     }
 
     public String getParameters() {
@@ -293,11 +295,12 @@ public abstract class CompositeCommand extends Command implements PluginIdentifi
 
     /**
      * Convenience method to obtain the user's team leader
+     * @param world - world to check
      * @param user - the User
      * @return UUID of player's team leader or null if user has no island
      */
-    protected UUID getTeamLeader(User user) {
-        return plugin.getIslands().getTeamLeader(user.getUniqueId());
+    protected UUID getTeamLeader(World world, User user) {
+        return plugin.getIslands().getTeamLeader(world, user.getUniqueId());
     }
 
     @Override
@@ -325,11 +328,12 @@ public abstract class CompositeCommand extends Command implements PluginIdentifi
 
     /**
      * Convenience method to check if a user has a team
+     * @param world - the world to check
      * @param user - the User
      * @return true if player is in a team
      */
-    protected boolean inTeam(User user) {
-        return plugin.getIslands().inTeam(user.getUniqueId());
+    protected boolean inTeam(World world, User user) {
+        return plugin.getIslands().inTeam(world, user.getUniqueId());
     }
 
     /**

src/main/java/us/tastybento/bskyblock/api/events/island/IslandEvent.java

@@ -2,9 +2,9 @@ package us.tastybento.bskyblock.api.events.island;
 
 import java.util.UUID;
 
+import org.bukkit.Bukkit;
 import org.bukkit.Location;
 
-import us.tastybento.bskyblock.BSkyBlock;
 import us.tastybento.bskyblock.api.events.IslandBaseEvent;
 import us.tastybento.bskyblock.database.objects.Island;
 
@@ -151,47 +151,47 @@ public class IslandEvent {
             switch (reason) {
             case CREATE:
                 IslandCreateEvent create = new IslandCreateEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(create);
+                Bukkit.getServer().getPluginManager().callEvent(create);
                 return create;
             case CREATED:
                 IslandCreatedEvent created = new IslandCreatedEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(created);
+                Bukkit.getServer().getPluginManager().callEvent(created);
                 return created;
             case DELETE:
                 IslandDeleteEvent delete = new IslandDeleteEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(delete);
+                Bukkit.getServer().getPluginManager().callEvent(delete);
                 return delete;
             case DELETED:
                 IslandDeletedEvent deleted = new IslandDeletedEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(deleted);
+                Bukkit.getServer().getPluginManager().callEvent(deleted);
                 return deleted;
             case ENTER:
                 IslandEnterEvent enter = new IslandEnterEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(enter);
+                Bukkit.getServer().getPluginManager().callEvent(enter);
                 return enter;
             case EXIT:
                 IslandExitEvent exit = new IslandExitEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(exit);
+                Bukkit.getServer().getPluginManager().callEvent(exit);
                 return exit;
             case LOCK:
                 IslandLockEvent lock = new IslandLockEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(lock);
+                Bukkit.getServer().getPluginManager().callEvent(lock);
                 return lock;
             case RESET:
                 IslandResetEvent reset = new IslandResetEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(reset);
+                Bukkit.getServer().getPluginManager().callEvent(reset);
                 return reset;
             case RESETTED:
                 IslandResettedEvent resetted = new IslandResettedEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(resetted);
+                Bukkit.getServer().getPluginManager().callEvent(resetted);
                 return resetted;
             case UNLOCK:
                 IslandUnlockEvent unlock = new IslandUnlockEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(unlock);
+                Bukkit.getServer().getPluginManager().callEvent(unlock);
                 return unlock;
             default:
                 IslandGeneralEvent general = new IslandGeneralEvent(island, player, admin, location);
-                BSkyBlock.getInstance().getServer().getPluginManager().callEvent(general);
+                Bukkit.getServer().getPluginManager().callEvent(general);
                 return general;
             }
 

src/main/java/us/tastybento/bskyblock/api/flags/Flag.java

@@ -125,7 +125,7 @@ public class Flag implements Comparable<Flag> {
      */
     public PanelItem toPanelItem(BSkyBlock plugin, User user) {
         // Get the island this user is on or their own
-        Island island = plugin.getIslands().getIslandAt(user.getLocation()).orElse(plugin.getIslands().getIsland(user.getUniqueId()));
+        Island island = plugin.getIslands().getIslandAt(user.getLocation()).orElse(plugin.getIslands().getIsland(user.getWorld(), user.getUniqueId()));
         String rank = RanksManager.OWNER_RANK_REF;
         if (island != null) {
             // TODO: Get the world settings - the player has no island and is not in an island location

src/main/java/us/tastybento/bskyblock/commands/AdminCommand.java

@@ -8,6 +8,7 @@ import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.admin.AdminGetRankCommand;
 import us.tastybento.bskyblock.commands.admin.AdminInfoCommand;
 import us.tastybento.bskyblock.commands.admin.AdminReloadCommand;
+import us.tastybento.bskyblock.commands.admin.AdminSchemCommand;
 import us.tastybento.bskyblock.commands.admin.AdminSetRankCommand;
 import us.tastybento.bskyblock.commands.admin.AdminTeleportCommand;
 import us.tastybento.bskyblock.commands.admin.AdminVersionCommand;
@@ -41,6 +42,8 @@ public class AdminCommand extends CompositeCommand {
         new AdminTeamKickCommand(this);
         new AdminTeamDisbandCommand(this);
         new AdminTeamMakeLeaderCommand(this);
+        // Schems
+        new AdminSchemCommand(this);
     }
 
     @Override

src/main/java/us/tastybento/bskyblock/commands/IslandCommand.java

@@ -63,9 +63,10 @@ public class IslandCommand extends CompositeCommand {
         if (user == null) {
             return false;
         }
+        // TODO: set up different games
         if (args.isEmpty()) {
             // If this player does not have an island, create one
-            if (!getPlugin().getIslands().hasIsland(user.getUniqueId())) {
+            if (!getPlugin().getIslands().hasIsland(user.getWorld(), user.getUniqueId())) {
                 return getSubCommand("create").map(createCmd -> createCmd.execute(user, new ArrayList<>())).orElse(false);
             } else {
                 // Otherwise, currently, just go home

src/main/java/us/tastybento/bskyblock/commands/admin/AdminGetRankCommand.java

@@ -9,6 +9,7 @@ import java.util.UUID;
 import java.util.stream.Collectors;
 
 import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 
 import us.tastybento.bskyblock.Constants;
@@ -43,6 +44,9 @@ public class AdminGetRankCommand extends CompositeCommand {
      */
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         if (args.size() != 1) {
             // Show help
             showHelp(this, user);
@@ -54,14 +58,14 @@ public class AdminGetRankCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getPlugin().getIslands().hasIsland(targetUUID)) {
+        if (!getPlugin().getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.player-has-no-island");
             return false;
         }
         // Get rank
         RanksManager rm = getPlugin().getRanksManager();
         User target = User.getInstance(targetUUID);     
-        Island island = getPlugin().getIslands().getIsland(targetUUID);       
+        Island island = getPlugin().getIslands().getIsland(world, targetUUID);       
         int currentRank = island.getRank(target);
         user.sendMessage("commands.admin.getrank.rank-is", "[rank]", user.getTranslation(rm.getRank(currentRank)));
         return true;

src/main/java/us/tastybento/bskyblock/commands/admin/AdminInfoCommand.java

@@ -3,6 +3,8 @@ package us.tastybento.bskyblock.commands.admin;
 import java.util.List;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -23,6 +25,9 @@ public class AdminInfoCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         if (args.size() > 1 || (args.isEmpty() && !user.isPlayer())) {
             // Show help
             showHelp(this, user);
@@ -42,12 +47,12 @@ public class AdminInfoCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getIslands().hasIsland(targetUUID)) {
+        if (!getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.player-has-no-island");
             return false;
         }
         // Show info for this player    
-        getIslands().getIsland(targetUUID).showInfo(getPlugin(), user);       
+        getIslands().getIsland(world, targetUUID).showInfo(getPlugin(), user);       
         return true;
     }
 }

src/main/java/us/tastybento/bskyblock/commands/admin/AdminRegisterCommand.java

@@ -4,6 +4,8 @@ import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -26,6 +28,9 @@ public class AdminRegisterCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         // If args are not right, show help
         if (args.size() != 1) {
             showHelp(this, user);
@@ -37,11 +42,11 @@ public class AdminRegisterCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (getIslands().hasIsland(targetUUID)) {
+        if (getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.player-has-island");
             return false;
         }
-        if (getIslands().inTeam(targetUUID)) {
+        if (getIslands().inTeam(world, targetUUID)) {
             user.sendMessage("commands.admin.register.cannot-register-team-player");
             return false;
         }

src/main/java/us/tastybento/bskyblock/commands/admin/AdminSchemCommand.java

@@ -0,0 +1,112 @@
+package us.tastybento.bskyblock.commands.admin;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import us.tastybento.bskyblock.Constants;
+import us.tastybento.bskyblock.api.commands.CompositeCommand;
+import us.tastybento.bskyblock.api.user.User;
+import us.tastybento.bskyblock.island.builders.Clipboard;
+
+public class AdminSchemCommand extends CompositeCommand {
+    private Map<UUID, Clipboard> clipboards;
+    private File schemFolder;
+
+    public AdminSchemCommand(CompositeCommand parent) {
+        super(parent, "schem");
+    }
+
+    public void setup() {
+        setPermission(Constants.PERMPREFIX + "admin.schem");
+        setParameters("commands.admin.schem.parameters");
+        setDescription("commands.admin.schem.description");
+        setOnlyPlayer(true);
+        clipboards = new HashMap<>();
+        schemFolder = new File(getPlugin().getDataFolder(), "schems");
+        if (!schemFolder.exists()) {
+            schemFolder.mkdirs();
+        }
+    }
+
+    public boolean execute(User user, List<String> args) {
+        if (args.isEmpty()) {
+            showHelp(this, user);
+            return false;
+        }
+        Clipboard cb = clipboards.getOrDefault(user.getUniqueId(), new Clipboard(getPlugin()));
+
+        if (args.get(0).equalsIgnoreCase("paste")) {
+            if (cb.isFull()) {
+                cb.paste(user.getLocation());
+                user.sendMessage("general.success");
+                return true;
+            } else {
+                user.sendMessage("commands.admin.schem.copy-first");
+                return true;
+            }
+        }
+
+        if (args.get(0).equalsIgnoreCase("load")) {
+            if (args.size() == 2) {
+                File file = new File(schemFolder, args.get(1) + ".schem"); 
+                if (file.exists()) {
+                    try {
+                        cb.load(file);
+                        return true;
+                    } catch (Exception e) {
+                        user.sendMessage("commands.admin.schem.could-not-load");
+                        e.printStackTrace();
+                        return false;
+                    }  
+                } else {
+                    user.sendMessage("commands.admin.schem.no-such-file");
+                    return false;
+                }
+            } else {
+                showHelp(this, user);
+                return false;
+            }
+        }
+
+        if (args.get(0).equalsIgnoreCase("copy")) {
+            return cb.copy(user);
+        }
+
+        if (args.get(0).equalsIgnoreCase("save")) {
+            if (cb.isFull()) {
+                if (args.size() == 2) {
+                    File file = new File(schemFolder, args.get(1)); 
+                    user.sendMessage("general.success");
+                    cb.save(file);
+                    return true;
+                } else {
+                    showHelp(this, user);
+                    return false;
+                }
+            } else {
+                user.sendMessage("commands.admin.schem.copy-first");
+                return false;
+            }
+        }
+
+        if (args.get(0).equalsIgnoreCase("pos1")) {
+            cb.setPos1(user.getLocation());
+            user.sendMessage("commands.admin.schem.set-pos1", "[vector]", user.getLocation().toVector().toString());
+            clipboards.put(user.getUniqueId(), cb);
+            return true;
+        }
+
+        if (args.get(0).equalsIgnoreCase("pos2")) {
+            cb.setPos2(user.getLocation());
+            user.sendMessage("commands.admin.schem.set-pos2", "[vector]", user.getLocation().toVector().toString());
+            clipboards.put(user.getUniqueId(), cb);
+            return true;
+        }
+
+        return false;
+    }
+
+}

src/main/java/us/tastybento/bskyblock/commands/admin/AdminSetRankCommand.java

@@ -8,6 +8,8 @@ import java.util.Optional;
 import java.util.UUID;
 import java.util.stream.Collectors;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -40,6 +42,9 @@ public class AdminSetRankCommand extends CompositeCommand {
      */
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         if (args.size() != 2) {
             // Show help
             showHelp(this, user);
@@ -51,7 +56,7 @@ public class AdminSetRankCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getPlugin().getIslands().hasIsland(targetUUID)) {
+        if (!getPlugin().getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.player-has-no-island");
             return false;
         }
@@ -66,7 +71,7 @@ public class AdminSetRankCommand extends CompositeCommand {
         }
         User target = User.getInstance(targetUUID);
         
-        Island island = getPlugin().getIslands().getIsland(targetUUID);       
+        Island island = getPlugin().getIslands().getIsland(world, targetUUID);       
         int currentRank = island.getRank(target);
         island.setRank(target, rankValue);
         user.sendMessage("commands.admin.setrank.rank-set", "[from]", user.getTranslation(rm.getRank(currentRank)), "[to]", user.getTranslation(rm.getRank(rankValue)));

src/main/java/us/tastybento/bskyblock/commands/admin/AdminTeleportCommand.java

@@ -6,6 +6,7 @@ import java.util.Optional;
 import java.util.UUID;
 
 import org.bukkit.Location;
+import org.bukkit.World;
 
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
@@ -29,6 +30,9 @@ public class AdminTeleportCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         if (args.isEmpty()) {
             this.showHelp(this, user);
             return true;
@@ -40,12 +44,12 @@ public class AdminTeleportCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         } else {
-            if (getIslands().hasIsland(targetUUID) || getIslands().inTeam(targetUUID)) {
-                Location warpSpot = getIslands().getIslandLocation(targetUUID).toVector().toLocation(getPlugin().getIslandWorldManager().getIslandWorld());
+            if (getIslands().hasIsland(world, targetUUID) || getIslands().inTeam(world, targetUUID)) {
+                Location warpSpot = getIslands().getIslandLocation(world, targetUUID).toVector().toLocation(getPlugin().getIslandWorldManager().getIslandWorld());
                 if (getLabel().equals("tpnether")) {
-                    warpSpot = getIslands().getIslandLocation(targetUUID).toVector().toLocation(getPlugin().getIslandWorldManager().getNetherWorld());
+                    warpSpot = getIslands().getIslandLocation(world, targetUUID).toVector().toLocation(getPlugin().getIslandWorldManager().getNetherWorld());
                 } else if (getLabel().equals("tpend")) {
-                    warpSpot = getIslands().getIslandLocation(targetUUID).toVector().toLocation(getPlugin().getIslandWorldManager().getEndWorld());
+                    warpSpot = getIslands().getIslandLocation(world, targetUUID).toVector().toLocation(getPlugin().getIslandWorldManager().getEndWorld());
                 }
                 // Other wise, go to a safe spot
                 String failureMessage = user.getTranslation("commands.admin.tp.manual", "[location]", warpSpot.getBlockX() + " " + warpSpot.getBlockY() + " "

src/main/java/us/tastybento/bskyblock/commands/admin/AdminUnregisterCommand.java

@@ -3,6 +3,8 @@ package us.tastybento.bskyblock.commands.admin;
 import java.util.List;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -23,6 +25,9 @@ public class AdminUnregisterCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         // If args are not right, show help
         if (args.size() != 1) {
             showHelp(this, user);
@@ -34,17 +39,17 @@ public class AdminUnregisterCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getIslands().hasIsland(targetUUID)) {
+        if (!getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.player-has-no-island");
             return false;
         }
-        if (getIslands().inTeam(targetUUID)) {
+        if (getIslands().inTeam(world, targetUUID)) {
             user.sendMessage("commands.admin.unregister.cannot-unregister-team-player");
             return false;
         }
         // Unregister island
-        user.sendMessage("commands.admin.unregister.unregistered-island", "[xyz]", Util.xyz(getIslands().getIsland(targetUUID).getCenter().toVector()));
-        getIslands().removePlayer(targetUUID);
+        user.sendMessage("commands.admin.unregister.unregistered-island", "[xyz]", Util.xyz(getIslands().getIsland(world, targetUUID).getCenter().toVector()));
+        getIslands().removePlayer(world, targetUUID);
         user.sendMessage("general.success");
         return true;
     }

src/main/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamAddCommand.java

@@ -3,6 +3,8 @@ package us.tastybento.bskyblock.commands.admin.teams;
 import java.util.List;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -23,6 +25,8 @@ public class AdminTeamAddCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
         // If args are not right, show help
         if (args.size() != 2) {
             showHelp(this, user);
@@ -39,20 +43,20 @@ public class AdminTeamAddCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player-name", "[name]", args.get(1));
             return false;
         }
-        if (!getIslands().hasIsland(leaderUUID)) {
+        if (!getIslands().hasIsland(world, leaderUUID)) {
             user.sendMessage("general.errors.player-has-no-island");
             return false;
         }
-        if (getIslands().inTeam(leaderUUID) && !getIslands().getTeamLeader(leaderUUID).equals(leaderUUID)) {
+        if (getIslands().inTeam(world, leaderUUID) && !getIslands().getTeamLeader(world, leaderUUID).equals(leaderUUID)) {
             user.sendMessage("commands.admin.team.add.name-not-leader", "[name]", args.get(0));
-            getIslands().getIsland(leaderUUID).showMembers(getPlugin(), user);
+            getIslands().getIsland(world, leaderUUID).showMembers(getPlugin(), user);
             return false;
         }
-        if (getIslands().inTeam(targetUUID)) {
+        if (getIslands().inTeam(world, targetUUID)) {
             user.sendMessage("commands.island.team.invite.errors.already-on-team");
             return false;
         }
-        if (getIslands().hasIsland(targetUUID)) {
+        if (getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("commands.admin.team.add.name-has-island", "[name]", args.get(1));
             return false;
         }
@@ -61,7 +65,7 @@ public class AdminTeamAddCommand extends CompositeCommand {
         User leader = User.getInstance(leaderUUID);
         leader.sendMessage("commands.island.team.invite.accept.name-joined-your-island", "[name]", target.getName());
         target.sendMessage("commands.island.team.invite.accept.you-joined-island", "[label]", Constants.ISLANDCOMMAND);
-        getIslands().getIsland(leaderUUID).addMember(targetUUID);
+        getIslands().getIsland(world, leaderUUID).addMember(targetUUID);
         user.sendMessage("general.success");
         return true;
 

src/main/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamDisbandCommand.java

@@ -3,6 +3,8 @@ package us.tastybento.bskyblock.commands.admin.teams;
 import java.util.List;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -22,6 +24,9 @@ public class AdminTeamDisbandCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         // If args are not right, show help
         if (args.size() != 1) {
             showHelp(this, user);
@@ -33,24 +38,24 @@ public class AdminTeamDisbandCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getIslands().hasIsland(targetUUID)) {
+        if (!getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getIslands().inTeam(targetUUID)) {
+        if (!getIslands().inTeam(world, targetUUID)) {
             user.sendMessage("general.errors.not-in-team");
             return false;
         }
-        if (!getIslands().getTeamLeader(targetUUID).equals(targetUUID)) {
-            user.sendMessage("commands.admin.team.disband.use-disband-leader", "[leader]", getPlayers().getName(getIslands().getTeamLeader(targetUUID)));
+        if (!getIslands().getTeamLeader(world, targetUUID).equals(targetUUID)) {
+            user.sendMessage("commands.admin.team.disband.use-disband-leader", "[leader]", getPlayers().getName(getIslands().getTeamLeader(world, targetUUID)));
             return false;
         }
         // Disband team
-        getIslands().getMembers(targetUUID).forEach(m -> {
+        getIslands().getMembers(world, targetUUID).forEach(m -> {
             User.getInstance(m).sendMessage("commands.admin.team.disband.disbanded");
             // The leader gets to keep the island
             if (!m.equals(targetUUID)) {
-                getIslands().setLeaveTeam(m);
+                getIslands().setLeaveTeam(world, m);
             }
         });
         user.sendMessage("general.success");

src/main/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamKickCommand.java

@@ -3,6 +3,8 @@ package us.tastybento.bskyblock.commands.admin.teams;
 import java.util.List;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -23,6 +25,9 @@ public class AdminTeamKickCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         // If args are not right, show help
         if (args.size() != 1) {
             showHelp(this, user);
@@ -34,21 +39,21 @@ public class AdminTeamKickCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getIslands().hasIsland(targetUUID)) {
+        if (!getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getIslands().inTeam(targetUUID)) {
+        if (!getIslands().inTeam(world, targetUUID)) {
             user.sendMessage("general.errors.not-in-team");
             return false;
         }
-        if (getIslands().getTeamLeader(targetUUID).equals(targetUUID)) {
+        if (getIslands().getTeamLeader(world, targetUUID).equals(targetUUID)) {
             user.sendMessage("commands.admin.team.kick.cannot-kick-leader");
-            getIslands().getIsland(targetUUID).showMembers(getPlugin(), user);
+            getIslands().getIsland(world, targetUUID).showMembers(getPlugin(), user);
             return false;
         }
         User.getInstance(targetUUID).sendMessage("commands.admin.team.kick.admin-kicked");
-        getIslands().removePlayer(targetUUID);
+        getIslands().removePlayer(world, targetUUID);
         user.sendMessage("general.success");
         return true;
 

src/main/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamMakeLeaderCommand.java

@@ -3,6 +3,8 @@ package us.tastybento.bskyblock.commands.admin.teams;
 import java.util.List;
 import java.util.UUID;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.user.User;
@@ -22,6 +24,9 @@ public class AdminTeamMakeLeaderCommand extends CompositeCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+
         // If args are not right, show help
         if (args.size() != 1) {
             showHelp(this, user);
@@ -33,20 +38,20 @@ public class AdminTeamMakeLeaderCommand extends CompositeCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getIslands().hasIsland(targetUUID)) {
+        if (!getIslands().hasIsland(world, targetUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getIslands().inTeam(targetUUID)) {
+        if (!getIslands().inTeam(world, targetUUID)) {
             user.sendMessage("general.errors.not-in-team");
             return false;
         }
-        if (getIslands().getTeamLeader(targetUUID).equals(targetUUID)) {
+        if (getIslands().getTeamLeader(world, targetUUID).equals(targetUUID)) {
             user.sendMessage("commands.admin.team.makeleader.already-leader");
             return false;
         }
         // Make new leader
-        getIslands().makeLeader(user, targetUUID);
+        getIslands().makeLeader(world, user, targetUUID);
         user.sendMessage("general.success");
         return true;
     }

src/main/java/us/tastybento/bskyblock/commands/island/IslandBanCommand.java

@@ -38,11 +38,11 @@ public class IslandBanCommand extends CompositeCommand {
         }
         UUID playerUUID = user.getUniqueId();
         // Player issuing the command must have an island
-        if (!getIslands().hasIsland(playerUUID)) {
+        if (!getIslands().hasIsland(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getIslands().isOwner(playerUUID)) {
+        if (!getIslands().isOwner(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.not-leader");
             return false;
         }
@@ -57,11 +57,11 @@ public class IslandBanCommand extends CompositeCommand {
             user.sendMessage("commands.island.ban.cannot-ban-yourself");
             return false;
         }
-        if (getIslands().getMembers(user.getUniqueId()).contains(targetUUID)) {
+        if (getIslands().getMembers(user.getWorld(), user.getUniqueId()).contains(targetUUID)) {
             user.sendMessage("commands.island.ban.cannot-ban-member");
             return false; 
         }
-        if (getIslands().getIsland(playerUUID).isBanned(targetUUID)) {
+        if (getIslands().getIsland(user.getWorld(), playerUUID).isBanned(targetUUID)) {
             user.sendMessage("commands.island.ban.player-already-banned");
             return false; 
         }        
@@ -76,13 +76,13 @@ public class IslandBanCommand extends CompositeCommand {
     }
 
     private boolean ban(User user, User targetUser) {
-        Island island = getIslands().getIsland(user.getUniqueId());
+        Island island = getIslands().getIsland(user.getWorld(), user.getUniqueId());
         if (island.addToBanList(targetUser.getUniqueId())) {
             user.sendMessage("general.success");
             targetUser.sendMessage("commands.island.ban.owner-banned-you", "[owner]", user.getName());
             // If the player is online, has an island and on the banned island, move them home immediately
-            if (targetUser.isOnline() && getIslands().hasIsland(targetUser.getUniqueId()) && island.onIsland(targetUser.getLocation())) {
-                getIslands().homeTeleport(targetUser.getPlayer());
+            if (targetUser.isOnline() && getIslands().hasIsland(user.getWorld(), targetUser.getUniqueId()) && island.onIsland(targetUser.getLocation())) {
+                getIslands().homeTeleport(user.getWorld(), targetUser.getPlayer());
                 island.getWorld().playSound(targetUser.getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 1F, 1F);
             }            
             return true;
@@ -97,7 +97,7 @@ public class IslandBanCommand extends CompositeCommand {
             // Don't show every player on the server. Require at least the first letter
             return Optional.empty();
         }
-        Island island = getIslands().getIsland(user.getUniqueId());
+        Island island = getIslands().getIsland(user.getWorld(), user.getUniqueId());
         List<String> options = Bukkit.getOnlinePlayers().stream()
                 .filter(p -> !p.getUniqueId().equals(user.getUniqueId()))
                 .filter(p -> !island.isBanned(p.getUniqueId()))

src/main/java/us/tastybento/bskyblock/commands/island/IslandBanlistCommand.java

@@ -30,11 +30,11 @@ public class IslandBanlistCommand extends CompositeCommand {
             return false;
         } 
         // Player issuing the command must have an island       
-        if (!getIslands().hasIsland(user.getUniqueId())) {
+        if (!getIslands().hasIsland(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.no-island");
             return false; 
         }
-        Island island = getIslands().getIsland(user.getUniqueId());
+        Island island = getIslands().getIsland(user.getWorld(), user.getUniqueId());
         // Show all the players banned on the island
         if (island.getBanned().isEmpty()) {
             user.sendMessage("commands.island.banlist.noone");

src/main/java/us/tastybento/bskyblock/commands/island/IslandCreateCommand.java

@@ -6,6 +6,8 @@ package us.tastybento.bskyblock.commands.island;
 import java.io.IOException;
 import java.util.List;
 
+import org.bukkit.World;
+
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.api.commands.CompositeCommand;
 import us.tastybento.bskyblock.api.events.island.IslandEvent.Reason;
@@ -36,32 +38,31 @@ public class IslandCreateCommand extends CompositeCommand {
      */
     @Override
     public boolean execute(User user, List<String> args) {
-        if (getIslands().hasIsland(user.getUniqueId())) {
+        // TODO: fix world
+        World world = getPlugin().getIslandWorldManager().getIslandWorld();
+        if (!args.isEmpty()) {
+            // Get game types
+            // TODO
+        }
+        if (getIslands().hasIsland(world, user.getUniqueId())) {
             user.sendMessage("general.errors.already-have-island");
             return false;
         }
-        if (getIslands().inTeam(user.getUniqueId())) {
+        if (getIslands().inTeam(world, user.getUniqueId())) {
             return false;
         }
         user.sendMessage("commands.island.create.creating-island");
-        createIsland(user);
-        return true;
-    }
-
-    /**
-     * Creates an island for player
-     *
-     * @param user - the User
-     */
-    protected void createIsland(User user) {
         try {
             NewIsland.builder()
-            .player(user.getPlayer())
+            .player(user)
+            .world(world)
             .reason(Reason.CREATE)
             .build();
+            return true;
         } catch (IOException e) {
             getPlugin().logError("Could not create island for player. " + e.getMessage());
             user.sendMessage("commands.island.create.unable-create-island");
+            return false;
         }
     }
 }

src/main/java/us/tastybento/bskyblock/commands/island/IslandGoCommand.java

@@ -39,7 +39,7 @@ public class IslandGoCommand extends CompositeCommand {
      */
     @Override
     public boolean execute(User user, List<String> args) {
-        if (!getIslands().hasIsland(user.getUniqueId())) {
+        if (!getIslands().hasIsland(user.getWorld(), user.getUniqueId())) {
             user.sendMessage(ChatColor.RED + "general.errors.no-island");
             return false;
         }
@@ -47,11 +47,11 @@ public class IslandGoCommand extends CompositeCommand {
             int homeValue = Integer.valueOf(args.get(0));
             int maxHomes = Util.getPermValue(user.getPlayer(), Constants.PERMPREFIX + "island.maxhomes", getSettings().getMaxHomes());
             if (homeValue > 1  && homeValue <= maxHomes) {
-                getIslands().homeTeleport(user.getPlayer(), homeValue);
+                getIslands().homeTeleport(user.getWorld(), user.getPlayer(), homeValue);
                 return true;
             }
         }
-        getIslands().homeTeleport(user.getPlayer());
+        getIslands().homeTeleport(user.getWorld(), user.getPlayer());
         return true;
     }
 

src/main/java/us/tastybento/bskyblock/commands/island/IslandResetCommand.java

@@ -43,15 +43,15 @@ public class IslandResetCommand extends CompositeCommand {
             user.sendMessage("general.errors.you-must-wait", SECONDS_PLACEHOLDER, String.valueOf(onRestartWaitTime(user)));
             return false;
         }
-        if (!getIslands().hasIsland(user.getUniqueId())) {
+        if (!getIslands().hasIsland(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getIslands().isOwner(user.getUniqueId())) {
+        if (!getIslands().isOwner(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.not-leader");
             return false;
         }
-        if (getIslands().inTeam(user.getUniqueId())) {
+        if (getIslands().inTeam(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("commands.island.reset.must-remove-members");
             return false;
         }
@@ -105,13 +105,13 @@ public class IslandResetCommand extends CompositeCommand {
         Player player = user.getPlayer();
         player.setGameMode(GameMode.SPECTATOR);
         // Get the player's old island
-        Island oldIsland = getIslands().getIsland(player.getUniqueId());
+        Island oldIsland = getIslands().getIsland(user.getWorld(), player.getUniqueId());
         // Remove them from this island (it still exists and will be deleted later)
-        getIslands().removePlayer(player.getUniqueId());
+        getIslands().removePlayer(user.getWorld(), player.getUniqueId());
         // Create new island and then delete the old one
         try {
             NewIsland.builder()
-            .player(player)
+            .player(user)
             .reason(Reason.RESET)
             .oldIsland(oldIsland)
             .build();

src/main/java/us/tastybento/bskyblock/commands/island/IslandResetnameCommand.java

@@ -35,17 +35,17 @@ public class IslandResetnameCommand extends CompositeCommand {
     public boolean execute(User user, List<String> args) {
         UUID playerUUID = user.getUniqueId();
 
-        if (!getIslands().hasIsland(playerUUID)) {
+        if (!getIslands().hasIsland(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
 
-        if (!getIslands().isOwner(playerUUID)) {
+        if (!getIslands().isOwner(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.not-leader");
             return false;
         }
         // Resets the island name
-        getIslands().getIsland(playerUUID).setName(null);
+        getIslands().getIsland(user.getWorld(), playerUUID).setName(null);
 
         user.sendMessage("general.success");
         return true;

src/main/java/us/tastybento/bskyblock/commands/island/IslandSethomeCommand.java

@@ -26,11 +26,11 @@ public class IslandSethomeCommand extends CompositeCommand {
     public boolean execute(User user, List<String> args) {
         UUID playerUUID = user.getUniqueId();
         // Check island
-        if (getPlugin().getIslands().getIsland(user.getUniqueId()) == null) {
+        if (getPlugin().getIslands().getIsland(user.getWorld(), user.getUniqueId()) == null) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getPlugin().getIslands().userIsOnIsland(user)) {
+        if (!getPlugin().getIslands().userIsOnIsland(user.getWorld(), user)) {
             user.sendMessage("commands.island.sethome.must-be-on-your-island");
             return false;
         }
@@ -50,7 +50,7 @@ public class IslandSethomeCommand extends CompositeCommand {
                         user.sendMessage("commands.island.sethome.num-homes", "[max]", String.valueOf(maxHomes));
                         return false;
                     } else {
-                        getPlugin().getPlayers().setHomeLocation(playerUUID, user.getLocation(), number);
+                        getPlugin().getPlayers().setHomeLocation(user, user.getLocation(), number);
                         user.sendMessage("commands.island.sethome.home-set");
                     }
                 } catch (Exception e) {

src/main/java/us/tastybento/bskyblock/commands/island/IslandSetnameCommand.java

@@ -40,12 +40,12 @@ public class IslandSetnameCommand extends CompositeCommand {
         Player player = user.getPlayer();
         UUID playerUUID = player.getUniqueId();
 
-        if (!getIslands().hasIsland(playerUUID)) {
+        if (!getIslands().hasIsland(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
 
-        if (!getIslands().isOwner(playerUUID)) {
+        if (!getIslands().isOwner(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.not-leader");
             return false;
         }
@@ -70,9 +70,9 @@ public class IslandSetnameCommand extends CompositeCommand {
 
         // Set the name
         if (!player.hasPermission(Constants.PERMPREFIX + "island.name.format")) {
-            getIslands().getIsland(player.getUniqueId()).setName(ChatColor.translateAlternateColorCodes('&', name));
+            getIslands().getIsland(user.getWorld(), player.getUniqueId()).setName(ChatColor.translateAlternateColorCodes('&', name));
         } else {
-            getIslands().getIsland(playerUUID).setName(name);
+            getIslands().getIsland(user.getWorld(), playerUUID).setName(name);
         }
 
         user.sendMessage("general.success");

src/main/java/us/tastybento/bskyblock/commands/island/IslandUnbanCommand.java

@@ -34,11 +34,11 @@ public class IslandUnbanCommand extends CompositeCommand {
         } 
         UUID playerUUID = user.getUniqueId();
         // Player issuing the command must have an island
-        if (!getIslands().hasIsland(playerUUID)) {
+        if (!getIslands().hasIsland(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        if (!getIslands().isOwner(playerUUID)) {
+        if (!getIslands().isOwner(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.not-leader");
             return false;
         }
@@ -53,7 +53,7 @@ public class IslandUnbanCommand extends CompositeCommand {
             user.sendMessage("commands.island.unban.cannot-unban-yourself");
             return false;
         }
-        if (!getIslands().getIsland(playerUUID).isBanned(targetUUID)) {
+        if (!getIslands().getIsland(user.getWorld(), playerUUID).isBanned(targetUUID)) {
             user.sendMessage("commands.island.unban.player-not-banned");
             return false; 
         }
@@ -63,7 +63,7 @@ public class IslandUnbanCommand extends CompositeCommand {
     }
 
     private boolean unban(User user, User targetUser) {
-        if (getIslands().getIsland(user.getUniqueId()).removeFromBanList(targetUser.getUniqueId())) {
+        if (getIslands().getIsland(user.getWorld(), user.getUniqueId()).removeFromBanList(targetUser.getUniqueId())) {
             user.sendMessage("general.success");
             targetUser.sendMessage("commands.island.unban.you-are-unbanned", "[owner]", user.getName());
             return true;
@@ -74,7 +74,7 @@ public class IslandUnbanCommand extends CompositeCommand {
 
     @Override
     public Optional<List<String>> tabComplete(User user, String alias, List<String> args) {       
-        Island island = getIslands().getIsland(user.getUniqueId());
+        Island island = getIslands().getIsland(user.getWorld(), user.getUniqueId());
         List<String> options = island.getBanned().stream().map(getPlayers()::getName).collect(Collectors.toList());
         String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
         return Optional.of(Util.tabLimit(options, lastArg));

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamCommand.java

@@ -36,7 +36,7 @@ public class IslandTeamCommand extends AbstractIslandTeamCommand {
     @Override
     public boolean execute(User user, List<String> args) {
         // Player issuing the command must have an island
-        UUID teamLeaderUUID = getTeamLeader(user);
+        UUID teamLeaderUUID = getTeamLeader(user.getWorld(), user);
         if (teamLeaderUUID == null) {
             user.sendMessage("general.errors.no-island");
             return false;
@@ -44,11 +44,11 @@ public class IslandTeamCommand extends AbstractIslandTeamCommand {
 
         UUID playerUUID = user.getUniqueId();
         // Fire event so add-ons can run commands, etc.
-        if (fireEvent(playerUUID)) {
+        if (fireEvent(user)) {
             // Cancelled
             return false;
         }
-        Set<UUID> teamMembers = getMembers(user);
+        Set<UUID> teamMembers = getMembers(user.getWorld(), user);
         if (teamLeaderUUID.equals(playerUUID)) {
             int maxSize = getMaxTeamSize(user);
             if (teamMembers.size() < maxSize) {
@@ -58,17 +58,17 @@ public class IslandTeamCommand extends AbstractIslandTeamCommand {
             }
         }
         // Show members of island
-        getIslands().getIsland(playerUUID).showMembers(getPlugin(), user);
+        getIslands().getIsland(user.getWorld(), playerUUID).showMembers(getPlugin(), user);
         return true;
     }
 
 
-    private boolean fireEvent(UUID playerUUID) {
+    private boolean fireEvent(User user) {
         IslandBaseEvent event = TeamEvent.builder()
                 .island(getIslands()
-                .getIsland(playerUUID))
+                .getIsland(user.getWorld(), user.getUniqueId()))
                 .reason(TeamEvent.Reason.INFO)
-                .involvedPlayer(playerUUID)
+                .involvedPlayer(user.getUniqueId())
                 .build();
         getPlugin().getServer().getPluginManager().callEvent(event);
         return event.isCancelled();

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamInviteAcceptCommand.java

@@ -39,13 +39,13 @@ public class IslandTeamInviteAcceptCommand extends AbstractIslandTeamCommand {
             return false;
         }
         // Check if player is already in a team
-        if (getIslands().inTeam(playerUUID)) {
+        if (getIslands().inTeam(user.getWorld(), playerUUID)) {
             user.sendMessage("commands.island.team.invite.errors.you-already-are-in-team");
             return false;
         }
         // Get the team leader
         UUID prospectiveTeamLeaderUUID = inviteList.get(playerUUID);
-        if (!getIslands().hasIsland(prospectiveTeamLeaderUUID)) {
+        if (!getIslands().hasIsland(user.getWorld(), prospectiveTeamLeaderUUID)) {
             user.sendMessage("commands.island.team.invite.errors.invalid-invite");
             inviteList.remove(playerUUID);
             return false;
@@ -53,7 +53,7 @@ public class IslandTeamInviteAcceptCommand extends AbstractIslandTeamCommand {
         // Fire event so add-ons can run commands, etc.
         IslandBaseEvent event = TeamEvent.builder()
                 .island(getIslands()
-                        .getIsland(prospectiveTeamLeaderUUID))
+                        .getIsland(user.getWorld(), prospectiveTeamLeaderUUID))
                 .reason(TeamEvent.Reason.JOIN)
                 .involvedPlayer(playerUUID)
                 .build();
@@ -66,16 +66,17 @@ public class IslandTeamInviteAcceptCommand extends AbstractIslandTeamCommand {
         // Put player into Spectator mode
         user.setGameMode(GameMode.SPECTATOR);
         // Get the player's island - may be null if the player has no island
-        Island island = getIslands().getIsland(playerUUID);
+        Island island = getIslands().getIsland(user.getWorld(), playerUUID);
         // Get the team's island
-        Island teamIsland = getIslands().getIsland(prospectiveTeamLeaderUUID);
+        Island teamIsland = getIslands().getIsland(user.getWorld(), prospectiveTeamLeaderUUID);
         // Clear the player's inventory
         user.getInventory().clear();
         // Move player to team's island
-        Location newHome = getIslands().getSafeHomeLocation(prospectiveTeamLeaderUUID, 1);
+        User prospectiveTeamLeader = User.getInstance(prospectiveTeamLeaderUUID);
+        Location newHome = getIslands().getSafeHomeLocation(user.getWorld(), prospectiveTeamLeader, 1);
         user.teleport(newHome);
         // Remove player as owner of the old island
-        getIslands().removePlayer(playerUUID);
+        getIslands().removePlayer(user.getWorld(), playerUUID);
         // Add the player as a team member of the new island
         getIslands().setJoinTeam(teamIsland, playerUUID);
         // Set the player's home

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamInviteCommand.java

@@ -34,11 +34,11 @@ public class IslandTeamInviteCommand extends AbstractIslandTeamCommand {
     public boolean execute(User user, List<String> args) {
         UUID playerUUID = user.getUniqueId();
         // Player issuing the command must have an island
-        if (!getIslands().hasIsland(user.getUniqueId())) {
+        if (!getIslands().hasIsland(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.no-island");
             return false;
         }
-        UUID teamLeaderUUID = getTeamLeader(user);
+        UUID teamLeaderUUID = getTeamLeader(user.getWorld(), user);
         if (!(teamLeaderUUID.equals(playerUUID))) {
             user.sendMessage("general.errors.not-leader");
             return false;
@@ -72,13 +72,13 @@ public class IslandTeamInviteCommand extends AbstractIslandTeamCommand {
             }
             // Check if this player can be invited to this island, or
             // whether they are still on cooldown
-            long time = getPlayers().getInviteCoolDownTime(invitedPlayerUUID, getIslands().getIslandLocation(playerUUID));
+            long time = getPlayers().getInviteCoolDownTime(invitedPlayerUUID, getIslands().getIslandLocation(user.getWorld(), playerUUID));
             if (time > 0 && !user.isOp()) {
                 user.sendMessage("commands.island.team.invite.cooldown", "[time]", String.valueOf(time));
                 return false;
             }
             // Player cannot invite someone already on a team
-            if (getIslands().inTeam(invitedPlayerUUID)) {
+            if (getIslands().inTeam(user.getWorld(), invitedPlayerUUID)) {
                 user.sendMessage("commands.island.team.invite.already-on-team");
                 return false;
             }
@@ -87,7 +87,7 @@ public class IslandTeamInviteCommand extends AbstractIslandTeamCommand {
     }
 
     private boolean invite(User user, User invitedPlayer) {
-        Set<UUID> teamMembers = getMembers(user);
+        Set<UUID> teamMembers = getMembers(user.getWorld(), user);
         // Check if player has space on their team
         int maxSize = getMaxTeamSize(user);
         if (teamMembers.size() < maxSize) {
@@ -99,7 +99,7 @@ public class IslandTeamInviteCommand extends AbstractIslandTeamCommand {
             }
             // Fire event so add-ons can run commands, etc.
             IslandBaseEvent event = TeamEvent.builder()
-                    .island(getIslands().getIsland(user.getUniqueId()))
+                    .island(getIslands().getIsland(user.getWorld(), user.getUniqueId()))
                     .reason(TeamEvent.Reason.INVITE)
                     .involvedPlayer(invitedPlayer.getUniqueId())
                     .build();
@@ -114,7 +114,7 @@ public class IslandTeamInviteCommand extends AbstractIslandTeamCommand {
             // Send message to online player
             invitedPlayer.sendMessage("commands.island.team.invite.name-has-invited-you", NAME_PLACEHOLDER, user.getName());
             invitedPlayer.sendMessage("commands.island.team.invite.to-accept-or-reject", "[label]", getLabel());
-            if (getIslands().hasIsland(invitedPlayer.getUniqueId())) {
+            if (getIslands().hasIsland(user.getWorld(), invitedPlayer.getUniqueId())) {
                 invitedPlayer.sendMessage("commands.island.team.invite.you-will-lose-your-island");
             }
             return true;

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamInviteRejectCommand.java

@@ -30,7 +30,7 @@ public class IslandTeamInviteRejectCommand extends AbstractIslandTeamCommand {
             // Fire event so add-ons can run commands, etc.
             IslandBaseEvent event = TeamEvent.builder()
                     .island(getIslands()
-                            .getIsland(inviteList.get(playerUUID)))
+                            .getIsland(user.getWorld(), inviteList.get(playerUUID)))
                     .reason(TeamEvent.Reason.REJECT)
                     .involvedPlayer(playerUUID)
                     .build();

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamKickCommand.java

@@ -30,11 +30,11 @@ public class IslandTeamKickCommand extends AbstractIslandTeamCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
-        if (!getIslands().inTeam(user.getUniqueId())) {
+        if (!getIslands().inTeam(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.no-team");
             return false;
         }
-        if (!getTeamLeader(user).equals(user.getUniqueId())) {
+        if (!getTeamLeader(user.getWorld(), user).equals(user.getUniqueId())) {
             user.sendMessage("general.errors.not-leader");
             return false;
         }
@@ -53,14 +53,14 @@ public class IslandTeamKickCommand extends AbstractIslandTeamCommand {
             user.sendMessage("commands.island.kick.cannot-kick");
             return false;
         }
-        if (!getIslands().getMembers(user.getUniqueId()).contains(targetUUID)) {
+        if (!getIslands().getMembers(user.getWorld(), user.getUniqueId()).contains(targetUUID)) {
             user.sendMessage("general.errors.not-in-team");
             return false;
         }
         if (!getSettings().isKickConfirmation() || kickSet.contains(targetUUID)) {
             kickSet.remove(targetUUID);
             User.getInstance(targetUUID).sendMessage("commands.island.team.kick.leader-kicked");
-            getIslands().removePlayer(targetUUID);
+            getIslands().removePlayer(user.getWorld(), targetUUID);
             user.sendMessage("general.success");
             return true;
         } else {

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamLeaveCommand.java

@@ -29,21 +29,21 @@ public class IslandTeamLeaveCommand extends AbstractIslandTeamCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
-        if (!getIslands().inTeam(user.getUniqueId())) {
+        if (!getIslands().inTeam(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.no-team");
             return false;
         }       
-        if (getIslands().hasIsland(user.getUniqueId())) {
+        if (getIslands().hasIsland(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("commands.island.team.leave.cannot-leave");
             return false;
         }
         if (!getSettings().isLeaveConfirmation() || leaveSet.contains(user.getUniqueId())) {
             leaveSet.remove(user.getUniqueId());
-            UUID leaderUUID = getIslands().getTeamLeader(user.getUniqueId());
+            UUID leaderUUID = getIslands().getTeamLeader(user.getWorld(), user.getUniqueId());
             if (leaderUUID != null) {
                 User.getInstance(leaderUUID).sendMessage("commands.island.team.leave.left-your-island", "[player]", user.getName());
             }
-            getIslands().removePlayer(user.getUniqueId());
+            getIslands().removePlayer(user.getWorld(), user.getUniqueId());
             user.sendMessage("general.success");
             return true;
         } else {

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamPromoteCommand.java

@@ -27,11 +27,11 @@ public class IslandTeamPromoteCommand extends AbstractIslandTeamCommand {
 
     @Override
     public boolean execute(User user, List<String> args) {
-        if (!getIslands().inTeam(user.getUniqueId())) {
+        if (!getIslands().inTeam(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("general.errors.no-team");
             return true;
         }
-        if (!getTeamLeader(user).equals(user.getUniqueId())) {
+        if (!getTeamLeader(user.getWorld(), user).equals(user.getUniqueId())) {
             user.sendMessage("general.errors.not-leader");
             return true;
         }
@@ -46,7 +46,7 @@ public class IslandTeamPromoteCommand extends AbstractIslandTeamCommand {
             user.sendMessage("general.errors.unknown-player");
             return true;
         }
-        if (!inTeam(target) || !getTeamLeader(user).equals(getTeamLeader(target))) {
+        if (!inTeam(user.getWorld(), target) || !getTeamLeader(user.getWorld(), user).equals(getTeamLeader(user.getWorld(), target))) {
             user.sendMessage("general.errors.not-in-team");
             return true;
         }
@@ -55,11 +55,11 @@ public class IslandTeamPromoteCommand extends AbstractIslandTeamCommand {
     }
 
     private boolean change(User user, User target) {
-        int currentRank = getIslands().getIsland(user.getUniqueId()).getRank(target);
+        int currentRank = getIslands().getIsland(user.getWorld(), user.getUniqueId()).getRank(target);
         if (this.getLabel().equals("promote")) {
             int nextRank = getPlugin().getRanksManager().getRankUpValue(currentRank);
             if (nextRank > currentRank) {
-                getIslands().getIsland(user.getUniqueId()).setRank(target, nextRank);
+                getIslands().getIsland(user.getWorld(), user.getUniqueId()).setRank(target, nextRank);
                 String rankName = user.getTranslation(getPlugin().getRanksManager().getRank(nextRank));
                 user.sendMessage("commands.island.team.promote.success", "[name]", target.getName(), "[rank]", rankName);
                 return true;
@@ -71,7 +71,7 @@ public class IslandTeamPromoteCommand extends AbstractIslandTeamCommand {
             // Demote
             int prevRank = getPlugin().getRanksManager().getRankDownValue(currentRank);
             if (prevRank < currentRank) {
-                getIslands().getIsland(user.getUniqueId()).setRank(target, prevRank);
+                getIslands().getIsland(user.getWorld(), user.getUniqueId()).setRank(target, prevRank);
                 String rankName = user.getTranslation(getPlugin().getRanksManager().getRank(prevRank));
                 user.sendMessage("commands.island.team.demote.success", "[name]", target.getName(), "[rank]", rankName);
                 return true;

src/main/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamSetownerCommand.java

@@ -30,8 +30,8 @@ public class IslandTeamSetownerCommand extends AbstractIslandTeamCommand {
     public boolean execute(User user, List<String> args) {
         UUID playerUUID = user.getUniqueId();
         // Can use if in a team
-        boolean inTeam = getPlugin().getIslands().inTeam(playerUUID);
-        UUID teamLeaderUUID = getTeamLeader(user);
+        boolean inTeam = getPlugin().getIslands().inTeam(user.getWorld(), playerUUID);
+        UUID teamLeaderUUID = getTeamLeader(user.getWorld(), user);
         if (!(inTeam && teamLeaderUUID.equals(playerUUID))) {
             user.sendMessage("general.errors.not-leader");
             return false;
@@ -46,7 +46,7 @@ public class IslandTeamSetownerCommand extends AbstractIslandTeamCommand {
             user.sendMessage("general.errors.unknown-player");
             return false;
         }
-        if (!getIslands().inTeam(playerUUID)) {
+        if (!getIslands().inTeam(user.getWorld(), playerUUID)) {
             user.sendMessage("general.errors.no-team");
             return false;
         }
@@ -54,14 +54,14 @@ public class IslandTeamSetownerCommand extends AbstractIslandTeamCommand {
             user.sendMessage("commands.island.team.setowner.errors.cant-transfer-to-yourself");
             return false;
         }
-        if (!getPlugin().getIslands().getMembers(playerUUID).contains(targetUUID)) {
+        if (!getPlugin().getIslands().getMembers(user.getWorld(), playerUUID).contains(targetUUID)) {
             user.sendMessage("commands.island.team.setowner.errors.target-is-not-member");
             return false;
         }
         // Fire event so add-ons can run commands, etc.
         IslandBaseEvent event = TeamEvent.builder()
                 .island(getIslands()
-                        .getIsland(playerUUID))
+                        .getIsland(user.getWorld(), playerUUID))
                 .reason(TeamEvent.Reason.MAKELEADER)
                 .involvedPlayer(targetUUID)
                 .build();
@@ -69,7 +69,7 @@ public class IslandTeamSetownerCommand extends AbstractIslandTeamCommand {
         if (event.isCancelled()) {
             return false;
         }
-        getIslands().makeLeader(user, targetUUID);
+        getIslands().makeLeader(user.getWorld(), user, targetUUID);
         getIslands().save(true);
         return true;
     }
@@ -79,7 +79,7 @@ public class IslandTeamSetownerCommand extends AbstractIslandTeamCommand {
     public Optional<List<String>> tabComplete(User user, String alias, List<String> args) {
         List<String> options = new ArrayList<>();
         String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
-        for (UUID member : getPlugin().getIslands().getMembers(user.getUniqueId())) {
+        for (UUID member : getPlugin().getIslands().getMembers(user.getWorld(), user.getUniqueId())) {
             options.add(getPlugin().getServer().getOfflinePlayer(member).getName());
         }
         return Optional.of(Util.tabLimit(options, lastArg));

src/main/java/us/tastybento/bskyblock/database/objects/Island.java

@@ -692,7 +692,7 @@ public class Island implements DataObject {
      * @param user - user who is requesting
      */
     public void showMembers(BSkyBlock plugin, User user) {
-        if (plugin.getIslands().inTeam(user.getUniqueId())) {
+        if (plugin.getIslands().inTeam(user.getWorld(), user.getUniqueId())) {
             user.sendMessage("commands.admin.info.team-members-title");
             members.forEach((u, i) -> {
                 if (owner.equals(u)) {

src/main/java/us/tastybento/bskyblock/database/objects/Players.java

@@ -5,9 +5,11 @@ import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 
 import com.google.gson.annotations.Expose;
@@ -21,7 +23,7 @@ import us.tastybento.bskyblock.BSkyBlock;
  */
 public class Players implements DataObject {
     @Expose
-    private Map<Integer, Location> homeLocations = new HashMap<>();
+    private Map<Location, Integer> homeLocations = new HashMap<>();
     @Expose
     private String uniqueId;
     @Expose
@@ -57,28 +59,48 @@ public class Players implements DataObject {
 
     /**
      * Gets the default home location.
-     * @return Location
+     * @param world - world to check
+     * @return Location - home location in world
      */
-    public Location getHomeLocation() {
-        return getHomeLocation(1); // Default
+    public Location getHomeLocation(World world) {
+        return getHomeLocation(world, 1); // Default
     }
 
     /**
-     * Gets the home location by number.
+     * Gets the home location by number for world
+     * @param world - includes world and any related nether or end worlds
      * @param number - a number
      * @return Location of this home or null if not available
      */
-    public Location getHomeLocation(int number) {
-        return homeLocations.get(number);
+    public Location getHomeLocation(World world, int number) {
+        return homeLocations.entrySet().stream()
+                .filter(en -> sameWorld(en.getKey().getWorld(), world) && en.getValue() == number)
+                .map(en -> en.getKey())
+                .findFirst()
+                .orElse(null);
     }
 
     /**
+     * @param world 
      * @return List of home locations
      */
-    public Map<Integer,Location> getHomeLocations() {
-        return homeLocations;
+    public Map<Location, Integer> getHomeLocations(World world) {
+        return homeLocations.entrySet().stream().filter(e -> sameWorld(e.getKey().getWorld(),world))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }
-
+    
+    /**
+     * Checks is world = world2 irrespective of the world type
+     * @param world
+     * @param world2
+     * @return true if the same
+     */
+    private boolean sameWorld(World world, World world2) {
+        String worldName = world.getName().replaceAll("_nether", "").replaceAll("_the_end", "");
+        String world2Name = world2.getName().replaceAll("_nether", "").replaceAll("_the_end", "");
+        return worldName.equalsIgnoreCase(world2Name);
+    }
+    
     /**
      * @return the kickedList
      */
@@ -96,7 +118,7 @@ public class Players implements DataObject {
     /**
      * @param homeLocations the homeLocations to set
      */
-    public void setHomeLocations(Map<Integer, Location> homeLocations) {
+    public void setHomeLocations(Map<Location, Integer> homeLocations) {
         this.homeLocations = homeLocations;
     }
 
@@ -149,12 +171,8 @@ public class Players implements DataObject {
      * @param location - the location
      * @param number - a number
      */
-    public void setHomeLocation(final Location location, int number) {
-        if (location == null) {
-            homeLocations.clear();
-        } else {
-            homeLocations.put(number, location);
-        }
+    public void setHomeLocation(Location location, int number) {
+        homeLocations.put(location, number);
     }
 
     /**
@@ -166,10 +184,11 @@ public class Players implements DataObject {
     }
 
     /**
-     * Clears all home Locations
+     * Clears all home Locations in world
+     * @param world 
      */
-    public void clearHomeLocations() {
-        homeLocations.clear();
+    public void clearHomeLocations(World world) {
+        homeLocations.keySet().removeIf(l -> sameWorld(l.getWorld(), world));
     }
 
     /**

src/main/java/us/tastybento/bskyblock/island/builders/Clipboard.java

@@ -0,0 +1,406 @@
+package us.tastybento.bskyblock.island.builders;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+import org.bukkit.Bukkit;
+import org.bukkit.DyeColor;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Banner;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Sign;
+import org.bukkit.block.banner.Pattern;
+import org.bukkit.block.banner.PatternType;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.material.Attachable;
+import org.bukkit.material.Button;
+import org.bukkit.material.Colorable;
+import org.bukkit.material.Directional;
+import org.bukkit.material.Lever;
+import org.bukkit.material.MaterialData;
+import org.bukkit.material.Openable;
+import org.bukkit.material.Redstone;
+
+import us.tastybento.bskyblock.BSkyBlock;
+import us.tastybento.bskyblock.api.user.User;
+
+public class Clipboard {
+
+    private enum TorchDir {
+        UNUSED,
+        EAST,
+        WEST,
+        SOUTH,
+        NORTH,
+        UP
+    }
+
+    private YamlConfiguration blockConfig = new YamlConfiguration();
+    private Location pos1;
+    private Location pos2;
+    private BSkyBlock plugin;
+    private boolean copied;
+
+    public Clipboard(BSkyBlock plugin) {
+        super();
+        this.plugin = plugin;
+    }
+    /**
+     * @return the pos1
+     */
+    public Location getPos1() {
+        return pos1;
+    }
+    /**
+     * @param pos1 the pos1 to set
+     */
+    public void setPos1(Location pos1) {
+        this.pos1 = pos1;
+    }
+    /**
+     * @return the pos2
+     */
+    public Location getPos2() {
+        return pos2;
+    }
+    /**
+     * @param pos2 the pos2 to set
+     */
+    public void setPos2(Location pos2) {
+        this.pos2 = pos2;
+    }
+
+    /**
+     * Copy the blocks between pos1 and pos2 to the clipboard
+     * @param user - user
+     * @return true if successful, false if pos1 or pos2 are undefined
+     */
+    public boolean copy(User user) {
+        if (pos1 == null || pos2 == null) {
+            user.sendMessage("commands.admin.schem.need-pos1-pos2");
+            return false;
+        }
+        int count = 0;
+        for (int x = Math.min(pos1.getBlockX(), pos2.getBlockX()); x <= Math.max(pos1.getBlockX(),pos2.getBlockX()); x++) {
+            for (int y = Math.min(pos1.getBlockY(), pos2.getBlockY()); y <= Math.max(pos1.getBlockY(),pos2.getBlockY()); y++) {
+                for (int z = Math.min(pos1.getBlockZ(), pos2.getBlockZ()); z <= Math.max(pos1.getBlockZ(),pos2.getBlockZ()); z++) {
+                    copyBlock(pos1.getWorld().getBlockAt(x, y, z), user.getLocation());
+                    count++;
+                }
+            }
+        }
+        user.sendMessage("commands.admin.schem.copied-blocks", "[number]", String.valueOf(count));
+        copied = true;
+        return true;
+    }
+
+    /**
+     * Pastes the clipboard to location
+     * @param location
+     */
+    public void paste(Location location) {
+        blockConfig.getKeys(false).forEach(b -> pasteBlock(location, blockConfig.getConfigurationSection(b)));
+    }
+
+    private void pasteBlock(Location location, ConfigurationSection s) {
+        String[] pos = s.getName().split(",");
+        int x = location.getBlockX() + Integer.valueOf(pos[0]);
+        int y = location.getBlockY() + Integer.valueOf(pos[1]);
+        int z = location.getBlockZ() + Integer.valueOf(pos[2]);
+        Material m = Material.getMaterial(s.getString("type"));
+        Block block = location.getWorld().getBlockAt(x, y, z);
+        if (s.getBoolean("attached")) {
+            plugin.getLogger().info("Setting 1 tick later for " + m.toString());
+            plugin.getServer().getScheduler().runTask(plugin, () -> setBlock(block, s, m));
+        } else {
+            setBlock(block, s, m);
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private void setBlock(Block block, ConfigurationSection s, Material m) {
+     // Block state
+        
+        if (s.getBoolean("attached") && m.toString().contains("TORCH")) {
+            TorchDir d = TorchDir.valueOf(s.getString("facing"));
+
+            Block rel = block.getRelative(BlockFace.DOWN);
+            Material rm = rel.getType();
+            Byte data = rel.getData();
+
+            if (rel.isEmpty() || rel.isLiquid()) {
+                rel.setType(Material.STONE);
+                block.setType(m);
+                block.setData((byte)d.ordinal());
+                // Set the block back to what it was
+                rel.setType(rm);
+                rel.setData(data);
+            } else {
+                block.setType(m);
+                block.setData((byte)d.ordinal());
+            }
+            return;
+        } 
+
+        block.setType(m);
+        
+        BlockState bs = block.getState();
+
+        byte data = (byte)s.getInt("data");
+        block.setData(data);
+
+
+        // Material Data
+        MaterialData md = bs.getData();
+        if (md instanceof Openable) {
+            Bukkit.getLogger().info("Openable");
+            Openable open = (Openable)md;
+            open.setOpen(s.getBoolean("open")); 
+        }
+
+        if (md instanceof Directional) {
+            Bukkit.getLogger().info("Directional");
+            Directional facing = (Directional)md;
+            facing.setFacingDirection(BlockFace.valueOf(s.getString("facing")));
+        }
+
+        if (md instanceof Lever) {
+            Bukkit.getLogger().info("Lever");
+            Lever r = (Lever)md;
+            r.setPowered(s.getBoolean("powered"));
+        }
+        if (md instanceof Button) {
+            Bukkit.getLogger().info("Button");
+            Button r = (Button)md;
+            r.setPowered(s.getBoolean("powered"));
+        }
+        // Block data
+        if (bs instanceof Sign) {
+            Bukkit.getLogger().info("Sign");
+            Sign sign = (Sign)bs;
+            List<String> lines = s.getStringList("lines");
+            for (int i =0 ; i < lines.size(); i++) {
+                sign.setLine(i, lines.get(i));
+            }
+            sign.update();
+        }
+        if (bs instanceof Banner) {
+            Bukkit.getLogger().info("Banner");
+            Banner banner = (Banner)bs;
+            DyeColor baseColor = DyeColor.valueOf(s.getString("baseColor"));
+            banner.setBaseColor(baseColor);
+            int i = 0;
+            ConfigurationSection pat = s.getConfigurationSection("pattern");
+            if (pat != null) {
+                for (String pattern : pat.getKeys(false)) {    
+                    banner.setPattern(i, new Pattern(DyeColor.valueOf(pat.getString(pattern))
+                            , PatternType.valueOf(pattern)));
+                    i++;
+                }
+            }
+        }
+        
+        bs.update(true, false);
+        if (bs instanceof InventoryHolder) {
+            Bukkit.getLogger().info("Inventory holder " + s.getCurrentPath());
+            
+            InventoryHolder ih = (InventoryHolder)bs;
+            @SuppressWarnings("unchecked")
+            List<ItemStack> items = (List<ItemStack>) s.get("inventory");
+            for (int i = 0; i < ih.getInventory().getSize(); i++) {
+                ih.getInventory().setItem(i, items.get(i));
+            }
+        }
+
+    }
+    
+    @SuppressWarnings("deprecation")
+    private void copyBlock(Block block, Location origin) {
+        if (block.getType().equals(Material.AIR)) {
+            return;
+        }
+        // Create position
+        int x = block.getLocation().getBlockX() - origin.getBlockX();
+        int y = block.getLocation().getBlockY() - origin.getBlockY();
+        int z = block.getLocation().getBlockZ() - origin.getBlockZ();
+        String pos = x + "," + y + "," + z;
+
+        // Position defines the section
+        ConfigurationSection s = blockConfig.createSection(pos);
+        // Set the block type
+        s.set("type", block.getType().toString());
+        if (block.getData() != 0) {
+            s.set("data", block.getData());
+        }
+
+        // Block state
+        BlockState bs = block.getState();
+
+        // Material Data
+        MaterialData md = bs.getData();
+        if (md instanceof Openable) {
+            Bukkit.getLogger().info("Openable");
+            Openable open = (Openable)md;
+            s.set("open", open.isOpen()); 
+        }
+        if (md instanceof Directional) {
+            Bukkit.getLogger().info("Directional");
+            Directional facing = (Directional)md;
+            s.set("facing", facing.getFacing().name()); 
+        }
+        if (md instanceof Attachable) {
+            Bukkit.getLogger().info("Attachable");
+            Attachable facing = (Attachable)md;
+            s.set("facing", facing.getFacing().name());
+            s.set("attached-face", facing.getAttachedFace().name());
+            s.set("attached", true);
+        }
+        if (md instanceof Colorable) {
+            Bukkit.getLogger().info("Colorable");
+            Colorable c = (Colorable)md;
+            s.set("color", c.getColor().name());
+        }
+        if (block.getType().equals(Material.CARPET)) {
+            Bukkit.getLogger().info("Carpet");
+            DyeColor c = DyeColor.getByWoolData(block.getData());
+            s.set("color", c.name());  
+        }
+        if (md instanceof Redstone) {
+            Bukkit.getLogger().info("Redstone");
+            Redstone r = (Redstone)md;
+            blockConfig.set("powered", r.isPowered());
+        }
+
+        // Block data
+        if (bs instanceof Sign) {
+            Bukkit.getLogger().info("Sign");
+            Sign sign = (Sign)bs;
+            s.set("lines", Arrays.asList(sign.getLines()));
+        }
+        if (bs instanceof Banner) {
+            Bukkit.getLogger().info("Banner");
+            Banner banner = (Banner)bs;
+            s.set("baseColor", banner.getBaseColor().toString());
+            banner.getPatterns().forEach(p -> {
+                s.set("pattern." + p.getPattern().toString(), p.getColor().toString());
+            });
+        }
+        if (bs instanceof InventoryHolder) {
+            Bukkit.getLogger().info("Inventory holder");
+            InventoryHolder ih = (InventoryHolder)bs;
+            s.set("inventory", ih.getInventory().getContents());
+        }
+
+    }
+    /**
+     * @return the blockConfig
+     */
+    private YamlConfiguration getBlockConfig() {
+        return blockConfig;
+    }
+
+    /**
+     * Load a file to clipboard
+     * @param file
+     * @throws IOException 
+     * @throws InvalidConfigurationException 
+     */
+    public void load(File file) throws IOException, InvalidConfigurationException {
+            unzip(file.getAbsolutePath());
+            blockConfig.load(file);
+            copied = true;
+            Files.delete(file.toPath());
+    }
+    
+    private void unzip(final String zipFilePath) throws IOException {
+        Path path = Paths.get(zipFilePath);
+        if (!(Files.exists(path))) {
+            return;
+        }
+        try (ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(zipFilePath))) {
+            ZipEntry entry = zipInputStream.getNextEntry();
+            while (entry != null) {
+                Path filePath = Paths.get(path.getParent().toString(), entry.getName());
+                if (!entry.isDirectory()) {
+                    unzipFiles(zipInputStream, filePath);
+                } else {
+                    Files.createDirectories(filePath);
+                }
+
+                zipInputStream.closeEntry();
+                entry = zipInputStream.getNextEntry();
+            }
+        }
+    }
+
+    private static void unzipFiles(final ZipInputStream zipInputStream, final Path unzipFilePath) throws IOException {
+
+        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(unzipFilePath.toAbsolutePath().toString()))) {
+            byte[] bytesIn = new byte[1024];
+            int read = 0;
+            while ((read = zipInputStream.read(bytesIn)) != -1) {
+                bos.write(bytesIn, 0, read);
+            }
+        }
+
+    }
+    
+    /**
+     * Save the clipboard to a file
+     * @param file
+     */
+    public void save(File file) {
+        try {
+            getBlockConfig().save(file);
+            zip(file);
+
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+
+    }
+    
+    private void zip(File targetFile) {
+
+        try (ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(targetFile.getAbsolutePath() + ".schem"))) {
+            zipOutputStream.putNextEntry(new ZipEntry(targetFile.getName()));
+            try (FileInputStream inputStream = new FileInputStream(targetFile)) {
+
+                final byte[] buffer = new byte[1024];
+                int length;
+                while((length = inputStream.read(buffer)) >= 0) {
+                    zipOutputStream.write(buffer, 0, length);
+                }
+                inputStream.close();
+                zipOutputStream.close();
+                targetFile.delete();
+            }
+        } catch (Exception e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
+    
+    public boolean isFull() {
+        return copied;
+    }
+}

src/main/java/us/tastybento/bskyblock/listeners/NetherPortals.java

@@ -112,9 +112,9 @@ public class NetherPortals implements Listener {
         }
         // If entering a portal in the end, teleport home if you have one, else do nothing
         if (e.getFrom().getWorld().equals(theEnd)) {
-            if (plugin.getIslands().hasIsland(e.getPlayer().getUniqueId())) {
+            if (plugin.getIslands().hasIsland(e.getPlayer().getWorld(), e.getPlayer().getUniqueId())) {
                 e.setCancelled(true);
-                plugin.getIslands().homeTeleport(e.getPlayer());
+                plugin.getIslands().homeTeleport(e.getPlayer().getWorld(), e.getPlayer());
             } 
             return;
         }
@@ -185,7 +185,7 @@ public class NetherPortals implements Listener {
         // If entering a portal in the nether, teleport to portal in overworld if there is one
         if (e.getFrom().getWorld().equals(nether)) {
             // If this is from the island nether, then go to the same vector, otherwise try island home location
-            Location to = plugin.getSettings().isNetherIslands() ? e.getFrom().toVector().toLocation(world) : plugin.getIslands().getIslandLocation(e.getPlayer().getUniqueId());
+            Location to = plugin.getSettings().isNetherIslands() ? e.getFrom().toVector().toLocation(world) : plugin.getIslands().getIslandLocation(e.getPlayer().getWorld(), e.getPlayer().getUniqueId());
             e.setCancelled(true);
             // Else other worlds teleport to the nether
             new SafeTeleportBuilder(plugin)

src/main/java/us/tastybento/bskyblock/listeners/ObsidianToLava.java

@@ -52,7 +52,7 @@ public class ObsidianToLava implements Listener {
             return false;
         }
         User user = User.getInstance(e.getPlayer());
-        if (plugin.getIslands().userIsOnIsland(user)) {
+        if (plugin.getIslands().userIsOnIsland(user.getWorld(), user)) {
             // Look around to see if this is a lone obsidian block
             Block b = e.getClickedBlock();
 

src/main/java/us/tastybento/bskyblock/listeners/flags/LockAndBanListener.java

@@ -147,8 +147,8 @@ public class LockAndBanListener implements Listener {
     private void eject(Player player) {
         player.setGameMode(GameMode.SPECTATOR);
         // Teleport player to their home
-        if (im.hasIsland(player.getUniqueId())) {
-            im.homeTeleport(player);
+        if (im.hasIsland(player.getWorld(), player.getUniqueId())) {
+            im.homeTeleport(player.getWorld(), player);
         } // else, TODO: teleport somewhere else?   
     }
 

src/main/java/us/tastybento/bskyblock/listeners/flags/UpDownClick.java

@@ -37,7 +37,7 @@ public class UpDownClick implements PanelItem.ClickHandler {
         // Left clicking increases the rank required
         // Right clicking decreases the rank required
         // Get the user's island
-        Island island = plugin.getIslands().getIsland(user.getUniqueId());
+        Island island = plugin.getIslands().getIsland(user.getWorld(), user.getUniqueId());
         if (island != null && island.getOwner().equals(user.getUniqueId())) {
             RanksManager rm = plugin.getRanksManager();
             Flag flag = plugin.getFlagsManager().getFlagByID(id);

src/main/java/us/tastybento/bskyblock/managers/IslandsManager.java

@@ -1,7 +1,8 @@
 package us.tastybento.bskyblock.managers;
 
 import java.util.Collection;
-import java.util.HashSet;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -10,6 +11,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
 import org.bukkit.Location;
 import org.bukkit.Material;
+import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.entity.Boat;
@@ -118,11 +120,11 @@ public class IslandsManager {
     /**
      * One island can be spawn, this is the one - otherwise, this value is null
      */
-    private Island spawn;
+    private Map<World, Island> spawn;
 
     private BSBDatabase<Island> handler;
 
-    private Location last;
+    private Map<World,Location> last;
     // Metrics data
     private int metrics_createdcount = 0;
 
@@ -137,8 +139,9 @@ public class IslandsManager {
         this.plugin = plugin;
         // Set up the database handler to store and retrieve Island classes
         handler = new BSBDatabase<>(plugin, Island.class);
-        islandCache = new IslandCache(plugin);
-        spawn = null;
+        islandCache = new IslandCache();
+        spawn = new HashMap<>();
+        last = new HashMap<>();
     }
 
     /**
@@ -265,58 +268,28 @@ public class IslandsManager {
         }
     }
 
-    /**
-     * Delete Island
-     * Called when an island is restarted or reset
-     *
-     * @param player - the player
-     *            - player name String
-     * @param removeBlocks
-     *            - true to remove the island blocks
-     */
-    public void deleteIsland(final UUID player, boolean removeBlocks) {
-        // Removes the island
-        final Island island = getIsland(player);
-        if (island != null) {
-            deleteIsland(island, removeBlocks);
-        } else {
-            plugin.logError("Could not delete player: " + player.toString() + " island!");
-        }
-    }
-
-    /**
-     * @param playerUUID - the player's UUID
-     * @return ban list for player
-     */
-    public Set<UUID> getBanList(UUID playerUUID) {
-        // Get player's island
-        Island island = getIsland(playerUUID);
-        return island == null ? new HashSet<>(): island.getBanned();
-    }
-
     public int getCount(){
         return islandCache.size();
     }
 
     /**
      * Gets the island for this player. If they are in a team, the team island is returned
-     * @param uuid - UUID
+     * @param world - world to check
+     * @param user - user
      * @return Island or null
      */
-    public Island getIsland(UUID uuid){
-        return islandCache.get(uuid);
+    public Island getIsland(World world, User user){
+        return islandCache.get(world, user.getUniqueId());
     }
-
+    
     /**
-     * Returns the island at the x,z location or null if there is none.
-     * This includes the full island space, not just the protected area.
-     *
-     * @param x - x coordinate
-     * @param z - z coordinate
+     * Gets the island for this player. If they are in a team, the team island is returned
+     * @param world - world to check
+     * @param uuid - user's uuid
      * @return Island or null
      */
-    public Island getIslandAt(int x, int z) {
-        return islandCache.getIslandAt(x,z);
+    public Island getIsland(World world, UUID uuid){
+        return islandCache.get(world, uuid);
     }
 
     /**
@@ -327,55 +300,37 @@ public class IslandsManager {
      * @return Optional Island object
      */
     public Optional<Island> getIslandAt(Location location) {
-        if (location == null) {
-            return Optional.empty();
-        }
-        // World check
-        if (!Util.inWorld(location)) {
-            return Optional.empty();
-        }
-        // Check if it is spawn
-        if (spawn != null && spawn.onIsland(location)) {
-            return Optional.of(spawn);
-        }
-        return Optional.ofNullable(getIslandAt(location.getBlockX(), location.getBlockZ()));
+        return Optional.ofNullable(islandCache.getIslandAt(location));
     }
 
     /**
-     * Returns the player's island location.
+     * Returns the player's island location in World
      * Returns an island location OR a team island location
      *
-     * @param playerUUID - the player's UUID
+     * @param world - world to check
+     * @param uuid - the player's UUID
      * @return Location of player's island or null if one does not exist
      */
-    public Location getIslandLocation(UUID playerUUID) {
-        if (hasIsland(playerUUID)) {
-            return getIsland(playerUUID).getCenter();
+    public Location getIslandLocation(World world, UUID uuid) {
+        if (hasIsland(world, uuid)) {
+            return getIsland(world, uuid).getCenter();
         }
         return null;
     }
 
-    /**
-     * Get name of the island owned by owner
-     * @param owner - the island owner
-     * @return Returns the name of owner's island, or the owner's name if there is none.
-     */
-    public String getIslandName(UUID owner) {
-        return islandCache.getIslandName(owner);
-    }
-
-    public Location getLast() {
-        return last;
+    public Location getLast(World world) {
+        return last.get(world);
     }
 
     /**
      * Returns a set of island member UUID's for the island of playerUUID
      *
+     * @param world - world to check
      * @param playerUUID - the player's UUID
      * @return Set of team UUIDs
      */
-    public Set<UUID> getMembers(UUID playerUUID) {
-        return islandCache.getMembers(playerUUID);
+    public Set<UUID> getMembers(World world, UUID playerUUID) {
+        return islandCache.getMembers(world, playerUUID);
     }
 
     /**
@@ -386,28 +341,25 @@ public class IslandsManager {
      */
 
     public Optional<Island> getProtectedIslandAt(Location location) {
-        // Try spawn
-        if (spawn != null && spawn.onIsland(location)) {
-            return Optional.of(spawn);
-        }
         return getIslandAt(location).filter(i -> i.onIsland(location));
     }
 
     /**
      * Determines a safe teleport spot on player's island or the team island
      * they belong to.
-     *
-     * @param playerUUID - the player's UUID UUID of player
+     * 
+     * @param world - world to check
+     * @param user - the player
      * @param number - a number - starting home location e.g., 1
      * @return Location of a safe teleport spot or null if one cannot be found
      */
-    public Location getSafeHomeLocation(UUID playerUUID, int number) {
+    public Location getSafeHomeLocation(World world, User user, int number) {
         // Try the numbered home location first
-        Location l = plugin.getPlayers().getHomeLocation(playerUUID, number);
+        Location l = plugin.getPlayers().getHomeLocation(world, user, number);
         if (l == null) {
             // Get the default home, which may be null too, but that's okay
             number = 1;
-            l = plugin.getPlayers().getHomeLocation(playerUUID, number);
+            l = plugin.getPlayers().getHomeLocation(world, user, number);
         }
         // Check if it is safe
         if (l != null) {
@@ -420,57 +372,57 @@ public class IslandsManager {
             if (lPlusOne != null) {
                 if (isSafeLocation(lPlusOne)) {
                     // Adjust the home location accordingly
-                    plugin.getPlayers().setHomeLocation(playerUUID, lPlusOne, number);
+                    plugin.getPlayers().setHomeLocation(user, lPlusOne, number);
                     return lPlusOne;
                 }
             }
         }
         // Home location either isn't safe, or does not exist so try the island
         // location
-        if (plugin.getIslands().inTeam(playerUUID)) {
-            l = plugin.getIslands().getIslandLocation(playerUUID);
+        if (plugin.getIslands().inTeam(world, user.getUniqueId())) {
+            l = plugin.getIslands().getIslandLocation(world, user.getUniqueId());
             if (isSafeLocation(l)) {
-                plugin.getPlayers().setHomeLocation(playerUUID, l, number);
+                plugin.getPlayers().setHomeLocation(user, l, number);
                 return l;
             } else {
                 // try team leader's home
-                Location tlh = plugin.getPlayers().getHomeLocation(plugin.getIslands().getTeamLeader(playerUUID));
+                Location tlh = plugin.getPlayers().getHomeLocation(world, plugin.getIslands().getTeamLeader(world, user.getUniqueId()));
                 if (tlh != null) {
                     if (isSafeLocation(tlh)) {
-                        plugin.getPlayers().setHomeLocation(playerUUID, tlh, number);
+                        plugin.getPlayers().setHomeLocation(user, tlh, number);
                         return tlh;
                     }
                 }
             }
         } else {
-            l = plugin.getIslands().getIslandLocation(playerUUID);
+            l = plugin.getIslands().getIslandLocation(world, user.getUniqueId());
             if (isSafeLocation(l)) {
-                plugin.getPlayers().setHomeLocation(playerUUID, l, number);
+                plugin.getPlayers().setHomeLocation(user, l, number);
                 return l.clone().add(new Vector(0.5D,0,0.5D));
             }
         }
         if (l == null) {
-            plugin.logWarning(plugin.getPlayers().getName(playerUUID) + " player has no island!");
+            plugin.logWarning(user.getName() + " player has no island in world " + world.getName() + "!");
             return null;
         }
         // If these island locations are not safe, then we need to get creative
         // Try the default location
         Location dl = new Location(l.getWorld(), l.getX() + 0.5D, l.getY() + 5D, l.getZ() + 2.5D, 0F, 30F);
         if (isSafeLocation(dl)) {
-            plugin.getPlayers().setHomeLocation(playerUUID, dl, number);
+            plugin.getPlayers().setHomeLocation(user, dl, number);
             return dl;
         }
         // Try just above the bedrock
         dl = new Location(l.getWorld(), l.getX() + 0.5D, l.getY() + 5D, l.getZ() + 0.5D, 0F, 30F);
         if (isSafeLocation(dl)) {
-            plugin.getPlayers().setHomeLocation(playerUUID, dl, number);
+            plugin.getPlayers().setHomeLocation(user, dl, number);
             return dl;
         }
         // Try all the way up to the sky
         for (int y = l.getBlockY(); y < 255; y++) {
             final Location n = new Location(l.getWorld(), l.getX() + 0.5D, y, l.getZ() + 0.5D);
             if (isSafeLocation(n)) {
-                plugin.getPlayers().setHomeLocation(playerUUID, n, number);
+                plugin.getPlayers().setHomeLocation(user, n, number);
                 return n;
             }
         }
@@ -478,41 +430,63 @@ public class IslandsManager {
         return null;
     }
 
-    public Island getSpawn(){
-        return spawn;
+    /**
+     * Get the island that is defined as spawn in this world
+     * @param world
+     * @return island or null
+     */
+    public Island getSpawn(World world){
+        return spawn.get(world);
     }
 
     /**
+     * Get the spawn point on the spawn island if it exists
+     * @param world
      * @return the spawnPoint or null if spawn does not exist
      */
-    public Location getSpawnPoint() {
-        return spawn == null ? null : spawn.getSpawnPoint();
+    public Location getSpawnPoint(World world) {
+        return spawn.containsKey(world) ? spawn.get(world).getSpawnPoint() : null;
     }
 
     /**
      * Provides UUID of this player's team leader or null if it does not exist
+     * @param world - world to check
      * @param playerUUID - the player's UUID
      * @return UUID of leader or null if player has no island
      */
-    public UUID getTeamLeader(UUID playerUUID) {
-        return islandCache.getTeamLeader(playerUUID);
+    public UUID getTeamLeader(World world, UUID leaderUUID) {
+        return islandCache.getTeamLeader(world, leaderUUID);
     }
 
     /**
-     * @param playerUUID - the player's UUID
+     * Checks if a player has an island in the world
+     * @param world - world to check
+     * @param user - the user
      * @return true if player has island and owns it
      */
-    public boolean hasIsland(UUID playerUUID) {
-        return islandCache.hasIsland(playerUUID);
+    public boolean hasIsland(World world, User user) {
+        return islandCache.hasIsland(world, user.getUniqueId());
     }
+    
+    /**
+     * Checks if a player has an island in the world
+     * @param world - world to check
+     * @param uuid - the user's uuid
+     * @return true if player has island and owns it
+     */
+    public boolean hasIsland(World world, UUID uuid) {
+        return islandCache.hasIsland(world, uuid);
+    }
+        
     /**
      * This teleports player to their island. If not safe place can be found
      * then the player is sent to spawn via /spawn command
      *
+     * @param world - world to check
      * @param player - the player
      */
-    public void homeTeleport(final Player player) {
-        homeTeleport(player, 1);
+    public void homeTeleport(World world, Player player) {
+        homeTeleport(world, player, 1);
     }
 
     /**
@@ -522,8 +496,9 @@ public class IslandsManager {
      * @param number - a number - home location to do to
      */
     @SuppressWarnings("deprecation")
-    public void homeTeleport(final Player player, int number) {
-        Location home = getSafeHomeLocation(player.getUniqueId(), number);
+    public void homeTeleport(World world, Player player, int number) {
+        User user = User.getInstance(player);
+        Location home = getSafeHomeLocation(world, user, number);
         // Stop any gliding
         player.setGliding(false);
         // Check if the player is a passenger in a boat
@@ -540,13 +515,12 @@ public class IslandsManager {
         if (home == null) {
             // Try to fix this teleport location and teleport the player if possible
             new SafeTeleportBuilder(plugin).entity(player)
-            .island(plugin.getIslands().getIsland(player.getUniqueId()))
+            .island(plugin.getIslands().getIsland(world, user))
             .homeNumber(number)
             .build();
             return;
         }
         player.teleport(home);
-        User user = User.getInstance(player);
         if (number == 1) {
             user.sendMessage("commands.island.go.teleport", "[label]", Constants.ISLANDCOMMAND);
         } else {
@@ -560,23 +534,23 @@ public class IslandsManager {
     }
 
     /**
-     * Indicates whether a player is at the island spawn or not
+     * Indicates whether a player is at an island spawn or not
      *
      * @param playerLoc
      * @return true if they are, false if they are not, or spawn does not exist
      */
     public boolean isAtSpawn(Location playerLoc) {
-        if (spawn == null) {
+        if (!spawn.containsKey(playerLoc.getWorld())) {
             return false;
         }
-        return spawn.onIsland(playerLoc);
+        return spawn.get(playerLoc.getWorld()).onIsland(playerLoc);
     }
 
     /**
      * @param spawn the spawn to set
      */
     public void setSpawn(Island spawn) {
-        this.spawn = spawn;
+        this.spawn.put(spawn.getWorld(), spawn);
     }
 
     /**
@@ -637,8 +611,8 @@ public class IslandsManager {
      * @param uniqueId - unique ID
      * @return true if the player is the owner of their island, i.e., owner or team leader
      */
-    public boolean isOwner(UUID uniqueId) {
-        return hasIsland(uniqueId) ? getIsland(uniqueId).getOwner().equals(uniqueId) : false;
+    public boolean isOwner(World world, UUID uniqueId) {
+        return hasIsland(world, uniqueId) ? getIsland(world, uniqueId).getOwner().equals(uniqueId) : false;
     }
 
     /**
@@ -664,7 +638,7 @@ public class IslandsManager {
      * @param loc - location
      * @return true if location is on island of player
      */
-    public boolean locationIsOnIsland(final Player player, final Location loc) {
+    public boolean locationIsOnIsland(Player player, Location loc) {
         if (player == null) {
             return false;
         }
@@ -687,11 +661,11 @@ public class IslandsManager {
      * @param user - the User
      * @return true if on valid island, false if not
      */
-    public boolean userIsOnIsland(User user) {
+    public boolean userIsOnIsland(World world, User user) {
         if (user == null) {
             return false;
         }
-        return Optional.ofNullable(getIsland(user.getUniqueId())).map(i -> i.onIsland(user.getLocation())).orElse(false);
+        return Optional.ofNullable(getIsland(world, user)).map(i -> i.onIsland(user.getLocation())).orElse(false);
     }
 
 
@@ -704,11 +678,21 @@ public class IslandsManager {
     }
 
     /**
-     * Removes this player from any and all islands.
-     * @param playerUUID - the player's UUID
+     * Removes this player from any and all islands in world
+     * @param world - world
+     * @param user - user
      */
-    public void removePlayer(UUID playerUUID) {
-        islandCache.removePlayer(playerUUID);
+    public void removePlayer(World world, User user) {
+        islandCache.removePlayer(world, user.getUniqueId());
+    }
+    
+    /**
+     * Removes this player from any and all islands in world
+     * @param world - world
+     * @param uuid - user's uuid
+     */
+    public void removePlayer(World world, UUID uuid) {
+        islandCache.removePlayer(world, uuid);
     }
 
     /**
@@ -716,18 +700,18 @@ public class IslandsManager {
      * Mobs are killed when the chunks are refreshed.
      * @param island to remove players from
      */
-    public void removePlayersFromIsland(final Island island) {
+    public void removePlayersFromIsland(Island island) {
         // Teleport players away
         for (Player player : Bukkit.getOnlinePlayers()) {
             if (island.inIslandSpace(player.getLocation().getBlockX(), player.getLocation().getBlockZ())) {
                 // Teleport island players to their island home
-                if (hasIsland(player.getUniqueId()) || plugin.getIslands().inTeam(player.getUniqueId())) {
-                    homeTeleport(player);
+                if (hasIsland(island.getWorld(), player.getUniqueId()) || plugin.getIslands().inTeam(island.getWorld(), player.getUniqueId())) {
+                    homeTeleport(island.getWorld(), player);
                 } else {
                     // Move player to spawn
-                    if (spawn != null) {
+                    if (spawn.containsKey(island.getWorld())) {
                         // go to island spawn
-                        player.teleport(plugin.getIslandWorldManager().getIslandWorld().getSpawnLocation());
+                        player.teleport(spawn.get(island.getWorld()).getSpawnPoint());
                     } else {
                         if (!player.performCommand(Constants.SPAWNCOMMAND)) {
                             plugin.logWarning("During island deletion player " + player.getName() + " could not be sent to spawn so was dropped, sorry.");
@@ -766,15 +750,6 @@ public class IslandsManager {
         }
     }
 
-    /**
-     * Set the island name
-     * @param owner - the island owner
-     * @param name
-     */
-    public void setIslandName(UUID owner, String name) {
-        islandCache.setIslandName(owner, name);
-    }
-
     /**
      * Puts a player in a team. Removes them from their old island if required.
      * @param playerUUID - the player's UUID
@@ -791,16 +766,17 @@ public class IslandsManager {
     }
 
     public void setLast(Location last) {
-        this.last = last;
+        this.last.put(last.getWorld(), last);
     }
 
     /**
      * Called when a player leaves a team
-     * @param playerUUID - the player's UUID
+     * @param world - world
+     * @param uuid - the player's UUID
      */
-    public void setLeaveTeam(UUID playerUUID) {
-        plugin.getPlayers().clearHomeLocations(playerUUID);
-        removePlayer(playerUUID);
+    public void setLeaveTeam(World world, UUID uuid) {
+        plugin.getPlayers().clearHomeLocations(world, uuid);
+        removePlayer(world, uuid);
     }
 
     public void shutdown(){
@@ -811,11 +787,12 @@ public class IslandsManager {
 
     /**
      * Checks if a player is in a team
+     * @param world - world
      * @param playerUUID - player's UUID
      * @return true if in team, false if not
      */
-    public boolean inTeam(UUID playerUUID) {
-        return getMembers(playerUUID).size() > 1;
+    public boolean inTeam(World world, UUID playerUUID) {
+        return getMembers(world, playerUUID).size() > 1;
     }
     
     private int getMaxRangeSize(User user) {
@@ -824,11 +801,12 @@ public class IslandsManager {
 
     /**
      * Makes a new leader for an island
+     * @param world - world
      * @param user - the user who is issuing the command
      * @param targetUUID - the current island member who is going to become the leader
      */
-    public void makeLeader(User user, UUID targetUUID) {
-        makeLeader(user, targetUUID, getIsland(targetUUID));
+    public void makeLeader(World world, User user, UUID targetUUID) {
+        makeLeader(user, targetUUID, getIsland(world, targetUUID));
     }
     
     /**

src/main/java/us/tastybento/bskyblock/managers/PlayersManager.java

@@ -10,6 +10,7 @@ import java.util.UUID;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.World;
 
 import us.tastybento.bskyblock.BSkyBlock;
 import us.tastybento.bskyblock.api.user.User;
@@ -152,6 +153,17 @@ public class PlayersManager {
         }
     }
 
+    /**
+     * Sets the home location for the player
+     * @param user - the player
+     * @param location - the location
+     * @param number - a number - 1 is default. Can be any number.
+     */
+    public void setHomeLocation(User user, Location location, int number) {
+        addPlayer(user.getUniqueId());
+        playerCache.get(user.getUniqueId()).setHomeLocation(location,number);
+    }
+    
     /**
      * Sets the home location for the player
      * @param playerUUID - the player's UUID
@@ -175,23 +187,38 @@ public class PlayersManager {
 
     /**
      * Clears any home locations for player
+     * @param world 
      * @param playerUUID - the player's UUID
      */
-    public void clearHomeLocations(UUID playerUUID) {
+    public void clearHomeLocations(World world, UUID playerUUID) {
         addPlayer(playerUUID);
-        playerCache.get(playerUUID).clearHomeLocations();
+        playerCache.get(playerUUID).clearHomeLocations(world);
     }
 
     /**
      * Returns the home location, or null if none
+     * @param world 
+     *
+     * @param user - the player
+     * @param number - a number
+     * @return Home location or null if none
+     */
+    public Location getHomeLocation(World world, User user, int number) {
+        addPlayer(user.getUniqueId());
+        return playerCache.get(user.getUniqueId()).getHomeLocation(world, number);
+    }
+    
+    /**
+     * Returns the home location, or null if none
+     * @param world 
      *
      * @param playerUUID - the player's UUID
      * @param number - a number
      * @return Home location or null if none
      */
-    public Location getHomeLocation(UUID playerUUID, int number) {
+    public Location getHomeLocation(World world, UUID playerUUID, int number) {
         addPlayer(playerUUID);
-        return playerCache.get(playerUUID).getHomeLocation(number);
+        return playerCache.get(playerUUID).getHomeLocation(world, number);
     }
 
     /**
@@ -199,9 +226,9 @@ public class PlayersManager {
      * @param playerUUID - the player's UUID
      * @return Home location or null if none
      */
-    public Location getHomeLocation(UUID playerUUID) {
+    public Location getHomeLocation(World world, UUID playerUUID) {
         addPlayer(playerUUID);
-        return playerCache.get(playerUUID).getHomeLocation(1);
+        return playerCache.get(playerUUID).getHomeLocation(world, 1);
     }
 
     /**
@@ -209,9 +236,9 @@ public class PlayersManager {
      * @param playerUUID - the player's UUID
      * @return List of home locations
      */
-    public Map<Integer, Location> getHomeLocations(UUID playerUUID) {
+    public Map<Location, Integer> getHomeLocations(World world, UUID playerUUID) {
         addPlayer(playerUUID);
-        return playerCache.get(playerUUID).getHomeLocations();
+        return playerCache.get(playerUUID).getHomeLocations(world);
     }
 
     /**

src/main/java/us/tastybento/bskyblock/managers/island/IslandCache.java

@@ -5,35 +5,34 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
-import java.util.TreeMap;
 import java.util.UUID;
 
-import org.bukkit.ChatColor;
 import org.bukkit.Location;
+import org.bukkit.World;
 
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 
-import us.tastybento.bskyblock.BSkyBlock;
 import us.tastybento.bskyblock.database.objects.Island;
 import us.tastybento.bskyblock.util.Util;
 
 public class IslandCache {
-    private BSkyBlock plugin;
     private BiMap<Location, Island> islandsByLocation;
     /**
      * Every player who is associated with an island is in this map.
      */
-    private HashMap<UUID, Island> islandsByUUID;
-    // 2D islandGrid of islands, x,z
-    private TreeMap<Integer, TreeMap<Integer, Island>> islandGrid = new TreeMap<>();
+    private Map<World, Map<UUID, Island>> islandsByUUID;
+    private Map<World, IslandGrid> grids;
+    private IslandGrid defaultGrid;
 
-    public IslandCache(BSkyBlock plugin) {
-        this.plugin = plugin;
+    public IslandCache() {
         islandsByLocation = HashBiMap.create();
         islandsByUUID = new HashMap<>();
+        grids = new HashMap<>();
+        defaultGrid = new IslandGrid();
     }
 
     /**
@@ -43,20 +42,22 @@ public class IslandCache {
      */
     public boolean addIsland(Island island) {
         islandsByLocation.put(island.getCenter(), island);
-        islandsByUUID.put(island.getOwner(), island);
+        islandsByUUID.putIfAbsent(island.getWorld(), new HashMap<>());
+        islandsByUUID.get(island.getWorld()).put(island.getOwner(), island);
         for (UUID member: island.getMemberSet()) {
-            islandsByUUID.put(member, island);
+            islandsByUUID.get(island.getWorld()).put(member, island);
         }
         return addToGrid(island);
     }
 
     /**
      * Adds a player's UUID to the look up for islands. Does no checking
-     * @param playerUUID
-     * @param teamIsland
+     * @param uuid - player's uuid
+     * @param island - island to associate with this uuid. Only one island can be associated per world.
      */
-    public void addPlayer(UUID playerUUID, Island teamIsland) {
-        islandsByUUID.put(playerUUID, teamIsland);
+    public void addPlayer(UUID uuid, Island island) {
+        islandsByUUID.putIfAbsent(island.getWorld(), new HashMap<>());
+        islandsByUUID.get(island.getWorld()).put(uuid, island);
     }
 
     /**
@@ -65,41 +66,7 @@ public class IslandCache {
      * @return true if successfully added, false if not
      */
     private boolean addToGrid(Island newIsland) {
-        if (islandGrid.containsKey(newIsland.getMinX())) {
-            TreeMap<Integer, Island> zEntry = islandGrid.get(newIsland.getMinX());
-            if (zEntry.containsKey(newIsland.getMinZ())) {
-                // Island already exists
-                Island conflict = islandGrid.get(newIsland.getMinX()).get(newIsland.getMinZ());
-                plugin.logWarning("*** Duplicate or overlapping islands! ***");
-                plugin.logWarning(
-                        "Island at (" + newIsland.getCenter().getBlockX() + ", " + newIsland.getCenter().getBlockZ() + ") conflicts with ("
-                                + conflict.getCenter().getBlockX() + ", " + conflict.getCenter().getBlockZ() + ")");
-                if (conflict.getOwner() != null) {
-                    plugin.logWarning("Accepted island is owned by " + plugin.getPlayers().getName(conflict.getOwner()));
-                    plugin.logWarning(conflict.getOwner().toString() + ".yml");
-                } else {
-                    plugin.logWarning("Accepted island is unowned.");
-                }
-                if (newIsland.getOwner() != null) {
-                    plugin.logWarning("Denied island is owned by " + plugin.getPlayers().getName(newIsland.getOwner()));
-                    plugin.logWarning(newIsland.getOwner().toString() + ".yml");
-                } else {
-                    plugin.logWarning("Denied island is unowned and is a database duplicate. Skipping it...");
-                }
-                plugin.logWarning("Recommend that the denied player file is deleted otherwise weird things can happen.");
-                return false;
-            } else {
-                // Add island
-                zEntry.put(newIsland.getMinZ(), newIsland);
-                islandGrid.put(newIsland.getMinX(), zEntry);
-            }
-        } else {
-            // Add island
-            TreeMap<Integer, Island> zEntry = new TreeMap<>();
-            zEntry.put(newIsland.getMinZ(), newIsland);
-            islandGrid.put(newIsland.getMinX(), zEntry);
-        }
-        return true;
+        return grids.getOrDefault(newIsland.getWorld(), defaultGrid).addToGrid(newIsland);
     }
 
     public void clear() {
@@ -113,10 +80,10 @@ public class IslandCache {
      * @return true if successful, false if not
      */
     public boolean deleteIslandFromCache(Island island) {
-        if (!islandsByLocation.remove(island.getCenter(), island)) {
+        if (!islandsByLocation.remove(island.getCenter(), island) || !islandsByUUID.containsKey(island.getWorld())) {         
             return false;
         }
-        Iterator<Entry<UUID, Island>> it = islandsByUUID.entrySet().iterator();
+        Iterator<Entry<UUID, Island>> it = islandsByUUID.get(island.getWorld()).entrySet().iterator();
         while (it.hasNext()) {
             Entry<UUID, Island> en = it.next();
             if (en.getValue().equals(island)) {
@@ -124,19 +91,7 @@ public class IslandCache {
             }
         }
         // Remove from grid
-        if (island != null) {
-            int x = island.getMinX();
-            int z = island.getMinZ();
-            if (islandGrid.containsKey(x)) {
-                TreeMap<Integer, Island> zEntry = islandGrid.get(x);
-                if (zEntry.containsKey(z)) {
-                    // Island exists - delete it
-                    zEntry.remove(z);
-                    islandGrid.put(x, zEntry);
-                }
-            }
-        }
-        return true;
+        return grids.getOrDefault(island.getWorld(), defaultGrid).removeFromGrid(island);
     }
 
     /**
@@ -150,34 +105,12 @@ public class IslandCache {
 
     /**
      * Returns island referenced by UUID
-     * @param uuid - uuid of player
+     * @param world - world to check
+     * @param uuid - player
      * @return island or null if none
      */
-    public Island get(UUID uuid) {
-        return islandsByUUID.get(uuid);
-    }
-
-    /**
-     * Returns the island at the x,z location or null if there is none.
-     * This includes the full island space, not just the protected area.
-     *
-     * @param x - x coordinate
-     * @param z - z coordinate
-     * @return Island or null
-     */
-    public Island getIslandAt(int x, int z) {
-        Entry<Integer, TreeMap<Integer, Island>> en = islandGrid.floorEntry(x);
-        if (en != null) {
-            Entry<Integer, Island> ent = en.getValue().floorEntry(z);
-            if (ent != null) {
-                // Check if in the island range
-                Island island = ent.getValue();
-                if (island.inIslandSpace(x, z)) {
-                    return island;
-                }
-            }
-        }
-        return null;
+    public Island get(World world, UUID uuid) {
+        return islandsByUUID.containsKey(world) ? islandsByUUID.get(world).get(uuid) : null;
     }
 
     /**
@@ -195,51 +128,53 @@ public class IslandCache {
         if (!Util.inWorld(location)) {
             return null;
         }
-        return getIslandAt(location.getBlockX(), location.getBlockZ());
+        return grids.getOrDefault(location.getWorld(), defaultGrid).getIslandAt(location.getBlockX(), location.getBlockZ());
     }
-
-    /**
-     * Get name of the island owned by owner
-     * @param owner - the island owner
-     * @return Returns the name of owner's island, or the owner's name if there is none.
-     */
-    public String getIslandName(UUID owner) {
-        String result = plugin.getPlayers().getName(owner);
-        if (islandsByUUID.containsKey(owner)) {
-            Island island = islandsByUUID.get(owner);
-            if (island.getName() != null && !island.getName().isEmpty()) {
-                result = island.getName();
-            }
-        }
-        return ChatColor.translateAlternateColorCodes('&', result) + ChatColor.RESET;
-    }
-
+    
     public Collection<Island> getIslands() {
         return Collections.unmodifiableCollection(islandsByLocation.values());
     }
 
-    public Set<UUID> getMembers(UUID playerUUID) {
-        Island island = islandsByUUID.get(playerUUID);
+    /**
+     * @param world - world to check
+     * @param uuid - uuid of player to check
+     * @return set of UUID's of island members. If there is no island, this set will be empty
+     */
+    public Set<UUID> getMembers(World world, UUID uuid) {
+        islandsByUUID.putIfAbsent(world, new HashMap<>());
+        Island island = islandsByUUID.get(world).get(uuid);
         if (island != null) {
             return island.getMemberSet();
         }
         return new HashSet<>(0);
     }
 
-    public UUID getTeamLeader(UUID playerUUID) {
-        if (islandsByUUID.containsKey(playerUUID)) {
-            return islandsByUUID.get(playerUUID).getOwner();
+    /**
+     * @param world - the world to check
+     * @param uuid - player's uuid
+     * @return team leader's UUID, the player UUID if they are not in a team, or null if there is no island
+     */
+    public UUID getTeamLeader(World world, UUID uuid) {
+        islandsByUUID.putIfAbsent(world, new HashMap<>());
+        Island island = islandsByUUID.get(world).get(uuid);
+        if (island != null) {
+            return island.getOwner();
         }
         return null;
     }
 
     /**
-     * @param playerUUID - the player's UUID
+     * @param world - the world to check
+     * @param uuid - the player
      * @return true if player has island and owns it
      */
-    public boolean hasIsland(UUID playerUUID) {
-        return (islandsByUUID.containsKey(playerUUID) && islandsByUUID.get(playerUUID).getOwner() != null 
-                && (islandsByUUID.get(playerUUID).getOwner().equals(playerUUID))) ? true : false;
+    public boolean hasIsland(World world, UUID uuid) {
+        islandsByUUID.putIfAbsent(world, new HashMap<>());
+        Island island = islandsByUUID.get(world).get(uuid);
+        if (island != null) {
+            return island.getOwner().equals(uuid);
+        }
+        return false;
     }
 
     /**
@@ -247,34 +182,20 @@ public class IslandCache {
      * The island is removed from the islandsByUUID map, but kept in the location map.
      * @param playerUUID - player's UUID
      */
-    public void removePlayer(UUID playerUUID) {
-        Island island = islandsByUUID.get(playerUUID);
+    public void removePlayer(World world, UUID uuid) {
+        islandsByUUID.putIfAbsent(world, new HashMap<>());
+        Island island = islandsByUUID.get(world).get(uuid);
         if (island != null) {
-            if (island.getOwner() != null && island.getOwner().equals(playerUUID)) {
+            if (island.getOwner() != null && island.getOwner().equals(uuid)) {
                 // Clear ownership and members
                 island.getMembers().clear();
                 island.setOwner(null);
             } else {
                 // Remove player from the island membership
-                island.removeMember(playerUUID);
+                island.removeMember(uuid);
             }
         }
-        islandsByUUID.remove(playerUUID);
-    }
-
-    /**
-     * Sets the island name
-     * @param owner - owner of island
-     * @param name - new island name
-     * @return true if successfull, false if no island for owner
-     */
-    public boolean setIslandName(UUID owner, String name) {
-        if (islandsByUUID.containsKey(owner)) {
-            Island island = islandsByUUID.get(owner);
-            island.setName(name);
-            return true;
-        }
-        return false;
+        islandsByUUID.get(world).remove(uuid);
     }
 
     /**
@@ -292,7 +213,8 @@ public class IslandCache {
      */
     public void setOwner(Island island, UUID newOwnerUUID) {
         island.setOwner(newOwnerUUID);
-        islandsByUUID.put(newOwnerUUID, island);
+        islandsByUUID.putIfAbsent(island.getWorld(), new HashMap<>());
+        islandsByUUID.get(island.getWorld()).put(newOwnerUUID, island);
         islandsByLocation.put(island.getCenter(), island);        
     }
     

src/main/java/us/tastybento/bskyblock/managers/island/IslandGrid.java

@@ -0,0 +1,85 @@
+package us.tastybento.bskyblock.managers.island;
+
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+import us.tastybento.bskyblock.database.objects.Island;
+
+/**
+ * Handles the island location grid for each world
+ * @author tastybento
+ *
+ */
+public class IslandGrid {
+    private TreeMap<Integer, TreeMap<Integer, Island>> islandGrid = new TreeMap<>();
+
+    /**
+     * Adds island to grid
+     * @param island - island to add
+     * @return true if successfully added, false if island already exists, or there is an overlap
+     */
+    public boolean addToGrid(Island island) {
+        if (islandGrid.containsKey(island.getMinX())) {
+            TreeMap<Integer, Island> zEntry = islandGrid.get(island.getMinX());
+            if (zEntry.containsKey(island.getMinZ())) {
+                return false;
+            } else {
+                // Add island
+                zEntry.put(island.getMinZ(), island);
+                islandGrid.put(island.getMinX(), zEntry);
+            }
+        } else {
+            // Add island
+            TreeMap<Integer, Island> zEntry = new TreeMap<>();
+            zEntry.put(island.getMinZ(), island);
+            islandGrid.put(island.getMinX(), zEntry);
+        }
+        return true;
+    }
+    
+    /**
+     * Remove island from grid
+     * @param island - the island to remove
+     * @return true if island existed and was deleted, false if there was nothing to delete
+     */
+    public boolean removeFromGrid(Island island) {
+        // Remove from grid
+        if (island != null) {
+            int x = island.getMinX();
+            int z = island.getMinZ();
+            if (islandGrid.containsKey(x)) {
+                TreeMap<Integer, Island> zEntry = islandGrid.get(x);
+                if (zEntry.containsKey(z)) {
+                    // Island exists - delete it
+                    zEntry.remove(z);
+                    islandGrid.put(x, zEntry);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    
+    /**
+     * Returns the island at the x,z location or null if there is none.
+     * This includes the full island space, not just the protected area.
+     *
+     * @param x - x coordinate
+     * @param z - z coordinate
+     * @return Island or null
+     */
+    public Island getIslandAt(int x, int z) {
+        Entry<Integer, TreeMap<Integer, Island>> en = islandGrid.floorEntry(x);
+        if (en != null) {
+            Entry<Integer, Island> ent = en.getValue().floorEntry(z);
+            if (ent != null) {
+                // Check if in the island range
+                Island island = ent.getValue();
+                if (island.inIslandSpace(x, z)) {
+                    return island;
+                }
+            }
+        }
+        return null;
+    }
+}

src/main/java/us/tastybento/bskyblock/managers/island/NewIsland.java

@@ -1,15 +1,15 @@
 package us.tastybento.bskyblock.managers.island;
 
 import java.io.IOException;
-import java.util.UUID;
 
 import org.bukkit.Location;
-import org.bukkit.entity.Player;
+import org.bukkit.World;
 
 import us.tastybento.bskyblock.BSkyBlock;
 import us.tastybento.bskyblock.api.events.IslandBaseEvent;
 import us.tastybento.bskyblock.api.events.island.IslandEvent;
 import us.tastybento.bskyblock.api.events.island.IslandEvent.Reason;
+import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.database.objects.Island;
 import us.tastybento.bskyblock.island.builders.IslandBuilder;
 import us.tastybento.bskyblock.island.builders.IslandBuilder.IslandType;
@@ -22,14 +22,16 @@ import us.tastybento.bskyblock.island.builders.IslandBuilder.IslandType;
 public class NewIsland {
     private BSkyBlock plugin;
     private Island island;
-    private final Player player;
+    private final User user;
     private final Reason reason;
+    private final World world;
 
-    private NewIsland(Island oldIsland, Player player, Reason reason) {
+    private NewIsland(Island oldIsland, User user, Reason reason, World world) {
         super();
         plugin = BSkyBlock.getInstance();
-        this.player = player;
+        this.user = user;
         this.reason = reason;
+        this.world = world;
         newIsland();
         if (oldIsland != null) {
             // Delete the old island
@@ -58,29 +60,36 @@ public class NewIsland {
      *
      */
     public static class Builder {
-        private Island oldIsland;
-        private Player player;
-        private Reason reason;
+        private Island oldIsland2;
+        private User user2;
+        private Reason reason2;
+        private World world2;
 
         public Builder oldIsland(Island oldIsland) {
-            this.oldIsland = oldIsland;
+            this.oldIsland2 = oldIsland;
+            this.world2 = oldIsland.getWorld();
             return this;
         }
 
 
-        public Builder player(Player player) {
-            this.player = player;
+        public Builder player(User player) {
+            this.user2 = player;
             return this;
         }
 
         public Builder reason(Reason reason) {
-            this.reason = reason;
+            this.reason2 = reason;
             return this;
         }
+        
+        public Builder world(World world) {
+           this.world2 = world;
+           return this;
+        }
 
         public Island build() throws IOException {
-            if (player != null) {
-                NewIsland newIsland = new NewIsland(oldIsland, player, reason);
+            if (user2 != null) {
+                NewIsland newIsland = new NewIsland(oldIsland2, user2, reason2, world2);
                 return newIsland.getIsland();
             }
             throw new IOException("Insufficient parameters. Must have a schematic and a player");
@@ -91,21 +100,20 @@ public class NewIsland {
      * Makes an island.
      */
     public void newIsland() {
-        final UUID playerUUID = player.getUniqueId();
         Location next = getNextIsland();
         // Add to the grid
-        island = plugin.getIslands().createIsland(next, playerUUID);
+        island = plugin.getIslands().createIsland(next, user.getUniqueId());
         // Save the player so that if the server is reset weird things won't happen
 
         // Clear any old home locations (they should be clear, but just in case)
-        plugin.getPlayers().clearHomeLocations(playerUUID);
+        plugin.getPlayers().clearHomeLocations(world, user.getUniqueId());
 
-        // Set home loction
-        plugin.getPlayers().setHomeLocation(playerUUID, next, 1);
+        // Set home location
+        plugin.getPlayers().setHomeLocation(user, next, 1);
 
         // Fire event
         IslandBaseEvent event = IslandEvent.builder()
-                .involvedPlayer(player.getUniqueId())
+                .involvedPlayer(user.getUniqueId())
                 .reason(reason)
                 .island(island)
                 .location(island.getCenter())
@@ -113,26 +121,26 @@ public class NewIsland {
         if (!event.isCancelled()) {
             // Create island
             new IslandBuilder(plugin, island)
-            .setPlayer(player)
+            .setPlayer(user.getPlayer())
             .setChestItems(plugin.getSettings().getChestItems())
             .setType(IslandType.ISLAND)
             .build();
             if (plugin.getSettings().isNetherGenerate() && plugin.getSettings().isNetherIslands() && plugin.getIslandWorldManager().getNetherWorld() != null) {
                 new IslandBuilder(plugin,island)
-                .setPlayer(player)
+                .setPlayer(user.getPlayer())
                 .setChestItems(plugin.getSettings().getChestItems())
                 .setType(IslandType.NETHER)
                 .build();
             }
             if (plugin.getSettings().isEndGenerate() && plugin.getSettings().isEndIslands() && plugin.getIslandWorldManager().getEndWorld() != null) {
                 new IslandBuilder(plugin,island)
-                .setPlayer(player)
+                .setPlayer(user.getPlayer())
                 .setChestItems(plugin.getSettings().getChestItems())
                 .setType(IslandType.END)
                 .build();
             }
             // Teleport player to their island
-            plugin.getIslands().homeTeleport(player);
+            plugin.getIslands().homeTeleport(world, user.getPlayer());
             // Fire exit event
             Reason reasonDone = Reason.CREATED;
             switch (reason) {
@@ -146,7 +154,7 @@ public class NewIsland {
                 break;
             }
             IslandEvent.builder()
-                    .involvedPlayer(player.getUniqueId())
+                    .involvedPlayer(user.getUniqueId())
                     .reason(reasonDone)
                     .island(island)
                     .location(island.getCenter())
@@ -159,7 +167,7 @@ public class NewIsland {
      * @return Location of island spot
      */
     private Location getNextIsland() {
-        Location last = plugin.getIslands().getLast();
+        Location last = plugin.getIslands().getLast(world);
         if (last == null) {
             last = new Location(plugin.getIslandWorldManager().getIslandWorld(), plugin.getSettings().getIslandXOffset() + plugin.getSettings().getIslandStartX(),
                     plugin.getSettings().getIslandHeight(), plugin.getSettings().getIslandZOffset() + plugin.getSettings().getIslandStartZ());

src/main/java/us/tastybento/bskyblock/util/teleport/SafeSpotTeleport.java

@@ -17,6 +17,7 @@ import org.bukkit.scheduler.BukkitTask;
 import org.bukkit.util.Vector;
 
 import us.tastybento.bskyblock.BSkyBlock;
+import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.database.objects.Island;
 import us.tastybento.bskyblock.util.Pair;
 
@@ -205,7 +206,7 @@ public class SafeSpotTeleport {
         Bukkit.getScheduler().runTask(plugin, () -> {
             if (!portal && entity instanceof Player) {
                 // Set home
-                plugin.getPlayers().setHomeLocation(entity.getUniqueId(), loc, homeNumber);
+                plugin.getPlayers().setHomeLocation(User.getInstance(entity), loc, homeNumber);
             }
             Vector velocity = entity.getVelocity();
             entity.teleport(loc);

src/test/java/us/tastybento/bskyblock/api/commands/DefaultHelpCommandTest.java

@@ -80,10 +80,10 @@ public class DefaultHelpCommandTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Has team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getIslands()).thenReturn(im);
 
 

src/test/java/us/tastybento/bskyblock/api/flags/FlagTest.java

@@ -145,7 +145,8 @@ public class FlagTest {
         when(user.getTranslation(Mockito.anyString())).thenReturn("translation");
         when(user.getTranslation(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn("long translation");
         
-        when(im.getIsland(Mockito.any())).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(island);
         Optional<Island> oL = Optional.ofNullable(island);
         when(im.getIslandAt(Mockito.any(Location.class))).thenReturn(oL);
         when(plugin.getIslands()).thenReturn(im);

src/test/java/us/tastybento/bskyblock/commands/IslandCommandTest.java

@@ -7,20 +7,24 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.UUID;
 import java.util.logging.Logger;
 
 import org.bukkit.Bukkit;
+import org.bukkit.Location;
 import org.bukkit.Server;
 import org.bukkit.World;
+import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginManager;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 import org.powermock.reflect.Whitebox;
@@ -28,13 +32,20 @@ import org.powermock.reflect.Whitebox;
 import us.tastybento.bskyblock.BSkyBlock;
 import us.tastybento.bskyblock.Constants;
 import us.tastybento.bskyblock.Settings;
+import us.tastybento.bskyblock.api.events.IslandBaseEvent;
+import us.tastybento.bskyblock.api.events.island.IslandEvent;
+import us.tastybento.bskyblock.api.events.island.IslandEvent.IslandEventBuilder;
 import us.tastybento.bskyblock.api.user.User;
+import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.PlayersManager;
+import us.tastybento.bskyblock.managers.island.NewIsland;
+import us.tastybento.bskyblock.managers.island.NewIsland.Builder;
 
 @RunWith(PowerMockRunner.class)
-@PrepareForTest(BSkyBlock.class)
+@PrepareForTest({Bukkit.class, BSkyBlock.class, NewIsland.class, IslandEvent.class })
 public class IslandCommandTest {
 
     @Mock
@@ -52,13 +63,17 @@ public class IslandCommandTest {
         PluginManager pluginManager = mock(PluginManager.class);
         when(server.getPluginManager()).thenReturn(pluginManager);
 
-        Bukkit.setServer(server);
-
-        when(Bukkit.getLogger()).thenReturn(Logger.getAnonymousLogger());
+        PowerMockito.mockStatic(Bukkit.class);
+        when(Bukkit.getServer()).thenReturn(server);
 
         plugin = mock(BSkyBlock.class);
         Whitebox.setInternalState(BSkyBlock.class, "instance", plugin);
-
+        
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
     }
 
     @Test
@@ -83,7 +98,28 @@ public class IslandCommandTest {
     }
 
     @Test
-    public void testExecuteUserListOfString() {
+    public void testExecuteUserListOfString() throws IOException {
+        PowerMockito.mockStatic(NewIsland.class);
+        Builder builder = mock(Builder.class);
+        Island island = mock(Island.class);
+        when(builder.build()).thenReturn(island);
+        when(builder.oldIsland(Mockito.any())).thenReturn(builder);
+        when(builder.player(Mockito.any())).thenReturn(builder);
+        when(builder.reason(Mockito.any())).thenReturn(builder);
+        when(builder.world(Mockito.any())).thenReturn(builder);
+        when(NewIsland.builder()).thenReturn(builder);
+        
+        PowerMockito.mockStatic(IslandEvent.class);
+        IslandEventBuilder ieb = mock(IslandEventBuilder.class);
+        when(ieb.admin(Mockito.anyBoolean())).thenReturn(ieb);
+        IslandBaseEvent event = mock(IslandBaseEvent.class);
+        when(ieb.build()).thenReturn(event);
+        when(ieb.involvedPlayer(Mockito.any())).thenReturn(ieb);
+        when(ieb.island(Mockito.any())).thenReturn(ieb);
+        when(ieb.location(Mockito.any())).thenReturn(ieb);
+        when(ieb.reason(Mockito.any())).thenReturn(ieb);
+        when(IslandEvent.builder()).thenReturn(ieb);
+        
         CommandsManager cm = mock(CommandsManager.class);
         when(plugin.getCommandsManager()).thenReturn(cm);
         // Setup
@@ -93,6 +129,8 @@ public class IslandCommandTest {
         when(plugin.getIslands()).thenReturn(im);
         User user = mock(User.class);
         UUID uuid = UUID.randomUUID();
+        Player player = mock(Player.class);
+        when(user.getPlayer()).thenReturn(player);
         when(user.getUniqueId()).thenReturn(uuid);
         PlayersManager pm = mock(PlayersManager.class);
         when(plugin.getPlayers()).thenReturn(pm);
@@ -100,11 +138,15 @@ public class IslandCommandTest {
         when(plugin.getSettings()).thenReturn(settings);
 
         // User has an island - so go there!
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         assertTrue(ic.execute(user, new ArrayList<>()));
 
-        // No island yet
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
+        //Island island = mock(Island.class);
+        Location location = mock(Location.class);
+        when(island.getCenter()).thenReturn(location);
+        // No island yet, one will be created
+        when(im.createIsland(Mockito.any(), Mockito.any())).thenReturn(island);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         assertTrue(ic.execute(user, new ArrayList<>()));
         
         // No such command

src/test/java/us/tastybento/bskyblock/commands/admin/AdminInfoCommandTest.java

@@ -12,6 +12,7 @@ import java.util.UUID;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
@@ -29,6 +30,7 @@ import us.tastybento.bskyblock.Settings;
 import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -89,16 +91,24 @@ public class AdminInfoCommandTest {
         ac = mock(AdminCommand.class);
         when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
 
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
+
+
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(),Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
 
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -146,8 +156,8 @@ public class AdminInfoCommandTest {
         AdminInfoCommand itl = new AdminInfoCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.hasIsland(Mockito.any())).thenReturn(false);
-        when(im.inTeam(Mockito.any())).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(false);
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.player-has-no-island"));
     }
@@ -160,9 +170,9 @@ public class AdminInfoCommandTest {
         AdminInfoCommand itl = new AdminInfoCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(notUUID)).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.eq(notUUID))).thenReturn(is);
         assertTrue(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(is).showInfo(Mockito.eq(plugin), Mockito.eq(user));
     }

src/test/java/us/tastybento/bskyblock/commands/admin/AdminRegisterCommandTest.java

@@ -13,6 +13,7 @@ import java.util.UUID;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.bukkit.util.Vector;
@@ -30,6 +31,7 @@ import us.tastybento.bskyblock.Settings;
 import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -91,16 +93,24 @@ public class AdminRegisterCommandTest {
         ac = mock(AdminCommand.class);
         when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
 
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
+
+
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(),Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
 
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -146,8 +156,8 @@ public class AdminRegisterCommandTest {
         AdminRegisterCommand itl = new AdminRegisterCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.inTeam(Mockito.any())).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(false);
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.player-has-island"));
     }
@@ -157,8 +167,8 @@ public class AdminRegisterCommandTest {
      */
     @Test
     public void testExecuteInTeam() {
-        when(im.hasIsland(Mockito.any())).thenReturn(false);
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         AdminRegisterCommand itl = new AdminRegisterCommand(ac);
@@ -171,8 +181,8 @@ public class AdminRegisterCommandTest {
      */
     @Test
     public void testExecuteAlreadyOwnedIsland() {
-        when(im.inTeam(Mockito.any())).thenReturn(false);
-        when(im.hasIsland(Mockito.any())).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         Location loc = mock(Location.class);
@@ -193,13 +203,13 @@ public class AdminRegisterCommandTest {
      */
     @Test
     public void testExecuteSuccess() {
-        when(im.inTeam(Mockito.any())).thenReturn(false);
-        when(im.hasIsland(Mockito.any())).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
         Island is = mock(Island.class);
         Location loc = mock(Location.class);
         when(loc.toVector()).thenReturn(new Vector(123,123,432));
         when(is.getCenter()).thenReturn(loc);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         Optional<Island> opi = Optional.of(is);
         when(im.getIslandAt(Mockito.any())).thenReturn(opi);
         when(user.getLocation()).thenReturn(loc);

src/test/java/us/tastybento/bskyblock/commands/admin/AdminUnregisterCommandTest.java

@@ -12,6 +12,7 @@ import java.util.UUID;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.bukkit.util.Vector;
@@ -29,6 +30,7 @@ import us.tastybento.bskyblock.Settings;
 import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -90,16 +92,24 @@ public class AdminUnregisterCommandTest {
         ac = mock(AdminCommand.class);
         when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
 
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
+
+
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(),Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
 
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -145,7 +155,7 @@ public class AdminUnregisterCommandTest {
         AdminUnregisterCommand itl = new AdminUnregisterCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.hasIsland(Mockito.any())).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.player-has-no-island"));
     }
@@ -155,7 +165,7 @@ public class AdminUnregisterCommandTest {
      */
     @Test
     public void testExecuteInTeam() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(),Mockito.any())).thenReturn(true);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         AdminUnregisterCommand itl = new AdminUnregisterCommand(ac);
@@ -168,12 +178,12 @@ public class AdminUnregisterCommandTest {
      */
     @Test
     public void testExecuteSuccess() {
-        when(im.inTeam(Mockito.any())).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(false);
         Island is = mock(Island.class);
         Location loc = mock(Location.class);
         when(loc.toVector()).thenReturn(new Vector(123,123,432));
         when(is.getCenter()).thenReturn(loc);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
 

src/test/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamAddCommandTest.java

@@ -12,6 +12,7 @@ import java.util.List;
 import java.util.UUID;
 
 import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.junit.Before;
@@ -28,6 +29,7 @@ import us.tastybento.bskyblock.Settings;
 import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -90,14 +92,15 @@ public class AdminTeamAddCommandTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -110,6 +113,12 @@ public class AdminTeamAddCommandTest {
         LocalesManager lm = mock(LocalesManager.class);
         when(lm.get(Mockito.any(), Mockito.any())).thenReturn("mock translation");
         when(plugin.getLocalesManager()).thenReturn(lm);
+        
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
     }
 
 
@@ -163,7 +172,7 @@ public class AdminTeamAddCommandTest {
         when(pm.getUUID(Mockito.eq("tastybento"))).thenReturn(uuid);
         when(pm.getUUID(Mockito.eq("poslovich"))).thenReturn(notUUID);
         
-        when(im.inTeam(notUUID)).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(notUUID))).thenReturn(true);
         
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("commands.island.team.invite.errors.already-on-team"));
@@ -182,7 +191,7 @@ public class AdminTeamAddCommandTest {
         when(pm.getUUID(Mockito.eq("poslovich"))).thenReturn(notUUID);
         
         // No island,
-        when(im.hasIsland(uuid)).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage("general.errors.player-has-no-island");
@@ -201,13 +210,13 @@ public class AdminTeamAddCommandTest {
         when(pm.getUUID(Mockito.eq("poslovich"))).thenReturn(notUUID);
         
         // Has island, has team, but not a leader
-        when(im.hasIsland(uuid)).thenReturn(true);
-        when(im.inTeam(uuid)).thenReturn(true);
-        when(im.getTeamLeader(uuid)).thenReturn(notUUID);
+        when(im.hasIsland(Mockito.any(),Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(),Mockito.eq(uuid))).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.eq(uuid))).thenReturn(notUUID);
         
         // Island
         Island island = mock(Island.class);
-        when(im.getIsland(uuid)).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(island);
         
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage("commands.admin.team.add.name-not-leader", "[name]", "tastybento");
@@ -226,12 +235,12 @@ public class AdminTeamAddCommandTest {
         when(pm.getUUID(Mockito.eq("poslovich"))).thenReturn(notUUID);
         
         // Has island, has team, is leader
-        when(im.hasIsland(uuid)).thenReturn(true);
-        when(im.inTeam(uuid)).thenReturn(true);
-        when(im.getTeamLeader(uuid)).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(),Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(),Mockito.eq(uuid))).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(uuid))).thenReturn(uuid);
         
         // Target has island
-        when(im.hasIsland(notUUID)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(notUUID))).thenReturn(true);
         
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage("commands.admin.team.add.name-has-island", "[name]", "poslovich");
@@ -250,11 +259,11 @@ public class AdminTeamAddCommandTest {
         when(pm.getUUID(Mockito.eq("poslovich"))).thenReturn(notUUID);
         
         // Has island, no team
-        when(im.hasIsland(uuid)).thenReturn(true);
-        when(im.inTeam(uuid)).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         
         // Target has island
-        when(im.hasIsland(notUUID)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(notUUID))).thenReturn(true);
         
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage("commands.admin.team.add.name-has-island", "[name]", "poslovich");
@@ -273,15 +282,15 @@ public class AdminTeamAddCommandTest {
         when(pm.getUUID(Mockito.eq("poslovich"))).thenReturn(notUUID);
         
         // Has island, no team
-        when(im.hasIsland(uuid)).thenReturn(true);
-        when(im.inTeam(uuid)).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         
         // Target has no island
-        when(im.hasIsland(notUUID)).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(notUUID))).thenReturn(false);
         
         // Island
         Island island = mock(Island.class);
-        when(im.getIsland(uuid)).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(island);
 
         
         // Success

src/test/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamDisbandCommandTest.java

@@ -12,6 +12,7 @@ import java.util.Set;
 import java.util.UUID;
 
 import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.junit.Before;
@@ -28,6 +29,7 @@ import us.tastybento.bskyblock.Settings;
 import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -87,17 +89,25 @@ public class AdminTeamDisbandCommandTest {
         // Parent command has no aliases
         ac = mock(AdminCommand.class);
         when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
+        
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
+
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(),Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -143,7 +153,7 @@ public class AdminTeamDisbandCommandTest {
         AdminTeamDisbandCommand itl = new AdminTeamDisbandCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(new HashSet<>());
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(new HashSet<>());
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.not-in-team"));
     }
@@ -153,13 +163,13 @@ public class AdminTeamDisbandCommandTest {
      */
     @Test
     public void testExecuteDisbandNotLeader() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         
-        when(im.getTeamLeader(notUUID)).thenReturn(uuid);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(notUUID))).thenReturn(uuid);
         when(pm.getName(Mockito.any())).thenReturn("leader");
         
         AdminTeamDisbandCommand itl = new AdminTeamDisbandCommand(ac);
@@ -172,23 +182,23 @@ public class AdminTeamDisbandCommandTest {
      */
     @Test
     public void testExecuteSuccess() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         // Leader
-        when(im.getTeamLeader(notUUID)).thenReturn(notUUID);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(notUUID))).thenReturn(notUUID);
         // Members
         Set<UUID> members = new HashSet<>();
         members.add(uuid);
         members.add(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(members);
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(members);
         
         AdminTeamDisbandCommand itl = new AdminTeamDisbandCommand(ac);
         assertTrue(itl.execute(user, Arrays.asList(name)));
-        Mockito.verify(im, Mockito.never()).setLeaveTeam(notUUID);
-        Mockito.verify(im).setLeaveTeam(uuid);
+        Mockito.verify(im, Mockito.never()).setLeaveTeam(Mockito.any(), Mockito.eq(notUUID));
+        Mockito.verify(im).setLeaveTeam(Mockito.any(), Mockito.eq(uuid));
         Mockito.verify(user).sendMessage(Mockito.eq("general.success"));
     }
     

src/test/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamKickCommandTest.java

@@ -15,6 +15,7 @@ import java.util.HashSet;
 import java.util.UUID;
 
 import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.junit.Before;
@@ -32,6 +33,7 @@ import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.commands.admin.teams.AdminTeamKickCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -92,16 +94,24 @@ public class AdminTeamKickCommandTest {
         ac = mock(AdminCommand.class);
         when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
 
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
+
+
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(),Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -147,7 +157,7 @@ public class AdminTeamKickCommandTest {
         AdminTeamKickCommand itl = new AdminTeamKickCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(new HashSet<>());
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(new HashSet<>());
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.not-in-team"));
     }
@@ -157,13 +167,13 @@ public class AdminTeamKickCommandTest {
      */
     @Test
     public void testExecuteKickLeader() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         
-        when(im.getTeamLeader(notUUID)).thenReturn(notUUID);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(notUUID))).thenReturn(notUUID);
         
         AdminTeamKickCommand itl = new AdminTeamKickCommand(ac);
         assertFalse(itl.execute(user, Arrays.asList(name)));
@@ -176,17 +186,17 @@ public class AdminTeamKickCommandTest {
      */
     @Test
     public void testExecute() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
                 
-        when(im.getTeamLeader(notUUID)).thenReturn(uuid);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(notUUID))).thenReturn(uuid);
         
         AdminTeamKickCommand itl = new AdminTeamKickCommand(ac);
         assertTrue(itl.execute(user, Arrays.asList(name)));
-        Mockito.verify(im).removePlayer(notUUID);
+        Mockito.verify(im).removePlayer(Mockito.any(), Mockito.eq(notUUID));
         Mockito.verify(user).sendMessage(Mockito.eq("general.success"));
     }
 

src/test/java/us/tastybento/bskyblock/commands/admin/teams/AdminTeamMakeLeaderCommandTest.java

@@ -12,6 +12,7 @@ import java.util.Set;
 import java.util.UUID;
 
 import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.junit.Before;
@@ -28,6 +29,7 @@ import us.tastybento.bskyblock.Settings;
 import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.commands.AdminCommand;
 import us.tastybento.bskyblock.database.objects.Island;
+import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.CommandsManager;
 import us.tastybento.bskyblock.managers.IslandsManager;
 import us.tastybento.bskyblock.managers.LocalesManager;
@@ -88,17 +90,25 @@ public class AdminTeamMakeLeaderCommandTest {
         ac = mock(AdminCommand.class);
         when(ac.getSubCommandAliases()).thenReturn(new HashMap<>());
 
+        // Island World Manager
+        IslandWorld iwm = mock(IslandWorld.class);
+        World world = mock(World.class);
+        when(iwm.getIslandWorld()).thenReturn(world);
+        when(plugin.getIslandWorldManager()).thenReturn(iwm);
+
+
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(User.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(),Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(),Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
-        
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+       
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -143,7 +153,7 @@ public class AdminTeamMakeLeaderCommandTest {
         AdminTeamMakeLeaderCommand itl = new AdminTeamMakeLeaderCommand(ac);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(new HashSet<>());
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(new HashSet<>());
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.not-in-team"));
     }
@@ -153,13 +163,13 @@ public class AdminTeamMakeLeaderCommandTest {
      */
     @Test
     public void testExecuteMakeLeaderAlreadyLeader() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         
-        when(im.getTeamLeader(notUUID)).thenReturn(notUUID);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(notUUID))).thenReturn(notUUID);
         
         AdminTeamMakeLeaderCommand itl = new AdminTeamMakeLeaderCommand(ac);
         assertFalse(itl.execute(user, Arrays.asList(name)));
@@ -171,24 +181,24 @@ public class AdminTeamMakeLeaderCommandTest {
      */
     @Test
     public void testExecuteSuccess() {
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         Island is = mock(Island.class);
-        when(im.getIsland(Mockito.any())).thenReturn(is);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
         // Leader
-        when(im.getTeamLeader(notUUID)).thenReturn(uuid);
+        when(im.getTeamLeader(Mockito.any(), Mockito.eq(notUUID))).thenReturn(uuid);
         when(pm.getName(Mockito.eq(uuid))).thenReturn("leader");
         // Members
         Set<UUID> members = new HashSet<>();
         members.add(uuid);
         members.add(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(members);
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(members);
         
         AdminTeamMakeLeaderCommand itl = new AdminTeamMakeLeaderCommand(ac);
         assertTrue(itl.execute(user, Arrays.asList(name)));
         // Add other verifications
-        Mockito.verify(im).makeLeader(user, notUUID);
+        Mockito.verify(im).makeLeader(Mockito.any(), Mockito.eq(user), Mockito.eq(notUUID));
         Mockito.verify(user).sendMessage(Mockito.eq("general.success"));
     }
     

src/test/java/us/tastybento/bskyblock/commands/island/IslandBanCommandTest.java

@@ -95,13 +95,13 @@ public class IslandBanCommandTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -113,7 +113,7 @@ public class IslandBanCommandTest {
         island = mock(Island.class);
         when(island.getBanned()).thenReturn(new HashSet<>());
         when(island.isBanned(Mockito.any())).thenReturn(false);
-        when(im.getIsland(Mockito.any(UUID.class))).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(island);
 
     }
 
@@ -151,7 +151,7 @@ public class IslandBanCommandTest {
     @Test
     public void testNotOwner() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         assertFalse(ibc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("general.errors.not-leader");
     }
@@ -159,8 +159,8 @@ public class IslandBanCommandTest {
     @Test
     public void testUnknownUser() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(pm.getUUID(Mockito.anyString())).thenReturn(null);
         assertFalse(ibc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("general.errors.unknown-player");
@@ -169,8 +169,8 @@ public class IslandBanCommandTest {
     @Test
     public void testBanSelf() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(pm.getUUID(Mockito.anyString())).thenReturn(uuid);
         assertFalse(ibc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("commands.island.ban.cannot-ban-yourself");
@@ -179,14 +179,14 @@ public class IslandBanCommandTest {
     @Test
     public void testBanTeamMate() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID teamMate = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(teamMate);
         Set<UUID> members = new HashSet<>();
         members.add(uuid);
         members.add(teamMate);
-        when(im.getMembers(Mockito.any())).thenReturn(members);
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(members);
         assertFalse(ibc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("commands.island.ban.cannot-ban-member");
     }
@@ -194,8 +194,8 @@ public class IslandBanCommandTest {
     @Test
     public void testBanAlreadyBanned() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID bannedUser = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(bannedUser);
         when(island.isBanned(Mockito.eq(bannedUser))).thenReturn(true);
@@ -206,8 +206,8 @@ public class IslandBanCommandTest {
     @Test
     public void testBanOp() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID op = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(op);
         PowerMockito.mockStatic(User.class);
@@ -222,8 +222,8 @@ public class IslandBanCommandTest {
     @Test
     public void testBanOfflineUser() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID targetUuid = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(targetUuid);        
         PowerMockito.mockStatic(User.class);
@@ -244,8 +244,8 @@ public class IslandBanCommandTest {
     @Test
     public void testBanOnlineUser() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID op = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(op);
         PowerMockito.mockStatic(User.class);
@@ -265,8 +265,8 @@ public class IslandBanCommandTest {
     @Test
     public void testCancelledBan() {
         IslandBanCommand ibc = new IslandBanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID op = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(op);
         PowerMockito.mockStatic(User.class);

src/test/java/us/tastybento/bskyblock/commands/island/IslandBanlistCommandTest.java

@@ -91,13 +91,13 @@ public class IslandBanlistCommandTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -109,7 +109,7 @@ public class IslandBanlistCommandTest {
         island = mock(Island.class);
         when(island.getBanned()).thenReturn(new HashSet<>());
         when(island.isBanned(Mockito.any())).thenReturn(false);
-        when(im.getIsland(Mockito.any(UUID.class))).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(island);
 
     }
 
@@ -133,7 +133,7 @@ public class IslandBanlistCommandTest {
     @Test
     public void testBanlistNooneBanned() {
         IslandBanlistCommand iubc = new IslandBanlistCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         assertTrue(iubc.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage("commands.island.banlist.noone");
     }
@@ -141,7 +141,7 @@ public class IslandBanlistCommandTest {
     @Test
     public void testBanlistBanned() {
         IslandBanlistCommand iubc = new IslandBanlistCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Make a ban list
         String[] names = {"adam", "ben", "cara", "dave", "ed", "frank", "freddy", "george", "harry", "ian", "joe"};        
         Set<UUID> banned = new HashSet<>();

src/test/java/us/tastybento/bskyblock/commands/island/IslandResetCommandTest.java

@@ -86,13 +86,13 @@ public class IslandResetCommandTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -119,7 +119,7 @@ public class IslandResetCommandTest {
     public void testNotLeader() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         assertFalse(irc.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage("general.errors.not-leader");
     }
@@ -128,9 +128,9 @@ public class IslandResetCommandTest {
     public void testHasTeam() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         assertFalse(irc.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage("commands.island.reset.must-remove-members");
     }
@@ -139,11 +139,11 @@ public class IslandResetCommandTest {
     public void testNoResetsLeft() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now has no team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         
         // Block based on no resets left
         when(pm.getResetsLeft(Mockito.eq(uuid))).thenReturn(0);
@@ -156,11 +156,11 @@ public class IslandResetCommandTest {
     public void testConfirmBeforeReset() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now has no team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Give the user some resets
         when(pm.getResetsLeft(Mockito.eq(uuid))).thenReturn(1);
         
@@ -172,11 +172,11 @@ public class IslandResetCommandTest {
     public void testNoConfirmationRequired() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now has no team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Give the user some resets
         when(pm.getResetsLeft(Mockito.eq(uuid))).thenReturn(1);
         // Set so no confirmation required
@@ -184,7 +184,7 @@ public class IslandResetCommandTest {
         
         // Old island mock
         Island oldIsland = mock(Island.class);
-        when(im.getIsland(Mockito.eq(uuid))).thenReturn(oldIsland);
+        when(im.getIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(oldIsland);
         
         // Mock up NewIsland builder
         NewIsland.Builder builder = mock(NewIsland.Builder.class);
@@ -206,11 +206,11 @@ public class IslandResetCommandTest {
     public void testUnlimitedResets() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now has no team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Give the user some resets
         when(pm.getResetsLeft(Mockito.eq(uuid))).thenReturn(1);
         // Set so no confirmation required
@@ -218,7 +218,7 @@ public class IslandResetCommandTest {
         
         // Old island mock
         Island oldIsland = mock(Island.class);
-        when(im.getIsland(Mockito.eq(uuid))).thenReturn(oldIsland);
+        when(im.getIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(oldIsland);
         
         // Mock up NewIsland builder
         NewIsland.Builder builder = mock(NewIsland.Builder.class);
@@ -243,11 +243,11 @@ public class IslandResetCommandTest {
     public void testConfirmationRequired() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now has no team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Give the user some resets
         when(pm.getResetsLeft(Mockito.eq(uuid))).thenReturn(1);
         // Set so no confirmation required
@@ -255,7 +255,7 @@ public class IslandResetCommandTest {
         
         // Old island mock
         Island oldIsland = mock(Island.class);
-        when(im.getIsland(Mockito.eq(uuid))).thenReturn(oldIsland);
+        when(im.getIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(oldIsland);
         
         // Mock up NewIsland builder
         NewIsland.Builder builder = mock(NewIsland.Builder.class);
@@ -284,11 +284,11 @@ public class IslandResetCommandTest {
     public void testNewIslandError() throws IOException {
         IslandResetCommand irc = new IslandResetCommand(ic);
         // Now has island, but is not the leader
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now is owner, but still has team
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Now has no team
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Give the user some resets
         when(pm.getResetsLeft(Mockito.eq(uuid))).thenReturn(1);
         // Set so no confirmation required
@@ -296,7 +296,7 @@ public class IslandResetCommandTest {
         
         // Old island mock
         Island oldIsland = mock(Island.class);
-        when(im.getIsland(Mockito.eq(uuid))).thenReturn(oldIsland);
+        when(im.getIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(oldIsland);
         
         // Mock up NewIsland builder
         NewIsland.Builder builder = mock(NewIsland.Builder.class);

src/test/java/us/tastybento/bskyblock/commands/island/IslandUnbanCommandTest.java

@@ -91,13 +91,13 @@ public class IslandUnbanCommandTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -109,7 +109,7 @@ public class IslandUnbanCommandTest {
         island = mock(Island.class);
         when(island.getBanned()).thenReturn(new HashSet<>());
         when(island.isBanned(Mockito.any())).thenReturn(false);
-        when(im.getIsland(Mockito.any(UUID.class))).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(island);
 
     }
 
@@ -144,7 +144,7 @@ public class IslandUnbanCommandTest {
     @Test
     public void testNotOwner() {
         IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         assertFalse(iubc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("general.errors.not-leader");
     }
@@ -152,8 +152,8 @@ public class IslandUnbanCommandTest {
     @Test
     public void testUnknownUser() {
         IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(pm.getUUID(Mockito.anyString())).thenReturn(null);
         assertFalse(iubc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("general.errors.unknown-player");
@@ -162,8 +162,8 @@ public class IslandUnbanCommandTest {
     @Test
     public void testBanSelf() {
         IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(pm.getUUID(Mockito.anyString())).thenReturn(uuid);
         assertFalse(iubc.execute(user, Arrays.asList("bill")));
         Mockito.verify(user).sendMessage("commands.island.unban.cannot-unban-yourself");
@@ -172,8 +172,8 @@ public class IslandUnbanCommandTest {
     @Test
     public void testBanNotBanned() {
         IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID bannedUser = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(bannedUser);
         when(island.isBanned(Mockito.eq(bannedUser))).thenReturn(false);
@@ -184,8 +184,8 @@ public class IslandUnbanCommandTest {
     @Test
     public void testUnbanUser() {
         IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID targetUUID = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(targetUUID);        
         PowerMockito.mockStatic(User.class);
@@ -208,8 +208,8 @@ public class IslandUnbanCommandTest {
     @Test
     public void testCancelledUnban() {
         IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(true);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         UUID targetUUID = UUID.randomUUID();
         when(pm.getUUID(Mockito.anyString())).thenReturn(targetUUID);        
         PowerMockito.mockStatic(User.class);

src/test/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamInviteCommandTest.java

@@ -90,13 +90,13 @@ public class IslandTeamInviteCommandTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         
         // Player Manager
         pm = mock(PlayersManager.class);
@@ -119,7 +119,7 @@ public class IslandTeamInviteCommandTest {
      */
     @Test
     public void testExecuteNoIsland() {
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
         IslandTeamInviteCommand itl = new IslandTeamInviteCommand(ic);
         assertFalse(itl.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.no-island"));
@@ -130,7 +130,7 @@ public class IslandTeamInviteCommandTest {
      */
     @Test
     public void testExecuteNotTeamLeader() {
-        when(im.getTeamLeader(Mockito.any())).thenReturn(notUUID);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(notUUID);
         IslandTeamInviteCommand itl = new IslandTeamInviteCommand(ic);
         assertFalse(itl.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.not-leader"));
@@ -201,7 +201,7 @@ public class IslandTeamInviteCommandTest {
         IslandTeamInviteCommand itl = new IslandTeamInviteCommand(ic);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.inTeam(Mockito.any())).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("commands.island.team.invite.already-on-team"));
     }

src/test/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamKickCommandTest.java

@@ -93,14 +93,14 @@ public class IslandTeamKickCommandTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team 
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         
         when(plugin.getPlayers()).thenReturn(pm);
 
@@ -120,7 +120,7 @@ public class IslandTeamKickCommandTest {
      */
     @Test
     public void testExecuteNoTeam() {
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         IslandTeamKickCommand itl = new IslandTeamKickCommand(ic);
         assertFalse(itl.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.no-team"));
@@ -131,7 +131,7 @@ public class IslandTeamKickCommandTest {
      */
     @Test
     public void testExecuteNotTeamLeader() {
-        when(im.getTeamLeader(Mockito.any())).thenReturn(notUUID);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(notUUID);
         IslandTeamKickCommand itl = new IslandTeamKickCommand(ic);
         assertFalse(itl.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.not-leader"));
@@ -180,7 +180,7 @@ public class IslandTeamKickCommandTest {
         IslandTeamKickCommand itl = new IslandTeamKickCommand(ic);
         String[] name = {"tastybento"};
         when(pm.getUUID(Mockito.any())).thenReturn(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(new HashSet<>());
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(new HashSet<>());
         assertFalse(itl.execute(user, Arrays.asList(name)));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.not-in-team"));
     }
@@ -197,11 +197,11 @@ public class IslandTeamKickCommandTest {
         
         Set<UUID> members = new HashSet<>();
         members.add(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(members);
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(members);
         
         IslandTeamKickCommand itl = new IslandTeamKickCommand(ic);
         assertTrue(itl.execute(user, Arrays.asList(name)));
-        Mockito.verify(im).removePlayer(notUUID);
+        Mockito.verify(im).removePlayer(Mockito.any(), Mockito.eq(notUUID));
         Mockito.verify(user).sendMessage(Mockito.eq("general.success"));
     }
     
@@ -217,7 +217,7 @@ public class IslandTeamKickCommandTest {
         
         Set<UUID> members = new HashSet<>();
         members.add(notUUID);
-        when(im.getMembers(Mockito.any())).thenReturn(members);
+        when(im.getMembers(Mockito.any(), Mockito.any())).thenReturn(members);
         
         IslandTeamKickCommand itl = new IslandTeamKickCommand(ic);
         assertFalse(itl.execute(user, Arrays.asList(name)));

src/test/java/us/tastybento/bskyblock/commands/island/teams/IslandTeamLeaveCommandTest.java

@@ -83,13 +83,13 @@ public class IslandTeamLeaveCommandTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -104,7 +104,7 @@ public class IslandTeamLeaveCommandTest {
      */
     @Test
     public void testExecuteNoTeam() {
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(false);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         IslandTeamLeaveCommand itl = new IslandTeamLeaveCommand(ic);
         assertFalse(itl.execute(user, new ArrayList<>()));
         Mockito.verify(user).sendMessage(Mockito.eq("general.errors.no-team"));
@@ -126,14 +126,14 @@ public class IslandTeamLeaveCommandTest {
     @Test
     public void testExecuteNoConfirmation() {
         when(s.isLeaveConfirmation()).thenReturn(false);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Add a team leader - null
-        when(im.getTeamLeader(Mockito.any())).thenReturn(null);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(null);
 
         IslandTeamLeaveCommand itl = new IslandTeamLeaveCommand(ic);
         assertTrue(itl.execute(user, new ArrayList<>()));
-        Mockito.verify(im).removePlayer(uuid);
+        Mockito.verify(im).removePlayer(Mockito.any(), Mockito.eq(uuid));
         Mockito.verify(user).sendMessage(Mockito.eq("general.success"));
     }
     
@@ -145,10 +145,10 @@ public class IslandTeamLeaveCommandTest {
         when(s.isLeaveConfirmation()).thenReturn(true);
         // 3 second timeout
         when(s.getLeaveWait()).thenReturn(3L);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         // Add a team leader - null
-        when(im.getTeamLeader(Mockito.any())).thenReturn(null);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(null);
 
         IslandTeamLeaveCommand itl = new IslandTeamLeaveCommand(ic);
         assertFalse(itl.execute(user, new ArrayList<>()));

src/test/java/us/tastybento/bskyblock/database/objects/PlayersTest.java

@@ -11,6 +11,7 @@ import java.util.UUID;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.World;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -52,11 +53,14 @@ public class PlayersTest {
     public void testSetHomeLocationLocation() {
         Players p = new Players(plugin, UUID.randomUUID());
         Location l = mock(Location.class);
+        World w = mock(World.class);
+        when(w.getName()).thenReturn("world");
+        when(l.getWorld()).thenReturn(w);
         p.setHomeLocation(l, 5);
-        assertEquals(l, p.getHomeLocation(5));
-        assertNotEquals(l, p.getHomeLocation(0));
-        p.setHomeLocation(null);
-        assertTrue(p.getHomeLocations().isEmpty());
+        assertEquals(l, p.getHomeLocation(w, 5));
+        assertNotEquals(l, p.getHomeLocation(w, 0));
+        p.clearHomeLocations(w);
+        assertTrue(p.getHomeLocations(w).isEmpty());
     }
 
     @Test

src/test/java/us/tastybento/bskyblock/listeners/NetherPortalsTest.java

@@ -117,9 +117,9 @@ public class NetherPortalsTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         when(plugin.getPlayers()).thenReturn(pm);
@@ -307,17 +307,17 @@ public class NetherPortalsTest {
         // Player has no island
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(UUID.randomUUID());
-        when(im.hasIsland(Mockito.any())).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(false);
         // Right cause, end exists, right world
         PlayerPortalEvent e = new PlayerPortalEvent(player, from, null, null, TeleportCause.END_PORTAL);
         when(s.isEndGenerate()).thenReturn(true);
         np.onEndIslandPortal(e);
         assertFalse(e.isCancelled()); 
         // Give player an island
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
         np.onEndIslandPortal(e);
         assertTrue(e.isCancelled());
-        Mockito.verify(im).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im).homeTeleport(Mockito.any(), Mockito.eq(player));
     }
 
     /**
@@ -606,7 +606,7 @@ public class NetherPortalsTest {
         assertTrue(e.isCancelled());
         // If regular nether, then to = island location
         Mockito.verify(from, Mockito.never()).toVector();
-        Mockito.verify(im).getIslandLocation(Mockito.any());
+        Mockito.verify(im).getIslandLocation(Mockito.any(), Mockito.any());
     }
     
     /**
@@ -627,7 +627,7 @@ public class NetherPortalsTest {
         assertTrue(e.isCancelled());
         // If regular nether, then to = island location
         Mockito.verify(from).toVector();
-        Mockito.verify(im, Mockito.never()).getIslandLocation(Mockito.any());
+        Mockito.verify(im, Mockito.never()).getIslandLocation(Mockito.any(), Mockito.any());
     }
     
     /**

src/test/java/us/tastybento/bskyblock/listeners/ObsidianToLavaTest.java

@@ -119,7 +119,7 @@ public class ObsidianToLavaTest {
         // Put player in world
         when(iwm.inWorld(Mockito.any())).thenReturn(true);
         // Put player on island
-        when(im.userIsOnIsland(Mockito.any())).thenReturn(true);
+        when(im.userIsOnIsland(Mockito.any(), Mockito.any())).thenReturn(true);
         // Set as survival
         when(who.getGameMode()).thenReturn(GameMode.SURVIVAL);
         
@@ -181,7 +181,7 @@ public class ObsidianToLavaTest {
         when(who.getGameMode()).thenReturn(GameMode.SURVIVAL);
 
         // Test when player is not on island
-        when(im.userIsOnIsland(Mockito.any())).thenReturn(false);
+        when(im.userIsOnIsland(Mockito.any(), Mockito.any())).thenReturn(false);
         assertFalse(listener.onPlayerInteract(event));
         
 

src/test/java/us/tastybento/bskyblock/listeners/flags/LockAndBanListenerTest.java

@@ -100,13 +100,13 @@ public class LockAndBanListenerTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -137,7 +137,7 @@ public class LockAndBanListenerTest {
         // Island is not locked by default
         when(island.isAllowed(Mockito.any(), Mockito.any())).thenReturn(true);
 
-        when(im.getIsland(Mockito.any(UUID.class))).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(island);
         
         // Create the listener object
         listener = new LockAndBanListener();
@@ -208,7 +208,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player on the island
         when(player.getLocation()).thenReturn(inside);
         
@@ -220,7 +220,7 @@ public class LockAndBanListenerTest {
         // User should see a message
         Mockito.verify(notifier).notify(Mockito.any(), Mockito.anyString());
         // User should be teleported somewhere 
-        Mockito.verify(im).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im).homeTeleport(Mockito.any(), Mockito.eq(player));
         // Call teleport event
         PlayerTeleportEvent e = new PlayerTeleportEvent(player, inside, outside);
         // Pass to event listener
@@ -281,7 +281,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player just outside island
         when(player.getLocation()).thenReturn(outside);
         
@@ -295,7 +295,7 @@ public class LockAndBanListenerTest {
         // Player should see a message
         Mockito.verify(notifier).notify(Mockito.any(), Mockito.anyString());
         // User should NOT be teleported somewhere
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player));
     }
     
     @Test
@@ -304,7 +304,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player inside island
         when(player.getLocation()).thenReturn(inside);
         
@@ -332,7 +332,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         
         // Add player to the ban list
         when(island.isBanned(Mockito.eq(uuid))).thenReturn(true);
@@ -352,9 +352,9 @@ public class LockAndBanListenerTest {
         // Player should see a message and nothing should be sent to Player 2
         Mockito.verify(notifier).notify(Mockito.any(), Mockito.anyString());
         // User should be teleported somewhere
-        Mockito.verify(im).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im).homeTeleport(Mockito.any(), Mockito.eq(player));
         // Player 2 should not be teleported
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player2));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player2));
         // Call teleport event
         PlayerTeleportEvent ev = new PlayerTeleportEvent(player, inside, outside);
         // Pass to event listener
@@ -406,7 +406,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player on the island
         when(player.getLocation()).thenReturn(inside);
         
@@ -418,7 +418,7 @@ public class LockAndBanListenerTest {
         // User should see a message
         Mockito.verify(notifier).notify(Mockito.any(), Mockito.anyString());
         // User should be teleported somewhere 
-        Mockito.verify(im).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im).homeTeleport(Mockito.any(), Mockito.eq(player));
         // Call teleport event
         PlayerTeleportEvent e = new PlayerTeleportEvent(player, inside, outside);
         // Pass to event listener
@@ -433,7 +433,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player on the island
         when(player.getLocation()).thenReturn(inside);
         // Log them in
@@ -441,7 +441,7 @@ public class LockAndBanListenerTest {
         // User should not see a message
         Mockito.verify(notifier, Mockito.never()).notify(Mockito.any(), Mockito.anyString());
         // User should not be teleported somewhere 
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player));
     }
         
     @Test
@@ -450,7 +450,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player just outside island
         when(player.getLocation()).thenReturn(outside);
         
@@ -464,7 +464,7 @@ public class LockAndBanListenerTest {
         // Player should see a message
         Mockito.verify(notifier).notify(Mockito.any(), Mockito.anyString());
         // User should NOT be teleported somewhere
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player));
     }
     
     @Test
@@ -473,7 +473,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player just outside island
         when(player.getLocation()).thenReturn(outside);
         // Move player
@@ -484,7 +484,7 @@ public class LockAndBanListenerTest {
         // Player should not see a message
         Mockito.verify(notifier, Mockito.never()).notify(Mockito.any(), Mockito.anyString());
         // User should NOT be teleported somewhere
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player));
     }
     
     @Test
@@ -493,7 +493,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player inside island
         when(player.getLocation()).thenReturn(inside);
         
@@ -522,7 +522,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         // Place the player inside island
         when(player.getLocation()).thenReturn(inside);
         // Move player
@@ -532,7 +532,7 @@ public class LockAndBanListenerTest {
         // Player should not see a message
         Mockito.verify(notifier, Mockito.never()).notify(Mockito.any(), Mockito.anyString());
         // User should not be teleported somewhere
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player));
     }
  
     @Test
@@ -541,7 +541,7 @@ public class LockAndBanListenerTest {
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(uuid);
         // Give player an island
-        when(im.hasIsland(uuid)).thenReturn(true);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         Player player2 = mock(Player.class);
         UUID uuid2 = UUID.randomUUID();
         when(player2.getUniqueId()).thenReturn(uuid2);
@@ -567,9 +567,9 @@ public class LockAndBanListenerTest {
         // Player should see a message and nothing should be sent to Player 2
         Mockito.verify(notifier).notify(Mockito.any(), Mockito.anyString());
         // User should be teleported somewhere
-        Mockito.verify(im).homeTeleport(Mockito.eq(player));
+        Mockito.verify(im).homeTeleport(Mockito.any(), Mockito.eq(player));
         // Player 2 should not be teleported
-        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.eq(player2));
+        Mockito.verify(im, Mockito.never()).homeTeleport(Mockito.any(), Mockito.eq(player2));
         // Call teleport event
         PlayerTeleportEvent ev = new PlayerTeleportEvent(player, inside, outside);
         // Pass to event listener

src/test/java/us/tastybento/bskyblock/listeners/flags/UpDownClickTest.java

@@ -101,13 +101,13 @@ public class UpDownClickTest {
 
         // No island for player to begin with (set it later in the tests)
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.eq(uuid))).thenReturn(false);
-        when(im.isOwner(Mockito.eq(uuid))).thenReturn(false);
+        when(im.hasIsland(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
+        when(im.isOwner(Mockito.any(), Mockito.eq(uuid))).thenReturn(false);
         when(plugin.getIslands()).thenReturn(im);
 
         // Has team
         pm = mock(PlayersManager.class);
-        when(im.inTeam(Mockito.eq(uuid))).thenReturn(true);
+        when(im.inTeam(Mockito.any(), Mockito.eq(uuid))).thenReturn(true);
         when(plugin.getPlayers()).thenReturn(pm);
 
         // Server & Scheduler
@@ -140,7 +140,7 @@ public class UpDownClickTest {
         // Island owner is user by default
         when(island.getOwner()).thenReturn(uuid);
 
-        when(im.getIsland(Mockito.any(UUID.class))).thenReturn(island);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(island);
 
         // Common from to's
         outside = mock(Location.class);
@@ -235,7 +235,7 @@ public class UpDownClickTest {
     
     @Test
     public void testNullIsland() {
-        when(im.getIsland(Mockito.any(UUID.class))).thenReturn(null);
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(null);
         Mockito.verify(plugin, Mockito.never()).getRanksManager();  
     }
 

src/test/java/us/tastybento/bskyblock/listeners/protection/FlyingMobEventsTest.java

@@ -96,9 +96,9 @@ public class FlyingMobEventsTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
         when(plugin.getPlayers()).thenReturn(pm);

src/test/java/us/tastybento/bskyblock/managers/IslandsManagerTest.java

@@ -47,7 +47,6 @@ import us.tastybento.bskyblock.api.user.User;
 import us.tastybento.bskyblock.database.objects.Island;
 import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.island.IslandCache;
-import us.tastybento.bskyblock.util.DeleteIslandChunks;
 import us.tastybento.bskyblock.util.Util;
 
 @RunWith(PowerMockRunner.class)
@@ -119,7 +118,8 @@ public class IslandsManagerTest {
 
         // Standard location
         manager = new IslandsManager(plugin);
-        location = mock(Location.class);                
+        location = mock(Location.class); 
+        when(location.getWorld()).thenReturn(world);
         space1 = mock(Block.class);
         ground = mock(Block.class);
         space2 = mock(Block.class);
@@ -447,67 +447,6 @@ public class IslandsManagerTest {
         assertNull(island);
     }
 
-    /**
-     * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#deleteIsland(java.util.UUID, boolean)}.
-     */
-    @Test
-    public void testDeleteIslandUUIDBoolean() {
-        UUID owner = UUID.randomUUID();
-        IslandsManager im = new IslandsManager(plugin);
-        Island island = im.createIsland(location, owner);
-
-        im.deleteIsland(owner, false);
-
-        assertNull(island.getOwner());
-    }
-
-    /**
-     * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#deleteIsland(java.util.UUID, boolean)}.
-     * @throws Exception 
-     */
-    @Test
-    public void testDeleteIslandUUIDBooleanRemoveBlocks() throws Exception {
-        DeleteIslandChunks dic = mock(DeleteIslandChunks.class);
-        PowerMockito.whenNew(DeleteIslandChunks.class).withAnyArguments().thenReturn(dic);
-        UUID owner = UUID.randomUUID();
-        IslandsManager im = new IslandsManager(plugin);
-        Island island = im.createIsland(location, owner);
-        island = im.createIsland(location, owner);        
-        im.deleteIsland(owner, true);
-
-        assertNull(island);
-    }
-
-    /**
-     * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#deleteIsland(java.util.UUID, boolean)}.
-     */
-    @Test
-    public void testDeleteIslandUUIDBooleanNoIsland() {
-        UUID owner = UUID.randomUUID();
-        IslandsManager im = new IslandsManager(plugin);
-        // Should error
-        im.deleteIsland(owner, false);
-
-        Mockito.verify(plugin).logError(Mockito.anyString());
-    }
-
-    /**
-     * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#getBanList(java.util.UUID)}.
-     */
-    @Test
-    public void testGetBanList() {
-        UUID owner = UUID.randomUUID();
-        IslandsManager im = new IslandsManager(plugin);
-        Island island = im.createIsland(location, owner);
-        Set<UUID> bl = im.getBanList(owner);
-        assertNotNull(bl);
-        assertTrue(bl.isEmpty());
-        UUID targetUUID = UUID.randomUUID();
-        island.addToBanList(targetUUID);
-        bl = im.getBanList(owner);
-        assertTrue(bl.contains(targetUUID));
-    }
-
     /**
      * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#getCount()}.
      */
@@ -527,24 +466,8 @@ public class IslandsManagerTest {
         UUID owner = UUID.randomUUID();
         IslandsManager im = new IslandsManager(plugin);
         Island island = im.createIsland(location, owner);
-        assertEquals(island, im.getIsland(owner));
-        assertNull(im.getIsland(UUID.randomUUID()));
-    }
-
-    /**
-     * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#getIslandAt(int, int)}.
-     * @throws Exception 
-     */
-    @Test
-    public void testGetIslandAtIntInt() throws Exception {
-        IslandCache ic = mock(IslandCache.class);
-        Island is = mock(Island.class);
-        when(ic.getIslandAt(Mockito.anyInt(), Mockito.anyInt())).thenReturn(is);
-        PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);
-        IslandsManager im = new IslandsManager(plugin);
-        assertEquals(is, im.getIslandAt(1, 1));
-        when(ic.getIslandAt(Mockito.anyInt(), Mockito.anyInt())).thenReturn(null);
-        assertNull(im.getIslandAt(100000, -100000));
+        assertEquals(island, im.getIsland(world, owner));
+        assertNull(im.getIsland(world, UUID.randomUUID()));
     }
 
     /**
@@ -556,7 +479,7 @@ public class IslandsManagerTest {
         // Mock island cache
         IslandCache ic = mock(IslandCache.class);
         Island is = mock(Island.class);
-        when(ic.getIslandAt(Mockito.anyInt(), Mockito.anyInt())).thenReturn(is);
+        when(ic.getIslandAt(Mockito.any(Location.class))).thenReturn(is);
         PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);
 
         PowerMockito.mockStatic(Util.class);
@@ -568,7 +491,7 @@ public class IslandsManagerTest {
         assertEquals(oi, im.getIslandAt(location));
 
         // in world, wrong island
-        when(ic.getIslandAt(Mockito.anyInt(), Mockito.anyInt())).thenReturn(null);
+        when(ic.getIslandAt(Mockito.any(Location.class))).thenReturn(null);
         assertEquals(Optional.empty(), im.getIslandAt(new Location(world, 100000, 120, -100000)));
 
         // not in world
@@ -584,26 +507,10 @@ public class IslandsManagerTest {
      */
     @Test
     public void testGetIslandLocation() {
-        UUID owner = UUID.randomUUID();
         IslandsManager im = new IslandsManager(plugin);
-        im.createIsland(location, owner);
-        assertEquals(location, im.getIslandLocation(owner));
-        assertNull(im.getIslandLocation(UUID.randomUUID()));
-    }
-
-    /**
-     * Test method for {@link us.tastybento.bskyblock.managers.IslandsManager#getIslandName(java.util.UUID)}.
-     * @throws Exception 
-     */
-    @Test
-    public void testGetIslandName() throws Exception {        
-        // Mock island cache
-        IslandCache ic = mock(IslandCache.class);
-        when(ic.getIslandName(Mockito.any())).thenReturn("name");
-        PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);      
-        IslandsManager im = new IslandsManager(plugin);
-        assertEquals("name", im.getIslandName(user.getUniqueId()));
-
+        im.createIsland(location, uuid);
+        assertEquals(location, im.getIslandLocation(world, uuid));
+        assertNull(im.getIslandLocation(world, UUID.randomUUID()));
     }
 
     /**
@@ -612,9 +519,9 @@ public class IslandsManagerTest {
     @Test
     public void testGetLast() {
         IslandsManager im = new IslandsManager(plugin);
-        assertNull(im.getLast());
         im.setLast(location);
-        assertEquals(location, im.getLast());
+        assertEquals(location, im.getLast(world));
+        assertNull(im.getLast(null));
     }
 
     /**
@@ -629,10 +536,10 @@ public class IslandsManagerTest {
         members.add(UUID.randomUUID());
         members.add(UUID.randomUUID());
         members.add(UUID.randomUUID());
-        when(ic.getMembers(Mockito.any())).thenReturn(members);
+        when(ic.getMembers(Mockito.any(), Mockito.any())).thenReturn(members);
         PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);      
         IslandsManager im = new IslandsManager(plugin);
-        assertEquals(members, im.getMembers(UUID.randomUUID()));
+        assertEquals(members, im.getMembers(world, UUID.randomUUID()));
     }
 
     /**
@@ -645,7 +552,7 @@ public class IslandsManagerTest {
         IslandCache ic = mock(IslandCache.class);
         Island is = mock(Island.class);
 
-        when(ic.getIslandAt(Mockito.anyInt(), Mockito.anyInt())).thenReturn(is);
+        when(ic.getIslandAt(Mockito.any(Location.class))).thenReturn(is);
 
         PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);
 
@@ -679,9 +586,9 @@ public class IslandsManagerTest {
     @Test
     public void testGetSafeHomeLocation() {
         IslandsManager im = new IslandsManager(plugin);
-        when(pm.getHomeLocation(Mockito.any(), Mockito.eq(0))).thenReturn(null);
-        when(pm.getHomeLocation(Mockito.any(), Mockito.eq(1))).thenReturn(location);
-        assertEquals(location, im.getSafeHomeLocation(UUID.randomUUID(), 0));
+        when(pm.getHomeLocation(Mockito.any(), Mockito.any(User.class), Mockito.eq(0))).thenReturn(null);
+        when(pm.getHomeLocation(Mockito.any(), Mockito.any(User.class), Mockito.eq(1))).thenReturn(location);
+        assertEquals(location, im.getSafeHomeLocation(world, user, 0));
         // Change location so that it is not safe
         // TODO
     }
@@ -692,11 +599,15 @@ public class IslandsManagerTest {
     @Test
     public void testGetSpawnPoint() {
         IslandsManager im = new IslandsManager(plugin);
-        assertNull(im.getSpawnPoint());
+        assertNull(im.getSpawnPoint(world));
+        // Create a spawn island for this world
         Island island = mock(Island.class);
+        when(island.getWorld()).thenReturn(world);
+        // Make a spawn position on the island
         when(island.getSpawnPoint()).thenReturn(location);
+        // Set the spawn island
         im.setSpawn(island);
-        assertEquals(location,im.getSpawnPoint());
+        assertEquals(location,im.getSpawnPoint(world));
     }
 
     /**
@@ -705,10 +616,10 @@ public class IslandsManagerTest {
     @Test
     public void testHomeTeleportPlayerInt() {
         IslandsManager im = new IslandsManager(plugin);
-        when(pm.getHomeLocation(Mockito.any(), Mockito.eq(0))).thenReturn(null);
-        when(pm.getHomeLocation(Mockito.any(), Mockito.eq(1))).thenReturn(location);
+        when(pm.getHomeLocation(Mockito.any(), Mockito.any(User.class), Mockito.eq(0))).thenReturn(null);
+        when(pm.getHomeLocation(Mockito.any(), Mockito.any(User.class), Mockito.eq(1))).thenReturn(location);
         when(player.getGameMode()).thenReturn(GameMode.SPECTATOR);
-        im.homeTeleport(player, 0);
+        im.homeTeleport(world, player, 0);
         Mockito.verify(player).teleport(location);
         Mockito.verify(player).setGameMode(GameMode.SURVIVAL);
 
@@ -722,6 +633,7 @@ public class IslandsManagerTest {
         IslandsManager im = new IslandsManager(plugin);
         assertFalse(im.isAtSpawn(location));
         Island island = mock(Island.class);
+        when(island.getWorld()).thenReturn(world);
         when(island.onIsland(Mockito.any())).thenReturn(true);
         im.setSpawn(island);
         assertTrue(im.isAtSpawn(location));
@@ -816,21 +728,21 @@ public class IslandsManagerTest {
         PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);
 
         IslandsManager im = new IslandsManager(plugin);
-        assertFalse(im.isOwner(null));
+        assertFalse(im.isOwner(world, null));
 
-        when(ic.hasIsland(Mockito.any())).thenReturn(false);
-        assertFalse(im.isOwner(UUID.randomUUID()));
+        when(ic.hasIsland(Mockito.any(), Mockito.any())).thenReturn(false);
+        assertFalse(im.isOwner(world, UUID.randomUUID()));
 
-        when(ic.hasIsland(Mockito.any())).thenReturn(true);
-        when(ic.get(Mockito.any(UUID.class))).thenReturn(is);
+        when(ic.hasIsland(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(ic.get(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
         UUID owner = UUID.randomUUID();
         when(is.getOwner()).thenReturn(owner);
         UUID notOwner = UUID.randomUUID();
         while (owner.equals(notOwner)) {
             notOwner = UUID.randomUUID();
         }
-        assertFalse(im.isOwner(notOwner));
-        assertTrue(im.isOwner(owner));
+        assertFalse(im.isOwner(world, notOwner));
+        assertTrue(im.isOwner(world, owner));
     }
 
     /**
@@ -853,7 +765,7 @@ public class IslandsManagerTest {
         IslandCache ic = mock(IslandCache.class);
         Island is = mock(Island.class);
 
-        when(ic.getIslandAt(Mockito.anyInt(),Mockito.anyInt())).thenReturn(is);
+        when(ic.getIslandAt(Mockito.any(Location.class))).thenReturn(is);
 
         PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);
 
@@ -895,18 +807,18 @@ public class IslandsManagerTest {
         IslandCache ic = mock(IslandCache.class);
         Island is = mock(Island.class);
 
-        when(ic.get(Mockito.any(UUID.class))).thenReturn(is);
+        when(ic.get(Mockito.any(), Mockito.any(UUID.class))).thenReturn(is);
 
         PowerMockito.whenNew(IslandCache.class).withAnyArguments().thenReturn(ic);
 
         IslandsManager im = new IslandsManager(plugin);
-        assertFalse(im.userIsOnIsland(null));
+        assertFalse(im.userIsOnIsland(world, null));
         
         when(is.onIsland(Mockito.any())).thenReturn(false);
-        assertFalse(im.userIsOnIsland(user));
+        assertFalse(im.userIsOnIsland(world, user));
         
         when(is.onIsland(Mockito.any())).thenReturn(true);
-        assertTrue(im.userIsOnIsland(user));       
+        assertTrue(im.userIsOnIsland(world, user));       
     }
 
     /**
@@ -924,7 +836,7 @@ public class IslandsManagerTest {
     @Test
     public void testRemovePlayer() {
         IslandsManager im = new IslandsManager(plugin);
-        im.removePlayer(uuid);
+        im.removePlayer(world, uuid);
     }
 
     /**

src/test/java/us/tastybento/bskyblock/managers/PlayersManagerTest.java

@@ -76,8 +76,11 @@ public class PlayersManagerTest {
         // island world mgr
         iwm = mock(IslandWorld.class);
         world = mock(World.class);
+        when(world.getName()).thenReturn("world");
         nether = mock(World.class);
+        when(nether.getName()).thenReturn("world_nether");
         end = mock(World.class);
+        when(end.getName()).thenReturn("world_the_end");
         when(iwm.getEndWorld()).thenReturn(end);
         when(iwm.getIslandWorld()).thenReturn(world);
         when(iwm.getNetherWorld()).thenReturn(nether);
@@ -110,9 +113,9 @@ public class PlayersManagerTest {
 
         // Player has island to begin with 
         im = mock(IslandsManager.class);
-        when(im.hasIsland(Mockito.any())).thenReturn(true);
-        when(im.isOwner(Mockito.any())).thenReturn(true);
-        when(im.getTeamLeader(Mockito.any())).thenReturn(uuid);
+        when(im.hasIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(true);
+        when(im.isOwner(Mockito.any(), Mockito.any())).thenReturn(true);
+        when(im.getTeamLeader(Mockito.any(), Mockito.any())).thenReturn(uuid);
         when(plugin.getIslands()).thenReturn(im);
 
 
@@ -270,10 +273,10 @@ public class PlayersManagerTest {
     }
 
     /**
-     * Test method for {@link us.tastybento.bskyblock.managers.PlayersManager#setHomeLocation(java.util.UUID, org.bukkit.Location, int)}.
+     * Test method for {@link us.tastybento.bskyblock.managers.PlayersManager#setHomeLocation(User, org.bukkit.Location, int)}.
      */
     @Test
-    public void testSetAndGetHomeLocationUUIDLocationInt() {
+    public void testSetAndGetHomeLocationUserLocationInt() {
         PlayersManager pm = new PlayersManager(plugin);
         Server server = mock(Server.class);
         when(Bukkit.getServer()).thenReturn(server);
@@ -282,15 +285,19 @@ public class PlayersManagerTest {
         when(server.getOfflinePlayer(Mockito.any(UUID.class))).thenReturn(olp);
 
         Location l = mock(Location.class);
+        when(l.getWorld()).thenReturn(world);
         Location l2 = mock(Location.class);
+        when(l2.getWorld()).thenReturn(nether);
         Location l3 = mock(Location.class);
+        when(l3.getWorld()).thenReturn(end);
+
         pm.setHomeLocation(uuid, l, 1);
         pm.setHomeLocation(uuid, l2, 0);
         pm.setHomeLocation(uuid, l3, 10);
-        assertEquals(l, pm.getHomeLocation(uuid));
-        assertEquals(l2, pm.getHomeLocation(uuid, 0));
-        assertEquals(l3, pm.getHomeLocation(uuid, 10));
-        assertNotEquals(l, pm.getHomeLocation(uuid, 20));
+        assertEquals(l, pm.getHomeLocation(world, uuid));
+        assertEquals(l2, pm.getHomeLocation(world, uuid, 0));
+        assertEquals(l3, pm.getHomeLocation(world, uuid, 10));
+        assertNotEquals(l, pm.getHomeLocation(world, uuid, 20));
     }
 
     /**
@@ -306,14 +313,17 @@ public class PlayersManagerTest {
         when(server.getOfflinePlayer(Mockito.any(UUID.class))).thenReturn(olp);
 
         Location l = mock(Location.class);
+        when(l.getWorld()).thenReturn(world);
         Location l2 = mock(Location.class);
+        when(l2.getWorld()).thenReturn(nether);
         Location l3 = mock(Location.class);
+        when(l3.getWorld()).thenReturn(end);
         pm.setHomeLocation(uuid, l, 1);
         pm.setHomeLocation(uuid, l2, 0);
         pm.setHomeLocation(uuid, l3, 10);
-        assertFalse(pm.getHomeLocations(uuid).isEmpty());
-        pm.clearHomeLocations(uuid);
-        assertTrue(pm.getHomeLocations(uuid).isEmpty());
+        assertFalse(pm.getHomeLocations(world, uuid).isEmpty());
+        pm.clearHomeLocations(world, uuid);
+        assertTrue(pm.getHomeLocations(world, uuid).isEmpty());
     }
 
     /**

src/test/java/us/tastybento/bskyblock/managers/island/IslandCacheTest.java

@@ -11,7 +11,6 @@ import static org.mockito.Mockito.when;
 
 import java.util.UUID;
 
-import org.bukkit.ChatColor;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.junit.Before;
@@ -27,7 +26,6 @@ import us.tastybento.bskyblock.BSkyBlock;
 import us.tastybento.bskyblock.database.objects.Island;
 import us.tastybento.bskyblock.generators.IslandWorld;
 import us.tastybento.bskyblock.managers.IslandsManager;
-import us.tastybento.bskyblock.managers.PlayersManager;
 import us.tastybento.bskyblock.util.Util;
 
 @RunWith(PowerMockRunner.class)
@@ -61,6 +59,7 @@ public class IslandCacheTest {
 
 
         island = mock(Island.class);
+        when(island.getWorld()).thenReturn(world);
         location = mock(Location.class);
         when(location.getWorld()).thenReturn(world);
         when(location.getBlockX()).thenReturn(0);
@@ -80,52 +79,52 @@ public class IslandCacheTest {
 
     @Test
     public void testIslandCache() {
-        assertNotNull(new IslandCache(plugin));
+        assertNotNull(new IslandCache());
     }
 
     @Test
     public void testAddIsland() {
-        IslandCache ic = new IslandCache(plugin);
+        IslandCache ic = new IslandCache();
         assertTrue(ic.addIsland(island));
         // Check if they are added
-        assertEquals(island, ic.get(owner)); 
+        assertEquals(island, ic.get(world, owner)); 
         assertEquals(island, ic.get(location));
     }
 
     @Test
     public void testAddPlayer() {
-        IslandCache ic = new IslandCache(plugin);
+        IslandCache ic = new IslandCache();
         UUID playerUUID = UUID.randomUUID();
         ic.addPlayer(playerUUID, island);
         // Check if they are added
-        assertEquals(island, ic.get(playerUUID));
-        assertNotSame(island, ic.get(UUID.randomUUID()));
+        assertEquals(island, ic.get(world, playerUUID));
+        assertNotSame(island, ic.get(world, UUID.randomUUID()));
 
     }
 
     @Test
     public void testClear() {
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
         // Check if they are added
-        assertEquals(island, ic.get(owner)); 
+        assertEquals(island, ic.get(world, owner)); 
         assertEquals(island, ic.get(location));
         ic.clear();
-        assertNull(ic.get(owner)); 
+        assertNull(ic.get(world, owner)); 
         assertNull(ic.get(location));
     }
 
     @Test
     public void testDeleteIslandFromCache() {
 
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
         // Check if they are added
-        assertEquals(island, ic.get(owner)); 
+        assertEquals(island, ic.get(world, owner)); 
         assertEquals(island, ic.get(location));
         boolean result = ic.deleteIslandFromCache(island);
         assertTrue(result);
-        assertNull(ic.get(owner)); 
+        assertNull(ic.get(world, owner)); 
         assertNull(ic.get(location));
 
         // Test removing an island that is not in the cache
@@ -152,7 +151,7 @@ public class IslandCacheTest {
 
     @Test
     public void testGetLocation() {
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
         // Check if they are added
         assertEquals(island, ic.get(location));
@@ -161,20 +160,10 @@ public class IslandCacheTest {
 
     @Test
     public void testGetUUID() {
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
         // Check if they are added
-        assertEquals(island, ic.get(owner)); 
-    }
-
-    @Test
-    public void testGetIslandAtIntInt() {
-        IslandCache ic = new IslandCache(plugin);        
-        ic.addIsland(island);
-        when(island.inIslandSpace(Mockito.any(Integer.class), Mockito.any(Integer.class))).thenReturn(true);
-        // Check if they are added
-        assertEquals(island, ic.getIslandAt(0,0));
-        assertNull(ic.getIslandAt(-2000,-2000));
+        assertEquals(island, ic.get(world, owner)); 
     }
 
     @Test
@@ -184,7 +173,7 @@ public class IslandCacheTest {
         // Set plugin
         Util.setPlugin(plugin);
         // New cache
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
         // Check islands is in world
         assertTrue(Util.inWorld(island.getCenter()));
@@ -204,41 +193,6 @@ public class IslandCacheTest {
         assertNull(ic.getIslandAt(location2));
     }
 
-    @Test
-    public void testGetIslandName() {
-        PlayersManager pm = mock(PlayersManager.class);
-        when(plugin.getPlayers()).thenReturn(pm);
-
-        // New cache
-        IslandCache ic = new IslandCache(plugin);        
-        ic.addIsland(island);
-        // Test with empty name
-        when(island.getName()).thenReturn("");
-        // Random player
-        when(pm.getName(Mockito.any())).thenReturn("tastybento");
-        assertEquals("tastybento" + ChatColor.RESET, ic.getIslandName(UUID.randomUUID()));
-        // Island owner
-        when(pm.getName(owner)).thenReturn("ownersname");
-        assertEquals("ownersname" + ChatColor.RESET, ic.getIslandName(island.getOwner()));
-
-        // Test with null name
-        when(island.getName()).thenReturn(null);
-        // Random player
-        when(pm.getName(Mockito.any())).thenReturn("tastybento");
-        assertEquals("tastybento" + ChatColor.RESET, ic.getIslandName(UUID.randomUUID()));
-        // Island owner
-        when(pm.getName(owner)).thenReturn("ownersname");
-        assertEquals("ownersname" + ChatColor.RESET, ic.getIslandName(island.getOwner()));
-
-        // Test with island name set
-        when(island.getName()).thenReturn("islandnameset");
-        // Random player
-        when(pm.getName(Mockito.any())).thenReturn("tastybento");
-        assertEquals("tastybento" + ChatColor.RESET, ic.getIslandName(UUID.randomUUID()));
-        // Island owner
-        when(pm.getName(owner)).thenReturn("ownersname");
-        assertEquals("islandnameset" + ChatColor.RESET, ic.getIslandName(island.getOwner()));
-    }
     /*
     @Test
     public void testGetIslands() {
@@ -246,26 +200,26 @@ public class IslandCacheTest {
     }
      */
     @Test
-    public void testGetMembers() {
+    public void testgetMembers() {
         // New cache
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
 
-        assertTrue(ic.getMembers(null).isEmpty());
-        assertTrue(ic.getMembers(UUID.randomUUID()).isEmpty());
-        assertFalse(ic.getMembers(island.getOwner()).isEmpty());
-        assertEquals(3, ic.getMembers(island.getOwner()).size());
+        assertTrue(ic.getMembers(world, null).isEmpty());
+        assertTrue(ic.getMembers(world, UUID.randomUUID()).isEmpty());
+        assertFalse(ic.getMembers(world, island.getOwner()).isEmpty());
+        assertEquals(3, ic.getMembers(world, island.getOwner()).size());
 
     }
     @Test
     public void testGetTeamLeader() {
         // New cache
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
 
-        assertEquals(owner, ic.getTeamLeader(owner));
-        assertNull(ic.getTeamLeader(null));
-        assertNull(ic.getTeamLeader(UUID.randomUUID()));
+        assertEquals(owner, ic.getTeamLeader(world, owner));
+        assertNull(ic.getTeamLeader(world, null));
+        assertNull(ic.getTeamLeader(world, UUID.randomUUID()));
 
 
     }
@@ -273,43 +227,33 @@ public class IslandCacheTest {
     @Test
     public void testHasIsland() {
         // New cache
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
 
-        assertTrue(ic.hasIsland(owner));
-        assertFalse(ic.hasIsland(UUID.randomUUID()));
-        assertFalse(ic.hasIsland(null));
+        assertTrue(ic.hasIsland(world, owner));
+        assertFalse(ic.hasIsland(world, UUID.randomUUID()));
+        assertFalse(ic.hasIsland(world, null));
     }
 
     @Test
     public void testRemovePlayer() {
         // New cache
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
 
-        assertTrue(ic.hasIsland(owner));
-        ic.removePlayer(null);
-        assertTrue(ic.hasIsland(owner));
-        ic.removePlayer(UUID.randomUUID());
-        assertTrue(ic.hasIsland(owner));
-        ic.removePlayer(owner);
-        assertFalse(ic.hasIsland(owner));
-    }
-
-    @Test
-    public void testSetIslandName() {
-        // New cache
-        IslandCache ic = new IslandCache(plugin);        
-        ic.addIsland(island);
-        assertTrue(ic.setIslandName(owner, "test tes test"));
-        assertFalse(ic.setIslandName(UUID.randomUUID(), "sadfas"));
-        assertFalse(ic.setIslandName(null, "sadfas"));
+        assertTrue(ic.hasIsland(world, owner));
+        ic.removePlayer(world, null);
+        assertTrue(ic.hasIsland(world, owner));
+        ic.removePlayer(world, UUID.randomUUID());
+        assertTrue(ic.hasIsland(world, owner));
+        ic.removePlayer(world, owner);
+        assertFalse(ic.hasIsland(world, owner));
     }
 
     @Test
     public void testSize() {
         // New cache
-        IslandCache ic = new IslandCache(plugin);        
+        IslandCache ic = new IslandCache();        
         ic.addIsland(island);
         assertEquals(1, ic.size());
     }