Plex 0.9

Use Google's reflection library to register commands

build.gradle

@@ -38,7 +38,7 @@ dependencies {
 }
 
 group = "dev.plex"
-version = "0.8"
+version = "0.9"
 description = "Plex"
 
 shadowJar {

src/main/java/dev/plex/Plex.java

@@ -23,18 +23,18 @@ import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.UpdateChecker;
 import dev.plex.world.CustomWorld;
+import java.io.File;
+import java.util.UUID;
 import lombok.Getter;
 import lombok.Setter;
 import org.bstats.bukkit.Metrics;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.io.File;
-import java.util.UUID;
-
 @Getter
 @Setter
-public class Plex extends JavaPlugin {
+public class Plex extends JavaPlugin
+{
     private static Plex plugin;
     public Config config;
     public Config messages;
@@ -63,19 +63,24 @@ public class Plex extends JavaPlugin {
 
     private String system;
 
-    public static Plex get() {
+    public static Plex get()
+    {
         return plugin;
     }
 
     @Override
-    public void onLoad() {
+    public void onLoad()
+    {
         plugin = this;
         config = new Config(this, "config.yml");
         messages = new Config(this, "messages.yml");
         indefBans = new Config(this, "indefbans.yml");
 
         modulesFolder = new File(this.getDataFolder() + File.separator + "modules");
-        if (!modulesFolder.exists()) modulesFolder.mkdir();
+        if (!modulesFolder.exists())
+        {
+            modulesFolder.mkdir();
+        }
 
         sqlConnection = new SQLConnection();
         mongoConnection = new MongoConnection();
@@ -87,19 +92,24 @@ public class Plex extends JavaPlugin {
     }
 
     @Override
-    public void onEnable() {
+    public void onEnable()
+    {
         config.load();
         messages.load();
+        // Don't add default entries to indefinite ban file
         indefBans.load(false);
 
         moduleManager.enableModules();
 
         system = config.getString("commands.permissions");
 
-        try {
+        try
+        {
             PlexUtils.testConnections();
             PlexLog.log("Connected to " + storageType.name().toUpperCase());
-        } catch (Exception e) {
+        }
+        catch (Exception e)
+        {
             PlexLog.error("Failed to connect to " + storageType.name().toUpperCase());
             e.printStackTrace();
         }
@@ -111,16 +121,22 @@ public class Plex extends JavaPlugin {
         Metrics metrics = new Metrics(this, 14143);
         PlexLog.log("Enabled Metrics");
 
-        if (redisConnection.isEnabled()) {
+        if (redisConnection.isEnabled())
+        {
             redisConnection.getJedis();
             PlexLog.log("Connected to Redis!");
-        } else {
+        }
+        else
+        {
             PlexLog.log("Redis is disabled in the configuration file, not connecting.");
         }
 
-        if (storageType == StorageType.MONGODB) {
+        if (storageType == StorageType.MONGODB)
+        {
             mongoPlayerData = new MongoPlayerData();
-        } else {
+        }
+        else
+        {
             sqlPlayerData = new SQLPlayerData();
         }
 
@@ -148,24 +164,28 @@ public class Plex extends JavaPlugin {
     }
 
     @Override
-    public void onDisable() {
+    public void onDisable()
+    {
         Bukkit.getOnlinePlayers().forEach(player ->
         {
             PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object
 
-            if (plugin.getRankManager().isAdmin(plexPlayer)) {
+            if (plugin.getRankManager().isAdmin(plexPlayer))
+            {
                 plugin.getAdminList().removeFromCache(UUID.fromString(plexPlayer.getUuid()));
             }
 
             if (mongoPlayerData != null) //back to mongo checking
             {
                 mongoPlayerData.update(plexPlayer); //update the player's document
-            } else if (sqlPlayerData != null) //sql checking
+            }
+            else if (sqlPlayerData != null) //sql checking
             {
                 sqlPlayerData.update(plexPlayer);
             }
         });
-        if (redisConnection.isEnabled() && redisConnection.getJedis().isConnected()) {
+        if (redisConnection.isEnabled() && redisConnection.getJedis().isConnected())
+        {
             PlexLog.log("Disabling Redis/Jedis. No memory leaks in this Anarchy server!");
             redisConnection.getJedis().close();
         }
@@ -173,21 +193,25 @@ public class Plex extends JavaPlugin {
         moduleManager.disableModules();
     }
 
-    private void generateWorlds() {
+    private void generateWorlds()
+    {
         PlexLog.log("Generating any worlds if needed...");
-        for (String key : config.getConfigurationSection("worlds").getKeys(false)) {
+        for (String key : config.getConfigurationSection("worlds").getKeys(false))
+        {
             CustomWorld.generateConfigFlatWorld(key);
         }
         PlexLog.log("Finished with world generation!");
     }
 
-    private void reloadPlayers() {
+    private void reloadPlayers()
+    {
         Bukkit.getOnlinePlayers().forEach(player ->
         {
             PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
             PlayerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
             PlayerCache.getPunishedPlayerMap().put(player.getUniqueId(), new PunishedPlayer(player.getUniqueId()));
-            if (plugin.getRankManager().isAdmin(plexPlayer)) {
+            if (plugin.getRankManager().isAdmin(plexPlayer))
+            {
                 Admin admin = new Admin(UUID.fromString(plexPlayer.getUuid()));
                 admin.setRank(plexPlayer.getRankFromString());
 

src/main/java/dev/plex/admin/AdminList.java

@@ -4,7 +4,6 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import dev.morphia.Datastore;
 import dev.morphia.query.Query;
-import dev.plex.Plex;
 import dev.plex.PlexBase;
 import dev.plex.player.PlexPlayer;
 import dev.plex.rank.enums.Rank;

src/main/java/dev/plex/command/PlexCommand.java

@@ -19,6 +19,7 @@ import java.util.Arrays;
 import java.util.UUID;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
@@ -90,9 +91,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      * Executes the command
      *
      * @param sender       The sender of the command
-     * @param playerSender The player who executed the command (null if command source is console or if command source is any but console executed)
+     * @param playerSender The player who executed the command (null if CommandSource is console or if CommandSource is any but console executed)
      * @param args         A Kyori Component to send to the sender (can be null)
-     * @return
      */
     protected abstract Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args);
 
@@ -165,9 +165,9 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     }
 
     /**
-     * Checks if the string given is a command string
+     * Checks if the String given is a matching command
      *
-     * @param label The string to check
+     * @param label The String to check
      * @return true if the string is a command name or alias
      */
     private boolean matches(String label)
@@ -202,9 +202,9 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     }
 
     /**
-     * Sends a message to an audience
+     * Sends a message to an Audience
      *
-     * @param audience The audience to send the message to
+     * @param audience The Audience to send the message to
      * @param s        The message to send
      */
     protected void send(Audience audience, String s)
@@ -213,10 +213,10 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     }
 
     /**
-     * Sends a message to an audience
+     * Sends a message to an Audience
      *
-     * @param audience  The audience to send the message to
+     * @param audience  The Audience to send the message to
-     * @param component The component to send
+     * @param component The Component to send
      */
     protected void send(Audience audience, Component component)
     {
@@ -226,7 +226,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     /**
      * Checks whether a sender has enough permissions or is high enough a rank
      *
-     * @param sender     A command sender
+     * @param sender     A CommandSender
      * @param rank       The rank to check (if the server is using ranks)
      * @param permission The permission to check (if the server is using permissions)
      * @return true if the sender has enough permissions
@@ -415,7 +415,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      *
      * @param s       The message entry
      * @param objects Any objects to replace in order
-     * @return A Kyori component
+     * @return A Kyori Component
      */
     protected Component messageComponent(String s, Object... objects)
     {
@@ -435,25 +435,25 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     }
 
     /**
-     * Converts usage to a component
+     * Converts usage to a Component
      *
-     * @return A Kyori component stating the usage
+     * @return A Kyori Component stating the usage
      */
     protected Component usage()
     {
-        return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + this.getUsage());
+        return Component.text("Correct Usage: ").color(NamedTextColor.YELLOW).append(componentFromString(this.getUsage()).color(NamedTextColor.GRAY));
     }
 
     /**
-     * Converts usage to a component
+     * Converts usage to a Component
      * <p>
      * s The usage to convert
      *
-     * @return A Kyori component stating the usage
+     * @return A Kyori Component stating the usage
      */
     protected Component usage(String s)
     {
-        return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + s);
+        return Component.text("Correct Usage: ").color(NamedTextColor.YELLOW).append(componentFromString(s).color(NamedTextColor.GRAY));
     }
 
     protected Player getNonNullPlayer(String name)
@@ -498,21 +498,26 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     }
 
     /**
-     * Converts a string to a legacy Kyori component
+     * Converts a String to a legacy Kyori Component
      *
-     * @param s The string to convert
+     * @param s The String to convert
      * @return A Kyori component
      */
     protected Component componentFromString(String s)
+    {
+        return LegacyComponentSerializer.legacyAmpersand().deserialize(s).colorIfAbsent(NamedTextColor.GRAY);
+    }
+
+    protected Component noColorComponentFromString(String s)
     {
         return LegacyComponentSerializer.legacyAmpersand().deserialize(s);
     }
 
     /**
-     * Converts a string to a mini message kyori component
+     * Converts a String to a MiniMessage Component
      *
-     * @param s The string to convert
+     * @param s The String to convert
-     * @return A Kyori component
+     * @return A Kyori Component
      */
     protected Component mmString(String s)
     {

src/main/java/dev/plex/command/annotation/System.java

@@ -0,0 +1,8 @@
+package dev.plex.command.annotation;
+
+public @interface System
+{
+    String value() default "";
+
+    boolean debug() default false;
+}

src/main/java/dev/plex/command/impl/AdminCMD.java

@@ -5,6 +5,7 @@ import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.command.exception.ConsoleOnlyException;
 import dev.plex.command.exception.PlayerNotFoundException;
 import dev.plex.command.source.RequiredCommandSource;
@@ -27,6 +28,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandPermissions(level = Rank.OP, source = RequiredCommandSource.ANY)
 @CommandParameters(name = "admin", usage = "/<command> <add <player> | remove <player> | setrank <player> <rank> | list>", aliases = "saconfig,slconfig,adminconfig,adminmanage", description = "Manage all admins")
+@System("ranks")
 public class AdminCMD extends PlexCommand
 {
     //TODO: Better return messages

src/main/java/dev/plex/command/impl/AdminChatCMD.java

@@ -1,13 +1,16 @@
 package dev.plex.command.impl;
 
+import dev.plex.cache.PlayerCache;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.listener.impl.ChatListener;
+import dev.plex.player.PlexPlayer;
 import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -25,7 +28,30 @@ public class AdminChatCMD extends PlexCommand
             return usage();
         }
 
-        ChatListener.adminChat(sender, StringUtils.join(args, " "));
+        adminChat(sender, StringUtils.join(args, " "));
         return null;
     }
+
+    private void adminChat(CommandSender sender, String message)
+    {
+        for (Player player : Bukkit.getOnlinePlayers())
+        {
+            if (plugin.getSystem().equalsIgnoreCase("ranks"))
+            {
+                PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
+                if (plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN))
+                {
+                    player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
+                }
+            }
+            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
+            {
+                if (player.hasPermission("plex.adminchat"))
+                {
+                    player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
+                }
+            }
+        }
+        plugin.getServer().getConsoleSender().sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
+    }
 }

src/main/java/dev/plex/command/impl/DebugCMD.java

@@ -4,6 +4,7 @@ import com.google.common.collect.ImmutableList;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
@@ -17,8 +18,9 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandParameters(name = "debug", description = "Debug command", usage = "/<command> <redis-reset | gamerules> [player]")
+@CommandParameters(name = "pdebug", description = "Plex's debug command", usage = "/<command> <redis-reset <player> | gamerules>")
 @CommandPermissions(level = Rank.EXECUTIVE, permission = "plex.debug")
+@System(debug = true)
 public class DebugCMD extends PlexCommand
 {
     @Override

src/main/java/dev/plex/command/impl/DeopAllCMD.java

@@ -3,6 +3,7 @@ package dev.plex.command.impl;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
@@ -14,6 +15,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandParameters(name = "deopall", description = "Deop everyone on the server", aliases = "deopa")
 @CommandPermissions(level = Rank.ADMIN)
+@System("ranks")
 public class DeopAllCMD extends PlexCommand
 {
     @Override

src/main/java/dev/plex/command/impl/DeopCMD.java

@@ -4,6 +4,7 @@ import com.google.common.collect.ImmutableList;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.util.List;
@@ -15,6 +16,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandParameters(name = "deop", description = "Deop a player on the server", usage = "/<command> <player>")
 @CommandPermissions(level = Rank.ADMIN, permission = "plex.deop")
+@System("ranks")
 public class DeopCMD extends PlexCommand
 {
     @Override

src/main/java/dev/plex/command/impl/ListCMD.java

@@ -4,11 +4,11 @@ import com.google.common.collect.Lists;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
 import java.util.List;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -17,13 +17,15 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandParameters(name = "list", description = "Show a list of all online players")
 @CommandPermissions(level = Rank.OP, permission = "plex.list")
+@System("ranks")
 public class ListCMD extends PlexCommand
 {
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
     {
         List<Player> players = Lists.newArrayList(Bukkit.getOnlinePlayers());
-        Component component = Component.text("There " + (players.size() == 1 ? "is" : "are") + " currently").color(NamedTextColor.GRAY)
+        Component list = Component.empty();
+        Component header = Component.text("There " + (players.size() == 1 ? "is" : "are") + " currently").color(NamedTextColor.GRAY)
                 .append(Component.space())
                 .append(Component.text(players.size()).color(NamedTextColor.YELLOW))
                 .append(Component.space())
@@ -33,18 +35,17 @@ public class ListCMD extends PlexCommand
                 .append(Component.space())
                 .append(Component.text(Bukkit.getMaxPlayers()).color(NamedTextColor.YELLOW))
                 .append(Component.space())
-                .append(Component.text(Bukkit.getMaxPlayers() == 1 ? "player." : "players.").color(NamedTextColor.GRAY))
+                .append(Component.text(Bukkit.getMaxPlayers() == 1 ? "player." : "players.").color(NamedTextColor.GRAY));
-                .append(Component.newline());
+        send(sender, header);
         for (int i = 0; i < players.size(); i++)
         {
             Player player = players.get(i);
-            component = component.append(LegacyComponentSerializer.legacyAmpersand().deserialize(getPlexPlayer(player).getRankFromString().getPrefix())).append(Component.space()).append(Component.text(player.getName()).color(NamedTextColor.WHITE));
+            list = list.append(getPlexPlayer(player).getRankFromString().getPrefix()).append(Component.space()).append(Component.text(player.getName()).color(NamedTextColor.WHITE));
             if (i != players.size() - 1)
             {
-                component = component.append(Component.text(",")).append(Component.space());
+                list = list.append(Component.text(",")).append(Component.space());
             }
         }
-
+        return list;
-        return component;
     }
 }

src/main/java/dev/plex/command/impl/LockupCMD.java

@@ -7,20 +7,15 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
 import dev.plex.player.PunishedPlayer;
-import dev.plex.punishment.Punishment;
-import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
+import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.UUID;
-
 @CommandParameters(name = "lockup", description = "Lockup a player on the server", usage = "/<command> <player>")
 @CommandPermissions(level = Rank.ADMIN, permission = "plex.lockup")
 public class LockupCMD extends PlexCommand

src/main/java/dev/plex/command/impl/NameHistoryCMD.java

@@ -15,7 +15,6 @@ import java.util.Arrays;
 import java.util.List;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.format.TextDecoration;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;

src/main/java/dev/plex/command/impl/OpAllCMD.java

@@ -3,6 +3,7 @@ package dev.plex.command.impl;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
@@ -14,6 +15,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandParameters(name = "opall", description = "Op everyone on the server", aliases = "opa")
 @CommandPermissions(level = Rank.ADMIN)
+@System("ranks")
 public class OpAllCMD extends PlexCommand
 {
     @Override
@@ -26,5 +28,4 @@ public class OpAllCMD extends PlexCommand
         PlexUtils.broadcast(messageComponent("oppedAllPlayers", sender.getName()));
         return null;
     }
-
 }

src/main/java/dev/plex/command/impl/OpCMD.java

@@ -4,6 +4,7 @@ import com.google.common.collect.ImmutableList;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.util.List;
@@ -15,6 +16,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandParameters(name = "op", description = "Op a player on the server", usage = "/<command> <player>")
 @CommandPermissions(level = Rank.OP)
+@System("ranks")
 public class OpCMD extends PlexCommand
 {
     @Override

src/main/java/dev/plex/command/impl/PlexCMD.java

@@ -1,6 +1,5 @@
 package dev.plex.command.impl;
 
-import com.google.common.collect.ImmutableList;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -9,30 +8,35 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.module.PlexModule;
 import dev.plex.module.PlexModuleFile;
 import dev.plex.rank.enums.Rank;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.apache.commons.lang.StringUtils;
-import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-import java.util.stream.Collectors;
-
 @CommandPermissions(level = Rank.OP, permission = "plex.plex", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "plex", usage = "/<command> [reload | redis | modules] [reload]", aliases = "plexhelp", description = "Show information about Plex or reload it")
+@CommandParameters(name = "plex", usage = "/<command> [reload | redis | modules [reload]]", description = "Show information about Plex or reload it")
-public class PlexCMD extends PlexCommand {
+public class PlexCMD extends PlexCommand
+{
     // Don't modify this command
     @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args) {
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-        if (args.length == 0) {
+    {
-            send(sender, ChatColor.LIGHT_PURPLE + "Plex - A new freedom plugin.");
+        if (args.length == 0)
-            send(sender, ChatColor.LIGHT_PURPLE + "Plugin version: " + plugin.getDescription().getVersion());
+        {
-            return componentFromString(ChatColor.LIGHT_PURPLE + "Authors: " + ChatColor.GOLD + "Telesphoreo, Taahh");
+            send(sender, mmString("<light_purple>Plex - A new freedom plugin."));
+            send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion()));
+            send(sender, mmString("<light_purple>Authors: <gold>Telesphoreo, Taahh"));
+            send(sender, mmString("<light_purple>Run <gold>/plex modules <light_purple>to see a list of modules."));
+            return null;
         }
-        if (args[0].equalsIgnoreCase("reload")) {
+        if (args[0].equalsIgnoreCase("reload"))
+        {
             checkRank(sender, Rank.SENIOR_ADMIN, "plex.reload");
             plugin.config.load();
             send(sender, "Reloaded config file");
@@ -44,34 +48,55 @@ public class PlexCMD extends PlexCommand {
             plugin.getRankManager().importDefaultRanks();
             send(sender, "Imported ranks");
             send(sender, "Plex successfully reloaded.");
-        } else if (args[0].equalsIgnoreCase("redis")) {
+            return null;
+        }
+        else if (args[0].equalsIgnoreCase("redis"))
+        {
             checkRank(sender, Rank.SENIOR_ADMIN, "plex.redis");
-            if (!plugin.getRedisConnection().isEnabled()) {
+            if (!plugin.getRedisConnection().isEnabled())
+            {
                 throw new CommandFailException("&cRedis is not enabled.");
             }
             plugin.getRedisConnection().getJedis().set("test", "123");
             send(sender, "Set test to 123. Now outputting key test...");
             send(sender, plugin.getRedisConnection().getJedis().get("test"));
             plugin.getRedisConnection().getJedis().close();
+            return null;
         }
-        if (args[0].equalsIgnoreCase("modules")) {
+        else if (args[0].equalsIgnoreCase("modules"))
-            if (args.length == 1) {
+        {
-                return MiniMessage.miniMessage().deserialize("<gold>Modules (" + plugin.getModuleManager().getModules().size() + "): <yellow>" + StringUtils.join(plugin.getModuleManager().getModules().stream().map(PlexModule::getPlexModuleFile).map(PlexModuleFile::getName).collect(Collectors.toList()), ", "));
+            if (args.length == 1)
+            {
+                return mmString("<gold>Modules (" + plugin.getModuleManager().getModules().size() + "): <yellow>" + StringUtils.join(plugin.getModuleManager().getModules().stream().map(PlexModule::getPlexModuleFile).map(PlexModuleFile::getName).collect(Collectors.toList()), ", "));
             }
-            if (args[1].equalsIgnoreCase("reload")) {
+            if (args[1].equalsIgnoreCase("reload"))
+            {
+                checkRank(sender, Rank.SENIOR_ADMIN, "plex.modules.reload");
                 plugin.getModuleManager().unloadModules();
                 plugin.getModuleManager().loadAllModules();
                 plugin.getModuleManager().loadModules();
                 plugin.getModuleManager().enableModules();
+                return componentFromString("All modules reloaded!");
             }
-        } else {
+        }
+        else
+        {
             return usage();
         }
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException {
+    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-        return ImmutableList.of("reload", "redis");
+    {
+        if (args.length == 1)
+        {
+            return Arrays.asList("reload", "redis", "modules");
+        }
+        else if (args[0].equalsIgnoreCase("modules"))
+        {
+            return List.of("reload");
+        }
+        return Collections.emptyList();
     }
 }

src/main/java/dev/plex/command/impl/PunishmentsCMD.java

@@ -22,7 +22,7 @@ public class PunishmentsCMD extends PlexCommand
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
     {
-        new PunishmentMenu().openInv(((Player)sender), 0);
+        new PunishmentMenu().openInv(playerSender, 0);
         return null;
     }
 

src/main/java/dev/plex/command/impl/RankCMD.java

@@ -3,6 +3,8 @@ package dev.plex.command.impl;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.annotation.System;
+import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.rank.enums.Rank;
 import net.kyori.adventure.text.Component;
@@ -11,8 +13,9 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.rank", source = RequiredCommandSource.IN_GAME)
+@CommandPermissions(level = Rank.OP, permission = "plex.rank", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "rank", description = "Displays your rank")
+@System("ranks")
 public class RankCMD extends PlexCommand
 {
     @Override
@@ -20,6 +23,10 @@ public class RankCMD extends PlexCommand
     {
         if (args.length == 0)
         {
+            if (isConsole(sender))
+            {
+                throw new CommandFailException("<red>When using the console, you must specify a player's rank.");
+            }
             if (!(playerSender == null))
             {
                 Rank rank = getPlexPlayer(playerSender).getRankFromString();

src/main/java/dev/plex/command/impl/TagCMD.java

@@ -19,7 +19,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @CommandPermissions(level = Rank.OP, permission = "plex.tag", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "tag", aliases = "prefix", description = "Manages your prefix", usage = "/<command> <set | clear> <prefix | player>")
+@CommandParameters(name = "tag", aliases = "prefix", description = "Set or clear your prefix", usage = "/<command> <set <prefix> | clear <player>>")
 public class TagCMD extends PlexCommand
 {
     @Override
@@ -47,8 +47,7 @@ public class TagCMD extends PlexCommand
                 return usage("/tag set <prefix>");
             }
             String prefix = StringUtils.join(args, " ", 1, args.length);
-
+            Component convertedComponent = removeEvents(noColorComponentFromString(prefix));
-            Component convertedComponent = removeEvents(componentFromString(prefix));
             convertedComponent = removeEvents(MiniMessage.miniMessage().deserialize(LegacyComponentSerializer.legacySection().serialize(convertedComponent)));
 
             if (PlainTextComponentSerializer.plainText().serialize(convertedComponent).length() > plugin.config.getInt("chat.max-tag-length", 16))

src/main/java/dev/plex/config/Config.java

@@ -2,16 +2,16 @@ package dev.plex.config;
 
 import dev.plex.Plex;
 import dev.plex.util.PlexLog;
-import org.bukkit.configuration.file.YamlConfiguration;
-
 import java.io.File;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
+import org.bukkit.configuration.file.YamlConfiguration;
 
 /**
  * Creates a custom Config object
  */
-public class Config extends YamlConfiguration {
+public class Config extends YamlConfiguration
+{
     /**
      * The plugin instance
      */
@@ -38,12 +38,14 @@ public class Config extends YamlConfiguration {
      * @param plugin The plugin instance
      * @param name   The file name
      */
-    public Config(Plex plugin, String name) {
+    public Config(Plex plugin, String name)
+    {
         this.plugin = plugin;
         this.file = new File(plugin.getDataFolder(), name);
         this.name = name;
 
-        if (!file.exists()) {
+        if (!file.exists())
+        {
             saveDefault();
         }
     }
@@ -56,17 +58,22 @@ public class Config extends YamlConfiguration {
     /**
      * Loads the configuration file
      */
-    public void load(boolean loadFromFile) {
+    public void load(boolean loadFromFile)
-        try {
+    {
-            if (loadFromFile) {
+        try
+        {
+            if (loadFromFile)
+            {
                 YamlConfiguration externalYamlConfig = YamlConfiguration.loadConfiguration(file);
                 InputStreamReader internalConfigFileStream = new InputStreamReader(Plex.get().getResource(name), StandardCharsets.UTF_8);
                 YamlConfiguration internalYamlConfig = YamlConfiguration.loadConfiguration(internalConfigFileStream);
 
                 // Gets all the keys inside the internal file and iterates through all of it's key pairs
-                for (String string : internalYamlConfig.getKeys(true)) {
+                for (String string : internalYamlConfig.getKeys(true))
+                {
                     // Checks if the external file contains the key already.
-                    if (!externalYamlConfig.contains(string)) {
+                    if (!externalYamlConfig.contains(string))
+                    {
                         // If it doesn't contain the key, we set the key based off what was found inside the plugin jar
                         externalYamlConfig.setComments(string, internalYamlConfig.getComments(string));
                         externalYamlConfig.set(string, internalYamlConfig.get(string));
@@ -74,14 +81,17 @@ public class Config extends YamlConfiguration {
                         added = true;
                     }
                 }
-                if (added) {
+                if (added)
+                {
                     externalYamlConfig.save(file);
                     PlexLog.log("Saving new file...");
                     added = false;
                 }
             }
             super.load(file);
-        } catch (Exception ex) {
+        }
+        catch (Exception ex)
+        {
             ex.printStackTrace();
         }
     }
@@ -89,10 +99,14 @@ public class Config extends YamlConfiguration {
     /**
      * Saves the configuration file
      */
-    public void save() {
+    public void save()
-        try {
+    {
+        try
+        {
             super.save(file);
-        } catch (Exception ex) {
+        }
+        catch (Exception ex)
+        {
             ex.printStackTrace();
         }
     }
@@ -100,7 +114,8 @@ public class Config extends YamlConfiguration {
     /**
      * Moves the configuration file from the plugin's resources folder to the data folder (plugins/Plex/)
      */
-    private void saveDefault() {
+    private void saveDefault()
+    {
         plugin.saveResource(name, false);
     }
 }

src/main/java/dev/plex/handlers/CommandHandler.java

@@ -3,56 +3,49 @@ package dev.plex.handlers;
 import com.google.common.collect.Lists;
 import dev.plex.PlexBase;
 import dev.plex.command.PlexCommand;
-import dev.plex.command.impl.*;
+import dev.plex.command.annotation.System;
 import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
+import java.lang.reflect.InvocationTargetException;
 import java.util.List;
+import java.util.Set;
 
-//TODO: Switch to Reflections API
 public class CommandHandler extends PlexBase
 {
     public CommandHandler()
     {
+        Set<Class<? extends PlexCommand>> commandSet = PlexUtils.getClassesBySubType("dev.plex.command.impl", PlexCommand.class);
         List<PlexCommand> commands = Lists.newArrayList();
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            commands.add(new AdminCMD());
-            commands.add(new DeopAllCMD());
-            commands.add(new DeopCMD());
-            commands.add(new OpAllCMD());
-            commands.add(new OpCMD());
-            commands.add(new RankCMD());
-        }
-        if (plugin.config.getBoolean("debug"))
-        {
-            commands.add(new DebugCMD());
-        }
 
-        commands.add(new AdminChatCMD());
+        commandSet.forEach(clazz ->
-        commands.add(new AdminworldCMD());
+        {
-        commands.add(new AdventureCMD());
+            try
-        commands.add(new BanCMD());
+            {
-        commands.add(new CommandSpyCMD());
+                System annotation = clazz.getDeclaredAnnotation(System.class);
-        commands.add(new CreativeCMD());
+                if (annotation != null)
-        commands.add(new FlatlandsCMD());
+                {
-        commands.add(new FreezeCMD());
+                    if (annotation.value().equalsIgnoreCase(plugin.getSystem()))
-        commands.add(new KickCMD());
+                    {
-        commands.add(new ListCMD());
+                        commands.add(clazz.getConstructor().newInstance());
-        commands.add(new LocalSpawnCMD());
+                        return;
-        commands.add(new LockupCMD());
+                    }
-        commands.add(new MasterbuilderworldCMD());
+
-        commands.add(new MuteCMD());
+                    if (plugin.config.getBoolean("debug") && annotation.debug())
-        commands.add(new NameHistoryCMD());
+                    {
-        commands.add(new PlexCMD());
+                        commands.add(clazz.getConstructor().newInstance());
-        commands.add(new PunishmentsCMD());
+                    }
-        commands.add(new RawSayCMD());
+                }
-        commands.add(new SpectatorCMD());
+                else
-        commands.add(new SurvivalCMD());
+                {
-        commands.add(new TagCMD());
+                    commands.add(clazz.getConstructor().newInstance());
-        commands.add(new TempbanCMD());
+                }
-        commands.add(new UnbanCMD());
+            }
-        commands.add(new UnfreezeCMD());
+            catch (InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException ex)
-        commands.add(new UnmuteCMD());
+            {
-        commands.add(new WorldCMD());
+                PlexLog.error("Failed to register " + clazz.getSimpleName() + " as a command!");
-        PlexLog.log(String.format("Registered %s commands!", commands.size()));
+            }
+        });
+
+        PlexLog.log(String.format("Registered %s commands from %s classes!", commands.size(), commandSet.size()));
     }
 }

src/main/java/dev/plex/handlers/ListenerHandler.java

@@ -1,34 +1,44 @@
 package dev.plex.handlers;
 
 import com.google.common.collect.Lists;
+import dev.plex.PlexBase;
 import dev.plex.listener.PlexListener;
-import dev.plex.listener.impl.AdminListener;
+import dev.plex.listener.annotation.Toggled;
-import dev.plex.listener.impl.BanListener;
-import dev.plex.listener.impl.ChatListener;
-import dev.plex.listener.impl.CommandListener;
-import dev.plex.listener.impl.FreezeListener;
-import dev.plex.listener.impl.GameModeListener;
-import dev.plex.listener.impl.PlayerListener;
-import dev.plex.listener.impl.ServerListener;
-import dev.plex.listener.impl.WorldListener;
 import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
+import java.lang.reflect.InvocationTargetException;
 import java.util.List;
+import java.util.Set;
 
-//TODO: Switch to Reflections API
+public class ListenerHandler extends PlexBase
-public class ListenerHandler
 {
     public ListenerHandler()
     {
+        Set<Class<? extends PlexListener>> listenerSet = PlexUtils.getClassesBySubType("dev.plex.listener.impl", PlexListener.class);
         List<PlexListener> listeners = Lists.newArrayList();
-        listeners.add(new AdminListener());
+
-        listeners.add(new BanListener());
+        listenerSet.forEach(clazz ->
-        listeners.add(new ChatListener());
+        {
-        listeners.add(new CommandListener());
+            try
-        listeners.add(new FreezeListener());
+            {
-        listeners.add(new GameModeListener());
+                Toggled annotation = clazz.getDeclaredAnnotation(Toggled.class);
-        listeners.add(new PlayerListener());
+                if (annotation != null)
-        listeners.add(new ServerListener());
+                {
-        listeners.add(new WorldListener());
+                    if (plugin.config.getBoolean("chat.enabled") && annotation.enabled())
-        PlexLog.log(String.format("Registered %s listeners!", listeners.size()));
+                    {
+                        listeners.add(clazz.getConstructor().newInstance());
+                    }
+                }
+                else
+                {
+                    listeners.add(clazz.getConstructor().newInstance());
+                }
+            }
+            catch (InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException ex)
+            {
+                PlexLog.error("Failed to register " + clazz.getSimpleName() + " as a listener!");
+            }
+        });
+        PlexLog.log(String.format("Registered %s listeners from %s classes!", listeners.size(), listenerSet.size()));
     }
 }

src/main/java/dev/plex/listener/annotation/Toggled.java

@@ -0,0 +1,6 @@
+package dev.plex.listener.annotation;
+
+public @interface Toggled
+{
+    boolean enabled() default false;
+}

src/main/java/dev/plex/listener/impl/ChatListener.java

@@ -2,49 +2,24 @@ package dev.plex.listener.impl;
 
 import dev.plex.cache.PlayerCache;
 import dev.plex.listener.PlexListener;
+import dev.plex.listener.annotation.Toggled;
 import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import io.papermc.paper.chat.ChatRenderer;
 import io.papermc.paper.event.player.AsyncChatEvent;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.jetbrains.annotations.NotNull;
 
+@Toggled(enabled = true)
 public class ChatListener extends PlexListener
 {
     private final PlexChatRenderer renderer = new PlexChatRenderer();
 
-    public static void adminChat(CommandSender sender, String message)
-    {
-        for (Player player : Bukkit.getOnlinePlayers())
-        {
-            if (plugin.getSystem().equalsIgnoreCase("ranks"))
-            {
-                PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
-                if (plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN))
-                {
-                    player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
-                }
-            }
-            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-            {
-                if (player.hasPermission("plex.adminchat"))
-                {
-                    player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
-                }
-            }
-        }
-        plugin.getServer().getConsoleSender().sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
-    }
-
     @EventHandler
     public void onChat(AsyncChatEvent event)
     {
@@ -56,8 +31,8 @@ public class ChatListener extends PlexListener
             return;
         }
 
-        String prefix = plugin.getRankManager().getPrefix(plexPlayer);
+        Component prefix = plugin.getRankManager().getPrefix(plexPlayer);
-        if (!prefix.isEmpty())
+        if (prefix != null)
         {
             renderer.hasPrefix = true;
             renderer.prefix = prefix;
@@ -73,14 +48,15 @@ public class ChatListener extends PlexListener
     public static class PlexChatRenderer implements ChatRenderer
     {
         public boolean hasPrefix;
-        public String prefix;
+        public Component prefix;
 
         @Override
         public @NotNull Component render(@NotNull Player source, @NotNull Component sourceDisplayName, @NotNull Component message, @NotNull Audience viewer)
         {
             if (hasPrefix)
             {
-                return Component.empty().append(MiniMessage.miniMessage().deserialize(prefix))
+                return Component.empty()
+                        .append(prefix)
                         .append(Component.space())
                         .append(LegacyComponentSerializer.legacyAmpersand().deserialize("&" + plugin.config.getString("chat.name-color") + LegacyComponentSerializer.legacyAmpersand().serialize(sourceDisplayName)))
                         .append(Component.space())
@@ -89,7 +65,7 @@ public class ChatListener extends PlexListener
                         .append(message);
             }
             return Component.empty()
-                    .append(sourceDisplayName)
+                    .append(LegacyComponentSerializer.legacyAmpersand().deserialize("&" + plugin.config.getString("chat.name-color") + LegacyComponentSerializer.legacyAmpersand().serialize(sourceDisplayName)))
                     .append(Component.space())
                     .append(Component.text("»").color(NamedTextColor.GRAY))
                     .append(Component.space())

src/main/java/dev/plex/listener/impl/PlayerListener.java

@@ -11,11 +11,8 @@ import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import java.util.Collections;
 import java.util.UUID;
-import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
-import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -50,9 +47,9 @@ public class PlayerListener extends PlexListener
         if (!DataUtils.hasPlayedBefore(player.getUniqueId()))
         {
             PlexLog.log("A player with this name has not joined the server before, creating new entry.");
-            plexPlayer = new PlexPlayer(player.getUniqueId()); //it doesn't! okay so now create the object
+            plexPlayer = new PlexPlayer(player.getUniqueId()); // it doesn't! okay so now create the object
-            plexPlayer.setName(player.getName()); //set the name of the player
+            plexPlayer.setName(player.getName()); // set the name of the player
-            plexPlayer.setIps(Collections.singletonList(player.getAddress().getAddress().getHostAddress().trim())); //set the arraylist of ips
+            plexPlayer.setIps(Collections.singletonList(player.getAddress().getAddress().getHostAddress().trim())); // set the arraylist of ips
             DataUtils.insert(plexPlayer); // insert data in some wack db
         }
         else
@@ -69,14 +66,10 @@ public class PlayerListener extends PlexListener
         }
 
         assert plexPlayer != null;
-
         String loginMessage = plugin.getRankManager().getLoginMessage(plexPlayer);
-
         if (!loginMessage.isEmpty())
         {
-            PlexUtils.broadcast(
+            PlexUtils.broadcast(MiniMessage.miniMessage().deserialize("<aqua>" + player.getName() + " is " + loginMessage));
-                    Component.text(ChatColor.AQUA + player.getName() + " is ").color(NamedTextColor.AQUA)
-                            .append(LegacyComponentSerializer.legacyAmpersand().deserialize(loginMessage)));
         }
     }
 

src/main/java/dev/plex/listener/impl/TabListener.java

@@ -0,0 +1,48 @@
+package dev.plex.listener.impl;
+
+import dev.plex.cache.DataUtils;
+import dev.plex.event.AdminAddEvent;
+import dev.plex.event.AdminRemoveEvent;
+import dev.plex.event.AdminSetRankEvent;
+import dev.plex.listener.PlexListener;
+import dev.plex.player.PlexPlayer;
+import net.kyori.adventure.text.Component;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class TabListener extends PlexListener
+{
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerJoin(PlayerJoinEvent event)
+    {
+        Player player = event.getPlayer();
+        PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
+        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onAdminAdd(AdminAddEvent event)
+    {
+        PlexPlayer plexPlayer = event.getPlexPlayer();
+        Player player = event.getPlexPlayer().getPlayer();
+        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onAdminRemove(AdminRemoveEvent event)
+    {
+        PlexPlayer plexPlayer = event.getPlexPlayer();
+        Player player = event.getPlexPlayer().getPlayer();
+        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onAdminSetRank(AdminSetRankEvent event)
+    {
+        PlexPlayer plexPlayer = event.getPlexPlayer();
+        Player player = event.getPlexPlayer().getPlayer();
+        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
+    }
+}

src/main/java/dev/plex/module/ModuleManager.java

@@ -4,10 +4,6 @@ import com.google.common.collect.Lists;
 import dev.plex.Plex;
 import dev.plex.module.exception.ModuleLoadException;
 import dev.plex.util.PlexLog;
-import lombok.Getter;
-import org.apache.logging.log4j.LogManager;
-import org.bukkit.configuration.file.YamlConfiguration;
-
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -18,18 +14,26 @@ import java.net.URLClassLoader;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.List;
+import lombok.Getter;
+import org.apache.logging.log4j.LogManager;
+import org.bukkit.configuration.file.YamlConfiguration;
 
 @Getter
-public class ModuleManager {
+public class ModuleManager
+{
 
     private final List<PlexModule> modules = Lists.newArrayList();
 
-    public void loadAllModules() {
+    public void loadAllModules()
+    {
         this.modules.clear();
         PlexLog.debug(String.valueOf(Plex.get().getModulesFolder().listFiles().length));
-        Arrays.stream(Plex.get().getModulesFolder().listFiles()).forEach(file -> {
+        Arrays.stream(Plex.get().getModulesFolder().listFiles()).forEach(file ->
-            if (file.getName().endsWith(".jar")) {
+        {
-                try {
+            if (file.getName().endsWith(".jar"))
+            {
+                try
+                {
                     URLClassLoader loader = new URLClassLoader(
                             new URL[]{file.toURI().toURL()},
                             Plex.class.getClassLoader()
@@ -54,57 +58,74 @@ public class ModuleManager {
                     String version = internalModuleConfig.getString("version", "1.0");
 
                     PlexModuleFile plexModuleFile = new PlexModuleFile(name, main, description, version);
-                    Class<? extends PlexModule> module = (Class<? extends PlexModule>) Class.forName(main, true, loader);
+                    Class<? extends PlexModule> module = (Class<? extends PlexModule>)Class.forName(main, true, loader);
 
                     PlexModule plexModule = module.getConstructor().newInstance();
                     plexModule.setPlex(Plex.get());
                     plexModule.setPlexModuleFile(plexModuleFile);
 
                     plexModule.setDataFolder(new File(Plex.get().getModulesFolder() + File.separator + plexModuleFile.getName()));
-                    if (!plexModule.getDataFolder().exists()) plexModule.getDataFolder().mkdir();
+                    if (!plexModule.getDataFolder().exists())
+                    {
+                        plexModule.getDataFolder().mkdir();
+                    }
 
                     plexModule.setLogger(LogManager.getLogger(plexModuleFile.getName()));
                     modules.add(plexModule);
-                } catch (MalformedURLException | ClassNotFoundException | InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e) {
+                }
+                catch (MalformedURLException | ClassNotFoundException | InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e)
+                {
                     e.printStackTrace();
                 }
             }
         });
     }
 
-    public void loadModules() {
+    public void loadModules()
-        this.modules.forEach(module -> {
+    {
+        this.modules.forEach(module ->
+        {
             PlexLog.log("Loading module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
             module.load();
         });
     }
 
-    public void enableModules() {
+    public void enableModules()
-        this.modules.forEach(module -> {
+    {
+        this.modules.forEach(module ->
+        {
             PlexLog.log("Enabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
             module.enable();
         });
     }
 
-    public void disableModules() {
+    public void disableModules()
-        this.modules.forEach(module -> {
+    {
+        this.modules.forEach(module ->
+        {
             PlexLog.log("Disabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
-            module.getCommands().stream().toList().forEach(plexCommand -> {
+            module.getCommands().stream().toList().forEach(plexCommand ->
+            {
                 module.unregisterCommand(plexCommand);
                 Plex.get().getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName());
                 plexCommand.getAliases().forEach(alias -> Plex.get().getServer().getCommandMap().getKnownCommands().remove(alias));
             });
-            module.getListeners().forEach(module::unregisterListener);
+            module.getListeners().stream().toList().forEach(module::unregisterListener);
             module.disable();
         });
     }
 
-    public void unloadModules() {
+    public void unloadModules()
+    {
         this.disableModules();
-        this.modules.forEach(module -> {
+        this.modules.forEach(module ->
-            try {
+        {
+            try
+            {
                 ((URLClassLoader)module.getClass().getClassLoader()).close();
-            } catch (IOException e) {
+            }
+            catch (IOException e)
+            {
                 e.printStackTrace();
             }
         });

src/main/java/dev/plex/module/PlexModule.java

@@ -4,17 +4,14 @@ import com.google.common.collect.Lists;
 import dev.plex.Plex;
 import dev.plex.command.PlexCommand;
 import dev.plex.listener.PlexListener;
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.Setter;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.bukkit.event.HandlerList;
-
 import java.io.File;
 import java.util.List;
 import java.util.Locale;
-import java.util.stream.Collectors;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.logging.log4j.Logger;
+import org.bukkit.event.HandlerList;
 
 @Getter
 @Setter(AccessLevel.MODULE)
@@ -31,11 +28,17 @@ public abstract class PlexModule
     private File dataFolder;
     private Logger logger;
 
-    public void load() {}
+    public void load()
+    {
+    }
 
-    public void enable() {}
+    public void enable()
+    {
+    }
 
-    public void disable() {}
+    public void disable()
+    {
+    }
 
     public void registerListener(PlexListener listener)
     {

src/main/java/dev/plex/player/PlexPlayer.java

@@ -11,6 +11,7 @@ import java.util.UUID;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
+import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;

src/main/java/dev/plex/punishment/Punishment.java

@@ -30,6 +30,7 @@ public class Punishment
     private boolean customTime;
     private boolean active; // Field is only for bans
     private LocalDateTime endDate;
+
     public Punishment(UUID punished, UUID punisher)
     {
         this.punished = punished;

src/main/java/dev/plex/punishment/PunishmentManager.java

@@ -7,7 +7,6 @@ import com.google.gson.Gson;
 import dev.plex.Plex;
 import dev.plex.PlexBase;
 import dev.plex.cache.PlayerCache;
-import dev.plex.player.PlexPlayer;
 import dev.plex.player.PunishedPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
@@ -15,7 +14,6 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.lang.reflect.Type;
 import java.nio.charset.StandardCharsets;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
@@ -24,11 +22,9 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 import java.util.stream.Collectors;
-
 import lombok.Data;
 import org.apache.commons.io.FileUtils;
 import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitRunnable;
 import org.json.JSONObject;
 import org.json.JSONTokener;
@@ -41,7 +37,8 @@ public class PunishmentManager extends PlexBase
     public void mergeIndefiniteBans()
     {
         this.indefiniteBans.clear();
-        Plex.get().indefBans.getKeys(false).forEach(key -> {
+        Plex.get().indefBans.getKeys(false).forEach(key ->
+        {
             IndefiniteBan ban = new IndefiniteBan();
             ban.ips.addAll(Plex.get().getIndefBans().getStringList(key + ".ips"));
             ban.usernames.addAll(Plex.get().getIndefBans().getStringList(key + ".users"));
@@ -54,7 +51,8 @@ public class PunishmentManager extends PlexBase
         if (Plex.get().getRedisConnection().isEnabled())
         {
             PlexLog.log("Asynchronously uploading all indefinite bans to Redis");
-            Plex.get().getRedisConnection().runAsync(jedis -> {
+            Plex.get().getRedisConnection().runAsync(jedis ->
+            {
                 jedis.set("indefbans", new Gson().toJson(indefiniteBans));
             });
         }
@@ -65,7 +63,9 @@ public class PunishmentManager extends PlexBase
         if (Plex.get().getRedisConnection().isEnabled())
         {
             PlexLog.debug("Checking if UUID is banned in Redis");
-            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>(){}.getType());
+            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
+            {
+            }.getType());
             return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUuids().contains(uuid));
         }
         return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUuids().contains(uuid));
@@ -76,7 +76,9 @@ public class PunishmentManager extends PlexBase
         if (Plex.get().getRedisConnection().isEnabled())
         {
             PlexLog.debug("Checking if IP is banned in Redis");
-            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>(){}.getType());
+            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
+            {
+            }.getType());
             return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getIps().contains(ip));
         }
         return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getIps().contains(ip));
@@ -87,7 +89,9 @@ public class PunishmentManager extends PlexBase
         if (Plex.get().getRedisConnection().isEnabled())
         {
             PlexLog.debug("Checking if username is banned in Redis");
-            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>(){}.getType());
+            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
+            {
+            }.getType());
             return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUsernames().contains(username));
         }
         return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUsernames().contains(username));
@@ -171,28 +175,31 @@ public class PunishmentManager extends PlexBase
     public List<Punishment> getActiveBans()
     {
         List<Punishment> punishments = Lists.newArrayList();
-        Jedis jedis = Plex.get().getRedisConnection().getJedis();
-        jedis.keys("*").forEach(key ->
-        {
-            try
-            {
-                UUID uuid = UUID.fromString(key);
-                String jsonPunishmentString = jedis.get(uuid.toString());
-                JSONObject object = new JSONObject(jsonPunishmentString);
-                object.getJSONObject(uuid.toString()).getJSONArray("punishments").forEach(json ->
-                {
-                    Punishment punishment = Punishment.fromJson(json.toString());
-                    if (punishment.isActive() && punishment.getType() == PunishmentType.BAN)
-                    {
-                        punishments.add(punishment);
-                    }
-                });
-            }
-            catch (IllegalArgumentException ignored)
-            {
 
-            }
+        if (Plex.get().getRedisConnection().isEnabled())
-        });
+        {
+            Jedis jedis = Plex.get().getRedisConnection().getJedis();
+            jedis.keys("*").forEach(key ->
+            {
+                try
+                {
+                    UUID uuid = UUID.fromString(key);
+                    String jsonPunishmentString = jedis.get(uuid.toString());
+                    JSONObject object = new JSONObject(jsonPunishmentString);
+                    object.getJSONObject(uuid.toString()).getJSONArray("punishments").forEach(json ->
+                    {
+                        Punishment punishment = Punishment.fromJson(json.toString());
+                        if (punishment.isActive() && punishment.getType() == PunishmentType.BAN)
+                        {
+                            punishments.add(punishment);
+                        }
+                    });
+                }
+                catch (IllegalArgumentException ignored)
+                {
+                }
+            });
+        }
 
         return punishments;
     }

src/main/java/dev/plex/rank/RankManager.java

@@ -4,6 +4,7 @@ import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
 import dev.plex.rank.enums.Rank;
 import dev.plex.rank.enums.Title;
+import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import java.io.File;
 import java.io.FileInputStream;
@@ -12,6 +13,9 @@ import java.io.IOException;
 import java.util.Arrays;
 import java.util.stream.Collectors;
 import lombok.SneakyThrows;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.json.JSONTokener;
@@ -88,11 +92,11 @@ public class RankManager
         }
     }
 
-    public String getPrefix(PlexPlayer player)
+    public Component getPrefix(PlexPlayer player)
     {
-        if (!player.getPrefix().isEmpty())
+        if (!player.getPrefix().equals(""))
         {
-            return player.getPrefix();
+            return MiniMessage.miniMessage().deserialize(player.getPrefix());
         }
         if (Plex.get().config.contains("titles.owners") && Plex.get().config.getStringList("titles.owners").contains(player.getName()))
         {
@@ -110,7 +114,7 @@ public class RankManager
         {
             return player.getRankFromString().getPrefix();
         }
-        return "";
+        return null;
     }
 
     public String getLoginMessage(PlexPlayer player)
@@ -138,6 +142,27 @@ public class RankManager
         return "";
     }
 
+    public NamedTextColor getColor(PlexPlayer player)
+    {
+        if (Plex.get().config.contains("titles.owners") && Plex.get().config.getStringList("titles.owners").contains(player.getName()))
+        {
+            return Title.OWNER.getColor();
+        }
+        if (PlexUtils.DEVELOPERS.contains(player.getUuid())) // don't remove or we will front door ur mother
+        {
+            return Title.DEV.getColor();
+        }
+        if (Plex.get().config.contains("titles.masterbuilders") && Plex.get().config.getStringList("titles.masterbuilders").contains(player.getName()))
+        {
+            return Title.MASTER_BUILDER.getColor();
+        }
+        if (Plex.get().getSystem().equalsIgnoreCase("ranks") && isAdmin(player))
+        {
+            return player.getRankFromString().getColor();
+        }
+        return NamedTextColor.WHITE;
+    }
+
     public boolean isAdmin(PlexPlayer plexPlayer)
     {
         return !plexPlayer.getRank().isEmpty() && plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN);

src/main/java/dev/plex/rank/enums/Rank.java

@@ -2,20 +2,20 @@ package dev.plex.rank.enums;
 
 import lombok.Getter;
 import lombok.Setter;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.minimessage.MiniMessage;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
-import org.bukkit.ChatColor;
 import org.json.JSONObject;
 
 @Getter
 public enum Rank
 {
-    IMPOSTOR(-1, ChatColor.AQUA + "an " + ChatColor.YELLOW + "Impostor", "Impostor", "&8[&eImp&8]"),
+    IMPOSTOR(-1, "<aqua>an <yellow>Impostor", "Impostor", "<dark_gray>[<yellow>Imp<dark_gray>]", NamedTextColor.YELLOW),
-    NONOP(0, "a " + ChatColor.WHITE + "Non-Op", "Non-Op", ""),
+    NONOP(0, "a <white>Non-Op", "Non-Op", "", NamedTextColor.WHITE),
-    OP(1, "an " + ChatColor.GREEN + "Operator", "Operator", "&8[&aOP&8]"),
+    OP(1, "an <green>Op", "Operator", "<dark_gray>[<green>OP<dark_gray>]", NamedTextColor.GREEN),
-    ADMIN(2, "an " + ChatColor.DARK_GREEN + "Admin", "Admin", "&8[&2Admin&8]"),
+    ADMIN(2, "an <dark_green>Admin", "Admin", "<dark_gray>[<green>Admin<dark_gray>]", NamedTextColor.DARK_GREEN),
-    SENIOR_ADMIN(3, "a " + ChatColor.GOLD + "Senior Admin", "Senior Admin", "&8[&6SrA&8]"),
+    SENIOR_ADMIN(3, "a <gold>Senior Admin", "Senior Admin", "<dark_gray>[<gold>SrA<dark_gray>]", NamedTextColor.GOLD),
-    EXECUTIVE(4, "an " + ChatColor.RED + "Executive", "Executive", "&8[&cExec&8]");
+    EXECUTIVE(4, "an <red>Executive", "Executive", "<dark_gray>[<red>Exec<dark_gray>]", NamedTextColor.RED);
 
     private final int level;
 
@@ -28,12 +28,16 @@ public enum Rank
     @Setter
     private String prefix;
 
-    Rank(int level, String loginMessage, String readable, String prefix)
+    @Getter
+    private NamedTextColor color;
+
+    Rank(int level, String loginMessage, String readable, String prefix, NamedTextColor color)
     {
         this.level = level;
         this.loginMessage = loginMessage;
         this.readable = readable;
         this.prefix = prefix;
+        this.color = color;
     }
 
     public boolean isAtLeast(Rank rank)
@@ -41,9 +45,9 @@ public enum Rank
         return this.level >= rank.getLevel();
     }
 
-    public String getPrefix()
+    public Component getPrefix()
     {
-        return MiniMessage.miniMessage().serialize(LegacyComponentSerializer.legacyAmpersand().deserialize(this.prefix));
+        return MiniMessage.miniMessage().deserialize(this.prefix);
     }
 
     public JSONObject toJSON()

src/main/java/dev/plex/rank/enums/Title.java

@@ -2,17 +2,17 @@ package dev.plex.rank.enums;
 
 import lombok.Getter;
 import lombok.Setter;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.minimessage.MiniMessage;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
-import org.bukkit.ChatColor;
 import org.json.JSONObject;
 
 @Getter
 public enum Title
 {
-    MASTER_BUILDER(0, ChatColor.AQUA + "a " + ChatColor.DARK_AQUA + "Master Builder", "Master Builder", "&8[&3Master Builder&8]"),
+    MASTER_BUILDER(0, "<aqua>a <dark_aqua>Master Builder", "Master Builder", "<dark_gray>[<dark_aqua>Master Builder<dark_gray>]", NamedTextColor.DARK_AQUA),
-    DEV(1, ChatColor.AQUA + "a " + ChatColor.DARK_PURPLE + "Developer", "Developer", "&8[&5Developer&8]"),
+    DEV(1, "<aqua>a <dark_purple>Developer", "Developer", "<dark_gray>[<dark_purple>Developer<dark_gray>]", NamedTextColor.DARK_PURPLE),
-    OWNER(2, ChatColor.AQUA + "an " + ChatColor.BLUE + "Owner", "Owner", "&8[&9Owner&8]");
+    OWNER(2, "<aqua>an <blue>Owner", "Owner", "<dark_gray>[<blue>Owner<dark_gray>]", NamedTextColor.BLUE);
 
     private final int level;
 
@@ -25,17 +25,21 @@ public enum Title
     @Setter
     private String prefix;
 
-    Title(int level, String loginMessage, String readable, String prefix)
+    @Getter
+    private NamedTextColor color;
+
+    Title(int level, String loginMessage, String readable, String prefix, NamedTextColor color)
     {
         this.level = level;
         this.loginMessage = loginMessage;
         this.readable = readable;
         this.prefix = prefix;
+        this.color = color;
     }
 
-    public String getPrefix()
+    public Component getPrefix()
     {
-        return MiniMessage.miniMessage().serialize(LegacyComponentSerializer.legacyAmpersand().deserialize(this.prefix));
+        return MiniMessage.miniMessage().deserialize(this.prefix);
     }
 
     public JSONObject toJSON()

src/main/java/dev/plex/services/impl/UpdateCheckerService.java

@@ -4,13 +4,13 @@ import dev.plex.services.AbstractService;
 
 public class UpdateCheckerService extends AbstractService
 {
+    private boolean newVersion = false;
+
     public UpdateCheckerService()
     {
         super(true, true);
     }
 
-    private boolean newVersion = false;
-
     @Override
     public void run()
     {

src/main/java/dev/plex/storage/MongoConnection.java

@@ -5,7 +5,6 @@ import com.mongodb.client.MongoClients;
 import dev.morphia.Datastore;
 import dev.morphia.Morphia;
 import dev.morphia.mapping.MapperOptions;
-import dev.plex.Plex;
 import dev.plex.PlexBase;
 import dev.plex.player.PlexPlayer;
 

src/main/java/dev/plex/storage/RedisConnection.java

@@ -2,9 +2,8 @@ package dev.plex.storage;
 
 import dev.plex.PlexBase;
 import dev.plex.util.PlexLog;
-import redis.clients.jedis.Jedis;
-
 import java.util.function.Consumer;
+import redis.clients.jedis.Jedis;
 
 public class RedisConnection extends PlexBase
 {

src/main/java/dev/plex/util/PlexLog.java

@@ -1,13 +1,11 @@
 package dev.plex.util;
 
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 
-public class PlexLog extends PlexBase
+public class PlexLog
 {
-    private static final boolean debugEnabled = plugin.config.getBoolean("debug");
-
     public static void log(String message, Object... strings)
     {
         for (int i = 0; i < strings.length; i++)
@@ -41,7 +39,7 @@ public class PlexLog extends PlexBase
                 message = message.replace("{" + i + "}", strings[i].toString());
             }
         }
-        if (debugEnabled)
+        if (Plex.get().config.getBoolean("debug"))
         {
             Bukkit.getConsoleSender().sendMessage(String.format(ChatColor.DARK_PURPLE + "[Plex Debug] " + ChatColor.GOLD + "%s", message));
         }

src/main/java/dev/plex/util/PlexUtils.java

@@ -1,5 +1,7 @@
 package dev.plex.util;
 
+import com.google.common.collect.ImmutableSet;
+import com.google.common.reflect.ClassPath;
 import dev.plex.Plex;
 import dev.plex.PlexBase;
 import dev.plex.config.Config;
@@ -15,12 +17,15 @@ import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Random;
+import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
@@ -320,6 +325,50 @@ public class PlexUtils extends PlexBase
         return UUID.fromString(uuidString);
     }
 
+    @SuppressWarnings("UnstableApiUsage")
+    public static Set<Class<?>> getClassesFrom(String packageName)
+    {
+        Set<Class<?>> classes = new HashSet<>();
+        try
+        {
+            ClassPath path = ClassPath.from(Plex.class.getClassLoader());
+            ImmutableSet<ClassPath.ClassInfo> infoSet = path.getTopLevelClasses(packageName);
+            infoSet.forEach(info ->
+            {
+                try
+                {
+                    Class<?> clazz = Class.forName(info.getName());
+                    classes.add(clazz);
+                }
+                catch (ClassNotFoundException ex)
+                {
+                    PlexLog.error("Unable to find class " + info.getName() + " in " + packageName);
+                }
+            });
+        }
+        catch (IOException ex)
+        {
+            PlexLog.error("Something went wrong while fetching classes from " + packageName);
+            throw new RuntimeException(ex);
+        }
+        return Collections.unmodifiableSet(classes);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> Set<Class<? extends T>> getClassesBySubType(String packageName, Class<T> subType)
+    {
+        Set<Class<?>> loadedClasses = getClassesFrom(packageName);
+        Set<Class<? extends T>> classes = new HashSet<>();
+        loadedClasses.forEach(clazz ->
+        {
+            if (clazz.getSuperclass() == subType || Arrays.asList(clazz.getInterfaces()).contains(subType))
+            {
+                classes.add((Class<? extends T>)clazz);
+            }
+        });
+        return Collections.unmodifiableSet(classes);
+    }
+
     public static int randomNum()
     {
         return ThreadLocalRandom.current().nextInt();

src/main/java/dev/plex/world/CustomChunkGenerator.java

@@ -17,6 +17,7 @@ public abstract class CustomChunkGenerator extends ChunkGenerator
         this.populators = Arrays.asList(populators);
     }
 
+    @Override
     public List<BlockPopulator> getDefaultPopulators(World world)
     {
         return populators;

src/main/java/dev/plex/world/FlatChunkGenerator.java

@@ -3,6 +3,8 @@ package dev.plex.world;
 import java.util.Random;
 import org.bukkit.World;
 import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.WorldInfo;
+import org.jetbrains.annotations.NotNull;
 
 public abstract class FlatChunkGenerator extends CustomChunkGenerator
 {
@@ -12,9 +14,8 @@ public abstract class FlatChunkGenerator extends CustomChunkGenerator
     }
 
     @Override
-    public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome)
+    public void generateSurface(WorldInfo worldInfo, Random random, int x, int z, ChunkData chunk)
     {
-        ChunkData chunk = this.createChunkData(world);
         for (int xx = 0; xx < 16; xx++)
         {
             for (int zz = 0; zz < 16; zz++)
@@ -22,7 +23,6 @@ public abstract class FlatChunkGenerator extends CustomChunkGenerator
                 createLoopChunkData(xx, height, zz, chunk);
             }
         }
-        return chunk;
     }
 
     public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);

src/main/java/dev/plex/world/NoiseChunkGenerator.java

@@ -3,7 +3,9 @@ package dev.plex.world;
 import java.util.Random;
 import org.bukkit.World;
 import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.WorldInfo;
 import org.bukkit.util.noise.PerlinNoiseGenerator;
+import org.jetbrains.annotations.NotNull;
 
 public abstract class NoiseChunkGenerator extends CustomChunkGenerator
 {
@@ -16,10 +18,9 @@ public abstract class NoiseChunkGenerator extends CustomChunkGenerator
     }
 
     @Override
-    public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome)
+    public void generateNoise(WorldInfo worldInfo, Random random, int x, int z, ChunkData chunk)
     {
-        ChunkData chunk = this.createChunkData(world);
+        PerlinNoiseGenerator generator = new PerlinNoiseGenerator(new Random(worldInfo.getSeed()));
-        PerlinNoiseGenerator generator = new PerlinNoiseGenerator(new Random(world.getSeed()));
         for (int xx = 0; xx < 16; xx++)
         {
             for (int zz = 0; zz < 16; zz++)
@@ -28,7 +29,6 @@ public abstract class NoiseChunkGenerator extends CustomChunkGenerator
                 createLoopChunkData(xx, height, zz, chunk);
             }
         }
-        return chunk;
     }
 
     public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);

src/main/java/dev/plex/world/OctaveChunkGenerator.java

@@ -3,7 +3,9 @@ package dev.plex.world;
 import java.util.Random;
 import org.bukkit.World;
 import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.WorldInfo;
 import org.bukkit.util.noise.PerlinOctaveGenerator;
+import org.jetbrains.annotations.NotNull;
 
 public abstract class OctaveChunkGenerator extends CustomChunkGenerator
 {
@@ -16,10 +18,9 @@ public abstract class OctaveChunkGenerator extends CustomChunkGenerator
     }
 
     @Override
-    public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome)
+    public void generateNoise(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z, @NotNull ChunkData chunk)
     {
-        ChunkData chunk = this.createChunkData(world);
+        PerlinOctaveGenerator generator = new PerlinOctaveGenerator(new Random(worldInfo.getSeed()), options.getOctaves());
-        PerlinOctaveGenerator generator = new PerlinOctaveGenerator(new Random(world.getSeed()), options.getOctaves());
         for (int xx = 0; xx < 16; xx++)
         {
             for (int zz = 0; zz < 16; zz++)
@@ -28,7 +29,6 @@ public abstract class OctaveChunkGenerator extends CustomChunkGenerator
                 createLoopChunkData(xx, height, zz, chunk);
             }
         }
-        return chunk;
     }
 
     public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);

src/main/resources/config.yml

@@ -18,6 +18,10 @@ banning:
   ban_url: "https://forum.plex.us.org"
 
 chat:
+  # Should the server use Plex's chat system? It is recommended to keep this on if you are using ranks.
+  # If you are using permissions, you should turn this off and use Vault to handle prefixes with a different chat plugin
+  enabled: true
+  # The maximum amount of characters a player can have for their tag
   max-tag-length: 16
   # Color code for name color
   name-color: 'f'