Part 1 / 2

Only thing left is to fix all the code issues from moving out the discord and shop implementations.

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

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

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

@@ -0,0 +1,85 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import me.totalfreedom.totalfreedommod.FreedomService;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import org.reflections.Reflections;
+
+public class CommandLoader extends FreedomService
+{
+    private final List<FreedomCommand> commands;
+
+    public CommandLoader()
+    {
+        commands = new ArrayList<>();
+    }
+
+    @Override
+    public void onStart()
+    {
+    }
+
+    @Override
+    public void onStop()
+    {
+    }
+
+    public void add(FreedomCommand command)
+    {
+        commands.add(command);
+        command.register();
+    }
+
+    public FreedomCommand getByName(String name)
+    {
+        for (FreedomCommand command : commands)
+        {
+            if (name.equals(command.getName()))
+            {
+                return command;
+            }
+        }
+        return null;
+    }
+
+    public boolean isAlias(String alias)
+    {
+        for (FreedomCommand command : commands)
+        {
+            if (Arrays.asList(command.getAliases().split(",")).contains(alias))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void loadCommands()
+    {
+        Reflections commandDir = new Reflections("me.totalfreedom.totalfreedommod.command");
+
+        Set<Class<? extends FreedomCommand>> commandClasses = commandDir.getSubTypesOf(FreedomCommand.class);
+
+        for (Class<? extends FreedomCommand> commandClass : commandClasses)
+        {
+            try
+            {
+                add(commandClass.newInstance());
+            }
+            catch (InstantiationException | IllegalAccessException | ExceptionInInitializerError ex)
+            {
+                FLog.warning("Failed to register command: /" + commandClass.getSimpleName().replace("Command_", ""));
+            }
+        }
+
+        FLog.info("Loaded " + commands.size() + " commands");
+    }
+
+    public List<FreedomCommand> getCommands()
+    {
+        return commands;
+    }
+}

commons/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
+}

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

@@ -0,0 +1,18 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CommandPermissions
+{
+
+    Rank rank() default Rank.NON_OP;
+
+    SourceType source() default SourceType.BOTH;
+
+    boolean blockHostConsole() default false;
+
+    int cooldown() default 0;
+}

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

@@ -0,0 +1,36 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Talk privately with other admins on the server.", usage = "/<command> [message]", aliases = "o,sc,ac,staffchat")
+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("You must be in-game to toggle admin chat, it cannot be toggled via CONSOLE or Telnet.");
+                return true;
+            }
+
+            FPlayer userinfo = plugin.pl.getPlayer(playerSender);
+            userinfo.setAdminChat(!userinfo.inAdminChat());
+            msg("Admin chat turned " + (userinfo.inAdminChat() ? "on" : "off") + ".");
+        }
+        else
+        {
+            plugin.cm.adminChat(sender, StringUtils.join(args, " "));
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_admininfo.java

@@ -0,0 +1,33 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.List;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Information on how to apply for admin.", usage = "/<command>", aliases = "si,ai,staffinfo")
+public class Command_admininfo extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        List<String> adminInfo = ConfigEntry.ADMIN_INFO.getStringList();
+
+        if (adminInfo.isEmpty())
+        {
+            msg("The admin information section of the config.yml file has not been configured.", ChatColor.RED);
+        }
+        else
+        {
+            msg(FUtil.colorize(StringUtils.join(adminInfo, "\n")));
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,55 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Denies joining of operators and only allows admins to join.", usage = "/<command> [on | off]", aliases = "staffmode")
+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-admins", true);
+            server.getOnlinePlayers().stream().filter(player -> !isAdmin(player)).forEach(player ->
+                    player.kick(Component.text("The server is now closed to non-admins.")));
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1 && plugin.al.isAdmin(sender) && !(sender instanceof Player))
+        {
+            return Arrays.asList("on", "off");
+        }
+
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,201 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import io.papermc.lib.PaperLib;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Allows for admins to configure time, and weather of the AdminWorld, and allows for admins and ops to go to the AdminWorld.",
+        usage = "/<command> [time <morning | noon | evening | night> | weather <off | rain | storm>]",
+        aliases = "sw,aw,staffworld")
+public class Command_adminworld extends FreedomCommand
+{
+
+    @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 ("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 false;
+                    }
+
+                    World adminWorld = null;
+                    try
+                    {
+                        adminWorld = plugin.wm.adminworld.getWorld();
+                    }
+                    catch (Exception ignored)
+                    {
+                    }
+
+                    if (adminWorld == null || playerSender.getWorld() == adminWorld)
+                    {
+                        msg("Going to the main world.");
+                        PaperLib.teleportAsync(playerSender, server.getWorlds().get(0).getSpawnLocation());
+                    }
+                    else
+                    {
+                        msg("Going to the AdminWorld.");
+                        plugin.wm.adminworld.sendToWorld(playerSender);
+                    }
+                    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();
+            }
+            msg(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();
+        }
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (!plugin.al.isAdmin(sender))
+        {
+            return Collections.emptyList();
+        }
+        if (args.length == 1)
+        {
+            return Arrays.asList("time", "weather");
+        }
+        else if (args.length == 2)
+        {
+            if (args[0].equals("time"))
+            {
+                return Arrays.asList("morning", "noon", "evening", "night");
+            }
+            else if (args[0].equals("weather"))
+            {
+                return Arrays.asList("off", "rain", "storm");
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    private enum CommandMode
+    {
+        TELEPORT, TIME, WEATHER
+    }
+
+    private static class PermissionDeniedException extends Exception
+    {
+
+        private static final long serialVersionUID = 1L;
+
+        private PermissionDeniedException()
+        {
+            super("");
+        }
+
+        private PermissionDeniedException(String string)
+        {
+            super(string);
+        }
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_adventure.java

@@ -0,0 +1,58 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Quickly change your own gamemode to adventure, define someone's username to change theirs, or change everyone's gamemode on the server.", usage = "/<command> <[partialname] | -a>", aliases = "gma")
+public class Command_adventure extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            if (isConsole())
+            {
+                msg("When used from the console, you must define a target player.");
+                return true;
+            }
+
+            playerSender.setGameMode(GameMode.ADVENTURE);
+            msg("Your gamemode has been set to adventure.");
+            return true;
+        }
+
+        checkRank(Rank.ADMIN);
+
+        if (args[0].equals("-a"))
+        {
+            for (Player targetPlayer : server.getOnlinePlayers())
+            {
+                targetPlayer.setGameMode(GameMode.ADVENTURE);
+            }
+
+            FUtil.adminAction(sender.getName(), "Changing everyone's gamemode to adventure", false);
+            msg("Your gamemode has been set to adventure.");
+            return true;
+        }
+
+        Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        msg("Setting " + player.getName() + " to game mode adventure.");
+        msg(player, sender.getName() + " set your game mode to adventure.");
+        player.setGameMode(GameMode.ADVENTURE);
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_aeclear.java

@@ -0,0 +1,36 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.AreaEffectCloud;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Clears lingering potion area effect clouds.", usage = "/<command>", aliases = "aec")
+public class Command_aeclear extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        FUtil.adminAction(sender.getName(), "Removing all area effect clouds", true);
+        int removed = 0;
+        for (World world : server.getWorlds())
+        {
+            for (Entity entity : world.getEntities())
+            {
+                if (entity instanceof AreaEffectCloud)
+                {
+                    entity.remove();
+                    removed++;
+                }
+            }
+        }
+        msg(removed + " area effect clouds removed.");
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_announce.java

@@ -0,0 +1,25 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Make an announcement anonymously to operators.", usage = "/<command> <message>")
+public class Command_announce extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        plugin.an.announce(StringUtils.join(args, " "));
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_attributelist.java

@@ -0,0 +1,21 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import java.util.Arrays;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Lists all possible attributes.", usage = "/<command>")
+public class Command_attributelist extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        msg("All possible attributes: " + FUtil.listToString(Arrays.stream(Attribute.values()).map(Enum::name).toList()));
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_autoclear.java

@@ -0,0 +1,36 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Toggle whether or not a player has their inventory automatically cleared when they join", usage = "/<command> <player>")
+public class Command_autoclear extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        boolean enabled = plugin.lp.CLEAR_ON_JOIN.contains(args[0]);
+
+        if (enabled)
+        {
+            plugin.lp.CLEAR_ON_JOIN.remove(args[0]);
+        }
+        else
+        {
+            plugin.lp.CLEAR_ON_JOIN.add(args[0]);
+        }
+
+        msg(args[0] + " will " + (enabled ? "no longer" : "now") + " have their inventory cleared when they join.");
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_autotp.java

@@ -0,0 +1,36 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Toggle whether or not a player is automatically teleported when they join", usage = "/<command> <player>")
+public class Command_autotp extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        boolean enabled = plugin.lp.TELEPORT_ON_JOIN.contains(args[0]);
+
+        if (enabled)
+        {
+            plugin.lp.TELEPORT_ON_JOIN.remove(args[0]);
+        }
+        else
+        {
+            plugin.lp.TELEPORT_ON_JOIN.add(args[0]);
+        }
+
+        msg(args[0] + " will " + (enabled ? "no longer" : "now") + " be automatically teleported when they join.");
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_ban.java

@@ -0,0 +1,185 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Objects;
+
+import com.earth2me.essentials.User;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.ArrayUtils;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
+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(rank = Rank.ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Bans the specified player.", usage = "/<command> <username> [reason] [-nrb | -q]", aliases = "gtfo")
+public class Command_ban 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 reason = null;
+        boolean silent = false;
+        boolean cancelRollback = false;
+        if (args.length >= 2)
+        {
+            if (args[args.length - 1].equalsIgnoreCase("-nrb") || args[args.length - 1].equalsIgnoreCase("-q"))
+            {
+                if (args[args.length - 1].equalsIgnoreCase("-nrb"))
+                {
+                    cancelRollback = true;
+                }
+
+                if (args[args.length - 1].equalsIgnoreCase("-q"))
+                {
+                    silent = true;
+                }
+
+                if (args.length >= 3)
+                {
+                    reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length - 1), " ");
+                }
+            }
+            else
+            {
+                reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+            }
+        }
+
+        final String username;
+        final String ip;
+
+        final Player player = getPlayer(args[0]);
+        if (player == null)
+        {
+            // Gets the IP using Essentials data if available
+            if (plugin.esb.isEnabled() && plugin.esb.getEssentialsUser(args[0]) != null)
+            {
+                User essUser = plugin.esb.getEssentialsUser(args[0]);
+                //
+                username = essUser.getName();
+                ip = essUser.getLastLoginAddress();
+            }
+            // Last resort - Getting the first result from the username itself
+            else
+            {
+                PlayerData entry = plugin.pl.getData(args[0]);
+                if (entry == null)
+                {
+                    msg(PLAYER_NOT_FOUND);
+                    return true;
+                }
+                else
+                {
+                    username = entry.getName();
+                    ip = entry.getIps().get(0);
+                }
+            }
+        }
+        else
+        {
+            username = player.getName();
+            ip = FUtil.getIp(player);
+
+            // Deop
+            player.setOp(false);
+
+            // Gamemode survival
+            player.setGameMode(GameMode.SURVIVAL);
+
+            // Clear inventory
+            player.getInventory().clear();
+
+            if (!silent)
+            {
+                // 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);
+                        Objects.requireNonNull(targetPos.getWorld()).strikeLightning(strike_pos);
+                    }
+                }
+            }
+            else
+            {
+                msg("Banned " + player.getName() + " quietly.");
+            }
+            // Kill player
+            player.setHealth(0.0);
+        }
+
+        // Checks if CoreProtect is loaded and installed, and skips the rollback and uses CoreProtect directly
+        if (!cancelRollback)
+        {
+            plugin.cpb.rollback(username);
+        }
+
+        if (player != null && !silent)
+        {
+            FUtil.bcastMsg(player.getName() + " has been a VERY naughty, naughty boy.", ChatColor.RED);
+        }
+
+        // Ban player
+        Ban ban;
+        if (player != null)
+        {
+            ban = Ban.forPlayer(player, sender, null, reason);
+        }
+        else
+        {
+            ban = Ban.forPlayerName(username, sender, null, reason);
+        }
+        ban.addIp(ip);
+
+        plugin.bm.addBan(ban);
+
+
+        if (!silent)
+        {
+            // Broadcast
+            final StringBuilder bcast = new StringBuilder()
+                    .append("Banning: ")
+                    .append(username);
+            if (reason != null)
+            {
+                bcast.append(" - Reason: ").append(ChatColor.YELLOW).append(reason);
+            }
+            msg(sender, ChatColor.GRAY + username + " has been banned and IP is: " + ip);
+            FUtil.adminAction(sender.getName(), bcast.toString(), true);
+        }
+
+        // Kick player and handle others on IP
+        if (player != null)
+        {
+            player.kickPlayer(ban.bakeKickMessage());
+            for (Player p : Bukkit.getOnlinePlayers())
+            {
+                if (FUtil.getIp(p).equals(FUtil.getIp(player)))
+                {
+                    p.kickPlayer(ChatColor.RED + "You've been kicked because someone on your IP has been banned.");
+                }
+            }
+        }
+
+        // Log ban
+        plugin.pul.logPunishment(new Punishment(username, ip, sender.getName(), PunishmentType.BAN, reason));
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_banip.java

@@ -0,0 +1,82 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Bans the specified ip.", usage = "/<command> <ip> [reason] [-q]")
+public class Command_banip extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        boolean silent = false;
+
+        String reason = null;
+
+        String ip = args[0];
+
+        if (FUtil.isValidIPv4(ip))
+        {
+            msg(ip + " is not a valid IP address", ChatColor.RED);
+            return true;
+        }
+
+        if (plugin.bm.getByIp(ip) != null)
+        {
+            msg("The IP " + ip + " is already banned", ChatColor.RED);
+            return true;
+        }
+
+        if (args[args.length - 1].equalsIgnoreCase("-q"))
+        {
+            silent = true;
+
+            if (args.length >= 2)
+            {
+                reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length - 1), " ");
+            }
+        }
+        else if (args.length > 1)
+        {
+            reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+        }
+
+        // Ban player
+        Ban ban = Ban.forPlayerIp(ip, sender, null, reason);
+        plugin.bm.addBan(ban);
+
+        // Kick player and handle others on IP
+        for (Player player : server.getOnlinePlayers())
+        {
+            if (FUtil.getIp(player).equals(ip))
+            {
+                player.kickPlayer(ban.bakeKickMessage());
+            }
+
+            if (!silent)
+            {
+                // Broadcast
+                FLog.info(ChatColor.RED + sender.getName() + " - Banned the IP " + ip);
+                String message = sender.getName() + " - Banned " + (plugin.al.isAdmin(player) ? "the IP " + ip : "an IP");
+                msg(player, message, ChatColor.RED);
+            }
+        }
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_banlist.java

@@ -0,0 +1,36 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows all banned player names. Admins may optionally use 'purge' to clear the list.", usage = "/<command> [purge]")
+public class Command_banlist 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"))
+            {
+                checkRank(Rank.SENIOR_ADMIN);
+
+                FUtil.adminAction(sender.getName(), "Purging the ban list", true);
+                int amount = plugin.bm.purge();
+                msg("Purged " + amount + " player bans.");
+                return true;
+            }
+            return false;
+        }
+
+        msg(plugin.bm.getAllBans().size() + " player bans ("
+                + plugin.bm.getUsernameBans().size() + " usernames, "
+                + plugin.bm.getIpBans().size() + " IPs)");
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_banname.java

@@ -0,0 +1,68 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "Bans the specified name.", usage = "/<command> <name> [reason] [-q]")
+public class Command_banname extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        boolean silent = false;
+
+        String reason = null;
+
+        String name = args[0];
+
+        if (plugin.bm.getByUsername(name) != null)
+        {
+            msg("The name " + name + " is already banned", ChatColor.RED);
+            return true;
+        }
+
+        if (args[args.length - 1].equalsIgnoreCase("-q"))
+        {
+            silent = true;
+
+            if (args.length >= 2)
+            {
+                reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length - 1), " ");
+            }
+        }
+        else if (args.length > 1)
+        {
+            reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+        }
+
+        // Ban player
+        Ban ban = Ban.forPlayerName(name, sender, null, reason);
+        plugin.bm.addBan(ban);
+
+        if (!silent)
+        {
+            FUtil.adminAction(sender.getName(), "Banned the name " + name, true);
+        }
+
+        Player player = getPlayer(name);
+        if (player != null)
+        {
+            player.kickPlayer(ban.bakeKickMessage());
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_bird.java

@@ -0,0 +1,33 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.SplittableRandom;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Spawns a random type of fish at your location.", usage = "/<command>")
+public class Command_bird extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        Location location = playerSender.getTargetBlock(null, 15).getLocation().add(0, 1, 0);
+        playerSender.getWorld().spawnEntity(location, getRandomFish());
+        msg(":goodbird:");
+        return true;
+    }
+
+    public EntityType getRandomFish()
+    {
+        List<EntityType> fishTypes = Arrays.asList(EntityType.COD, EntityType.SALMON, EntityType.PUFFERFISH, EntityType.TROPICAL_FISH);
+        SplittableRandom random = new SplittableRandom();
+        return fishTypes.get(random.nextInt(fishTypes.size()));
+    }
+}

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

