Example usage for com.google.common.collect HashMultiset create

List of usage examples for com.google.common.collect HashMultiset create

Introduction

In this page you can find the example usage for com.google.common.collect HashMultiset create.

Prototype

public static <E> HashMultiset<E> create() 

Source Link

Document

Creates a new, empty HashMultiset using the default initial capacity.

Usage

From source file:org.eclipse.viatra.query.runtime.base.core.NavigationHelperContentAdapter.java

/**
 * This method uses either the original {@link EStructuralFeature} instance or the String id.
 *//*from   w w w.  ja v a 2  s  .co  m*/
private void addToReversedFeatureMap(final Object feature, final EObject holder) {
    Multiset<EObject> setVal = featureToHolderMap.get(feature);

    if (setVal == null) {
        setVal = HashMultiset.create();
        featureToHolderMap.put(feature, setVal);
    }
    setVal.add(holder);
}

From source file:com.wasteofplastic.acidisland.commands.AdminCmd.java

public boolean onCommand(final CommandSender sender, final Command command, final String label,
        final String[] split) {
    // Console commands
    Player player;//from   www .j a  v a 2s.  c  o m
    if (sender instanceof Player) {
        player = (Player) sender;
        if (split.length > 0) {
            // Admin-only commands : reload, register, delete and purge
            if (split[0].equalsIgnoreCase("reload") || split[0].equalsIgnoreCase("register")
                    || split[0].equalsIgnoreCase("delete") || split[0].equalsIgnoreCase("purge")
                    || split[0].equalsIgnoreCase("confirm") || split[0].equalsIgnoreCase("setspawn")
                    || split[0].equalsIgnoreCase("deleteisland") || split[0].equalsIgnoreCase("setrange")
                    || split[0].equalsIgnoreCase("unregister")) {
                if (!checkAdminPerms(player, split)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
            } else {
                // Mod commands
                if (!checkModPerms(player, split)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
            }
        }
    }
    // Check for zero parameters e.g., /asadmin
    switch (split.length) {
    case 0:
        help(sender, label);
        return true;
    case 1:
        if (Settings.teamChat && split[0].equalsIgnoreCase("spy")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "mod.spy") || player.isOp()) {
                if (plugin.getChatListener().toggleSpy(player.getUniqueId())) {
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale().teamChatStatusOn);
                } else {
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale().teamChatStatusOff);
                }
                return true;
            }
        } else if (split[0].equalsIgnoreCase("lock")) {
            // Just /asadmin lock
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            Island island = plugin.getGrid().getIslandAt(player.getLocation());
            // Check if island exists
            if (island == null) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNotOnIsland);
                return true;
            } else {
                Player owner = plugin.getServer().getPlayer(island.getOwner());
                if (island.isLocked()) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().lockUnlocking);
                    island.setLocked(false);
                    if (owner != null) {
                        owner.sendMessage(plugin.myLocale(owner.getUniqueId()).adminLockadminUnlockedIsland);
                    } else {
                        plugin.getMessages().setMessage(island.getOwner(),
                                plugin.myLocale(island.getOwner()).adminLockadminUnlockedIsland);
                    }
                } else {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().lockLocking);
                    island.setLocked(true);
                    if (owner != null) {
                        owner.sendMessage(plugin.myLocale(owner.getUniqueId()).adminLockadminLockedIsland);
                    } else {
                        plugin.getMessages().setMessage(island.getOwner(),
                                plugin.myLocale(island.getOwner()).adminLockadminLockedIsland);
                    }
                }
                return true;
            }
        } else
        // Find farms
        if (split[0].equalsIgnoreCase("topbreeders")) {
            // Go through each island and find how many farms there are
            sender.sendMessage(plugin.myLocale().adminTopBreedersFinding);
            //TreeMap<Integer, List<UUID>> topEntityIslands = new TreeMap<Integer, List<UUID>>();
            // Generate the stats
            sender.sendMessage(plugin.myLocale().adminTopBreedersChecking.replace("[number]",
                    String.valueOf(plugin.getGrid().getOwnershipMap().size())));
            // Try just finding every entity
            final List<Entity> allEntities = ASkyBlock.getIslandWorld().getEntities();
            final World islandWorld = ASkyBlock.getIslandWorld();
            final World netherWorld = ASkyBlock.getNetherWorld();
            plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable() {

                @Override
                public void run() {
                    Map<UUID, Multiset<EntityType>> result = new HashMap<UUID, Multiset<EntityType>>();
                    // Find out where the entities are
                    for (Entity entity : allEntities) {
                        //System.out.println("DEBUG " + entity.getType().toString());
                        if (entity.getLocation().getWorld().equals(islandWorld)
                                || entity.getLocation().getWorld().equals(netherWorld)) {
                            //System.out.println("DEBUG in world");
                            if (entity instanceof Creature && !(entity instanceof Player)) {
                                //System.out.println("DEBUG creature");
                                // Find out where it is
                                Island island = plugin.getGrid().getIslandAt(entity.getLocation());
                                if (island != null && !island.isSpawn()) {
                                    //System.out.println("DEBUG on island");
                                    // Add to result
                                    UUID owner = island.getOwner();
                                    Multiset<EntityType> count = result.get(owner);
                                    if (count == null) {
                                        // New entry for owner
                                        //System.out.println("DEBUG new entry for owner");
                                        count = HashMultiset.create();
                                    }
                                    count.add(entity.getType());
                                    result.put(owner, count);
                                }
                            }
                        }
                    }
                    // Sort by the number of entities on each island
                    TreeMap<Integer, List<UUID>> topEntityIslands = new TreeMap<Integer, List<UUID>>();
                    for (Entry<UUID, Multiset<EntityType>> entry : result.entrySet()) {
                        int numOfEntities = entry.getValue().size();
                        List<UUID> players = topEntityIslands.get(numOfEntities);
                        if (players == null) {
                            players = new ArrayList<UUID>();
                        }
                        players.add(entry.getKey());
                        topEntityIslands.put(numOfEntities, players);
                    }
                    final TreeMap<Integer, List<UUID>> topBreeders = topEntityIslands;
                    final Map<UUID, Multiset<EntityType>> finalResult = result;
                    // Now display results in sync thread
                    plugin.getServer().getScheduler().runTask(plugin, new Runnable() {

                        @Override
                        public void run() {
                            if (topBreeders.isEmpty()) {
                                sender.sendMessage(plugin.myLocale().adminTopBreedersNothing);
                                return;
                            }
                            int rank = 1;
                            // Display, largest first
                            for (int numOfEntities : topBreeders.descendingKeySet()) {
                                // Only bother if there's more that 5 animals
                                if (numOfEntities > 5) {
                                    // There can be multiple owners in the same position
                                    List<UUID> owners = topBreeders.get(numOfEntities);
                                    // Go through the owners one by one
                                    for (UUID owner : owners) {
                                        sender.sendMessage("#" + rank + " " + plugin.getPlayers().getName(owner)
                                                + " = " + numOfEntities);
                                        String content = "";
                                        Multiset<EntityType> entityCount = finalResult.get(owner);
                                        for (EntityType entity : entityCount.elementSet()) {
                                            int num = entityCount.count(entity);
                                            String color = ChatColor.GREEN.toString();
                                            if (num > 10 && num <= 20) {
                                                color = ChatColor.YELLOW.toString();
                                            } else if (num > 20 && num <= 40) {
                                                color = ChatColor.GOLD.toString();
                                            } else if (num > 40) {
                                                color = ChatColor.RED.toString();
                                            }
                                            content += Util.prettifyText(entity.toString()) + " x " + color
                                                    + num + ChatColor.WHITE + ", ";
                                        }
                                        int lastComma = content.lastIndexOf(",");
                                        // plugin.getLogger().info("DEBUG: last comma " +
                                        // lastComma);
                                        if (lastComma > 0) {
                                            content = content.substring(0, lastComma);
                                        }
                                        sender.sendMessage("  " + content);

                                    }
                                    rank++;
                                    if (rank > 10) {
                                        break;
                                    }
                                }
                            }
                            // If we didn't show anything say so
                            if (rank == 1) {
                                sender.sendMessage(plugin.myLocale().adminTopBreedersNothing);
                            }

                        }
                    });

                }
            });
            return true;
        }
        // Delete island
        if (split[0].equalsIgnoreCase("deleteisland")) {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().adminDeleteIslandError);
            return true;
        }
        // Set spawn
        if (split[0].equalsIgnoreCase("setspawn")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            player = (Player) sender;
            // Island spawn must be in the island world
            if (!player.getLocation().getWorld().getName().equals(Settings.worldName)) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorWrongWorld);
                return true;
            }
            // The island location is calculated based on the grid
            Location closestIsland = getClosestIsland(player.getLocation());
            Island oldSpawn = plugin.getGrid().getSpawn();
            Island newSpawn = plugin.getGrid().getIslandAt(closestIsland);
            if (newSpawn != null && newSpawn.isSpawn()) {
                // Already spawn, so just set the world spawn coords
                plugin.getGrid().setSpawnPoint(player.getLocation());
                //ASkyBlock.getIslandWorld().setSpawnLocation(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminSetSpawnset);
                return true;
            }
            // Space otherwise occupied - find if anyone owns it
            if (newSpawn != null && newSpawn.getOwner() != null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnownedBy.replace("[name]",
                        plugin.getPlayers().getName(newSpawn.getOwner())));
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnmove);
                return true;
            }
            if (oldSpawn != null) {
                sender.sendMessage(ChatColor.GOLD
                        + "Changing spawn island location. Warning: old spawn island location at "
                        + oldSpawn.getCenter().getBlockX() + "," + oldSpawn.getCenter().getBlockZ()
                        + " will be at risk of being overwritten with new islands. Recommend to clear that old area.");
                plugin.getGrid().deleteSpawn();
            }
            // New spawn site is free, so make it official
            if (newSpawn == null) {
                // Make the new spawn
                newSpawn = plugin.getGrid().addIsland(closestIsland.getBlockX(), closestIsland.getBlockZ());
            }
            plugin.getGrid().setSpawn(newSpawn);
            plugin.getGrid().setSpawnPoint(player.getLocation());
            //ASkyBlock.getIslandWorld().setSpawnLocation(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
            player.sendMessage(ChatColor.GREEN + plugin.myLocale().adminSetSpawnsetting.replace("[location]",
                    player.getLocation().getBlockX() + "," + player.getLocation().getBlockZ()));
            player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawncenter.replace("[location]",
                    newSpawn.getCenter().getBlockX() + "," + newSpawn.getCenter().getBlockZ()));
            player.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawnlimits.replace("[min]",
                    newSpawn.getMinX() + "," + newSpawn.getMinZ())).replace("[max]",
                            (newSpawn.getMinX() + newSpawn.getIslandDistance() - 1) + ","
                                    + (newSpawn.getMinZ() + newSpawn.getIslandDistance() - 1)));
            player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnrange.replace("[number]",
                    String.valueOf(newSpawn.getProtectionSize())));
            player.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawncoords.replace("[min]",
                    newSpawn.getMinProtectedX() + ", " + newSpawn.getMinProtectedZ())).replace("[max]",
                            +(newSpawn.getMinProtectedX() + newSpawn.getProtectionSize() - 1) + ", "
                                    + (newSpawn.getMinProtectedZ() + newSpawn.getProtectionSize() - 1)));
            if (newSpawn.isLocked()) {
                player.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnlocked);
            }
            return true;
        } else if (split[0].equalsIgnoreCase("info") || split[0].equalsIgnoreCase("setrange")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            Location closestIsland = getClosestIsland(((Player) sender).getLocation());
            if (closestIsland == null) {
                sender.sendMessage(ChatColor.RED + "Sorry, could not find an island. Move closer?");
                return true;
            }
            Island island = plugin.getGrid().getIslandAt(closestIsland);
            if (island != null && island.isSpawn()) {
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminInfotitle);
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawncenter.replace(
                        "[location]", island.getCenter().getBlockX() + "," + island.getCenter().getBlockZ()));
                sender.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawnlimits.replace("[min]",
                        island.getMinX() + "," + island.getMinZ())).replace("[max]",
                                (island.getMinX() + island.getIslandDistance() - 1) + ","
                                        + (island.getMinZ() + island.getIslandDistance() - 1)));
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnrange.replace("[number]",
                        String.valueOf(island.getProtectionSize())));
                sender.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawncoords.replace("[min]",
                        island.getMinProtectedX() + ", " + island.getMinProtectedZ())).replace("[max]",
                                +(island.getMinProtectedX() + island.getProtectionSize() - 1) + ", "
                                        + (island.getMinProtectedZ() + island.getProtectionSize() - 1)));
                if (island.isLocked()) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnlocked);
                }
                return true;
            }
            if (island == null) {
                plugin.getLogger().info("Get island at was null" + closestIsland);
            }
            UUID target = plugin.getPlayers().getPlayerFromIslandLocation(closestIsland);
            if (target == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminInfounowned);
                return true;
            }
            showInfo(target, sender);
            return true;
        } else if (split[0].equalsIgnoreCase("resetsign")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            player = (Player) sender;
            if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "mod.signadmin") && !player.isOp()) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                return true;
            }
            // Find out whether the player is looking at a warp sign
            // Look at what the player was looking at
            BlockIterator iter = new BlockIterator(player, 10);
            Block lastBlock = iter.next();
            while (iter.hasNext()) {
                lastBlock = iter.next();
                if (lastBlock.getType() == Material.AIR)
                    continue;
                break;
            }
            if (!lastBlock.getType().equals(Material.SIGN_POST)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminResetSignNoSign);
                return true;
            }
            // Check if it is a warp sign
            Sign sign = (Sign) lastBlock.getState();
            sender.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).adminResetSignFound);
            // Find out whose island this is
            // plugin.getLogger().info("DEBUG: closest bedrock: " +
            // closestBedRock.toString());
            UUID target = plugin.getPlayers().getPlayerFromIslandLocation(player.getLocation());
            if (target == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminInfounowned);
                return true;
            }
            if (plugin.getWarpSignsListener().addWarp(target, lastBlock.getLocation())) {
                // Change sign color to green
                sign.setLine(0, ChatColor.GREEN + plugin.myLocale().warpswelcomeLine);
                sign.update();
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).adminResetSignRescued
                        .replace("[name]", plugin.getPlayers().getName(target)));
                return true;
            }
            // Warp already exists
            sender.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminResetSignErrorExists
                    .replace("[name]", plugin.getWarpSignsListener().getWarpOwner(lastBlock.getLocation())));
            return true;

        } else if (split[0].equalsIgnoreCase("reload")) {
            plugin.reloadConfig();
            plugin.loadPluginConfig();
            plugin.getChallenges().reloadChallengeConfig();
            if (Settings.useEconomy && VaultHelper.setupEconomy()) {
                ControlPanel.loadShop();
            } else {
                Settings.useEconomy = false;
            }
            ControlPanel.loadControlPanel();
            if (Settings.updateCheck) {
                plugin.checkUpdates();
            } else {
                plugin.setUpdateCheck(null);
            }
            plugin.getIslandCmd().loadSchematics();
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().reloadconfigReloaded);
            return true;
        } else if (split[0].equalsIgnoreCase("topten")) {
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminTopTengenerating);
            TopTen.topTenCreate(sender);
            return true;
        } else if (split[0].equalsIgnoreCase("purge")) {
            if (purgeFlag) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgealreadyRunning);
                return true;
            }
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgeusage.replace("[label]", label));
            return true;
        } else if (split[0].equalsIgnoreCase("confirm")) {
            if (!confirmReq) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().confirmerrorTimeLimitExpired);
                return true;
            } else {
                // Tell purge routine to go
                confirmOK = true;
                confirmReq = false;
            }
            return true;
        } else {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            return false;
        }
    case 2:
        // Resetsign <player> - makes a warp sign for player
        if (split[0].equalsIgnoreCase("resetsign")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            Player p = (Player) sender;
            if (!VaultHelper.checkPerm(p, Settings.PERMPREFIX + "mod.signadmin") && !p.isOp()) {
                p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).errorNoPermission);
                return true;
            }
            // Convert target name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID) && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Has an island
                // Find out whether the player is looking at a warp sign
                // Look at what the player was looking at
                BlockIterator iter = new BlockIterator(p, 10);
                Block lastBlock = iter.next();
                while (iter.hasNext()) {
                    lastBlock = iter.next();
                    if (lastBlock.getType() == Material.AIR)
                        continue;
                    break;
                }
                // Check if it is a sign
                if (!lastBlock.getType().equals(Material.SIGN_POST)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).adminResetSignNoSign);
                    return true;
                }
                Sign sign = (Sign) lastBlock.getState();
                // Check if the sign is within the right island boundary
                Location islandLoc = plugin.getPlayers().getIslandLocation(playerUUID);
                if (!plugin.getGrid().getIslandAt(islandLoc).inIslandSpace(sign.getLocation())) {
                    p.sendMessage(
                            ChatColor.RED + plugin.myLocale(p.getUniqueId()).adminSetHomeNotOnPlayersIsland);
                } else {
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminResetSignFound);
                    // Find out if this player is allowed to have a sign on this island
                    if (plugin.getWarpSignsListener().addWarp(playerUUID, lastBlock.getLocation())) {
                        // Change sign color to green
                        sign.setLine(0, ChatColor.GREEN + plugin.myLocale().warpswelcomeLine);
                        sign.update();
                        p.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminResetSignRescued
                                .replace("[name]", plugin.getPlayers().getName(playerUUID)));
                        return true;
                    }
                    // Warp already exists
                    sender.sendMessage(ChatColor.RED
                            + plugin.myLocale(p.getUniqueId()).adminResetSignErrorExists.replace("[name]",
                                    plugin.getWarpSignsListener().getWarpOwner(lastBlock.getLocation())));
                }
            }
            return true;
        }
        // Delete the island you are on
        else if (split[0].equalsIgnoreCase("deleteisland")) {
            if (!split[1].equalsIgnoreCase("confirm")) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminDeleteIslandError);
                return true;
            }
            // Get the island I am on
            Island island = plugin.getGrid().getIslandAt(((Player) sender).getLocation());
            if (island == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminDeleteIslandnoid);
                return true;
            }
            // Try to get the owner of this island
            UUID owner = island.getOwner();
            String name = "unknown";
            if (owner != null) {
                name = plugin.getPlayers().getName(owner);
                sender.sendMessage(
                        ChatColor.RED + plugin.myLocale().adminSetSpawnownedBy.replace("[name]", name));
                sender.sendMessage(
                        ChatColor.RED + plugin.myLocale().adminDeleteIslanduse.replace("[name]", name));
                return true;
            } else {
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().deleteremoving.replace("[name]", name));
                deleteIslands(island, sender);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("resethome")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID) && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Has an island
                Location safeHome = plugin.getGrid().getSafeHomeLocation(playerUUID, 1);
                if (safeHome == null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetHomeNoneFound);
                } else {
                    plugin.getPlayers().setHomeLocation(playerUUID, safeHome);
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminSetHomeHomeSet.replace(
                            "[location]",
                            safeHome.getBlockX() + ", " + safeHome.getBlockY() + "," + safeHome.getBlockZ()));
                }
            }
            return true;
        } else if (split[0].equalsIgnoreCase("sethome")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID) && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    player.sendMessage(
                            ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIslandOther);
                    return true;
                }
                // Has an island
                Location islandLoc = plugin.getPlayers().getIslandLocation(playerUUID);
                // Check the player is within the island boundaries
                if (!plugin.getGrid().getIslandAt(islandLoc).inIslandSpace(player.getLocation())) {
                    player.sendMessage(ChatColor.RED
                            + plugin.myLocale(player.getUniqueId()).adminSetHomeNotOnPlayersIsland);
                } else {
                    // Check that the location is safe
                    if (!GridManager.isSafeLocation(player.getLocation())) {
                        // Not safe
                        player.sendMessage(
                                ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminSetHomeNoneFound);
                    } else {
                        // Success
                        plugin.getPlayers().setHomeLocation(playerUUID, player.getLocation());
                        player.sendMessage(
                                ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).adminSetHomeHomeSet
                                        .replace("[location]",
                                                player.getLocation().getBlockX() + ", "
                                                        + player.getLocation().getBlockY() + ","
                                                        + player.getLocation().getBlockZ()));
                    }
                }
            }
            return true;
        } else
        // Set protection for the island the player is on
        if (split[0].equalsIgnoreCase("setrange")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            UUID playerUUID = player.getUniqueId();
            Island island = plugin.getGrid().getIslandAt(player.getLocation());
            // Check if island exists
            if (island == null) {
                player.sendMessage(ChatColor.RED + plugin.myLocale().errorNotOnIsland);
                return true;
            } else {
                int newRange = 10;
                int maxRange = Settings.islandDistance;
                // If spawn do something different
                if (island.isSpawn()) {
                    try {
                        newRange = Integer.valueOf(split[1]);
                    } catch (Exception e) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeInvalid);
                        return true;
                    }
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).adminSetRangeSet
                            .replace("[number]", String.valueOf(newRange)));
                    if (newRange > maxRange) {
                        player.sendMessage(ChatColor.RED + "" + ChatColor.BOLD
                                + plugin.myLocale(playerUUID).adminSetRangeWarning.replace("[max]",
                                        String.valueOf(maxRange)));
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeWarning2);
                    }
                    island.setProtectionSize(newRange);
                    player.sendMessage(
                            ChatColor.YELLOW + plugin.myLocale().adminSetSpawncenter.replace("[location]",
                                    island.getCenter().getBlockX() + "," + island.getCenter().getBlockZ()));
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnlimits
                            .replace("[min]", island.getMinX() + "," + island.getMinZ())
                            .replace("[max]", (island.getMinX() + island.getIslandDistance() - 1) + ","
                                    + (island.getMinZ() + island.getIslandDistance() - 1)));
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnrange
                            .replace("[number]", String.valueOf(island.getProtectionSize())));
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawncoords
                            .replace("[min]", island.getMinProtectedX() + ", " + island.getMinProtectedZ())
                            .replace("[max]", +(island.getMinProtectedX() + island.getProtectionSize() - 1)
                                    + ", " + (island.getMinProtectedZ() + island.getProtectionSize() - 1)));
                    if (island.isLocked()) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnlocked);
                    }
                } else {
                    if (!plugin.getConfig().getBoolean("island.overridelimit")) {
                        maxRange -= 16;
                    }
                    try {
                        newRange = Integer.valueOf(split[1]);
                    } catch (Exception e) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeInvalid
                                + " " + plugin.myLocale(playerUUID).adminSetRangeTip.replace("[max]",
                                        String.valueOf(maxRange)));
                        return true;
                    }
                    if (newRange < 10 || newRange > maxRange) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeInvalid
                                + " " + plugin.myLocale(playerUUID).adminSetRangeTip.replace("[max]",
                                        String.valueOf(maxRange)));
                        return true;
                    }
                    island.setProtectionSize(newRange);
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).adminSetRangeSet
                            .replace("[number]", String.valueOf(newRange)));
                    showInfo(island.getOwner(), sender);
                }
                return true;
            }
        }
        if (split[0].equalsIgnoreCase("purge")) {
            // PURGE Command
            // Check for "allow" or "disallow" flags
            // Protect island from purging
            if (split[1].equalsIgnoreCase("allow") || split[1].equalsIgnoreCase("disallow")) {
                // Find the closest island
                if (!(sender instanceof Player)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                    return true;
                }
                Player p = (Player) sender;
                // Island spawn must be in the island world
                if (!p.getLocation().getWorld().equals(ASkyBlock.getIslandWorld())
                        && !p.getLocation().getWorld().equals(ASkyBlock.getNetherWorld())) {
                    p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).errorWrongWorld);
                    return true;
                }
                Island island = plugin.getGrid().getIslandAt(p.getLocation());
                if (island == null) {
                    p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).errorNoIslandOther);
                    return true;
                }
                if (split[1].equalsIgnoreCase("allow")) {
                    island.setPurgeProtected(true);
                } else {
                    island.setPurgeProtected(false);
                }
                if (island.isPurgeProtected()) {
                    p.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminAllowPurge);
                } else {
                    p.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminPreventPurge);
                }
                return true;
            }

            // Purge runs in the background so if one is already running
            // this flag stops a repeat
            if (purgeFlag) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgealreadyRunning);
                return true;
            }

            if (split[1].equalsIgnoreCase("unowned")) {
                countUnowned(sender);
                return true;
            }
            // Set the flag
            purgeFlag = true;
            // See if this purge unowned

            // Convert days to hours - no other limit checking?
            final int time;
            try {
                time = Integer.parseInt(split[1]) * 24;
            } catch (Exception e) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgeusage.replace("[label]", label));
                purgeFlag = false;
                return true;
            }
            sender.sendMessage(
                    ChatColor.YELLOW + plugin.myLocale().purgecalculating.replace("[time]", split[1]));
            // Check who has not been online since the time
            for (Entry<UUID, Island> entry : plugin.getGrid().getOwnershipMap().entrySet()) {
                //plugin.getLogger().info("UUID = " + entry.getKey());
                // Only do this if it isn't protected
                if (entry.getKey() != null && !entry.getValue().isPurgeProtected()) {
                    if (Bukkit.getOfflinePlayer(entry.getKey()).hasPlayedBefore()) {
                        long offlineTime = Bukkit.getOfflinePlayer(entry.getKey()).getLastPlayed();
                        offlineTime = (System.currentTimeMillis() - offlineTime) / 3600000L;
                        if (offlineTime > time) {
                            //if (plugin.getPlayers().getIslandLevel(entry.getKey()) < Settings.abandonedIslandLevel) {
                            // Check level later
                            removeList.add(entry.getKey());
                            //}
                        }
                    } else {
                        removeList.add(entry.getKey());
                    }
                }
            }
            if (removeList.isEmpty()) {
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgenoneFound);
                purgeFlag = false;
                return true;
            }
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgethisWillRemove
                    .replace("[number]", String.valueOf(removeList.size()))
                    .replace("[level]", String.valueOf(Settings.abandonedIslandLevel)));
            sender.sendMessage(ChatColor.RED + plugin.myLocale().purgewarning);
            sender.sendMessage(ChatColor.RED + plugin.myLocale().purgetypeConfirm.replace("[label]", label));
            confirmReq = true;
            confirmOK = false;
            confirmTimer = 0;
            new BukkitRunnable() {
                @Override
                public void run() {
                    // This waits for 10 seconds and if no
                    // confirmation received, then it
                    // cancels
                    if (confirmTimer++ > 10) {
                        // Ten seconds is up!
                        confirmReq = false;
                        confirmOK = false;
                        purgeFlag = false;
                        removeList.clear();
                        sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgepurgeCancelled);
                        this.cancel();
                    } else if (confirmOK) {
                        // Set up a repeating task to run every 2
                        // seconds to remove
                        // islands one by one and then cancel when
                        // done
                        final int total = removeList.size();
                        new BukkitRunnable() {
                            @Override
                            public void run() {
                                if (removeList.isEmpty() && purgeFlag) {
                                    purgeFlag = false;
                                    sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgefinished);
                                    this.cancel();
                                }

                                if (removeList.size() > 0 && purgeFlag) {
                                    // Check the level
                                    if (plugin.getPlayers().getIslandLevel(
                                            removeList.get(0)) < Settings.abandonedIslandLevel) {
                                        sender.sendMessage(ChatColor.YELLOW + "["
                                                + (total - removeList.size() + 1) + "/" + total + "] "
                                                + plugin.myLocale().purgeremovingName.replace("[name]",
                                                        plugin.getPlayers().getName(removeList.get(0))));
                                        plugin.deletePlayerIsland(removeList.get(0), true);
                                    }
                                    removeList.remove(0);
                                }
                                //sender.sendMessage("Now waiting...");
                            }
                        }.runTaskTimer(plugin, 0L, 20L);
                        confirmReq = false;
                        confirmOK = false;
                        this.cancel();
                    }
                }
            }.runTaskTimer(plugin, 0L, 40L);
            return true;
        } else if (split[0].equalsIgnoreCase("lock")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                Island island = plugin.getGrid().getIsland(playerUUID);
                if (island != null) {
                    Player owner = plugin.getServer().getPlayer(island.getOwner());
                    if (island.isLocked()) {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().lockUnlocking);
                        island.setLocked(false);
                        if (owner != null) {
                            owner.sendMessage(
                                    plugin.myLocale(owner.getUniqueId()).adminLockadminUnlockedIsland);
                        } else {
                            plugin.getMessages().setMessage(island.getOwner(),
                                    plugin.myLocale(island.getOwner()).adminLockadminUnlockedIsland);
                        }
                    } else {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().lockLocking);
                        island.setLocked(true);
                        if (owner != null) {
                            owner.sendMessage(plugin.myLocale(owner.getUniqueId()).adminLockadminLockedIsland);
                        } else {
                            plugin.getMessages().setMessage(island.getOwner(),
                                    plugin.myLocale(island.getOwner()).adminLockadminLockedIsland);
                        }
                    }
                } else {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                }
                return true;
            }
        } else if (split[0].equalsIgnoreCase("clearreset")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                plugin.getPlayers().setResetsLeft(playerUUID, Settings.resetLimit);
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().clearedResetLimit + " ["
                        + Settings.resetLimit + "]");
                return true;
            }
        } else if (split[0].equalsIgnoreCase("tp")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
                return true;
            }
            player = (Player) sender;
            // Convert name to a UUID
            final UUID targetUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(targetUUID)) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                return true;
            } else {
                if (plugin.getPlayers().hasIsland(targetUUID) || plugin.getPlayers().inTeam(targetUUID)) {
                    // Teleport to the over world
                    Location warpSpot = plugin.getPlayers().getIslandLocation(targetUUID).toVector()
                            .toLocation(ASkyBlock.getIslandWorld());
                    String failureMessage = ChatColor.RED
                            + plugin.myLocale(player.getUniqueId()).adminTpManualWarp.replace("[location]",
                                    warpSpot.getBlockX() + " " + warpSpot.getBlockY() + " "
                                            + warpSpot.getBlockZ());
                    // Try the player's home first
                    Location home = plugin.getPlayers().getHomeLocation(targetUUID);
                    plugin.getGrid();
                    if (home.getWorld().equals(ASkyBlock.getIslandWorld())
                            && GridManager.isSafeLocation(home)) {
                        player.teleport(home);
                        return true;
                    }
                    // Other wise, go to a safe spot
                    new SafeSpotTeleport(plugin, player, warpSpot, failureMessage);
                    return true;
                }
                sender.sendMessage(plugin.myLocale().errorNoIslandOther);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("tpnether")) {
            if (!Settings.createNether || !Settings.newNether) {
                return false;
            }
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
                return true;
            }
            player = (Player) sender;
            // Convert name to a UUID
            final UUID targetUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(targetUUID)) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                return true;
            } else {
                if (plugin.getPlayers().hasIsland(targetUUID) || plugin.getPlayers().inTeam(targetUUID)) {
                    // Teleport to the nether
                    Location warpSpot = plugin.getPlayers().getIslandLocation(targetUUID).toVector()
                            .toLocation(ASkyBlock.getNetherWorld());
                    String failureMessage = ChatColor.RED
                            + plugin.myLocale(player.getUniqueId()).adminTpManualWarp.replace("[location]",
                                    warpSpot.getBlockX() + " " + warpSpot.getBlockY() + " "
                                            + warpSpot.getBlockZ());
                    // Try the player's home first
                    Location home = plugin.getPlayers().getHomeLocation(targetUUID);
                    plugin.getGrid();
                    if (home.getWorld().equals(ASkyBlock.getNetherWorld())
                            && GridManager.isSafeLocation(home)) {
                        player.teleport(home);
                        return true;
                    }
                    new SafeSpotTeleport(plugin, player, warpSpot, failureMessage);
                    return true;
                }
                sender.sendMessage(plugin.myLocale().errorNoIslandOther);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("delete")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                // This now deletes the player and cleans them up even if
                // they don't have an island
                sender.sendMessage(
                        ChatColor.YELLOW + plugin.myLocale().deleteremoving.replace("[name]", split[1]));
                // If they are online and in ASkyBlock then delete their
                // stuff too
                Player target = plugin.getServer().getPlayer(playerUUID);
                if (target != null) {
                    // Clear any coop inventories
                    // CoopPlay.getInstance().returnAllInventories(target);
                    // Remove any of the target's coop invitees and grab
                    // their stuff
                    CoopPlay.getInstance().clearMyInvitedCoops(target);
                    CoopPlay.getInstance().clearMyCoops(target);
                    plugin.resetPlayer(target);
                }
                // plugin.getLogger().info("DEBUG: deleting player");
                plugin.deletePlayerIsland(playerUUID, true);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("register")) {
            if (sender instanceof Player) {
                // Convert name to a UUID
                final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
                if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                    return true;
                } else {
                    if (adminSetPlayerIsland(sender, ((Player) sender).getLocation(), playerUUID)) {
                        sender.sendMessage(ChatColor.GREEN
                                + plugin.myLocale().registersettingIsland.replace("[name]", split[1]));
                        plugin.getGrid().saveGrid();
                    } else {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().registererrorBedrockNotFound);
                    }
                    return true;
                }
            } else {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            }
            return true;
        } else if (split[0].equalsIgnoreCase("unregister")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                if (plugin.getPlayers().inTeam(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminUnregisterOnTeam);
                    return true;
                }
                Location island = plugin.getPlayers().getIslandLocation(playerUUID);
                if (island == null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Delete player, but keep blocks
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminUnregisterKeepBlocks
                        .replace("[location]", +plugin.getPlayers().getIslandLocation(playerUUID).getBlockX()
                                + "," + plugin.getPlayers().getIslandLocation(playerUUID).getBlockZ()));
                plugin.deletePlayerIsland(playerUUID, false);
                plugin.getGrid().saveGrid();
                return true;
            }
        } else if (split[0].equalsIgnoreCase("info")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            // plugin.getLogger().info("DEBUG: console player info UUID = "
            // + playerUUID);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                showInfo(playerUUID, sender);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("resetallchallenges")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            plugin.getPlayers().resetAllChallenges(playerUUID);
            sender.sendMessage(
                    ChatColor.YELLOW + plugin.myLocale().resetChallengessuccess.replace("[name]", split[1]));
            return true;
        } else {
            return false;
        }
    case 3:
        // Confirm purge unowned
        if (split[0].equalsIgnoreCase("purge")) {
            if (purgeFlag) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgealreadyRunning);
                return true;
            }
            // Check if this is purge unowned
            if (split[1].equalsIgnoreCase("unowned") && split[2].equalsIgnoreCase("confirm")) {
                if (!purgeUnownedConfirm) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().confirmerrorTimeLimitExpired);
                    return true;
                } else {
                    purgeUnownedConfirm = false;
                    // Purge the unowned islands
                    purgeUnownedIslands(sender);
                    return true;
                }
            }

        }
        // Set protection
        if (split[0].equalsIgnoreCase("setrange")) {
            // Convert name to a UUID
            UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            // Check if player exists
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            // Check if the target is in a team and if so, the leader needs to be adjusted
            if (plugin.getPlayers().inTeam(playerUUID)) {
                playerUUID = plugin.getPlayers().getTeamLeader(playerUUID);
            }
            // Get the range that this player has now
            Island island = plugin.getGrid().getIsland(playerUUID);
            if (island == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                return true;
            } else {
                int newRange = 0;
                int maxRange = Settings.islandDistance;
                if (!plugin.getConfig().getBoolean("island.overridelimit")) {
                    maxRange -= 16;
                }
                try {
                    newRange = Integer.valueOf(split[2]);
                } catch (Exception e) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetRangeInvalid + " "
                            + plugin.myLocale().adminSetRangeTip.replace("[max]", String.valueOf(maxRange)));

                    return true;
                }
                if (newRange < 10 || newRange > maxRange) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetRangeInvalid + " "
                            + plugin.myLocale().adminSetRangeTip.replace("[max]", String.valueOf(maxRange)));

                    return true;
                }
                island.setProtectionSize(newRange);
                sender.sendMessage(ChatColor.GREEN
                        + plugin.myLocale().adminSetRangeSet.replace("[number]", String.valueOf(newRange)));
                showInfo(playerUUID, sender);
                plugin.getGrid().saveGrid();
                return true;
            }
        }
        // Change biomes
        if (split[0].equalsIgnoreCase("setbiome")) {
            // Convert name to a UUID
            UUID playerUUID = plugin.getPlayers().getUUID(split[1]);
            // Check if player exists
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            // Check if the target is in a team and if so, the leader
            if (plugin.getPlayers().inTeam(playerUUID)) {
                playerUUID = plugin.getPlayers().getTeamLeader(playerUUID);
            }
            // Check if biome is valid
            Biome biome = null;
            String biomeName = split[2].toUpperCase();
            try {
                biome = Biome.valueOf(biomeName);
                biomeName = biome.name();
                if (!plugin.getConfig().contains("biomes." + biomeName)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().biomeUnknown);
                    // Doing it this way ensures that only valid biomes are
                    // shown
                    for (Biome b : Biome.values()) {
                        if (plugin.getConfig().contains("biomes." + b.name())) {
                            sender.sendMessage(b.name());
                        }
                    }
                    return true;
                }
                // Get friendly name
                biomeName = plugin.getConfig().getString("biomes." + biomeName + ".friendlyname",
                        Util.prettifyText(biomeName));

            } catch (Exception e) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().biomeUnknown);
                for (Biome b : Biome.values()) {
                    if (plugin.getConfig().contains("biomes." + b.name())) {
                        sender.sendMessage(b.name());
                    }
                }
                return true;
            }
            // Okay clear to set biome
            // Actually set the biome
            if (plugin.getPlayers().inTeam(playerUUID)
                    && plugin.getPlayers().getTeamIslandLocation(playerUUID) != null) {
                plugin.getBiomes().setIslandBiome(plugin.getPlayers().getTeamIslandLocation(playerUUID), biome);
            } else {
                plugin.getBiomes().setIslandBiome(plugin.getPlayers().getIslandLocation(playerUUID), biome);
            }
            sender.sendMessage(ChatColor.GREEN + plugin.myLocale().biomeSet.replace("[biome]", biomeName));
            Player targetPlayer = plugin.getServer().getPlayer(playerUUID);
            if (targetPlayer != null) {
                // Online
                targetPlayer.sendMessage("[Admin] " + ChatColor.GREEN
                        + plugin.myLocale(playerUUID).biomeSet.replace("[biome]", biomeName));
            } else {
                plugin.getMessages().setMessage(playerUUID, "[Admin] " + ChatColor.GREEN
                        + plugin.myLocale(playerUUID).biomeSet.replace("[biome]", biomeName));
            }
            return true;
        } else
        // team kick <player> and team delete <leader>
        if (split[0].equalsIgnoreCase("team")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (split[1].equalsIgnoreCase("kick")) {
                // Remove player from team
                if (!plugin.getPlayers().inTeam(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoTeam);
                    return true;
                }
                UUID teamLeader = plugin.getPlayers().getTeamLeader(playerUUID);
                if (teamLeader == null) {
                    // Player is apparently in a team, but there is no team leader
                    // Remove their team status
                    // Clear the player of all team-related items
                    plugin.getPlayers().setLeaveTeam(playerUUID);
                    plugin.getPlayers().setHomeLocation(playerUUID, null);
                    plugin.getPlayers().setIslandLocation(playerUUID, null);
                    // Remove any warps
                    plugin.getWarpSignsListener().removeWarp(playerUUID);
                    sender.sendMessage(
                            ChatColor.RED + plugin.myLocale().kicknameRemoved.replace("[name]", split[2]));
                    return true;
                }
                // Payer is not a team leader
                if (!teamLeader.equals(playerUUID)) {
                    // Clear the player of all team-related items
                    plugin.getPlayers().setLeaveTeam(playerUUID);
                    plugin.getPlayers().setHomeLocation(playerUUID, null);
                    plugin.getPlayers().setIslandLocation(playerUUID, null);
                    // Clear the leader of this player and if they now have
                    // no team, remove the team
                    plugin.getPlayers().removeMember(teamLeader, playerUUID);
                    if (plugin.getPlayers().getMembers(teamLeader).size() < 2) {
                        plugin.getPlayers().setLeaveTeam(teamLeader);
                    }
                    // Remove any warps
                    plugin.getWarpSignsListener().removeWarp(playerUUID);
                    sender.sendMessage(
                            ChatColor.RED + plugin.myLocale().kicknameRemoved.replace("[name]", split[2]));
                    return true;
                } else {
                    sender.sendMessage(
                            ChatColor.RED + (plugin.myLocale().adminTeamKickLeader.replace("[label]", label))
                                    .replace("[name]", split[2]));
                    return true;
                }
            } else {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
                return false;
            }
        } else if (split[0].equalsIgnoreCase("completechallenge")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (plugin.getPlayers().checkChallenge(playerUUID, split[1].toLowerCase())
                    || !plugin.getPlayers().get(playerUUID).challengeExists(split[1].toLowerCase())) {
                sender.sendMessage(
                        ChatColor.RED + plugin.myLocale().completeChallengeerrorChallengeDoesNotExist);
                return true;
            }
            plugin.getPlayers().get(playerUUID).completeChallenge(split[1].toLowerCase());
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().completeChallengechallangeCompleted
                    .replace("[challengename]", split[1].toLowerCase()).replace("[name]", split[2]));
            return true;
        } else if (split[0].equalsIgnoreCase("resetchallenge")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (!plugin.getPlayers().checkChallenge(playerUUID, split[1].toLowerCase())
                    || !plugin.getPlayers().get(playerUUID).challengeExists(split[1].toLowerCase())) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().resetChallengeerrorChallengeDoesNotExist);
                return true;
            }
            plugin.getPlayers().resetChallenge(playerUUID, split[1].toLowerCase());
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().resetChallengechallengeReset
                    .replace("[challengename]", split[1].toLowerCase()).replace("[name]", split[2]));
            return true;
        } else if (split[0].equalsIgnoreCase("info") && split[1].equalsIgnoreCase("challenges")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2]);
            // plugin.getLogger().info("DEBUG: console player info UUID = "
            // + playerUUID);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                showInfoChallenges(playerUUID, sender);
                return true;
            }
        }
        return false;
    case 4:
        // Team add <player> <leader>
        if (split[0].equalsIgnoreCase("team") && split[1].equalsIgnoreCase("add")) {
            // Convert names to UUIDs
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2]);
            final Player targetPlayer = plugin.getServer().getPlayer(playerUUID);
            final UUID teamLeader = plugin.getPlayers().getUUID(split[3]);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)
                    || !plugin.getPlayers().isAKnownPlayer(teamLeader)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (playerUUID.equals(teamLeader)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminTeamAddLeaderToOwn);
                return true;
            }
            // See if leader has an island
            if (!plugin.getPlayers().hasIsland(teamLeader)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminTeamAddLeaderNoIsland);
                return true;
            }
            // Check to see if this player is already in a team
            if (plugin.getPlayers().inTeam(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().inviteerrorThatPlayerIsAlreadyInATeam);
                return true;
            }
            // If the leader's member list does not contain their own name
            // then
            // add it
            if (!plugin.getPlayers().getMembers(teamLeader).contains(teamLeader)) {
                // Set up the team leader
                plugin.getPlayers().setJoinTeam(teamLeader, teamLeader,
                        plugin.getPlayers().getIslandLocation(teamLeader));
                plugin.getPlayers().addTeamMember(teamLeader, teamLeader);
                sender.sendMessage(ChatColor.GOLD + plugin.myLocale().adminTeamAddedLeader);
            }
            // This is a hack to clear any pending invitations
            if (targetPlayer != null) {
                targetPlayer.performCommand(Settings.ISLANDCOMMAND + " decline");
            }
            // If the invitee has an island of their own
            if (plugin.getPlayers().hasIsland(playerUUID)) {
                Location islandLoc = plugin.getPlayers().getIslandLocation(playerUUID);
                if (islandLoc != null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminTeamNowUnowned
                            .replace("[name]", plugin.getPlayers().getName(playerUUID))
                            .replace("[location]", islandLoc.getBlockX() + " " + islandLoc.getBlockZ()));
                }
            }
            // Remove their old island affiliation - do not delete the
            // island just in case
            plugin.deletePlayerIsland(playerUUID, false);
            // Join the team and set the team island location and leader
            plugin.getPlayers().setJoinTeam(playerUUID, teamLeader,
                    plugin.getPlayers().getIslandLocation(teamLeader));
            // Configure the best home location for this player
            if (plugin.getPlayers().getHomeLocation(teamLeader) != null) {
                plugin.getPlayers().setHomeLocation(playerUUID,
                        plugin.getPlayers().getHomeLocation(teamLeader));
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminTeamSettingHome);
            } else {
                plugin.getPlayers().setHomeLocation(playerUUID,
                        plugin.getPlayers().getIslandLocation(teamLeader));
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminTeamSettingHome);
            }
            // If the leader's member list does not contain player then add
            // it
            if (!plugin.getPlayers().getMembers(teamLeader).contains(playerUUID)) {
                plugin.getPlayers().addTeamMember(teamLeader, playerUUID);
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminTeamAddingPlayer);
            } else {
                sender.sendMessage(ChatColor.GOLD + plugin.myLocale().adminTeamAlreadyOnTeam);
            }
            // Teleport the player if they are online
            if (targetPlayer != null) {
                plugin.getGrid().homeTeleport(targetPlayer);
            }
            plugin.getGrid().saveGrid();
            return true;
        } else {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            return false;
        }
    default:
        return false;
    }
}

