Many changes for TFM 5.0

Refractoring
Reworked /saconfig
Reworked part of the command system
Removed unused config sections
Refractored part of the config
Fixed bugs with admin list
Actually allow CONSOLE to have senior perms

src/main/java/me/totalfreedom/totalfreedommod/command/CommandFailException.java

@@ -0,0 +1,11 @@
+
+package me.totalfreedom.totalfreedommod.command;
+
+public class CommandFailException extends RuntimeException {
+    private static final long serialVersionUID = -92333791173123L;
+
+    public CommandFailException(String message) {
+        super(message);
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/CommandLoader.java

@@ -0,0 +1,45 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import lombok.Getter;
+import me.totalfreedom.totalfreedommod.FreedomService;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import net.pravian.aero.command.handler.SimpleCommandHandler;
+import org.bukkit.ChatColor;
+
+public class CommandLoader extends FreedomService
+{
+
+    @Getter
+    private final SimpleCommandHandler<TotalFreedomMod> handler;
+
+    public CommandLoader(TotalFreedomMod plugin)
+    {
+        super(plugin);
+
+        handler = new SimpleCommandHandler<>(plugin);
+    }
+
+    @Override
+    protected void onStart()
+    {
+        handler.clearCommands();
+        handler.setExecutorFactory(new FreedomCommandExecutor.FreedomExecutorFactory());
+        handler.setCommandClassPrefix("Command_");
+        handler.setPermissionMessage(ChatColor.RED + "You do not have permission to use this command.");
+        handler.setOnlyConsoleMessage(ChatColor.RED + "This command can only be used from the console.");
+        handler.setOnlyPlayerMessage(ChatColor.RED + "This command can only be used by players.");
+
+        handler.loadFrom(FreedomCommand.class.getPackage());
+        handler.registerAll("TotalFreedomMod", true);
+
+        FLog.info("Loaded " + handler.getExecutors().size() + " commands");
+    }
+
+    @Override
+    protected void onStop()
+    {
+        handler.clearCommands();
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/CommandParameters.java

@@ -0,0 +1,15 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CommandParameters
+{
+
+    String description();
+
+    String usage();
+
+    String aliases() default ""; // "alias1,alias2,alias3" - no spaces
+}

src/main/java/me/totalfreedom/totalfreedommod/command/CommandPermissions.java

@@ -0,0 +1,16 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CommandPermissions
+{
+
+    PlayerRank level();
+
+    SourceType source();
+
+    boolean blockHostConsole() default false;
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_adminchat.java

@@ -0,0 +1,41 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(
+        description = "AdminChat - Talk privately with other admins. Using <command> itself will toggle AdminChat on and off for all messages.",
+        usage = "/<command> [message...]",
+        aliases = "o,ac")
+public class Command_adminchat extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            if (senderIsConsole)
+            {
+                msg("Only in-game players can toggle AdminChat.");
+                return true;
+            }
+
+            FPlayer userinfo = plugin.pl.getPlayer(playerSender);
+            userinfo.setAdminChat(!userinfo.inAdminChat());
+            msg("Toggled Admin Chat " + (userinfo.inAdminChat() ? "on" : "off") + ".");
+        }
+        else
+        {
+            FUtil.adminChatMessage(sender, StringUtils.join(args, " "), senderIsConsole);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_adminmode.java

@@ -0,0 +1,45 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "Close server to non-superadmins.", usage = "/<command> [on | off]")
+public class Command_adminmode extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if (args[0].equalsIgnoreCase("off"))
+        {
+            ConfigEntry.ADMIN_ONLY_MODE.setBoolean(false);
+            FUtil.adminAction(sender.getName(), "Opening the server to all players.", true);
+            return true;
+        }
+        else if (args[0].equalsIgnoreCase("on"))
+        {
+            ConfigEntry.ADMIN_ONLY_MODE.setBoolean(true);
+            FUtil.adminAction(sender.getName(), "Closing the server to non-superadmins.", true);
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!isAdmin(player))
+                {
+                    player.kickPlayer("Server is now closed to non-superadmins.");
+                }
+            }
+            return true;
+        }
+
+        return false;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_adminworld.java

@@ -0,0 +1,248 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import me.totalfreedom.totalfreedommod.world.WorldTime;
+import me.totalfreedom.totalfreedommod.world.WorldWeather;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Go to the AdminWorld.",
+        usage = "/<command> [guest < list | purge | add <player> | remove <player> > | time <morning | noon | evening | night> | weather <off | on | storm>]")
+public class Command_adminworld extends FreedomCommand
+{
+
+    private enum CommandMode
+    {
+
+        TELEPORT, GUEST, TIME, WEATHER;
+    }
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        CommandMode commandMode = null;
+
+        if (args.length == 0)
+        {
+            commandMode = CommandMode.TELEPORT;
+        }
+        else if (args.length >= 2)
+        {
+            if ("guest".equalsIgnoreCase(args[0]))
+            {
+                commandMode = CommandMode.GUEST;
+            }
+            else if ("time".equalsIgnoreCase(args[0]))
+            {
+                commandMode = CommandMode.TIME;
+            }
+            else if ("weather".equalsIgnoreCase(args[0]))
+            {
+                commandMode = CommandMode.WEATHER;
+            }
+        }
+
+        if (commandMode == null)
+        {
+            return false;
+        }
+
+        try
+        {
+            switch (commandMode)
+            {
+                case TELEPORT:
+                {
+                    if (!(sender instanceof Player) || playerSender == null)
+                    {
+                        return true;
+                    }
+
+                    World adminWorld = null;
+                    try
+                    {
+                        adminWorld = plugin.wm.adminworld.getWorld();
+                    }
+                    catch (Exception ex)
+                    {
+                    }
+
+                    if (adminWorld == null || playerSender.getWorld() == adminWorld)
+                    {
+                        msg("Going to the main world.");
+                        playerSender.teleport(server.getWorlds().get(0).getSpawnLocation());
+                    }
+                    else
+                    {
+                        if (plugin.wm.adminworld.canAccessWorld(playerSender))
+                        {
+                            msg("Going to the AdminWorld.");
+                            plugin.wm.adminworld.sendToWorld(playerSender);
+                        }
+                        else
+                        {
+                            msg("You don't have permission to access the AdminWorld.");
+                        }
+                    }
+
+                    break;
+                }
+                case GUEST:
+                {
+                    if (args.length == 2)
+                    {
+                        if ("list".equalsIgnoreCase(args[1]))
+                        {
+                            msg("AdminWorld guest list: " + plugin.wm.adminworld.guestListToString());
+                        }
+                        else if ("purge".equalsIgnoreCase(args[1]))
+                        {
+                            assertCommandPerms(sender, playerSender);
+                            plugin.wm.adminworld.purgeGuestList();
+                            FUtil.adminAction(sender.getName(), "AdminWorld guest list purged.", false);
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                    else if (args.length == 3)
+                    {
+                        assertCommandPerms(sender, playerSender);
+
+                        if ("add".equalsIgnoreCase(args[1]))
+                        {
+                            final Player player = getPlayer(args[2]);
+
+                            if (player == null)
+                            {
+                                sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+                                return true;
+                            }
+
+                            if (plugin.wm.adminworld.addGuest(player, playerSender))
+                            {
+                                FUtil.adminAction(sender.getName(), "AdminWorld guest added: " + player.getName(), false);
+                            }
+                            else
+                            {
+                                msg("Could not add player to guest list.");
+                            }
+                        }
+                        else if ("remove".equals(args[1]))
+                        {
+                            final Player player = plugin.wm.adminworld.removeGuest(args[2]);
+                            if (player != null)
+                            {
+                                FUtil.adminAction(sender.getName(), "AdminWorld guest removed: " + player.getName(), false);
+                            }
+                            else
+                            {
+                                msg("Can't find guest entry for: " + args[2]);
+                            }
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+
+                    break;
+                }
+                case TIME:
+                {
+                    assertCommandPerms(sender, playerSender);
+
+                    if (args.length == 2)
+                    {
+                        WorldTime timeOfDay = WorldTime.getByAlias(args[1]);
+                        if (timeOfDay != null)
+                        {
+                            plugin.wm.adminworld.setTimeOfDay(timeOfDay);
+                            msg("AdminWorld time set to: " + timeOfDay.name());
+                        }
+                        else
+                        {
+                            msg("Invalid time of day. Can be: sunrise, noon, sunset, midnight");
+                        }
+                    }
+                    else
+                    {
+                        return false;
+                    }
+
+                    break;
+                }
+                case WEATHER:
+                {
+                    assertCommandPerms(sender, playerSender);
+
+                    if (args.length == 2)
+                    {
+                        WorldWeather weatherMode = WorldWeather.getByAlias(args[1]);
+                        if (weatherMode != null)
+                        {
+                            plugin.wm.adminworld.setWeatherMode(weatherMode);
+                            msg("AdminWorld weather set to: " + weatherMode.name());
+                        }
+                        else
+                        {
+                            msg("Invalid weather mode. Can be: off, rain, storm");
+                        }
+                    }
+                    else
+                    {
+                        return false;
+                    }
+
+                    break;
+                }
+                default:
+                {
+                    return false;
+                }
+            }
+        }
+        catch (PermissionDeniedException ex)
+        {
+            if (ex.getMessage().isEmpty())
+            {
+                return noPerms();
+            }
+            sender.sendMessage(ex.getMessage());
+            return true;
+        }
+
+        return true;
+    }
+
+    // TODO: Redo this properly
+    private void assertCommandPerms(CommandSender sender, Player playerSender) throws PermissionDeniedException
+    {
+        if (!(sender instanceof Player) || playerSender == null || !isAdmin(sender))
+        {
+            throw new PermissionDeniedException();
+        }
+    }
+
+    private class PermissionDeniedException extends Exception
+    {
+
+        private static final long serialVersionUID = 1L;
+
+        private PermissionDeniedException()
+        {
+            super("");
+        }
+
+        private PermissionDeniedException(String string)
+        {
+            super(string);
+        }
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_blockcmd.java

@@ -0,0 +1,63 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Block all commands for a specific player.", usage = "/<command> <purge | <partialname>>", aliases = "blockcommands,blockcommand")
+public class Command_blockcmd extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if (args[0].equalsIgnoreCase("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Unblocking commands for all players", true);
+            int counter = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                FPlayer playerdata = plugin.pl.getPlayer(player);
+                if (playerdata.allCommandsBlocked())
+                {
+                    counter += 1;
+                    playerdata.setCommandsBlocked(false);
+                }
+            }
+            msg("Unblocked commands for " + counter + " players.");
+            return true;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        if (isAdmin(sender))
+        {
+            msg(player.getName() + " is a Superadmin, and cannot have their commands blocked.");
+            return true;
+        }
+
+        FPlayer playerdata = plugin.pl.getPlayer(player);
+
+        playerdata.setCommandsBlocked(!playerdata.allCommandsBlocked());
+
+        FUtil.adminAction(sender.getName(), (playerdata.allCommandsBlocked() ? "B" : "Unb") + "locking all commands for " + player.getName(), true);
+        msg((playerdata.allCommandsBlocked() ? "B" : "Unb") + "locked all commands.");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_cage.java

@@ -0,0 +1,110 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Place a cage around someone.", usage = "/<command> <purge | off | <partialname> [outermaterial] [innermaterial]>")
+public class Command_cage extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        if ("off".equals(args[0]) && sender instanceof Player)
+        {
+            FUtil.adminAction(sender.getName(), "Uncaging " + sender.getName(), true);
+            FPlayer playerdata = plugin.pl.getPlayer(playerSender);
+
+            playerdata.getCageData().setCaged(false);
+            return true;
+        }
+        else if ("purge".equals(args[0]))
+        {
+            FUtil.adminAction(sender.getName(), "Uncaging all players", true);
+
+            for (Player player : server.getOnlinePlayers())
+            {
+                FPlayer playerdata = plugin.pl.getPlayer(player);
+                playerdata.getCageData().setCaged(false);
+            }
+
+            return true;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        FPlayer playerdata = plugin.pl.getPlayer(player);
+
+        Material outerMaterial = Material.GLASS;
+        Material innerMaterial = Material.AIR;
+
+        if (args.length >= 2)
+        {
+            if ("off".equals(args[1]))
+            {
+                FUtil.adminAction(sender.getName(), "Uncaging " + player.getName(), true);
+                playerdata.getCageData().setCaged(false);
+
+                return true;
+            }
+            else
+            {
+                if ("darth".equalsIgnoreCase(args[1]))
+                {
+                    outerMaterial = Material.SKULL;
+                }
+                else if (Material.matchMaterial(args[1]) != null)
+                {
+                    outerMaterial = Material.matchMaterial(args[1]);
+                }
+            }
+        }
+
+        if (args.length >= 3)
+        {
+            if (args[2].equalsIgnoreCase("water"))
+            {
+                innerMaterial = Material.STATIONARY_WATER;
+            }
+            else if (args[2].equalsIgnoreCase("lava"))
+            {
+                innerMaterial = Material.STATIONARY_LAVA;
+            }
+        }
+
+        Location targetPos = player.getLocation().clone().add(0, 1, 0);
+        playerdata.getCageData().cage(targetPos, outerMaterial, innerMaterial);
+
+        player.setGameMode(GameMode.SURVIVAL);
+
+        if (outerMaterial != Material.SKULL)
+        {
+            FUtil.adminAction(sender.getName(), "Caging " + player.getName(), true);
+        }
+        else
+        {
+            FUtil.adminAction(sender.getName(), "Caging " + player.getName() + " in PURE_DARTH", true);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_cake.java

@@ -0,0 +1,54 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.Random;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.Achievement;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "For the people that are still alive.", usage = "/<command>")
+public class Command_cake extends FreedomCommand
+{
+
+    public static final String CAKE_LYRICS = "But there's no sense crying over every mistake. You just keep on trying till you run out of cake.";
+    private final Random random = new Random();
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        final StringBuilder output = new StringBuilder();
+
+        final String[] words = CAKE_LYRICS.split(" ");
+        for (final String word : words)
+        {
+            output.append(ChatColor.COLOR_CHAR).append(Integer.toHexString(1 + random.nextInt(14))).append(word).append(" ");
+        }
+
+        final ItemStack heldItem = new ItemStack(Material.CAKE);
+        final ItemMeta heldItemMeta = heldItem.getItemMeta();
+        heldItemMeta.setDisplayName((new StringBuilder()).append(ChatColor.WHITE).append("The ").append(ChatColor.DARK_GRAY).append("Lie").toString());
+        heldItem.setItemMeta(heldItemMeta);
+
+        for (final Player player : server.getOnlinePlayers())
+        {
+            final int firstEmpty = player.getInventory().firstEmpty();
+            if (firstEmpty >= 0)
+            {
+                player.getInventory().setItem(firstEmpty, heldItem);
+            }
+
+            player.awardAchievement(Achievement.BAKE_CAKE);
+        }
+
+        FUtil.bcastMsg(output.toString());
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_cartsit.java

@@ -0,0 +1,82 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Minecart;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Sit in nearest minecart. If target is in a minecart already, they will disembark.", usage = "/<command> [partialname]")
+public class Command_cartsit extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        Player targetPlayer = playerSender;
+
+        if (args.length == 1)
+        {
+
+            targetPlayer = getPlayer(args[0]);
+
+            if (targetPlayer == null)
+            {
+                sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+                return true;
+            }
+        }
+
+        if (senderIsConsole)
+        {
+            if (targetPlayer == null)
+            {
+                sender.sendMessage("When used from the console, you must define a target player: /cartsit <player>");
+                return true;
+            }
+        }
+        else if (targetPlayer != playerSender && !isAdmin(sender))
+        {
+            sender.sendMessage("Only superadmins can select another player as a /cartsit target.");
+            return true;
+        }
+
+        if (targetPlayer.isInsideVehicle())
+        {
+            targetPlayer.getVehicle().eject();
+        }
+        else
+        {
+            Minecart nearest_cart = null;
+            for (Minecart cart : targetPlayer.getWorld().getEntitiesByClass(Minecart.class))
+            {
+                if (cart.isEmpty())
+                {
+                    if (nearest_cart == null)
+                    {
+                        nearest_cart = cart;
+                    }
+                    else
+                    {
+                        if (cart.getLocation().distanceSquared(targetPlayer.getLocation()) < nearest_cart.getLocation().distanceSquared(targetPlayer.getLocation()))
+                        {
+                            nearest_cart = cart;
+                        }
+                    }
+                }
+            }
+
+            if (nearest_cart != null)
+            {
+                nearest_cart.setPassenger(targetPlayer);
+            }
+            else
+            {
+                sender.sendMessage("There are no empty minecarts in the target world.");
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_cbtool.java

@@ -0,0 +1,218 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "No Description Yet", usage = "/<command>")
+public class Command_cbtool extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        if ("targetblock".equalsIgnoreCase(args[0]) && sender instanceof Player)
+        {
+            Block targetBlock = DepreciationAggregator.getTargetBlock(playerSender, null, 100);
+            msg("Your target block: " + targetBlock.getLocation().toString());
+            return true;
+        }
+
+        try
+        {
+            final StringBuffer generatedCommand = new StringBuffer();
+
+            final Matcher matcher = Pattern.compile("\\[(.+?)\\]").matcher(StringUtils.join(args, " ").trim());
+            while (matcher.find())
+            {
+                matcher.appendReplacement(generatedCommand, processSubCommand(matcher.group(1)));
+            }
+            matcher.appendTail(generatedCommand);
+
+            if (plugin.cb.isCommandBlocked(generatedCommand.toString(), sender, false))
+            {
+                return true;
+            }
+
+            server.dispatchCommand(sender, generatedCommand.toString());
+        }
+        catch (SubCommandFailureException ex)
+        {
+        }
+        catch (Exception ex)
+        {
+            FLog.severe(ex);
+        }
+
+        return true;
+    }
+
+    private String processSubCommand(final String subcommand) throws SubCommandFailureException
+    {
+        final String[] args = StringUtils.split(subcommand, " ");
+
+        if (args.length == 1)
+        {
+            throw new SubCommandFailureException("Invalid subcommand name.");
+        }
+
+        return SubCommand.getByName(args[0]).getExecutable().execute(ArrayUtils.remove(args, 0));
+    }
+
+    private static enum SubCommand
+    {
+
+        PLAYER_DETECT("playerdetect", new SubCommandExecutable()
+        {
+            @Override
+            public String execute(String[] args) throws SubCommandFailureException
+            {
+                if (args.length != 5)
+                {
+                    throw new SubCommandFailureException("Invalid # of arguments.");
+                }
+
+                double x, y, z;
+                try
+                {
+                    x = Double.parseDouble(args[0].trim());
+                    y = Double.parseDouble(args[1].trim());
+                    z = Double.parseDouble(args[2].trim());
+                }
+                catch (NumberFormatException ex)
+                {
+                    throw new SubCommandFailureException("Invalid coordinates.");
+                }
+
+                World world = null;
+                final String needleWorldName = args[3].trim();
+                final List<World> worlds = Bukkit.getWorlds();
+                for (final World testWorld : worlds)
+                {
+                    if (testWorld.getName().trim().equalsIgnoreCase(needleWorldName))
+                    {
+                        world = testWorld;
+                        break;
+                    }
+                }
+
+                if (world == null)
+                {
+                    throw new SubCommandFailureException("Invalid world name.");
+                }
+
+                final Location testLocation = new Location(world, x, y, z);
+
+                double radius;
+                try
+                {
+                    radius = Double.parseDouble(args[4].trim());
+                }
+                catch (NumberFormatException ex)
+                {
+                    throw new SubCommandFailureException("Invalid radius.");
+                }
+
+                final double radiusSq = radius * radius;
+
+                final List<Player> worldPlayers = testLocation.getWorld().getPlayers();
+                for (final Player testPlayer : worldPlayers)
+                {
+                    if (testPlayer.getLocation().distanceSquared(testLocation) < radiusSq)
+                    {
+                        return testPlayer.getName();
+                    }
+                }
+
+                throw new SubCommandFailureException("No player found in range.");
+            }
+        }),
+        PLAYER_DETECT_BOOLEAN("playerdetectboolean", new SubCommandExecutable()
+        {
+            @Override
+            public String execute(String[] args) throws SubCommandFailureException
+            {
+                try
+                {
+                    PLAYER_DETECT.getExecutable().execute(args);
+                }
+                catch (SubCommandFailureException ex)
+                {
+                    return "0";
+                }
+
+                return "1";
+            }
+        });
+        //
+        private final String name;
+        private final SubCommandExecutable executable;
+
+        private SubCommand(String subCommandName, SubCommandExecutable subCommandImpl)
+        {
+            this.name = subCommandName;
+            this.executable = subCommandImpl;
+        }
+
+        public SubCommandExecutable getExecutable()
+        {
+            return executable;
+        }
+
+        public String getName()
+        {
+            return name;
+        }
+
+        public static SubCommand getByName(String needle) throws SubCommandFailureException
+        {
+            needle = needle.trim();
+            for (SubCommand subCommand : values())
+            {
+                if (subCommand.getName().equalsIgnoreCase(needle))
+                {
+                    return subCommand;
+                }
+            }
+            throw new SubCommandFailureException("Invalid subcommand name.");
+        }
+    }
+
+    private interface SubCommandExecutable
+    {
+
+        public String execute(String[] args) throws SubCommandFailureException;
+    }
+
+    private static class SubCommandFailureException extends Exception
+    {
+
+        public SubCommandFailureException()
+        {
+        }
+
+        public SubCommandFailureException(String message)
+        {
+            super(message);
+        }
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_cmdspy.java

@@ -0,0 +1,24 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Spy on commands", usage = "/<command>", aliases = "commandspy")
+public class Command_cmdspy extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+
+        FPlayer playerdata = plugin.pl.getPlayer(playerSender);
+        playerdata.setCommandSpy(!playerdata.cmdspyEnabled());
+        msg("CommandSpy " + (playerdata.cmdspyEnabled() ? "enabled." : "disabled."));
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_colorme.java

@@ -0,0 +1,59 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.Iterator;
+import java.util.Map;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Essentials Interface Command - Color your current nickname.", usage = "/<command> <color>")
+public class Command_colorme extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if ("list".equalsIgnoreCase(args[0]))
+        {
+            msg("Colors: " + StringUtils.join(FUtil.CHAT_COLOR_NAMES.keySet(), ", "));
+            return true;
+        }
+
+        final String needle = args[0].trim().toLowerCase();
+        ChatColor color = null;
+        final Iterator<Map.Entry<String, ChatColor>> it = FUtil.CHAT_COLOR_NAMES.entrySet().iterator();
+        while (it.hasNext())
+        {
+            final Map.Entry<String, ChatColor> entry = it.next();
+            if (entry.getKey().contains(needle))
+            {
+                color = entry.getValue();
+                break;
+            }
+        }
+
+        if (color == null)
+        {
+            msg("Invalid color: " + needle + " - Use \"/colorme list\" to list colors.");
+            return true;
+        }
+
+        final String newNick = color + ChatColor.stripColor(playerSender.getDisplayName()).trim() + ChatColor.WHITE;
+
+        plugin.esb.setNickname(sender.getName(), newNick);
+
+        msg("Your nickname is now: " + newNick);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_commandlist.java

@@ -0,0 +1,53 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Show all commands for all server plugins.", usage = "/<command>", aliases = "cmdlist")
+public class Command_commandlist extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        List<String> commands = new ArrayList<>();
+
+        for (Plugin targetPlugin : server.getPluginManager().getPlugins())
+        {
+            try
+            {
+                PluginDescriptionFile desc = targetPlugin.getDescription();
+                Map<String, Map<String, Object>> map = (Map<String, Map<String, Object>>) desc.getCommands();
+
+                if (map != null)
+                {
+                    for (Entry<String, Map<String, Object>> entry : map.entrySet())
+                    {
+                        String command_name = (String) entry.getKey();
+                        commands.add(command_name);
+                    }
+                }
+            }
+            catch (Throwable ex)
+            {
+            }
+        }
+
+        Collections.sort(commands);
+
+        sender.sendMessage(StringUtils.join(commands, ","));
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_consolesay.java

@@ -0,0 +1,24 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_CONSOLE)
+@CommandParameters(description = "Telnet command - Send a chat message with chat formatting over telnet.", usage = "/<command> <message...>", aliases = "csay")
+public class Command_consolesay extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 0)
+        {
+            FUtil.bcastMsg(String.format("§7[CONSOLE]§f<§c%s§f> %s", sender.getName(), StringUtils.join(args, " ")));
+        }
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_creative.java

@@ -0,0 +1,73 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Quickly change your own gamemode to creative, or define someone's username to change theirs.", usage = "/<command> [partialname]", aliases = "gmc")
+public class Command_creative extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (senderIsConsole)
+        {
+            if (args.length == 0)
+            {
+                sender.sendMessage("When used from the console, you must define a target user to change gamemode on.");
+                return true;
+            }
+        }
+
+        Player player;
+        if (args.length == 0)
+        {
+            player = playerSender;
+        }
+        else
+        {
+            if (args[0].equalsIgnoreCase("-a"))
+            {
+                if (!isAdmin(sender))
+                {
+                    noPerms();
+                    return true;
+                }
+
+                for (Player targetPlayer : server.getOnlinePlayers())
+                {
+                    targetPlayer.setGameMode(GameMode.CREATIVE);
+                }
+
+                FUtil.adminAction(sender.getName(), "Changing everyone's gamemode to creative", false);
+                return true;
+            }
+
+            if (!(senderIsConsole || isAdmin(sender)))
+            {
+                msg("Only superadmins can change other user's gamemode.");
+                return true;
+            }
+
+            player = getPlayer(args[0]);
+
+            if (player == null)
+            {
+                sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+                return true;
+            }
+
+        }
+
+        msg("Setting " + player.getName() + " to game mode 'Creative'.");
+        msg(player, sender.getName() + " set your game mode to 'Creative'.");
+        player.setGameMode(GameMode.CREATIVE);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_deafen.java

@@ -0,0 +1,52 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.Random;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Make some noise.", usage = "/<command>")
+public class Command_deafen extends FreedomCommand
+{
+
+    private static final Random random = new Random();
+    public static final double STEPS = 10.0;
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        for (final Player player : server.getOnlinePlayers())
+        {
+            for (double percent = 0.0; percent <= 1.0; percent += (1.0 / STEPS))
+            {
+                final float pitch = (float) (percent * 2.0);
+
+                new BukkitRunnable()
+                {
+                    @Override
+                    public void run()
+                    {
+                        player.playSound(randomOffset(player.getLocation(), 5.0), Sound.values()[random.nextInt(Sound.values().length)], 100.0f, pitch);
+                    }
+                }.runTaskLater(plugin, Math.round(20.0 * percent * 2.0));
+            }
+        }
+
+        return true;
+    }
+
+    private static Location randomOffset(Location a, double magnitude)
+    {
+        return a.clone().add(randomDoubleRange(-1.0, 1.0) * magnitude, randomDoubleRange(-1.0, 1.0) * magnitude, randomDoubleRange(-1.0, 1.0) * magnitude);
+    }
+
+    private static Double randomDoubleRange(double min, double max)
+    {
+        return min + (random.nextDouble() * ((max - min) + 1.0));
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_debug.java

@@ -0,0 +1,113 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.lang.reflect.Field;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE)
+@CommandParameters(description = "For developers only - debug things via reflection.", usage = "/<command>")
+public class Command_debug extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 3)
+        {
+            return false;
+        }
+
+        try
+        {
+            String className = args[0];
+            String fieldName = args[1];
+            String newValue = StringUtils.join(ArrayUtils.subarray(args, 2, args.length), " ");
+
+            if (className.equalsIgnoreCase("_"))
+            {
+                className = "me.StevenLawson.TotalFreedomMod.TotalFreedomMod";
+            }
+
+            setStaticValue(className, fieldName, newValue);
+
+            sender.sendMessage("Debug: OK");
+        }
+        catch (Exception ex)
+        {
+            sender.sendMessage(ex.getMessage());
+        }
+
+        return true;
+    }
+
+    public static void setStaticValue(final String className, final String fieldName, final String newValueString) throws Exception
+    {
+        Class<?> forName = Class.forName(className);
+        if (forName != null)
+        {
+            final Field field = forName.getDeclaredField(fieldName);
+            if (field != null)
+            {
+                Object newValue;
+
+                Class<?> type = field.getType();
+                if (type.isPrimitive())
+                {
+                    if (type.getName().equals("int"))
+                    {
+                        newValue = Integer.parseInt(newValueString);
+                    }
+                    else if (type.getName().equals("double"))
+                    {
+                        newValue = Double.parseDouble(newValueString);
+                    }
+                    else if (type.getName().equals("boolean"))
+                    {
+                        newValue = Boolean.parseBoolean(newValueString);
+                    }
+                    else
+                    {
+                        throw new Exception("Unknown primitive field type.");
+                    }
+                }
+                else
+                {
+                    if (type.isAssignableFrom(Integer.class))
+                    {
+                        newValue = new Integer(newValueString);
+                    }
+                    else if (type.isAssignableFrom(Double.class))
+                    {
+                        newValue = new Double(newValueString);
+                    }
+                    else if (type.isAssignableFrom(Boolean.class))
+                    {
+                        newValue = Boolean.valueOf(newValueString);
+                    }
+                    else if (type.isAssignableFrom(String.class))
+                    {
+                        newValue = newValueString;
+                    }
+                    else
+                    {
+                        throw new Exception("Unknown complex field type.");
+                    }
+                }
+
+                field.setAccessible(true);
+
+                final Object oldValue = field.get(Class.forName(className));
+                if (oldValue != null)
+                {
+                    field.set(oldValue, newValue);
+                }
+
+                field.setAccessible(false);
+            }
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_denick.java

@@ -0,0 +1,26 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Essentials Interface Command - Remove the nickname of all players on the server.", usage = "/<command>")
+public class Command_denick extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Removing all nicknames", false);
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            plugin.esb.setNickname(player.getName(), null);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_deop.java

@@ -0,0 +1,46 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Deop a player.", usage = "/<command> <playername>")
+public class Command_deop extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        OfflinePlayer player = null;
+
+        for (Player onlinePlayer : server.getOnlinePlayers())
+        {
+            if (args[0].equalsIgnoreCase(onlinePlayer.getName()))
+            {
+                player = onlinePlayer;
+            }
+        }
+
+        // if the player is not online
+        if (player == null)
+        {
+            player = DepreciationAggregator.getOfflinePlayer(server, args[0]);
+        }
+
+        FUtil.adminAction(sender.getName(), "De-opping " + player.getName(), false);
+
+        player.setOp(false);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_deopall.java

@@ -0,0 +1,27 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Deop everyone on the server.", usage = "/<command>")
+public class Command_deopall extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "De-opping all players on the server", true);
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            player.setOp(false);
+            player.sendMessage(FreedomCommand.YOU_ARE_NOT_OP);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_dispfill.java

@@ -0,0 +1,112 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.Dispenser;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Fill nearby dispensers with a set of items of your choice.", usage = "/<command> <radius> <comma,separated,items>")
+public class Command_dispfill extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 2)
+        {
+            int radius;
+
+            try
+            {
+                radius = Math.max(5, Math.min(25, Integer.parseInt(args[0])));
+            }
+            catch (NumberFormatException ex)
+            {
+                sender.sendMessage("Invalid radius.");
+                return true;
+            }
+
+            final List<ItemStack> items = new ArrayList<>();
+
+            final String[] itemsRaw = StringUtils.split(args[1], ",");
+            for (final String searchItem : itemsRaw)
+            {
+                Material material = Material.matchMaterial(searchItem);
+                if (material == null)
+                {
+                    try
+                    {
+                        material = DepreciationAggregator.getMaterial(Integer.parseInt(searchItem));
+                    }
+                    catch (NumberFormatException ex)
+                    {
+                    }
+                }
+
+                if (material != null)
+                {
+                    items.add(new ItemStack(material, 64));
+                }
+                else
+                {
+                    sender.sendMessage("Skipping invalid item: " + searchItem);
+                }
+            }
+
+            final ItemStack[] itemsArray = items.toArray(new ItemStack[items.size()]);
+
+            int affected = 0;
+            final Location centerLocation = playerSender.getLocation();
+            final Block centerBlock = centerLocation.getBlock();
+            for (int xOffset = -radius; xOffset <= radius; xOffset++)
+            {
+                for (int yOffset = -radius; yOffset <= radius; yOffset++)
+                {
+                    for (int zOffset = -radius; zOffset <= radius; zOffset++)
+                    {
+                        final Block targetBlock = centerBlock.getRelative(xOffset, yOffset, zOffset);
+                        if (targetBlock.getLocation().distanceSquared(centerLocation) < (radius * radius))
+                        {
+                            if (targetBlock.getType().equals(Material.DISPENSER))
+                            {
+                                sender.sendMessage("Filling dispenser @ " + FUtil.formatLocation(targetBlock.getLocation()));
+                                setDispenserContents(targetBlock, itemsArray);
+                                affected++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            sender.sendMessage("Done. " + affected + " dispenser(s) filled.");
+        }
+        else
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static void setDispenserContents(final Block targetBlock, final ItemStack[] items)
+    {
+        if (targetBlock.getType() == Material.DISPENSER)
+        {
+            final Inventory dispenserInv = ((Dispenser) targetBlock.getState()).getInventory();
+            dispenserInv.clear();
+            dispenserInv.addItem(items);
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_doom.java

@@ -0,0 +1,111 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.util.Vector;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "For the bad Superadmins", usage = "/<command> <playername>")
+public class Command_doom extends FreedomCommand
+{
+
+    @Override
+    public boolean run(final CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        FUtil.adminAction(sender.getName(), "Casting oblivion over " + player.getName(), true);
+        FUtil.bcastMsg(player.getName() + " will be completely obliviated!", ChatColor.RED);
+
+        final String ip = player.getAddress().getAddress().getHostAddress().trim();
+
+        // Remove from superadmin
+        Admin admin = getAdmin(player);
+        if (admin != null)
+        {
+            FUtil.adminAction(sender.getName(), "Removing " + player.getName() + " from the superadmin list", true);
+            plugin.al.removeAdmin(admin);
+        }
+
+        // Remove from whitelist
+        player.setWhitelisted(false);
+
+        // Deop
+        player.setOp(false);
+
+        // Ban player
+        Ban ban = Ban.forPlayer(player, sender);
+        ban.setReason("&cFUCKOFF");
+        for (String playerIp : plugin.pl.getData(player).getIps())
+        {
+            ban.addIp(playerIp);
+        }
+        plugin.bm.addBan(ban);
+
+        // Set gamemode to survival
+        player.setGameMode(GameMode.SURVIVAL);
+
+        // Clear inventory
+        player.closeInventory();
+        player.getInventory().clear();
+
+        // Ignite player
+        player.setFireTicks(10000);
+
+        // Generate explosion
+        player.getWorld().createExplosion(player.getLocation(), 4F);
+
+        // Shoot the player in the sky
+        player.setVelocity(player.getVelocity().clone().add(new Vector(0, 20, 0)));
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                // strike lightning
+                player.getWorld().strikeLightning(player.getLocation());
+
+                // kill (if not done already)
+                player.setHealth(0.0);
+            }
+        }.runTaskLater(plugin, 2L * 20L);
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                // message
+                FUtil.adminAction(sender.getName(), "Banning " + player.getName() + ", IP: " + ip, true);
+
+                // generate explosion
+                player.getWorld().createExplosion(player.getLocation(), 4F);
+
+                // kick player
+                player.kickPlayer(ChatColor.RED + "FUCKOFF, and get your shit together!");
+            }
+        }.runTaskLater(plugin, 3L * 20L);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_enchant.java

@@ -0,0 +1,129 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Enchant items.", usage = "/<command> <list | addall | reset | add <name> | remove <name>>")
+public class Command_enchant extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        ItemStack itemInHand = playerSender.getItemInHand();
+
+        if (itemInHand == null)
+        {
+            msg("You are holding an invalid item.");
+            return true;
+        }
+
+        if (args[0].equalsIgnoreCase("list"))
+        {
+            boolean has_enchantments = false;
+
+            StringBuilder possible_ench = new StringBuilder("Possible enchantments for held item: ");
+            for (Enchantment ench : Enchantment.values())
+            {
+                if (ench.canEnchantItem(itemInHand))
+                {
+                    has_enchantments = true;
+                    possible_ench.append(ench.getName()).append(", ");
+                }
+            }
+
+            if (has_enchantments)
+            {
+                msg(possible_ench.toString());
+            }
+            else
+            {
+                msg("The held item has no enchantments.");
+            }
+        }
+        else if (args[0].equalsIgnoreCase("addall"))
+        {
+            for (Enchantment ench : Enchantment.values())
+            {
+                try
+                {
+                    if (ench.canEnchantItem(itemInHand))
+                    {
+                        itemInHand.addEnchantment(ench, ench.getMaxLevel());
+                    }
+                }
+                catch (Exception ex)
+                {
+                    FLog.info("Error using " + ench.getName() + " on " + itemInHand.getType().name() + " held by " + playerSender.getName() + ".");
+                }
+            }
+
+            msg("Added all possible enchantments for this item.");
+        }
+        else if (args[0].equalsIgnoreCase("reset"))
+        {
+            for (Enchantment ench : itemInHand.getEnchantments().keySet())
+            {
+                itemInHand.removeEnchantment(ench);
+            }
+
+            msg("Removed all enchantments.");
+        }
+        else
+        {
+            if (args.length < 2)
+            {
+                return false;
+            }
+
+            Enchantment ench = null;
+
+            try
+            {
+                ench = Enchantment.getByName(args[1]);
+            }
+            catch (Exception ex)
+            {
+            }
+
+            if (ench == null)
+            {
+                msg(args[1] + " is an invalid enchantment for the held item. Type \"/enchant list\" for valid enchantments for this item.");
+                return true;
+            }
+
+            if (args[0].equalsIgnoreCase("add"))
+            {
+                if (ench.canEnchantItem(itemInHand))
+                {
+                    itemInHand.addEnchantment(ench, ench.getMaxLevel());
+
+                    msg("Added enchantment: " + ench.getName());
+                }
+                else
+                {
+                    msg("Can't use this enchantment on held item.");
+                }
+            }
+            else if (args[0].equals("remove"))
+            {
+                itemInHand.removeEnchantment(ench);
+
+                msg("Removed enchantment: " + ench.getName());
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_ender.java

@@ -0,0 +1,20 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Goto the ender / \"The End\".", usage = "/<command>")
+public class Command_ender extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.gotoWorld(playerSender, server.getWorlds().get(0).getName() + "_the_end");
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_entitywipe.java

@@ -0,0 +1,22 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Remove various server entities that may cause lag, such as dropped items, minecarts, and boats.", usage = "/<command> <carts>", aliases = "ew,rd")
+public class Command_entitywipe extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Removing all server entities.", true);
+        msg((plugin.ew.wipeEntities(true, true)) + " entities removed.");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_expel.java

@@ -0,0 +1,90 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Push people away from you.", usage = "/<command> [radius] [strength]")
+public class Command_expel extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        double radius = 20.0;
+        double strength = 5.0;
+
+        if (args.length >= 1)
+        {
+            try
+            {
+                radius = Math.max(1.0, Math.min(100.0, Double.parseDouble(args[0])));
+            }
+            catch (NumberFormatException ex)
+            {
+            }
+        }
+
+        if (args.length >= 2)
+        {
+            try
+            {
+                strength = Math.max(0.0, Math.min(50.0, Double.parseDouble(args[1])));
+            }
+            catch (NumberFormatException ex)
+            {
+            }
+        }
+
+        List<String> pushedPlayers = new ArrayList<>();
+
+        final Vector senderPos = playerSender.getLocation().toVector();
+        final List<Player> players = playerSender.getWorld().getPlayers();
+        for (final Player player : players)
+        {
+            if (player.equals(playerSender))
+            {
+                continue;
+            }
+
+            final Location targetPos = player.getLocation();
+            final Vector targetPosVec = targetPos.toVector();
+
+            boolean inRange = false;
+            try
+            {
+                inRange = targetPosVec.distanceSquared(senderPos) < (radius * radius);
+            }
+            catch (IllegalArgumentException ex)
+            {
+            }
+
+            if (inRange)
+            {
+                player.getWorld().createExplosion(targetPos, 0.0f, false);
+                FUtil.setFlying(player, false);
+                player.setVelocity(targetPosVec.subtract(senderPos).normalize().multiply(strength));
+                pushedPlayers.add(player.getName());
+            }
+        }
+
+        if (pushedPlayers.isEmpty())
+        {
+            msg("No players pushed.");
+        }
+        else
+        {
+            msg("Pushed " + pushedPlayers.size() + " players: " + StringUtils.join(pushedPlayers, ", "));
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_findip.java

@@ -0,0 +1,35 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Shows all IPs registered to a player", usage = "/<command> <player>")
+public class Command_findip extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+
+            msg(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        msg("Player IPs: " + StringUtils.join(plugin.pl.getData(player).getIps(), ", "));
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_flatlands.java

@@ -0,0 +1,27 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Goto the flatlands.", usage = "/<command>")
+public class Command_flatlands extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (ConfigEntry.FLATLANDS_GENERATE.getBoolean())
+        {
+            plugin.wm.flatlands.sendToWorld(playerSender);
+        }
+        else
+        {
+            msg("Flatlands is currently disabled.");
+        }
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_freeze.java

@@ -0,0 +1,67 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import me.totalfreedom.totalfreedommod.freeze.FreezeData;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Freeze players (toggles on and off).", usage = "/<command> [target | purge]", aliases = "fr")
+public class Command_freeze extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            boolean allFrozen = plugin.fm.isGlobalFreeze();
+            plugin.fm.setGlobalFreeze(!allFrozen);
+
+            if (!allFrozen)
+            {
+                FUtil.adminAction(sender.getName(), "Disabling global player freeze", true);
+                msg("Players are now free to move.");
+                return true;
+            }
+
+            FUtil.adminAction(sender.getName(), "Disabling global player freeze", true);
+            msg("Players are now unfrozen.");
+
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!isAdmin(player))
+                {
+                    msg(player, "You have been frozen due to rulebreakers, you will be unfrozen soon.", ChatColor.RED);
+                }
+            }
+            return true;
+        }
+
+        if (args[0].equals("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Unfreezing all players", false);
+            plugin.fm.purge();
+            return true;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND, ChatColor.RED);
+            return true;
+        }
+
+        final FreezeData fd = plugin.pl.getPlayer(player).getFreezeData();
+        fd.setFrozen(!fd.isFrozen());
+
+        msg(player.getName() + " has been " + (fd.isFrozen() ? "frozen" : "unfrozen") + ".");
+        msg(player, "You have been " + (fd.isFrozen() ? "frozen" : "unfrozen") + ".", ChatColor.AQUA);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_fuckoff.java

@@ -0,0 +1,50 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "You'll never even see it coming.", usage = "/<command>")
+public class Command_fuckoff extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        FPlayer player = plugin.pl.getPlayer(playerSender);
+
+        if (!args[0].equals("on"))
+        {
+            player.disableFuckoff();
+        }
+        else
+        {
+
+            double radius = 25.0;
+            if (args.length >= 2)
+            {
+                try
+                {
+                    radius = Math.max(5.0, Math.min(50, Double.parseDouble(args[1])));
+                }
+                catch (NumberFormatException ex)
+                {
+                }
+            }
+
+            player.setFuckoff(radius);
+        }
+
+        msg("Fuckoff " + (player.isFuckOff() ? ("enabled. Radius: " + player.getFuckoffRadius() + ".") : "disabled."));
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_gadmin.java

@@ -0,0 +1,209 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.nio.charset.StandardCharsets;
+import java.util.Iterator;
+import java.util.UUID;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.freeze.FreezeData;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(
+        description = "Use admin commands on someone by hash. Use mode 'list' to get a player's hash. Other modes are kick, nameban, ipban, ban, op, deop, ci, fr, smite.",
+        usage = "/<command> [list | [<kick | nameban | ipban | ban | op | deop | ci | fr | smite> <targethash>] ]")
+public class Command_gadmin extends FreedomCommand
+{
+
+    private enum GadminMode
+    {
+
+        LIST("list"),
+        KICK("kick"),
+        NAMEBAN("nameban"),
+        IPBAN("ipban"),
+        BAN("ban"),
+        OP("op"),
+        DEOP("deop"),
+        CI("ci"),
+        FR("fr"),
+        SMITE("smite");
+        private final String modeName;
+
+        private GadminMode(String command)
+        {
+            this.modeName = command;
+        }
+
+        public String getModeName()
+        {
+            return modeName;
+        }
+
+        public static GadminMode findMode(String needle)
+        {
+            for (final GadminMode mode : GadminMode.values())
+            {
+                if (needle.equalsIgnoreCase(mode.getModeName()))
+                {
+                    return mode;
+                }
+            }
+            return null;
+        }
+    }
+
+    public String getPlayerHash(Player player)
+    {
+        return UUID.nameUUIDFromBytes(player.getName().toLowerCase().getBytes(StandardCharsets.UTF_8)).toString().substring(0, 4);
+    }
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        final GadminMode mode = GadminMode.findMode(args[0].toLowerCase());
+        if (mode == null)
+        {
+            msg("Invalid mode: " + args[0], ChatColor.RED);
+            return true;
+        }
+
+        final Iterator<? extends Player> it = server.getOnlinePlayers().iterator();
+
+        if (mode == GadminMode.LIST)
+        {
+            msg("[ Real Name ] : [ Display Name ] - Hash:");
+            while (it.hasNext())
+            {
+                final Player player = it.next();
+                sender.sendMessage(ChatColor.GRAY + String.format("[ %s ] : [ %s ] - %s",
+                        player.getName(),
+                        ChatColor.stripColor(player.getDisplayName()),
+                        getPlayerHash(player)));
+            }
+            return true;
+        }
+
+        if (args.length < 2)
+        {
+            return false;
+        }
+
+        Player target = null;
+        while (it.hasNext() && target == null)
+        {
+            final Player player = it.next();
+            final String hash = getPlayerHash(player);
+
+            if (hash.equalsIgnoreCase(args[1]))
+            {
+                target = player;
+            }
+        }
+
+        if (target == null)
+        {
+            msg("Invalid player hash: " + args[1], ChatColor.RED);
+            return true;
+        }
+
+        switch (mode)
+        {
+            case KICK:
+            {
+                FUtil.adminAction(sender.getName(), String.format("Kicking: %s.", target.getName()), false);
+                target.kickPlayer("Kicked by Administrator");
+
+                break;
+            }
+            case NAMEBAN:
+            {
+                FUtil.adminAction(sender.getName(), String.format("Banning Name: %s.", target.getName()), true);
+                plugin.bm.addBan(Ban.forPlayerName(target, sender, null, null));
+                target.kickPlayer("Username banned by Administrator.");
+
+                break;
+            }
+            case IPBAN:
+            {
+                String ip = target.getAddress().getAddress().getHostAddress();
+                String[] ip_parts = ip.split("\\.");
+                if (ip_parts.length == 4)
+                {
+                    ip = String.format("%s.%s.*.*", ip_parts[0], ip_parts[1]);
+                }
+                FUtil.adminAction(sender.getName(), String.format("Banning IP: %s.", ip), true);
+                plugin.bm.addBan(Ban.forPlayerIp(ip, sender, null, null));
+
+                target.kickPlayer("IP address banned by Administrator.");
+
+                break;
+            }
+            case BAN:
+            {
+                String ip = target.getAddress().getAddress().getHostAddress();
+                String[] ip_parts = ip.split("\\.");
+                if (ip_parts.length == 4)
+                {
+                    ip = String.format("%s.%s.*.*", ip_parts[0], ip_parts[1]);
+                }
+                FUtil.adminAction(sender.getName(), String.format("Banning Name: %s, IP: %s.", target.getName(), ip), true);
+
+                plugin.bm.addBan(Ban.forPlayer(target, sender));
+
+                target.kickPlayer("IP and username banned by Administrator.");
+
+                break;
+            }
+            case OP:
+            {
+                FUtil.adminAction(sender.getName(), String.format("Opping %s.", target.getName()), false);
+                target.setOp(false);
+                target.sendMessage(FreedomCommand.YOU_ARE_OP);
+
+                break;
+            }
+            case DEOP:
+            {
+                FUtil.adminAction(sender.getName(), String.format("Deopping %s.", target.getName()), false);
+                target.setOp(false);
+                target.sendMessage(FreedomCommand.YOU_ARE_NOT_OP);
+
+                break;
+            }
+            case CI:
+            {
+                target.getInventory().clear();
+
+                break;
+            }
+            case FR:
+            {
+                FreezeData fd = plugin.pl.getPlayer(target).getFreezeData();
+                fd.setFrozen(!fd.isFrozen());
+
+                msg(target.getName() + " has been " + (fd.isFrozen() ? "frozen" : "unfrozen") + ".");
+                target.sendMessage(ChatColor.AQUA + "You have been " + (fd.isFrozen() ? "frozen" : "unfrozen") + ".");
+
+                break;
+            }
+            case SMITE:
+            {
+                Command_smite.smite(target);
+
+                break;
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_gcmd.java

@@ -0,0 +1,56 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Send a command as someone else.", usage = "/<command> <fromname> <outcommand>")
+public class Command_gcmd extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 2)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        final String outCommand = StringUtils.join(args, " ", 1, args.length);
+
+        if (plugin.cb.isCommandBlocked(outCommand, sender))
+        {
+            return true;
+        }
+
+        try
+        {
+            msg("Sending command as " + player.getName() + ": " + outCommand);
+            if (server.dispatchCommand(player, outCommand))
+            {
+                msg("Command sent.");
+            }
+            else
+            {
+                msg("Unknown error sending command.");
+            }
+        }
+        catch (Throwable ex)
+        {
+            msg("Error sending command: " + ex.getMessage());
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_glist.java

@@ -0,0 +1,120 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Bans or unbans any player, even those who are not logged in anymore.", usage = "/<command> <purge | <ban | unban> <username>>")
+public class Command_glist extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        if (args.length == 1)
+        {
+            if (args[0].equalsIgnoreCase("purge"))
+            {
+                if (getAdmin(sender).getRank() == PlayerRank.SENIOR_ADMIN)
+                {
+                    plugin.pl.purgeAllData();
+                    msg("Purged playerbase.");
+                }
+                else
+                {
+                    msg("Only Senior Admins may purge the userlist.");
+                }
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (args.length == 2)
+        {
+            String username;
+            final List<String> ips = new ArrayList<>();
+
+            final Player player = getPlayer(args[1]);
+
+            if (player == null)
+            {
+                final PlayerData entry = plugin.pl.getData(args[1]);
+
+                if (entry == null)
+                {
+                    msg("Can't find that user. If target is not logged in, make sure that you spelled the name exactly.");
+                    return true;
+                }
+
+                username = entry.getUsername();
+                ips.addAll(entry.getIps());
+            }
+            else
+            {
+                username = player.getName();
+                final PlayerData entry = plugin.pl.getData(player);
+                ips.addAll(entry.getIps());
+            }
+
+            String mode = args[0].toLowerCase();
+            if (mode.equalsIgnoreCase("ban"))
+            {
+                FUtil.adminAction(sender.getName(), "Banning " + username + " and IPs: " + StringUtils.join(ips, ", "), true);
+
+                final Player target = Bukkit.getPlayer(username);
+                if (target != null)
+                {
+                    target.kickPlayer("You have been banned by " + sender.getName() + "\n If you think you have been banned wrongly, appeal here: " + ConfigEntry.SERVER_BAN_URL.getString());
+                }
+
+                Ban ban = Ban.forPlayerFuzzy(player, sender, null, null);
+                for (String ip : ips)
+                {
+                    ban.addIp(ip);
+                    ban.addIp(FUtil.getFuzzyIp(ip));
+                }
+                plugin.bm.addBan(ban);
+            }
+            else if (mode.equalsIgnoreCase("unban"))
+            {
+                FUtil.adminAction(sender.getName(), "Unbanning " + username + " and IPs: " + StringUtils.join(ips, ", "), true);
+                plugin.bm.removeBan(plugin.bm.getByUsername(username));
+                for (String ip : ips)
+                {
+                    Ban ban = plugin.bm.getByIp(ip);
+                    if (ban != null)
+                    {
+                        plugin.bm.removeBan(ban);
+                    }
+                }
+            }
+            else
+            {
+                return false;
+            }
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_gtfo.java

@@ -0,0 +1,100 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import net.pravian.aero.util.Ips;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Makes someone GTFO (deop and ip ban by username).", usage = "/<command> <partialname>")
+public class Command_gtfo extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND, ChatColor.RED);
+            return true;
+        }
+
+        String reason = null;
+        if (args.length >= 2)
+        {
+            reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+        }
+
+        FUtil.bcastMsg(player.getName() + " has been a VERY naughty, naughty boy.", ChatColor.RED);
+
+        // Undo WorldEdits
+        try
+        {
+            plugin.web.undo(player, 15);
+        }
+        catch (NoClassDefFoundError ex)
+        {
+        }
+
+        // Rollback
+        plugin.rb.rollback(player.getName());
+
+        // Deop
+        player.setOp(false);
+
+        // Gamemode suvival
+        player.setGameMode(GameMode.SURVIVAL);
+
+        // Clear inventory
+        player.getInventory().clear();
+
+        // Strike with lightning
+        final Location targetPos = player.getLocation();
+        for (int x = -1; x <= 1; x++)
+        {
+            for (int z = -1; z <= 1; z++)
+            {
+                final Location strike_pos = new Location(targetPos.getWorld(), targetPos.getBlockX() + x, targetPos.getBlockY(), targetPos.getBlockZ() + z);
+                targetPos.getWorld().strikeLightning(strike_pos);
+            }
+        }
+
+        String ip = FUtil.getFuzzyIp(Ips.getIp(player));
+
+        // Broadcast
+        final StringBuilder bcast = new StringBuilder()
+                .append(ChatColor.RED)
+                .append("Banning: ")
+                .append(player.getName())
+                .append(", IP: ")
+                .append(ip);
+        if (reason != null)
+        {
+            bcast.append(" - Reason: ").append(ChatColor.YELLOW).append(reason);
+        }
+        FUtil.bcastMsg(bcast.toString());
+
+        // Ban player
+        plugin.bm.addBan(Ban.forPlayerFuzzy(player, sender, null, reason));
+
+        // Kick player
+        player.kickPlayer(ChatColor.RED + "GTFO");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_health.java

@@ -0,0 +1,105 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.text.DecimalFormat;
+import java.util.concurrent.atomic.AtomicInteger;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import org.apache.commons.lang.math.DoubleRange;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "View ticks-per-second", usage = "/<command>")
+public class Command_health extends FreedomCommand
+{
+
+    private static final int BYTES_PER_MB = 1024 * 1024;
+    private static final DoubleRange TPS_RANGE = new DoubleRange(20.0 - 0.1, 20.0 + 0.1);
+
+    @Override
+    public boolean run(final CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        Runtime runtime = Runtime.getRuntime();
+        long usedMem = runtime.totalMemory() - runtime.freeMemory();
+
+        msg("Reserved Memory: " + (double) runtime.totalMemory() / (double) BYTES_PER_MB + "mb");
+        msg("Used Memory: " + new DecimalFormat("#").format((double) usedMem / (double) BYTES_PER_MB)
+                + "mb (" + new DecimalFormat("#").format(((double) usedMem / (double) runtime.totalMemory()) * 100.0) + "%)");
+        msg("Max Memory: " + (double) runtime.maxMemory() / (double) BYTES_PER_MB + "mb");
+        msg("Calculating ticks per second, please wait...");
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                try
+                {
+                    TFM_TickMeter tickMeter = new TFM_TickMeter(plugin);
+                    tickMeter.startTicking();
+                    Thread.sleep(2500);
+                    final double ticksPerSecond = tickMeter.stopTicking();
+
+                    new BukkitRunnable()
+                    {
+                        @Override
+                        public void run()
+                        {
+                            msg("Ticks per second: " + (TPS_RANGE.containsDouble(ticksPerSecond) ? ChatColor.GREEN : ChatColor.RED) + ticksPerSecond);
+                        }
+                    }.runTask(plugin);
+                }
+                catch (Exception ex)
+                {
+                    FLog.severe(ex);
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+
+        return true;
+    }
+
+    private class TFM_TickMeter
+    {
+
+        private final AtomicInteger ticks = new AtomicInteger();
+        private final TotalFreedomMod plugin;
+        private long startTime;
+        private BukkitTask task;
+
+        public TFM_TickMeter(TotalFreedomMod plugin)
+        {
+            this.plugin = plugin;
+        }
+
+        public void startTicking()
+        {
+            startTime = System.currentTimeMillis();
+            ticks.set(0);
+
+            task = new BukkitRunnable()
+            {
+                @Override
+                public void run()
+                {
+                    ticks.incrementAndGet();
+                }
+            }.runTaskTimer(plugin, 0L, 1L);
+        }
+
+        public double stopTicking()
+        {
+            task.cancel();
+            long elapsed = System.currentTimeMillis() - startTime;
+            int tickCount = ticks.get();
+
+            return (double) tickCount / ((double) elapsed / 1000.0);
+        }
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_invis.java

@@ -0,0 +1,68 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Shows (optionally smites) invisisible players", usage = "/<command> (smite)")
+public class Command_invis extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean smite = false;
+        if (args.length >= 1)
+        {
+            if (args[0].equalsIgnoreCase("smite"))
+            {
+                FUtil.adminAction(sender.getName(), "Smiting all invisible players", true);
+                smite = true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        List<String> players = new ArrayList<>();
+        int smites = 0;
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            if (player.hasPotionEffect(PotionEffectType.INVISIBILITY))
+            {
+                players.add(player.getName());
+                if (smite && !plugin.al.isAdmin(player))
+                {
+                    player.setHealth(0.0);
+                    smites++;
+                }
+            }
+        }
+
+        if (players.isEmpty())
+        {
+            msg("There are no invisible players");
+            return true;
+        }
+
+        if (smite)
+        {
+            msg("Smitten " + smites + " players");
+        }
+        else
+        {
+            msg("Invisible players (" + players.size() + "): " + StringUtils.join(players, ", "));
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_jumppads.java

@@ -0,0 +1,96 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.fun.Jumppads;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Manage jumppads", usage = "/<command> <on | off | info | sideways <on | off> | strength <strength (1-10)>>", aliases = "launchpads,jp")
+public class Command_jumppads extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0 || args.length > 2)
+        {
+            return false;
+        }
+
+        if (args.length == 1)
+        {
+            if (args[0].equalsIgnoreCase("info"))
+            {
+                msg("Jumppads: " + (plugin.jp.getMode().isOn() ? "Enabled" : "Disabled"), ChatColor.BLUE);
+                msg("Sideways: " + (plugin.jp.getMode() == Jumppads.JumpPadMode.NORMAL_AND_SIDEWAYS ? "Enabled" : "Disabled"), ChatColor.BLUE);
+                msg("Strength: " + (plugin.jp.getStrength() * 10 - 1), ChatColor.BLUE);
+                return true;
+            }
+
+            if ("off".equals(args[0]))
+            {
+                FUtil.adminAction(sender.getName(), "Disabling Jumppads", false);
+                plugin.jp.setMode(Jumppads.JumpPadMode.OFF);
+            }
+            else
+            {
+                FUtil.adminAction(sender.getName(), "Enabling Jumppads", false);
+                plugin.jp.setMode(Jumppads.JumpPadMode.MADGEEK);
+            }
+        }
+        else
+        {
+            if (plugin.jp.getMode() == Jumppads.JumpPadMode.OFF)
+            {
+                msg("Jumppads are currently disabled, please enable them before changing jumppads settings.");
+                return true;
+            }
+
+            if (args[0].equalsIgnoreCase("sideways"))
+            {
+                if ("off".equals(args[1]))
+                {
+                    FUtil.adminAction(sender.getName(), "Setting Jumppads mode to: Madgeek", false);
+                    plugin.jp.setMode(Jumppads.JumpPadMode.MADGEEK);
+                }
+                else
+                {
+                    FUtil.adminAction(sender.getName(), "Setting Jumppads mode to: Normal and Sideways", false);
+                    plugin.jp.setMode(Jumppads.JumpPadMode.NORMAL_AND_SIDEWAYS);
+                }
+            }
+            else if (args[0].equalsIgnoreCase("strength"))
+            {
+                final float strength;
+                try
+                {
+                    strength = Float.parseFloat(args[1]);
+                }
+                catch (NumberFormatException ex)
+                {
+                    msg("Invalid Strength");
+                    return true;
+                }
+
+                if (strength > 10 || strength < 1)
+                {
+                    msg("Invalid Strength: The strength may be 1 through 10.");
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Setting Jumppads strength to: " + String.valueOf(strength), false);
+                plugin.jp.setStrength((strength / 10) + 0.1F);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_kicknoob.java

@@ -0,0 +1,30 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Kick all non-superadmins on server.", usage = "/<command>")
+public class Command_kicknoob extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Disconnecting all non-superadmins.", true);
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            if (!plugin.al.isAdmin(player))
+            {
+                player.kickPlayer(ChatColor.RED + "All non-superadmins were kicked by " + sender.getName() + ".");
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_landmine.java

@@ -0,0 +1,67 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.Iterator;
+import me.totalfreedom.totalfreedommod.fun.Landminer.Landmine;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Set a landmine trap.", usage = "/<command>")
+public class Command_landmine extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!ConfigEntry.LANDMINES_ENABLED.getBoolean())
+        {
+            msg("The landmine is currently disabled.", ChatColor.GREEN);
+            return true;
+        }
+
+        if (!ConfigEntry.ALLOW_EXPLOSIONS.getBoolean())
+        {
+            msg("Explosions are currently disabled.", ChatColor.GREEN);
+            return true;
+        }
+
+        double radius = 2.0;
+
+        if (args.length >= 1)
+        {
+            if ("list".equals(args[0]))
+            {
+                final Iterator<Landmine> landmines = plugin.lm.getLandmines().iterator();
+                while (landmines.hasNext())
+                {
+                    msg(landmines.next().toString());
+                }
+                return true;
+            }
+
+            try
+            {
+                radius = Math.max(2.0, Math.min(6.0, Double.parseDouble(args[0])));
+            }
+            catch (NumberFormatException ex)
+            {
+            }
+        }
+
+        final Block landmine = playerSender.getLocation().getBlock().getRelative(BlockFace.DOWN);
+        landmine.setType(Material.TNT);
+        plugin.lm.add(new Landmine(landmine.getLocation(), playerSender, radius));
+
+        msg("Landmine planted - Radius = " + radius + " blocks.", ChatColor.GREEN);
+
+        return true;
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_lastcmd.java

@@ -0,0 +1,45 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Show the last command that someone used.", usage = "/<command> <player>")
+public class Command_lastcmd extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        final FPlayer playerdata = plugin.pl.getPlayer(player);
+
+        if (playerdata != null)
+        {
+            String lastCommand = playerdata.getLastCommand();
+            if (lastCommand.isEmpty())
+            {
+                lastCommand = "(none)";
+            }
+            msg(player.getName() + " - Last Command: " + lastCommand, ChatColor.GRAY);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_list.java

@@ -0,0 +1,106 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Lists the real names of all online players.", usage = "/<command> [-a | -i]", aliases = "who")
+public class Command_list extends FreedomCommand
+{
+
+    private static enum ListFilter
+    {
+
+        ALL,
+        ADMINS,
+        IMPOSTORS;
+    }
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 1)
+        {
+            return false;
+        }
+
+        if (FUtil.isFromHostConsole(sender.getName()))
+        {
+            final List<String> names = new ArrayList<>();
+            for (Player player : server.getOnlinePlayers())
+            {
+                names.add(player.getName());
+            }
+            msg("There are " + names.size() + "/" + server.getMaxPlayers() + " players online:\n" + StringUtils.join(names, ", "), ChatColor.WHITE);
+            return true;
+        }
+
+        final ListFilter listFilter;
+        if (args.length == 1)
+        {
+            if ("-a".equals(args[0]))
+            {
+                listFilter = ListFilter.ADMINS;
+            }
+            else if ("-i".equals(args[0]))
+            {
+                listFilter = ListFilter.IMPOSTORS;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            listFilter = ListFilter.ALL;
+        }
+
+        final StringBuilder onlineStats = new StringBuilder();
+        final StringBuilder onlineUsers = new StringBuilder();
+
+        onlineStats.append(ChatColor.BLUE).append("There are ").append(ChatColor.RED).append(server.getOnlinePlayers().size());
+        onlineStats.append(ChatColor.BLUE).append(" out of a maximum ").append(ChatColor.RED).append(server.getMaxPlayers());
+        onlineStats.append(ChatColor.BLUE).append(" players online.");
+
+        final List<String> names = new ArrayList<>();
+        for (Player player : server.getOnlinePlayers())
+        {
+            if (listFilter == ListFilter.ADMINS && !plugin.al.isAdmin(player))
+            {
+                continue;
+            }
+
+            if (listFilter == ListFilter.IMPOSTORS && !plugin.al.isAdminImpostor(player))
+            {
+                continue;
+            }
+
+            names.add(plugin.rm.getRank(player).getColoredTag() + player.getName());
+        }
+
+        onlineUsers.append("Connected ");
+        onlineUsers.append(listFilter == Command_list.ListFilter.ADMINS ? "admins: " : "players: ");
+        onlineUsers.append(StringUtils.join(names, ChatColor.WHITE + ", "));
+
+        if (senderIsConsole)
+        {
+            sender.sendMessage(ChatColor.stripColor(onlineStats.toString()));
+            sender.sendMessage(ChatColor.stripColor(onlineUsers.toString()));
+        }
+        else
+        {
+            sender.sendMessage(onlineStats.toString());
+            sender.sendMessage(onlineUsers.toString());
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_localspawn.java

@@ -0,0 +1,20 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Teleport to the spawn point for the current world.", usage = "/<command>", aliases = "worldspawn,gotospawn")
+public class Command_localspawn extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        playerSender.teleport(playerSender.getWorld().getSpawnLocation());
+        msg("Teleported to spawnpoint for world \"" + playerSender.getWorld().getName() + "\".");
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_lockup.java

@@ -0,0 +1,127 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "Block target's minecraft input. This is evil, and I never should have wrote it.", usage = "/<command> <all | purge | <<partialname> on | off>>")
+public class Command_lockup extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 1)
+        {
+            if (args[0].equalsIgnoreCase("all"))
+            {
+                FUtil.adminAction(sender.getName(), "Locking up all players", true);
+
+                for (Player player : server.getOnlinePlayers())
+                {
+                    startLockup(player);
+                }
+                msg("Locked up all players.");
+            }
+            else if (args[0].equalsIgnoreCase("purge"))
+            {
+                FUtil.adminAction(sender.getName(), "Unlocking all players", true);
+                for (Player player : server.getOnlinePlayers())
+                {
+                    cancelLockup(player);
+                }
+
+                msg("Unlocked all players.");
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (args.length == 2)
+        {
+            if (args[1].equalsIgnoreCase("on"))
+            {
+                final Player player = getPlayer(args[0]);
+
+                if (player == null)
+                {
+                    sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Locking up " + player.getName(), true);
+                startLockup(player);
+                msg("Locked up " + player.getName() + ".");
+            }
+            else if ("off".equals(args[1]))
+            {
+                final Player player = getPlayer(args[0]);
+
+                if (player == null)
+                {
+                    sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Unlocking " + player.getName(), true);
+                cancelLockup(player);
+                msg("Unlocked " + player.getName() + ".");
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private void cancelLockup(FPlayer playerdata)
+    {
+        BukkitTask lockupScheduleId = playerdata.getLockupScheduleID();
+        if (lockupScheduleId != null)
+        {
+            lockupScheduleId.cancel();
+            playerdata.setLockupScheduleId(null);
+        }
+    }
+
+    private void cancelLockup(final Player player)
+    {
+        cancelLockup(plugin.pl.getPlayer(player));
+    }
+
+    private void startLockup(final Player player)
+    {
+        final FPlayer playerdata = plugin.pl.getPlayer(player);
+
+        cancelLockup(playerdata);
+
+        playerdata.setLockupScheduleId(new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                if (player.isOnline())
+                {
+                    player.openInventory(player.getInventory());
+                }
+                else
+                {
+                    cancelLockup(playerdata);
+                }
+            }
+        }.runTaskTimer(plugin, 0L, 5L));
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_logs.java

@@ -0,0 +1,169 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Register your connection with the TFM logviewer.", usage = "/<command> [off]")
+public class Command_logs extends FreedomCommand
+{
+
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        LogsRegistrationMode mode = LogsRegistrationMode.UPDATE;
+
+        if (args.length == 1)
+        {
+            mode = ("off".equals(args[0]) ? LogsRegistrationMode.DELETE : LogsRegistrationMode.UPDATE);
+        }
+
+        updateLogsRegistration(sender, playerSender, mode);
+
+        return true;
+    }
+
+    public static void updateLogsRegistration(final CommandSender sender, final Player target, final LogsRegistrationMode mode)
+    {
+        updateLogsRegistration(sender, target.getName(), target.getAddress().getAddress().getHostAddress().trim(), mode);
+    }
+
+    public static void updateLogsRegistration(final CommandSender sender, final String targetName, final String targetIP, final LogsRegistrationMode mode)
+    {
+        final String logsRegisterUrl = ConfigEntry.LOGS_URL.getString();
+        final String logsRegisterPassword = ConfigEntry.LOGS_SECRET.getString();
+
+        if (logsRegisterUrl == null || logsRegisterPassword == null || logsRegisterUrl.isEmpty() || logsRegisterPassword.isEmpty())
+        {
+            return;
+        }
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                try
+                {
+                    if (sender != null)
+                    {
+                        sender.sendMessage(ChatColor.YELLOW + "Connecting...");
+                    }
+
+                    URL url = new URLBuilder(logsRegisterUrl)
+                            .addQueryParameter("mode", mode.toString())
+                            .addQueryParameter("password", logsRegisterPassword)
+                            .addQueryParameter("name", targetName)
+                            .addQueryParameter("ip", targetIP)
+                            .getURL();
+
+                    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+                    connection.setConnectTimeout(1000 * 5);
+                    connection.setReadTimeout(1000 * 5);
+                    connection.setUseCaches(false);
+                    connection.setRequestMethod("HEAD");
+
+                    final int responseCode = connection.getResponseCode();
+
+                    if (sender != null)
+                    {
+                        new BukkitRunnable()
+                        {
+                            @Override
+                            public void run()
+                            {
+                                if (responseCode == 200)
+                                {
+                                    sender.sendMessage(ChatColor.GREEN + "Registration " + mode.toString() + "d.");
+                                }
+                                else
+                                {
+                                    sender.sendMessage(ChatColor.RED + "Error contacting logs registration server.");
+                                }
+                            }
+                        }.runTask(TotalFreedomMod.plugin);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    FLog.severe(ex);
+                }
+            }
+        }.runTaskAsynchronously(TotalFreedomMod.plugin);
+    }
+
+    public static void deactivateSuperadmin(Admin superadmin)
+    {
+        for (String ip : superadmin.getIps())
+        {
+            updateLogsRegistration(null, superadmin.getName(), ip, Command_logs.LogsRegistrationMode.DELETE);
+        }
+    }
+
+    public static enum LogsRegistrationMode
+    {
+
+        UPDATE("update"), DELETE("delete");
+        private final String mode;
+
+        private LogsRegistrationMode(String mode)
+        {
+            this.mode = mode;
+        }
+
+        @Override
+        public String toString()
+        {
+            return mode;
+        }
+    }
+
+    private static class URLBuilder
+    {
+
+        private final String requestPath;
+        private final Map<String, String> queryStringMap = new HashMap<>();
+
+        public URLBuilder(String requestPath)
+        {
+            this.requestPath = requestPath;
+        }
+
+        public URLBuilder addQueryParameter(String key, String value)
+        {
+            queryStringMap.put(key, value);
+            return this;
+        }
+
+        public URL getURL() throws MalformedURLException
+        {
+            List<String> pairs = new ArrayList<>();
+            Iterator<Entry<String, String>> it = queryStringMap.entrySet().iterator();
+            while (it.hasNext())
+            {
+                Entry<String, String> pair = it.next();
+                pairs.add(pair.getKey() + "=" + pair.getValue());
+            }
+
+            return new URL(requestPath + "?" + StringUtils.join(pairs, "&"));
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_moblimiter.java

@@ -0,0 +1,84 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.GameRuleHandler;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_CONSOLE)
+@CommandParameters(description = "Control mob rezzing parameters.", usage = "/<command> <on|off|setmax <count>|dragon|giant|ghast|slime>")
+public class Command_moblimiter extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        if (args[0].equalsIgnoreCase("on"))
+        {
+            ConfigEntry.MOB_LIMITER_ENABLED.setBoolean(true);
+        }
+        else if (args[0].equalsIgnoreCase("off"))
+        {
+            ConfigEntry.MOB_LIMITER_ENABLED.setBoolean(false);
+        }
+        else if (args[0].equalsIgnoreCase("dragon"))
+        {
+            ConfigEntry.MOB_LIMITER_DISABLE_DRAGON.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_DRAGON.getBoolean());
+        }
+        else if (args[0].equalsIgnoreCase("giant"))
+        {
+            ConfigEntry.MOB_LIMITER_DISABLE_GIANT.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_GIANT.getBoolean());
+        }
+        else if (args[0].equalsIgnoreCase("slime"))
+        {
+            ConfigEntry.MOB_LIMITER_DISABLE_SLIME.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_SLIME.getBoolean());
+        }
+        else if (args[0].equalsIgnoreCase("ghast"))
+        {
+            ConfigEntry.MOB_LIMITER_DISABLE_GHAST.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_GHAST.getBoolean());
+        }
+        else
+        {
+            if (args.length < 2)
+            {
+                return false;
+            }
+
+            if (args[0].equalsIgnoreCase("setmax"))
+            {
+                try
+                {
+                    ConfigEntry.MOB_LIMITER_MAX.setInteger(Math.max(0, Math.min(2000, Integer.parseInt(args[1]))));
+                }
+                catch (NumberFormatException nfex)
+                {
+                }
+            }
+        }
+
+        if (ConfigEntry.MOB_LIMITER_ENABLED.getBoolean())
+        {
+            sender.sendMessage("Moblimiter enabled. Maximum mobcount set to: " + ConfigEntry.MOB_LIMITER_MAX.getInteger() + ".");
+
+            msg("Dragon: " + (ConfigEntry.MOB_LIMITER_DISABLE_DRAGON.getBoolean() ? "disabled" : "enabled") + ".");
+            msg("Giant: " + (ConfigEntry.MOB_LIMITER_DISABLE_GIANT.getBoolean() ? "disabled" : "enabled") + ".");
+            msg("Slime: " + (ConfigEntry.MOB_LIMITER_DISABLE_SLIME.getBoolean() ? "disabled" : "enabled") + ".");
+            msg("Ghast: " + (ConfigEntry.MOB_LIMITER_DISABLE_GHAST.getBoolean() ? "disabled" : "enabled") + ".");
+        }
+        else
+        {
+            msg("Moblimiter is disabled. No mob restrictions are in effect.");
+        }
+
+        plugin.gr.setGameRule(GameRuleHandler.GameRule.DO_MOB_SPAWNING, !ConfigEntry.MOB_LIMITER_ENABLED.getBoolean());
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_mobpurge.java

@@ -0,0 +1,46 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Ambient;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Ghast;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Slime;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Purge all mobs in all worlds.", usage = "/<command>", aliases = "mp")
+public class Command_mobpurge extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        msg("Purging all mobs...");
+        msg(purgeMobs() + " mobs removed.");
+        return true;
+    }
+
+    public static int purgeMobs()
+    {
+        int removed = 0;
+        for (World world : Bukkit.getWorlds())
+        {
+            for (Entity ent : world.getLivingEntities())
+            {
+                if (ent instanceof Creature || ent instanceof Ghast || ent instanceof Slime || ent instanceof EnderDragon || ent instanceof Ambient)
+                {
+                    ent.remove();
+                    removed++;
+                }
+            }
+        }
+
+        return removed;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_mp44.java

@@ -0,0 +1,52 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Modern weaponry, FTW. Use 'draw' to start firing, 'sling' to stop firing.", usage = "/<command> <draw | sling>")
+public class Command_mp44 extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!ConfigEntry.MP44_ENABLED.getBoolean())
+        {
+            msg("The mp44 is currently disabled.", ChatColor.GREEN);
+            return true;
+        }
+
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        FPlayer playerdata = plugin.pl.getPlayer(playerSender);
+
+        if (args[0].equalsIgnoreCase("draw"))
+        {
+            playerdata.armMP44();
+
+            msg("mp44 is ARMED! Left click with gunpowder to start firing, left click again to quit.", ChatColor.GREEN);
+            msg("Type /mp44 sling to disable.  -by Madgeek1450", ChatColor.GREEN);
+
+            playerSender.setItemInHand(new ItemStack(Material.SULPHUR, 1));
+        }
+        else
+        {
+            playerdata.disarmMP44();
+
+            sender.sendMessage(ChatColor.GREEN + "mp44 Disarmed.");
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_nether.java

@@ -0,0 +1,20 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Goto the nether.", usage = "/<command>")
+public class Command_nether extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.gotoWorld(playerSender, server.getWorlds().get(0).getName() + "_nether");
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_nickclean.java

@@ -0,0 +1,51 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Essentials Interface Command - Remove distracting things from nicknames of all players on server.", usage = "/<command>", aliases = "nc")
+public class Command_nickclean extends FreedomCommand
+{
+
+    private static final ChatColor[] BLOCKED = new ChatColor[]
+    {
+        ChatColor.MAGIC,
+        ChatColor.STRIKETHROUGH,
+        ChatColor.ITALIC,
+        ChatColor.UNDERLINE,
+        ChatColor.BLACK
+    };
+    private static final Pattern REGEX = Pattern.compile(ChatColor.COLOR_CHAR + "[" + StringUtils.join(BLOCKED, "") + "]");
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Cleaning all nicknames.", false);
+
+        for (final Player player : server.getOnlinePlayers())
+        {
+            final String playerName = player.getName();
+            final String nickName = plugin.esb.getNickname(playerName);
+            if (nickName != null && !nickName.isEmpty() && !nickName.equalsIgnoreCase(playerName))
+            {
+                final Matcher matcher = REGEX.matcher(nickName);
+                if (matcher.find())
+                {
+                    final String newNickName = matcher.replaceAll("");
+                    msg(ChatColor.RESET + playerName + ": \"" + nickName + ChatColor.RESET + "\" -> \"" + newNickName + ChatColor.RESET + "\".");
+                    plugin.esb.setNickname(playerName, newNickName);
+                }
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_nickfilter.java

@@ -0,0 +1,123 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "NickFilter: Prefix any command with this command to replace nicknames in that command with real names. Nicknames should be prefixed with a !.",
+        usage = "/<command> <other_command> !<playernick>",
+        aliases = "nf")
+public class Command_nickfilter extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean nickMatched = false;
+
+        final List<String> outputCommand = new ArrayList<>();
+
+        if (args.length >= 1)
+        {
+            final List<String> argsList = Arrays.asList(args);
+            for (String arg : argsList)
+            {
+                Player player = null;
+
+                Matcher matcher = Pattern.compile("^!(.+)$").matcher(arg);
+                if (matcher.find())
+                {
+                    String displayName = matcher.group(1);
+
+                    player = getPlayerByDisplayName(displayName);
+
+                    if (player == null)
+                    {
+                        player = getPlayerByDisplayNameAlt(displayName);
+
+                        if (player == null)
+                        {
+                            sender.sendMessage(ChatColor.GRAY + "Can't find player by nickname: " + displayName);
+                            return true;
+                        }
+                    }
+                }
+
+                if (player == null)
+                {
+                    outputCommand.add(arg);
+                }
+                else
+                {
+                    nickMatched = true;
+                    outputCommand.add(player.getName());
+                }
+            }
+        }
+
+        if (!nickMatched)
+        {
+            sender.sendMessage("No nicknames replaced in command.");
+            return true;
+        }
+
+        String newCommand = StringUtils.join(outputCommand, " ");
+
+        if (plugin.cb.isCommandBlocked(newCommand, sender))
+        {
+            // CommandBlocker handles messages and broadcasts
+            return true;
+        }
+
+        sender.sendMessage("Sending command: \"" + newCommand + "\".");
+        server.dispatchCommand(sender, newCommand);
+
+        return true;
+    }
+
+    private static Player getPlayerByDisplayName(String needle)
+    {
+        needle = needle.toLowerCase().trim();
+
+        for (Player player : Bukkit.getOnlinePlayers())
+        {
+            if (player.getDisplayName().toLowerCase().trim().contains(needle))
+            {
+                return player;
+            }
+        }
+
+        return null;
+    }
+
+    private static Player getPlayerByDisplayNameAlt(String needle)
+    {
+        needle = needle.toLowerCase().trim();
+
+        Integer minEditDistance = null;
+        Player minEditMatch = null;
+
+        for (Player player : Bukkit.getOnlinePlayers())
+        {
+            String haystack = player.getDisplayName().toLowerCase().trim();
+            int editDistance = StringUtils.getLevenshteinDistance(needle, haystack.toLowerCase());
+            if (minEditDistance == null || minEditDistance.intValue() > editDistance)
+            {
+                minEditDistance = editDistance;
+                minEditMatch = player;
+            }
+        }
+
+        return minEditMatch;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_nicknyan.java

@@ -0,0 +1,73 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Essentials Interface Command - Nyanify your nickname.", usage = "/<command> <<nick> | off>")
+public class Command_nicknyan extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if ("off".equals(args[0]))
+        {
+            plugin.esb.setNickname(sender.getName(), null);
+            msg("Nickname cleared.");
+            return true;
+        }
+
+        final String nickPlain = ChatColor.stripColor(FUtil.colorize(args[0].trim()));
+
+        if (!nickPlain.matches("^[a-zA-Z_0-9" + ChatColor.COLOR_CHAR + "]+$"))
+        {
+            msg("That nickname contains invalid characters.");
+            return true;
+        }
+        else if (nickPlain.length() < 4 || nickPlain.length() > 30)
+        {
+            msg("Your nickname must be between 4 and 30 characters long.");
+            return true;
+        }
+
+        for (Player player : Bukkit.getOnlinePlayers())
+        {
+            if (player == playerSender)
+            {
+                continue;
+            }
+            if (player.getName().equalsIgnoreCase(nickPlain) || ChatColor.stripColor(player.getDisplayName()).trim().equalsIgnoreCase(nickPlain))
+            {
+                msg("That nickname is already in use.");
+                return true;
+            }
+        }
+
+        final StringBuilder newNick = new StringBuilder();
+
+        final char[] chars = nickPlain.toCharArray();
+        for (char c : chars)
+        {
+            newNick.append(FUtil.randomChatColor()).append(c);
+        }
+
+        newNick.append(ChatColor.WHITE);
+
+        plugin.esb.setNickname(sender.getName(), newNick.toString());
+
+        msg("Your nickname is now: " + newNick.toString());
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_onlinemode.java

@@ -0,0 +1,71 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Switch server online-mode on and off.", usage = "/<command> <on | off>")
+public class Command_onlinemode extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            msg("Server is currently running with 'online-mode=" + (server.getOnlineMode() ? "true" : "false") + "'.", ChatColor.WHITE);
+            msg("\"/onlinemode on\" and \"/onlinemode off\" can be used to change online mode from the console.", ChatColor.WHITE);
+        }
+        else
+        {
+            boolean onlineMode;
+
+            if (sender instanceof Player && !plugin.al.isSeniorAdmin(sender))
+            {
+                noPerms();
+                return true;
+            }
+
+            if (args[0].equalsIgnoreCase("on"))
+            {
+                onlineMode = true;
+            }
+            else if (args[0].equalsIgnoreCase("off"))
+            {
+                onlineMode = false;
+            }
+            else
+            {
+                return false;
+            }
+
+            try
+            {
+                plugin.si.setOnlineMode(onlineMode);
+
+                if (onlineMode)
+                {
+                    for (Player player : server.getOnlinePlayers())
+                    {
+                        player.kickPlayer("Server is activating \"online-mode=true\". Please reconnect.");
+                    }
+                }
+
+                FUtil.adminAction(sender.getName(), "Turning player validation " + (onlineMode ? "on" : "off") + ".", true);
+
+                server.reload();
+            }
+            catch (Exception ex)
+            {
+                FLog.severe(ex);
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_op.java

@@ -0,0 +1,60 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Makes a player operator", usage = "/<command> <playername>")
+public class Command_op extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if (args[0].equalsIgnoreCase("all") || args[0].equalsIgnoreCase("everyone"))
+        {
+            msg("Correct usage: /opall");
+            return true;
+        }
+
+        OfflinePlayer player = null;
+        for (Player onlinePlayer : server.getOnlinePlayers())
+        {
+            if (args[0].equalsIgnoreCase(onlinePlayer.getName()))
+            {
+                player = onlinePlayer;
+            }
+        }
+
+        // if the player is not online
+        if (player == null)
+        {
+            if (plugin.al.isAdmin(sender) || senderIsConsole)
+            {
+                player = DepreciationAggregator.getOfflinePlayer(server, args[0]);
+            }
+            else
+            {
+                msg("That player is not online.");
+                msg("You don't have permissions to OP offline players.", ChatColor.YELLOW);
+                return true;
+            }
+        }
+
+        FUtil.adminAction(sender.getName(), "Opping " + player.getName(), false);
+        player.setOp(true);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_opall.java

@@ -0,0 +1,49 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Op everyone on the server, optionally change everyone's gamemode at the same time.", usage = "/<command> [-c | -s]")
+public class Command_opall extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Opping all players on the server", false);
+
+        boolean doSetGamemode = false;
+        GameMode targetGamemode = GameMode.CREATIVE;
+        if (args.length != 0)
+        {
+            if (args[0].equals("-c"))
+            {
+                doSetGamemode = true;
+                targetGamemode = GameMode.CREATIVE;
+            }
+            else if (args[0].equals("-s"))
+            {
+                doSetGamemode = true;
+                targetGamemode = GameMode.SURVIVAL;
+            }
+        }
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            player.setOp(true);
+            player.sendMessage(FreedomCommand.YOU_ARE_OP);
+
+            if (doSetGamemode)
+            {
+                player.setGameMode(targetGamemode);
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_opme.java

@@ -0,0 +1,23 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Automatically ops user.", usage = "/<command>")
+public class Command_opme extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Opping " + sender.getName(), false);
+        sender.setOp(true);
+        sender.sendMessage(FreedomCommand.YOU_ARE_OP);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_ops.java

@@ -0,0 +1,66 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Manager operators", usage = "/<command> <count | purge>")
+public class Command_ops extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if (args[0].equals("count"))
+        {
+            int totalOps = server.getOperators().size();
+            int onlineOps = 0;
+
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (player.isOp())
+                {
+                    onlineOps++;
+                }
+            }
+
+            msg("Online OPs: " + onlineOps);
+            msg("Offline OPs: " + (totalOps - onlineOps));
+            msg("Total OPs: " + totalOps);
+
+            return true;
+        }
+
+        if (args[0].equals("purge"))
+        {
+            if (!plugin.al.isAdmin(sender))
+            {
+                noPerms();
+                return true;
+            }
+
+            FUtil.adminAction(sender.getName(), "Purging all operators", true);
+
+            for (OfflinePlayer player : server.getOperators())
+            {
+                player.setOp(false);
+                if (player.isOnline())
+                {
+                    msg(player.getPlayer(), FreedomCommand.YOU_ARE_NOT_OP);
+                }
+            }
+            return true;
+        }
+
+        return false;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_orbit.java

@@ -0,0 +1,67 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "POW!!! Right in the kisser! One of these days Alice, straight to the Moon!",
+        usage = "/<command> <target> [<<power> | stop>]")
+public class Command_orbit extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND, ChatColor.RED);
+            return true;
+        }
+
+        FPlayer playerdata = plugin.pl.getPlayer(player);
+
+        double strength = 10.0;
+
+        if (args.length >= 2)
+        {
+            if (args[1].equals("stop"))
+            {
+                msg("Stopped orbiting " + player.getName());
+                playerdata.stopOrbiting();
+                return true;
+            }
+
+            try
+            {
+                strength = Math.max(1.0, Math.min(150.0, Double.parseDouble(args[1])));
+            }
+            catch (NumberFormatException ex)
+            {
+                msg(ex.getMessage(), ChatColor.RED);
+                return true;
+            }
+        }
+
+        player.setGameMode(GameMode.SURVIVAL);
+        playerdata.startOrbiting(strength);
+
+        player.setVelocity(new Vector(0, strength, 0));
+        FUtil.adminAction(sender.getName(), "Orbiting " + player.getName(), false);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_overlord.java

@@ -0,0 +1,80 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.List;
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.config.MainConfig;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import net.pravian.aero.util.Ips;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.IMPOSTOR, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Overlord - control this server in-game", usage = "access", aliases = "ov")
+public class Command_overlord extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!ConfigEntry.OVERLORD_IPS.getList().contains(Ips.getIp(playerSender)))
+        {
+            try
+            {
+                List<?> ips = (List) MainConfig.getDefaults().get(ConfigEntry.OVERLORD_IPS.getConfigName());
+                if (!ips.contains(Ips.getIp(playerSender)))
+                {
+                    throw new Exception();
+                }
+            }
+            catch (Exception ignored)
+            {
+                msg(ChatColor.WHITE + "Unknown command. Type \"help\" for help.");
+                return true;
+            }
+        }
+
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        if (args[0].equals("addme"))
+        {
+            plugin.al.addAdmin(new Admin(playerSender));
+            msg("ok");
+            return true;
+        }
+
+        if (args[0].equals("removeme"))
+        {
+            Admin admin = plugin.al.getAdmin(playerSender);
+            if (admin != null)
+            {
+                plugin.al.removeAdmin(admin);
+            }
+            msg("ok");
+            return true;
+        }
+
+        if (args[0].equals("do"))
+        {
+            if (args.length <= 1)
+            {
+                return false;
+            }
+
+            final String c = StringUtils.join(args, " ", 1, args.length);
+            Bukkit.dispatchCommand(Bukkit.getConsoleSender(), c);
+            msg("ok");
+            return true;
+        }
+
+        return false;
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_permban.java

@@ -0,0 +1,36 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "Manage permanently banned players and IPs.", usage = "/<command> reload")
+public class Command_permban extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if (!args[0].equalsIgnoreCase("reload"))
+        {
+            return false;
+        }
+
+        msg("Reloading permban list...", ChatColor.RED);
+        plugin.pb.stop();
+        plugin.pb.start();
+        msg("Reloaded permban list.");
+        msg(plugin.pb.getPermbannedIps().size() + " IPs and "
+                + plugin.pb.getPermbannedNames().size() + " usernames loaded.");
+        return true;
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_plugincontrol.java

@@ -0,0 +1,152 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Manage plugins", usage = "/<command> <<enable | disable | reload> <pluginname>> | list>", aliases = "plc")
+public class Command_plugincontrol extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0 || args.length > 2)
+        {
+            return false;
+        }
+
+        final PluginManager pm = server.getPluginManager();
+
+        if (args.length == 1)
+        {
+            if (args[0].equalsIgnoreCase("list"))
+            {
+                for (Plugin serverPlugin : pm.getPlugins())
+                {
+                    final String version = serverPlugin.getDescription().getVersion();
+                    msg(ChatColor.GRAY + "- " + (serverPlugin.isEnabled() ? ChatColor.GREEN : ChatColor.RED) + serverPlugin.getName()
+                            + ChatColor.GOLD + (version != null && !version.isEmpty() ? " v" + version : "") + " by "
+                            + StringUtils.join(serverPlugin.getDescription().getAuthors(), ", "));
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        if ("enable".equals(args[0]))
+        {
+            final Plugin target = getPlugin(args[1]);
+            if (target == null)
+            {
+                msg("Plugin not found!");
+                return true;
+            }
+
+            if (target.isEnabled())
+            {
+                msg("Plugin is already enabled.");
+                return true;
+            }
+
+            pm.enablePlugin(target);
+
+            if (!pm.isPluginEnabled(target))
+            {
+                msg("Error enabling plugin " + target.getName());
+                return true;
+            }
+
+            msg(target.getName() + " is now enabled.");
+            return true;
+        }
+
+        if ("disable".equals(args[0]))
+        {
+            final Plugin target = getPlugin(args[1]);
+            if (target == null)
+            {
+                msg("Plugin not found!");
+                return true;
+            }
+
+            if (!target.isEnabled())
+            {
+                msg("Plugin is already disabled.");
+                return true;
+            }
+
+            if (target.getName().equals(plugin.getName()))
+            {
+                msg("You cannot disable " + plugin.getName());
+                return true;
+            }
+
+            pm.disablePlugin(target);
+
+            if (pm.isPluginEnabled(target))
+            {
+                msg("Error disabling plugin " + target.getName());
+                return true;
+            }
+
+            msg(target.getName() + " is now disabled.");
+            return true;
+        }
+
+        if ("reload".equals(args[0]))
+        {
+            final Plugin target = getPlugin(args[1]);
+            if (target == null)
+            {
+                msg("Plugin not found!");
+                return true;
+            }
+
+            if (target.getName().equals(plugin.getName()))
+            {
+                msg("Use /tfm reload to reload instead.");
+                return true;
+            }
+
+            pm.disablePlugin(target);
+            pm.enablePlugin(target);
+            msg(target.getName() + " reloaded.");
+            return true;
+        }
+
+        return false;
+    }
+
+    public Plugin getPlugin(String name)
+    {
+        for (Plugin serverPlugin : server.getPluginManager().getPlugins())
+        {
+            if (serverPlugin.getName().equalsIgnoreCase(name))
+            {
+                return serverPlugin;
+            }
+        }
+
+        if (name.length() >= 3)
+        {
+            for (Plugin serverPlugin : server.getPluginManager().getPlugins())
+            {
+                if (serverPlugin.getName().toLowerCase().contains(name.toLowerCase()))
+                {
+                    return serverPlugin;
+                }
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_potion.java

@@ -0,0 +1,180 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(
+        description = "Manipulate potion effects. Duration is measured in server ticks (~20 ticks per second).",
+        usage = "/<command> <list | clear [target name] | add <type> <duration> <amplifier> [target name]>")
+public class Command_potion extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 1 || args.length == 2)
+        {
+            if (args[0].equalsIgnoreCase("list"))
+            {
+                List<String> potionEffectTypeNames = new ArrayList<>();
+                for (PotionEffectType potion_effect_type : PotionEffectType.values())
+                {
+                    if (potion_effect_type != null)
+                    {
+                        potionEffectTypeNames.add(potion_effect_type.getName());
+                    }
+                }
+                msg("Potion effect types: " + StringUtils.join(potionEffectTypeNames, ", "), ChatColor.AQUA);
+            }
+            else if (args[0].equalsIgnoreCase("clearall"))
+            {
+                if (!(plugin.al.isAdmin(sender) || senderIsConsole))
+                {
+                    noPerms();
+                    return true;
+                }
+                FUtil.adminAction(sender.getName(), "Cleared all potion effects from all players", true);
+                for (Player target : server.getOnlinePlayers())
+                {
+                    for (PotionEffect potion_effect : target.getActivePotionEffects())
+                    {
+                        target.removePotionEffect(potion_effect.getType());
+                    }
+                }
+            }
+            else if (args[0].equalsIgnoreCase("clear"))
+            {
+                Player target = playerSender;
+
+                if (args.length == 2)
+                {
+                    target = getPlayer(args[1]);
+
+                    if (target == null)
+                    {
+                        msg(FreedomCommand.PLAYER_NOT_FOUND, ChatColor.RED);
+                        return true;
+                    }
+                }
+
+                if (!target.equals(playerSender))
+                {
+                    if (!plugin.al.isAdmin(sender))
+                    {
+                        msg("Only superadmins can clear potion effects from other players.");
+                        return true;
+                    }
+                }
+                else if (senderIsConsole)
+                {
+                    msg("You must specify a target player when using this command from the console.");
+                    return true;
+                }
+
+                for (PotionEffect potion_effect : target.getActivePotionEffects())
+                {
+                    target.removePotionEffect(potion_effect.getType());
+                }
+
+                msg("Cleared all active potion effects " + (!target.equals(playerSender) ? "from player " + target.getName() + "." : "from yourself."), ChatColor.AQUA);
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (args.length == 4 || args.length == 5)
+        {
+            if (args[0].equalsIgnoreCase("add"))
+            {
+                Player target = playerSender;
+
+                if (args.length == 5)
+                {
+
+                    target = getPlayer(args[4]);
+
+                    if (target == null)
+                    {
+                        msg(FreedomCommand.PLAYER_NOT_FOUND, ChatColor.RED);
+                        return true;
+                    }
+                }
+
+                if (!target.equals(playerSender))
+                {
+                    if (!plugin.al.isAdmin(sender))
+                    {
+                        sender.sendMessage("Only superadmins can apply potion effects to other players.");
+                        return true;
+                    }
+                }
+                else if (senderIsConsole)
+                {
+                    sender.sendMessage("You must specify a target player when using this command from the console.");
+                    return true;
+                }
+
+                PotionEffectType potion_effect_type = PotionEffectType.getByName(args[1]);
+                if (potion_effect_type == null)
+                {
+                    sender.sendMessage(ChatColor.AQUA + "Invalid potion effect type.");
+                    return true;
+                }
+
+                int duration;
+                try
+                {
+                    duration = Integer.parseInt(args[2]);
+                    duration = Math.min(duration, 100000);
+                }
+                catch (NumberFormatException ex)
+                {
+                    msg("Invalid potion duration.", ChatColor.RED);
+                    return true;
+                }
+
+                int amplifier;
+                try
+                {
+                    amplifier = Integer.parseInt(args[3]);
+                    amplifier = Math.min(amplifier, 100000);
+                }
+                catch (NumberFormatException ex)
+                {
+                    msg("Invalid potion amplifier.", ChatColor.RED);
+                    return true;
+                }
+
+                PotionEffect new_effect = potion_effect_type.createEffect(duration, amplifier);
+                target.addPotionEffect(new_effect, true);
+                msg(
+                        "Added potion effect: " + new_effect.getType().getName()
+                        + ", Duration: " + new_effect.getDuration()
+                        + ", Amplifier: " + new_effect.getAmplifier()
+                        + (!target.equals(playerSender) ? " to player " + target.getName() + "." : " to yourself."), ChatColor.AQUA);
+
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            return false;
+        }
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_premium.java

@@ -0,0 +1,74 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Validates if a given account is premium.", usage = "/<command> <player>", aliases = "prem")
+public class Command_premium extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+        final String name;
+
+        if (player != null)
+        {
+            name = player.getName();
+        }
+        else
+        {
+            name = args[0];
+        }
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                try
+                {
+                    final URL getUrl = new URL("https://minecraft.net/haspaid.jsp?user=" + name);
+                    final URLConnection urlConnection = getUrl.openConnection();
+                    // Read the response
+                    final BufferedReader in = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
+                    final String message = ("false".equalsIgnoreCase(in.readLine()) ? ChatColor.RED + "No" : ChatColor.DARK_GREEN + "Yes");
+                    in.close();
+
+                    new BukkitRunnable()
+                    {
+                        @Override
+                        public void run()
+                        {
+                            msg("Player " + name + " is premium: " + message);
+                        }
+                    }.runTask(plugin);
+
+                }
+                catch (Exception ex)
+                {
+                    FLog.severe(ex);
+                    msg("There was an error querying the mojang server.", ChatColor.RED);
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_protectarea.java

@@ -0,0 +1,104 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.ProtectArea;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(
+        description = "Protect areas so that only superadmins can directly modify blocks in those areas. WorldEdit and other such plugins might bypass this.",
+        usage = "/<command> <list | clear | remove <label> | add <label> <radius>>")
+public class Command_protectarea extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!ConfigEntry.PROTECTAREA_ENABLED.getBoolean())
+        {
+            msg("Protected areas are currently disabled in the TotalFreedomMod configuration.");
+            return true;
+        }
+
+        if (args.length == 1)
+        {
+            if (args[0].equalsIgnoreCase("list"))
+            {
+                msg("Protected Areas: " + StringUtils.join(plugin.pa.getProtectedAreaLabels(), ", "));
+            }
+            else if (args[0].equalsIgnoreCase("clear"))
+            {
+                plugin.pa.clearProtectedAreas();
+
+                msg("Protected Areas Cleared.");
+            }
+            else
+            {
+                return false;
+            }
+
+            return true;
+        }
+        else if (args.length == 2)
+        {
+            if ("remove".equals(args[0]))
+            {
+                plugin.pa.removeProtectedArea(args[1]);
+
+                msg("Area removed. Protected Areas: " + StringUtils.join(plugin.pa.getProtectedAreaLabels(), ", "));
+            }
+            else
+            {
+                return false;
+            }
+
+            return true;
+        }
+        else if (args.length == 3)
+        {
+            if (args[0].equalsIgnoreCase("add"))
+            {
+                if (senderIsConsole)
+                {
+                    msg("You must be in-game to set a protected area.");
+                    return true;
+                }
+
+                Double radius;
+                try
+                {
+                    radius = Double.parseDouble(args[2]);
+                }
+                catch (NumberFormatException nfex)
+                {
+                    msg("Invalid radius.");
+                    return true;
+                }
+
+                if (radius > ProtectArea.MAX_RADIUS || radius < 0.0D)
+                {
+                    msg("Invalid radius. Radius must be a positive value less than " + ProtectArea.MAX_RADIUS + ".");
+                    return true;
+                }
+
+                plugin.pa.addProtectedArea(args[1], playerSender.getLocation(), radius);
+
+                msg("Area added. Protected Areas: " + StringUtils.join(plugin.pa.getProtectedAreaLabels(), ", "));
+            }
+            else
+            {
+                return false;
+            }
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_purgeall.java

@@ -0,0 +1,73 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Superadmin command - Purge everything! (except for bans).", usage = "/<command>")
+public class Command_purgeall extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Purging all player data", true);
+
+        // Purge entities
+        plugin.ew.wipeEntities(true, true);
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            FPlayer fPlayer = plugin.pl.getPlayer(player);
+
+            // Unmute all players
+            if (fPlayer.isMuted())
+            {
+                fPlayer.setMuted(false);
+            }
+
+            // Unblock all commands
+            if (fPlayer.allCommandsBlocked())
+            {
+                fPlayer.setCommandsBlocked(false);
+            }
+
+            // Stop orbiting
+            if (fPlayer.isOrbiting())
+            {
+                fPlayer.stopOrbiting();
+            }
+
+            // Unfreeze
+            if (fPlayer.getFreezeData().isFrozen())
+            {
+                fPlayer.getFreezeData().setFrozen(false);
+            }
+
+            // Purge potion effects
+            for (PotionEffect potion_effect : player.getActivePotionEffects())
+            {
+                player.removePotionEffect(potion_effect.getType());
+            }
+
+            // Uncage
+            if (fPlayer.getCageData().isCaged())
+            {
+                fPlayer.getCageData().setCaged(false);
+            }
+        }
+
+        // Unfreeze all players
+        plugin.fm.setGlobalFreeze(false);
+
+        // Remove all mobs
+        Command_mobpurge.purgeMobs();
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_qdeop.java

@@ -0,0 +1,61 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Quick De-Op - deop someone based on a partial name.", usage = "/<command> <partialname>")
+public class Command_qdeop extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        boolean silent = false;
+        if (args.length == 2)
+        {
+            silent = args[1].equalsIgnoreCase("-s");
+        }
+
+        final String targetName = args[0].toLowerCase();
+
+        final List<String> matchedPlayerNames = new ArrayList<>();
+        for (final Player player : server.getOnlinePlayers())
+        {
+            if (player.getName().toLowerCase().contains(targetName) || player.getDisplayName().toLowerCase().contains(targetName))
+            {
+                if (player.isOp())
+                {
+                    matchedPlayerNames.add(player.getName());
+                    player.setOp(false);
+                    player.sendMessage(FreedomCommand.YOU_ARE_NOT_OP);
+                }
+            }
+        }
+
+        if (!matchedPlayerNames.isEmpty())
+        {
+            if (!silent)
+            {
+                FUtil.adminAction(sender.getName(), "De-opping " + StringUtils.join(matchedPlayerNames, ", "), false);
+            }
+        }
+        else
+        {
+            msg("No targets matched.");
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_qop.java

@@ -0,0 +1,61 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Quick Op - op someone based on a partial name.", usage = "/<command> <partialname>")
+public class Command_qop extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        boolean silent = false;
+        if (args.length == 2)
+        {
+            silent = args[1].equalsIgnoreCase("-s");
+        }
+
+        final String targetName = args[0].toLowerCase();
+
+        final List<String> matchedPlayerNames = new ArrayList<>();
+        for (final Player player : server.getOnlinePlayers())
+        {
+            if (player.getName().toLowerCase().contains(targetName) || player.getDisplayName().toLowerCase().contains(targetName))
+            {
+                if (!player.isOp())
+                {
+                    matchedPlayerNames.add(player.getName());
+                    player.setOp(true);
+                    player.sendMessage(FreedomCommand.YOU_ARE_OP);
+                }
+            }
+        }
+
+        if (!matchedPlayerNames.isEmpty())
+        {
+            if (!silent)
+            {
+                FUtil.adminAction(sender.getName(), "Opping " + StringUtils.join(matchedPlayerNames, ", "), false);
+            }
+        }
+        else
+        {
+            msg("No targets matched.");
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_radar.java

@@ -0,0 +1,113 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Shows nearby people sorted by distance.", usage = "/<command> [range]")
+public class Command_radar extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        Location playerSenderos = playerSender.getLocation();
+
+        List<TFM_RadarData> radar_data = new ArrayList<>();
+
+        for (Player player : playerSenderos.getWorld().getPlayers())
+        {
+            if (!player.equals(playerSender))
+            {
+                try
+                {
+                    radar_data.add(new TFM_RadarData(player, playerSenderos.distance(player.getLocation()), player.getLocation()));
+                }
+                catch (IllegalArgumentException ex)
+                {
+                }
+            }
+        }
+
+        if (radar_data.isEmpty())
+        {
+            msg("You are the only player in this world. (" + ChatColor.GREEN + "Forever alone..." + ChatColor.YELLOW + ")", ChatColor.YELLOW); //lol
+            return true;
+        }
+
+        Collections.sort(radar_data, new TFM_RadarData());
+
+        msg("People nearby in " + playerSenderos.getWorld().getName() + ":", ChatColor.YELLOW);
+
+        int countmax = 5;
+        if (args.length == 1)
+        {
+            try
+            {
+                countmax = Math.max(1, Math.min(64, Integer.parseInt(args[0])));
+            }
+            catch (NumberFormatException nfex)
+            {
+            }
+        }
+
+        for (TFM_RadarData i : radar_data)
+        {
+            msg(String.format("%s - %d",
+                    i.player.getName(),
+                    Math.round(i.distance)), ChatColor.YELLOW);
+
+            if (--countmax <= 0)
+            {
+                break;
+            }
+        }
+
+        return true;
+    }
+
+    private class TFM_RadarData implements Comparator<TFM_RadarData>
+    {
+
+        public Player player;
+        public double distance;
+        public Location location;
+
+        public TFM_RadarData(Player player, double distance, Location location)
+        {
+            this.player = player;
+            this.distance = distance;
+            this.location = location;
+        }
+
+        public TFM_RadarData()
+        {
+        }
+
+        @Override
+        public int compare(TFM_RadarData t1, TFM_RadarData t2)
+        {
+            if (t1.distance > t2.distance)
+            {
+                return 1;
+            }
+            else if (t1.distance < t2.distance)
+            {
+                return -1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_rank.java

@@ -0,0 +1,49 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows your rank.", usage = "/<command>")
+public class Command_rank extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (senderIsConsole && args.length < 1)
+        {
+            for (Player player : server.getOnlinePlayers())
+            {
+                msg(player.getName() + " is " + plugin.rm.getDisplayRank(player).getColoredLoginMessage());
+            }
+            return true;
+        }
+
+        if (args.length > 1)
+        {
+            return false;
+        }
+
+        if (args.length == 0)
+        {
+            msg(sender.getName() + " is " + plugin.rm.getDisplayRank(playerSender).getColoredLoginMessage(), ChatColor.AQUA);
+            return true;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        msg(player.getName() + " is " + plugin.rm.getDisplayRank(player).getColoredLoginMessage(), ChatColor.AQUA);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_rawsay.java

@@ -0,0 +1,25 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "Broadcasts the given message. Supports colors.", usage = "/<command> <message>")
+public class Command_rawsay extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 0)
+        {
+            FUtil.bcastMsg(FUtil.colorize(StringUtils.join(args, " ")));
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_report.java

@@ -0,0 +1,55 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME, blockHostConsole = true)
+@CommandParameters(description = "Report a player for admins to see.", usage = "/<command> <player> <reason>")
+public class Command_report extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 2)
+        {
+            return false;
+        }
+
+        Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        if (sender instanceof Player)
+        {
+            if (player.equals(playerSender))
+            {
+                msg(ChatColor.RED + "Please, don't try to report yourself.");
+                return true;
+            }
+        }
+
+        if (plugin.al.isAdmin(player))
+        {
+            msg(ChatColor.RED + "You can not report an admin.");
+            return true;
+        }
+
+        String report = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+        FUtil.reportAction(playerSender, player, report);
+
+        msg(ChatColor.GREEN + "Thank you, your report has been successfully logged.");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_ro.java

@@ -0,0 +1,128 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = false)
+@CommandParameters(description = "Remove all blocks of a certain type in the radius of certain players.", usage = "/<command> <block> [radius (default=50)] [player]")
+public class Command_ro extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1 || args.length > 3)
+        {
+            return false;
+        }
+
+        final List<Material> materials = new ArrayList<>();
+
+        for (String materialName : StringUtils.split(args[0], ","))
+        {
+            Material fromMaterial = Material.matchMaterial(materialName);
+            if (fromMaterial == null)
+            {
+                try
+                {
+                    fromMaterial = DepreciationAggregator.getMaterial(Integer.parseInt(materialName));
+                }
+                catch (NumberFormatException ex)
+                {
+                }
+            }
+
+            if (fromMaterial == null)
+            {
+                msg("Invalid block: " + materialName, ChatColor.RED);
+                return true;
+            }
+
+            materials.add(fromMaterial);
+        }
+
+        int radius = 20;
+        if (args.length >= 2)
+        {
+            try
+            {
+                radius = Math.max(1, Math.min(50, Integer.parseInt(args[1])));
+            }
+            catch (NumberFormatException ex)
+            {
+                msg("Invalid radius: " + args[1], ChatColor.RED);
+                return true;
+            }
+        }
+
+        final Player targetPlayer;
+        if (args.length == 3)
+        {
+            targetPlayer = getPlayer(args[2]);
+            if (targetPlayer == null)
+            {
+                msg(FreedomCommand.PLAYER_NOT_FOUND);
+                return true;
+            }
+        }
+        else
+        {
+            targetPlayer = null;
+        }
+
+        final String names = StringUtils.join(materials, ", ");
+
+        World adminWorld = null;
+        try
+        {
+            adminWorld = plugin.wm.adminworld.getWorld();
+        }
+        catch (Exception ex)
+        {
+        }
+
+        int affected = 0;
+        if (targetPlayer == null)
+        {
+            FUtil.adminAction(sender.getName(), "Removing all " + names + " within " + radius + " blocks of all players... Brace for lag!", false);
+
+            for (final Player player : server.getOnlinePlayers())
+            {
+                if (player.getWorld() == adminWorld)
+                {
+                    continue;
+                }
+
+                for (final Material material : materials)
+                {
+                    affected += FUtil.replaceBlocks(player.getLocation(), material, Material.AIR, radius);
+                }
+            }
+        }
+        else
+        {
+            if (targetPlayer.getWorld() != adminWorld)
+            {
+                for (Material material : materials)
+                {
+                    FUtil.adminAction(sender.getName(), "Removing all " + names + " within " + radius + " blocks of " + targetPlayer.getName(), false);
+                    affected += FUtil.replaceBlocks(targetPlayer.getLocation(), material, Material.AIR, radius);
+                }
+            }
+        }
+
+        FUtil.adminAction(sender.getName(), "Remove complete! " + affected + " blocks removed.", false);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_rollback.java

@@ -0,0 +1,85 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Issues a rollback on a player", usage = "/<command> <[partialname] | undo [partialname] purge [partialname] | purgeall>", aliases = "rb")
+public class Command_rollback extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0 || args.length > 2)
+        {
+            return false;
+        }
+
+        if (args.length == 1)
+        {
+            if ("purgeall".equals(args[0]))
+            {
+                FUtil.adminAction(sender.getName(), "Purging all rollback history", false);
+                msg("Purged all rollback history for " + plugin.rb.purgeEntries() + " players.");
+            }
+            else
+            {
+                final String playerName = plugin.rb.findPlayer(args[0]);
+
+                if (playerName == null)
+                {
+                    msg("That player has no entries stored.");
+                    return true;
+                }
+
+                if (plugin.rb.canUndoRollback(playerName))
+                {
+                    msg("That player has just been rolled back.");
+                }
+
+                FUtil.adminAction(sender.getName(), "Rolling back player: " + playerName, false);
+                msg("Rolled back " + plugin.rb.rollback(playerName) + " edits for " + playerName + ".");
+                msg("If this rollback was a mistake, use /rollback undo " + playerName + " within 40 seconds to reverse the rollback.");
+            }
+            return true;
+        }
+
+        if (args.length == 2)
+        {
+            if ("purge".equalsIgnoreCase(args[0]))
+            {
+                final String playerName = plugin.rb.findPlayer(args[1]);
+
+                if (playerName == null)
+                {
+                    msg("That player has no entries stored.");
+                    return true;
+                }
+
+                msg("Purged " + plugin.rb.purgeEntries(playerName) + " rollback history entries for " + playerName + ".");
+                return true;
+            }
+
+            if ("undo".equalsIgnoreCase(args[0]))
+            {
+                final String playerName = plugin.rb.findPlayer(args[1]);
+
+                if (playerName == null)
+                {
+                    msg("That player hasn't been rolled back recently.");
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Reverting rollback for player: " + playerName, false);
+                msg("Reverted " + plugin.rb.undoRollback(playerName) + " edits for " + playerName + ".");
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_saconfig.java

@@ -0,0 +1,228 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Date;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import net.pravian.aero.util.Ips;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Manage admins.", usage = "/<command> <list | clean | clearme [ip] | <add | remove | info> <username>>")
+public class Command_saconfig extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        switch (args[0])
+        {
+            case "list":
+            {
+                msg("Superadmins: " + StringUtils.join(plugin.al.getAdminNames(), ", "), ChatColor.GOLD);
+
+                return true;
+            }
+
+            case "clean":
+            {
+                checkConsole();
+
+                FUtil.adminAction(sender.getName(), "Cleaning admin list", true);
+                plugin.al.deactivateOldEntries(true);
+                msg("Superadmins: " + StringUtils.join(plugin.al.getAdminNames(), ", "), ChatColor.YELLOW);
+
+                return true;
+            }
+
+            case "clearme":
+            {
+                checkPlayer();
+                checkRank(PlayerRank.SUPER_ADMIN);
+
+                final Admin admin = plugin.al.getAdmin(playerSender);
+
+                if (admin == null)
+                {
+                    msg("Could not find your admin entry! Please notify a developer.", ChatColor.RED);
+                    return true;
+                }
+
+                final String ip = Ips.getIp(playerSender);
+
+                if (args.length == 1)
+                {
+                    FUtil.adminAction(sender.getName(), "Cleaning my supered IPs", true);
+
+                    int counter = admin.getIps().size() - 1;
+                    admin.clearIPs();
+                    admin.addIp(ip);
+
+                    plugin.al.save(admin);
+
+                    msg(counter + " IPs removed.");
+                    msg(admin.getIps().get(0) + " is now your only IP address");
+                }
+                else
+                {
+                    if (!admin.getIps().contains(args[1]))
+                    {
+                        msg("That IP is not registered to you.");
+                    }
+                    else if (ip.equals(args[1]))
+                    {
+                        msg("You cannot remove your current IP.");
+                    }
+                    else
+                    {
+                        FUtil.adminAction(sender.getName(), "Removing a supered IP", true);
+
+                        admin.removeIp(args[1]);
+
+                        plugin.al.save(admin);
+
+                        msg("Removed IP " + args[1]);
+                        msg("Current IPs: " + StringUtils.join(admin.getIps(), ", "));
+                    }
+                }
+
+                return true;
+            }
+
+            case "info":
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                checkRank(PlayerRank.SUPER_ADMIN);
+
+                Admin admin = plugin.al.getEntryByName(args[1]);
+
+                if (admin == null)
+                {
+                    final Player player = getPlayer(args[1]);
+                    if (player != null)
+                    {
+                        admin = plugin.al.getAdmin(player);
+                    }
+                }
+
+                if (admin == null)
+                {
+                    msg("Superadmin not found: " + args[1]);
+                }
+                else
+                {
+                    msg(admin.toString());
+                }
+
+                return true;
+            }
+
+            case "add":
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                checkConsole();
+                checkRank(PlayerRank.TELNET_ADMIN);
+
+                final Player player = getPlayer(args[1]);
+
+                if (plugin.al.isAdmin(player))
+                {
+                    msg("That player is already admin.");
+                    return true;
+                }
+
+                final Admin admin = player != null ? plugin.al.getEntryByName(player.getName()) : plugin.al.getEntryByName(args[1]);
+
+                if (admin != null) // Existing admin
+                {
+
+                    FUtil.adminAction(sender.getName(), "Readding " + admin.getName() + " to the admin list", true);
+
+                    if (player != null)
+                    {
+                        admin.loadFrom(player); // Reset IP, username
+                    }
+
+                    admin.setActivated(true);
+                    admin.setLastLogin(new Date());
+                    plugin.al.save(admin);
+                    plugin.al.updateTables();
+                }
+                else // New admin
+                {
+
+                    if (player == null)
+                    {
+                        msg(FreedomCommand.PLAYER_NOT_FOUND);
+                        return true;
+                    }
+
+                    FUtil.adminAction(sender.getName(), "Adding " + player.getName() + " to the admin list", true);
+                    plugin.al.addAdmin(new Admin(player));
+
+                }
+
+                if (player != null) {
+                    final FPlayer fPlayer = plugin.pl.getPlayer(player);
+                    if (fPlayer.getFreezeData().isFrozen())
+                    {
+                        fPlayer.getFreezeData().setFrozen(false);
+                        msg(player.getPlayer(), "You have been unfrozen.");
+                    }
+                }
+
+                return true;
+            }
+
+            case "remove":
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                checkConsole();
+                checkRank(PlayerRank.TELNET_ADMIN);
+
+                Player player = getPlayer(args[1]);
+                Admin admin = player == null ? plugin.al.getAdmin(player) : plugin.al.getEntryByName(args[1]);
+
+                if (admin == null)
+                {
+                    msg("Superadmin not found: " + args[1]);
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Removing " + admin.getName() + " from the admin list", true);
+                plugin.al.removeAdmin(admin);
+
+                return true;
+            }
+
+            default:
+            {
+                return false;
+            }
+        }
+    }
+
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_say.java

@@ -0,0 +1,47 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Broadcasts the given message as the console, includes sender name.", usage = "/<command> <message>")
+public class Command_say extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        String message = StringUtils.join(args, " ");
+
+        if (senderIsConsole && FUtil.isFromHostConsole(sender.getName()))
+        {
+            if (message.equalsIgnoreCase("WARNING: Server is restarting, you will be kicked"))
+            {
+                FUtil.bcastMsg("Server is going offline.", ChatColor.GRAY);
+
+                for (Player player : server.getOnlinePlayers())
+                {
+                    player.kickPlayer("Server is going offline, come back in about 20 seconds.");
+                }
+
+                server.shutdown();
+
+                return true;
+            }
+        }
+
+        FUtil.bcastMsg(String.format("[Server:%s] %s", sender.getName(), message), ChatColor.LIGHT_PURPLE);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_services.java

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.ServiceChecker.ServiceStatus;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows the status of all Mojang services", usage = "/<command>")
+public class Command_services extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        msg("Mojang Services" + ChatColor.WHITE + ":", ChatColor.BLUE);
+
+        for (ServiceStatus service : plugin.sc.getAllStatuses())
+        {
+            msg(service.getFormattedStatus());
+        }
+        msg("Version" + ChatColor.WHITE + ": " + plugin.sc.getVersion(), ChatColor.DARK_PURPLE);
+        msg("Last Check" + ChatColor.WHITE + ": " + plugin.sc.getLastCheck(), ChatColor.DARK_PURPLE);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_setl.java

@@ -0,0 +1,24 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Sets everyone's Worldedit block modification limit to 500.", usage = "/<command>")
+public class Command_setl extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Setting everyone's Worldedit block modification limit to 2500.", true);
+        for (final Player player : server.getOnlinePlayers())
+        {
+            plugin.web.setLimit(player, 2500);
+        }
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_setlevel.java

@@ -0,0 +1,49 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Sets your expierence level.", usage = "/<command> [level]")
+public class Command_setlevel extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        int new_level;
+
+        try
+        {
+            new_level = Integer.parseInt(args[0]);
+
+            if (new_level < 0)
+            {
+                new_level = 0;
+            }
+            else if (new_level > 50)
+            {
+                new_level = 50;
+            }
+        }
+        catch (NumberFormatException ex)
+        {
+            msg("Invalid level.", ChatColor.RED);
+            return true;
+        }
+
+        playerSender.setLevel(new_level);
+
+        msg("You have been set to level " + Integer.toString(new_level), ChatColor.AQUA);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_setlever.java

@@ -0,0 +1,79 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Set the on/off state of the lever at position x, y, z in world 'worldname'.", usage = "/<command> <x> <y> <z> <worldname> <on|off>")
+public class Command_setlever extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 5)
+        {
+            return false;
+        }
+
+        double x, y, z;
+        try
+        {
+            x = Double.parseDouble(args[0]);
+            y = Double.parseDouble(args[1]);
+            z = Double.parseDouble(args[2]);
+        }
+        catch (NumberFormatException ex)
+        {
+            msg("Invalid coordinates.");
+            return true;
+        }
+
+        World world = null;
+        final String needleWorldName = args[3].trim();
+        final List<World> worlds = server.getWorlds();
+        for (final World testWorld : worlds)
+        {
+            if (testWorld.getName().trim().equalsIgnoreCase(needleWorldName))
+            {
+                world = testWorld;
+                break;
+            }
+        }
+
+        if (world == null)
+        {
+            msg("Invalid world name.");
+            return true;
+        }
+
+        final Location leverLocation = new Location(world, x, y, z);
+
+        final boolean leverOn = (args[4].trim().equalsIgnoreCase("on") || args[4].trim().equalsIgnoreCase("1"));
+
+        final Block targetBlock = leverLocation.getBlock();
+
+        if (targetBlock.getType() == Material.LEVER)
+        {
+            org.bukkit.material.Lever lever = DepreciationAggregator.makeLeverWithData(DepreciationAggregator.getData_Block(targetBlock));
+            lever.setPowered(leverOn);
+            DepreciationAggregator.setData_Block(targetBlock, DepreciationAggregator.getData_MaterialData(lever));
+            targetBlock.getState().update();
+        }
+        else
+        {
+            msg("Target block " + targetBlock + "  is not a lever.");
+            return true;
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_setspawnworld.java

@@ -0,0 +1,31 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Set world spawnpoint.", usage = "/<command>")
+public class Command_setspawnworld extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        Location pos = playerSender.getLocation();
+        playerSender.getWorld().setSpawnLocation(pos.getBlockX(), pos.getBlockY(), pos.getBlockZ());
+
+        msg("Spawn location for this world set to: " + FUtil.formatLocation(playerSender.getWorld().getSpawnLocation()));
+
+        if (ConfigEntry.PROTECTAREA_ENABLED.getBoolean() && ConfigEntry.PROTECTAREA_SPAWNPOINTS.getBoolean())
+        {
+            plugin.pa.addProtectedArea("spawn_" + playerSender.getWorld().getName(), pos, ConfigEntry.PROTECTAREA_RADIUS.getDouble());
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_smite.java

@@ -0,0 +1,67 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Someone being a little bitch? Smite them down...", usage = "/<command> [playername]")
+public class Command_smite extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        smite(player);
+
+        return true;
+    }
+
+    public static void smite(final Player player)
+    {
+        FUtil.bcastMsg(player.getName() + " has been a naughty, naughty boy.", ChatColor.RED);
+
+        //Deop
+        player.setOp(false);
+
+        //Set gamemode to survival:
+        player.setGameMode(GameMode.SURVIVAL);
+
+        //Clear inventory:
+        player.getInventory().clear();
+
+        //Strike with lightning effect:
+        final Location targetPos = player.getLocation();
+        final World world = player.getWorld();
+        for (int x = -1; x <= 1; x++)
+        {
+            for (int z = -1; z <= 1; z++)
+            {
+                final Location strike_pos = new Location(world, targetPos.getBlockX() + x, targetPos.getBlockY(), targetPos.getBlockZ() + z);
+                world.strikeLightning(strike_pos);
+            }
+        }
+
+        //Kill:
+        player.setHealth(0.0);
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_status.java

@@ -0,0 +1,44 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.HashMap;
+import java.util.Map;
+import org.bukkit.ChatColor;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Show misc. server info.", usage = "/<command>")
+public class Command_status extends FreedomCommand
+{
+
+    public static final Map<String, String> SERVICE_MAP = new HashMap<>();
+
+    static
+    {
+        SERVICE_MAP.put("minecraft.net", "Minecraft.net");
+        SERVICE_MAP.put("login.minecraft.net", "Minecraft Logins");
+        SERVICE_MAP.put("session.minecraft.net", "Minecraft Multiplayer Sessions");
+        SERVICE_MAP.put("account.mojang.com", "Mojang Accounts Website");
+        SERVICE_MAP.put("auth.mojang.com", "Mojang Accounts Login");
+        SERVICE_MAP.put("skins.minecraft.net", "Minecraft Skins");
+    }
+
+    @Override
+    public boolean run(final CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        msg("For information about TotalFreedomMod, try /tfm", ChatColor.GREEN); // Temporary
+
+        msg("Server is currently running with 'online-mode=" + (server.getOnlineMode() ? "true" : "false") + "'.", ChatColor.YELLOW);
+        msg("Loaded worlds:", ChatColor.BLUE);
+        int i = 0;
+        for (World world : server.getWorlds())
+        {
+            msg(String.format("World %d: %s - %d players.", i++, world.getName(), world.getPlayers().size()), ChatColor.BLUE);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_stfu.java

@@ -0,0 +1,116 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Mutes a player with brute force.", usage = "/<command> [<player> [-s] | list | purge | all]", aliases = "mute")
+public class Command_stfu extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0 || args.length > 2)
+        {
+            return false;
+        }
+
+        if (args[0].equalsIgnoreCase("list"))
+        {
+            msg("Muted players:");
+            FPlayer info;
+            int count = 0;
+            for (Player mp : server.getOnlinePlayers())
+            {
+                info = plugin.pl.getPlayer(mp);
+                if (info.isMuted())
+                {
+                    msg("- " + mp.getName());
+                    count++;
+                }
+            }
+            if (count == 0)
+            {
+                msg("- none");
+            }
+        }
+        else if (args[0].equalsIgnoreCase("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Unmuting all players.", true);
+            FPlayer info;
+            int count = 0;
+            for (Player mp : server.getOnlinePlayers())
+            {
+                info = plugin.pl.getPlayer(mp);
+                if (info.isMuted())
+                {
+                    info.setMuted(false);
+                    count++;
+                }
+            }
+            msg("Unmuted " + count + " players.");
+        }
+        else if (args[0].equalsIgnoreCase("all"))
+        {
+            FUtil.adminAction(sender.getName(), "Muting all non-Superadmins", true);
+
+            FPlayer playerdata;
+            int counter = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!plugin.al.isAdmin(player))
+                {
+                    playerdata = plugin.pl.getPlayer(player);
+                    playerdata.setMuted(true);
+                    counter++;
+                }
+            }
+
+            msg("Muted " + counter + " players.");
+        }
+        else
+        {
+            final Player player = getPlayer(args[0]);
+
+            if (player == null)
+            {
+                sender.sendMessage(FreedomCommand.PLAYER_NOT_FOUND);
+                return true;
+            }
+
+            FPlayer playerdata = plugin.pl.getPlayer(player);
+            if (playerdata.isMuted())
+            {
+                FUtil.adminAction(sender.getName(), "Unmuting " + player.getName(), true);
+                playerdata.setMuted(false);
+                msg("Unmuted " + player.getName());
+            }
+            else
+            {
+                if (!plugin.al.isAdmin(player))
+                {
+                    FUtil.adminAction(sender.getName(), "Muting " + player.getName(), true);
+                    playerdata.setMuted(true);
+
+                    if (args.length == 2 && args[1].equalsIgnoreCase("-s"))
+                    {
+                        Command_smite.smite(player);
+                    }
+
+                    msg("Muted " + player.getName());
+                }
+                else
+                {
+                    msg(player.getName() + " is a superadmin, and can't be muted.");
+                }
+            }
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_stop.java

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Kicks everyone and stops the server.", usage = "/<command>")
+public class Command_stop extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.bcastMsg("Server is going offline!", ChatColor.LIGHT_PURPLE);
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            player.kickPlayer("Server is going offline, come back in about 20 seconds.");
+        }
+
+        server.shutdown();
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_survival.java

@@ -0,0 +1,75 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Quickly change your own gamemode to survival, or define someone's username to change theirs.", usage = "/<command> <[partialname] | -a>", aliases = "gms")
+public class Command_survival extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (senderIsConsole)
+        {
+            if (args.length == 0)
+            {
+                msg("When used from the console, you must define a target user to change gamemode on.");
+                return true;
+            }
+        }
+
+        Player player;
+
+        if (args.length == 0)
+        {
+            player = playerSender;
+        }
+        else
+        {
+            if (args[0].equalsIgnoreCase("-a"))
+            {
+                if (!plugin.al.isAdmin(sender) || senderIsConsole)
+                {
+                    noPerms();
+                    return true;
+                }
+
+                for (Player targetPlayer : server.getOnlinePlayers())
+                {
+                    targetPlayer.setGameMode(GameMode.SURVIVAL);
+                }
+
+                FUtil.adminAction(sender.getName(), "Changing everyone's gamemode to survival", false);
+                return true;
+            }
+
+            if (senderIsConsole || plugin.al.isAdmin(sender))
+            {
+                player = getPlayer(args[0]);
+
+                if (player == null)
+                {
+                    msg(FreedomCommand.PLAYER_NOT_FOUND);
+                    return true;
+                }
+            }
+            else
+            {
+                msg("Only superadmins can change other user's gamemode.");
+                return true;
+            }
+        }
+
+        msg("Setting " + player.getName() + " to game mode 'Survival'.");
+        player.sendMessage(sender.getName() + " set your game mode to 'Survival'.");
+        player.setGameMode(GameMode.SURVIVAL);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tag.java

@@ -0,0 +1,159 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.Arrays;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Sets yourself a prefix", usage = "/<command> <set <tag..> | off | clear <player> | clearall>")
+public class Command_tag extends FreedomCommand
+{
+
+    public static final List<String> FORBIDDEN_WORDS = Arrays.asList(new String[]
+    {
+        "admin", "owner", "moderator", "developer", "console"
+    });
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 1)
+        {
+            if ("list".equalsIgnoreCase(args[0]))
+            {
+                msg("Tags for all online players:");
+
+                for (final Player player : server.getOnlinePlayers())
+                {
+                    final FPlayer playerdata = plugin.pl.getPlayer(player);
+                    if (playerdata.getTag() != null)
+                    {
+                        msg(player.getName() + ": " + playerdata.getTag());
+                    }
+                }
+
+                return true;
+            }
+            else if ("clearall".equalsIgnoreCase(args[0]))
+            {
+                if (!plugin.al.isAdmin(sender))
+                {
+                    noPerms();
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Removing all tags", false);
+
+                int count = 0;
+                for (final Player player : server.getOnlinePlayers())
+                {
+                    final FPlayer playerdata = plugin.pl.getPlayer(player);
+                    if (playerdata.getTag() != null)
+                    {
+                        count++;
+                        playerdata.setTag(null);
+                    }
+                }
+
+                msg(count + " tag(s) removed.");
+
+                return true;
+            }
+            else if ("off".equalsIgnoreCase(args[0]))
+            {
+                if (senderIsConsole)
+                {
+                    msg("\"/tag off\" can't be used from the console. Use \"/tag clear <player>\" or \"/tag clearall\" instead.");
+                }
+                else
+                {
+                    plugin.pl.getPlayer(playerSender).setTag(null);
+                    msg("Your tag has been removed.");
+                }
+
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (args.length >= 2)
+        {
+            if ("clear".equalsIgnoreCase(args[0]))
+            {
+                if (!plugin.al.isAdmin(sender))
+                {
+                    noPerms();
+                    return true;
+                }
+
+                final Player player = getPlayer(args[1]);
+
+                if (player == null)
+                {
+                    msg(FreedomCommand.PLAYER_NOT_FOUND);
+                    return true;
+                }
+
+                plugin.pl.getPlayer(player).setTag(null);
+                msg("Removed " + player.getName() + "'s tag.");
+
+                return true;
+            }
+            else if ("set".equalsIgnoreCase(args[0]))
+            {
+                final String inputTag = StringUtils.join(args, " ", 1, args.length);
+                final String outputTag = FUtil.colorize(StringUtils.replaceEachRepeatedly(StringUtils.strip(inputTag),
+                        new String[]
+                        {
+                            "" + ChatColor.COLOR_CHAR, "&k"
+                        },
+                        new String[]
+                        {
+                            "", ""
+                        })) + ChatColor.RESET;
+
+                if (!plugin.al.isAdmin(sender))
+                {
+                    final String rawTag = ChatColor.stripColor(outputTag).toLowerCase();
+
+                    if (rawTag.length() > 20)
+                    {
+                        msg("That tag is too long (Max is 20 characters).");
+                        return true;
+                    }
+
+                    for (String word : FORBIDDEN_WORDS)
+                    {
+                        if (rawTag.contains(word))
+                        {
+                            msg("That tag contains a forbidden word.");
+                            return true;
+                        }
+                    }
+                }
+
+                plugin.pl.getPlayer(playerSender).setTag(outputTag);
+                msg("Tag set to '" + outputTag + "'.");
+
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            return false;
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tagnyan.java

@@ -0,0 +1,39 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Gives you a tag with random colors", usage = "/<command> <tag>", aliases = "tn")
+public class Command_tagnyan extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        final StringBuilder tag = new StringBuilder();
+
+        for (char c : ChatColor.stripColor(FUtil.colorize(StringUtils.join(args, " "))).toCharArray())
+        {
+            tag.append(FUtil.randomChatColor()).append(c);
+        }
+
+        final FPlayer data = plugin.pl.getPlayer(playerSender);
+        data.setTag(tag.toString());
+
+        msg("Set tag to " + tag);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tban.java

@@ -0,0 +1,51 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Temporarily bans a player for five minutes.", usage = "/<command> <partialname>", aliases = "noob")
+public class Command_tban extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND, ChatColor.RED);
+            return true;
+        }
+
+        // strike with lightning effect:
+        final Location targetPos = player.getLocation();
+        for (int x = -1; x <= 1; x++)
+        {
+            for (int z = -1; z <= 1; z++)
+            {
+                final Location strike_pos = new Location(targetPos.getWorld(), targetPos.getBlockX() + x, targetPos.getBlockY(), targetPos.getBlockZ() + z);
+                targetPos.getWorld().strikeLightning(strike_pos);
+            }
+        }
+
+        FUtil.adminAction(sender.getName(), "Tempbanning: " + player.getName() + " for 5 minutes.", true);
+        plugin.bm.addBan(Ban.forPlayer(player, sender, FUtil.parseDateOffset("5m"), ChatColor.RED + "You have been temporarily banned for 5 minutes."));
+
+        player.kickPlayer(ChatColor.RED + "You have been temporarily banned for five minutes. Please read totalfreedom.me for more info.");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tempban.java

@@ -0,0 +1,77 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Temporarily ban someone.", usage = "/<command> [playername] [duration] [reason]")
+public class Command_tempban extends FreedomCommand
+{
+
+    private static final SimpleDateFormat date_format = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z");
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        final StringBuilder message = new StringBuilder("Temporarily banned " + player.getName());
+
+        Date expires = FUtil.parseDateOffset("30m");
+        if (args.length >= 2)
+        {
+            Date parsed_offset = FUtil.parseDateOffset(args[1]);
+            if (parsed_offset != null)
+            {
+                expires = parsed_offset;
+            }
+        }
+        message.append(" until ").append(date_format.format(expires));
+
+        String reason = "Banned by " + sender.getName();
+        if (args.length >= 3)
+        {
+            reason = StringUtils.join(ArrayUtils.subarray(args, 2, args.length), " ") + " (" + sender.getName() + ")";
+            message.append(", Reason: \"").append(reason).append("\"");
+        }
+
+        // strike with lightning effect:
+        final Location targetPos = player.getLocation();
+        for (int x = -1; x <= 1; x++)
+        {
+            for (int z = -1; z <= 1; z++)
+            {
+                final Location strike_pos = new Location(targetPos.getWorld(), targetPos.getBlockX() + x, targetPos.getBlockY(), targetPos.getBlockZ() + z);
+                targetPos.getWorld().strikeLightning(strike_pos);
+            }
+        }
+
+        FUtil.adminAction(sender.getName(), message.toString(), true);
+
+        plugin.bm.addBan(Ban.forPlayer(player, sender, expires, reason));
+
+        player.kickPlayer(sender.getName() + " - " + message.toString());
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tfbanlist.java

@@ -0,0 +1,49 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows all banned player names. Superadmins may optionally use 'purge' to clear the list.", usage = "/<command> [purge]")
+public class Command_tfbanlist extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 0)
+        {
+            if (args[0].equalsIgnoreCase("purge"))
+            {
+                if (senderIsConsole || plugin.al.isAdmin(sender))
+                {
+                    try
+                    {
+                        FUtil.adminAction(sender.getName(), "Purging the ban list", true);
+                        plugin.bm.purgeNameBans();
+                        sender.sendMessage(ChatColor.GRAY + "Ban list has been purged.");
+                    }
+                    catch (Exception ex)
+                    {
+                        FLog.severe(ex);
+                    }
+
+                    return true;
+                }
+                else
+                {
+                    msg("You do not have permission to purge the ban list, you may only view it.");
+                }
+            }
+        }
+
+        msg(plugin.bm.getUsernameBans().size() + " name bans total");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tfipbanlist.java

@@ -0,0 +1,50 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows all banned IPs. Superadmins may optionally use 'purge' to clear the list.", usage = "/<command> [purge]")
+public class Command_tfipbanlist extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 0)
+        {
+            if (args[0].equalsIgnoreCase("purge"))
+            {
+                if (senderIsConsole || plugin.al.isAdmin(sender))
+                {
+                    try
+                    {
+                        plugin.bm.purgeIpBans();
+                        FUtil.adminAction(sender.getName(), "Purging the IP ban list", true);
+
+                        sender.sendMessage(ChatColor.GRAY + "IP ban list has been purged.");
+                    }
+                    catch (Exception ex)
+                    {
+                        FLog.severe(ex);
+                    }
+
+                    return true;
+                }
+                else
+                {
+                    msg("You do not have permission to purge the IP ban list, you may only view it.");
+                }
+            }
+        }
+
+        msg(plugin.bm.getIpBans() + " IP bans total");
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tfm.java

@@ -0,0 +1,70 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.config.MainConfig;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/*
+ * See https://github.com/TotalFreedom/License - This file may not be edited or removed.
+ */
+@CommandPermissions(level = PlayerRank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows information about TotalFreedomMod or reloads it", usage = "/<command> [reload]")
+public class Command_tfm extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 1)
+        {
+            if (!args[0].equals("reload"))
+            {
+                return false;
+            }
+
+            if (!plugin.al.isAdmin(sender))
+            {
+                noPerms();
+                return true;
+            }
+
+            MainConfig.load();
+            plugin.services.stop();
+            plugin.services.start();
+
+            final String message = String.format("%s v%s reloaded.",
+                    TotalFreedomMod.pluginName,
+                    TotalFreedomMod.pluginVersion);
+
+            msg(message);
+            FLog.info(message);
+            return true;
+        }
+
+        TotalFreedomMod.BuildProperties build = TotalFreedomMod.build;
+        msg("TotalFreedomMod for 'Total Freedom', the original all-op server.", ChatColor.GOLD);
+        msg("Running on " + ConfigEntry.SERVER_NAME.getString() + ".", ChatColor.GOLD);
+        msg("Created by Madgeek1450 and Prozza.", ChatColor.GOLD);
+        msg(String.format("Version "
+                + ChatColor.BLUE + "%s.%s " + ChatColor.GOLD + "("
+                + ChatColor.BLUE + "%s" + ChatColor.GOLD + ")",
+                build.version,
+                build.number,
+                build.head), ChatColor.GOLD);
+        msg(String.format("Compiled "
+                + ChatColor.BLUE + "%s" + ChatColor.GOLD + " by "
+                + ChatColor.BLUE + "%s",
+                build.date,
+                build.author), ChatColor.GOLD);
+        msg("Visit " + ChatColor.AQUA + "http://github.com/TotalFreedom/TotalFreedomMod"
+                + ChatColor.GREEN + " for more information.", ChatColor.GREEN);
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tfupdate.java

@@ -0,0 +1,70 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.io.File;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+@CommandPermissions(level = PlayerRank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "Update server files.", usage = "/<command>")
+public class Command_tfupdate extends FreedomCommand
+{
+
+    public static final String[] FILES
+            =
+            {
+            };
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (FILES.length == 0)
+        {
+            msg("This command is disabled.");
+            return true;
+        }
+
+        if (!sender.getName().equalsIgnoreCase("madgeek1450"))
+        {
+            noPerms();
+            return true;
+        }
+
+        for (final String url : FILES)
+        {
+            new BukkitRunnable()
+            {
+                @Override
+                public void run()
+                {
+                    try
+                    {
+                        FLog.info("Downloading: " + url);
+
+                        File file = new File("./updates/" + url.substring(url.lastIndexOf("/") + 1));
+                        if (file.exists())
+                        {
+                            file.delete();
+                        }
+                        if (!file.getParentFile().exists())
+                        {
+                            file.getParentFile().mkdirs();
+                        }
+
+                        FUtil.downloadFile(url, file, true);
+                    }
+                    catch (Exception ex)
+                    {
+                        FLog.severe(ex);
+                    }
+                }
+            }.runTaskAsynchronously(plugin);
+        }
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_toggle.java

@@ -0,0 +1,167 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.GameRuleHandler.GameRule;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Toggles TotalFreedomMod settings", usage = "/<command> [option] [value] [value]")
+public class Command_toggle extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            msg("Available toggles: ");
+            msg("- waterplace");
+            msg("- fireplace");
+            msg("- lavaplace");
+            msg("- fluidspread");
+            msg("- lavadmg");
+            msg("- firespread");
+            msg("- prelog");
+            msg("- lockdown");
+            msg("- petprotect");
+            msg("- droptoggle");
+            msg("- nonuke");
+            msg("- explosives");
+            return false;
+        }
+
+        if (args[0].equals("waterplace"))
+        {
+            toggle("Water placement is", ConfigEntry.ALLOW_WATER_PLACE);
+            return true;
+        }
+
+        if (args[0].equals("fireplace"))
+        {
+            toggle("Fire placement is", ConfigEntry.ALLOW_FIRE_PLACE);
+            return true;
+        }
+
+        if (args[0].equals("lavaplace"))
+        {
+            toggle("Lava placement is", ConfigEntry.ALLOW_LAVA_PLACE);
+            return true;
+        }
+
+        if (args[0].equals("fluidspread"))
+        {
+            toggle("Fluid spread is", ConfigEntry.ALLOW_FLUID_SPREAD);
+            return true;
+        }
+
+        if (args[0].equals("lavadmg"))
+        {
+            toggle("Lava damage is", ConfigEntry.ALLOW_LAVA_DAMAGE);
+            return true;
+        }
+
+        if (args[0].equals("firespread"))
+        {
+            toggle("Fire spread is", ConfigEntry.ALLOW_FIRE_SPREAD);
+            plugin.gr.setGameRule(GameRule.DO_FIRE_TICK, ConfigEntry.ALLOW_FIRE_SPREAD.getBoolean());
+            return true;
+        }
+
+        if (args[0].equals("prelog"))
+        {
+            toggle("Command prelogging is", ConfigEntry.ENABLE_PREPROCESS_LOG);
+            return true;
+        }
+
+        if (args[0].equals("lockdown"))
+        {
+            boolean active = !plugin.lp.isLockdownEnabled();
+            plugin.lp.setLockdownEnabled(active);
+
+            FUtil.adminAction(sender.getName(), (active ? "A" : "De-a") + "ctivating server lockdown", true);
+            return true;
+        }
+
+        if (args[0].equals("petprotect"))
+        {
+            toggle("Tamed pet protection is", ConfigEntry.ENABLE_PET_PROTECT);
+            return true;
+        }
+
+        if (args[0].equals("droptoggle"))
+        {
+            toggle("Automatic entity wiping is", ConfigEntry.AUTO_ENTITY_WIPE);
+            return true;
+        }
+
+        if (args[0].equals("nonuke"))
+        {
+            if (args.length >= 2)
+            {
+                try
+                {
+                    ConfigEntry.NUKE_MONITOR_RANGE.setDouble(Math.max(1.0, Math.min(500.0, Double.parseDouble(args[1]))));
+                }
+                catch (NumberFormatException nfex)
+                {
+                }
+            }
+
+            if (args.length >= 3)
+            {
+                try
+                {
+                    ConfigEntry.NUKE_MONITOR_COUNT_BREAK.setInteger(Math.max(1, Math.min(500, Integer.parseInt(args[2]))));
+                }
+                catch (NumberFormatException nfex)
+                {
+                }
+            }
+
+            toggle("Nuke monitor is", ConfigEntry.NUKE_MONITOR_ENABLED);
+
+            if (ConfigEntry.NUKE_MONITOR_ENABLED.getBoolean())
+            {
+                msg("Anti-freecam range is set to " + ConfigEntry.NUKE_MONITOR_RANGE.getDouble() + " blocks.");
+                msg("Block throttle rate is set to " + ConfigEntry.NUKE_MONITOR_COUNT_BREAK.getInteger() + " blocks destroyed per 5 seconds.");
+            }
+
+            return true;
+        }
+        if (args[0].equals("explosives"))
+        {
+            if (args.length == 2)
+            {
+                try
+                {
+                    ConfigEntry.EXPLOSIVE_RADIUS.setDouble(Math.max(1.0, Math.min(30.0, Double.parseDouble(args[1]))));
+                }
+                catch (NumberFormatException ex)
+                {
+                    msg(ex.getMessage());
+                    return true;
+                }
+            }
+
+            toggle("Explosions are", ConfigEntry.ALLOW_EXPLOSIONS);
+
+            if (ConfigEntry.ALLOW_EXPLOSIONS.getBoolean())
+            {
+                msg("Radius set to " + ConfigEntry.EXPLOSIVE_RADIUS.getDouble());
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    private void toggle(String name, ConfigEntry entry)
+    {
+        msg(name + " now " + (entry.setBoolean(!entry.getBoolean()) ? "enabled." : "disabled."));
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_tossmob.java

@@ -0,0 +1,91 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Throw a mob in the direction you are facing when you left click with a stick.",
+        usage = "/<command> <mobtype [speed] | off | list>")
+public class Command_tossmob extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!ConfigEntry.TOSSMOB_ENABLED.getBoolean())
+        {
+            msg("Tossmob is currently disabled.");
+            return true;
+        }
+
+        FPlayer playerData = plugin.pl.getPlayer(playerSender);
+
+        EntityType creature = EntityType.PIG;
+        if (args.length >= 1)
+        {
+            if ("off".equals(args[0]))
+            {
+                playerData.disableMobThrower();
+                msg("MobThrower is disabled.", ChatColor.GREEN);
+                return true;
+            }
+
+            if (args[0].equalsIgnoreCase("list"))
+            {
+                msg("Supported mobs: " + StringUtils.join(FUtil.MOB_TYPES.keySet(), ", "), ChatColor.GREEN);
+                return true;
+            }
+
+            try
+            {
+                creature = FUtil.getEntityType(args[0]);
+            }
+            catch (Exception ex)
+            {
+                msg(args[0] + " is not a supported mob type. Using a pig instead.", ChatColor.RED);
+                msg("By the way, you can type /tossmob list to see all possible mobs.", ChatColor.RED);
+                creature = EntityType.PIG;
+            }
+        }
+
+        double speed = 1.0;
+        if (args.length >= 2)
+        {
+            try
+            {
+                speed = Double.parseDouble(args[1]);
+            }
+            catch (NumberFormatException nfex)
+            {
+            }
+        }
+
+        if (speed < 1.0)
+        {
+            speed = 1.0;
+        }
+        else if (speed > 5.0)
+        {
+            speed = 5.0;
+        }
+
+        playerData.enableMobThrower(creature, speed);
+        msg("MobThrower is enabled. Creature: " + creature + " - Speed: " + speed + ".", ChatColor.GREEN);
+        msg("Left click while holding a " + Material.BONE.toString() + " to throw mobs!", ChatColor.GREEN);
+        msg("Type '/tossmob off' to disable.  -By Madgeek1450", ChatColor.GREEN);
+
+        playerSender.setItemInHand(new ItemStack(Material.BONE, 1));
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_trail.java

@@ -0,0 +1,133 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.plugin.RegisteredListener;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Pretty rainbow trails.", usage = "/<command> [off]")
+public class Command_trail extends FreedomCommand
+{
+
+    private static Listener movementListener = null;
+    private static final List<Player> trailPlayers = new ArrayList<>();
+    private static final Random RANDOM = new Random();
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 0 && "off".equals(args[0]))
+        {
+            trailPlayers.remove(playerSender);
+
+            msg("Trail disabled.");
+        }
+        else
+        {
+            if (!trailPlayers.contains(playerSender))
+            {
+                trailPlayers.add(playerSender);
+            }
+
+            msg("Trail enabled. Use \"/trail off\" to disable.");
+        }
+
+        if (!trailPlayers.isEmpty())
+        {
+            registerMovementHandler();
+        }
+        else
+        {
+            unregisterMovementHandler();
+        }
+
+        return true;
+    }
+
+    private static void registerMovementHandler()
+    {
+        if (getRegisteredListener(movementListener) == null)
+        {
+            Bukkit.getPluginManager().registerEvents(movementListener = new Listener()
+            {
+                @EventHandler(priority = EventPriority.NORMAL)
+                public void onPlayerMove(PlayerMoveEvent event)
+                {
+                    Player player = event.getPlayer();
+                    if (trailPlayers.contains(player))
+                    {
+                        Block fromBlock = event.getFrom().getBlock();
+                        if (fromBlock.isEmpty())
+                        {
+                            Block toBlock = event.getTo().getBlock();
+                            if (!fromBlock.equals(toBlock))
+                            {
+                                fromBlock.setType(Material.WOOL);
+                                DepreciationAggregator.setData_Block(fromBlock, (byte) RANDOM.nextInt(16));
+                            }
+                        }
+                    }
+                }
+            }, TotalFreedomMod.plugin);
+        }
+    }
+
+    private static void unregisterMovementHandler()
+    {
+        Listener registeredListener = getRegisteredListener(movementListener);
+        if (registeredListener != null)
+        {
+            PlayerMoveEvent.getHandlerList().unregister(registeredListener);
+        }
+    }
+
+    private static Listener getRegisteredListener(Listener listener)
+    {
+        RegisteredListener[] registeredListeners = PlayerMoveEvent.getHandlerList().getRegisteredListeners();
+        for (RegisteredListener registeredListener : registeredListeners)
+        {
+            if (registeredListener.getListener() == listener)
+            {
+                return listener;
+            }
+        }
+        return null;
+    }
+
+    public static void startTrail(Player player)
+    {
+        if (!trailPlayers.contains(player))
+        {
+            trailPlayers.add(player);
+        }
+
+        if (!trailPlayers.isEmpty())
+        {
+            registerMovementHandler();
+        }
+    }
+
+    public static void stopTrail(Player player)
+    {
+        trailPlayers.remove(player);
+
+        if (trailPlayers.isEmpty())
+        {
+            unregisterMovementHandler();
+        }
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_warn.java

@@ -0,0 +1,56 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import org.apache.commons.lang.ArrayUtils;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Warns a player.", usage = "/<command> <player> <reason>")
+public class Command_warn extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 2)
+        {
+            return false;
+        }
+
+        Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        if (sender instanceof Player)
+        {
+            if (player.equals(playerSender))
+            {
+                msg(ChatColor.RED + "Please, don't try to warn yourself.");
+                return true;
+            }
+        }
+
+        if (plugin.al.isAdmin(player))
+        {
+            msg(ChatColor.RED + "You can not warn admins");
+            return true;
+        }
+
+        String warnReason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+
+        msg(ChatColor.RED + "[WARNING] " + warnReason);
+        msg(ChatColor.GREEN + "You have successfully warned " + player.getName());
+
+        plugin.pl.getPlayer(player).incrementWarnings();
+
+        return true;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_whitelist.java

@@ -0,0 +1,170 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Manage the whitelist.", usage = "/<command> <on | off | list | count | add <player> | remove <player> | addall | purge>")
+public class Command_whitelist extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        // list
+        if (args[0].equalsIgnoreCase("list"))
+        {
+            msg("Whitelisted players: " + FUtil.playerListToNames(server.getWhitelistedPlayers()));
+            return true;
+        }
+
+        // count
+        if (args[0].equalsIgnoreCase("count"))
+        {
+            int onlineWPs = 0;
+            int offlineWPs = 0;
+            int totalWPs = 0;
+
+            for (OfflinePlayer player : server.getWhitelistedPlayers())
+            {
+                if (player.isOnline())
+                {
+                    onlineWPs++;
+                }
+                else
+                {
+                    offlineWPs++;
+                }
+                totalWPs++;
+            }
+
+            msg("Online whitelisted players: " + onlineWPs);
+            msg("Offline whitelisted players: " + offlineWPs);
+            msg("Total whitelisted players: " + totalWPs);
+
+            return true;
+        }
+
+        // all commands past this line are superadmin-only
+        if (!(senderIsConsole || plugin.al.isAdmin(sender)))
+        {
+            return noPerms();
+        }
+
+        // on
+        if (args[0].equalsIgnoreCase("on"))
+        {
+            FUtil.adminAction(sender.getName(), "Turning the whitelist on.", true);
+            server.setWhitelist(true);
+            return true;
+        }
+
+        // off
+        if (args[0].equalsIgnoreCase("off"))
+        {
+            FUtil.adminAction(sender.getName(), "Turning the whitelist off.", true);
+            server.setWhitelist(false);
+            return true;
+        }
+
+        // add
+        if (args[0].equalsIgnoreCase("add"))
+        {
+            if (args.length < 2)
+            {
+                return false;
+            }
+
+            String search_name = args[1].trim().toLowerCase();
+
+            OfflinePlayer player = getPlayer(search_name);
+
+            if (player == null)
+            {
+                player = DepreciationAggregator.getOfflinePlayer(server, search_name);
+            }
+
+            FUtil.adminAction(sender.getName(), "Adding " + player.getName() + " to the whitelist.", false);
+            player.setWhitelisted(true);
+            return true;
+        }
+
+        // remove
+        if ("remove".equals(args[0]))
+        {
+            if (args.length < 2)
+            {
+                return false;
+            }
+
+            String search_name = args[1].trim().toLowerCase();
+
+            OfflinePlayer player = getPlayer(search_name);
+
+            if (player == null)
+            {
+                player = DepreciationAggregator.getOfflinePlayer(server, search_name);
+            }
+
+            if (player.isWhitelisted())
+            {
+                FUtil.adminAction(sender.getName(), "Removing " + player.getName() + " from the whitelist.", false);
+                player.setWhitelisted(false);
+                return true;
+            }
+            else
+            {
+                msg("That player is not whitelisted");
+                return true;
+            }
+
+        }
+
+        // addall
+        if (args[0].equalsIgnoreCase("addall"))
+        {
+            FUtil.adminAction(sender.getName(), "Adding all online players to the whitelist.", false);
+            int counter = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!player.isWhitelisted())
+                {
+                    player.setWhitelisted(true);
+                    counter++;
+                }
+            }
+
+            msg("Whitelisted " + counter + " players.");
+            return true;
+        }
+
+        // all commands past this line are console/telnet only
+        if (!senderIsConsole)
+        {
+            noPerms();
+            return true;
+        }
+
+        //purge
+        if (args[0].equalsIgnoreCase("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Removing all players from the whitelist.", false);
+            msg("Removed " + plugin.si.purgeWhitelist() + " players from the whitelist.");
+
+            return true;
+        }
+
+        // none of the commands were executed
+        return false;
+    }
+}

src/main/java/me/totalfreedom/totalfreedommod/command/Command_whohas.java

@@ -0,0 +1,73 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.PlayerRank;
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.util.DepreciationAggregator;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(level = PlayerRank.SUPER_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "See who has a block and optionally smite.", usage = "/<command> <item> [smite]", aliases = "wh")
+public class Command_whohas extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        final boolean doSmite = args.length >= 2 && "smite".equalsIgnoreCase(args[1]);
+
+        final String materialName = args[0];
+        Material material = Material.matchMaterial(materialName);
+        if (material == null)
+        {
+            try
+            {
+                material = DepreciationAggregator.getMaterial(Integer.parseInt(materialName));
+            }
+            catch (NumberFormatException ex)
+            {
+            }
+        }
+
+        if (material == null)
+        {
+            msg("Invalid block: " + materialName, ChatColor.RED);
+            return true;
+        }
+
+        final List<String> players = new ArrayList<>();
+
+        for (final Player player : server.getOnlinePlayers())
+        {
+            if (player.getInventory().contains(material))
+            {
+                players.add(player.getName());
+                if (doSmite && !plugin.al.isAdmin(player))
+                {
+                    Command_smite.smite(player);
+                }
+            }
+        }
+
+        if (players.isEmpty())
+        {
+            msg("There are no players with that item");
+        }
+        else
+        {
+            msg("Players with item " + material.name() + ": " + StringUtils.join(players, ", "));
+        }
+
+        return true;
+    }
+}