@@ -0,0 +1,92 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Block all commands for everyone on the server, or a specific player.", usage = "/<command> <-a | purge | <player>>", aliases = "blockcommands,blockcommand,bc,bcmd")
+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].equals("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;
+        }
+
+        if (args[0].equals("-a"))
+        {
+            FUtil.adminAction(sender.getName(), "Blocking commands for all non-admins", true);
+            int counter = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (isAdmin(player))
+                {
+                    continue;
+                }
+
+                counter += 1;
+                plugin.pl.getPlayer(player).setCommandsBlocked(true);
+                msg(player, "Your commands have been blocked by an admin.", ChatColor.RED);
+            }
+
+            msg("Blocked commands for " + counter + " players.");
+            return true;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(FreedomCommand.PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        if (isAdmin(player))
+        {
+            msg(player.getName() + " is an admin, and cannot have their commands blocked.");
+            return true;
+        }
+
+        FPlayer playerdata = plugin.pl.getPlayer(player);
+        if (!playerdata.allCommandsBlocked())
+        {
+            FUtil.adminAction(sender.getName(), "Blocking all commands for " + player.getName(), true);
+            playerdata.setCommandsBlocked(true);
+            msg("Blocked commands for " + player.getName() + ".");
+
+            plugin.pul.logPunishment(new Punishment(player.getName(), FUtil.getIp(player), sender.getName(), PunishmentType.BLOCKCMD, null));
+        }
+        else
+        {
+            msg("That players commands are already blocked.", ChatColor.RED);
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_blockedit.java

@@ -0,0 +1,110 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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;
+
+import java.util.List;
+import java.util.Optional;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Restricts/restores block modification abilities for everyone on the server or a certain player.", usage = "/<command> [<player> [reason] | list | purge | all]")
+public class Command_blockedit extends FreedomCommand
+{
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, final Command cmd, final String commandLabel, String[] args, final boolean senderIsConsole)
+    {
+        if (args.length > 0)
+        {
+            switch (args[0].toLowerCase())
+            {
+                case "list" ->
+                {
+                    List<? extends Player> list = server.getOnlinePlayers().stream().filter(player ->
+                            plugin.pl.getPlayer(player).isEditBlocked()).sorted().toList();
+
+                    // Oh dear god, why do I have to do it like this?
+                    msg("There " + (list.size() != 1 ? "are " : "is ") + list.size() + " player"
+                            + (list.size() != 1 ? "s" : "") + " online with restricted block modification abilities"
+                            + (list.size() > 0 ? ":" : "."));
+
+                    list.forEach(player -> msg("- " + player.getName()));
+                }
+                case "purge" ->
+                {
+                    FUtil.adminAction(sender.getName(), "Restoring block modification abilities for all players", true);
+
+                    List<? extends Player> list = server.getOnlinePlayers().stream().filter(player ->
+                            plugin.pl.getPlayer(player).isEditBlocked()).toList();
+
+                    list.forEach(player ->
+                    {
+                        plugin.pl.getPlayer(player).setEditBlocked(false);
+                        msg(player, "Your block modification abilities have been restored.", ChatColor.GREEN);
+                    });
+
+                    msg("Restored block modification abilities for " + list.size() + " player"
+                            + (list.size() != 1 ? "s" : "") + ".");
+                }
+                case "all", "-a" ->
+                {
+                    FUtil.adminAction(sender.getName(), "Restricting block modification abilities for all non-admins", true);
+
+                    List<? extends Player> list = server.getOnlinePlayers().stream().filter(player ->
+                            !plugin.al.isAdmin(player)).toList();
+
+                    list.forEach(player ->
+                    {
+                        plugin.pl.getPlayer(player).setEditBlocked(true);
+                        msg(player, "Your block modification abilities have been restricted.", ChatColor.RED);
+                    });
+
+                    msg("Restricted block modification abilities for " + list.size() + " player"
+                            + (list.size() != 1 ? "s" : "") + ".");
+                }
+                default -> Optional.ofNullable(getPlayer(args[0])).ifPresentOrElse(player ->
+                {
+                    FPlayer fPlayer = plugin.pl.getPlayer(player);
+
+                    if (fPlayer.isEditBlocked())
+                    {
+                        FUtil.adminAction(sender.getName(), "Restoring block modification abilities for " + player.getName(), true);
+                        fPlayer.setEditBlocked(false);
+                        msg("Restored block modification abilities for " + player.getName() + ".");
+                        msg(player, "Your block modification abilities have been restored.", ChatColor.GREEN);
+                    }
+                    else
+                    {
+                        if (plugin.al.isAdmin(player))
+                        {
+                            msg(player.getName() + " is an admin, and as such cannot have their block modification abilities restricted.", ChatColor.RED);
+                        }
+                        else
+                        {
+                            FUtil.adminAction(sender.getName(), "Restricting block modification abilities for " + player.getName(), true);
+                            fPlayer.setEditBlocked(true);
+                            msg("Restricted block modification abilities for " + player.getName() + ".");
+                            msg(player, "Your block modification abilities have been restricted.", ChatColor.RED);
+
+                            plugin.pul.logPunishment(new Punishment(player.getName(), FUtil.getIp(player),
+                                    sender.getName(), PunishmentType.BLOCKEDIT, null));
+                        }
+                    }
+
+                }, () -> msg(PLAYER_NOT_FOUND));
+            }
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_blockpvp.java

@@ -0,0 +1,137 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Toggle PVP mode for everyone or a certain player.", usage = "/<command> [[-s] <player> [reason] | list | purge | all]", aliases = "pvpblock,pvpmode")
+public class Command_blockpvp extends FreedomCommand
+{
+
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, final Command cmd, final String commandLabel, String[] args, final boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        if (args[0].equals("list"))
+        {
+            msg("PVP is blocked for players:");
+            int count = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                final FPlayer info = plugin.pl.getPlayer(player);
+                if (info.isPvpBlocked())
+                {
+                    msg(" - " + player.getName());
+                    ++count;
+                }
+            }
+
+            if (count == 0)
+            {
+                msg(" - none");
+            }
+            return true;
+        }
+
+        if (args[0].equals("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Enabling PVP for all players.", true);
+            int count = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                final FPlayer info = plugin.pl.getPlayer(player);
+                if (info.isPvpBlocked())
+                {
+                    info.setPvpBlocked(false);
+                    ++count;
+                }
+            }
+
+            msg("Enabled PVP for " + count + " players.");
+            return true;
+        }
+
+        if (args[0].equals("all"))
+        {
+            FUtil.adminAction(sender.getName(), "Disabling PVP for all non-admins", true);
+            int counter = 0;
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!plugin.al.isAdmin(player))
+                {
+                    final FPlayer playerdata = plugin.pl.getPlayer(player);
+                    playerdata.setPvpBlocked(true);
+                    ++counter;
+                }
+            }
+
+            msg("Disabling PVP for " + counter + " players.");
+            return true;
+        }
+
+        final boolean smite = args[0].equals("-s");
+        if (smite)
+        {
+            args = ArrayUtils.subarray(args, 1, args.length);
+            if (args.length < 1)
+            {
+                return false;
+            }
+        }
+
+        final Player p = getPlayer(args[0]);
+        if (p == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        String reason = null;
+        if (args.length > 1)
+        {
+            reason = StringUtils.join(args, " ", 1, args.length);
+        }
+
+        final FPlayer pd = plugin.pl.getPlayer(p);
+        if (pd.isPvpBlocked())
+        {
+            FUtil.adminAction(sender.getName(), "Enabling PVP for " + p.getName(), true);
+            pd.setPvpBlocked(false);
+            msg("Enabling PVP for " + p.getName());
+            msg(p, "Your PVP have been enabled.", ChatColor.GREEN);
+        }
+        else
+        {
+            if (plugin.al.isAdmin(p))
+            {
+                msg(p.getName() + " is an admin, and cannot have their PVP disabled.");
+                return true;
+            }
+
+            FUtil.adminAction(sender.getName(), "Disabling PVP for " + p.getName(), true);
+            pd.setPvpBlocked(true);
+            if (smite)
+            {
+                Command_smite.smite(sender, p, reason);
+            }
+            plugin.pul.logPunishment(new Punishment(p.getName(), FUtil.getIp(p), sender.getName(), PunishmentType.BLOCKPVP, null));
+
+            msg(p, "Your PVP has been disabled.", ChatColor.RED);
+            msg("Disabled PVP for " + p.getName());
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_blockredstone.java

@@ -0,0 +1,41 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Blocks redstone on the server.", usage = "/<command>", aliases = "bre")
+public class Command_blockredstone extends FreedomCommand
+{
+
+    public boolean run(final CommandSender sender, final Player playerSender, final Command cmd, final String commandLabel, final String[] args, final boolean senderIsConsole)
+    {
+        if (ConfigEntry.ALLOW_REDSTONE.getBoolean())
+        {
+            ConfigEntry.ALLOW_REDSTONE.setBoolean(false);
+            FUtil.adminAction(sender.getName(), "Blocking all redstone", true);
+            new BukkitRunnable()
+            {
+                public void run()
+                {
+                    if (!ConfigEntry.ALLOW_REDSTONE.getBoolean())
+                    {
+                        FUtil.adminAction("TotalFreedom", "Unblocking all redstone", false);
+                        ConfigEntry.ALLOW_REDSTONE.setBoolean(true);
+                    }
+                }
+            }.runTaskLater(plugin, 6000L);
+        }
+        else
+        {
+            ConfigEntry.ALLOW_REDSTONE.setBoolean(true);
+            FUtil.adminAction(sender.getName(), "Unblocking all redstone", true);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,164 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.ChatColor;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Place a cage around someone with certain blocks, or someone's player head.", usage = "/<command> <purge | <partialname> [head | block] [playername | blockname]")
+public class Command_cage extends FreedomCommand
+{
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, final Command cmd, final String commandLabel, final String[] args, final boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        String skullName = null;
+        if (args[0].equalsIgnoreCase("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Uncaging all players", true);
+            server.getOnlinePlayers().stream().map(player -> plugin.pl.getPlayer(player)).forEach(fPlayer ->
+                    fPlayer.getCageData().setCaged(false));
+            return true;
+        }
+
+        Player player = getPlayer(args[0]);
+        if (player == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        final FPlayer fPlayer = plugin.pl.getPlayer(player);
+        if (fPlayer.getCageData().isCaged())
+        {
+            msg("That player is already caged.", ChatColor.RED);
+            return true;
+        }
+
+        Material outerMaterial = Material.GLASS;
+        Material innerMaterial = Material.AIR;
+        if (args.length >= 2 && args[1] != null)
+        {
+            final String s = args[1];
+            switch (s)
+            {
+                case "head" ->
+                {
+                    outerMaterial = Material.PLAYER_HEAD;
+                    if (args.length >= 3)
+                    {
+                        skullName = args[2];
+                    }
+                    else
+                    {
+                        outerMaterial = Material.SKELETON_SKULL;
+                    }
+                }
+                case "block" ->
+                {
+                    if (args.length >= 3)
+                    {
+                        // Checks the validity of the Material and checks if it's a block.
+                        // This is incredibly inefficient, as Spigot's isBlock() method in Material is an actual
+                        // nightmare of switch-cases.
+                        if (Material.matchMaterial(args[2]) != null && Material.matchMaterial(args[2]).isBlock())
+                        {
+                            outerMaterial = Material.matchMaterial(args[2]);
+                        }
+                        else
+                        {
+                            msg("Invalid block!", ChatColor.RED);
+                            return true;
+                        }
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                default ->
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (outerMaterial == Material.PLAYER_HEAD)
+        {
+            FUtil.adminAction(sender.getName(), "Caging " + player.getName() + " in " + skullName, true);
+        }
+        else
+        {
+            FUtil.adminAction(sender.getName(), "Caging " + player.getName(), true);
+        }
+
+        Location location = player.getLocation().clone().add(0.0, 1.0, 0.0);
+
+        if (skullName != null)
+        {
+            fPlayer.getCageData().cage(location, outerMaterial, innerMaterial, skullName);
+        }
+        else
+        {
+            fPlayer.getCageData().cage(location, outerMaterial, innerMaterial);
+        }
+        player.setGameMode(GameMode.SURVIVAL);
+
+        plugin.pul.logPunishment(new Punishment(player.getName(), FUtil.getIp(player), sender.getName(), PunishmentType.CAGE, null));
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (!plugin.al.isAdmin(sender))
+        {
+            return null;
+        }
+
+        if (args.length == 1)
+        {
+            List<String> arguments = new ArrayList<>();
+            arguments.add("purge");
+            arguments.addAll(FUtil.getPlayerList());
+            return arguments;
+        }
+        else if (args.length == 2)
+        {
+            if (!args[0].equals("purge"))
+            {
+                return Arrays.asList("head", "block");
+            }
+        }
+        else if (args.length == 3)
+        {
+            if (args[1].equals("block"))
+            {
+                return Arrays.stream(Material.values()).map(Enum::name).toList();
+            }
+            else if (args[1].equals("head"))
+            {
+                return FUtil.getPlayerList();
+            }
+        }
+
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,48 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "For the people that are still alive - gives a cake to everyone on the server.", 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.";
+
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, final Command cmd, final String commandLabel, final String[] args, final boolean senderIsConsole)
+    {
+        final StringBuilder output = new StringBuilder();
+
+        for (final String word : CAKE_LYRICS.split(" "))
+        {
+            output.append(FUtil.randomChatColor()).append(word).append(" ");
+        }
+
+        final ItemStack heldItem = new ItemStack(Material.CAKE);
+        final ItemMeta heldItemMeta = heldItem.getItemMeta();
+        assert heldItemMeta != null;
+        heldItemMeta.setDisplayName(ChatColor.WHITE + "The " + ChatColor.DARK_GRAY + "Lie");
+        heldItem.setItemMeta(heldItemMeta);
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            final int firstEmpty = player.getInventory().firstEmpty();
+            if (firstEmpty >= 0)
+            {
+                player.getInventory().setItem(firstEmpty, heldItem);
+            }
+        }
+
+        FUtil.bcastMsg(output.toString());
+        return true;
+    }
+}

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

@@ -0,0 +1,77 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Objects;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Minecart;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.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 && plugin.al.isAdmin(sender))
+        {
+            targetPlayer = getPlayer(args[0]);
+
+            if (targetPlayer == null)
+            {
+                msg(PLAYER_NOT_FOUND);
+                return true;
+            }
+        }
+
+        if (senderIsConsole)
+        {
+            if (targetPlayer == null)
+            {
+                msg("When used from the console, you must define a target player: /cartsit <player>");
+                return true;
+            }
+        }
+
+        if (targetPlayer.isInsideVehicle())
+        {
+            Objects.requireNonNull(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.addPassenger(targetPlayer);
+            }
+            else
+            {
+                msg("There are no empty minecarts in the target world.");
+            }
+        }
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_cleanchat.java

@@ -0,0 +1,27 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Clears the chat.", usage = "/<command>", aliases = "cc")
+public class Command_cleanchat extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        server.getOnlinePlayers().stream().filter(player -> !plugin.al.isAdmin(player)).forEach(player ->
+        {
+            for (int i = 0; i < 100; i++)
+            {
+                msg(player, "");
+            }
+        });
+
+        FUtil.adminAction(sender.getName(), "Cleared chat", true);
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_cleardiscordqueue.java

@@ -0,0 +1,20 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.ONLY_CONSOLE)
+@CommandParameters(description = "Clear the discord message queue.", usage = "/<command>")
+public class Command_cleardiscordqueue extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        plugin.dc.clearQueue();
+        msg("Cleared the discord message queue.");
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_clearinventory.java

@@ -0,0 +1,79 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Clear your inventory.", usage = "/<command> [player]", aliases = "ci,clear")
+public class Command_clearinventory extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+
+        if (args.length < 1)
+        {
+            if (senderIsConsole)
+            {
+                return false;
+            }
+
+            playerSender.getInventory().clear();
+            msg("Your inventory has been cleared.");
+        }
+        else
+        {
+            if (plugin.al.isAdmin(sender))
+            {
+                if (args[0].equals("-a"))
+                {
+                    FUtil.adminAction(sender.getName(), "Clearing everyone's inventory", true);
+                    for (Player player : server.getOnlinePlayers())
+                    {
+                        player.getInventory().clear();
+                    }
+                    msg("Sucessfully cleared everyone's inventory.");
+                }
+                else
+                {
+                    Player player = getPlayer(args[0]);
+
+                    if (player == null)
+                    {
+                        msg(PLAYER_NOT_FOUND);
+                        return true;
+                    }
+
+                    player.getInventory().clear();
+                    msg("Cleared " + player.getName() + "'s inventory.");
+                    msg(player, sender.getName() + " has cleared your inventory.");
+                }
+            }
+            else
+            {
+                return noPerms();
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1 && plugin.al.isAdmin(sender))
+        {
+            List<String> players = FUtil.getPlayerList();
+            players.add("-a");
+            return players;
+        }
+
+        return Collections.emptyList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_clownfish.java

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.shop.ShopItem;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Obtain a clown fish", usage = "/<command>")
+public class Command_clownfish extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (plugin.pl.getData(playerSender).hasItem(ShopItem.CLOWN_FISH) && (!plugin.lp.CLOWNFISH_TOGGLE.contains(playerSender.getName())))
+        {
+            playerSender.getInventory().addItem(plugin.sh.getClownFish());
+            msg("You have been given a Clown Fish", ChatColor.GREEN);
+        }
+        else
+        {
+            msg("You do not own a Clown Fish or an admin has toggled your ability to use it. Purchase one from the shop.", ChatColor.RED);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,24 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.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)
+    {
+        Admin admin = plugin.al.getAdmin(playerSender);
+        admin.setCommandSpy(!admin.getCommandSpy());
+        msg("CommandSpy " + (admin.getCommandSpy() ? "enabled." : "disabled."));
+        plugin.al.save(admin);
+        plugin.al.updateTables();
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_coins.java

@@ -0,0 +1,145 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows the amount of coins you or another player has. Also allows you to give coins to other players.", usage = "/<command> [player] | pay <player> <amount>")
+public class Command_coins extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!ConfigEntry.SHOP_ENABLED.getBoolean())
+        {
+            msg("The shop is currently disabled!", ChatColor.RED);
+            return true;
+        }
+
+        final String prefix = FUtil.colorize(ConfigEntry.SHOP_PREFIX.getString() + " ");
+
+        switch (args.length)
+        {
+            // Mode for seeing how many coins the sender has (doesn't work from console)
+            case 0:
+            {
+                if (senderIsConsole)
+                {
+                    msg("When used from the console, you must define a target player.");
+                }
+                else
+                {
+                    PlayerData playerData = getData(playerSender);
+                    msg(prefix + ChatColor.GREEN + "You have " + ChatColor.RED + playerData.getCoins() + ChatColor.GREEN
+                            + " coins.");
+                }
+                return true;
+            }
+
+            // Mode for seeing how many coins a player has.
+            case 1:
+            {
+                Player target = getPlayer(args[0]);
+
+                if (target == null)
+                {
+                    msg(PLAYER_NOT_FOUND);
+                }
+                else
+                {
+                    PlayerData playerData = getData(target);
+                    msg(prefix + ChatColor.GREEN + target.getName() + " has " + ChatColor.RED + playerData.getCoins() + ChatColor.GREEN + " coins.");
+                }
+                return true;
+            }
+
+            // Mode for paying another player coins
+            case 3:
+            {
+                if (args[0].equalsIgnoreCase("pay"))
+                {
+                    checkPlayer();
+
+                    final Player target = getPlayer(args[1]);
+                    final PlayerData senderData = getData(playerSender);
+
+                    int coinsToTransfer;
+
+                    // Processes args[2]
+                    try
+                    {
+                        // Prevents players from trying to be cheeky with negative numbers.
+                        coinsToTransfer = Math.max(Math.abs(Integer.parseInt(args[2])), 1);
+                    }
+                    catch (NumberFormatException ex)
+                    {
+                        msg("Invalid number: " + args[2], ChatColor.RED);
+                        return true;
+                    }
+
+                    // Prevents players from performing transactions they can't afford to do.
+                    if (senderData.getCoins() < coinsToTransfer)
+                    {
+                        msg("You don't have enough coins to perform this transaction.", ChatColor.RED);
+                        return true;
+                    }
+
+                    if (target == null)
+                    {
+                        msg(PLAYER_NOT_FOUND);
+                    }
+                    else
+                    {
+                        PlayerData playerData = getData(target);
+                        playerData.setCoins(playerData.getCoins() + coinsToTransfer);
+                        senderData.setCoins(senderData.getCoins() - coinsToTransfer);
+
+                        msg(target, sender.getName()
+                                + ChatColor.GREEN + " has given you "
+                                + ChatColor.GOLD + coinsToTransfer
+                                + ChatColor.GREEN + " coin" + (coinsToTransfer > 1 ? "s" : "") + "!", ChatColor.GOLD);
+
+                        msg("You have given "
+                                + ChatColor.GOLD + coinsToTransfer
+                                + ChatColor.GREEN + " coin" + (coinsToTransfer > 1 ? "s" : "")
+                                + " to " + ChatColor.GOLD + target.getName() + ChatColor.GREEN + ".", ChatColor.GREEN);
+
+                        plugin.pl.save(playerData);
+                        plugin.pl.save(senderData);
+                    }
+
+                    return true;
+                }
+            }
+
+            default:
+            {
+                return false;
+            }
+        }
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1)
+        {
+            List<String> options = new ArrayList<>(FUtil.getPlayerList());
+
+            options.add("pay");
+
+            return options;
+        }
+
+        return FUtil.getPlayerList();
+    }
+}

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

@@ -0,0 +1,55 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Map;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Essentials Interface Command - Set your nickname to a certain color.", 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 (args[0].equalsIgnoreCase("list"))
+        {
+            msg("Colors: " + StringUtils.join(FUtil.CHAT_COLOR_NAMES.keySet(), ", "));
+            return true;
+        }
+
+        final String needle = args[0].trim().toLowerCase();
+        ChatColor color = null;
+        for (Map.Entry<String, ChatColor> entry : FUtil.CHAT_COLOR_NAMES.entrySet())
+        {
+            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;
+    }
+}

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

@@ -0,0 +1,50 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.apache.commons.lang.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 = Rank.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 = desc.getCommands();
+
+                for (Entry<String, Map<String, Object>> entry : map.entrySet())
+                {
+                    String command_name = entry.getKey();
+                    commands.add(command_name);
+                }
+            }
+            catch (Throwable ignored)
+            {
+            }
+        }
+
+        Collections.sort(commands);
+
+        msg(StringUtils.join(commands, ", "));
+
+        return true;
+    }
+}

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

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.ONLY_CONSOLE)
+@CommandParameters(description = "Telnet/Console 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)
+        {
+            return false;
+        }
+
+        String message = StringUtils.join(args, " ");
+        FUtil.bcastMsg(String.format("§7[CONSOLE] §c%s §8\u00BB §f%s", sender.getName(), StringUtils.join(args, " ")));
+        plugin.dc.messageChatChannel("[CONSOLE] " + sender.getName() + " \u00BB " + ChatColor.stripColor(message));
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_cookie.java

@@ -0,0 +1,63 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "For those who have no friends - gives a cookie to everyone on the server.", usage = "/<command>")
+public class Command_cookie extends FreedomCommand
+{
+    public static final String COOKIE_LYRICS = "Imagine that you have zero cookies and you split them evenly among zero friends. How many cookies does each person get? See? It doesn't make sense. And Cookie Monster is sad that there are no cookies, and you are sad that you have no friends.";
+    public static final String LORE = "But, you can have a cookie anyways,\nsince you are sad you are have no friends.";
+
+    @Override
+    public boolean run(CommandSender sender, Player sender_p, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        final StringBuilder output = new StringBuilder();
+
+        for (final String word : COOKIE_LYRICS.split(" "))
+        {
+            output.append(FUtil.randomChatColor()).append(word).append(" ");
+        }
+
+        final StringBuilder lore = new StringBuilder();
+
+        for (final String word : LORE.split(" "))
+        {
+            lore.append(FUtil.randomChatColor()).append(word).append(" ");
+        }
+
+        final ItemStack heldItem = new ItemStack(Material.COOKIE);
+        final ItemMeta heldItemMeta = heldItem.getItemMeta();
+        String name = ChatColor.DARK_RED + "C" +
+                ChatColor.GOLD + "o" +
+                ChatColor.YELLOW + "o" +
+                ChatColor.DARK_GREEN + "k" +
+                ChatColor.DARK_BLUE + "i" +
+                ChatColor.DARK_PURPLE + "e";
+        assert heldItemMeta != null;
+        heldItemMeta.setDisplayName(name);
+        heldItemMeta.setLore(Arrays.asList(lore.toString().split("\n")));
+        heldItem.setItemMeta(heldItemMeta);
+
+        for (final Player player : server.getOnlinePlayers())
+        {
+            final int firstEmpty = player.getInventory().firstEmpty();
+            if (firstEmpty >= 0)
+            {
+                player.getInventory().setItem(firstEmpty, heldItem);
+            }
+        }
+
+        FUtil.bcastMsg(output.toString());
+        return true;
+    }
+}

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