From source file:it.units.malelab.ege.util.DUMapper.java

private static double[][][] getNeatData3(String baseDir, String fileNamePattern, int generations)
        throws IOException {
    List<List<Map<Integer, Multimap<Integer, Integer>>>> data = new ArrayList<>();
    Map<Integer, String> nodeTypesMap = new HashMap<>();
    for (int g = 0; g < generations; g++) {
        List<Map<Integer, Multimap<Integer, Integer>>> currentPopulation = new ArrayList<>();
        BufferedReader reader = Files.newBufferedReader(
                FileSystems.getDefault().getPath(baseDir, String.format(fileNamePattern, g + 1)));
        String line;//  www .  j a v a  2 s.co m
        boolean isInPopulation = false;
        Map<Integer, Multimap<Integer, Integer>> currentIndividual = null;
        while ((line = reader.readLine()) != null) {
            if (line.equals("[NEAT-POPULATION:SPECIES]")) {
                isInPopulation = true;
                continue;
            }
            if (!isInPopulation) {
                continue;
            }
            if (line.startsWith("\"g\"")) {
                if (currentIndividual != null) {
                    //save current individual
                    currentPopulation.add(currentIndividual);
                }
                currentIndividual = new HashMap<>();
            }
            if (line.startsWith("\"n\"")) {
                String[] pieces = line.split(",");
                nodeTypesMap.put(Integer.parseInt(pieces[4]), pieces[3].replaceAll("\"", ""));
                currentIndividual.put(Integer.parseInt(pieces[4]), (Multimap) HashMultimap.create());
            } else if (line.startsWith("\"l\"")) {
                String[] pieces = line.split(",");
                int from = Integer.parseInt(pieces[3]);
                int to = Integer.parseInt(pieces[4]);
                if (currentIndividual.get(from) == null) {
                    currentIndividual.put(from, (Multimap) HashMultimap.create());
                }
                if (currentIndividual.get(to) == null) {
                    currentIndividual.put(to, (Multimap) HashMultimap.create());
                }
                currentIndividual.get(from).put(1, to);
                currentIndividual.get(to).put(-1, from);
            }
        }
        reader.close();
        data.add(currentPopulation);
    }
    //build node innovation numbers
    String[] nodeTypes = new String[] { "i", "b", "h", "o" };
    List<Integer> nodeINs = new ArrayList<>();
    for (String nodeType : nodeTypes) {
        List<Integer> typeNodeINs = new ArrayList<>();
        for (Integer in : nodeTypesMap.keySet()) {
            if (nodeTypesMap.get(in).equals(nodeType)) {
                typeNodeINs.add(in);
            }
        }
        Collections.sort(typeNodeINs);
        nodeINs.addAll(typeNodeINs);
    }
    //populate arrays
    double[][] usages = new double[generations][];
    double[][] diversities = new double[generations][];
    for (int g = 0; g < generations; g++) {
        usages[g] = new double[nodeINs.size()];
        diversities[g] = new double[nodeINs.size()];
        List<Map<Integer, Multimap<Integer, Integer>>> currentPopulation = data.get(g);
        //populate usages, diversities
        int i = 0;
        for (int nodeIN : nodeINs) {
            double[] localUsages = new double[currentPopulation.size()];
            Multiset<Set<Integer>> froms = HashMultiset.create();
            Multiset<Set<Integer>> tos = HashMultiset.create();
            int c = 0;
            for (Map<Integer, Multimap<Integer, Integer>> currentIndividual : currentPopulation) {
                if (nodeTypesMap.get(nodeIN).equals("i") || nodeTypesMap.get(nodeIN).equals("b")) {
                    if (currentIndividual.containsKey(nodeIN)) {
                        localUsages[c] = currentIndividual.get(nodeIN).get(1).isEmpty() ? 0 : 1;
                        tos.add(new HashSet<>(currentIndividual.get(nodeIN).get(1)));
                    } else {
                        tos.add(Collections.EMPTY_SET);
                    }
                } else if (nodeTypesMap.get(nodeIN).equals("h")) {
                    if (currentIndividual.containsKey(nodeIN)) {
                        localUsages[c] = (currentIndividual.get(nodeIN).get(-1).isEmpty() ? 0 : 0.5)
                                + (currentIndividual.get(nodeIN).get(1).isEmpty() ? 0 : 0.5);
                        tos.add(new HashSet<>(currentIndividual.get(nodeIN).get(1)));
                        froms.add(new HashSet<>(currentIndividual.get(nodeIN).get(-1)));
                    } else {
                        tos.add(Collections.EMPTY_SET);
                        froms.add(Collections.EMPTY_SET);
                    }
                } else if (nodeTypesMap.get(nodeIN).equals("o")) {
                    if (currentIndividual.containsKey(nodeIN)) {
                        localUsages[c] = currentIndividual.get(nodeIN).get(-1).isEmpty() ? 0 : 1;
                        froms.add(new HashSet<>(currentIndividual.get(nodeIN).get(-1)));
                    } else {
                        froms.add(Collections.EMPTY_SET);
                    }
                }
                c = c + 1;
            }
            usages[g][i] = StatUtils.mean(localUsages);
            if (nodeTypesMap.get(nodeIN).equals("i") || nodeTypesMap.get(nodeIN).equals("b")) {
                diversities[g][i] = Utils.multisetDiversity(tos, tos.elementSet());
            } else if (nodeTypesMap.get(nodeIN).equals("h")) {
                diversities[g][i] = Utils.multisetDiversity(tos, tos.elementSet()) / 2
                        + Utils.multisetDiversity(froms, tos.elementSet()) / 2;
            } else if (nodeTypesMap.get(nodeIN).equals("o")) {
                diversities[g][i] = Utils.multisetDiversity(froms, tos.elementSet());
            }
            i = i + 1;
        }
    }
    return new double[][][] { diversities, usages };
}

From source file:com.trein.gtfs.otp.building.graph.osm.Graph.java

public void summarizeBuilderAnnotations() {
    List<GraphBuilderAnnotation> gbas = this.graphBuilderAnnotations;
    Multiset<Class<? extends GraphBuilderAnnotation>> classes = HashMultiset.create();
    LOG.info("Summary (number of each type of annotation):");
    for (GraphBuilderAnnotation gba : gbas) {
        classes.add(gba.getClass());//ww  w.ja  v  a2s.  c o  m
    }
    for (Multiset.Entry<Class<? extends GraphBuilderAnnotation>> e : classes.entrySet()) {
        String name = e.getElement().getSimpleName();
        int count = e.getCount();
        LOG.info("    {} - {}", name, count);
    }
}

From source file:org.opentripplanner.routing.graph.Graph.java

public void summarizeBuilderAnnotations() {
    List<GraphBuilderAnnotation> gbas = this.graphBuilderAnnotations;
    Multiset<Class<? extends GraphBuilderAnnotation>> classes = HashMultiset.create();
    LOG.info("Summary (number of each type of annotation):");
    for (GraphBuilderAnnotation gba : gbas)
        classes.add(gba.getClass());// w  ww  .  j a v a2 s . c om
    for (Multiset.Entry<Class<? extends GraphBuilderAnnotation>> e : classes.entrySet()) {
        String name = e.getElement().getSimpleName();
        int count = e.getCount();
        LOG.info("    {} - {}", name, count);
    }
}