@@ -0,0 +1,59 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Quickly change your own gamemode to creative, define someone's username to change theirs, or change everyone's gamemode on the server.", usage = "/<command> <-a | [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 (args.length == 0)
+        {
+            if (isConsole())
+            {
+                msg("When used from the console, you must define a target player.");
+                return true;
+            }
+
+            playerSender.setGameMode(GameMode.CREATIVE);
+            msg("Your gamemode has been set to creative.");
+            return true;
+        }
+
+        checkRank(Rank.ADMIN);
+
+        if (args[0].equals("-a"))
+        {
+            for (Player targetPlayer : server.getOnlinePlayers())
+            {
+                targetPlayer.setGameMode(GameMode.CREATIVE);
+            }
+
+            FUtil.adminAction(sender.getName(), "Changing everyone's gamemode to creative", false);
+            msg("Your gamemode has been set to creative.");
+            return true;
+        }
+
+        Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(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;
+    }
+}

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

@@ -0,0 +1,51 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.SplittableRandom;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Makes random sounds.", usage = "/<command>")
+public class Command_deafen extends FreedomCommand
+{
+
+    public static final double STEPS = 10.0;
+    private static final SplittableRandom random = new SplittableRandom();
+
+    private static Location randomOffset(Location a)
+    {
+        return a.clone().add(randomDoubleRange() * 5.0, randomDoubleRange() * 5.0, randomDoubleRange() * 5.0);
+    }
+
+    private static Double randomDoubleRange()
+    {
+        return -1.0 + (random.nextDouble() * ((1.0 - -1.0) + 1.0));
+    }
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        {
+            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()
+                    {
+                        playerSender.playSound(randomOffset(playerSender.getLocation()), Sound.values()[random.nextInt(Sound.values().length)], 100.0f, pitch);
+                    }
+                }.runTaskLater(plugin, Math.round(20.0 * percent * 2.0));
+            }
+        }
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_debugstick.java

@@ -0,0 +1,38 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Get a stick of happiness.", usage = "/<command>")
+public class Command_debugstick extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        ItemStack itemStack = new ItemStack(Material.DEBUG_STICK);
+        ItemMeta itemMeta = itemStack.getItemMeta();
+        assert itemMeta != null;
+        itemMeta.displayName(Component.text("Stick of Happiness", NamedTextColor.GOLD).decorate(TextDecoration.BOLD));
+        itemMeta.lore(Arrays.asList(
+                Component.text("This is the most powerful stick in the game.", NamedTextColor.RED),
+                Component.text("You can left click to select what you want to change.", NamedTextColor.DARK_BLUE),
+                Component.text("And then you can right click to change it!", NamedTextColor.DARK_GREEN),
+                Component.text("Isn't technology amazing?", NamedTextColor.DARK_PURPLE)
+        ));
+        itemStack.setItemMeta(itemMeta);
+        playerSender.getInventory().addItem(itemStack);
+        return true;
+    }
+}

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

@@ -0,0 +1,27 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.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)
+    {
+        if (!plugin.esb.isEnabled())
+        {
+            msg("Essentials is not enabled on this server.");
+            return true;
+        }
+
+        FUtil.adminAction(sender.getName(), "Removing all nicknames", false);
+        server.getOnlinePlayers().forEach(player -> plugin.esb.setNickname(player.getName(), null));
+        return true;
+    }
+}

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

@@ -0,0 +1,60 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Deop a player", usage = "/<command> <partialname>")
+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;
+        }
+
+        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 (Player player : server.getOnlinePlayers())
+        {
+            if ((player.getName().toLowerCase().contains(targetName) || player.getDisplayName().toLowerCase().contains(targetName)
+                    || player.getName().contains(targetName) || player.getDisplayName().contains(targetName)) &&
+                    player.isOp() && !plugin.al.isVanished(player.getUniqueId()))
+            {
+                matchedPlayerNames.add(player.getName());
+                player.setOp(false);
+                msg(player, YOU_ARE_NOT_OP);
+                plugin.rm.updateDisplay(player);
+            }
+        }
+
+        if (!matchedPlayerNames.isEmpty())
+        {
+            if (!silent)
+            {
+                FUtil.adminAction(sender.getName(), "De-opping " + StringUtils.join(matchedPlayerNames, ", "), false);
+            }
+        }
+        else
+        {
+            msg("Either the player is already deopped, or the player could not be found.");
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,28 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.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);
+            msg(player, YOU_ARE_NOT_OP);
+            plugin.rm.updateDisplay(player);
+        }
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_disguisetoggle.java

@@ -0,0 +1,38 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Toggle LibsDisguises for everyone online.", usage = "/<command>", aliases = "dtoggle")
+public class Command_disguisetoggle extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!plugin.ldb.isEnabled())
+        {
+            msg("LibsDisguises is not enabled.");
+            return true;
+        }
+
+        FUtil.adminAction(sender.getName(), (plugin.ldb.isDisguisesEnabled() ? "Disabling" : "Enabling") + " disguises", false);
+
+        if (plugin.ldb.isDisguisesEnabled())
+        {
+            plugin.ldb.undisguiseAll(true);
+            plugin.ldb.setDisguisesEnabled(false);
+        }
+        else
+        {
+            plugin.ldb.setDisguisesEnabled(true);
+        }
+
+        msg("Disguises are now " + (plugin.ldb.isDisguisesEnabled() ? "enabled." : "disabled."));
+        return true;
+    }
+}

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

@@ -0,0 +1,102 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.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(rank = Rank.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
+{
+
+    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);
+        }
+    }
+
+    @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)
+            {
+                msg("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)
+                {
+                    items.add(new ItemStack(material, 64));
+                }
+                else
+                {
+                    msg("Skipping invalid item: " + searchItem);
+                }
+            }
+
+            final ItemStack[] itemsArray = items.toArray(new ItemStack[0]);
+
+            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))
+                            {
+                                msg("Filling dispenser @ " + FUtil.formatLocation(targetBlock.getLocation()));
+                                plugin.cpb.getCoreProtectAPI().logContainerTransaction(sender.getName(), targetBlock.getLocation());
+                                setDispenserContents(targetBlock, itemsArray);
+                                affected++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            msg("Done. " + affected + " dispenser(s) filled.");
+        }
+        else
+        {
+            return false;
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,133 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.banning.Ban;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.discord.Discord;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.ArrayUtils;
+import org.apache.commons.lang.StringUtils;
+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(rank = Rank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE, blockHostConsole = true)
+@CommandParameters(description = "Sends the specified player to their doom.", usage = "/<command> <playername> [reason]")
+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 == 0)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+
+        if (player == null)
+        {
+            msg(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 = FUtil.getIp(player);
+
+        // Remove from admin
+        Admin admin = getAdmin(player);
+        if (admin != null)
+        {
+            FUtil.adminAction(sender.getName(), "Removing " + player.getName() + " from the admin list", true);
+            admin.setActive(false);
+            plugin.al.save(admin);
+            plugin.al.updateTables();
+            if (plugin.dc.enabled && ConfigEntry.DISCORD_ROLE_SYNC.getBoolean())
+            {
+                Discord.syncRoles(admin, plugin.pl.getData(admin.getName()).getDiscordID());
+            }
+        }
+
+        // Remove from whitelist
+        player.setWhitelisted(false);
+
+        // Deop
+        player.setOp(false);
+
+        String reason = null;
+
+        if (args.length > 1)
+        {
+            reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+        }
+
+        // Ban player
+        Ban ban = Ban.forPlayer(player, sender);
+        ban.setReason((reason == null ? "FUCKOFF" : reason));
+        ban.addIp(ip);
+        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(), 0F, false);
+
+        // Shoot the player in the sky
+        player.setVelocity(player.getVelocity().clone().add(new Vector(0, 20, 0)));
+
+        final String kickReason = (reason == null ? "FUCKOFF, and get your shit together!" : reason);
+
+        // Log doom
+        plugin.pul.logPunishment(new Punishment(player.getName(), FUtil.getIp(player), sender.getName(), PunishmentType.DOOM, reason));
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                // strike lightning
+                player.getWorld().strikeLightningEffect(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(), true);
+                msg(sender, player.getName() + " has been banned and IP is: " + ip);
+
+                // generate explosion
+                player.getWorld().createExplosion(player.getLocation(), 0F, false);
+
+                // kick player
+                player.kickPlayer(ChatColor.RED + kickReason);
+            }
+        }.runTaskLater(plugin, 3L * 20L);
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_eject.java