From source file:com.wasteofplastic.askyblock.commands.AdminCmd.java

@Override
public boolean onCommand(final CommandSender sender, final Command command, final String label,
        final String[] split) {
    // Console commands
    Player player;//from   w w  w . ja va 2 s  . c  o m
    if (sender instanceof Player) {
        player = (Player) sender;
        if (split.length > 0) {
            // Admin-only commands : reload, register, delete and purge
            if (split[0].equalsIgnoreCase("reload") || split[0].equalsIgnoreCase("register")
                    || split[0].equalsIgnoreCase("delete") || split[0].equalsIgnoreCase("purge")
                    || split[0].equalsIgnoreCase("confirm") || split[0].equalsIgnoreCase("setspawn")
                    || split[0].equalsIgnoreCase("deleteisland") || split[0].equalsIgnoreCase("setrange")
                    || split[0].equalsIgnoreCase("reserve") || split[0].equalsIgnoreCase("unregister")
                    || split[0].equalsIgnoreCase("clearresetall")
                    || split[0].equalsIgnoreCase("settingsreset")) {
                if (!checkAdminPerms(player, split)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
            } else {
                // Mod commands
                if (!checkModPerms(player, split)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
            }
        }
    }
    // Island name (can have spaces)
    if (split.length > 1 && split[0].equalsIgnoreCase("name")) {
        final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
        // plugin.getLogger().info("DEBUG: console player info UUID = "
        // + playerUUID);
        if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            return true;
        } else {
            if (split.length == 2) {
                // Say the island name
                sender.sendMessage(plugin.getGrid().getIslandName(playerUUID));
            } else {
                String name = split[2];
                for (int i = 3; i < split.length; i++) {
                    name = name + " " + split[i];
                }
                if (name.length() < Settings.minNameLength) {
                    sender.sendMessage(ChatColor.RED + (plugin.myLocale().errorTooShort).replace("[length]",
                            String.valueOf(Settings.minNameLength)));
                    return true;
                }
                if (name.length() > Settings.maxNameLength) {
                    sender.sendMessage(ChatColor.RED + (plugin.myLocale().errorTooLong).replace("[length]",
                            String.valueOf(Settings.maxNameLength)));
                    return true;
                }
                plugin.getGrid().setIslandName(playerUUID, ChatColor.translateAlternateColorCodes('&', name));
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().generalSuccess);
            }
            return true;
        }
    }

    // Check for zero parameters e.g., /asadmin
    switch (split.length) {
    case 0:
        help(sender, label);
        return true;
    case 1:
        if (split[0].equalsIgnoreCase("setdeaths")) {
            sender.sendMessage(ChatColor.YELLOW + label + " setdeaths <player> <number>:" + ChatColor.WHITE
                    + " " + plugin.myLocale().adminHelpsetDeaths);
            return true;
        } else if (split[0].equalsIgnoreCase("settingsreset")) {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().adminHelpSettingsReset);
            return true;
        } else if (Settings.teamChat && split[0].equalsIgnoreCase("spy")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "mod.spy") || player.isOp()) {
                if (plugin.getChatListener().toggleSpy(player.getUniqueId())) {
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale().teamChatStatusOn);
                } else {
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale().teamChatStatusOff);
                }
                return true;
            }
        } else if (split[0].equalsIgnoreCase("lock")) {
            // Just /asadmin lock
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            Island island = plugin.getGrid().getIslandAt(player.getLocation());
            // Check if island exists
            if (island == null) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNotOnIsland);
                return true;
            } else {
                Player owner = plugin.getServer().getPlayer(island.getOwner());
                if (island.isLocked()) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().lockUnlocking);
                    island.setLocked(false);
                    if (owner != null) {
                        owner.sendMessage(plugin.myLocale(owner.getUniqueId()).adminLockadminUnlockedIsland);
                    } else {
                        plugin.getMessages().setMessage(island.getOwner(),
                                plugin.myLocale(island.getOwner()).adminLockadminUnlockedIsland);
                    }
                } else {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().lockLocking);
                    island.setLocked(true);
                    if (owner != null) {
                        owner.sendMessage(plugin.myLocale(owner.getUniqueId()).adminLockadminLockedIsland);
                    } else {
                        plugin.getMessages().setMessage(island.getOwner(),
                                plugin.myLocale(island.getOwner()).adminLockadminLockedIsland);
                    }
                }
                return true;
            }
        } else
        // Find farms
        if (split[0].equalsIgnoreCase("topbreeders")) {
            // Go through each island and find how many farms there are
            sender.sendMessage(plugin.myLocale().adminTopBreedersFinding);
            //TreeMap<Integer, List<UUID>> topEntityIslands = new TreeMap<Integer, List<UUID>>();
            // Generate the stats
            sender.sendMessage(plugin.myLocale().adminTopBreedersChecking.replace("[number]",
                    String.valueOf(plugin.getGrid().getOwnershipMap().size())));
            // Try just finding every entity
            final List<Entity> allEntities = ASkyBlock.getIslandWorld().getEntities();
            final World islandWorld = ASkyBlock.getIslandWorld();
            final World netherWorld = ASkyBlock.getNetherWorld();
            plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable() {

                @Override
                public void run() {
                    Map<UUID, Multiset<EntityType>> result = new HashMap<UUID, Multiset<EntityType>>();
                    // Find out where the entities are
                    for (Entity entity : allEntities) {
                        //System.out.println("DEBUG " + entity.getType().toString());
                        if (entity.getLocation().getWorld().equals(islandWorld)
                                || entity.getLocation().getWorld().equals(netherWorld)) {
                            //System.out.println("DEBUG in world");
                            if (entity instanceof Creature && !(entity instanceof Player)) {
                                //System.out.println("DEBUG creature");
                                // Find out where it is
                                Island island = plugin.getGrid().getIslandAt(entity.getLocation());
                                if (island != null && !island.isSpawn()) {
                                    //System.out.println("DEBUG on island");
                                    // Add to result
                                    UUID owner = island.getOwner();
                                    Multiset<EntityType> count = result.get(owner);
                                    if (count == null) {
                                        // New entry for owner
                                        //System.out.println("DEBUG new entry for owner");
                                        count = HashMultiset.create();
                                    }
                                    count.add(entity.getType());
                                    result.put(owner, count);
                                }
                            }
                        }
                    }
                    // Sort by the number of entities on each island
                    TreeMap<Integer, List<UUID>> topEntityIslands = new TreeMap<Integer, List<UUID>>();
                    for (Entry<UUID, Multiset<EntityType>> entry : result.entrySet()) {
                        int numOfEntities = entry.getValue().size();
                        List<UUID> players = topEntityIslands.get(numOfEntities);
                        if (players == null) {
                            players = new ArrayList<UUID>();
                        }
                        players.add(entry.getKey());
                        topEntityIslands.put(numOfEntities, players);
                    }
                    final TreeMap<Integer, List<UUID>> topBreeders = topEntityIslands;
                    final Map<UUID, Multiset<EntityType>> finalResult = result;
                    // Now display results in sync thread
                    plugin.getServer().getScheduler().runTask(plugin, new Runnable() {

                        @Override
                        public void run() {
                            if (topBreeders.isEmpty()) {
                                sender.sendMessage(plugin.myLocale().adminTopBreedersNothing);
                                return;
                            }
                            int rank = 1;
                            // Display, largest first
                            for (int numOfEntities : topBreeders.descendingKeySet()) {
                                // Only bother if there's more that 5 animals
                                if (numOfEntities > 5) {
                                    // There can be multiple owners in the same position
                                    List<UUID> owners = topBreeders.get(numOfEntities);
                                    // Go through the owners one by one
                                    for (UUID owner : owners) {
                                        sender.sendMessage("#" + rank + " " + plugin.getPlayers().getName(owner)
                                                + " = " + numOfEntities);
                                        String content = "";
                                        Multiset<EntityType> entityCount = finalResult.get(owner);
                                        for (EntityType entity : entityCount.elementSet()) {
                                            int num = entityCount.count(entity);
                                            String color = ChatColor.GREEN.toString();
                                            if (num > 10 && num <= 20) {
                                                color = ChatColor.YELLOW.toString();
                                            } else if (num > 20 && num <= 40) {
                                                color = ChatColor.GOLD.toString();
                                            } else if (num > 40) {
                                                color = ChatColor.RED.toString();
                                            }
                                            content += Util.prettifyText(entity.toString()) + " x " + color
                                                    + num + ChatColor.WHITE + ", ";
                                        }
                                        int lastComma = content.lastIndexOf(",");
                                        // plugin.getLogger().info("DEBUG: last comma " +
                                        // lastComma);
                                        if (lastComma > 0) {
                                            content = content.substring(0, lastComma);
                                        }
                                        sender.sendMessage("  " + content);

                                    }
                                    rank++;
                                    if (rank > 10) {
                                        break;
                                    }
                                }
                            }
                            // If we didn't show anything say so
                            if (rank == 1) {
                                sender.sendMessage(plugin.myLocale().adminTopBreedersNothing);
                            }

                        }
                    });

                }
            });
            return true;
        }
        // Delete island
        if (split[0].equalsIgnoreCase("deleteisland")) {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().adminDeleteIslandError);
            return true;
        }
        // Set spawn
        if (split[0].equalsIgnoreCase("setspawn")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            player = (Player) sender;
            // Island spawn must be in the island world
            if (!player.getLocation().getWorld().getName().equals(Settings.worldName)) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorWrongWorld);
                return true;
            }
            // The island location is calculated based on the grid
            Location closestIsland = getClosestIsland(player.getLocation());
            Island oldSpawn = plugin.getGrid().getSpawn();
            Island newSpawn = plugin.getGrid().getIslandAt(closestIsland);
            if (newSpawn != null && newSpawn.isSpawn()) {
                // Already spawn, so just set the world spawn coords
                plugin.getGrid().setSpawnPoint(player.getLocation());
                //ASkyBlock.getIslandWorld().setSpawnLocation(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminSetSpawnset);
                return true;
            }
            // Space otherwise occupied - find if anyone owns it
            if (newSpawn != null && newSpawn.getOwner() != null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnownedBy.replace("[name]",
                        plugin.getPlayers().getName(newSpawn.getOwner())));
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnmove);
                return true;
            }
            if (oldSpawn != null) {
                sender.sendMessage(ChatColor.GOLD
                        + "Changing spawn island location. Warning: old spawn island location at "
                        + oldSpawn.getCenter().getBlockX() + "," + oldSpawn.getCenter().getBlockZ()
                        + " will be at risk of being overwritten with new islands. Recommend to clear that old area.");
                plugin.getGrid().deleteSpawn();
            }
            // New spawn site is free, so make it official
            if (newSpawn == null) {
                // Make the new spawn
                newSpawn = plugin.getGrid().addIsland(closestIsland.getBlockX(), closestIsland.getBlockZ(),
                        Environment.NORMAL);
            }
            plugin.getGrid().setSpawn(newSpawn);
            plugin.getGrid().setSpawnPoint(player.getLocation());
            //ASkyBlock.getIslandWorld().setSpawnLocation(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
            player.sendMessage(ChatColor.GREEN + plugin.myLocale().adminSetSpawnsetting.replace("[location]",
                    player.getLocation().getBlockX() + "," + player.getLocation().getBlockZ()));
            player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawncenter.replace("[location]",
                    newSpawn.getCenter().getBlockX() + "," + newSpawn.getCenter().getBlockZ()));
            player.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawnlimits.replace("[min]",
                    newSpawn.getMinX() + "," + newSpawn.getMinZ())).replace("[max]",
                            (newSpawn.getMinX() + newSpawn.getIslandDistance() - 1) + ","
                                    + (newSpawn.getMinZ() + newSpawn.getIslandDistance() - 1)));
            player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnrange.replace("[number]",
                    String.valueOf(newSpawn.getProtectionSize())));
            player.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawncoords.replace("[min]",
                    newSpawn.getMinProtectedX() + ", " + newSpawn.getMinProtectedZ())).replace("[max]",
                            +(newSpawn.getMinProtectedX() + newSpawn.getProtectionSize() - 1) + ", "
                                    + (newSpawn.getMinProtectedZ() + newSpawn.getProtectionSize() - 1)));
            if (newSpawn.isLocked()) {
                player.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnlocked);
            }
            return true;
        } else if (split[0].equalsIgnoreCase("info") || split[0].equalsIgnoreCase("setrange")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            Location closestIsland = getClosestIsland(((Player) sender).getLocation());
            if (closestIsland == null) {
                sender.sendMessage(ChatColor.RED + "Sorry, could not find an island. Move closer?");
                return true;
            }
            Island island = plugin.getGrid().getIslandAt(closestIsland);
            if (island != null && island.isSpawn()) {
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminInfotitle);
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawncenter.replace(
                        "[location]", island.getCenter().getBlockX() + "," + island.getCenter().getBlockZ()));
                sender.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawnlimits.replace("[min]",
                        island.getMinX() + "," + island.getMinZ())).replace("[max]",
                                (island.getMinX() + island.getIslandDistance() - 1) + ","
                                        + (island.getMinZ() + island.getIslandDistance() - 1)));
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnrange.replace("[number]",
                        String.valueOf(island.getProtectionSize())));
                sender.sendMessage(ChatColor.YELLOW + (plugin.myLocale().adminSetSpawncoords.replace("[min]",
                        island.getMinProtectedX() + ", " + island.getMinProtectedZ())).replace("[max]",
                                +(island.getMinProtectedX() + island.getProtectionSize() - 1) + ", "
                                        + (island.getMinProtectedZ() + island.getProtectionSize() - 1)));
                if (island.isLocked()) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnlocked);
                }
                return true;
            }
            if (island == null) {
                plugin.getLogger().info("Get island at was null" + closestIsland);
            }
            UUID target = plugin.getPlayers().getPlayerFromIslandLocation(closestIsland);
            if (target == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminInfounowned);
                return true;
            }
            showInfo(target, sender);
            return true;
        } else if (split[0].equalsIgnoreCase("resetsign")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            player = (Player) sender;
            if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "mod.signadmin") && !player.isOp()) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                return true;
            }
            // Find out whether the player is looking at a warp sign
            // Look at what the player was looking at
            BlockIterator iter = new BlockIterator(player, 10);
            Block lastBlock = iter.next();
            while (iter.hasNext()) {
                lastBlock = iter.next();
                if (lastBlock.getType() == Material.AIR)
                    continue;
                break;
            }
            if (!lastBlock.getType().equals(Material.SIGN_POST)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminResetSignNoSign);
                return true;
            }
            // Check if it is a warp sign
            Sign sign = (Sign) lastBlock.getState();
            sender.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).adminResetSignFound);
            // Find out whose island this is
            // plugin.getLogger().info("DEBUG: closest bedrock: " +
            // closestBedRock.toString());
            UUID target = plugin.getPlayers().getPlayerFromIslandLocation(player.getLocation());
            if (target == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminInfounowned);
                return true;
            }
            if (plugin.getWarpSignsListener().addWarp(target, lastBlock.getLocation())) {
                // Change sign color to green
                sign.setLine(0, ChatColor.GREEN + plugin.myLocale().warpswelcomeLine);
                sign.update();
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).adminResetSignRescued
                        .replace("[name]", plugin.getPlayers().getName(target)));
                return true;
            }
            // Warp already exists
            sender.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminResetSignErrorExists
                    .replace("[name]", plugin.getWarpSignsListener().getWarpOwner(lastBlock.getLocation())));
            return true;

        } else if (split[0].equalsIgnoreCase("reload")) {
            plugin.reloadConfig();
            plugin.loadPluginConfig();
            plugin.getChallenges().reloadChallengeConfig();
            if (Settings.useEconomy && VaultHelper.setupEconomy()) {
                ControlPanel.loadShop();
            } else {
                Settings.useEconomy = false;
            }
            ControlPanel.loadControlPanel();
            if (Settings.updateCheck) {
                plugin.checkUpdates();
            } else {
                plugin.setUpdateCheck(null);
            }
            plugin.getIslandCmd().loadSchematics();
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().reloadconfigReloaded);
            return true;
        } else if (split[0].equalsIgnoreCase("topten")) {
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminTopTengenerating);
            TopTen.topTenCreate(sender);
            return true;
        } else if (split[0].equalsIgnoreCase("purge")) {
            if (purgeFlag) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgealreadyRunning);
                return true;
            }
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgeusage.replace("[label]", label));
            return true;
        } else if (split[0].equalsIgnoreCase("confirm")) {
            if (!confirmReq) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().confirmerrorTimeLimitExpired);
                return true;
            } else {
                // Tell purge routine to go
                confirmOK = true;
                confirmReq = false;
            }
            return true;
        } else
        // clearesetall - clears all player resets
        if (split[0].equalsIgnoreCase("clearresetall")) {
            if (asyncPending) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorCommandNotReady);
                return true;
            }
            // Do online players first
            plugin.getPlayers().clearResets(Settings.resetLimit);
            // Do offline players
            final File playerFolder = plugin.getPlayersFolder();
            // Set the pending flag
            asyncPending = true;
            // Check against player files
            plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable() {

                @Override
                public void run() {
                    //System.out.println("DEBUG: Running async task");
                    int done = 0;
                    // Check files against potentialUnowned
                    FilenameFilter ymlFilter = new FilenameFilter() {
                        @Override
                        public boolean accept(File dir, String name) {
                            String lowercaseName = name.toLowerCase();
                            if (lowercaseName.endsWith(".yml")) {
                                return true;
                            } else {
                                return false;
                            }
                        }
                    };
                    for (File file : playerFolder.listFiles(ymlFilter)) {
                        List<String> playerFileContents = new ArrayList<String>();
                        done++;
                        try {
                            Scanner scanner = new Scanner(file);
                            while (scanner.hasNextLine()) {
                                final String lineFromFile = scanner.nextLine();
                                if (lineFromFile.contains("resetsLeft:")) {
                                    playerFileContents.add("resetsLeft: " + Settings.resetLimit);
                                } else {
                                    playerFileContents.add(lineFromFile);
                                }
                            }
                            scanner.close();
                            // Write file
                            FileWriter writer = new FileWriter(file);
                            for (String str : playerFileContents) {
                                writer.write(str + "\n");
                            }
                            writer.close();
                            if (done % 500 == 0) {
                                final int update = done;
                                plugin.getServer().getScheduler().runTask(plugin, new Runnable() {

                                    @Override
                                    public void run() {
                                        // Tell player
                                        sender.sendMessage(ChatColor.GREEN + plugin.myLocale().clearedResetLimit
                                                + " [" + update + " players]...");
                                    }
                                });
                            }
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    //System.out.println("DEBUG: scanning done");
                    asyncPending = false;
                    sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().clearedResetLimit + " [" + done
                            + " players] completed.");
                }
            });
            return true;
        } else {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            return false;
        }
    case 2:
        if (!plugin.getServer().getVersion().contains("(MC: 1.7")) {
            if (split[0].equalsIgnoreCase("level")) {
                // Convert name to a UUID
                final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
                // plugin.getLogger().info("DEBUG: console player info UUID = "
                // + playerUUID);
                if (playerUUID == null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                    return true;
                } else {
                    if (sender instanceof Player) {
                        plugin.getIslandCmd().calculateIslandLevel(sender, playerUUID, false);
                    } else {
                        plugin.getIslandCmd().calculateIslandLevel(sender, playerUUID, true);
                    }
                    return true;
                }
            }
        }
        if (split[0].equalsIgnoreCase("settingsreset")) {
            if (split[1].equalsIgnoreCase("confirm")) {
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().settingsResetInProgress);
                plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable() {

                    @Override
                    public void run() {
                        for (Collection<Island> islands : plugin.getGrid().getOwnedIslands().values()) {
                            for (Island island : islands) {
                                island.setDefaults();
                            }
                        }
                        for (Island island : plugin.getGrid().getUnownedIslands().values()) {
                            island.setDefaults();
                        }
                        sender.sendMessage(ChatColor.GREEN + plugin.myLocale().settingsResetDone);
                        plugin.getGrid().saveGrid();
                    }
                });
                return true;
            } else {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminHelpSettingsReset);
                return true;
            }
        }
        // Resetsign <player> - makes a warp sign for player
        if (split[0].equalsIgnoreCase("resetsign")) {
            // Find the closest island
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUseInGame);
                return true;
            }
            Player p = (Player) sender;
            if (!VaultHelper.checkPerm(p, Settings.PERMPREFIX + "mod.signadmin") && !p.isOp()) {
                p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).errorNoPermission);
                return true;
            }
            // Convert target name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID, ((Player) sender).getWorld().getEnvironment())
                        && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Has an island
                // Find out whether the player is looking at a warp sign
                // Look at what the player was looking at
                BlockIterator iter = new BlockIterator(p, 10);
                Block lastBlock = iter.next();
                while (iter.hasNext()) {
                    lastBlock = iter.next();
                    if (lastBlock.getType() == Material.AIR)
                        continue;
                    break;
                }
                // Check if it is a sign
                if (!lastBlock.getType().equals(Material.SIGN_POST)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).adminResetSignNoSign);
                    return true;
                }
                Sign sign = (Sign) lastBlock.getState();
                // Check if the sign is within the right island boundary
                Location islandLoc = plugin.getPlayers().getIslandLocation(playerUUID);
                if (!plugin.getGrid().getIslandAt(islandLoc).inIslandSpace(sign.getLocation())) {
                    p.sendMessage(
                            ChatColor.RED + plugin.myLocale(p.getUniqueId()).adminSetHomeNotOnPlayersIsland);
                } else {
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminResetSignFound);
                    // Find out if this player is allowed to have a sign on this island
                    if (plugin.getWarpSignsListener().addWarp(playerUUID, lastBlock.getLocation())) {
                        // Change sign color to green
                        sign.setLine(0, ChatColor.GREEN + plugin.myLocale().warpswelcomeLine);
                        sign.update();
                        p.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminResetSignRescued
                                .replace("[name]", plugin.getPlayers().getName(playerUUID)));
                        return true;
                    }
                    // Warp already exists
                    sender.sendMessage(ChatColor.RED
                            + plugin.myLocale(p.getUniqueId()).adminResetSignErrorExists.replace("[name]",
                                    plugin.getWarpSignsListener().getWarpOwner(lastBlock.getLocation())));
                }
            }
            return true;
        }
        // Delete the island you are on
        else if (split[0].equalsIgnoreCase("deleteisland")) {
            if (!split[1].equalsIgnoreCase("confirm")) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminDeleteIslandError);
                return true;
            }
            // Get the island I am on
            Island island = plugin.getGrid().getIslandAt(((Player) sender).getLocation());
            if (island == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminDeleteIslandnoid);
                return true;
            }
            // Try to get the owner of this island
            UUID owner = island.getOwner();
            String name = "unknown";
            if (owner != null) {
                name = plugin.getPlayers().getName(owner);
                sender.sendMessage(
                        ChatColor.RED + plugin.myLocale().adminSetSpawnownedBy.replace("[name]", name));
                sender.sendMessage(
                        ChatColor.RED + plugin.myLocale().adminDeleteIslanduse.replace("[name]", name));
                return true;
            } else {
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().deleteremoving.replace("[name]", name));
                deleteIslands(island, sender);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("resetname")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID, ((Player) sender).getWorld().getEnvironment())
                        && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Has an island
                plugin.getGrid().setIslandName(playerUUID, null);
                sender.sendMessage(plugin.myLocale().generalSuccess);
            }
            return true;
        } else if (split[0].equalsIgnoreCase("resethome")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID, ((Player) sender).getWorld().getEnvironment())
                        && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Has an island
                Location safeHome = plugin.getGrid().getSafeHomeLocation(playerUUID, 1);
                if (safeHome == null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetHomeNoneFound);
                } else {
                    plugin.getPlayers().setHomeLocation(playerUUID, safeHome);
                    sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminSetHomeHomeSet.replace(
                            "[location]",
                            safeHome.getBlockX() + ", " + safeHome.getBlockY() + "," + safeHome.getBlockZ()));
                }
            }
            return true;
        } else if (split[0].equalsIgnoreCase("sethome")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
            } else {
                // Check if this player has an island
                if (!plugin.getPlayers().hasIsland(playerUUID, player.getWorld().getEnvironment())
                        && !plugin.getPlayers().inTeam(playerUUID)) {
                    // No island
                    player.sendMessage(
                            ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIslandOther);
                    return true;
                }
                // Has an island
                Location islandLoc = plugin.getPlayers().getIslandLocation(playerUUID);
                // Check the player is within the island boundaries
                if (!plugin.getGrid().getIslandAt(islandLoc).inIslandSpace(player.getLocation())) {
                    player.sendMessage(ChatColor.RED
                            + plugin.myLocale(player.getUniqueId()).adminSetHomeNotOnPlayersIsland);
                } else {
                    // Check that the location is safe
                    if (!GridManager.isSafeLocation(player.getLocation())) {
                        // Not safe
                        player.sendMessage(
                                ChatColor.RED + plugin.myLocale(player.getUniqueId()).adminSetHomeNoneFound);
                    } else {
                        // Success
                        plugin.getPlayers().setHomeLocation(playerUUID, player.getLocation());
                        player.sendMessage(
                                ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).adminSetHomeHomeSet
                                        .replace("[location]",
                                                player.getLocation().getBlockX() + ", "
                                                        + player.getLocation().getBlockY() + ","
                                                        + player.getLocation().getBlockZ()));
                    }
                }
            }
            return true;
        } else
        // Set protection for the island the player is on
        if (split[0].equalsIgnoreCase("setrange")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                return true;
            }
            player = (Player) sender;
            UUID playerUUID = player.getUniqueId();
            Island island = plugin.getGrid().getIslandAt(player.getLocation());
            // Check if island exists
            if (island == null) {
                player.sendMessage(ChatColor.RED + plugin.myLocale().errorNotOnIsland);
                return true;
            } else {
                int newRange = 10;
                int maxRange = Settings.islandDistance;
                // If spawn do something different
                if (island.isSpawn()) {
                    try {
                        newRange = Integer.valueOf(split[1]);
                    } catch (Exception e) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeInvalid);
                        return true;
                    }
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).adminSetRangeSet
                            .replace("[number]", String.valueOf(newRange)));
                    if (newRange > maxRange) {
                        player.sendMessage(ChatColor.RED + "" + ChatColor.BOLD
                                + plugin.myLocale(playerUUID).adminSetRangeWarning.replace("[max]",
                                        String.valueOf(maxRange)));
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeWarning2);
                    }
                    island.setProtectionSize(newRange);
                    player.sendMessage(
                            ChatColor.YELLOW + plugin.myLocale().adminSetSpawncenter.replace("[location]",
                                    island.getCenter().getBlockX() + "," + island.getCenter().getBlockZ()));
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnlimits
                            .replace("[min]", island.getMinX() + "," + island.getMinZ())
                            .replace("[max]", (island.getMinX() + island.getIslandDistance() - 1) + ","
                                    + (island.getMinZ() + island.getIslandDistance() - 1)));
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawnrange
                            .replace("[number]", String.valueOf(island.getProtectionSize())));
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale().adminSetSpawncoords
                            .replace("[min]", island.getMinProtectedX() + ", " + island.getMinProtectedZ())
                            .replace("[max]", +(island.getMinProtectedX() + island.getProtectionSize() - 1)
                                    + ", " + (island.getMinProtectedZ() + island.getProtectionSize() - 1)));
                    if (island.isLocked()) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale().adminSetSpawnlocked);
                    }
                } else {
                    if (!plugin.getConfig().getBoolean("island.overridelimit")) {
                        maxRange -= 16;
                    }
                    try {
                        newRange = Integer.valueOf(split[1]);
                    } catch (Exception e) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeInvalid
                                + " " + plugin.myLocale(playerUUID).adminSetRangeTip.replace("[max]",
                                        String.valueOf(maxRange)));
                        return true;
                    }
                    if (newRange < 10 || newRange > maxRange) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).adminSetRangeInvalid
                                + " " + plugin.myLocale(playerUUID).adminSetRangeTip.replace("[max]",
                                        String.valueOf(maxRange)));
                        return true;
                    }
                    island.setProtectionSize(newRange);
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).adminSetRangeSet
                            .replace("[number]", String.valueOf(newRange)));
                    showInfo(island.getOwner(), sender);
                }
                return true;
            }
        }
        if (split[0].equalsIgnoreCase("purge")) {
            // PURGE Command
            // Check for "allow" or "disallow" flags
            // Protect island from purging
            if (split[1].equalsIgnoreCase("allow") || split[1].equalsIgnoreCase("disallow")) {
                // Find the closest island
                if (!(sender instanceof Player)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminLockerrorInGame);
                    return true;
                }
                Player p = (Player) sender;
                // Island spawn must be in the island world
                if (!p.getLocation().getWorld().equals(ASkyBlock.getIslandWorld())
                        && !p.getLocation().getWorld().equals(ASkyBlock.getNetherWorld())) {
                    p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).errorWrongWorld);
                    return true;
                }
                Island island = plugin.getGrid().getIslandAt(p.getLocation());
                if (island == null) {
                    p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).errorNoIslandOther);
                    return true;
                }
                if (split[1].equalsIgnoreCase("allow")) {
                    island.setPurgeProtected(true);
                } else {
                    island.setPurgeProtected(false);
                }
                if (island.isPurgeProtected()) {
                    p.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminAllowPurge);
                } else {
                    p.sendMessage(ChatColor.GREEN + plugin.myLocale(p.getUniqueId()).adminPreventPurge);
                }
                return true;
            }

            // Purge runs in the background so if one is already running
            // this flag stops a repeat
            if (purgeFlag) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgealreadyRunning);
                return true;
            }

            if (split[1].equalsIgnoreCase("unowned")) {
                countUnowned(sender);
                return true;
            }
            // Set the flag
            purgeFlag = true;
            // See if this purge unowned

            // Convert days to hours - no other limit checking?
            final int time;
            try {
                time = Integer.parseInt(split[1]) * 24;
            } catch (Exception e) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgeusage.replace("[label]", label));
                purgeFlag = false;
                return true;
            }
            sender.sendMessage(
                    ChatColor.YELLOW + plugin.myLocale().purgecalculating.replace("[time]", split[1]));
            // Check who has not been online since the time
            for (Entry<UUID, Collection<Island>> entry : plugin.getGrid().getOwnershipMap().asMap()
                    .entrySet()) {
                for (Island island : entry.getValue()) {
                    if (entry.getKey() != null && !island.isPurgeProtected()) {
                        if (Bukkit.getOfflinePlayer(entry.getKey()).hasPlayedBefore()) {
                            long offlineTime = Bukkit.getOfflinePlayer(entry.getKey()).getLastPlayed();
                            offlineTime = (System.currentTimeMillis() - offlineTime) / 3600000L;
                            if (offlineTime > time) {
                                //if (plugin.getPlayers().getIslandLevel(entry.getKey()) < Settings.abandonedIslandLevel) {
                                // Check level later
                                removeList.add(entry.getKey());
                                //}
                            }
                        } else {
                            removeList.add(entry.getKey());
                        }
                    }
                }
                //plugin.getLogger().info("UUID = " + entry.getKey());
                // Only do this if it isn't protected
            }
            if (removeList.isEmpty()) {
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgenoneFound);
                purgeFlag = false;
                return true;
            }
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgethisWillRemove
                    .replace("[number]", String.valueOf(removeList.size()))
                    .replace("[level]", String.valueOf(Settings.abandonedIslandLevel)));
            sender.sendMessage(ChatColor.RED + plugin.myLocale().purgewarning);
            sender.sendMessage(ChatColor.RED + plugin.myLocale().purgetypeConfirm.replace("[label]", label));
            confirmReq = true;
            confirmOK = false;
            confirmTimer = 0;
            new BukkitRunnable() {
                @Override
                public void run() {
                    // This waits for 10 seconds and if no
                    // confirmation received, then it
                    // cancels
                    if (confirmTimer++ > 10) {
                        // Ten seconds is up!
                        confirmReq = false;
                        confirmOK = false;
                        purgeFlag = false;
                        removeList.clear();
                        sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgepurgeCancelled);
                        this.cancel();
                    } else if (confirmOK) {
                        // Set up a repeating task to run every 2
                        // seconds to remove
                        // islands one by one and then cancel when
                        // done
                        final int total = removeList.size();
                        new BukkitRunnable() {
                            @Override
                            public void run() {
                                if (removeList.isEmpty() && purgeFlag) {
                                    purgeFlag = false;
                                    sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().purgefinished);
                                    this.cancel();
                                }

                                if (removeList.size() > 0 && purgeFlag) {
                                    // Check if the player is online
                                    if (plugin.getServer().getPlayer(removeList.get(0)) == null) {
                                        //plugin.getLogger().info("DEBUG: player is offline");
                                        // Check the level
                                        if (plugin.getPlayers().getIslandLevel(
                                                removeList.get(0)) < Settings.abandonedIslandLevel) {
                                            sender.sendMessage(ChatColor.YELLOW + "["
                                                    + (total - removeList.size() + 1) + "/" + total + "] "
                                                    + plugin.myLocale().purgeremovingName.replace("[name]",
                                                            plugin.getPlayers().getName(removeList.get(0))));
                                            plugin.deletePlayerIsland(removeList.get(0), true,
                                                    plugin.getServer().getPlayer(removeList.get(0)).getWorld()
                                                            .getEnvironment());
                                        }
                                    } else {
                                        sender.sendMessage(
                                                ChatColor.YELLOW + "[" + (total - removeList.size() + 1) + "/"
                                                        + total + "] " + "Skipping online player...");
                                    }
                                    removeList.remove(0);
                                }
                                //sender.sendMessage("Now waiting...");
                            }
                        }.runTaskTimer(plugin, 0L, 20L);
                        confirmReq = false;
                        confirmOK = false;
                        this.cancel();
                    }
                }
            }.runTaskTimer(plugin, 0L, 40L);
            return true;
        } else if (split[0].equalsIgnoreCase("lock")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                Island island = plugin.getGrid().getIsland(playerUUID,
                        plugin.getServer().getPlayer(playerUUID).getWorld().getEnvironment());
                if (island != null) {
                    Player owner = plugin.getServer().getPlayer(island.getOwner());
                    if (island.isLocked()) {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().lockUnlocking);
                        island.setLocked(false);
                        if (owner != null) {
                            owner.sendMessage(
                                    plugin.myLocale(owner.getUniqueId()).adminLockadminUnlockedIsland);
                        } else {
                            plugin.getMessages().setMessage(island.getOwner(),
                                    plugin.myLocale(island.getOwner()).adminLockadminUnlockedIsland);
                        }
                    } else {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().lockLocking);
                        island.setLocked(true);
                        if (owner != null) {
                            owner.sendMessage(plugin.myLocale(owner.getUniqueId()).adminLockadminLockedIsland);
                        } else {
                            plugin.getMessages().setMessage(island.getOwner(),
                                    plugin.myLocale(island.getOwner()).adminLockadminLockedIsland);
                        }
                    }
                } else {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                }
                return true;
            }
        } else if (split[0].equalsIgnoreCase("setdeaths")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                sender.sendMessage(ChatColor.GREEN + plugin.getPlayers().getName(playerUUID) + " "
                        + plugin.getPlayers().getDeaths(playerUUID) + " " + plugin.myLocale().deaths);
                sender.sendMessage(ChatColor.YELLOW + label + " setdeaths <player> <number>:" + ChatColor.WHITE
                        + " " + plugin.myLocale().adminHelpsetDeaths);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("clearreset")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                plugin.getPlayers().setResetsLeft(playerUUID, Settings.resetLimit);
                sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().clearedResetLimit + " ["
                        + Settings.resetLimit + "]");
                return true;
            }
        } else if (split[0].equalsIgnoreCase("tp")) {
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
                return true;
            }
            player = (Player) sender;
            // Convert name to a UUID
            final UUID targetUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(targetUUID)) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                return true;
            } else {
                if (plugin.getPlayers().hasIsland(targetUUID, player.getWorld().getEnvironment())
                        || plugin.getPlayers().inTeam(targetUUID)) {
                    // Teleport to the over world
                    Location warpSpot = plugin.getPlayers().getIslandLocation(targetUUID).toVector()
                            .toLocation(ASkyBlock.getIslandWorld());
                    String failureMessage = ChatColor.RED
                            + plugin.myLocale(player.getUniqueId()).adminTpManualWarp.replace("[location]",
                                    warpSpot.getBlockX() + " " + warpSpot.getBlockY() + " "
                                            + warpSpot.getBlockZ());
                    // Try the player's home first
                    Location home = plugin.getPlayers().getHomeLocation(targetUUID);
                    plugin.getGrid();
                    if (home != null && home.getWorld().equals(ASkyBlock.getIslandWorld())
                            && GridManager.isSafeLocation(home)) {
                        player.teleport(home);
                        return true;
                    }
                    // Other wise, go to a safe spot
                    new SafeSpotTeleport(plugin, player, warpSpot, failureMessage);
                    return true;
                }
                sender.sendMessage(plugin.myLocale().errorNoIslandOther);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("tpnether")) {
            if (!Settings.createNether || !Settings.newNether || ASkyBlock.getNetherWorld() == null) {
                return false;
            }
            if (!(sender instanceof Player)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
                return true;
            }
            player = (Player) sender;
            // Convert name to a UUID
            final UUID targetUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(targetUUID)) {
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                return true;
            } else {
                if (plugin.getPlayers().hasIsland(targetUUID, player.getWorld().getEnvironment())
                        || plugin.getPlayers().inTeam(targetUUID)) {
                    // Teleport to the nether
                    Location warpSpot = plugin.getPlayers().getIslandLocation(targetUUID).toVector()
                            .toLocation(ASkyBlock.getNetherWorld());
                    String failureMessage = ChatColor.RED
                            + plugin.myLocale(player.getUniqueId()).adminTpManualWarp.replace("[location]",
                                    warpSpot.getBlockX() + " " + warpSpot.getBlockY() + " "
                                            + warpSpot.getBlockZ());
                    // Try the player's home first
                    Location home = plugin.getPlayers().getHomeLocation(targetUUID);
                    plugin.getGrid();
                    if (home != null && home.getWorld().equals(ASkyBlock.getNetherWorld())
                            && GridManager.isSafeLocation(home)) {
                        player.teleport(home);
                        return true;
                    }
                    new SafeSpotTeleport(plugin, player, warpSpot, failureMessage);
                    return true;
                }
                sender.sendMessage(plugin.myLocale().errorNoIslandOther);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("delete")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                // This now deletes the player and cleans them up even if
                // they don't have an island
                sender.sendMessage(
                        ChatColor.YELLOW + plugin.myLocale().deleteremoving.replace("[name]", split[1]));
                // If they are online and in ASkyBlock then delete their
                // stuff too
                Player target = plugin.getServer().getPlayer(playerUUID);
                if (target != null) {
                    // Clear any coop inventories
                    // CoopPlay.getInstance().returnAllInventories(target);
                    // Remove any of the target's coop invitees and grab
                    // their stuff
                    CoopPlay.getInstance().clearMyInvitedCoops(target);
                    CoopPlay.getInstance().clearMyCoops(target);
                    plugin.resetPlayer(target);
                }
                // plugin.getLogger().info("DEBUG: deleting player");
                plugin.deletePlayerIsland(playerUUID, true, Environment.NETHER);
                plugin.deletePlayerIsland(playerUUID, true, Environment.NORMAL);

                return true;
            }
        } else if (split[0].equalsIgnoreCase("reserve")) {
            // Reserves a spot for the player's next island
            if (sender instanceof Player) {
                player = (Player) sender;
                // Convert name to a UUID
                final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
                if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                    return true;
                } else {
                    // Check the spot
                    Location islandLoc = plugin.getGrid().getClosestIsland(player.getLocation());
                    Island island = plugin.getGrid().getIslandAt(islandLoc);
                    if (island == null) {
                        // Empty spot, reserve it!
                        plugin.getIslandCmd().reserveLocation(playerUUID, islandLoc);
                        sender.sendMessage(ChatColor.GREEN + " [" + islandLoc.getBlockX() + ", "
                                + islandLoc.getBlockZ() + "] " + plugin.myLocale().generalSuccess);
                    } else {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().adminReserveIslandExists);
                    }
                    return true;
                }
            } else {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            }
            return true;
        } else if (split[0].equalsIgnoreCase("register")) {
            if (sender instanceof Player) {
                // Convert name to a UUID
                final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
                if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                    return true;
                } else {
                    if (adminSetPlayerIsland(sender, ((Player) sender).getLocation(), playerUUID)) {
                        sender.sendMessage(ChatColor.GREEN
                                + plugin.myLocale().registersettingIsland.replace("[name]", split[1]));
                        plugin.getGrid().saveGrid();
                    } else {
                        sender.sendMessage(ChatColor.RED + plugin.myLocale().registererrorBedrockNotFound);
                    }
                    return true;
                }
            } else {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            }
            return true;
        } else if (split[0].equalsIgnoreCase("unregister")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                if (plugin.getPlayers().inTeam(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminUnregisterOnTeam);
                    return true;
                }
                Location island = plugin.getPlayers().getIslandLocation(playerUUID);
                if (island == null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                    return true;
                }
                // Delete player, but keep blocks
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminUnregisterKeepBlocks
                        .replace("[location]", +plugin.getPlayers().getIslandLocation(playerUUID).getBlockX()
                                + "," + plugin.getPlayers().getIslandLocation(playerUUID).getBlockZ()));
                plugin.deletePlayerIsland(playerUUID, false, Environment.NORMAL);
                plugin.deletePlayerIsland(playerUUID, false, Environment.NETHER);
                plugin.getGrid().saveGrid();
                return true;
            }
        } else if (split[0].equalsIgnoreCase("info")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            // plugin.getLogger().info("DEBUG: console player info UUID = "
            // + playerUUID);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                showInfo(playerUUID, sender);
                return true;
            }
        } else if (split[0].equalsIgnoreCase("resetallchallenges")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            plugin.getPlayers().resetAllChallenges(playerUUID, true);
            sender.sendMessage(
                    ChatColor.YELLOW + plugin.myLocale().resetChallengessuccess.replace("[name]", split[1]));
            return true;
        } else {
            return false;
        }
    case 3:
        // Confirm purge unowned
        if (split[0].equalsIgnoreCase("purge")) {
            if (purgeFlag) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().purgealreadyRunning);
                return true;
            }
            // Check if this is purge unowned
            if (split[1].equalsIgnoreCase("unowned") && split[2].equalsIgnoreCase("confirm")) {
                if (!purgeUnownedConfirm) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().confirmerrorTimeLimitExpired);
                    return true;
                } else {
                    purgeUnownedConfirm = false;
                    // Purge the unowned islands
                    purgeUnownedIslands(sender);
                    return true;
                }
            }

        }
        // Set protection
        if (split[0].equalsIgnoreCase("setrange")) {
            // Convert name to a UUID
            UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            // Check if player exists
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            // Check if the target is in a team and if so, the leader needs to be adjusted
            if (plugin.getPlayers().inTeam(playerUUID)) {
                playerUUID = plugin.getPlayers().getTeamLeader(playerUUID);
            }
            // Get the range that this player has now
            Island island = plugin.getGrid().getIsland(playerUUID,
                    ((Player) sender).getWorld().getEnvironment());
            if (island == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIslandOther);
                return true;
            } else {
                int newRange = 0;
                int maxRange = Settings.islandDistance;
                if (!plugin.getConfig().getBoolean("island.overridelimit")) {
                    maxRange -= 16;
                }
                try {
                    newRange = Integer.valueOf(split[2]);
                } catch (Exception e) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetRangeInvalid + " "
                            + plugin.myLocale().adminSetRangeTip.replace("[max]", String.valueOf(maxRange)));

                    return true;
                }
                if (newRange < 10 || newRange > maxRange) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminSetRangeInvalid + " "
                            + plugin.myLocale().adminSetRangeTip.replace("[max]", String.valueOf(maxRange)));
                    return true;
                }
                island.setProtectionSize(newRange);
                sender.sendMessage(ChatColor.GREEN
                        + plugin.myLocale().adminSetRangeSet.replace("[number]", String.valueOf(newRange)));
                showInfo(playerUUID, sender);
                plugin.getGrid().saveGrid();
                return true;
            }
        } else if (split[0].equalsIgnoreCase("setdeaths")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                try {
                    int newDeaths = Integer.valueOf(split[2]);
                    int oldDeaths = plugin.getPlayers().getDeaths(playerUUID);
                    plugin.getPlayers().setDeaths(playerUUID, newDeaths);
                    sender.sendMessage(ChatColor.GREEN + plugin.getPlayers().getName(playerUUID) + " "
                            + oldDeaths + " >>> " + newDeaths + " " + plugin.myLocale().deaths);
                } catch (Exception e) {
                    sender.sendMessage(ChatColor.GREEN + plugin.getPlayers().getName(playerUUID) + " "
                            + plugin.getPlayers().getDeaths(playerUUID) + " " + plugin.myLocale().deaths);
                    sender.sendMessage(ChatColor.YELLOW + label + " setdeaths <player> <number>:"
                            + ChatColor.WHITE + " " + plugin.myLocale().adminHelpsetDeaths);
                    return true;
                }
                return true;
            }
        }
        // Change biomes
        if (split[0].equalsIgnoreCase("setbiome")) {
            // Convert name to a UUID
            UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            // Check if player exists
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            // Check if the target is in a team and if so, the leader
            if (plugin.getPlayers().inTeam(playerUUID)) {
                playerUUID = plugin.getPlayers().getTeamLeader(playerUUID);
            }
            Island island = plugin.getGrid().getIsland(playerUUID,
                    ((Player) sender).getLocation().getWorld().getEnvironment());
            if (island == null) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoIsland);
                return true;
            }
            // Check if biome is valid
            Biome biome = null;
            String biomeName = split[2].toUpperCase();
            try {
                biome = Biome.valueOf(biomeName);
                biomeName = biome.name();
                if (!plugin.getConfig().contains("biomes." + biomeName)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().biomeUnknown);
                    // Doing it this way ensures that only valid biomes are
                    // shown
                    for (Biome b : Biome.values()) {
                        if (plugin.getConfig().contains("biomes." + b.name())) {
                            sender.sendMessage(b.name());
                        }
                    }
                    return true;
                }
                // Get friendly name
                biomeName = plugin.getConfig().getString("biomes." + biomeName + ".friendlyname",
                        Util.prettifyText(biomeName));

            } catch (Exception e) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().biomeUnknown);
                for (Biome b : Biome.values()) {
                    if (plugin.getConfig().contains("biomes." + b.name())) {
                        sender.sendMessage(b.name());
                    }
                }
                return true;
            }
            // Okay clear to set biome
            // Actually set the biome
            plugin.getBiomes().setIslandBiome(island, biome);
            sender.sendMessage(ChatColor.GREEN + plugin.myLocale().biomeSet.replace("[biome]", biomeName));
            Player targetPlayer = plugin.getServer().getPlayer(playerUUID);
            if (targetPlayer != null) {
                // Online
                targetPlayer.sendMessage("[Admin] " + ChatColor.GREEN
                        + plugin.myLocale(playerUUID).biomeSet.replace("[biome]", biomeName));
            } else {
                plugin.getMessages().setMessage(playerUUID, "[Admin] " + ChatColor.GREEN
                        + plugin.myLocale(playerUUID).biomeSet.replace("[biome]", biomeName));
            }
            return true;
        } else
        // team kick <player> and team delete <leader>
        if (split[0].equalsIgnoreCase("team")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (split[1].equalsIgnoreCase("kick")) {
                // Remove player from team
                if (!plugin.getPlayers().inTeam(playerUUID)) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().errorNoTeam);
                    return true;
                }
                UUID teamLeader = plugin.getPlayers().getTeamLeader(playerUUID);
                if (teamLeader == null) {
                    // Player is apparently in a team, but there is no team leader
                    // Remove their team status
                    // Clear the player of all team-related items
                    plugin.getPlayers().setLeaveTeam(playerUUID);
                    plugin.getPlayers().setHomeLocation(playerUUID, null);
                    plugin.getPlayers().setIslandLocation(playerUUID, null);
                    // Remove any warps
                    plugin.getWarpSignsListener().removeWarp(playerUUID);
                    sender.sendMessage(
                            ChatColor.RED + plugin.myLocale().kicknameRemoved.replace("[name]", split[2]));
                    return true;
                }
                // Payer is not a team leader
                if (!teamLeader.equals(playerUUID)) {
                    // Clear the player of all team-related items
                    plugin.getPlayers().setLeaveTeam(playerUUID);
                    plugin.getPlayers().setHomeLocation(playerUUID, null);
                    plugin.getPlayers().setIslandLocation(playerUUID, null);
                    // Clear the leader of this player and if they now have
                    // no team, remove the team
                    plugin.getPlayers().removeMember(teamLeader, playerUUID);
                    if (plugin.getPlayers().getMembers(teamLeader).size() < 2) {
                        plugin.getPlayers().setLeaveTeam(teamLeader);
                    }
                    // Remove any warps
                    plugin.getWarpSignsListener().removeWarp(playerUUID);
                    sender.sendMessage(
                            ChatColor.RED + plugin.myLocale().kicknameRemoved.replace("[name]", split[2]));
                    return true;
                } else {
                    sender.sendMessage(
                            ChatColor.RED + (plugin.myLocale().adminTeamKickLeader.replace("[label]", label))
                                    .replace("[name]", split[2]));
                    return true;
                }
            } else {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
                return false;
            }
        } else if (split[0].equalsIgnoreCase("completechallenge")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (plugin.getPlayers().checkChallenge(playerUUID, split[2].toLowerCase())
                    || !plugin.getPlayers().get(playerUUID).challengeExists(split[2].toLowerCase())) {
                sender.sendMessage(
                        ChatColor.RED + plugin.myLocale().completeChallengeerrorChallengeDoesNotExist);
                return true;
            }
            plugin.getPlayers().get(playerUUID).completeChallenge(split[2].toLowerCase());
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().completeChallengechallangeCompleted
                    .replace("[challengename]", split[2].toLowerCase()).replace("[name]", split[1]));
            return true;
        } else if (split[0].equalsIgnoreCase("resetchallenge")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[1], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (!plugin.getPlayers().checkChallenge(playerUUID, split[2].toLowerCase())
                    || !plugin.getPlayers().get(playerUUID).challengeExists(split[2].toLowerCase())) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().resetChallengeerrorChallengeDoesNotExist);
                return true;
            }
            plugin.getPlayers().resetChallenge(playerUUID, split[2].toLowerCase());
            sender.sendMessage(ChatColor.YELLOW + plugin.myLocale().resetChallengechallengeReset
                    .replace("[challengename]", split[2].toLowerCase()).replace("[name]", split[1]));
            return true;
        } else if (split[0].equalsIgnoreCase("info") && split[1].equalsIgnoreCase("challenges")) {
            // Convert name to a UUID
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2], true);
            // plugin.getLogger().info("DEBUG: console player info UUID = "
            // + playerUUID);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            } else {
                showInfoChallenges(playerUUID, sender);
                return true;
            }
        }
        return false;
    case 4:
        // Team add <player> <leader>
        if (split[0].equalsIgnoreCase("team") && split[1].equalsIgnoreCase("add")) {
            // Convert names to UUIDs
            final UUID playerUUID = plugin.getPlayers().getUUID(split[2], true);
            final Player targetPlayer = plugin.getServer().getPlayer(playerUUID);
            final UUID teamLeader = plugin.getPlayers().getUUID(split[3], true);
            if (!plugin.getPlayers().isAKnownPlayer(playerUUID)
                    || !plugin.getPlayers().isAKnownPlayer(teamLeader)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownPlayer);
                return true;
            }
            if (playerUUID.equals(teamLeader)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminTeamAddLeaderToOwn);
                return true;
            }
            // See if leader has an island
            if (!plugin.getPlayers().hasIsland(teamLeader, ((Player) sender).getWorld().getEnvironment())) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().adminTeamAddLeaderNoIsland);
                return true;
            }
            // Check to see if this player is already in a team
            if (plugin.getPlayers().inTeam(playerUUID)) {
                sender.sendMessage(ChatColor.RED + plugin.myLocale().inviteerrorThatPlayerIsAlreadyInATeam);
                return true;
            }
            // If the leader's member list does not contain their own name
            // then
            // add it
            if (!plugin.getPlayers().getMembers(teamLeader).contains(teamLeader)) {
                // Set up the team leader
                plugin.getPlayers().setJoinTeam(teamLeader, teamLeader,
                        plugin.getPlayers().getIslandLocation(teamLeader));
                plugin.getPlayers().addTeamMember(teamLeader, teamLeader);
                sender.sendMessage(ChatColor.GOLD + plugin.myLocale().adminTeamAddedLeader);
            }
            // This is a hack to clear any pending invitations
            if (targetPlayer != null) {
                targetPlayer.performCommand(Settings.ISLANDCOMMAND + " decline");
            }
            // If the invitee has an island of their own
            if (plugin.getPlayers().hasIsland(playerUUID, ((Player) sender).getWorld().getEnvironment())) {
                Location islandLoc = plugin.getPlayers().getIslandLocation(playerUUID);
                if (islandLoc != null) {
                    sender.sendMessage(ChatColor.RED + plugin.myLocale().adminTeamNowUnowned
                            .replace("[name]", plugin.getPlayers().getName(playerUUID))
                            .replace("[location]", islandLoc.getBlockX() + " " + islandLoc.getBlockZ()));
                }
            }
            // Remove their old island affiliation - do not delete the
            // island just in case
            plugin.deletePlayerIsland(playerUUID, false, Environment.NETHER);
            plugin.deletePlayerIsland(playerUUID, false, Environment.NORMAL);
            // Join the team and set the team island location and leader
            plugin.getPlayers().setJoinTeam(playerUUID, teamLeader,
                    plugin.getPlayers().getIslandLocation(teamLeader));
            // Configure the best home location for this player
            if (plugin.getPlayers().getHomeLocation(teamLeader) != null) {
                plugin.getPlayers().setHomeLocation(playerUUID,
                        plugin.getPlayers().getHomeLocation(teamLeader));
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminTeamSettingHome);
            } else {
                plugin.getPlayers().setHomeLocation(playerUUID,
                        plugin.getPlayers().getIslandLocation(teamLeader));
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminTeamSettingHome);
            }
            // If the leader's member list does not contain player then add
            // it
            if (!plugin.getPlayers().getMembers(teamLeader).contains(playerUUID)) {
                plugin.getPlayers().addTeamMember(teamLeader, playerUUID);
                sender.sendMessage(ChatColor.GREEN + plugin.myLocale().adminTeamAddingPlayer);
            } else {
                sender.sendMessage(ChatColor.GOLD + plugin.myLocale().adminTeamAlreadyOnTeam);
            }
            // Teleport the player if they are online
            if (targetPlayer != null) {
                plugin.getGrid().homeTeleport(targetPlayer, targetPlayer.getWorld().getEnvironment());
            }
            plugin.getGrid().saveGrid();
            return true;
        } else {
            sender.sendMessage(ChatColor.RED + plugin.myLocale().errorUnknownCommand);
            return false;
        }
    default:
        return false;
    }
}

From source file:org.apache.flink.streaming.runtime.operators.windowing.WindowOperator.java

private void restoreTimers(DataInputView in) throws IOException {
    int numWatermarkTimers = in.readInt();
    watermarkTimers = new HashSet<>(numWatermarkTimers);
    watermarkTimersQueue = new PriorityQueue<>(Math.max(numWatermarkTimers, 1));
    for (int i = 0; i < numWatermarkTimers; i++) {
        K key = keySerializer.deserialize(in);
        W window = windowSerializer.deserialize(in);
        long timestamp = in.readLong();
        Timer<K, W> timer = new Timer<>(timestamp, key, window);
        watermarkTimers.add(timer);//from   ww  w .j av a 2 s  . c o m
        watermarkTimersQueue.add(timer);
    }

    int numProcessingTimeTimers = in.readInt();
    processingTimeTimersQueue = new PriorityQueue<>(Math.max(numProcessingTimeTimers, 1));
    processingTimeTimers = new HashSet<>();
    for (int i = 0; i < numProcessingTimeTimers; i++) {
        K key = keySerializer.deserialize(in);
        W window = windowSerializer.deserialize(in);
        long timestamp = in.readLong();
        Timer<K, W> timer = new Timer<>(timestamp, key, window);
        processingTimeTimersQueue.add(timer);
        processingTimeTimers.add(timer);
    }

    int numProcessingTimeTimerTimestamp = in.readInt();
    processingTimeTimerTimestamps = HashMultiset.create();
    for (int i = 0; i < numProcessingTimeTimerTimestamp; i++) {
        long timestamp = in.readLong();
        int count = in.readInt();
        processingTimeTimerTimestamps.add(timestamp, count);
    }
}