@@ -0,0 +1,50 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Eject any entities that are riding you.", usage = "/<command>")
+public class Command_eject extends FreedomCommand
+{
+    /* Player.getShoulderEntityLeft() and Player.getShoulderEntityRight() are deprecated, however unless
+        Player.getPassengers() also includes shoulders (which isn't likely, given the official documentation doesn't
+        state an alternative method to use instead), these methods will continue to be used here. */
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        // Uses the size of the return value of Player.getPassengers() as the starting number of entities ejected
+        int count = playerSender.getPassengers().size();
+
+        // Removes any entities from the sender's shoulders
+        if (playerSender.getShoulderEntityLeft() != null)
+        {
+            playerSender.setShoulderEntityLeft(null);
+            count++;
+        }
+        if (playerSender.getShoulderEntityRight() != null)
+        {
+            playerSender.setShoulderEntityLeft(null);
+            count++;
+        }
+
+        // Removes anything riding the sender
+        playerSender.eject();
+
+        if (count != 0)
+        {
+            msg(count + " entit" + (count == 1 ? "y was" : "ies were") + " ejected.", ChatColor.GREEN);
+        }
+        else
+        {
+            msg("Nothing was ejected.", ChatColor.GREEN);
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,255 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.IntStream;
+
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Enchant items.", usage = "/<command> <list | addall | reset | add <name> [level] | remove <name>>")
+public class Command_enchant extends FreedomCommand
+{
+    @SuppressWarnings("deprecation")
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        ItemStack item = Objects.requireNonNull(playerSender.getEquipment()).getItemInMainHand();
+
+        if (item.getType() == Material.AIR)
+        {
+            msg("You have to hold an item to enchant it");
+            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(item))
+                {
+                    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"))
+        {
+            Arrays.stream(Enchantment.values()).filter(enchantment -> enchantment.canEnchantItem(item)).forEach(ench ->
+            {
+                try
+                {
+                    item.addEnchantment(ench, ench.getMaxLevel());
+                }
+                catch (Exception ex)
+                {
+                    msg("Could not add enchantment: " + ench.getName());
+                }
+            });
+
+            msg("Added all possible enchantments for this item.");
+        }
+        else if (args[0].equalsIgnoreCase("reset"))
+        {
+            item.getEnchantments().keySet().forEach(item::removeEnchantment);
+            msg("Removed all enchantments.");
+        }
+        else
+        {
+            if (args.length < 2)
+            {
+                return false;
+            }
+
+            Enchantment ench = null;
+
+            try
+            {
+                ench = Enchantment.getByName(args[1].toUpperCase());
+            }
+            catch (Exception ignored)
+            {
+            }
+
+            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(item) && !ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean())
+                {
+                    msg("Can't use this enchantment on held item.");
+                    return true;
+                }
+                int level = ench.getMaxLevel();
+                if (args.length > 2)
+                {
+                    try
+                    {
+                        if (ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean())
+                        {
+                            level = Integer.parseInt(args[2]);
+                        }
+                        else
+                        {
+                            level = Math.max(1, Math.min(ench.getMaxLevel(), Integer.parseInt(args[2])));
+                        }
+                    }
+                    catch (NumberFormatException ex)
+                    {
+                        msg("\"" + args[2] + "\" is not a valid number", ChatColor.RED);
+                        return true;
+                    }
+                }
+                if (!ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean())
+                {
+                    item.addEnchantment(ench, level);
+                }
+                else
+                {
+                    item.addUnsafeEnchantment(ench, level);
+                }
+
+                msg("Added enchantment: " + ench.getName());
+            }
+            else if (args[0].equals("remove"))
+            {
+                item.removeEnchantment(ench);
+
+                msg("Removed enchantment: " + ench.getName());
+            }
+        }
+
+        return true;
+    }
+
+    @SuppressWarnings("deprecation")
+    public List<String> getAllEnchantments()
+    {
+        List<String> enchantments = new ArrayList<>();
+        for (Enchantment enchantment : Enchantment.values())
+        {
+            enchantments.add(enchantment.getName());
+        }
+        return enchantments;
+    }
+
+    @SuppressWarnings("deprecation")
+    public List<String> getAllEnchantments(ItemStack item)
+    {
+        List<String> enchantments = new ArrayList<>();
+        for (Enchantment enchantment : Enchantment.values())
+        {
+            if (enchantment.canEnchantItem(item))
+            {
+                enchantments.add(enchantment.getName());
+            }
+        }
+        return enchantments;
+    }
+
+    @SuppressWarnings("deprecation")
+    public List<String> getEnchantments(ItemStack item)
+    {
+        List<String> enchantments = new ArrayList<>();
+        for (Enchantment enchantment : item.getEnchantments().keySet())
+        {
+            enchantments.add(enchantment.getName());
+        }
+        return enchantments;
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        Player player;
+        if (sender instanceof Player)
+        {
+            player = (Player)sender;
+        }
+        else
+        {
+            return Collections.emptyList();
+        }
+        ItemStack item = Objects.requireNonNull(player.getEquipment()).getItemInMainHand();
+
+        if (item.getType() == Material.AIR)
+        {
+            return Collections.emptyList();
+        }
+
+        boolean unsafe = ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean();
+
+        if (args.length == 1)
+        {
+            return Arrays.asList("list", "addall", "reset", "add", "remove");
+        }
+        else if (args.length == 2)
+        {
+            if (args[0].equals("add"))
+            {
+                if (unsafe)
+                {
+                    return getAllEnchantments();
+                }
+                else
+                {
+                    return getAllEnchantments(item);
+                }
+            }
+            else if (args[0].equals("remove"))
+            {
+                return getEnchantments(item);
+            }
+        }
+        else if (args.length == 3 && args[0].equals("add"))
+        {
+            Enchantment enchantment = Enchantment.getByName(args[1].toUpperCase());
+            if (enchantment != null)
+            {
+                if (!unsafe)
+                {
+                    return IntStream.rangeClosed(1, enchantment.getMaxLevel()).mapToObj(String::valueOf).toList();
+                }
+                else
+                {
+                    return Collections.singletonList("[level]");
+                }
+            }
+        }
+
+        return Collections.emptyList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_end.java

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

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

@@ -0,0 +1,119 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import me.totalfreedom.totalfreedommod.util.Groups;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Remove various server entities that may cause lag, such as dropped items, minecarts, and boats.", usage = "/<command> [name | -a]", aliases = "ew,rd")
+public class Command_entitywipe extends FreedomCommand
+{
+
+    public static List<EntityType> getAllEntities()
+    {
+        List<EntityType> entityTypes = new ArrayList<>();
+        for (EntityType entityType : EntityType.values())
+        {
+            if (!Groups.MOB_TYPES.contains(entityType))
+            {
+                entityTypes.add(entityType);
+            }
+        }
+        return entityTypes;
+    }
+
+    public static List<String> getAllEntityNames()
+    {
+        List<String> names = new ArrayList<>();
+        for (EntityType entityType : getAllEntities())
+        {
+            names.add(entityType.name());
+        }
+        return names;
+    }
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        EntityType type = null;
+        String entityName = null;
+        boolean bypassBlacklist = false;
+        if (args.length > 0)
+        {
+            if (args[0].equals("-a"))
+            {
+                bypassBlacklist = true;
+            }
+            else
+            {
+                try
+                {
+                    type = EntityType.valueOf(args[0].toUpperCase());
+                }
+                catch (Exception e)
+                {
+                    msg(args[0] + " is not a valid entity type.", ChatColor.RED);
+                    return true;
+                }
+
+                if (type == EntityType.PLAYER)
+                {
+                    msg("Player entities cannot be purged.", ChatColor.RED);
+                    return true;
+                }
+
+                if (!getAllEntities().contains(type))
+                {
+                    msg(FUtil.formatName(type.name()) + " is an entity, however: it is a mob.", ChatColor.RED);
+                    return true;
+                }
+            }
+        }
+
+        if (type != null)
+        {
+            entityName = FUtil.formatName(type.name());
+        }
+
+        FUtil.adminAction(sender.getName(), "Purging all " + (type != null ? entityName + "s" : "entities"), true);
+        int count;
+        if (type != null)
+        {
+            count = plugin.ew.wipeEntities(type);
+        }
+        else
+        {
+            count = plugin.ew.wipeEntities(bypassBlacklist);
+        }
+        if (count == 1)
+        {
+            msg(count + " " + (type != null ? entityName : "entity") + " removed.");
+        }
+        else
+        {
+            msg(count + " " + (type != null ? entityName : "entitie") + FUtil.showS(count) + " removed.");
+        }
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        List<String> names = getAllEntityNames();
+        names.add("-a");
+        if (args.length == 1)
+        {
+            return names;
+        }
+
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,90 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.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(rank = Rank.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 ignored)
+            {
+            }
+        }
+
+        if (args.length >= 2)
+        {
+            try
+            {
+                strength = Math.max(0.0, Math.min(50.0, Double.parseDouble(args[1])));
+            }
+            catch (NumberFormatException ignored)
+            {
+            }
+        }
+
+        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 ignored)
+            {
+            }
+
+            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;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_explode.java

@@ -0,0 +1,69 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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.util.Vector;
+
+@CommandPermissions(rank = Rank.SENIOR_ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Surprise someone.", usage = "/<command> <player>")
+public class Command_explode 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;
+        }
+
+        player.setFlying(false);
+        player.setVelocity(player.getVelocity().clone().add(new Vector(0, 50, 0)));
+
+        for (int i = 1; i <= 3; i++)
+        {
+            FUtil.createExplosionOnDelay(player.getLocation(), 2L, i * 10);
+        }
+
+        new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    player.getWorld().strikeLightning(player.getLocation());
+                    player.getWorld().createExplosion(player.getLocation(), 4L);
+                }
+                player.setHealth(0.0);
+                msg("Exploded " + player.getName());
+            }
+        }.runTaskLater(plugin, 40);
+
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1 && plugin.al.isAdmin(sender))
+        {
+            return FUtil.getPlayerList();
+        }
+        return Collections.emptyList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_explosivearrows.java

@@ -0,0 +1,31 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Make arrows explode", usage = "/<command>", aliases = "ea")
+public class Command_explosivearrows extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean onList = plugin.it.explosivePlayers.contains(playerSender);
+        if (onList)
+        {
+            plugin.it.explosivePlayers.remove(playerSender);
+            msg("You no longer have explosive arrows", ChatColor.RED);
+        }
+        else
+        {
+            plugin.it.explosivePlayers.add(playerSender);
+            msg("You now have explosive arrows", ChatColor.GREEN);
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,35 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Shows all IPs registered to a player", usage = "/<command> <player>", aliases = "showip,listip")
+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;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_fireball.java

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.shop.ShopItem;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Obtain a fire ball", usage = "/<command>")
+public class Command_fireball extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (plugin.pl.getData(playerSender).hasItem(ShopItem.FIRE_BALL))
+        {
+            playerSender.getInventory().addItem(plugin.sh.getFireBall());
+            msg("You have been given a Fire Ball", ChatColor.GREEN);
+        }
+        else
+        {
+            msg("You do not own a Fire Ball! Purchase one from the shop.", ChatColor.RED);
+        }
+        return true;
+    }
+}

commons/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.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Go to 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 in the TotalFreedomMod configuration.");
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_forcekill.java

@@ -0,0 +1,37 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Forcefully kill someone - for those who REALLY need to die.", usage = "/<command> <playername>")
+public class Command_forcekill extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!plugin.al.isAdmin(sender) && !senderIsConsole)
+        {
+            playerSender.setHealth(0);
+            return true;
+        }
+
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        final Player player = getPlayer(args[0]);
+        if (player == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        player.setHealth(0);
+        return true;
+    }
+}

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

@@ -0,0 +1,73 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.freeze.FreezeData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Freeze/Unfreeze a specified player, or all non-admins on the server.", 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 gFreeze = !plugin.fm.isGlobalFreeze();
+            plugin.fm.setGlobalFreeze(gFreeze);
+
+            if (!gFreeze)
+            {
+                FUtil.adminAction(sender.getName(), "Unfreezing all players", false);
+                msg("Players are now free to move.");
+                return true;
+            }
+
+            FUtil.adminAction(sender.getName(), "Freezing all players", false);
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!isAdmin(player))
+                {
+                    player.sendTitle(ChatColor.RED + "You've been globally frozen.", ChatColor.YELLOW + "Please be patient and you will be unfrozen shortly.", 20, 100, 60);
+                    msg(player, "You have been globally frozen due to an OP breaking the rules, please wait and you will be unfrozen soon.", ChatColor.RED);
+                }
+            }
+            msg("Players are now frozen.");
+            return true;
+        }
+
+        if (args[0].equalsIgnoreCase("purge"))
+        {
+            FUtil.adminAction(sender.getName(), "Unfreezing all players", false);
+            for (Player player : server.getOnlinePlayers())
+            {
+                if (!isAdmin(player))
+                {
+                    player.sendTitle(ChatColor.GREEN + "You've been unfrozen.", ChatColor.YELLOW + "You may now move again.", 20, 100, 60);
+                }
+            }
+            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;
+    }
+}

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

@@ -0,0 +1,50 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.SENIOR_ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "You'll never even see it coming - repeatedly push players away from you until command is untoggled.", usage = "/<command> <on [radius (default=25)] | off>")
+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;
+    }
+}

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

@@ -0,0 +1,62 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.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)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        final String outCommand = StringUtils.join(args, " ", 1, args.length);
+
+        if (plugin.cb.isCommandBlocked(outCommand, sender))
+        {
+            return true;
+        }
+
+        if (plugin.al.isAdmin(player))
+        {
+            msg(ChatColor.RED + "You can not use gcmd on admins");
+            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;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_glow.java

@@ -0,0 +1,32 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Toggles the glowing outline effect because y'all lazy as fuck", usage = "/<command>")
+public class Command_glow extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean glowing = false;
+        if (playerSender.getPotionEffect(PotionEffectType.GLOWING) != null)
+        {
+            playerSender.removePotionEffect(PotionEffectType.GLOWING);
+        }
+        else
+        {
+            PotionEffect glow = new PotionEffect(PotionEffectType.GLOWING, 1000000, 1, false, false);
+            playerSender.addPotionEffect(glow);
+            glowing = true;
+        }
+        msg("You are " + (glowing ? "now" : "no longer") + " glowing.");
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_grapplinghook.java

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.shop.ShopItem;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Obtain a grappling hook", usage = "/<command>")
+public class Command_grapplinghook extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (plugin.pl.getData(playerSender).hasItem(ShopItem.GRAPPLING_HOOK))
+        {
+            playerSender.getInventory().addItem(plugin.sh.getGrapplingHook());
+            msg("You have been given a Grappling Hook", ChatColor.GREEN);
+        }
+        else
+        {
+            msg("You do not own a Grappling Hook! Purchase one from the shop.", ChatColor.RED);
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_gravity.java

@@ -0,0 +1,22 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Toggles player gravity on/off.", usage = "/<command>")
+public class Command_gravity extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean enabled = !playerSender.hasGravity();
+        playerSender.setGravity(enabled);
+        msg((enabled ? "En" : "Dis") + "abled gravity.", (enabled ? ChatColor.GREEN : ChatColor.RED));
+        return true;
+    }
+}

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

@@ -0,0 +1,110 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.text.DecimalFormat;
+import java.util.concurrent.atomic.AtomicInteger;
+import me.totalfreedom.totalfreedommod.TotalFreedomMod;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "View server health, such as ticks-per-second, memory, etc.", 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();
+
+                    // Plugin was disabled during async task
+                    if (!plugin.isEnabled())
+                    {
+                        return;
+                    }
+
+                    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 static 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);
+        }
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_indefban.java

@@ -0,0 +1,32 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.SENIOR_ADMIN, source = SourceType.ONLY_CONSOLE)
+@CommandParameters(description = "Reload the indefinite ban list.", usage = "/<command> <reload>", aliases = "ib")
+public class Command_indefban 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 the indefinite ban list...");
+        plugin.im.onStop();
+        plugin.im.onStart();
+        msg("Reloaded the indefinite ban list.");
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_inspect.java