From source file:eu.esdihumboldt.hale.common.align.model.AlignmentUtil.java

/**
 * Returns the values of the given instance which match the given property
 * entity definition./*from w  ww  .j  a va2  s .  com*/
 * 
 * @param instance the instance to collect values from
 * @param definition the property
 * @param onlyValues whether to only return values, or to return whatever
 *            can be found (including groups/instances)
 * @return all values of the given property
 */
public static Multiset<Object> getValues(Instance instance, PropertyEntityDefinition definition,
        boolean onlyValues) {
    Multiset<Object> result = HashMultiset.create();
    addValues(instance, definition.getPropertyPath(), result, onlyValues);
    return result;
}

From source file:tr.com.serkanozal.proxyable.util.JvmUtil.java

private static int guessAlignment(int oopSize) {
    final int COUNT = 1000 * 1000;
    Object[] array = new Object[COUNT];
    long[] offsets = new long[COUNT];

    for (int c = 0; c < COUNT - 3; c += 3) {
        array[c + 0] = new MyObject1();
        array[c + 1] = new MyObject2();
        array[c + 1] = new MyObject3();
    }//ww  w  . jav a2  s . co  m

    for (int c = 0; c < COUNT; c++) {
        offsets[c] = addressOfObject(array[c], oopSize);
    }

    Arrays.sort(offsets);

    Multiset<Integer> sizes = HashMultiset.create();
    for (int c = 1; c < COUNT; c++) {
        sizes.add((int) (offsets[c] - offsets[c - 1]));
    }

    int min = -1;
    for (int s : sizes.elementSet()) {
        if (s <= 0) {
            continue;
        }
        if (min == -1) {
            min = s;
        } else {
            min = gcd(min, s);
        }
    }

    return min;
}

From source file:org.dllearner.algorithms.qtl.experiments.QTLEvaluation.java

private RDFResourceTree applyBaseLine(ExamplesWrapper examples, Baseline baselineApproach) {
    Collection<RDFResourceTree> posExamples = examples.posExamplesMapping.values();
    Collection<RDFResourceTree> negExamples = examples.negExamplesMapping.values();

    switch (baselineApproach) {
    case RANDOM:// 1.
        String query = "SELECT ?cls WHERE {?cls a owl:Class .} ORDER BY RAND() LIMIT 1";
        QueryExecution qe = qef.createQueryExecution(query);
        ResultSet rs = qe.execSelect();
        if (rs.hasNext()) {
            QuerySolution qs = rs.next();
            Resource cls = qs.getResource("cls");
            RDFResourceTree solution = new RDFResourceTree();
            solution.addChild(new RDFResourceTree(cls.asNode()), RDF.type.asNode());
            return solution;
        }//from  w w w  . java2s . c o  m
    case MOST_POPULAR_TYPE_IN_KB:// 2.
        query = "SELECT ?cls WHERE {?cls a owl:Class . ?s a ?cls .} ORDER BY DESC(COUNT(?s)) LIMIT 1";
        qe = qef.createQueryExecution(query);
        rs = qe.execSelect();
        if (rs.hasNext()) {
            QuerySolution qs = rs.next();
            Resource cls = qs.getResource("cls");
            RDFResourceTree solution = new RDFResourceTree();
            solution.addChild(new RDFResourceTree(cls.asNode()), RDF.type.asNode());
            return solution;
        }
    case MOST_FREQUENT_TYPE_IN_EXAMPLES:// 3.
        Multiset<Node> types = HashMultiset.create();
        for (RDFResourceTree ex : posExamples) {
            List<RDFResourceTree> children = ex.getChildren(RDF.type.asNode());
            for (RDFResourceTree child : children) {
                types.add(child.getData());
            }
        }
        Node mostFrequentType = Ordering.natural().onResultOf(new Function<Multiset.Entry<Node>, Integer>() {
            @Override
            public Integer apply(Multiset.Entry<Node> entry) {
                return entry.getCount();
            }
        }).max(types.entrySet()).getElement();
        RDFResourceTree solution = new RDFResourceTree();
        solution.addChild(new RDFResourceTree(mostFrequentType), RDF.type.asNode());
        return solution;
    case MOST_FREQUENT_EDGE_IN_EXAMPLES:// 4.
    {
        Multiset<Pair<Node, Node>> pairs = HashMultiset.create();
        for (RDFResourceTree ex : posExamples) {
            SortedSet<Node> edges = ex.getEdges();
            for (Node edge : edges) {
                List<RDFResourceTree> children = ex.getChildren(edge);
                for (RDFResourceTree child : children) {
                    pairs.add(new Pair<>(edge, child.getData()));
                }
            }
        }
        Pair<Node, Node> mostFrequentPair = Ordering.natural()
                .onResultOf(new Function<Multiset.Entry<Pair<Node, Node>>, Integer>() {
                    @Override
                    public Integer apply(Multiset.Entry<Pair<Node, Node>> entry) {
                        return entry.getCount();
                    }
                }).max(pairs.entrySet()).getElement();
        solution = new RDFResourceTree();
        solution.addChild(new RDFResourceTree(mostFrequentPair.getValue()), mostFrequentPair.getKey());
        return solution;
    }
    case MOST_INFORMATIVE_EDGE_IN_EXAMPLES:
        // get all p-o in pos examples
        Multiset<Pair<Node, Node>> edgeObjectPairs = HashMultiset.create();
        for (RDFResourceTree ex : posExamples) {
            SortedSet<Node> edges = ex.getEdges();
            for (Node edge : edges) {
                List<RDFResourceTree> children = ex.getChildren(edge);
                for (RDFResourceTree child : children) {
                    edgeObjectPairs.add(new Pair<>(edge, child.getData()));
                }
            }
        }

        double bestAccuracy = -1;
        solution = new RDFResourceTree();

        for (Pair<Node, Node> pair : edgeObjectPairs.elementSet()) {
            Node edge = pair.getKey();
            Node childValue = pair.getValue();

            // compute accuracy
            int tp = edgeObjectPairs.count(pair);
            int fn = posExamples.size() - tp;
            int fp = 0;
            for (RDFResourceTree ex : negExamples) { // compute false positives
                List<RDFResourceTree> children = ex.getChildren(edge);
                if (children != null) {
                    for (RDFResourceTree child : children) {
                        if (child.getData().equals(childValue)) {
                            fp++;
                            break;
                        }
                    }
                }
            }
            int tn = negExamples.size() - fp;

            double accuracy = Heuristics.getPredictiveAccuracy(posExamples.size(), negExamples.size(), tp, tn,
                    1.0);
            // update best solution
            if (accuracy >= bestAccuracy) {
                solution = new RDFResourceTree();
                solution.addChild(new RDFResourceTree(childValue), edge);
                bestAccuracy = accuracy;
            }
        }
        return solution;
    case LGG:
        LGGGenerator lggGenerator = new LGGGeneratorSimple();
        RDFResourceTree lgg = lggGenerator.getLGG(Lists.newArrayList(posExamples));
        return lgg;

    default:
        break;

    }
    return null;
}