@@ -0,0 +1,85 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Block inspector tool for operators.", usage = "/<command> [history] [page]", aliases = "ins")
+public class Command_inspect extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!plugin.cpb.isEnabled())
+        {
+            msg("CoreProtect is not enabled on this server.");
+            return true;
+        }
+
+        if (args.length == 0)
+        {
+            PlayerData playerData = plugin.pl.getData(playerSender);
+            playerData.setInspect(!playerData.hasInspection());
+            plugin.pl.save(playerData);
+            msg("Block inspector " + (playerData.hasInspection() ? "enabled." : "disabled."));
+            return true;
+        }
+
+        if (args[0].equalsIgnoreCase("history"))
+        {
+            int pageIndex = 1;
+
+            if (args.length >= 2)
+            {
+                try
+                {
+                    pageIndex = Integer.parseInt(args[1]);
+                }
+                catch (NumberFormatException e)
+                {
+                    msg("Invalid number.", ChatColor.RED);
+                    return true;
+                }
+            }
+
+            int godDammit = pageIndex;
+            Optional.ofNullable(plugin.cpb.getHistoryForPlayer(playerSender)).ifPresentOrElse(page ->
+                    plugin.cpb.showPageToPlayer(playerSender, page, godDammit),
+                    () -> msg("You haven't inspected anything yet!", ChatColor.RED));
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1)
+        {
+            return Collections.singletonList("history");
+        }
+        else if (args.length == 2 && args[0].equalsIgnoreCase("history") && plugin.cpb.isEnabled()
+                && sender instanceof Player player && plugin.cpb.hasHistory(player))
+        {
+            return IntStream.rangeClosed(1, plugin.cpb.getHistoryForPlayer(player).getPageCount()).limit(50)
+                    .mapToObj(String::valueOf).toList();
+        }
+        else
+        {
+            return Collections.emptyList();
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Shows (optionally clears) invisible players", usage = "/<command> [clear]")
+public class Command_invis extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean clear = false;
+
+        if (args.length >= 1)
+        {
+            if (args[0].equalsIgnoreCase("clear"))
+            {
+                if (!plugin.al.isAdmin(sender))
+                {
+                    return noPerms();
+                }
+                else
+                {
+                    FUtil.adminAction(sender.getName(), "Clearing all invisibility potion effects from all players", true);
+                    clear = true;
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        List<String> players = new ArrayList<>();
+        int clears = 0;
+
+        for (Player player : server.getOnlinePlayers())
+        {
+            if (player.hasPotionEffect(PotionEffectType.INVISIBILITY) && !plugin.al.isVanished(player.getUniqueId()))
+            {
+                players.add(player.getName());
+                if (clear && !plugin.al.isAdmin(player))
+                {
+                    player.removePotionEffect((PotionEffectType.INVISIBILITY));
+                    clears++;
+                }
+            }
+        }
+
+        if (players.isEmpty())
+        {
+            msg("There are no invisible players");
+            return true;
+        }
+
+        if (clear)
+        {
+            msg("Cleared " + clears + " players");
+        }
+        else
+        {
+            msg("Invisible players (" + players.size() + "): " + StringUtils.join(players, ", "));
+        }
+
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1 && plugin.al.isAdmin(sender))
+        {
+            return Collections.singletonList("clear");
+        }
+
+        return Collections.emptyList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_invsee.java

@@ -0,0 +1,73 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Look into another player's inventory, or optionally take items out.", usage = "/<command> <player> [offhand | armor]", aliases = "inv,insee")
+public class Command_invsee extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        Player player = getPlayer(args[0], true);
+
+        if (player == null)
+        {
+            msg(PLAYER_NOT_FOUND);
+            return false;
+        }
+
+        if (playerSender == player)
+        {
+            msg("You cannot run this command on yourself.", ChatColor.RED);
+            return true;
+        }
+
+        if (plugin.al.isAdmin(player) && !plugin.al.isAdmin(playerSender))
+        {
+            msg("You cannot see the inventory of admins.", ChatColor.RED);
+            return true;
+        }
+
+        Inventory inv;
+        if (args.length > 1)
+        {
+            if (args[1].equals("offhand"))
+            {
+                ItemStack offhand = player.getInventory().getItemInOffHand();
+                Inventory inventory = server.createInventory(null, 9, player.getName() + "'s offhand");
+                inventory.setItem(1, offhand);
+                playerSender.openInventory(inventory);
+                return true;
+            }
+            else if (args[1].equals("armor"))
+            {
+                Inventory inventory = server.createInventory(null, 9, player.getName() + "'s armor");
+                inventory.setContents(player.getInventory().getArmorContents());
+                playerSender.openInventory(inventory);
+                return true;
+            }
+        }
+        inv = player.getInventory();
+        playerSender.closeInventory();
+        if (!plugin.al.isAdmin(player))
+        {
+            FPlayer fPlayer = plugin.pl.getPlayer(playerSender);
+            fPlayer.setInvSee(true);
+        }
+        playerSender.openInventory(inv);
+        return true;
+    }
+}

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

@@ -0,0 +1,116 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.fun.Jumppads;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Toggles jumppads on/off, view the status of jumppads, or make them sideways.", usage = "/<command> <on | off | info | sideways <on | off>>", 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.players.get(playerSender).isOn() ? "Enabled" : "Disabled"), ChatColor.BLUE);
+                msg("Sideways: " + (plugin.jp.players.get(playerSender) == Jumppads.JumpPadMode.NORMAL_AND_SIDEWAYS ? "Enabled" : "Disabled"), ChatColor.BLUE);
+                return true;
+            }
+
+            if (args[0].equalsIgnoreCase("off"))
+            {
+                if (plugin.jp.players.get(playerSender) == Jumppads.JumpPadMode.OFF)
+                {
+                    msg("Your jumppads are already disabled.");
+                    return true;
+                }
+                msg("Disabled your jumppads.", ChatColor.GRAY);
+                plugin.jp.players.put(playerSender, Jumppads.JumpPadMode.OFF);
+            }
+            else
+            {
+                if (plugin.jp.players.get(playerSender) != Jumppads.JumpPadMode.OFF)
+                {
+                    msg("Your jumppads are already enabled.");
+                    return true;
+                }
+                msg("Enabled your jumpppads.", ChatColor.GRAY);
+                plugin.jp.players.put(playerSender, Jumppads.JumpPadMode.MADGEEK);
+            }
+        }
+        else
+        {
+            if (plugin.jp.players.get(playerSender) == Jumppads.JumpPadMode.OFF)
+            {
+                msg("Your jumppads are currently disabled, please enable them before changing jumppads settings.");
+                return true;
+            }
+
+            if (args[0].equalsIgnoreCase("sideways"))
+            {
+                if ("off".equals(args[1]))
+                {
+                    if (plugin.jp.players.get(playerSender) == Jumppads.JumpPadMode.MADGEEK)
+                    {
+                        msg("Your jumppads are already set to normal mode.");
+                        return true;
+                    }
+                    msg("Set Jumppads mode to: Normal", ChatColor.GRAY);
+                    plugin.jp.players.put(playerSender, Jumppads.JumpPadMode.MADGEEK);
+                }
+                else
+                {
+                    if (plugin.jp.players.get(playerSender) == Jumppads.JumpPadMode.NORMAL_AND_SIDEWAYS)
+                    {
+                        msg("Your jumppads are already set to normal and sideways mode.");
+                        return true;
+                    }
+                    msg("Set Jumppads mode to: Normal and Sideways", ChatColor.GRAY);
+                    plugin.jp.players.put(playerSender, Jumppads.JumpPadMode.NORMAL_AND_SIDEWAYS);
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (!plugin.al.isAdmin(sender))
+        {
+            return Collections.emptyList();
+        }
+        if (args.length == 1)
+        {
+            return Arrays.asList("on", "off", "info", "sideways");
+        }
+        else if (args.length == 2)
+        {
+            if (args[0].equals("sideways"))
+            {
+                return Arrays.asList("on", "off");
+            }
+        }
+
+        return Collections.emptyList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_kick.java

@@ -0,0 +1,86 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FLog;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Kick the specified player.", usage = "/<command> <player> [reason] [-q]")
+public class Command_kick 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(PLAYER_NOT_FOUND);
+            return true;
+        }
+
+        boolean silent = false;
+
+        String reason = null;
+        if (args[args.length - 1].equalsIgnoreCase("-q"))
+        {
+            silent = true;
+            FLog.debug("silent");
+
+            if (args.length >= 2)
+            {
+                FLog.debug("set reason (silent)");
+                reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length - 1), " ");
+            }
+        }
+        else if (args.length > 1)
+        {
+            FLog.debug("set reason");
+            reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
+        }
+
+        StringBuilder builder = new StringBuilder()
+                .append(ChatColor.RED).append("You have been kicked from the server.")
+                .append("\n").append(ChatColor.RED).append("Kicked by: ").append(ChatColor.GOLD).append(sender.getName());
+
+        if (reason != null)
+        {
+            builder.append("\n").append(ChatColor.RED).append("Reason: ").append(ChatColor.GOLD).append(reason);
+        }
+
+        if (!silent)
+        {
+            if (reason != null)
+            {
+                FUtil.adminAction(sender.getName(), "Kicking " + player.getName() + " - Reason: " + reason, true);
+            }
+            else
+            {
+                FUtil.adminAction(sender.getName(), "Kicking " + player.getName(), true);
+            }
+        }
+        else
+        {
+            msg("Kicked " + player.getName() + " quietly.");
+        }
+
+        player.kickPlayer(builder.toString());
+
+        plugin.pul.logPunishment(new Punishment(player.getName(), FUtil.getIp(player), sender.getName(), PunishmentType.KICK, reason));
+
+        return true;
+    }
+}

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

@@ -0,0 +1,24 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Kick all non-admins on server.", usage = "/<command>", aliases = "kickall")
+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-admins", true);
+
+        server.getOnlinePlayers().stream().filter(player -> !plugin.al.isAdmin(player)).forEach(player ->
+                player.kick(Component.text("All non-admins were kicked by " + sender.getName() + ".", NamedTextColor.RED)));
+        return true;
+    }
+}

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

@@ -0,0 +1,65 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Iterator;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.fun.Landminer.Landmine;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.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 ignored)
+            {
+            }
+        }
+
+        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;
+    }
+}

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

@@ -0,0 +1,45 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Show the last command the specified player 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;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_lightningrod.java

@@ -0,0 +1,29 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.shop.ShopItem;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Obtain a lightning rod", usage = "/<command>")
+public class Command_lightningrod extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (plugin.pl.getData(playerSender).hasItem(ShopItem.LIGHTNING_ROD))
+        {
+            playerSender.getInventory().addItem(plugin.sh.getLightningRod());
+            msg("You have been given a Lightning Rod", ChatColor.GREEN);
+        }
+        else
+        {
+            msg("You do not own a Lightning Rod! Purchase one from the shop.", ChatColor.RED);
+        }
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_linkdiscord.java

@@ -0,0 +1,61 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.discord.Discord;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Link your Discord account to your Minecraft account", usage = "/<command> [<name> <id>]")
+public class Command_linkdiscord extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!plugin.dc.enabled)
+        {
+            msg("The Discord integration system is currently disabled.", ChatColor.RED);
+            return true;
+        }
+
+        if (args.length > 1 && plugin.al.isAdmin(playerSender))
+        {
+            PlayerData playerData = plugin.pl.getData(args[0]);
+            if (playerData == null)
+            {
+                msg(PLAYER_NOT_FOUND);
+                return true;
+            }
+
+            playerData.setDiscordID(args[1]);
+            msg("Linked " + args[0] + "'s Discord account.", ChatColor.GREEN);
+            return true;
+        }
+
+        String code;
+
+        PlayerData data = plugin.pl.getData(playerSender);
+        if (data.getDiscordID() != null)
+        {
+            msg("Your Minecraft account is already linked to a Discord account.", ChatColor.RED);
+            return true;
+        }
+
+        if (Discord.LINK_CODES.containsValue(data))
+        {
+            code = Discord.getCode(data);
+        }
+        else
+        {
+            code = plugin.dc.generateCode(5);
+            Discord.LINK_CODES.put(code, data);
+        }
+        msg("Your linking code is " + ChatColor.AQUA + code, ChatColor.GREEN);
+        msg("Take this code and DM the server bot (" + plugin.dc.formatBotTag() + ") the code (do not put anything else in the message, only the code)");
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_links.java

@@ -0,0 +1,49 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "See TotalFreedom's social media links.", usage = "/<command>", aliases = "link")
+public class Command_links extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        YamlConfiguration config = plugin.config.configuration;
+        ConfigurationSection section = config.getConfigurationSection("social_links");
+        if (section != null)
+        {
+            Map<String, Object> values = section.getValues(false);
+
+            List<String> lines = new ArrayList<>();
+
+            for (String key : values.keySet())
+            {
+                if (!(values.get(key) instanceof String))
+                {
+                    continue;
+                }
+                String link = (String)values.get(key);
+                lines.add(ChatColor.GOLD + "- " + key + ": " + ChatColor.AQUA + link);
+            }
+
+            msg("Social Media Links:", ChatColor.AQUA);
+            sender.sendMessage(lines.toArray(new String[0]));
+            return true;
+        }
+        else
+        {
+            msg("There are no links added in the configuration file.", ChatColor.RED);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,98 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import net.md_5.bungee.api.ChatColor;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+@CommandPermissions(rank = Rank.NON_OP, source = SourceType.BOTH)
+@CommandParameters(description = "Lists the real names of all online players.", usage = "/<command> [-a | -v]", aliases = "who,lsit")
+public class Command_list extends FreedomCommand
+{
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, final Command cmd, final String commandLabel, final String[] args, final boolean senderIsConsole)
+    {
+        if (args.length > 1)
+        {
+            return false;
+        }
+
+        ListFilter listFilter;
+        if (args.length == 1)
+        {
+            switch (args[0].toLowerCase())
+            {
+                case "-s", "-a" -> listFilter = ListFilter.ADMINS;
+                case "-v" ->
+                {
+                    checkRank(Rank.ADMIN);
+                    listFilter = ListFilter.VANISHED_ADMINS;
+                }
+                case "-t" ->
+                {
+                    checkRank(Rank.ADMIN);
+                    listFilter = ListFilter.TELNET_SESSIONS;
+                }
+                default ->
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            listFilter = ListFilter.PLAYERS;
+        }
+
+        String onlineStats;
+        List<String> players;
+
+        if (listFilter == ListFilter.TELNET_SESSIONS && plugin.al.isAdmin(sender))
+        {
+            players = plugin.btb.getConnectedAdmins().stream().map(Admin::getName).toList();
+            onlineStats = ChatColor.BLUE + "There are " + ChatColor.RED + players.size() + ChatColor.BLUE
+                    + " admins connected to telnet.";
+        }
+        else
+        {
+            onlineStats = ChatColor.BLUE + "There are " + ChatColor.RED + FUtil.getFakePlayerCount() + ChatColor.BLUE
+                    + " out of a maximum " + ChatColor.RED + server.getMaxPlayers() + ChatColor.BLUE + " players online.";
+
+            players = server.getOnlinePlayers().stream().filter(pl ->
+                    (listFilter == ListFilter.ADMINS && plugin.al.isAdmin(pl) && !plugin.al.isVanished(pl.getUniqueId()))
+                    || (listFilter == ListFilter.VANISHED_ADMINS && plugin.al.isVanished(pl.getUniqueId()))
+                    || (listFilter == ListFilter.PLAYERS && !plugin.al.isVanished(pl.getUniqueId()))).map(player ->
+                    plugin.rm.getDisplay(player).getColoredTag() + player.getName()).toList();
+        }
+
+        String onlineUsers = "Connected " + listFilter.name().toLowerCase().replace('_', ' ') + ": " + ChatColor.WHITE +
+                StringUtils.join(players, ChatColor.WHITE + ", " + ChatColor.WHITE);
+
+        if (senderIsConsole)
+        {
+            msg(ChatColor.stripColor(onlineStats));
+            msg(ChatColor.stripColor(onlineUsers));
+        }
+        else
+        {
+            msg(onlineStats);
+            msg(onlineUsers);
+        }
+
+        return true;
+    }
+
+    private enum ListFilter
+    {
+        PLAYERS,
+        ADMINS,
+        VANISHED_ADMINS,
+        TELNET_SESSIONS
+    }
+}

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

@@ -0,0 +1,20 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import io.papermc.lib.PaperLib;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Teleport to the spawn point for the current world, instead of the Essentials spawn point.", 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)
+    {
+        PaperLib.teleportAsync(playerSender, playerSender.getWorld().getSpawnLocation());
+        msg("Teleported to spawnpoint for world \"" + playerSender.getWorld().getName() + "\".");
+        return true;
+    }
+}

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

@@ -0,0 +1,135 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.SENIOR_ADMIN, source = SourceType.BOTH, blockHostConsole = true)
+@CommandParameters(description = "This is evil, and I never should have wrote it - blocks specified player's input.", usage = "/<command> <all | purge | <<partialname> on | off> [-q]>")
+public class Command_lockup extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        boolean silent = (args[args.length - 1].equalsIgnoreCase("-q"));
+        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)
+                {
+                    msg(PLAYER_NOT_FOUND);
+                    return true;
+                }
+
+                if (!silent)
+                {
+                    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)
+                {
+                    msg(PLAYER_NOT_FOUND);
+                    return true;
+                }
+
+                if (!silent)
+                {
+                    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.setLockedUp(false);
+            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.setLockedUp(true);
+        playerdata.setLockupScheduleId(new BukkitRunnable()
+        {
+            @Override
+            public void run()
+            {
+                if (player.isOnline())
+                {
+                    player.openInventory(player.getInventory());
+                }
+                else
+                {
+                    cancelLockup(playerdata);
+                }
+            }
+        }.runTaskTimer(plugin, 0L, 5L));
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_loginmessage.java

@@ -0,0 +1,51 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.shop.ShopItem;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Change your login message", usage = "/<command> [message]")
+public class Command_loginmessage extends FreedomCommand
+{
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!plugin.pl.getData(playerSender).hasItem(ShopItem.LOGIN_MESSAGES) && !isAdmin(playerSender))
+        {
+            msg("You did not purchase the ability to use login messages! Purchase the ability from the shop.", ChatColor.RED);
+            return true;
+        }
+
+        if (args.length == 0)
+        {
+            playerSender.openInventory(plugin.sh.generateLoginMessageGUI(playerSender));
+            return true;
+        }
+
+        checkRank(Rank.ADMIN);
+
+        String message = StringUtils.join(args, " ");
+        if (!message.contains("%rank%") && !message.contains("%coloredrank%"))
+        {
+            msg("Your login message must contain your rank. Use either %rank% or %coloredrank% to specify where you want the rank", ChatColor.RED);
+            return true;
+        }
+        int length = message.replace("%name%", "").replace("%rank%", "").replace("%coloredrank%", "").replace("%art%", "").length();
+        if (length > 100)
+        {
+            msg("Your login message cannot be more than 100 characters (excluding your rank and your name)", ChatColor.RED);
+            return true;
+        }
+        PlayerData data = getData(playerSender);
+        data.setLoginMessage(message);
+        plugin.pl.save(data);
+        msg("Your login message is now the following:\n" + plugin.rm.craftLoginMessage(playerSender, message), ChatColor.GREEN);
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_manageshop.java

@@ -0,0 +1,228 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.shop.ShopItem;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Manage the shop", usage = "/<command> <coins: <add | set | remove> <amount> <player | all> | items: <give | take> <item> <player>", aliases = "ms")
+public class Command_manageshop extends FreedomCommand
+{
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+
+        if (!FUtil.isExecutive(sender.getName()))
+        {
+            return noPerms();
+        }
+
+        if (args.length < 2)
+        {
+            return false;
+        }
+        if (args[0].equals("coins"))
+        {
+            if (args.length < 4)
+            {
+                return false;
+            }
+            switch (args[1])
+            {
+                case "add":
+                {
+                    try
+                    {
+                        int amount = Math.max(0, Math.min(1000000, Integer.parseInt(args[2])));
+                        if (!args[3].equals("all"))
+                        {
+                            PlayerData playerData = plugin.pl.getData(args[3]);
+                            if (playerData == null)
+                            {
+                                msg(PLAYER_NOT_FOUND);
+                                return true;
+                            }
+                            playerData.setCoins(playerData.getCoins() + amount);
+                            plugin.pl.save(playerData);
+                            msg("Successfully added " + amount + " coins to " + args[3] + ". Their new balance is " + playerData.getCoins(), ChatColor.GREEN);
+                            Player player = getPlayer(args[3]);
+                            if (player != null)
+                            {
+                                msg(player, sender.getName() + " gave you " + amount + " coins. Your new balance is " + playerData.getCoins(), ChatColor.GREEN);
+                            }
+                        }
+                        else
+                        {
+                            for (Player player : server.getOnlinePlayers())
+                            {
+                                PlayerData playerData = plugin.pl.getData(player);
+                                playerData.setCoins(playerData.getCoins() + amount);
+                                plugin.pl.save(playerData);
+                                msg(player, sender.getName() + " gave you " + amount + " coins. Your new balance is " + playerData.getCoins(), ChatColor.GREEN);
+                            }
+                            msg("Successfully added " + amount + " coins to all online players.", ChatColor.GREEN);
+                        }
+                        return true;
+                    }
+                    catch (NumberFormatException ex)
+                    {
+                        msg("Invalid number: " + args[2], ChatColor.RED);
+                        return true;
+                    }
+                }
+                case "remove":
+                {
+                    try
+                    {
+                        int amount = Math.max(0, Math.min(1000000, Integer.parseInt(args[2])));
+                        if (!args[3].equals("all"))
+                        {
+                            PlayerData playerData = plugin.pl.getData(args[3]);
+                            if (playerData == null)
+                            {
+                                msg(PLAYER_NOT_FOUND);
+                                return true;
+                            }
+                            playerData.setCoins(playerData.getCoins() - amount);
+                            if (playerData.getCoins() < 0)
+                            {
+                                playerData.setCoins(0);
+                            }
+                            plugin.pl.save(playerData);
+                            msg("Successfully removed " + amount + " coins from " + args[3] + ". Their new balance is " + playerData.getCoins(), ChatColor.GREEN);
+                            Player player = getPlayer(args[3]);
+                            if (player != null)
+                            {
+                                msg(player, sender.getName() + " took " + amount + " coins from you. Your new balance is " + playerData.getCoins(), ChatColor.RED);
+                            }
+                        }
+                        else
+                        {
+                            for (Player player : server.getOnlinePlayers())
+                            {
+                                PlayerData playerData = plugin.pl.getData(player);
+                                playerData.setCoins(playerData.getCoins() - amount);
+                                if (playerData.getCoins() < 0)
+                                {
+                                    playerData.setCoins(0);
+                                }
+                                plugin.pl.save(playerData);
+                                msg(player, sender.getName() + " took " + amount + " coins from you. Your new balance is " + playerData.getCoins(), ChatColor.RED);
+                            }
+                            msg("Successfully took " + amount + " coins from all online players.", ChatColor.GREEN);
+                        }
+                        return true;
+                    }
+                    catch (NumberFormatException ex)
+                    {
+                        msg("Invalid number: " + args[2], ChatColor.RED);
+                        return true;
+                    }
+                }
+                case "set":
+                {
+                    try
+                    {
+                        int amount = Math.max(0, Math.min(1000000, Integer.parseInt(args[2])));
+                        PlayerData playerData = plugin.pl.getData(args[3]);
+                        if (playerData == null)
+                        {
+                            msg(PLAYER_NOT_FOUND);
+                            return true;
+                        }
+                        playerData.setCoins(amount);
+                        plugin.pl.save(playerData);
+                        msg("Successfully set " + args[3] + "'s coins to " + amount, ChatColor.GREEN);
+                        Player player = getPlayer(args[3]);
+                        if (player != null)
+                        {
+                            msg(player, sender.getName() + " set your coin balance to " + amount, ChatColor.GREEN);
+                        }
+                        return true;
+                    }
+                    catch (NumberFormatException ex)
+                    {
+                        msg("Invalid number: " + args[2], ChatColor.RED);
+                        return true;
+                    }
+                }
+                default:
+                {
+                    return false;
+                }
+            }
+        }
+        else if (args[0].equals("items"))
+        {
+            if (args[1].equals("list"))
+            {
+                msg("List of all shop items: " + StringUtils.join(ShopItem.values(), ", "));
+                return true;
+            }
+
+            if (args.length < 4)
+            {
+                return false;
+            }
+
+            if (args[1].equals("give"))
+            {
+                ShopItem item = ShopItem.findItem(args[2].toUpperCase());
+                if (item == null)
+                {
+                    msg(args[2] + " is not a valid item.", ChatColor.RED);
+                    return true;
+                }
+
+                PlayerData playerData = plugin.pl.getData(args[3]);
+                if (playerData == null)
+                {
+                    msg(PLAYER_NOT_FOUND);
+                    return true;
+                }
+                playerData.giveItem(item);
+                plugin.pl.save(playerData);
+                msg("Successfully gave the " + item.getName() + " to " + args[3], ChatColor.GREEN);
+                Player player = getPlayer(args[3]);
+                if (player != null)
+                {
+                    msg(player, sender.getName() + " gave the " + item.getName() + " to you", ChatColor.GREEN);
+                }
+                return true;
+            }
+            else if (args[1].equals("take"))
+            {
+                ShopItem item = ShopItem.findItem(args[2].toUpperCase());
+                if (item == null)
+                {
+                    msg(args[2] + " is not a valid item.", ChatColor.RED);
+                    return true;
+                }
+
+                PlayerData playerData = plugin.pl.getData(args[3]);
+                if (playerData == null)
+                {
+                    msg(PLAYER_NOT_FOUND);
+                    return true;
+                }
+                playerData.removeItem(item);
+                plugin.pl.save(playerData);
+                msg("Successfully took the " + item.getName() + " from " + args[3], ChatColor.GREEN);
+                Player player = getPlayer(args[3]);
+                if (player != null)
+                {
+                    msg(player, sender.getName() + " took the " + item.getName() + " from you", ChatColor.RED);
+                }
+                return true;
+            }
+
+        }
+        return false;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_masterbuilderinfo.java

@@ -0,0 +1,34 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.List;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Information on how to apply for Master Builder.", usage = "/<command>", aliases = "mbi")
+public class Command_masterbuilderinfo extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        List<String> masterBuilderInfo = ConfigEntry.MASTER_BUILDER_INFO.getStringList();
+
+        if (masterBuilderInfo.isEmpty())
+        {
+            msg("The master builder information section of the config.yml file has not been configured.", ChatColor.RED);
+        }
+        else
+        {
+            msg(FUtil.colorize(StringUtils.join(masterBuilderInfo, "\n")));
+        }
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_masterbuilderworld.java

@@ -0,0 +1,202 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import io.papermc.lib.PaperLib;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Allows for master builders to configure the time, the weather of the MasterBuilder, and allows for players to go to the MasterBuilderWorld.",
+        usage = "/<command> [time <morning | noon | evening | night> | weather <off | rain | storm>]",
+        aliases = "mbw,mbworld")
+public class Command_masterbuilderworld extends FreedomCommand
+{
+
+    @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 ("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 false;
+                    }
+
+                    World masterBuilderWorld = null;
+                    try
+                    {
+                        masterBuilderWorld = plugin.wm.masterBuilderWorld.getWorld();
+                    }
+                    catch (Exception ignored)
+                    {
+                    }
+
+                    if (masterBuilderWorld == null || playerSender.getWorld() == masterBuilderWorld)
+                    {
+                        msg("Going to the main world.");
+                        PaperLib.teleportAsync(playerSender, server.getWorlds().get(0).getSpawnLocation());
+                    }
+                    else
+                    {
+                        msg("Going to the Master Builder world");
+                        plugin.wm.masterBuilderWorld.sendToWorld(playerSender);
+                    }
+
+                    break;
+                }
+                case TIME:
+                {
+                    assertCommandPerms(sender, playerSender);
+
+                    if (args.length == 2)
+                    {
+                        WorldTime timeOfDay = WorldTime.getByAlias(args[1]);
+                        if (timeOfDay != null)
+                        {
+                            plugin.wm.masterBuilderWorld.setTimeOfDay(timeOfDay);
+                            msg("MasterBuilder world 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.masterBuilderWorld.setWeatherMode(weatherMode);
+                            msg("MasterBuilder world 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();
+            }
+            msg(ex.getMessage());
+            return true;
+        }
+
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (!plugin.al.isAdmin(sender))
+        {
+            return Collections.emptyList();
+        }
+        if (args.length == 1)
+        {
+            return Arrays.asList("time", "weather");
+        }
+        else if (args.length == 2)
+        {
+            if (args[0].equals("time"))
+            {
+                return Arrays.asList("morning", "noon", "evening", "night");
+            }
+            else if (args[0].equals("weather"))
+            {
+                return Arrays.asList("off", "rain", "storm");
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    // TODO: Redo this properly
+    private void assertCommandPerms(CommandSender sender, Player playerSender) throws PermissionDeniedException
+    {
+        if (!(sender instanceof Player) || playerSender == null || !plugin.al.isAdmin(playerSender))
+        {
+            throw new PermissionDeniedException();
+        }
+    }
+
+    private enum CommandMode
+    {
+        TELEPORT, TIME, WEATHER
+    }
+
+    private static class PermissionDeniedException extends Exception
+    {
+
+        private static final long serialVersionUID = 1L;
+
+        private PermissionDeniedException()
+        {
+            super("");
+        }
+
+        private PermissionDeniedException(String string)
+        {
+            super(string);
+        }
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_mbconfig.java

@@ -0,0 +1,201 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "List, add, or remove master builders. Master builders can also clear their own IPs.", usage = "/<command> <list | clearip <ip> | clearips | <<add | remove> <username>>>")
+public class Command_mbconfig 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("Master Builders: " + StringUtils.join(plugin.pl.getMasterBuilderNames(), ", "), ChatColor.GOLD);
+                return true;
+            }
+
+            case "clearips":
+            {
+                if (args.length > 1)
+                {
+                    return false;
+                }
+
+                if (senderIsConsole)
+                {
+                    msg("Only in-game players may use this command.", ChatColor.RED);
+                    return true;
+                }
+
+                PlayerData data = plugin.pl.getData(sender.getName());
+                if (!data.isMasterBuilder())
+                {
+                    msg("You are not a master builder!", ChatColor.RED);
+                    return true;
+                }
+
+                int counter = data.getIps().size() - 1;
+                data.clearIps();
+                data.addIp(FUtil.getIp(playerSender));
+                plugin.sql.addPlayer(data);
+                msg(counter + " IPs removed.");
+                msg(data.getIps().get(0) + " is now your only IP address");
+                FUtil.adminAction(sender.getName(), "Clearing my IPs", true);
+                return true;
+            }
+            case "clearip":
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                if (senderIsConsole)
+                {
+                    msg("Only in-game players may use this command.", ChatColor.RED);
+                    return true;
+                }
+
+                PlayerData data = plugin.pl.getData(sender.getName());
+                final String targetIp = FUtil.getIp(playerSender);
+
+                if (!data.isMasterBuilder())
+                {
+                    msg("You are not a master builder!", ChatColor.RED);
+                    return true;
+                }
+
+                if (targetIp.equals(args[1]))
+                {
+                    msg("You cannot remove your current IP.");
+                    return true;
+                }
+                data.removeIp(args[1]);
+                plugin.sql.addPlayer(data);
+                msg("Removed IP " + args[1]);
+                msg("Current IPs: " + StringUtils.join(data.getIps(), ", "));
+                return true;
+            }
+            case "add":
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                if (plugin.pl.canManageMasterBuilders(sender.getName()))
+                {
+                    return noPerms();
+                }
+
+                final Player player = getPlayer(args[1]);
+
+                PlayerData data = player != null ? plugin.pl.getData(player) : plugin.pl.getData(args[1]);
+
+                if (data == null)
+                {
+                    msg(PLAYER_NOT_FOUND, ChatColor.RED);
+                    return true;
+                }
+
+                if (!data.isMasterBuilder())
+                {
+                    FUtil.adminAction(sender.getName(), "Adding " + data.getName() + " to the Master Builder list", true);
+                    data.setMasterBuilder(true);
+                    plugin.pl.save(data);
+                    if (player != null)
+                    {
+                        plugin.rm.updateDisplay(player);
+                    }
+                }
+                else
+                {
+                    msg("That player is already on the Master Builder list.");
+                }
+                return true;
+            }
+            case "remove":
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                if (plugin.pl.canManageMasterBuilders(sender.getName()))
+                {
+                    return noPerms();
+                }
+
+                Player player = getPlayer(args[1]);
+                PlayerData data = player != null ? plugin.pl.getData(player) : plugin.pl.getData(args[1]);
+
+                if (data == null || !data.isMasterBuilder())
+                {
+                    msg("Master Builder not found: " + args[1]);
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Removing " + data.getName() + " from the Master Builder list", true);
+                data.setMasterBuilder(false);
+                plugin.pl.save(data);
+                if (player != null)
+                {
+                    plugin.rm.updateDisplay(player);
+                }
+                return true;
+            }
+            default:
+            {
+                return false;
+            }
+        }
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1)
+        {
+            return Arrays.asList("add", "remove", "list", "clearips", "clearip");
+        }
+        else if (args.length == 2)
+        {
+            if (args[0].equalsIgnoreCase("add"))
+            {
+                return FUtil.getPlayerList();
+            }
+            else if (args[0].equalsIgnoreCase("remove"))
+            {
+                return plugin.pl.getMasterBuilderNames();
+            }
+            else if (args[0].equalsIgnoreCase("clearip"))
+            {
+                PlayerData data = plugin.pl.getData(sender.getName());
+                if (data.isMasterBuilder())
+                {
+                    return data.getIps();
+                }
+                return Collections.emptyList();
+            }
+        }
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,71 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.GameRuleHandler;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Control mob limiting 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;
+        }
+
+        switch (args[0].toLowerCase())
+        {
+            case "on" -> ConfigEntry.MOB_LIMITER_ENABLED.setBoolean(true);
+            case "off" -> ConfigEntry.MOB_LIMITER_ENABLED.setBoolean(false);
+            case "dragon" -> ConfigEntry.MOB_LIMITER_DISABLE_DRAGON.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_DRAGON.getBoolean());
+            case "giant" -> ConfigEntry.MOB_LIMITER_DISABLE_GIANT.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_GIANT.getBoolean());
+            case "slime" -> ConfigEntry.MOB_LIMITER_DISABLE_SLIME.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_SLIME.getBoolean());
+            case "ghast" -> ConfigEntry.MOB_LIMITER_DISABLE_GHAST.setBoolean(!ConfigEntry.MOB_LIMITER_DISABLE_GHAST.getBoolean());
+            case "setmax" ->
+            {
+                if (args.length < 2)
+                {
+                    return false;
+                }
+
+                try
+                {
+                    ConfigEntry.MOB_LIMITER_MAX.setInteger(Math.max(0, Math.min(2000, Integer.parseInt(args[1]))));
+                }
+                catch (Exception ex)
+                {
+                    msg("Invalid number: " + args[1], ChatColor.RED);
+                    return true;
+                }
+            }
+            default ->
+            {
+                // Shut the fuck up Codacy!
+            }
+        }
+
+        if (ConfigEntry.MOB_LIMITER_ENABLED.getBoolean())
+        {
+            msg("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;
+    }
+}

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

@@ -0,0 +1,63 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import me.totalfreedom.totalfreedommod.util.Groups;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Purge all mobs in all worlds.", usage = "/<command> [name]", aliases = "mp")
+public class Command_mobpurge extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        EntityType type = null;
+        String mobName = null;
+        if (args.length > 0)
+        {
+            try
+            {
+                type = EntityType.valueOf(args[0].toUpperCase());
+            }
+            catch (Exception e)
+            {
+                msg(args[0] + " is not a valid mob type.", ChatColor.RED);
+                return true;
+            }
+
+            if (!Groups.MOB_TYPES.contains(type))
+            {
+                msg(FUtil.formatName(type.name()) + " is an entity, however it is not a mob.", ChatColor.RED);
+                return true;
+            }
+        }
+
+        if (type != null)
+        {
+            mobName = FUtil.formatName(type.name());
+        }
+
+        FUtil.adminAction(sender.getName(), "Purging all " + (type != null ? mobName + "s" : "mobs"), true);
+        int count = plugin.ew.purgeMobs(type);
+        msg(count + " " + (type != null ? mobName : "mob") + FUtil.showS(count) + " removed.");
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1)
+        {
+            return Groups.MOB_TYPES.stream().map(Enum::name).toList();
+        }
+
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,53 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Objects;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.player.FPlayer;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.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);
+
+            Objects.requireNonNull(playerSender.getEquipment()).setItemInMainHand(new ItemStack(Material.GUNPOWDER, 1));
+        }
+        else
+        {
+            playerdata.disarmMP44();
+
+            msg("mp44 Disarmed.", ChatColor.GREEN);
+        }
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_mute.java

@@ -0,0 +1,154 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.*;
+import me.totalfreedom.totalfreedommod.punishments.Punishment;
+import me.totalfreedom.totalfreedommod.punishments.PunishmentType;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Mutes a player with brute force.", usage = "/<command> <[-s | -q] <player> [reason] | list | purge | all>", aliases = "stfu")
+public class Command_mute extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length == 0)
+        {
+            return false;
+        }
+
+        switch (args[0].toLowerCase())
+        {
+            case "list" ->
+            {
+                msg("Muted players:");
+                List<? extends Player> list = server.getOnlinePlayers().stream().filter(player ->
+                        plugin.pl.getPlayer(player).isMuted()).toList();
+
+                if (list.size() > 0)
+                    list.forEach(player -> msg("- " + player.getName()));
+                else
+                    msg("- none");
+            }
+            case "purge" ->
+            {
+                FUtil.adminAction(sender.getName(), "Unmuting all players", true);
+                List<? extends Player> list = server.getOnlinePlayers().stream().filter(player ->
+                        plugin.pl.getPlayer(player).isMuted()).toList();
+
+                list.forEach(player ->
+                {
+                    plugin.pl.getPlayer(player).setMuted(false);
+                    player.sendTitle(ChatColor.RED + "You have been unmuted.",
+                            ChatColor.YELLOW + "Be sure to follow the rules!", 20, 100, 60);
+                });
+
+                msg("Unmuted " + list.size() + " player" + (list.size() != 1 ? "s" : "") + ".");
+            }
+            case "all" ->
+            {
+                FUtil.adminAction(sender.getName(), "Muting all non-admins", true);
+                List<? extends Player> list = server.getOnlinePlayers().stream().filter(player ->
+                        !plugin.al.isAdmin(player)).toList();
+
+                list.forEach(player ->
+                {
+                    plugin.pl.getPlayer(player).setMuted(true);
+                    player.sendTitle(ChatColor.RED + "You've been muted globally.",
+                            ChatColor.YELLOW + "Please be patient and you will be unmuted shortly.", 20, 100, 60);
+                });
+
+                msg("Muted " + list.size() + " player" + (list.size() != 1 ? "s" : "") + ".");
+            }
+            default ->
+            {
+                boolean quiet = args[0].equalsIgnoreCase("-q");
+                boolean smite = args[0].equalsIgnoreCase("-s");
+
+                // Handling the -q parameter
+                if (quiet || smite)
+                {
+                    if (args.length == 1) return false;
+                    args = ArrayUtils.subarray(args, 1, args.length);
+                }
+
+                // Handling the (optional) reason
+                String reason = args.length > 1 ? StringUtils.join(args, " ", 1, args.length) : null;
+
+                // Showtime
+                Optional.ofNullable(getPlayer(args[0])).ifPresentOrElse(player ->
+                {
+                    if (plugin.al.isAdmin(player))
+                    {
+                        msg(player.getName() + " is an admin, and as such can't be muted.", ChatColor.RED);
+                        return;
+                    }
+                    else if (plugin.pl.getPlayer(player).isMuted())
+                    {
+                        msg(player.getName() + " is already muted.", ChatColor.RED);
+                        return;
+                    }
+
+                    // Don't broadcast the mute if it was quiet
+                    if (!quiet)
+                    {
+                        FUtil.adminAction(sender.getName(), "Muting " + player.getName(), true);
+                    }
+
+                    // Smite the player if we're supposed to
+                    if (smite)
+                    {
+                        Command_smite.smite(sender, player, reason, true, false);
+                    }
+
+                    // Mutes the player
+                    plugin.pl.getPlayer(player).setMuted(true);
+
+                    // Notify the player that they have been muted
+                    player.sendTitle(ChatColor.RED + "You've been muted.",
+                            ChatColor.YELLOW + "Be sure to follow the rules!", 20, 100, 60);
+                    msg(player, "You have been muted by " + ChatColor.YELLOW + sender.getName()
+                            + ChatColor.RED + ".", ChatColor.RED);
+
+                    // Give them the reason if one is present.
+                    if (reason != null)
+                    {
+                        msg(player, "Reason: " + ChatColor.YELLOW + reason, ChatColor.RED);
+                    }
+
+                    msg((quiet ? "Quietly m" : "M") + "uted " + player.getName() + ".");
+                    plugin.pul.logPunishment(new Punishment(player.getName(), FUtil.getIp(player), sender.getName(),
+                            PunishmentType.MUTE, reason));
+                }, () -> msg(PLAYER_NOT_FOUND));
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (!plugin.al.isAdmin(sender))
+        {
+            return null;
+        }
+
+        if (args.length == 1)
+        {
+            List<String> arguments = new ArrayList<>();
+            arguments.addAll(FUtil.getPlayerList());
+            arguments.addAll(Arrays.asList("list", "purge", "all"));
+            return arguments;
+        }
+
+        return Collections.emptyList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_myadmin.java

@@ -0,0 +1,251 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.admin.Admin;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.discord.Discord;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Manage your admin entry.", usage = "/<command> [-o <admin name>] <clearips | clearip <ip> | setscformat <format> | clearscformat> | syncroles>")
+public class Command_myadmin extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 1)
+        {
+            return false;
+        }
+
+        Player init = null;
+        Admin target = getAdmin(playerSender);
+        Player targetPlayer = playerSender;
+
+        // -o switch
+        if (args[0].equals("-o"))
+        {
+            checkRank(Rank.SENIOR_ADMIN);
+            init = playerSender;
+            targetPlayer = getPlayer(args[1]);
+            if (targetPlayer == null)
+            {
+                msg(FreedomCommand.PLAYER_NOT_FOUND);
+                return true;
+            }
+
+            target = getAdmin(targetPlayer);
+            if (target == null)
+            {
+                msg("That player is not an admin", ChatColor.RED);
+                return true;
+            }
+
+            // Shift 2
+            args = Arrays.copyOfRange(args, 2, args.length);
+            if (args.length < 1)
+            {
+                return false;
+            }
+        }
+
+        final String targetIp = FUtil.getIp(targetPlayer);
+
+        switch (args[0])
+        {
+            case "clearips":
+            {
+                if (args.length != 1)
+                {
+                    return false; // Double check: the player might mean "clearip"
+                }
+
+                if (init == null)
+                {
+                    FUtil.adminAction(sender.getName(), "Clearing my IPs", true);
+                }
+                else
+                {
+                    FUtil.adminAction(sender.getName(), "Clearing " + target.getName() + "'s IPs", true);
+                }
+
+                int counter = target.getIps().size() - 1;
+                target.clearIPs();
+                target.addIp(targetIp);
+
+                plugin.al.save(target);
+                plugin.al.updateTables();
+                plugin.pl.syncIps(target);
+
+                msg(counter + " IPs removed.");
+                msg(targetPlayer, target.getIps().get(0) + " is now your only IP address");
+                return true;
+            }
+
+            case "clearip":
+            {
+                if (args.length != 2)
+                {
+                    return false; // Double check: the player might mean "clearips"
+                }
+
+                if (!target.getIps().contains(args[1]))
+                {
+                    if (init == null)
+                    {
+                        msg("That IP is not registered to you.");
+                    }
+                    else
+                    {
+                        msg("That IP does not belong to that player.");
+                    }
+                    return true;
+                }
+
+                if (targetIp.equals(args[1]))
+                {
+                    if (init == null)
+                    {
+                        msg("You cannot remove your current IP.");
+                    }
+                    else
+                    {
+                        msg("You cannot remove that admins current IP.");
+                    }
+                    return true;
+                }
+
+                FUtil.adminAction(sender.getName(), "Removing an IP" + (init == null ? "" : " from " + targetPlayer.getName() + "'s IPs"), true);
+
+                target.removeIp(args[1]);
+                plugin.al.save(target);
+                plugin.al.updateTables();
+
+                plugin.pl.syncIps(target);
+
+                msg("Removed IP " + args[1]);
+                msg("Current IPs: " + StringUtils.join(target.getIps(), ", "));
+                return true;
+            }
+
+            case "setacformat":
+            case "setscformat":
+            {
+                String format = StringUtils.join(args, " ", 1, args.length);
+                target.setAcFormat(format);
+                plugin.al.save(target);
+                plugin.al.updateTables();
+                msg("Set admin chat format to \"" + format + "\".", ChatColor.GRAY);
+                String example = format.replace("%name%", "ExampleAdmin").replace("%rank%", Rank.ADMIN.getAbbr()).replace("%rankcolor%", Rank.ADMIN.getColor().toString()).replace("%msg%", "The quick brown fox jumps over the lazy dog.");
+                msg(ChatColor.GRAY + "Example: " + FUtil.colorize(example));
+                return true;
+            }
+
+            case "clearacformat":
+            case "clearscformat":
+            {
+                target.setAcFormat(null);
+                plugin.al.save(target);
+                plugin.al.updateTables();
+                msg("Cleared admin chat format.", ChatColor.GRAY);
+                return true;
+            }
+
+            case "syncroles":
+            {
+                if (plugin.dc.enabled)
+                {
+                    if (!ConfigEntry.DISCORD_ROLE_SYNC.getBoolean())
+                    {
+                        msg("Role syncing is not enabled.", ChatColor.RED);
+                        return true;
+                    }
+                    PlayerData playerData = plugin.pl.getData(target.getName());
+                    if (playerData.getDiscordID() == null)
+                    {
+                        msg("Please run /linkdiscord first!", ChatColor.RED);
+                        return true;
+                    }
+                    boolean synced = Discord.syncRoles(target, playerData.getDiscordID());
+                    if (synced)
+                    {
+                        msg("Successfully synced your roles.", ChatColor.GREEN);
+                    }
+                    else
+                    {
+                        msg("Failed to sync your roles, please check the console.", ChatColor.RED);
+                    }
+                }
+
+                return true;
+            }
+
+            default:
+            {
+                return false;
+            }
+        }
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (!plugin.al.isAdmin(sender))
+        {
+            return Collections.emptyList();
+        }
+
+        List<String> singleArguments = Arrays.asList("clearips", "setscformat", "setacformat");
+        List<String> doubleArguments = Arrays.asList("clearip", "clearscformat", "clearacformat", "syncroles");
+        if (args.length == 1)
+        {
+            List<String> options = new ArrayList<>();
+            options.add("-o");
+            options.addAll(singleArguments);
+            options.addAll(doubleArguments);
+            return options;
+        }
+        else if (args.length == 2)
+        {
+            if (args[0].equalsIgnoreCase("-o"))
+            {
+                return FUtil.getPlayerList();
+            }
+            else
+            {
+                if (doubleArguments.contains(args[0]) && args[0].equalsIgnoreCase("clearip"))
+                {
+                    List<String> ips = plugin.al.getAdmin(sender).getIps();
+                    ips.remove(FUtil.getIp((Player)sender));
+                    return ips;
+                }
+            }
+        }
+        else if (args.length == 3 && args[0].equalsIgnoreCase("-o"))
+        {
+            List<String> options = new ArrayList<>();
+            options.addAll(singleArguments);
+            options.addAll(doubleArguments);
+            return options;
+        }
+        else if (args.length == 4 && args[0].equalsIgnoreCase("-o") && args[2].equalsIgnoreCase("clearip"))
+        {
+            Admin admin = plugin.al.getEntryByName(args[1]);
+            if (admin != null)
+            {
+                return admin.getIps();
+            }
+        }
+        return FUtil.getPlayerList();
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_myinfo.java

@@ -0,0 +1,18 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Check your personal data", usage = "/<command>")
+public class Command_myinfo extends FreedomCommand
+{
+    @Override
+    public boolean run(final CommandSender sender, final Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        msg(plugin.pl.getData(playerSender).toString());
+        return true;
+    }
+}

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

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

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

@@ -0,0 +1,152 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import me.totalfreedom.totalfreedommod.config.ConfigEntry;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.Color;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Essentials Interface Command - Remove illegal chatcodes from nicknames of one or all players on server.", usage = "/<command> [player]", aliases = "nc")
+public class Command_nickclean extends FreedomCommand
+{
+    private final Map<String, Color> colorCodes = new HashMap<String, Color>()
+    {{
+        put("&0", Color.BLACK);
+        put("&1", Color.BLUE);
+        put("&2", Color.GREEN);
+        put("&3", Color.TEAL);
+        put("&4", Color.MAROON);
+        put("&5", Color.FUCHSIA);
+        put("&6", Color.OLIVE);
+        put("&7", Color.SILVER);
+        put("&8", Color.GRAY);
+        put("&9", Color.NAVY);
+        put("&a", Color.LIME);
+        put("&b", Color.AQUA);
+        put("&c", Color.RED);
+        put("&d", Color.PURPLE);
+        put("&e", Color.YELLOW);
+        put("&f", Color.WHITE);
+    }};
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length > 1)
+        {
+            Player player = getPlayer(args[0]);
+
+            if (player == null)
+            {
+                msg(PLAYER_NOT_FOUND);
+                return true;
+            }
+
+            FUtil.adminAction(sender.getName(), "Cleaning " + player.getName() + "'s nickname", false);
+            cleanNickname(player);
+            return true;
+        }
+
+        FUtil.adminAction(sender.getName(), "Cleaning all nicknames", false);
+        for (final Player player : server.getOnlinePlayers())
+        {
+            cleanNickname(player);
+        }
+        return true;
+    }
+
+    public void cleanNickname(Player player)
+    {
+        final String playerName = player.getName();
+        final String nickName = plugin.esb.getNickname(playerName);
+        StringBuilder newNick = new StringBuilder();
+        boolean nickChanged = false;
+        if (nickName != null)
+        {
+            if (nickName.contains("§x"))
+            {
+                // Detects colors that are similar to blocked codes.
+                spliterator:
+                for (String split : nickName.split("§x"))
+                {
+                    List<Color> colors = new ArrayList<>();
+                    String hexColorSub;
+                    if (split.length() >= 12 && split.contains("§"))
+                    {
+                        hexColorSub = split.substring(0, 12);
+                        split = String.valueOf(split.charAt(12));
+                        String hexColorString = "#" + hexColorSub.replaceAll("§", "");
+                        java.awt.Color hexColor = java.awt.Color.decode(hexColorString);
+
+                        // Get a range of nearby colors that are alike to the color blocked.
+                        Color colorFirst;
+                        Color colorSecond;
+
+                        colorFirst = Color.fromRGB(Math.min(hexColor.getRed() + 20, 255), Math.min(hexColor.getGreen() + 20, 255), Math.min(hexColor.getBlue() + 20, 255));
+                        colorSecond = Color.fromRGB(Math.max(hexColor.getRed() - 20, 0), Math.max(hexColor.getGreen() - 20, 0), Math.max(hexColor.getBlue() - 20, 0));
+                        colors.addAll(FUtil.createColorGradient(colorFirst, colorSecond, 40));
+
+                        colorFirst = Color.fromRGB(Math.min(hexColor.getRed() + 20, 255), Math.min(hexColor.getGreen(), 255), Math.min(hexColor.getBlue(), 255));
+                        colorSecond = Color.fromRGB(Math.max(hexColor.getRed() - 20, 0), Math.max(hexColor.getGreen(), 0), Math.max(hexColor.getBlue(), 0));
+                        colors.addAll(FUtil.createColorGradient(colorFirst, colorSecond, 40));
+
+                        colorFirst = Color.fromRGB(Math.min(hexColor.getRed(), 255), Math.min(hexColor.getGreen() + 20, 255), Math.min(hexColor.getBlue(), 255));
+                        colorSecond = Color.fromRGB(Math.max(hexColor.getRed(), 0), Math.max(hexColor.getGreen() - 20, 0), Math.max(hexColor.getBlue(), 0));
+                        colors.addAll(FUtil.createColorGradient(colorFirst, colorSecond, 40));
+
+                        colorFirst = Color.fromRGB(Math.min(hexColor.getRed(), 255), Math.min(hexColor.getGreen(), 255), Math.min(hexColor.getBlue() + 20, 255));
+                        colorSecond = Color.fromRGB(Math.max(hexColor.getRed(), 0), Math.max(hexColor.getGreen(), 0), Math.max(hexColor.getBlue() - 20, 0));
+                        colors.addAll(FUtil.createColorGradient(colorFirst, colorSecond, 40));
+
+                        for (String colorCode : ConfigEntry.BLOCKED_CHATCODES.getString().split(","))
+                        {
+                            // Makes sure that there's hex colors in the split.
+                            for (Color color : colors)
+                            {
+                                if (colorCodes.get(colorCode) != null && FUtil.colorClose(color, colorCodes.get(colorCode), 40))
+                                {
+                                    nickChanged = true;
+                                    newNick.append(split);
+                                    continue spliterator;
+                                }
+                            }
+
+                        }
+                        newNick.append("§x").append(hexColorSub).append(split);
+                    }
+                }
+            }
+            else
+            {
+                // Falls back on old code if hex isn't used.
+                final Pattern REGEX = Pattern.compile(FUtil.colorize(ChatColor.COLOR_CHAR + "[" + StringUtils.join(ConfigEntry.BLOCKED_CHATCODES.getString().split(","), "") + "]"), Pattern.CASE_INSENSITIVE);
+                if (!nickName.isEmpty() && !nickName.equalsIgnoreCase(playerName))
+                {
+                    final Matcher matcher = REGEX.matcher(nickName);
+                    if (matcher.find())
+                    {
+                        nickChanged = true;
+                        newNick.append(matcher.replaceAll(""));
+                    }
+                }
+            }
+        }
+
+        if (nickChanged)
+        {
+            msg(ChatColor.RESET + playerName + ": \"" + nickName + ChatColor.RESET + "\" -> \"" + newNick.toString() + ChatColor.RESET + "\".");
+        }
+        plugin.esb.setNickname(playerName, newNick.toString());
+    }
+}

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

@@ -0,0 +1,120 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.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
+{
+
+    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 > editDistance)
+            {
+                minEditDistance = editDistance;
+                minEditMatch = player;
+            }
+        }
+
+        return minEditMatch;
+    }
+
+    @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)
+        {
+            for (String arg : args)
+            {
+                Player player = null;
+
+                Matcher matcher = Pattern.compile("^!(.+)$").matcher(arg);
+                if (matcher.find())
+                {
+                    String displayName = matcher.group(1);
+
+                    player = getPlayerByDisplayName(displayName);
+
+                    if (player == null || plugin.al.isVanished(player.getUniqueId()) && !plugin.al.isAdmin(sender))
+                    {
+                        player = getPlayerByDisplayNameAlt(displayName);
+
+                        if (player == null || !plugin.al.isVanished(player.getUniqueId()) && !plugin.al.isAdmin(sender))
+                        {
+                            msg("Can't find player by nickname: " + displayName);
+                            return true;
+                        }
+                    }
+                }
+
+                if (player == null)
+                {
+                    outputCommand.add(arg);
+                }
+                else
+                {
+                    nickMatched = true;
+                    outputCommand.add(player.getName());
+                }
+            }
+        }
+
+        if (!nickMatched)
+        {
+            msg("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;
+        }
+
+        msg("Sending command: \"" + newCommand + "\".");
+        server.dispatchCommand(sender, newCommand);
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_nickgradient.java

@@ -0,0 +1,99 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Color;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Essentials Interface Command - Rainbowify your nickname.", usage = "/<command> <hex> <hex> <nick>", aliases = "nickgr")
+public class Command_nickgradient extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!server.getPluginManager().isPluginEnabled("Essentials"))
+        {
+            msg("Essentials is not enabled on this server.");
+            return true;
+        }
+
+        if (args.length != 3)
+        {
+            return false;
+        }
+
+        String nick = args[2].trim();
+
+        if (nick.length() < 3 || nick.length() > 30)
+        {
+            msg("Your nickname must be between 3 and 30 characters long.");
+            return true;
+        }
+
+        for (Player player : Bukkit.getOnlinePlayers())
+        {
+            if (player == playerSender)
+            {
+                continue;
+            }
+            if (player.getName().equalsIgnoreCase(nick) || ChatColor.stripColor(player.getDisplayName()).trim().equalsIgnoreCase(nick))
+            {
+                msg("That nickname is already in use.");
+                return true;
+            }
+        }
+
+        String from = "", to = "";
+        java.awt.Color awt1, awt2;
+        try
+        {
+            if (args[0].equalsIgnoreCase("random") ||
+                    args[0].equalsIgnoreCase("r"))
+            {
+                awt1 = FUtil.getRandomAWTColor();
+                from = " (From: " + FUtil.getHexStringOfAWTColor(awt1) + ")";
+            }
+            else
+            {
+                awt1 = java.awt.Color.decode(args[0]);
+            }
+            if (args[1].equalsIgnoreCase("random") ||
+                    args[1].equalsIgnoreCase("r"))
+            {
+                awt2 = FUtil.getRandomAWTColor();
+                to = " (To: " + FUtil.getHexStringOfAWTColor(awt2) + ")";
+            }
+            else
+            {
+                awt2 = java.awt.Color.decode(args[1]);
+            }
+        }
+        catch (NumberFormatException ex)
+        {
+            msg("Invalid hex values.");
+            return true;
+        }
+        Color c1 = FUtil.fromAWT(awt1);
+        Color c2 = FUtil.fromAWT(awt2);
+        List<Color> gradient = FUtil.createColorGradient(c1, c2, nick.length());
+        String[] splitNick = nick.split("");
+        for (int i = 0; i < splitNick.length; i++)
+        {
+            splitNick[i] = net.md_5.bungee.api.ChatColor.of(FUtil.toAWT(gradient.get(i))) + splitNick[i];
+        }
+        nick = StringUtils.join(splitNick, "");
+        final String outputNick = FUtil.colorize(nick);
+
+        plugin.esb.setNickname(sender.getName(), outputNick);
+
+        msg("Your nickname is now: '" + outputNick + ChatColor.GRAY + "'" + from + to);
+        return true;
+    }
+}

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

@@ -0,0 +1,69 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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;
+import java.util.Arrays;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Essentials Interface Command - Randomize the colors of 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 (!server.getPluginManager().isPluginEnabled("Essentials"))
+        {
+            msg("Essentials is not enabled on this server.");
+            return true;
+        }
+
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        if (args[0].equalsIgnoreCase("off"))
+        {
+            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() < 3 || nickPlain.length() > 30)
+        {
+            msg("Your nickname must be between 3 and 30 characters long.");
+            return true;
+        }
+
+
+        if (server.getOnlinePlayers().stream().anyMatch(player -> player != playerSender
+                && (player.getName().equalsIgnoreCase(nickPlain)
+                || ChatColor.stripColor(plugin.esb.getNickname(player.getName())).trim().equalsIgnoreCase(nickPlain))))
+        {
+            msg("That nickname is already in use.");
+            return true;
+        }
+
+        final StringBuilder newNick = new StringBuilder();
+        Arrays.stream(nickPlain.chars().toArray()).forEach(character -> newNick.append(FUtil.randomChatColor())
+                .append(Character.toString(character)));
+
+        newNick.append(ChatColor.WHITE);
+
+        plugin.esb.setNickname(sender.getName(), newNick.toString());
+
+        msg("Your nickname is now: " + newNick);
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_nickrainbow.java

@@ -0,0 +1,64 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "Essentials Interface Command - Rainbowify your nickname.", usage = "/<command> <nick>")
+public class Command_nickrainbow extends FreedomCommand
+{
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (!server.getPluginManager().isPluginEnabled("Essentials"))
+        {
+            msg("Essentials is not enabled on this server.");
+            return true;
+        }
+
+        if (args.length != 1)
+        {
+            return false;
+        }
+
+        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;
+        }
+
+        if (nickPlain.length() < 3 || nickPlain.length() > 30)
+        {
+            msg("Your nickname must be between 3 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 String newNick = FUtil.rainbowify(ChatColor.stripColor(FUtil.colorize(nickPlain)));
+
+        plugin.esb.setNickname(sender.getName(), newNick);
+
+        msg("Your nickname is now: " + newNick);
+
+        return true;
+    }
+}

commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_notes.java

@@ -0,0 +1,144 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.player.PlayerData;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+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(rank = Rank.ADMIN, source = SourceType.BOTH)
+@CommandParameters(description = "Manage notes for a player", usage = "/<command> <name> <list | add <note> | remove <id> | clear>")
+public class Command_notes extends FreedomCommand
+{
+
+    @Override
+    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
+    {
+        if (args.length < 2)
+        {
+            return false;
+        }
+
+        PlayerData playerData;
+
+        final Player player = getPlayer(args[0]);
+        if (player == null)
+        {
+            final PlayerData entry = plugin.pl.getData(args[0]);
+
+            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;
+            }
+
+            playerData = plugin.pl.getData(entry.getName());
+        }
+        else
+        {
+            playerData = plugin.pl.getData(player);
+        }
+
+        switch (args[1])
+        {
+            case "list":
+            {
+                final StringBuilder noteList = new StringBuilder();
+                noteList.append(ChatColor.GREEN).append("Player notes for ").append(playerData.getName()).append(":");
+                int id = 1;
+                for (String note : playerData.getNotes())
+                {
+                    String noteLine = id + ". " + note;
+                    noteList.append("\n").append(ChatColor.GOLD).append(noteLine);
+                    id++;
+                }
+                msg(noteList.toString());
+                return true;
+            }
+
+            case "add":
+            {
+                if (args.length < 3)
+                {
+                    return false;
+                }
+                String note = sender.getName() + ": " + StringUtils.join(ArrayUtils.subarray(args, 2, args.length), " ");
+                playerData.addNote(note);
+                plugin.pl.save(playerData);
+                msg("Note added.", ChatColor.GREEN);
+                return true;
+            }
+
+            case "remove":
+            {
+                if (args.length < 3)
+                {
+                    return false;
+                }
+
+                int id;
+                try
+                {
+                    id = Integer.parseInt(args[2]);
+                }
+                catch (NumberFormatException e)
+                {
+                    msg("Invalid number: " + args[2], ChatColor.RED);
+                    return true;
+                }
+
+                id--;
+
+                if (playerData.removeNote(id))
+                {
+                    plugin.pl.save(playerData);
+                    msg("Note removed.");
+                }
+                else
+                {
+                    msg("No note with the ID of " + args[2] + " exists.", ChatColor.RED);
+                }
+                return true;
+            }
+
+            case "clear":
+            {
+                int count = playerData.getNotes().size();
+                playerData.clearNotes();
+                plugin.pl.save(playerData);
+                msg("Cleared " + count + " notes.", ChatColor.GREEN);
+                return true;
+            }
+
+            default:
+            {
+                return false;
+            }
+        }
+    }
+
+    @Override
+    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
+    {
+        if (args.length == 1)
+        {
+            return FUtil.getPlayerList();
+        }
+        else if (args.length == 2)
+        {
+            return Arrays.asList("list", "add", "remove", "clear");
+        }
+        else if (args.length > 2 && (args[1].equals("add")))
+        {
+            return FUtil.getPlayerList();
+        }
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,61 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.ArrayList;
+import java.util.List;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH, cooldown = 5)
+@CommandParameters(description = "OP a player", usage = "/<command> <partialname>")
+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;
+        }
+
+        boolean silent = false;
+        if (args.length == 2)
+        {
+            silent = args[1].equalsIgnoreCase("-s");
+        }
+
+        final String targetName = args[0].toLowerCase();
+
+        List<String> matchedPlayerNames = new ArrayList<>();
+        for (final Player player : server.getOnlinePlayers())
+        {
+            if ((player.getName().toLowerCase().contains(targetName) || player.getDisplayName().toLowerCase().contains(targetName)
+                    || player.getName().contains(targetName) || player.getDisplayName().contains(targetName)) &&
+                    !player.isOp() && !plugin.al.isVanished(player.getUniqueId()))
+            {
+                matchedPlayerNames.add(player.getName());
+                player.setOp(true);
+                msg(player, YOU_ARE_OP);
+                plugin.rm.updateDisplay(player);
+            }
+        }
+
+        if (!matchedPlayerNames.isEmpty())
+        {
+            if (!silent)
+            {
+                FUtil.adminAction(sender.getName(), "Opping " + StringUtils.join(matchedPlayerNames, ", "), false);
+            }
+        }
+        else
+        {
+            msg("Either the player is already opped, or the player could not be found.");
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,34 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.OP, source = SourceType.BOTH, cooldown = 30)
+@CommandParameters(description = "OP everyone on the server.", usage = "/<command>")
+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);
+
+        server.getOnlinePlayers().forEach(player ->
+        {
+            if (!player.isOp())
+            {
+                player.setOp(true);
+                msg(player, YOU_ARE_OP);
+                plugin.rm.updateDisplay(player);
+            }
+            else
+            {
+                player.recalculatePermissions();
+            }
+        });
+
+        return true;
+    }
+}

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

@@ -0,0 +1,23 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import me.totalfreedom.totalfreedommod.rank.Rank;
+import me.totalfreedom.totalfreedommod.util.FUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@CommandPermissions(rank = Rank.NON_OP, source = SourceType.ONLY_IN_GAME)
+@CommandParameters(description = "OPs the command sender.", 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);
+        msg(YOU_ARE_OP);
+        plugin.rm.updateDisplay(playerSender);
+        return true;
+    }
+}

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

@@ -0,0 +1,65 @@
+package me.totalfreedom.totalfreedommod.command;
+
+import java.util.Objects;
+import me.totalfreedom.totalfreedommod.rank.Rank;
+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(rank = Rank.OP, source = SourceType.BOTH)
+@CommandParameters(description = "Manage 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].equalsIgnoreCase("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].equalsIgnoreCase("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(Objects.requireNonNull(player.getPlayer()), FreedomCommand.YOU_ARE_NOT_OP);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+}