Update to Velocity 4.0.0

Jenkinsfile

@@ -1,8 +1,5 @@
 pipeline {
     agent any
-    tools {
-        jdk 'JDK 21.0.3'
-    }
     stages {
         stage("build") {
             steps {
@@ -17,7 +14,6 @@ pipeline {
             archiveArtifacts artifacts: "build/libs/*.jar", fingerprint: true
             javadoc javadocDir: "server/build/docs/javadoc", keepAll: false
             discordSend description: "**Build:** ${env.BUILD_NUMBER}\n**Status:** ${currentBuild.currentResult}", enableArtifactsList: true, footer: "Built with Jenkins", link: env.BUILD_URL, result: currentBuild.currentResult, scmWebUrl: "https://github.com/plexusorg/Plex", showChangeset: true, title: env.JOB_NAME, webhookURL: env.WEBHOOK_URL
-            discordSend description: "**Build:** ${env.BUILD_NUMBER}\n**Status:** ${currentBuild.currentResult}", enableArtifactsList: true, footer: "Built with Jenkins", link: env.BUILD_URL, result: currentBuild.currentResult, scmWebUrl: "https://github.com/plexusorg/Plex", showChangeset: true, title: env.JOB_NAME, webhookURL: env.TF_WEBHOOK_URL
             cleanWs()
         }
     }

build.gradle

@@ -0,0 +1,72 @@
+plugins {
+    id "java"
+    id "maven-publish"
+    id "com.github.johnrengelman.shadow" version "8.1.1"
+}
+
+group = "dev.plex"
+version = "1.4-SNAPSHOT"
+description = "Plex"
+
+subprojects {
+    apply plugin: "java"
+    apply plugin: "maven-publish"
+    apply plugin: "com.github.johnrengelman.shadow"
+
+    repositories {
+        maven {
+            url = uri("https://repo.papermc.io/repository/maven-public/")
+        }
+
+        maven {
+            url = uri("https://repository.apache.org/content/repositories/snapshots/")
+        }
+
+        maven {
+            url = uri("https://repo.maven.apache.org/maven2/")
+        }
+
+        maven {
+            url = uri("https://jitpack.io")
+            content {
+                includeGroup("com.github.MilkBowl")
+            }
+        }
+
+        mavenCentral()
+    }
+
+    java {
+        toolchain.languageVersion.set(JavaLanguageVersion.of(17))
+    }
+
+    tasks.withType(JavaCompile) {
+        options.encoding = "UTF-8"
+    }
+
+    publishing {
+        repositories {
+            maven {
+                def releasesRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-releases/")
+                def snapshotsRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-snapshots/")
+                url = rootProject.version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
+                credentials {
+                    username = System.getenv("plexUser")
+                    password = System.getenv("plexPassword")
+                }
+            }
+        }
+    }
+}
+
+clean {
+    dependsOn(":server:clean")
+    dependsOn(":proxy:clean")
+}
+
+task copyJars(type: Copy, dependsOn: subprojects.jar) {
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    from(subprojects.jar)
+    from(subprojects.shadowJar)
+    into project.file('build/libs')
+}

build.gradle.kts

@@ -1,91 +0,0 @@
-plugins {
-    id("java")
-    id("maven-publish")
-    id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.10"
-    id("net.kyori.blossom") version "2.1.0"
-    id("com.gradleup.shadow") version "9.0.0-beta12"
-}
-
-group = "dev.plex"
-version = "1.5-SNAPSHOT"
-description = "Plex"
-
-subprojects {
-    apply(plugin = "java")
-    apply(plugin = "maven-publish")
-    apply(plugin = "org.jetbrains.gradle.plugin.idea-ext")
-    apply(plugin = "net.kyori.blossom")
-    apply(plugin = "com.gradleup.shadow")
-
-    repositories {
-        maven {
-            url = uri("https://repo.papermc.io/repository/maven-public/")
-        }
-
-        maven {
-            url = uri("https://repository.apache.org/content/repositories/snapshots/")
-        }
-
-        maven {
-            url = uri("https://repo.maven.apache.org/maven2/")
-        }
-
-        maven {
-            url = uri("https://jitpack.io")
-            content {
-                includeGroup("com.github.MilkBowl")
-                includeGroup("com.github.LeonMangler")
-            }
-        }
-
-        mavenCentral()
-    }
-
-    java {
-        toolchain.languageVersion.set(JavaLanguageVersion.of(21))
-    }
-
-    tasks {
-        compileJava {
-            options.encoding = Charsets.UTF_8.name()
-        }
-        javadoc {
-            options.encoding = Charsets.UTF_8.name()
-        }
-        processResources {
-            filteringCharset = Charsets.UTF_8.name()
-        }
-    }
-
-    publishing {
-        repositories {
-            maven {
-                val releasesRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-releases/")
-                val snapshotsRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-snapshots/")
-                url = if (rootProject.version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl
-                credentials {
-                    username = System.getenv("plexUser")
-                    password = System.getenv("plexPassword")
-                }
-            }
-        }
-    }
-}
-
-tasks.clean {
-    dependsOn(subprojects.map {
-        it.project.tasks.clean
-    })
-}
-
-tasks.register<Copy>("copyJars", fun Copy.() {
-    dependsOn(tasks.jar)
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    from(subprojects.map {
-        it.project.tasks.shadowJar
-    })
-    from(subprojects.map {
-        it.project.tasks.jar
-    })
-    into(file("build/libs"))
-})

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -15,8 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# SPDX-License-Identifier: Apache-2.0
-#
 
 ##############################################################################
 #
@@ -57,7 +55,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -86,8 +84,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
-' "$PWD" ) || exit
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

gradlew.bat

@@ -13,8 +13,6 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -45,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
 
 goto fail
 
@@ -59,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
 
 goto fail
 

proxy/build.gradle.kts

@@ -1,3 +1,8 @@
+plugins {
+    id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.7"
+    id("net.kyori.blossom") version "2.1.0"
+}
+
 group = rootProject.group
 version = rootProject.version
 description = "Plex-Velocity"
@@ -39,9 +44,10 @@ publishing {
 }
 
 dependencies {
-    compileOnly("org.projectlombok:lombok:1.18.38")
-    annotationProcessor("org.projectlombok:lombok:1.18.38")
-    compileOnly("org.json:json:20250107")
-    compileOnly("com.velocitypowered:velocity-api:3.4.0-SNAPSHOT")
-    annotationProcessor("com.velocitypowered:velocity-api:3.4.0-SNAPSHOT")
+    compileOnly("org.projectlombok:lombok:1.18.30")
+    annotationProcessor("org.projectlombok:lombok:1.18.30")
+    compileOnly("org.json:json:20231013")
+    implementation("net.kyori:adventure-text-minimessage:4.14.0")
+    compileOnly("com.velocitypowered:velocity-api:4.0.0-SNAPSHOT")
+    annotationProcessor("com.velocitypowered:velocity-api:4.0.0-SNAPSHOT")
 }

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

@@ -2,7 +2,7 @@ package dev.plex;
 
 import com.google.inject.Inject;
 import com.velocitypowered.api.event.Subscribe;
-import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.event.lifecycle.ProxyInitializeEvent;
 import com.velocitypowered.api.plugin.Plugin;
 import com.velocitypowered.api.plugin.annotation.DataDirectory;
 import com.velocitypowered.api.proxy.ProxyServer;
@@ -10,10 +10,11 @@ import dev.plex.config.TomlConfig;
 import dev.plex.handlers.ListenerHandler;
 import dev.plex.settings.ServerSettings;
 import dev.plex.util.PlexLog;
+import lombok.Getter;
+
 import java.io.File;
 import java.nio.file.Path;
 import java.util.logging.Logger;
-import lombok.Getter;
 
 /**
  * Credits for TOML library go to https://github.com/mwanji/toml4j
@@ -27,7 +28,7 @@ import lombok.Getter;
 @Plugin(
         name = "Plex",
         id = "plex",
-        version = BuildParameters.VERSION,
+        version = "{{ version }}",
         url = "https://plex.us.org",
         description = "Plex provides a new experience for freedom servers.",
         authors = {"Telesphoreo", "Taah"}

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

@@ -2,19 +2,20 @@ package dev.plex.command;
 
 import com.velocitypowered.api.command.CommandMeta;
 import com.velocitypowered.api.command.CommandSource;
+import com.velocitypowered.api.command.ConsoleCommandSource;
 import com.velocitypowered.api.command.SimpleCommand;
-import com.velocitypowered.api.proxy.ConsoleCommandSource;
-import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.connection.Player;
 import dev.plex.Plex;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import java.util.Arrays;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+
 public abstract class PlexCommand implements SimpleCommand
 {
     /**
@@ -42,10 +43,9 @@ public abstract class PlexCommand implements SimpleCommand
         this.perms = getClass().getAnnotation(CommandPermissions.class);
         this.commandSource = this.perms.source();
 
-        CommandMeta.Builder meta = plugin.getServer().getCommandManager().metaBuilder(this.params.name());
+        CommandMeta.Builder meta = plugin.getServer().commandManager().createMetaBuilder(this.params.name());
         meta.aliases(this.params.aliases());
-        meta.plugin(Plex.get());
-        plugin.getServer().getCommandManager().register(meta.build(), this);
+        plugin.getServer().commandManager().register(meta.build(), this);
     }
 
     protected abstract Component execute(@NotNull CommandSource source, @Nullable Player player, @NotNull String[] args);

proxy/src/main/java/dev/plex/command/annotation/CommandPermissions.java

@@ -1,6 +1,7 @@
 package dev.plex.command.annotation;
 
 import dev.plex.command.source.RequiredCommandSource;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 

proxy/src/main/java/dev/plex/config/TomlConfig.java

@@ -3,12 +3,13 @@ package dev.plex.config;
 import dev.plex.Plex;
 import dev.plex.toml.Toml;
 import dev.plex.toml.TomlWriter;
+import lombok.Getter;
+import lombok.Setter;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.function.Consumer;
-import lombok.Getter;
-import lombok.Setter;
 
 @Getter
 public class TomlConfig

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

@@ -4,6 +4,7 @@ import com.google.common.collect.Lists;
 import dev.plex.listener.PlexListener;
 import dev.plex.util.PlexLog;
 import dev.plex.util.ReflectionsUtil;
+
 import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Set;

proxy/src/main/java/dev/plex/listener/PlexListener.java

@@ -8,6 +8,6 @@ public class PlexListener
 
     public PlexListener()
     {
-        Plex.get().getServer().getEventManager().register(Plex.get(), this);
+        Plex.get().getServer().eventManager().register(Plex.get(), this);
     }
 }

proxy/src/main/java/dev/plex/listener/impl/ConnectionListener.java

@@ -2,7 +2,7 @@ package dev.plex.listener.impl;
 
 import com.velocitypowered.api.event.PostOrder;
 import com.velocitypowered.api.event.Subscribe;
-import com.velocitypowered.api.event.connection.DisconnectEvent;
+import com.velocitypowered.api.event.player.DisconnectEvent;
 import com.velocitypowered.api.event.player.ServerConnectedEvent;
 import dev.plex.Plex;
 import dev.plex.listener.PlexListener;
@@ -14,27 +14,27 @@ public class ConnectionListener extends PlexListener
     @Subscribe(order = PostOrder.FIRST)
     public void onPlayerJoin(ServerConnectedEvent event)
     {
-        if (event.getPreviousServer().isPresent())
+        if (event.previousServer() != null)
         {
             Plex.get().server.sendMessage(miniMessage("<dark_gray>[<#ffbf00>o<dark_gray>] <yellow>"
-                    + event.getPlayer().getUsername() + " switched from " + event.getPreviousServer().get().getServerInfo().getName()
-                    + " to " + event.getServer().getServerInfo().getName()));
+                    + event.player().username() + " switched from " + event.previousServer().serverInfo().name()
+                    + " to " + event.target().serverInfo().name()));
         }
         else
         {
             Plex.get().server.sendMessage(miniMessage("<dark_gray>[<green>+<dark_gray>] <yellow>"
-                    + event.getPlayer().getUsername() + " joined server " + event.getServer().getServerInfo().getName()));
+                    + event.player().username() + " joined server " + event.target().serverInfo().name()));
         }
     }
 
     @Subscribe(order = PostOrder.FIRST)
     public void onPlayerLeave(DisconnectEvent event)
     {
-        if (event.getPlayer().getCurrentServer().isPresent())
+        if (event.player().connectedServer() != null)
         {
             Plex.get().server.sendMessage(miniMessage("<dark_gray>[<red>-<dark_gray>] <yellow>"
-                    + event.getPlayer().getUsername() + " left server " +
-                    event.getPlayer().getCurrentServer().get().getServerInfo().getName()));
+                    + event.player().username() + " left server " +
+                    event.player().connectedServer().serverInfo().name()));
         }
     }
 

proxy/src/main/java/dev/plex/listener/impl/ServerListener.java

@@ -2,18 +2,19 @@ package dev.plex.listener.impl;
 
 import com.velocitypowered.api.event.PostOrder;
 import com.velocitypowered.api.event.Subscribe;
-import com.velocitypowered.api.event.proxy.ProxyPingEvent;
+import com.velocitypowered.api.event.connection.ProxyPingEvent;
 import com.velocitypowered.api.proxy.server.ServerPing;
 import dev.plex.listener.PlexListener;
 import dev.plex.settings.ServerSettings;
 import dev.plex.util.RandomUtil;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
 import java.util.UUID;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 
 public class ServerListener extends PlexListener
 {
@@ -23,10 +24,10 @@ public class ServerListener extends PlexListener
         String baseMotd = plugin.getConfig().as(ServerSettings.class).getServer().getMotd().get(ThreadLocalRandom.current().nextInt(plugin.getConfig().as(ServerSettings.class).getServer().getMotd().size()));
         baseMotd = baseMotd.replace("\\n", "\n");
         baseMotd = baseMotd.replace("%servername%", plugin.getConfig().as(ServerSettings.class).getServer().getName());
-        baseMotd = baseMotd.replace("%mcversion%", plugin.getServer().getVersion().getVersion().split(" ")[0]);
+        baseMotd = baseMotd.replace("%mcversion%", plugin.getServer().version().version().split(" ")[0]);
         baseMotd = baseMotd.replace("%randomgradient%", "<gradient:" + RandomUtil.getRandomColor().toString() + ":" + RandomUtil.getRandomColor().toString() + ">");
 
-        ServerPing.Builder builder = event.getPing().asBuilder();
+        ServerPing.Builder builder = event.ping().asBuilder();
 
         if (plugin.getConfig().as(ServerSettings.class).getServer().isColorizeMotd())
         {
@@ -44,7 +45,7 @@ public class ServerListener extends PlexListener
         }
 
         builder.samplePlayers(plugin.getConfig().as(ServerSettings.class).getServer().getSample().stream().map(s -> new ServerPing.SamplePlayer(convertColorCodes(s), UUID.randomUUID())).toArray(ServerPing.SamplePlayer[]::new));
-        builder.onlinePlayers(plugin.getServer().getPlayerCount() + plugin.getConfig().as(ServerSettings.class).getServer().getAddPlayerCount());
+        builder.onlinePlayers(plugin.getServer().countConnectedPlayers() + plugin.getConfig().as(ServerSettings.class).getServer().getAddPlayerCount());
         if (plugin.getConfig().as(ServerSettings.class).getServer().isPlusOneMaxPlayer())
         {
             builder.maximumPlayers(builder.getOnlinePlayers() + 1);

proxy/src/main/java/dev/plex/settings/ServerSettings.java

@@ -2,10 +2,11 @@ package dev.plex.settings;
 
 import com.google.common.collect.Lists;
 import com.google.gson.annotations.SerializedName;
-import java.util.List;
 import lombok.Data;
 import lombok.Getter;
 
+import java.util.List;
+
 @Getter
 public class ServerSettings
 {

proxy/src/main/java/dev/plex/toml/ArrayValueWriter.java

@@ -4,6 +4,7 @@ package dev.plex.toml;
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Collection;
+
 import static dev.plex.toml.ValueWriters.WRITERS;
 
 public abstract class ArrayValueWriter implements dev.plex.toml.ValueWriter

proxy/src/main/java/dev/plex/toml/ObjectValueWriter.java

@@ -1,14 +1,10 @@
 package dev.plex.toml;
 
 import com.google.gson.annotations.SerializedName;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 class ObjectValueWriter implements ValueWriter
 {

proxy/src/main/java/dev/plex/toml/Results.java

@@ -1,11 +1,6 @@
 package dev.plex.toml;
 
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
 class Results

proxy/src/main/java/dev/plex/toml/TableArrayValueWriter.java

@@ -1,6 +1,7 @@
 package dev.plex.toml;
 
 import java.util.Collection;
+
 import static dev.plex.toml.ValueWriters.WRITERS;
 
 class TableArrayValueWriter extends ArrayValueWriter

proxy/src/main/java/dev/plex/toml/Toml.java

@@ -2,23 +2,12 @@ package dev.plex.toml;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import lombok.Getter;
 
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
 /**
  * <p>Provides access to the keys and tables in a TOML data source.</p>
  *

proxy/src/main/java/dev/plex/toml/TomlWriter.java

@@ -1,17 +1,13 @@
 package dev.plex.toml;
 
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.StringWriter;
-import java.io.Writer;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.*;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
-import org.jetbrains.annotations.Nullable;
+
 import static dev.plex.toml.ValueWriters.WRITERS;
 
 /**

proxy/src/main/java/dev/plex/toml/ValueReaders.java

@@ -1,6 +1,7 @@
 package dev.plex.toml;
 
 import java.util.concurrent.atomic.AtomicInteger;
+
 import static dev.plex.toml.ArrayValueReader.ARRAY_VALUE_READER;
 import static dev.plex.toml.BooleanValueReaderWriter.BOOLEAN_VALUE_READER_WRITER;
 import static dev.plex.toml.DateValueReaderWriter.DATE_VALUE_READER_WRITER;

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

@@ -17,12 +17,12 @@ public class PlexLog
                 message = message.replace("{" + i + "}", strings[i].toString());
             }
         }
-        Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<yellow>[Plex] <gray>" + message));
+        Plex.get().getServer().consoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<yellow>[Plex] <gray>" + message));
     }
 
     public static void log(Component component)
     {
-        Plex.get().getServer().getConsoleCommandSource().sendMessage(Component.text("[Plex] ").color(NamedTextColor.YELLOW).append(component).colorIfAbsent(NamedTextColor.GRAY));
+        Plex.get().getServer().consoleCommandSource().sendMessage(Component.text("[Plex] ").color(NamedTextColor.YELLOW).append(component).colorIfAbsent(NamedTextColor.GRAY));
     }
 
     public static void error(String message, Object... strings)
@@ -34,7 +34,7 @@ public class PlexLog
                 message = message.replace("{" + i + "}", strings[i].toString());
             }
         }
-        Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<red>[Plex Error] <gold>" + message));
+        Plex.get().getServer().consoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<red>[Plex Error] <gold>" + message));
     }
 
     public static void warn(String message, Object... strings)
@@ -46,7 +46,7 @@ public class PlexLog
                 message = message.replace("{" + i + "}", strings[i].toString());
             }
         }
-        Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<#eb7c0e>[Plex Warning] <gold>" + message));
+        Plex.get().getServer().consoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<#eb7c0e>[Plex Warning] <gold>" + message));
     }
 
     public static void debug(String message, Object... strings)
@@ -60,7 +60,7 @@ public class PlexLog
         }
         if (Plex.get().getConfig().as(ServerSettings.class).getServer().isDebug())
         {
-            Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<dark_purple>[Plex Debug] <gold>" + message));
+            Plex.get().getServer().consoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<dark_purple>[Plex Debug] <gold>" + message));
         }
     }
 }

proxy/src/main/java/dev/plex/util/RandomUtil.java

@@ -1,8 +1,9 @@
 package dev.plex.util;
 
-import java.util.concurrent.ThreadLocalRandom;
 import net.kyori.adventure.text.format.NamedTextColor;
 
+import java.util.concurrent.ThreadLocalRandom;
+
 public class RandomUtil
 {
     public static NamedTextColor getRandomColor()

proxy/src/main/java/dev/plex/util/ReflectionsUtil.java

@@ -3,6 +3,7 @@ package dev.plex.util;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.reflect.ClassPath;
 import dev.plex.Plex;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;

server/build.gradle

@@ -0,0 +1,154 @@
+plugins {
+    id "net.minecrell.plugin-yml.paper" version "0.6.0"
+}
+
+dependencies {
+    library "org.projectlombok:lombok:1.18.30"
+    annotationProcessor "org.projectlombok:lombok:1.18.30"
+    library "org.json:json:20231013"
+    library "commons-io:commons-io:2.15.0"
+    library "redis.clients:jedis:5.0.2"
+    library "org.mariadb.jdbc:mariadb-java-client:3.2.0"
+    library "com.zaxxer:HikariCP:5.0.1"
+    library "org.apache.maven.resolver:maven-resolver-transport-http:1.9.16"
+    library "org.jetbrains:annotations:24.0.1"
+    compileOnly "dev.folia:folia-api:1.20.1-R0.1-SNAPSHOT"
+    compileOnly("com.github.MilkBowl:VaultAPI:1.7.1") {
+        exclude group: "org.bukkit", module: "bukkit"
+    }
+    implementation "org.bstats:bstats-base:3.0.2"
+    implementation "org.bstats:bstats-bukkit:3.0.2"
+}
+
+group = rootProject.group
+version = rootProject.version
+description = "Plex-Server"
+
+shadowJar {
+    archiveBaseName.set("Plex")
+    archiveClassifier.set("")
+    relocate "org.bstats", "dev.plex"
+}
+
+paper {
+    name = "Plex"
+    version = project.version
+    description = "Plex provides a new experience for freedom servers."
+    main = "dev.plex.Plex"
+    loader = "dev.plex.PlexLibraryManager"
+    website = "https://plex.us.org"
+    authors = ["Telesphoreo", "taahanis", "supernt"]
+    apiVersion = "1.19"
+    foliaSupported = true
+    generateLibrariesJson = true
+    // Load BukkitTelnet and LibsDisguises before Plex so the modules register properly
+    serverDependencies {
+        'BukkitTelnet' {
+            required = false
+            load = 'BEFORE'
+        }
+        'LibsDisguises' {
+            required = false
+            load = 'BEFORE'
+        }
+        'Vault' {
+            required = false
+            load = 'BEFORE'
+        }
+        'Essentials' {
+            required = false
+            load = 'BEFORE'
+        }
+        'SlimeWorldManager' {
+            required = false
+            load = 'AFTER'
+        }
+    }
+}
+
+String getGitHash() {
+    def stdout = new ByteArrayOutputStream()
+    try {
+        exec {
+            commandLine "git", "rev-parse", "--short", "HEAD"
+            standardOutput = stdout
+            ignoreExitValue = true
+        }
+    } catch (GradleException e) {
+        logger.error("Couldn't determine Git head because Git is not installed. " + e.getMessage())
+    }
+    return stdout.size() > 0 ? stdout.toString().trim() : "unknown"
+}
+
+String getBuildNumber() {
+    def stdout = new ByteArrayOutputStream()
+    try {
+        exec {
+            commandLine "git", "rev-list", "HEAD", "--count"
+            standardOutput = stdout
+            ignoreExitValue = true
+        }
+    } catch (GradleException e) {
+        logger.error("Couldn't determine build number because Git is not installed. " + e.getMessage())
+    }
+    return stdout.size() ? stdout.toString().trim() + " (local)" : "unknown"
+}
+
+static def getDate() {
+    return new Date().format("MM/dd/yyyy '<light_purple>at<gold>' hh:mm:ss a z")
+}
+
+task buildProperties {
+    ant.propertyfile(file: "$project.projectDir/src/main/resources/build.properties") {
+        entry(key: "buildAuthor", default: System.getenv("JENKINS_URL") != null ? "jenkins" : "unknown")
+        entry(key: "buildNumber", value: System.getenv("JENKINS_URL") != null ? System.getenv("BUILD_NUMBER") + " (Jenkins)" : getBuildNumber())
+        entry(key: "buildDate", value: getDate())
+        entry(key: "buildHead", value: getGitHash())
+    }
+}
+
+tasks {
+    build {
+        dependsOn(shadowJar)
+        finalizedBy(buildProperties)
+    }
+
+    jar {
+        enabled = false
+    }
+
+    shadowJar {
+        finalizedBy(rootProject.tasks.copyJars)
+    }
+
+    javadoc {
+        options.memberLevel = JavadocMemberLevel.PRIVATE
+    }
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            pom.withXml {
+                def dependenciesNode = asNode().appendNode("dependencies")
+                configurations.getByName("library").getAllDependencies().each { dependency ->
+                    dependenciesNode.appendNode("dependency").with {
+                        it.appendNode("groupId", dependency.group)
+                        it.appendNode("artifactId", dependency.name)
+                        it.appendNode("version", dependency.version)
+                        it.appendNode("scope", "provided")
+                    }
+                }
+                configurations.getByName("implementation").getAllDependencies().each { dependency ->
+                    dependenciesNode.appendNode("dependency").with {
+                        it.appendNode("groupId", dependency.group)
+                        it.appendNode("artifactId", dependency.name)
+                        it.appendNode("version", dependency.version)
+                        it.appendNode("scope", "runtime")
+                    }
+                }
+            }
+            artifacts = [shadowJar]
+        }
+    }
+}

server/build.gradle.kts

@@ -1,167 +0,0 @@
-import net.minecrell.pluginyml.paper.PaperPluginDescription
-import java.io.ByteArrayOutputStream
-import java.text.SimpleDateFormat
-import java.util.*
-
-plugins {
-    id("net.kyori.indra.git") version "3.1.3"
-    id("de.eldoria.plugin-yml.paper") version "0.7.1"
-}
-
-repositories {
-    maven(url = uri("https://maven.playpro.com"))
-    maven(url = uri("https://nexus.telesphoreo.me/repository/plex-modules/"))
-}
-
-dependencies {
-    library("org.projectlombok:lombok:1.18.38")
-    library("org.json:json:20250107")
-    library("commons-io:commons-io:2.19.0")
-    library("redis.clients:jedis:6.0.0-beta2")
-    library("org.mariadb.jdbc:mariadb-java-client:3.5.3")
-    library("com.zaxxer:HikariCP:6.3.0")
-    library("org.apache.maven.resolver:maven-resolver-transport-http:1.9.22")
-    library("org.jetbrains:annotations:26.0.2")
-    compileOnly("io.papermc.paper:paper-api:1.21.4-R0.1-SNAPSHOT")
-    compileOnly("com.github.MilkBowl:VaultAPI:1.7.1") {
-        exclude("org.bukkit", "bukkit")
-    }
-    compileOnly("net.coreprotect:coreprotect:22.4")
-    compileOnly("network.darkhelmet.prism:Prism-Api:1.0.0")
-
-    implementation("org.bstats:bstats-base:3.1.0")
-    implementation("org.bstats:bstats-bukkit:3.1.0")
-
-    implementation("com.github.LeonMangler:SuperVanish:6.2.18-3")
-
-    annotationProcessor("org.projectlombok:lombok:1.18.38")
-}
-
-group = rootProject.group
-version = rootProject.version
-description = "Plex-Server"
-
-paper {
-    name = "Plex"
-    version = rootProject.version.toString()
-    description = "Plex provides a new experience for freedom servers."
-    main = "dev.plex.Plex"
-    loader = "dev.plex.PlexLibraryManager"
-    website = "https://plex.us.org"
-    authors = listOf("Telesphoreo", "taahanis", "supernt")
-    apiVersion = "1.20.5"
-    foliaSupported = true
-    generateLibrariesJson = true
-    // Load BukkitTelnet and LibsDisguises before Plex so the modules register properly
-    serverDependencies {
-        register("BukkitTelnet") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("Essentials") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("LibsDisguises") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("Prism") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("CoreProtect") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("PremiumVanish") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("SlimeWorldManager") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.AFTER
-        }
-        register("SuperVanish") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-        register("Vault") {
-            required = false
-            load = PaperPluginDescription.RelativeLoadOrder.BEFORE
-        }
-    }
-}
-
-fun getBuildNumber(): String {
-    val stdout = ByteArrayOutputStream()
-    try {
-        exec {
-            commandLine("git", "rev-list", "HEAD", "--count")
-            standardOutput = stdout
-            isIgnoreExitValue = true
-        }
-    } catch (e: GradleException) {
-        logger.error("Couldn't determine build number because Git is not installed. " + e.message)
-    }
-    return if (stdout.size() > 0) stdout.toString().trim() else "unknown"
-}
-
-tasks {
-    build {
-        dependsOn(shadowJar)
-    }
-
-    jar {
-        enabled = false
-    }
-
-    sourceSets {
-        main {
-            blossom {
-                resources {
-                    property("author", if (System.getenv("JENKINS_URL") != null) "jenkins" else System.getProperty("user.name"))
-                    property("buildNumber", if (System.getenv("BUILD_NUMBER") != null) System.getenv("BUILD_NUMBER") else getBuildNumber())
-                    property("date", SimpleDateFormat("MM/dd/yyyy '<light_purple>at<gold>' hh:mm:ss a z").format(Date()))
-                    property("gitCommit", indraGit.commit()?.name?.take(7))
-                }
-            }
-        }
-    }
-
-    shadowJar {
-        archiveBaseName.set("Plex")
-        archiveClassifier.set("")
-        relocate("org.bstats", "dev.plex")
-        finalizedBy(rootProject.tasks["copyJars"])
-    }
-
-    javadoc {
-        options.memberLevel = JavadocMemberLevel.PRIVATE
-    }
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("maven") {
-            pom.withXml {
-                val dependenciesNode = asNode().appendNode("dependencies")
-                configurations.getByName("library").allDependencies.configureEach {
-                    dependenciesNode.appendNode("dependency")
-                            .appendNode("groupId", group).parent()
-                            .appendNode("artifactId", name).parent()
-                            .appendNode("version", version).parent()
-                            .appendNode("scope", "provided").parent()
-                }
-                configurations.getByName("implementation").allDependencies.configureEach {
-                    dependenciesNode.appendNode("dependency")
-                            .appendNode("groupId", group).parent()
-                            .appendNode("artifactId", name).parent()
-                            .appendNode("version", version).parent()
-                            .appendNode("scope", "provided").parent()
-                }
-            }
-            artifacts.artifact(tasks.shadowJar)
-        }
-    }
-}

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

@@ -1,12 +1,11 @@
 package dev.plex;
 
+import com.google.common.collect.Lists;
 import dev.plex.cache.DataUtils;
 import dev.plex.cache.PlayerCache;
 import dev.plex.config.Config;
 import dev.plex.handlers.CommandHandler;
 import dev.plex.handlers.ListenerHandler;
-import dev.plex.hook.CoreProtectHook;
-import dev.plex.hook.PrismHook;
 import dev.plex.module.ModuleManager;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.PunishmentManager;
@@ -17,23 +16,22 @@ import dev.plex.storage.StorageType;
 import dev.plex.storage.player.SQLPlayerData;
 import dev.plex.storage.punishment.SQLNotes;
 import dev.plex.storage.punishment.SQLPunishment;
-import dev.plex.util.BuildInfo;
-import dev.plex.util.BungeeUtil;
-import dev.plex.util.PlexLog;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.UpdateChecker;
+import dev.plex.util.*;
 import dev.plex.util.redis.MessageUtil;
+import dev.plex.util.sql.SQLUtil;
 import dev.plex.world.CustomWorld;
-import java.io.File;
 import lombok.Getter;
 import lombok.Setter;
 import net.milkbowl.vault.chat.Chat;
 import net.milkbowl.vault.permission.Permission;
+import org.apache.commons.lang3.StringUtils;
 import org.bstats.bukkit.Metrics;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.RegisteredServiceProvider;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import java.io.File;
+
 @Getter
 @Setter
 public class Plex extends JavaPlugin
@@ -48,6 +46,7 @@ public class Plex extends JavaPlugin
     public File modulesFolder;
     private StorageType storageType = StorageType.SQLITE;
     private SQLConnection sqlConnection;
+//    private MongoConnection mongoConnection;
     private RedisConnection redisConnection;
 
     private PlayerCache playerCache;
@@ -64,9 +63,6 @@ public class Plex extends JavaPlugin
     private Permission permissions;
     private Chat chat;
 
-    private CoreProtectHook coreProtectHook;
-    private PrismHook prismHook;
-
     public static Plex get()
     {
         return plugin;
@@ -109,6 +105,7 @@ public class Plex extends JavaPlugin
         commands.load(false);
 
         sqlConnection = new SQLConnection();
+//        mongoConnection = new MongoConnection();
         redisConnection = new RedisConnection();
 
         playerCache = new PlayerCache();
@@ -127,38 +124,12 @@ public class Plex extends JavaPlugin
 
         if (!getServer().getPluginManager().isPluginEnabled("Vault"))
         {
-            throw new RuntimeException("Vault is required to run on the server alongside a permissions plugin, we recommend LuckPerms!");
+            throw new RuntimeException("Vault is required to run on the server if you use permissions alongside a permissions plugin, we recommend LuckPerms!");
         }
 
         permissions = setupPermissions();
         chat = setupChat();
 
-        if (plugin.getServer().getPluginManager().isPluginEnabled("CoreProtect"))
-        {
-            PlexLog.log("Hooked into CoreProtect!");
-            coreProtectHook = new CoreProtectHook(this);
-        }
-        else
-        {
-            PlexLog.debug("Not hooking into CoreProtect");
-        }
-        if (plugin.getServer().getPluginManager().isPluginEnabled("Prism"))
-        {
-            PlexLog.log("Hooked into Prism!");
-            prismHook = new PrismHook(this);
-        }
-        else
-        {
-            PlexLog.debug("Not hooking into Prism");
-        }
-
-        if (PlexUtils.hasVanishPlugin())
-        {
-            PlexLog.log("Hooked into SuperVanish / PremiumVanish!");
-        } else {
-            PlexLog.debug("Not hooking into SuperVanish / PremiumVanish");
-        }
-
         updateChecker = new UpdateChecker();
         PlexLog.log("Update checking enabled");
 

server/src/main/java/dev/plex/PlexLibraryManager.java

@@ -4,6 +4,11 @@ import com.google.gson.Gson;
 import io.papermc.paper.plugin.loader.PluginClasspathBuilder;
 import io.papermc.paper.plugin.loader.PluginLoader;
 import io.papermc.paper.plugin.loader.library.impl.MavenLibraryResolver;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.jetbrains.annotations.NotNull;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -11,10 +16,6 @@ import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
-import org.eclipse.aether.artifact.DefaultArtifact;
-import org.eclipse.aether.graph.Dependency;
-import org.eclipse.aether.repository.RemoteRepository;
-import org.jetbrains.annotations.NotNull;
 
 public class PlexLibraryManager implements PluginLoader
 {
@@ -28,9 +29,9 @@ public class PlexLibraryManager implements PluginLoader
         // The plugin is null, a hacky way to check whether to load Jetty or not
         if (new File("plugins/Plex/modules/Module-HTTPD.jar").isFile())
         {
-            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-server:12.0.14"), null));
-            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty.ee10:jetty-ee10-servlet:12.0.14"), null));
-            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-proxy:12.0.14"), null));
+            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-server:11.0.18"), null));
+            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-servlet:11.0.18"), null));
+            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-proxy:11.0.18"), null));
         }
         classpathBuilder.addLibrary(resolver);
     }

server/src/main/java/dev/plex/cache/DataUtils.java

@@ -2,6 +2,8 @@ package dev.plex.cache;
 
 import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
+import dev.plex.storage.StorageType;
+
 import java.util.Optional;
 import java.util.UUID;
 

server/src/main/java/dev/plex/cache/PlayerCache.java

@@ -2,6 +2,7 @@ package dev.plex.cache;
 
 import com.google.common.collect.Maps;
 import dev.plex.player.PlexPlayer;
+
 import java.util.Map;
 import java.util.UUID;
 

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

@@ -1,38 +1,29 @@
 package dev.plex.command;
 
-import com.google.common.collect.Lists;
 import dev.plex.Plex;
 import dev.plex.cache.DataUtils;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
-import dev.plex.command.exception.CommandFailException;
-import dev.plex.command.exception.ConsoleMustDefinePlayerException;
-import dev.plex.command.exception.ConsoleOnlyException;
-import dev.plex.command.exception.PlayerNotBannedException;
-import dev.plex.command.exception.PlayerNotFoundException;
+import dev.plex.command.exception.*;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
-import java.util.Arrays;
-import java.util.List;
-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.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.World;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandMap;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.command.PluginIdentifiableCommand;
+import org.bukkit.command.*;
 import org.bukkit.entity.Player;
-import org.bukkit.util.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+import java.util.UUID;
+
 /**
  * Superclass for all commands
  */
@@ -70,7 +61,6 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         setName(this.params.name());
         setLabel(this.params.name());
         setDescription(params.description());
-        setPermission(this.perms.permission());
         setUsage(params.usage().replace("<command>", this.params.name()));
         if (params.aliases().split(",").length > 0)
         {
@@ -84,8 +74,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
             {
                 getMap().getKnownCommands().remove(this.getName().toLowerCase());
             }
-            this.getAliases().forEach(s ->
-            {
+            this.getAliases().forEach(s -> {
                 if (getMap().getKnownCommands().containsKey(s.toLowerCase()))
                 {
                     getMap().getKnownCommands().remove(s.toLowerCase());
@@ -177,17 +166,6 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return true;
     }
 
-    @NotNull
-    public abstract List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException;
-
-    @NotNull
-    @Override
-    public List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        List<String> list = smartTabComplete(sender, alias, args);
-        return StringUtil.copyPartialMatches(args[args.length - 1], list, Lists.newArrayList());
-    }
-
     /**
      * Checks if the String given is a matching command
      *
@@ -305,6 +283,47 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return !permission.isEmpty() && player.hasPermission(permission);
     }
 
+/*    *//**
+     * Checks whether a sender has enough permissions or is high enough a rank
+     *
+     * @param sender     The player object
+     * @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
+     * @see Rank
+     *//*
+    protected boolean silentCheckPermission(CommandSender sender, Rank rank, String permission)
+    {
+        if (!isConsole(sender))
+        {
+            return silentCheckPermission((Player) sender, rank, permission);
+        }
+        return true;
+    }
+
+    *//**
+     * Checks whether a player has enough permissions or is high enough a rank
+     *
+     * @param player     The player object
+     * @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
+     * @see Rank
+     *//*
+    protected boolean silentCheckPermission(Player player, Rank rank, String permission)
+    {
+        PlexPlayer plexPlayer = getPlexPlayer(player);
+        if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        {
+            return rank.isAtLeast(Rank.ADMIN) ? plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(rank) : plexPlayer.getRankFromString().isAtLeast(rank);
+        }
+        else if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        {
+            return !permission.isEmpty() && player.hasPermission(permission);
+        }
+        return true;
+    }*/
+
     /**
      * Gets the UUID of the sender
      *

server/src/main/java/dev/plex/command/annotation/CommandPermissions.java

@@ -1,6 +1,7 @@
 package dev.plex.command.annotation;
 
 import dev.plex.command.source.RequiredCommandSource;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 

server/src/main/java/dev/plex/command/blocking/BlockedCommand.java

@@ -1,10 +1,11 @@
 package dev.plex.command.blocking;
 
 import com.google.common.collect.Lists;
-import java.util.List;
 import lombok.Data;
 import net.kyori.adventure.text.Component;
 
+import java.util.List;
+
 @Data
 public class BlockedCommand
 {

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

@@ -1,5 +1,6 @@
 package dev.plex.command.impl;
 
+import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -10,10 +11,9 @@ import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.minimessage.SafeMiniMessage;
 import dev.plex.util.redis.MessageUtil;
-import java.util.Collections;
-import java.util.List;
-import java.util.UUID;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.apache.commons.lang3.BooleanUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
@@ -21,6 +21,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.UUID;
+
 @CommandPermissions(permission = "plex.adminchat", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "adminchat", description = "Talk privately with other admins", usage = "/<command> <message>", aliases = "o,ac,sc,staffchat")
 public class AdminChatCMD extends PlexCommand
@@ -56,10 +58,4 @@ public class AdminChatCMD extends PlexCommand
         MessageUtil.sendStaffChat(sender, SafeMiniMessage.mmDeserialize(message), PlexUtils.adminChat(sender.getName(), prefix, message).toArray(UUID[]::new));
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/AdminworldCMD.java

@@ -4,8 +4,6 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -31,10 +29,4 @@ public class AdminworldCMD extends PlexCommand
         }
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/AdventureCMD.java

@@ -8,7 +8,6 @@ import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.event.GameModeUpdateEvent;
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -17,6 +16,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 @CommandPermissions(permission = "plex.gamemode.adventure", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "adventure", aliases = "gma,egma,eadventure,adventuremode,eadventuremode", description = "Set your own or another player's gamemode to adventure mode")
 public class AdventureCMD extends PlexCommand
@@ -52,7 +53,7 @@ public class AdventureCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         if (silentCheckPermission(sender, "plex.gamemode.adventure.others"))
         {

server/src/main/java/dev/plex/command/impl/BanCMD.java

@@ -1,5 +1,7 @@
 package dev.plex.command.impl;
 
+import com.google.common.collect.ImmutableList;
+import dev.plex.Plex;
 import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
@@ -9,14 +11,7 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
-import dev.plex.util.BungeeUtil;
-import dev.plex.util.PlexLog;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.TimeUtils;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-import java.util.Collections;
-import java.util.List;
+import dev.plex.util.*;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -25,7 +20,11 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandParameters(name = "ban", usage = "/<command> <player> [reason] [-rb]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.List;
+
+@CommandParameters(name = "ban", usage = "/<command> <player> [reason]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
 @CommandPermissions(permission = "plex.ban", source = RequiredCommandSource.ANY)
 
 public class BanCMD extends PlexCommand
@@ -57,27 +56,27 @@ public class BanCMD extends PlexCommand
             String reason;
             Punishment punishment = new Punishment(plexPlayer.getUuid(), getUUID(sender));
             punishment.setType(PunishmentType.BAN);
-            boolean rollBack = false;
             if (args.length > 1)
             {
                 reason = StringUtils.join(args, " ", 1, args.length);
-                String newReason = StringUtils.normalizeSpace(reason.replace("-rb", ""));
-                punishment.setReason(newReason.trim().isEmpty() ? messageString("noReasonProvided") : newReason);
-                rollBack = reason.startsWith("-rb") || reason.endsWith("-rb");
+                punishment.setReason(reason);
             }
             else
             {
-                punishment.setReason(messageString("noReasonProvided"));
+                punishment.setReason("No reason provided.");
             }
             punishment.setPunishedUsername(plexPlayer.getName());
             ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
             punishment.setEndDate(date.plusDays(1));
             punishment.setCustomTime(false);
             punishment.setActive(true);
-            punishment.setIp(player != null ? player.getAddress().getAddress().getHostAddress().trim() : plexPlayer.getIps().get(plexPlayer.getIps().size() - 1));
+            if (player != null)
+            {
+                punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
+            }
             plugin.getPunishmentManager().punish(plexPlayer, punishment);
             PlexUtils.broadcast(messageComponent("banningPlayer", sender.getName(), plexPlayer.getName()));
-            Bukkit.getGlobalRegionScheduler().execute(plugin, () ->
+            Bukkit.getScheduler().runTask(Plex.get(), () ->
             {
                 if (player != null)
                 {
@@ -85,59 +84,14 @@ public class BanCMD extends PlexCommand
                 }
             });
             PlexLog.debug("(From /ban command) PunishedPlayer UUID: " + plexPlayer.getUuid());
-
-            if (rollBack)
-            {
-                /*if (plugin.getPrismHook() != null && plugin.getPrismHook().hasPrism())
-                {
-                    PrismParameters parameters = plugin.getPrismHook().prismApi().createParameters();
-                    parameters.addActionType("block-place");
-                    parameters.addActionType("block-break");
-                    parameters.addActionType("block-burn");
-                    parameters.addActionType("entity-spawn");
-                    parameters.addActionType("entity-kill");
-                    parameters.addActionType("entity-explode");
-                    parameters.addPlayerName(plexPlayer.getName());
-                    parameters.setBeforeTime(Instant.now().toEpochMilli());
-                    parameters.setProcessType(PrismProcessType.ROLLBACK);
-                    final Future<Result> result = plugin.getPrismHook().prismApi().performLookup(parameters, sender);
-                    Bukkit.getAsyncScheduler().runNow(plugin, scheduledTask ->
-                    {
-                        try
-                        {
-                            final Result done = result.get();
-                        }
-                        catch (InterruptedException | ExecutionException e)
-                        {
-                            throw new RuntimeException(e);
-                        }
-                    });
-                }
-                else */
-                if (plugin.getCoreProtectHook() != null && plugin.getCoreProtectHook().hasCoreProtect())
-                {
-                    Bukkit.getAsyncScheduler().runNow(plugin, scheduledTask ->
-                    {
-                        plugin.getCoreProtectHook().coreProtectAPI().performRollback(86400, Collections.singletonList(plexPlayer.getName()), null, null, null, null, 0, null);
-                    });
-                }
-            }
         });
 
         return null;
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
-        if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
-        {
-            return PlexUtils.getPlayerNameList();
-        }
-        if (args.length > 1 && silentCheckPermission(sender, this.getPermission()))
-        {
-            return Collections.singletonList("-rb");
-        }
-        return Collections.emptyList();
+        return args.length == 1 && silentCheckPermission(sender, "plex.ban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/BanListCommand.java

@@ -1,59 +0,0 @@
-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;
-import dev.plex.punishment.Punishment;
-import java.util.List;
-import java.util.stream.Collectors;
-import net.kyori.adventure.text.Component;
-import org.apache.commons.lang3.StringUtils;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-@CommandParameters(name = "banlist", description = "Manages the banlist", usage = "/<command> [purge]")
-@CommandPermissions(permission = "plex.banlist")
-public class BanListCommand extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
-    {
-        if (args.length == 0)
-        {
-            plugin.getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
-            {
-                send(sender, mmString("<gold>Active Bans (" + punishments.size() + "): <yellow>" + StringUtils.join(punishments.stream().map(Punishment::getPunishedUsername).collect(Collectors.toList()), ", ")));
-            });
-            return null;
-        }
-        if (args[0].equalsIgnoreCase("purge") || args[0].equalsIgnoreCase("clear"))
-        {
-            if (sender instanceof Player)
-            {
-                return messageComponent("noPermissionInGame");
-            }
-            if (!sender.getName().equalsIgnoreCase("console"))
-            {
-                if (!checkPermission(sender, "plex.banlist.clear"))
-                {
-                    return null;
-                }
-            }
-            plugin.getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
-            {
-                punishments.forEach(plugin.getPunishmentManager()::unban);
-                send(sender, mmString("<gold>Unbanned " + punishments.size() + " players."));
-            });
-        }
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 && silentCheckPermission(sender, "plex.banlist.clear") ? List.of("purge", "clear") : ImmutableList.of();
-    }
-}

server/src/main/java/dev/plex/command/impl/BcastLoginMessageCMD.java

@@ -1,58 +0,0 @@
-package dev.plex.command.impl;
-
-import com.google.common.collect.ImmutableList;
-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.exception.PlayerNotFoundException;
-import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.meta.PlayerMeta;
-import dev.plex.player.PlexPlayer;
-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;
-
-@CommandPermissions(permission = "plex.broadcastloginmessage", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "bcastloginmessage", usage = "/<command> <player>", description = "Broadcast your login message (for vanish support)", aliases = "bcastlm")
-public class BcastLoginMessageCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length == 0)
-        {
-            return usage();
-        }
-
-        PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
-
-        if (plexPlayer == null)
-        {
-            throw new PlayerNotFoundException();
-        }
-
-        String loginMessage = PlayerMeta.getLoginMessage(plexPlayer);
-        if (!loginMessage.isEmpty())
-        {
-            PlexUtils.broadcast(PlexUtils.stringToComponent(loginMessage));
-            PlexUtils.broadcast(messageComponent("loginMessage", plexPlayer.getName()));
-        }
-        else
-        {
-            return mmString("<red>This player does not have a login message.");
-        }
-
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
-}

server/src/main/java/dev/plex/command/impl/BlockEditCMD.java

@@ -5,10 +5,6 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.listener.impl.BlockListener;
 import dev.plex.util.PlexUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
@@ -98,20 +94,4 @@ public class BlockEditCMD extends PlexCommand
         }
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (silentCheckPermission(sender, this.getPermission()))
-        {
-            List<String> options = new ArrayList<>();
-            if (args.length == 1)
-            {
-                options.addAll(Arrays.asList("list", "purge", "all"));
-                options.addAll(PlexUtils.getPlayerNameList());
-                return options;
-            }
-        }
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/CommandSpyCMD.java

@@ -6,8 +6,6 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -32,10 +30,4 @@ public class CommandSpyCMD extends PlexCommand
         }
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/ConsoleSayCMD.java

@@ -5,8 +5,6 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.util.PlexUtils;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
@@ -29,10 +27,4 @@ public class ConsoleSayCMD extends PlexCommand
         PlexUtils.broadcast(PlexUtils.messageComponent("consoleSayMessage", sender.getName(), PlexUtils.mmStripColor(StringUtils.join(args, " "))));
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/CreativeCMD.java

@@ -8,7 +8,6 @@ import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.event.GameModeUpdateEvent;
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -17,6 +16,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 @CommandPermissions(permission = "plex.gamemode.creative", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "creative", aliases = "gmc,egmc,ecreative,eecreative,creativemode,ecreativemode", description = "Set your own or another player's gamemode to creative mode")
 public class CreativeCMD extends PlexCommand
@@ -55,7 +56,7 @@ public class CreativeCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         if (silentCheckPermission(sender, "plex.gamemode.creative.others"))
         {

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

@@ -8,10 +8,8 @@ import dev.plex.menu.impl.MaterialMenu;
 import dev.plex.util.GameRuleUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.command.Command;
@@ -20,6 +18,11 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.CompletableFuture;
+
 @CommandParameters(name = "pdebug", description = "Plex's debug command", usage = "/<command> <aliases <command> | redis-reset <player> | gamerules>")
 @CommandPermissions(permission = "plex.debug")
 public class DebugCMD extends PlexCommand
@@ -39,9 +42,9 @@ public class DebugCMD extends PlexCommand
                 if (plugin.getRedisConnection().getJedis().exists(player.getUniqueId().toString()))
                 {
                     plugin.getRedisConnection().getJedis().del(player.getUniqueId().toString());
-                    return messageComponent("redisResetSuccessful", player.getName());
+                    return componentFromString("Successfully reset " + player.getName() + "'s Redis punishments!").color(NamedTextColor.YELLOW);
                 }
-                return messageComponent("redisResetPlayerNotFound");
+                return componentFromString("Couldn't find player in Redis punishments.");
             }
         }
         if (args[0].equalsIgnoreCase("gamerules"))
@@ -60,7 +63,7 @@ public class DebugCMD extends PlexCommand
                     PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
                 }
             }
-            return messageComponent("reappliedGamerules");
+            return mmString("<aqua>Re-applied game all the game rules!");
         }
         if (args[0].equalsIgnoreCase("aliases"))
         {
@@ -70,9 +73,9 @@ public class DebugCMD extends PlexCommand
                 Command command = plugin.getServer().getCommandMap().getCommand(commandName);
                 if (command == null)
                 {
-                    return messageComponent("commandNotFound");
+                    return mmString("<red>That command could not be found!");
                 }
-                return messageComponent("commandAliases", commandName, Arrays.toString(command.getAliases().toArray(new String[0])));
+                return mmString("<aqua>Aliases for " + commandName + " are: " + Arrays.toString(command.getAliases().toArray(new String[0])));
             }
         }
         if (args[0].equalsIgnoreCase("pagination"))
@@ -88,8 +91,8 @@ public class DebugCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
-}
+}

server/src/main/java/dev/plex/command/impl/EntityWipeCMD.java

@@ -6,12 +6,6 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
@@ -22,6 +16,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.*;
+
 @CommandPermissions(permission = "plex.entitywipe", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "entitywipe", description = "Remove various server entities that may cause lag, such as dropped items, minecarts, and boats.", usage = "/<command> [entity] [radius]", aliases = "ew,rd")
 public class EntityWipeCMD extends PlexCommand
@@ -110,24 +106,20 @@ public class EntityWipeCMD extends PlexCommand
         return null;
     }
 
-    public @NotNull List<String> smartTabComplete(@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
     {
-        if (silentCheckPermission(sender, this.getPermission()))
+        List<String> entities = new ArrayList<>();
+        for (World world : Bukkit.getWorlds())
         {
-            List<String> entities = new ArrayList<>();
-            for (World world : Bukkit.getWorlds())
+            for (Entity entity : world.getEntities())
             {
-                for (Entity entity : world.getEntities())
+                if (entity.getType() != EntityType.PLAYER)
                 {
-                    if (entity.getType() != EntityType.PLAYER)
-                    {
-                        entities.add(entity.getType().name());
-                    }
+                    entities.add(entity.getType().name());
                 }
             }
-            return entities.stream().toList();
         }
-        return Collections.emptyList();
+        return entities.stream().toList();
     }
 
     private Integer parseInt(CommandSender sender, String string)
@@ -138,7 +130,7 @@ public class EntityWipeCMD extends PlexCommand
         }
         catch (NumberFormatException ex)
         {
-            sender.sendMessage(messageComponent("notANumber", string));
+            sender.sendMessage(mmString("<red>" + string + "<red> is not a valid number!"));
         }
         return null;
     }
@@ -159,4 +151,4 @@ public class EntityWipeCMD extends PlexCommand
         }
         return true;
     }
-}
+}

server/src/main/java/dev/plex/command/impl/FlatlandsCMD.java

@@ -4,8 +4,7 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import java.util.Collections;
-import java.util.List;
+
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -30,10 +29,4 @@ public class FlatlandsCMD extends PlexCommand
         }
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/FreezeCMD.java

@@ -7,17 +7,19 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
+
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-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.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.List;
+
 @CommandParameters(name = "freeze", description = "Freeze a player on the server", usage = "/<command> <player>", aliases = "fr")
 @CommandPermissions(permission = "plex.freeze")
 public class FreezeCMD extends PlexCommand
@@ -40,12 +42,11 @@ public class FreezeCMD extends PlexCommand
         Punishment punishment = new Punishment(punishedPlayer.getUuid(), getUUID(sender));
         punishment.setCustomTime(false);
         ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
-        punishment.setEndDate(date.plusSeconds(plugin.config.getInt("punishments.freeze-timer", 300)));
+        punishment.setEndDate(date.plusMinutes(5));
         punishment.setType(PunishmentType.FREEZE);
         punishment.setPunishedUsername(player.getName());
         punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
         punishment.setReason("");
-        punishment.setActive(true);
 
         plugin.getPunishmentManager().punish(punishedPlayer, punishment);
         PlexUtils.broadcast(messageComponent("frozePlayer", sender.getName(), player.getName()));
@@ -53,8 +54,8 @@ public class FreezeCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, "plex.freeze") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/GamemodeCMD.java

@@ -7,9 +7,6 @@ import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.event.GameModeUpdateEvent;
 import dev.plex.util.PlexUtils;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -18,6 +15,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
 @CommandParameters(name = "gamemode", usage = "/<command> <creative | survival | adventure | default | spectator> [player]", description = "Change your gamemode", aliases = "gm,egamemode,gmt,egmt")
 @CommandPermissions(permission = "plex.gamemode", source = RequiredCommandSource.ANY)
 public class GamemodeCMD extends PlexCommand
@@ -87,7 +88,7 @@ public class GamemodeCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         if (args.length == 1)
         {
@@ -95,10 +96,7 @@ public class GamemodeCMD extends PlexCommand
         }
         if (args.length == 2)
         {
-            if (silentCheckPermission(sender, "plex.gamemode.others"))
-            {
-                return PlexUtils.getPlayerNameList();
-            }
+            return PlexUtils.getPlayerNameList();
         }
         return Collections.emptyList();
     }

server/src/main/java/dev/plex/command/impl/KickCMD.java

@@ -1,6 +1,5 @@
 package dev.plex.command.impl;
 
-import com.google.common.collect.ImmutableList;
 import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
@@ -10,12 +9,10 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
+
 import dev.plex.util.BungeeUtil;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -24,6 +21,9 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
 @CommandParameters(name = "kick", description = "Kicks a player", usage = "/<command> <player>")
 @CommandPermissions(permission = "plex.kick", source = RequiredCommandSource.ANY)
 public class KickCMD extends PlexCommand
@@ -37,7 +37,7 @@ public class KickCMD extends PlexCommand
         }
 
         PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
-        String reason = messageString("noReasonProvided");
+        String reason = "No reason provided";
 
         if (plexPlayer == null)
         {
@@ -67,10 +67,4 @@ public class KickCMD extends PlexCommand
         BungeeUtil.kickPlayer(player, Punishment.generateKickMessage(punishment));
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
-}
+}

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

@@ -5,10 +5,6 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.hook.VaultHook;
-import dev.plex.meta.PlayerMeta;
-import dev.plex.util.PlexUtils;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
@@ -17,7 +13,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandParameters(name = "list", description = "Show a list of all online players", usage = "/<command> [-d | -v]", aliases = "lsit,who,playerlist,online")
+import java.util.Collections;
+import java.util.List;
+
+@CommandParameters(name = "list", description = "Show a list of all online players", usage = "/<command> [-d]", aliases = "lsit,who,playerlist,online")
 @CommandPermissions(permission = "plex.list")
 public class ListCMD extends PlexCommand
 {
@@ -25,17 +24,18 @@ public class ListCMD extends PlexCommand
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
     {
         List<Player> players = Lists.newArrayList(Bukkit.getOnlinePlayers());
-        if (args.length > 0 && args[0].equalsIgnoreCase("-v"))
-        {
-            checkPermission(sender, "plex.list.vanished");
-            players.removeIf(player -> !PlayerMeta.isVanished(player));
-        }
-        else
-        {
-            players.removeIf(PlayerMeta::isVanished);
-        }
         Component list = Component.empty();
-        Component header = PlexUtils.messageComponent(players.size() == 1 ? "listHeader" : "listHeaderPlural", players.size(), Bukkit.getMaxPlayers());
+        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())
+                .append(Component.text(players.size() == 1 ? "player" : "players").color(NamedTextColor.GRAY))
+                .append(Component.space())
+                .append(Component.text("online out of").color(NamedTextColor.GRAY))
+                .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));
         send(sender, header);
         if (players.isEmpty())
         {
@@ -65,11 +65,11 @@ public class ListCMD extends PlexCommand
         return list;
     }
 
-    public @NotNull List<String> smartTabComplete(@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
     {
-        if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
+        if (args.length == 1)
         {
-            return List.of("-d", "-v");
+            return Collections.singletonList("-d");
         }
         return Collections.emptyList();
     }

server/src/main/java/dev/plex/command/impl/LocalSpawnCMD.java

@@ -4,8 +4,7 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import java.util.Collections;
-import java.util.List;
+
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -23,10 +22,4 @@ public class LocalSpawnCMD extends PlexCommand
         playerSender.teleportAsync(playerSender.getWorld().getSpawnLocation());
         return messageComponent("teleportedToWorldSpawn");
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

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

@@ -5,14 +5,16 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
+
 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.util.List;
+
 @CommandParameters(name = "lockup", description = "Lockup a player on the server", usage = "/<command> <player>")
 @CommandPermissions(permission = "plex.lockup")
 public class LockupCMD extends PlexCommand
@@ -37,8 +39,8 @@ public class LockupCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, "plex.lockup") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/MasterbuilderworldCMD.java

@@ -4,8 +4,7 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import java.util.Collections;
-import java.util.List;
+
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -31,10 +30,4 @@ public class MasterbuilderworldCMD extends PlexCommand
         }
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/MobLimitCMD.java

@@ -1,95 +0,0 @@
-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.source.RequiredCommandSource;
-import dev.plex.util.PlexUtils;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import net.kyori.adventure.text.Component;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-@CommandParameters(name = "moblimit", usage = "/<command> [on | off | setmax <limit>]", aliases = "entitylimit", description = "Manages the mob limit per chunk.")
-@CommandPermissions(permission = "plex.moblimit", source = RequiredCommandSource.ANY)
-public class MobLimitCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length == 0)
-        {
-            Chunk chunk = playerSender != null ? playerSender.getLocation().getChunk() : Bukkit.getWorlds().get(0).getChunkAt(0, 0);
-
-            int currentLimit = plugin.config.getInt("entity_limit.max_mobs_per_chunk");
-            int currentMobCount = (int) Arrays.stream(chunk.getEntities())
-                    .filter(entity -> entity instanceof LivingEntity && !(entity instanceof Player))
-                    .count();
-
-            String status = plugin.config.getBoolean("entity_limit.mob_limit_enabled") ? "<green>Enabled" : "<red>Disabled";
-            return PlexUtils.messageComponent("mobLimitStatus", status, currentMobCount, currentLimit, chunk.getX(), chunk.getZ());
-        }
-
-        switch (args[0].toLowerCase())
-        {
-            case "on":
-                plugin.config.set("entity_limit.mob_limit_enabled", true);
-                plugin.config.save();
-                return PlexUtils.messageComponent("mobLimitToggle", "enabled");
-            case "off":
-                plugin.config.set("entity_limit.mob_limit_enabled", false);
-                plugin.config.save();
-                return PlexUtils.messageComponent("mobLimitToggle", "disabled");
-            case "setmax":
-                try
-                {
-                    if (args.length != 2) return usage();
-
-                    int newLimit = Integer.parseInt(args[1]);
-                    if (newLimit < 0) throw new NumberFormatException();
-
-                    int limitCeiling = plugin.config.getInt("entity_limit.mob_limit_ceiling");
-                    if (newLimit > limitCeiling)
-                    {
-                        newLimit = limitCeiling;
-                        sender.sendMessage(PlexUtils.messageComponent("mobLimitCeiling"));
-                    }
-
-                    plugin.config.set("entity_limit.max_mobs_per_chunk", newLimit);
-                    plugin.config.save();
-                    return PlexUtils.messageComponent("mobLimitSet", newLimit);
-                }
-                catch (NumberFormatException e)
-                {
-                    return PlexUtils.messageComponent("unableToParseNumber", args[1]);
-                }
-            default:
-                return usage();
-        }
-    }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (silentCheckPermission(sender, this.getPermission()))
-        {
-            if (args.length == 1)
-            {
-                return Arrays.asList("on", "off", "setmax");
-            }
-            if (args.length == 2 && args[0].equals("setmax"))
-            {
-                return Collections.emptyList();
-            }
-            return Collections.emptyList();
-        }
-        return Collections.emptyList();
-    }
-}

server/src/main/java/dev/plex/command/impl/MobPurgeCMD.java

@@ -4,118 +4,50 @@ 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.util.PlexLog;
+
 import dev.plex.util.PlexUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
-import org.apache.commons.lang3.text.WordUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Mob;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.HashMap;
+
 @CommandPermissions(permission = "plex.mobpurge", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "mobpurge", description = "Purge all mobs.", usage = "/<command> [mob]", aliases = "mp")
+@CommandParameters(name = "mobpurge", description = "Purge all mobs.", usage = "/<command>", aliases = "mp")
 public class MobPurgeCMD extends PlexCommand
 {
-    private final List<EntityType> MOB_TYPES = new ArrayList<>();
-
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
     {
-        EntityType type = null;
-        String mobName = null;
-        if (args.length > 0)
-        {
-            try
-            {
-                type = EntityType.valueOf(args[0].toUpperCase());
-            }
-            catch (Exception e)
-            {
-                PlexLog.debug("A genius tried and failed removing the following invalid mob: " + args[0].toUpperCase());
-                send(sender, messageComponent("notAValidMob"));
-                return null;
-            }
-            if (!MOB_TYPES.contains(type))
-            {
-                PlexLog.debug(Arrays.deepToString(MOB_TYPES.toArray()));
-                PlexLog.debug("A genius tried to remove a mob that doesn't exist: " + args[0].toUpperCase());
-                sender.sendMessage(messageComponent("notAValidMobButValidEntity"));
-                return null;
-            }
-        }
-        if (type != null)
-        {
-            mobName = WordUtils.capitalizeFully(type.name().replace("_", " "));
-            PlexLog.debug("The args aren't null so the mob is: " + mobName);
-        }
-        int count = purgeMobs(type);
-        if (type != null)
-        {
-            PlexUtils.broadcast(messageComponent("removedEntitiesOfTypes", sender.getName(), count, mobName));
-            PlexLog.debug("All " + count + " of " + mobName + " were removed");
-        }
-        else
-        {
-            PlexUtils.broadcast(messageComponent("removedMobs", sender.getName(), count));
-            PlexLog.debug("All " + count + " valid mobs were removed");
-        }
-        sender.sendMessage(messageComponent("amountOfMobsRemoved", count, (type != null ? mobName : "mob") + multipleS(count)));
-        return null;
-    }
+        HashMap<String, Integer> entityCounts = new HashMap<>();
 
-    private String multipleS(int count)
-    {
-        return (count == 1 ? "" : "s");
-    }
-
-    private int purgeMobs(EntityType type)
-    {
-        int removed = 0;
         for (World world : Bukkit.getWorlds())
         {
-            for (Entity entity : world.getLivingEntities())
+            for (Entity entity : world.getEntities())
             {
-                if (entity instanceof LivingEntity && !(entity instanceof Player))
+                if (entity instanceof Mob)
                 {
-                    if (type != null && !entity.getType().equals(type))
-                    {
-                        continue;
-                    }
+                    String type = entity.getType().name();
                     entity.remove();
-                    removed++;
+
+                    entityCounts.put(type, entityCounts.getOrDefault(type, 0) + 1);
                 }
             }
         }
-        return removed;
-    }
 
-    private List<String> getAllMobs()
-    {
-        List<String> mobs = new ArrayList<>();
-        Arrays.stream(EntityType.values()).filter(EntityType::isAlive).filter(EntityType::isSpawnable).forEach(MOB_TYPES::add);
-        for (EntityType entityType : MOB_TYPES)
-        {
-            mobs.add(entityType.name());
-        }
-        return mobs;
-    }
+        int entityCount = entityCounts.values().stream().mapToInt(a -> a).sum();
 
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
-        {
-            return getAllMobs();
-        }
-        return Collections.emptyList();
+        PlexUtils.broadcast(messageComponent("removedMobs", sender.getName(), entityCount));
+
+        /*entityCounts.forEach((entityName, numRemoved) -> {
+            sender.sendMessage(messageComponent("removedEntitiesOfType", sender.getName(), numRemoved, entityName));
+        });*/
+        return null;
     }
 }

server/src/main/java/dev/plex/command/impl/MuteCMD.java

@@ -7,17 +7,19 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
+
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-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.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.List;
+
 @CommandParameters(name = "mute", description = "Mute a player on the server", usage = "/<command> <player>", aliases = "stfu")
 @CommandPermissions(permission = "plex.mute")
 public class MuteCMD extends PlexCommand
@@ -37,7 +39,7 @@ public class MuteCMD extends PlexCommand
             return messageComponent("playerMuted");
         }
 
-        if (silentCheckPermission(player, "plex.mute"))
+        if (silentCheckPermission(player,"plex.mute"))
         {
             send(sender, messageComponent("higherRankThanYou"));
             return null;
@@ -46,12 +48,11 @@ public class MuteCMD extends PlexCommand
         Punishment punishment = new Punishment(punishedPlayer.getUuid(), getUUID(sender));
         punishment.setCustomTime(false);
         ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
-        punishment.setEndDate(date.plusSeconds(plugin.config.getInt("punishments.mute-timer", 300)));
+        punishment.setEndDate(date.plusMinutes(5));
         punishment.setType(PunishmentType.MUTE);
         punishment.setPunishedUsername(player.getName());
         punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
         punishment.setReason("");
-        punishment.setActive(true);
 
         plugin.getPunishmentManager().punish(punishedPlayer, punishment);
         PlexUtils.broadcast(messageComponent("mutedPlayer", sender.getName(), player.getName()));
@@ -59,8 +60,8 @@ public class MuteCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender,"plex.mute") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/NotesCMD.java

@@ -6,15 +6,11 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.extra.Note;
+
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicReference;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
@@ -22,6 +18,13 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
 @CommandParameters(name = "notes", description = "Manage notes for a player", usage = "/<command> <player> <list | add <note> | remove <id> | clear>")
 @CommandPermissions(permission = "plex.notes")
 public class NotesCMD extends PlexCommand
@@ -122,11 +125,11 @@ public class NotesCMD extends PlexCommand
 
     private void readNotes(@NotNull CommandSender sender, PlexPlayer plexPlayer, List<Note> notes)
     {
-        AtomicReference<Component> noteList = new AtomicReference<>(messageComponent("notesHeader", plexPlayer.getName()));
+        AtomicReference<Component> noteList = new AtomicReference<>(Component.text("Player notes for: " + plexPlayer.getName()).color(NamedTextColor.GREEN));
         for (Note note : notes)
         {
-            Component noteLine = messageComponent("notePrefix", note.getId(), DataUtils.getPlayer(note.getWrittenBy()).getName(), TimeUtils.useTimezone(note.getTimestamp()));
-            noteLine = noteLine.append(messageComponent("noteLine", note.getNote()));
+            Component noteLine = mmString("<gold><!italic>" + note.getId() + " - Written by: " + DataUtils.getPlayer(note.getWrittenBy()).getName() + " on " + TimeUtils.useTimezone(note.getTimestamp()));
+            noteLine = noteLine.append(mmString("<newline><yellow># " + note.getNote()));
             noteList.set(noteList.get().append(Component.newline()));
             noteList.set(noteList.get().append(noteLine));
         }
@@ -134,20 +137,16 @@ public class NotesCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
-        if (silentCheckPermission(sender, this.getPermission()))
+        if (args.length == 1)
         {
-            if (args.length == 1)
-            {
-                return PlexUtils.getPlayerNameList();
-            }
-            if (args.length == 2)
-            {
-                return Arrays.asList("list", "add", "remove", "clear");
-            }
-            return Collections.emptyList();
+            return PlexUtils.getPlayerNameList();
+        }
+        if (args.length == 2)
+        {
+            return Arrays.asList("list", "add", "remove", "clear");
         }
         return Collections.emptyList();
     }
-}
+}

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

@@ -10,10 +10,6 @@ import dev.plex.module.PlexModuleFile;
 import dev.plex.util.BuildInfo;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -23,6 +19,11 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
 @CommandPermissions(source = RequiredCommandSource.ANY)
 @CommandParameters(name = "plex", usage = "/<command> [reload | redis | modules [reload]]", description = "Show information about Plex or reload it")
 public class PlexCMD extends PlexCommand
@@ -34,7 +35,7 @@ public class PlexCMD extends PlexCommand
         if (args.length == 0)
         {
             send(sender, mmString("<light_purple>Plex - A new freedom plugin."));
-            send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion() + " #" + BuildInfo.getNumber() + " <light_purple>Git: <gold>" + BuildInfo.getCommit()));
+            send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion() + " #" + BuildInfo.getNumber() + " <light_purple>Git: <gold>" + BuildInfo.getHead()));
             send(sender, mmString("<light_purple>Authors: <gold>Telesphoreo, Taahh"));
             send(sender, mmString("<light_purple>Built by: <gold>" + BuildInfo.getAuthor() + " <light_purple>on <gold>" + BuildInfo.getDate()));
             send(sender, mmString("<light_purple>Run <gold>/plex modules <light_purple>to see a list of modules."));
@@ -125,7 +126,7 @@ public class PlexCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         if (args.length == 1)
         {

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

@@ -7,11 +7,11 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.PlayerNotFoundException;
 import dev.plex.command.source.RequiredCommandSource;
+
 import dev.plex.menu.impl.PunishedPlayerMenu;
 import dev.plex.menu.impl.PunishmentMenu;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
@@ -20,6 +20,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 @CommandParameters(name = "punishments", usage = "/<command> [player]", description = "Opens the Punishments GUI", aliases = "punishlist,punishes")
 @CommandPermissions(permission = "plex.punishments", source = RequiredCommandSource.IN_GAME)
 public class PunishmentsCMD extends PlexCommand
@@ -48,8 +50,8 @@ public class PunishmentsCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/RawSayCMD.java

@@ -4,9 +4,8 @@ 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.util.PlexUtils;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
@@ -29,10 +28,4 @@ public class RawSayCMD extends PlexCommand
         PlexUtils.broadcast(StringUtils.join(args, " "));
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/RemoveLoginMessageCMD.java

@@ -1,14 +1,11 @@
 package dev.plex.command.impl;
 
-import com.google.common.collect.ImmutableList;
 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.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
-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;
@@ -54,17 +51,4 @@ public class RemoveLoginMessageCMD extends PlexCommand
         }
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (args.length == 1)
-        {
-            if (silentCheckPermission(sender, "plex.removeloginmessage.others"))
-            {
-                return List.of("-o");
-            }
-        }
-        return args.length == 2 && silentCheckPermission(sender, "plex.removeloginmessage.others") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
 }

server/src/main/java/dev/plex/command/impl/SayCMD.java

@@ -4,9 +4,8 @@ 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.util.PlexUtils;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
@@ -29,10 +28,4 @@ public class SayCMD extends PlexCommand
         PlexUtils.broadcast(PlexUtils.messageComponent("sayMessage", sender.getName(), PlexUtils.mmStripColor(StringUtils.join(args, " "))));
         return null;
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return Collections.emptyList();
-    }
 }

server/src/main/java/dev/plex/command/impl/SetLoginMessageCMD.java

@@ -1,6 +1,5 @@
 package dev.plex.command.impl;
 
-import com.google.common.collect.ImmutableList;
 import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
@@ -10,9 +9,7 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -56,18 +53,20 @@ public class SetLoginMessageCMD extends PlexCommand
                 validateMessage(message);
                 plexPlayer.setLoginMessage(message);
                 return messageComponent("setOtherPlayersLoginMessage", plexPlayer.getName(),
-                        MiniMessage.miniMessage().serialize(PlexUtils.stringToComponent(message.replace("%player%", plexPlayer.getName()))));
+                        message.replace("%player%", plexPlayer.getName()));
             }
             if (isConsole(sender))
             {
                 return messageComponent("noPermissionConsole");
             }
             PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayer(playerSender.getUniqueId());
-            String message = StringUtils.join(args, " ", 0, args.length)
-                    .replace(plexPlayer.getName(), "%player%");
+            String message = StringUtils.join(args, " ", 0, args.length);
+            message = message.replace(plexPlayer.getName(), "%player%");
+            message = PlexUtils.legacyToMiniString(message);
             validateMessage(message);
             plexPlayer.setLoginMessage(message);
-            return messageComponent("setOwnLoginMessage", PlexUtils.stringToComponent(message.replace("%player%", plexPlayer.getName())));
+            return messageComponent("setOwnLoginMessage",
+                    message.replace("%player%", plexPlayer.getName()));
         }
         return null;
     }
@@ -80,17 +79,4 @@ public class SetLoginMessageCMD extends PlexCommand
             throw new CommandFailException(messageString("nameRequired"));
         }
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (args.length == 1)
-        {
-            if (silentCheckPermission(sender, "plex.setloginmessage"))
-            {
-                return List.of("-o");
-            }
-        }
-        return args.length == 2 && args[0].equalsIgnoreCase("-o") && silentCheckPermission(sender, "plex.setloginmessage") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
 }

server/src/main/java/dev/plex/command/impl/SmiteCMD.java

@@ -7,13 +7,11 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
+
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.title.Title;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -25,6 +23,11 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+
 @CommandPermissions(permission = "plex.smite", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "smite", usage = "/<command> <player> [reason] [-ci | -q]", description = "Someone being a little bitch? Smite them down...")
 public class SmiteCMD extends PlexCommand
@@ -76,16 +79,21 @@ public class SmiteCMD extends PlexCommand
         final Player player = getNonNullPlayer(args[0]);
         final PlexPlayer plexPlayer = getPlexPlayer(player);
 
-        Title title = Title.title(messageComponent("smiteTitleHeader"), messageComponent("smiteTitleMessage", reason, sender.getName()));
+        Title title = Title.title(Component.text("You've been smitten.").color(NamedTextColor.RED), Component.text("Be sure to follow the rules!").color(NamedTextColor.YELLOW));
         player.showTitle(title);
 
         if (!silent)
         {
-            PlexUtils.broadcast(messageComponent("smiteBroadcast", player.getName(), reason != null ? reason : messageString("noReasonProvided"), sender.getName()));
+            PlexUtils.broadcast(mmString("<red>" + player.getName() + " has been a naughty, naughty boy."));
+            if (reason != null)
+            {
+                PlexUtils.broadcast(mmString("  <red>Reason: " + "<yellow>" + reason));
+            }
+            PlexUtils.broadcast(mmString("  <red>Smitten by: " + "<yellow>" + sender.getName()));
         }
         else
         {
-            send(sender, messageComponent("smittenQuietly", player.getName()));
+            send(sender, "Smitten " + player.getName() + " quietly.");
         }
 
         // Set gamemode to survival
@@ -122,18 +130,18 @@ public class SmiteCMD extends PlexCommand
         if (reason != null)
         {
             punishment.setReason(reason);
+            send(player, mmString("<red>You've been smitten. Reason: <yellow>" + reason));
         }
-        send(player, messageComponent("smitten", reason != null ? reason : messageString("noReasonProvided")));
         return null;
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
-        if (silentCheckPermission(sender, this.getPermission()) && args.length == 1)
+        if (silentCheckPermission(sender,"plex.smite") && args.length == 1)
         {
             return PlexUtils.getPlayerNameList();
         }
         return Collections.emptyList();
     }
-}
+}

server/src/main/java/dev/plex/command/impl/SpectatorCMD.java

@@ -7,8 +7,8 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.event.GameModeUpdateEvent;
+
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -17,6 +17,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 @CommandPermissions(permission = "plex.gamemode.spectator", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "spectator", aliases = "gmsp,egmsp,spec", description = "Set your own or another player's gamemode to spectator mode")
 public class SpectatorCMD extends PlexCommand
@@ -54,7 +56,7 @@ public class SpectatorCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         if (silentCheckPermission(sender,"plex.gamemode.spectator.others"))
         {

server/src/main/java/dev/plex/command/impl/SurvivalCMD.java

@@ -7,8 +7,8 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.event.GameModeUpdateEvent;
+
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -17,6 +17,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 @CommandPermissions(permission = "plex.gamemode.survival", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "survival", aliases = "gms,egms,esurvival,survivalmode,esurvivalmode", description = "Set your own or another player's gamemode to survival mode")
 public class SurvivalCMD extends PlexCommand
@@ -55,7 +57,7 @@ public class SurvivalCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         if (silentCheckPermission(sender,"plex.gamemode.survival.others"))
         {

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

@@ -6,10 +6,9 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
+
 import dev.plex.util.PlexUtils;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import dev.plex.util.minimessage.SafeMiniMessage;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
@@ -48,15 +47,16 @@ public class TagCMD extends PlexCommand
             {
                 return usage("/tag set <prefix>");
             }
+            String prefix = PlexUtils.legacyToMiniString(StringUtils.join(args, " ", 1, args.length));
 
-            Component convertedComponent = PlexUtils.stringToComponent(StringUtils.join(args, " ", 1, args.length));
+            Component convertedComponent = SafeMiniMessage.mmDeserializeWithoutEvents(prefix);
 
             if (PlainTextComponentSerializer.plainText().serialize(convertedComponent).length() > plugin.config.getInt("chat.max-tag-length", 16))
             {
                 return messageComponent("maximumPrefixLength", plugin.config.getInt("chat.max-tag-length", 16));
             }
 
-            player.setPrefix(MiniMessage.miniMessage().serialize(convertedComponent));
+            player.setPrefix(prefix);
             DataUtils.update(player);
             return messageComponent("prefixSetTo", MiniMessage.miniMessage().serialize(convertedComponent));
         }
@@ -80,7 +80,7 @@ public class TagCMD extends PlexCommand
                 DataUtils.update(player);
                 return messageComponent("prefixCleared");
             }
-            checkPermission(sender, "plex.tag.clear.others");
+            checkPermission(sender,"plex.tag.clear.others");
             Player target = getNonNullPlayer(args[1]);
             PlexPlayer plexTarget = DataUtils.getPlayer(target.getUniqueId());
             plexTarget.setPrefix(null);
@@ -89,26 +89,6 @@ public class TagCMD extends PlexCommand
         }
         return usage();
     }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (args.length == 1)
-        {
-            return Arrays.asList("set", "clear");
-        }
-        if (args.length == 2)
-        {
-            if (args[0].equalsIgnoreCase("clear"))
-            {
-                if (silentCheckPermission(sender, "plex.tag.clear.others"))
-                {
-                    return PlexUtils.getPlayerNameList();
-                }
-            }
-        }
-        return Collections.emptyList();
-    }
 }
 
 

server/src/main/java/dev/plex/command/impl/TempbanCMD.java

@@ -10,12 +10,10 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
+
 import dev.plex.util.BungeeUtil;
-import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -24,7 +22,9 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandParameters(name = "tempban", usage = "/<command> <player> <time> [reason] [-rb]", description = "Temporarily ban a player")
+import java.util.List;
+
+@CommandParameters(name = "tempban", usage = "/<command> <player> <time> [reason]", description = "Temporarily ban a player")
 @CommandPermissions(permission = "plex.tempban", source = RequiredCommandSource.ANY)
 
 public class TempbanCMD extends PlexCommand
@@ -52,17 +52,14 @@ public class TempbanCMD extends PlexCommand
         }
         Punishment punishment = new Punishment(target.getUuid(), getUUID(sender));
         punishment.setType(PunishmentType.TEMPBAN);
-        boolean rollBack = false;
         if (args.length > 2)
         {
             reason = StringUtils.join(args, " ", 2, args.length);
-            String newReason = StringUtils.normalizeSpace(reason.replace("-nrb", ""));
-            punishment.setReason(newReason.trim().isEmpty() ? messageString("noReasonProvided") : newReason);
-            rollBack = reason.startsWith("-rb") || reason.endsWith("-rb");
+            punishment.setReason(reason);
         }
         else
         {
-            punishment.setReason(messageString("noReasonProvided"));
+            punishment.setReason("No reason provided.");
         }
         punishment.setPunishedUsername(target.getName());
         punishment.setEndDate(TimeUtils.createDate(args[1]));
@@ -78,46 +75,12 @@ public class TempbanCMD extends PlexCommand
         {
             BungeeUtil.kickPlayer(player, Punishment.generateBanMessage(punishment));
         }
-        if (rollBack)
-        {
-                /*if (plugin.getPrismHook().hasPrism()) {
-                    PrismParameters parameters = plugin.getPrismHook().prismApi().createParameters();
-                    parameters.addActionType("block-place");
-                    parameters.addActionType("block-break");
-                    parameters.addActionType("block-burn");
-                    parameters.addActionType("entity-spawn");
-                    parameters.addActionType("entity-kill");
-                    parameters.addActionType("entity-explode");
-                    parameters.addPlayerName(plexPlayer.getName());
-                    parameters.setBeforeTime(Instant.now().toEpochMilli());
-                    parameters.setProcessType(PrismProcessType.ROLLBACK);
-                    final Future<Result> result = plugin.getPrismHook().prismApi().performLookup(parameters, sender);
-                    Bukkit.getAsyncScheduler().runNow(plugin, scheduledTask -> {
-                        try
-                        {
-                            final Result done = result.get();
-                        } catch (InterruptedException | ExecutionException e)
-                        {
-                            throw new RuntimeException(e);
-                        }
-                    });
-                }
-                else */
-            if (plugin.getCoreProtectHook() != null && plugin.getCoreProtectHook().hasCoreProtect())
-            {
-                PlexLog.debug("Testing coreprotect");
-                Bukkit.getAsyncScheduler().runNow(plugin, scheduledTask ->
-                {
-                    plugin.getCoreProtectHook().coreProtectAPI().performRollback(86400, Collections.singletonList(target.getName()), null, null, null, null, 0, null);
-                });
-            }
-        }
         return null;
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender,"plex.tempban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/TempmuteCMD.java

@@ -1,91 +0,0 @@
-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;
-import dev.plex.player.PlexPlayer;
-import dev.plex.punishment.Punishment;
-import dev.plex.punishment.PunishmentType;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.TimeUtils;
-import java.time.ZonedDateTime;
-import java.util.Arrays;
-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;
-
-@CommandParameters(name = "tempmute", description = "Temporarily mute a player on the server",
-        usage = "/<command> <player> <time> [reason]", aliases = "tmute")
-@CommandPermissions(permission = "plex.tempmute")
-public class TempmuteCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length < 2)
-        {
-            return usage();
-        }
-
-        Player player = getNonNullPlayer(args[0]);
-        PlexPlayer punishedPlayer = getOfflinePlexPlayer(player.getUniqueId());
-
-        if (punishedPlayer.isMuted())
-        {
-            return messageComponent("playerMuted");
-        }
-
-        if (silentCheckPermission(player, "plex.tempmute"))
-        {
-            send(sender, messageComponent("higherRankThanYou"));
-            return null;
-        }
-
-        ZonedDateTime endDate;
-        try
-        {
-            endDate = TimeUtils.createDate(args[1]);
-        }
-        catch (NumberFormatException e)
-        {
-            return messageComponent("invalidTimeFormat");
-        }
-
-        if (endDate.isBefore(ZonedDateTime.now()))
-        {
-            return messageComponent("timeMustBeFuture");
-        }
-
-        ZonedDateTime oneWeekFromNow = ZonedDateTime.now().plusWeeks(1);
-        if (endDate.isAfter(oneWeekFromNow))
-        {
-            return messageComponent("maxTimeExceeded");
-        }
-
-        final String reason = args.length >= 3 ? String.join(" ", Arrays.copyOfRange(args, 2, args.length))
-                : messageString("noReasonProvided");
-
-        Punishment punishment = new Punishment(punishedPlayer.getUuid(), getUUID(sender));
-        punishment.setCustomTime(true);
-        punishment.setEndDate(endDate);
-        punishment.setType(PunishmentType.MUTE);
-        punishment.setPunishedUsername(player.getName());
-        punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
-        punishment.setReason(reason);
-        punishment.setActive(true);
-
-        plugin.getPunishmentManager().punish(punishedPlayer, punishment);
-        PlexUtils.broadcast(messageComponent("tempMutedPlayer", sender.getName(), player.getName(), TimeUtils.formatRelativeTime(endDate)));
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
-}

server/src/main/java/dev/plex/command/impl/ToggleCMD.java

@@ -6,8 +6,8 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.menu.impl.ToggleMenu;
+
 import dev.plex.util.PlexUtils;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.command.CommandSender;
@@ -15,6 +15,8 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 @CommandParameters(name = "toggle", description = "Allows toggling various server aspects through a GUI", aliases = "toggles")
 @CommandPermissions(permission = "plex.toggle", source = RequiredCommandSource.ANY)
 public class ToggleCMD extends PlexCommand
@@ -31,8 +33,6 @@ public class ToggleCMD extends PlexCommand
                 sender.sendMessage(PlexUtils.mmDeserialize("<gray>  - Fluidspread" + status("fluidspread")));
                 sender.sendMessage(PlexUtils.mmDeserialize("<gray>  - Drops" + status("drops")));
                 sender.sendMessage(PlexUtils.mmDeserialize("<gray>  - Redstone" + status("redstone")));
-                sender.sendMessage(PlexUtils.mmDeserialize("<gray>  - PVP" + status("pvp")));
-                sender.sendMessage(PlexUtils.mmDeserialize("<gray>  - Chat" + status("chat")));
                 return null;
             }
             switch (args[0].toLowerCase())
@@ -53,15 +53,6 @@ public class ToggleCMD extends PlexCommand
                 {
                     return toggle("redstone");
                 }
-                case "pvp" ->
-                {
-                    return toggle("pvp");
-                }
-                case "chat" ->
-                {
-                    PlexUtils.broadcast(PlexUtils.messageComponent("chatToggled", sender.getName(), plugin.toggles.getBoolean("chat") ? "off" : "on"));
-                    return toggle("chat");
-                }
                 default ->
                 {
                     return messageComponent("invalidToggle");
@@ -73,9 +64,9 @@ public class ToggleCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 
     private String status(String toggle)

server/src/main/java/dev/plex/command/impl/UnbanCMD.java

@@ -9,14 +9,16 @@ import dev.plex.command.exception.PlayerNotBannedException;
 import dev.plex.command.exception.PlayerNotFoundException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
+
 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.util.List;
+
 @CommandParameters(name = "unban", usage = "/<command> <player>", description = "Unbans a player, offline or online")
 @CommandPermissions(permission = "plex.ban", source = RequiredCommandSource.ANY)
 
@@ -54,8 +56,8 @@ public class UnbanCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender,"plex.unban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/UnfreezeCMD.java

@@ -1,22 +1,21 @@
 package dev.plex.command.impl;
 
 import com.google.common.collect.ImmutableList;
-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.exception.CommandFailException;
-import dev.plex.command.exception.PlayerNotFoundException;
 import dev.plex.player.PlexPlayer;
-import dev.plex.punishment.PunishmentType;
+
 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.util.List;
+
 @CommandPermissions(permission = "plex.unfreeze")
 @CommandParameters(name = "unfreeze", description = "Unfreeze a player", usage = "/<command> <player>")
 public class UnfreezeCMD extends PlexCommand
@@ -28,28 +27,20 @@ public class UnfreezeCMD extends PlexCommand
         {
             return usage();
         }
-        PlexPlayer punishedPlayer = DataUtils.getPlayer(args[0]);
-        if (punishedPlayer == null)
-        {
-            throw new PlayerNotFoundException();
-        }
-
+        Player player = getNonNullPlayer(args[0]);
+        PlexPlayer punishedPlayer = getOfflinePlexPlayer(player.getUniqueId());
         if (!punishedPlayer.isFrozen())
         {
             throw new CommandFailException(PlexUtils.messageString("playerNotFrozen"));
         }
         punishedPlayer.setFrozen(false);
-        punishedPlayer.getPunishments().stream().filter(punishment -> punishment.getType() == PunishmentType.FREEZE && punishment.isActive()).forEach(punishment -> {
-            punishment.setActive(false);
-            plugin.getSqlPunishment().updatePunishment(punishment.getType(), false, punishment.getPunished());
-        });
-        PlexUtils.broadcast(messageComponent("unfrozePlayer", sender.getName(), punishedPlayer.getName()));
+        PlexUtils.broadcast(messageComponent("unfrozePlayer", sender.getName(), player.getName()));
         return null;
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender,"plex.unfreeze") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/UnmuteCMD.java

@@ -1,22 +1,21 @@
 package dev.plex.command.impl;
 
 import com.google.common.collect.ImmutableList;
-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.exception.CommandFailException;
-import dev.plex.command.exception.PlayerNotFoundException;
 import dev.plex.player.PlexPlayer;
-import dev.plex.punishment.PunishmentType;
+
 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.util.List;
+
 @CommandPermissions(permission = "plex.unmute")
 @CommandParameters(name = "unmute", description = "Unmute a player", usage = "/<command> <player>")
 public class UnmuteCMD extends PlexCommand
@@ -28,28 +27,20 @@ public class UnmuteCMD extends PlexCommand
         {
             return usage();
         }
-        PlexPlayer punishedPlayer = DataUtils.getPlayer(args[0]);
-        if (punishedPlayer == null)
-        {
-            throw new PlayerNotFoundException();
-        }
-
+        Player player = getNonNullPlayer(args[0]);
+        PlexPlayer punishedPlayer = getOfflinePlexPlayer(player.getUniqueId());
         if (!punishedPlayer.isMuted())
         {
             throw new CommandFailException(PlexUtils.messageString("playerNotMuted"));
         }
         punishedPlayer.setMuted(false);
-        punishedPlayer.getPunishments().stream().filter(punishment -> punishment.getType() == PunishmentType.MUTE && punishment.isActive()).forEach(punishment -> {
-            punishment.setActive(false);
-            plugin.getSqlPunishment().updatePunishment(punishment.getType(), false, punishment.getPunished());
-        });
-        PlexUtils.broadcast(messageComponent("unmutedPlayer", sender.getName(), punishedPlayer.getName()));
+        PlexUtils.broadcast(messageComponent("unmutedPlayer", sender.getName(), player.getName()));
         return null;
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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 args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender,"plex.unfreeze") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/WhoHasCMD.java

@@ -4,9 +4,6 @@ import com.google.common.collect.ImmutableList;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.JoinConfiguration;
 import net.kyori.adventure.text.TextComponent;
@@ -17,6 +14,9 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+import java.util.List;
+
 @CommandPermissions(permission = "plex.whohas")
 @CommandParameters(name = "whohas", description = "Returns a list of players with a specific item in their inventory.", usage = "/<command> <material>", aliases = "wh")
 public class WhoHasCMD extends PlexCommand
@@ -36,43 +36,17 @@ public class WhoHasCMD extends PlexCommand
             return messageComponent("materialNotFound", args[0]);
         }
 
-        boolean clearInventory = args.length > 1 && args[1].equalsIgnoreCase("clear");
+        final List<TextComponent> players = Bukkit.getOnlinePlayers().stream().filter(player ->
+                player.getInventory().contains(material)).map(player -> Component.text(player.getName())).toList();
 
-        if (clearInventory && !sender.hasPermission("plex.whohas.clear"))
-        {
-            return messageComponent("noPermissionNode", "plex.whohas.clear");
-        }
-
-        List<TextComponent> players = Bukkit.getOnlinePlayers().stream().filter(player ->
-                player.getInventory().contains(material)).map(player -> {
-            if (clearInventory)
-            {
-                player.getInventory().remove(material);
-                player.updateInventory();
-            }
-            return Component.text(player.getName());
-        }).toList();
-
-        return players.isEmpty() ?
-                messageComponent("nobodyHasThatMaterial") :
-                (clearInventory ?
-                        messageComponent("playersMaterialCleared", Component.text(material.name()),
-                                Component.join(JoinConfiguration.commas(true), players)) :
-                        messageComponent("playersWithMaterial", Component.text(material.name()),
-                                Component.join(JoinConfiguration.commas(true), players)));
+        return players.isEmpty() ? messageComponent("nobodyHasThatMaterial") :
+                messageComponent("playersWithMaterial", Component.text(material.name()),
+                        Component.join(JoinConfiguration.commas(true), players));
     }
 
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
-        if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
-        {
-            return Arrays.stream(Material.values()).map(Enum::name).toList();
-        }
-        else if (args.length == 2 && silentCheckPermission(sender, "plex.whohas.clear"))
-        {
-            return Collections.singletonList("clear");
-        }
-        return ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, "plex.whohas") ? Arrays.stream(Material.values()).map(Enum::name).toList() : ImmutableList.of();
     }
 }

server/src/main/java/dev/plex/command/impl/WorldCMD.java

@@ -6,9 +6,7 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
-import java.util.List;
-import java.util.UUID;
-import java.util.regex.Pattern;
+
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
@@ -17,6 +15,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+import java.util.UUID;
+import java.util.regex.Pattern;
+
 @CommandPermissions(permission = "plex.world", source = RequiredCommandSource.IN_GAME)
 @CommandParameters(name = "world", description = "Teleport to a world.", usage = "/<command> <world>")
 public class WorldCMD extends PlexCommand
@@ -36,18 +38,19 @@ public class WorldCMD extends PlexCommand
         boolean playerWorld = args[0].matches("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
         if (playerWorld && Plex.get().getModuleManager().getModules().stream().anyMatch(plexModule -> plexModule.getPlexModuleFile().getName().equalsIgnoreCase("Module-TFMExtras")))
         {
-            checkPermission(playerSender, "plex.world.playerworlds");
+            checkPermission(playerSender,"plex.world.playerworlds");
         }
         playerSender.teleportAsync(world.getSpawnLocation());
         return messageComponent("playerWorldTeleport", world.getName());
     }
 
+
     @Override
-    public @NotNull List<String> smartTabComplete(@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
     {
         final List<String> completions = Lists.newArrayList();
         final Player player = (Player) sender;
-        if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
+        if (args.length == 1)
         {
             @NotNull List<World> worlds = Bukkit.getWorlds();
             for (World world : worlds)
@@ -57,7 +60,7 @@ public class WorldCMD extends PlexCommand
                 try
                 {
                     final UUID uuid = UUID.fromString(worldName);
-                    if (uuid.equals(player.getUniqueId()) || silentCheckPermission(player, "plex.world.playerworlds"))
+                    if (uuid.equals(player.getUniqueId()) || silentCheckPermission(player,"plex.world.playerworlds"))
                     {
                         completions.add(worldName);
                     }

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

@@ -2,10 +2,11 @@ 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

server/src/main/java/dev/plex/config/ModuleConfig.java

@@ -1,11 +1,12 @@
 package dev.plex.config;
 
 import dev.plex.module.PlexModule;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.YamlConfiguration;
 
 /**
  * Creates a custom Config object

server/src/main/java/dev/plex/hook/CoreProtectHook.java

@@ -1,52 +0,0 @@
-package dev.plex.hook;
-
-import dev.plex.Plex;
-import dev.plex.util.PlexLog;
-import net.coreprotect.CoreProtect;
-import net.coreprotect.CoreProtectAPI;
-import org.bukkit.plugin.Plugin;
-
-public class CoreProtectHook
-{
-    private CoreProtectAPI coreProtectAPI;
-    private boolean hasApi;
-
-    public CoreProtectHook(Plex plex)
-    {
-        Plugin plugin = plex.getServer().getPluginManager().getPlugin("CoreProtect");
-
-        // Check that CoreProtect is loaded
-        if (!(plugin instanceof CoreProtect))
-        {
-            PlexLog.debug("Plugin was not CoreProtect.");
-            return;
-        }
-
-        // Check that the API is enabled
-        CoreProtectAPI coreProtectAPI = ((CoreProtect) plugin).getAPI();
-        this.hasApi = coreProtectAPI.isEnabled();
-        if (!hasApi)
-        {
-            PlexLog.debug("CoreProtect API was disabled.");
-            return;
-        }
-
-        // Check that a compatible version of the API is loaded
-        if (coreProtectAPI.APIVersion() < 9)
-        {
-            PlexLog.debug("CoreProtect API version is: {0}", coreProtectAPI.APIVersion());
-            return;
-        }
-        this.coreProtectAPI = coreProtectAPI;
-        this.coreProtectAPI.testAPI();
-    }
-
-    public boolean hasCoreProtect() {
-        return hasApi;
-    }
-
-    public CoreProtectAPI coreProtectAPI()
-    {
-        return coreProtectAPI;
-    }
-}

server/src/main/java/dev/plex/hook/PrismHook.java

@@ -1,34 +0,0 @@
-package dev.plex.hook;
-
-import dev.plex.Plex;
-import network.darkhelmet.prism.api.PrismApi;
-import org.bukkit.plugin.Plugin;
-
-public class PrismHook
-{
-    private PrismApi prismApi;
-
-    public PrismHook(Plex plex)
-    {
-        Plugin plugin = plex.getServer().getPluginManager().getPlugin("Prism");
-
-        // Check that Prism is loaded
-        if (!plugin.isEnabled())
-        {
-            return;
-        }
-
-        // Check that the API is enabled
-        this.prismApi = (PrismApi) plugin;
-    }
-
-    public boolean hasPrism() {
-        return prismApi != null;
-    }
-
-    public PrismApi prismApi()
-    {
-        return prismApi;
-    }
-}
-

server/src/main/java/dev/plex/hook/VaultHook.java

@@ -4,7 +4,6 @@ import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.minimessage.SafeMiniMessage;
-import java.util.UUID;
 import net.kyori.adventure.text.Component;
 import net.milkbowl.vault.chat.Chat;
 import net.milkbowl.vault.permission.Permission;
@@ -12,6 +11,8 @@ import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.plugin.RegisteredServiceProvider;
 
+import java.util.UUID;
+
 public class VaultHook
 {
     private static Chat CHAT;
@@ -81,8 +82,8 @@ public class VaultHook
         if (vaultPrefix == null || vaultPrefix.isEmpty()) {
             return Component.empty();
         }
-        PlexLog.debug("prefix: {0}", SafeMiniMessage.mmSerializeWithoutEvents(PlexUtils.stringToComponent(vaultPrefix)).replace("<", "\\<"));
-        return PlexUtils.stringToComponent(vaultPrefix);
+        PlexLog.debug("prefix: {0}", PlexUtils.legacyToMiniString(vaultPrefix).replace("<", "\\<"));
+        return SafeMiniMessage.mmDeserializeWithoutEvents(PlexUtils.legacyToMiniString(vaultPrefix));
     }
 
     public static Permission getPermission()

server/src/main/java/dev/plex/listener/impl/AntiNukerListener.java

@@ -2,13 +2,14 @@ package dev.plex.listener.impl;
 
 import dev.plex.listener.PlexListener;
 import dev.plex.services.impl.TimingService;
-import dev.plex.util.PlexUtils;
-import java.util.UUID;
+import net.kyori.adventure.text.Component;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 
+import java.util.UUID;
+
 public class AntiNukerListener extends PlexListener
 {
     @EventHandler(priority = EventPriority.HIGH)
@@ -18,7 +19,7 @@ public class AntiNukerListener extends PlexListener
         if (getCount(event.getPlayer().getUniqueId()) > 200L)
         {
             TimingService.strikes.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
-            event.getPlayer().kick(PlexUtils.messageComponent("nukerKickMessage"));
+            event.getPlayer().kick(Component.text("Please turn off your nuker!"));
             event.setCancelled(true);
         }
     }
@@ -30,7 +31,7 @@ public class AntiNukerListener extends PlexListener
         if (getCount(event.getPlayer().getUniqueId()) > 200L)
         {
             TimingService.strikes.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
-            event.getPlayer().kick(PlexUtils.messageComponent("nukerKickMessage"));
+            event.getPlayer().kick(Component.text("Please turn off your nuker!"));
             event.setCancelled(true);
         }
     }

server/src/main/java/dev/plex/listener/impl/AntiSpamListener.java

@@ -2,13 +2,15 @@ package dev.plex.listener.impl;
 
 import dev.plex.listener.PlexListener;
 import dev.plex.services.impl.TimingService;
-import dev.plex.util.PlexUtils;
 import io.papermc.paper.event.player.AsyncChatEvent;
-import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 
+import java.util.UUID;
+
 public class AntiSpamListener extends PlexListener
 {
     @EventHandler
@@ -17,7 +19,7 @@ public class AntiSpamListener extends PlexListener
         TimingService.spamCooldown.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
         if (getCount(event.getPlayer().getUniqueId()) > 8L)
         {
-            event.getPlayer().sendMessage(PlexUtils.messageComponent("antiSpamMessage"));
+            event.getPlayer().sendMessage(Component.text("Please refrain from spamming messages.").color(NamedTextColor.GRAY));
             event.setCancelled(true);
         }
     }
@@ -28,7 +30,7 @@ public class AntiSpamListener extends PlexListener
         TimingService.spamCooldown.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
         if (getCount(event.getPlayer().getUniqueId()) > 8L)
         {
-            event.getPlayer().sendMessage(PlexUtils.messageComponent("antiSpamMessage"));
+            event.getPlayer().sendMessage(Component.text("Please refrain from spamming commands.").color(NamedTextColor.GRAY));
             event.setCancelled(true);
         }
     }

server/src/main/java/dev/plex/listener/impl/BanListener.java

@@ -7,8 +7,6 @@ import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentManager;
 import dev.plex.punishment.PunishmentType;
-import dev.plex.util.PlexLog;
-import it.unimi.dsi.fastutil.Pair;
 import org.bukkit.Bukkit;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
@@ -45,26 +43,11 @@ public class BanListener extends PlexListener
 
         if (plugin.getPunishmentManager().isBanned(event.getUniqueId()))
         {
-            if (Plex.get().getPermissions() != null && Plex.get().getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass"))
-            {
-                return;
-            }
+            if (Plex.get().getPermissions() != null && Plex.get().getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass")) return;
             PlexPlayer player = DataUtils.getPlayer(event.getUniqueId());
             player.getPunishments().stream().filter(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive()).findFirst().ifPresent(punishment ->
                     event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
                             Punishment.generateBanMessage(punishment)));
-            return;
-        }
-        Punishment ipBannedPunishment = plugin.getPunishmentManager().getBanByIP(event.getAddress().getHostAddress());
-        if (ipBannedPunishment != null)
-        {
-            // Don't check if the other account that's banned has bypass abilities, check if current has only
-            if (Plex.get().getPermissions() != null && Plex.get().getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass"))
-            {
-                return;
-            }
-            event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    Punishment.generateBanMessage(ipBannedPunishment));
         }
     }
 }

server/src/main/java/dev/plex/listener/impl/BlockListener.java

@@ -2,9 +2,6 @@ package dev.plex.listener.impl;
 
 import dev.plex.listener.PlexListener;
 import dev.plex.util.PlexUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
@@ -14,6 +11,10 @@ import org.bukkit.event.EventPriority;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 public class BlockListener extends PlexListener
 {
     private static final List<Material> blockedBlocks = new ArrayList<>();

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

@@ -10,13 +10,9 @@ import dev.plex.util.minimessage.SafeMiniMessage;
 import dev.plex.util.redis.MessageUtil;
 import io.papermc.paper.chat.ChatRenderer;
 import io.papermc.paper.event.player.AsyncChatEvent;
-
-import java.util.UUID;
-import java.util.function.BiConsumer;
-import java.util.function.Supplier;
-
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
 import net.kyori.adventure.text.TextReplacementConfig;
 import net.kyori.adventure.text.event.ClickEvent;
 import net.kyori.adventure.text.format.NamedTextColor;
@@ -25,8 +21,13 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.UUID;
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+
 @Toggleable("chat.enabled")
-public class ChatListener extends PlexListener {
+public class ChatListener extends PlexListener
+{
     public static final TextReplacementConfig URL_REPLACEMENT_CONFIG = TextReplacementConfig
             .builder()
             .match("(https?|ftp|file)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]")
@@ -38,24 +39,27 @@ public class ChatListener extends PlexListener {
     public static BiConsumer<AsyncChatEvent, PlexPlayer> PRE_RENDERER = ChatListener::defaultChatProcessing;
     private final PlexChatRenderer renderer = new PlexChatRenderer();
 
-    private static final Component format = SafeMiniMessage.mmDeserialize(plugin.config.getString("chat.format"));
-
     @EventHandler(priority = EventPriority.LOWEST)
-    public void onChat(AsyncChatEvent event) {
+    public void onChat(AsyncChatEvent event)
+    {
         PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(event.getPlayer().getUniqueId());
-        if (plexPlayer.isStaffChat()) {
+        if (plexPlayer.isStaffChat())
+        {
             String prefix = PlexUtils.mmSerialize(VaultHook.getPrefix(event.getPlayer())); // Don't use PlexPlayer#getPrefix because that returns their custom set prefix and not their group's
             MessageUtil.sendStaffChat(event.getPlayer(), event.message(), PlexUtils.adminChat(event.getPlayer().getName(), prefix, SafeMiniMessage.mmSerialize(event.message())).toArray(UUID[]::new));
-            plugin.getServer().getConsoleSender().sendMessage(PlexUtils.messageComponent("adminChatFormat", event.getPlayer().getName(), prefix, SafeMiniMessage.mmSerialize(event.message().replaceText(URL_REPLACEMENT_CONFIG))));
+            plugin.getServer().getConsoleSender().sendMessage(PlexUtils.messageComponent("adminChatFormat", event.getPlayer().getName(), prefix, PlexUtils.legacyToMiniString(SafeMiniMessage.mmSerializeWithoutEvents(event.message()))).replaceText(URL_REPLACEMENT_CONFIG));
             event.setCancelled(true);
             return;
         }
         Component prefix = PlayerMeta.getPrefix(plexPlayer);
 
-        if (prefix != null && !prefix.equals(Component.empty()) && !prefix.equals(Component.space())) {
+        if (prefix != null && !prefix.equals(Component.empty()) && !prefix.equals(Component.space()))
+        {
             renderer.hasPrefix = true;
             renderer.prefix = prefix;
-        } else {
+        }
+        else
+        {
             renderer.hasPrefix = false;
             renderer.prefix = null;
         }
@@ -65,40 +69,43 @@ public class ChatListener extends PlexListener {
         event.renderer(renderer);
     }
 
-    public static class PlexChatRenderer implements ChatRenderer {
+    public static class PlexChatRenderer implements ChatRenderer
+    {
         public boolean hasPrefix;
         public Component prefix;
         public Supplier<Component> before = null;
 
         @Override
-        public @NotNull Component render(@NotNull Player source, @NotNull Component sourceDisplayName, @NotNull Component message, @NotNull Audience viewer) {
-            Component component = format;
+        public @NotNull Component render(@NotNull Player source, @NotNull Component sourceDisplayName, @NotNull Component message, @NotNull Audience viewer)
+        {
+            Component component = Component.empty();
 
-            if (before != null) {
+            if (before != null)
+            {
                 component = component.append(before.get());
             }
-
-            // Substitute the prefix from the config
-            if (hasPrefix) {
-                component = component.replaceText(TextReplacementConfig.builder().matchLiteral("{prefix}").replacement(prefix).build());
+            if (hasPrefix)
+            {
+                component = component.append(prefix).append(Component.space());
             }
-
-            // Substitute the display name from the config
-            component = component.replaceText(TextReplacementConfig.builder().matchLiteral("{name}")
-                    .replacement(sourceDisplayName).build());
-
-            // Substitute the message from the config
-            component = component.replaceText(TextReplacementConfig.builder().matchLiteral("{message}").replacement(message).build());
-
-            // Fix links not being clickable
-            component = component.replaceText(URL_REPLACEMENT_CONFIG);
-
-            return component;
+            return component
+                    .append(Component.empty())
+                    .append(
+                            source.name().equals(sourceDisplayName) ?
+                                    SafeMiniMessage.mmDeserialize(plugin.config.getString("chat.name-color") + SafeMiniMessage.mmSerialize(sourceDisplayName))
+                                    : SafeMiniMessage.mmDeserialize(plugin.config.getString("chat.name-color")).append(sourceDisplayName)
+                    )
+                    .append(Component.space())
+                    .append(Component.text("»").color(NamedTextColor.GRAY))
+                    .append(Component.space())
+                    .append(message)
+                    .replaceText(URL_REPLACEMENT_CONFIG);
         }
     }
 
-    private static void defaultChatProcessing(AsyncChatEvent event, PlexPlayer plexPlayer) {
-        String text = PlexUtils.getTextFromComponent(event.message());
-        event.message(PlexUtils.stringToComponent(text));
+    private static void defaultChatProcessing(AsyncChatEvent event, PlexPlayer plexPlayer)
+    {
+        String text = PlexUtils.legacyToMiniString(PlexUtils.getTextFromComponent(event.message()));
+        event.message(SafeMiniMessage.mmDeserializeWithoutEvents(text));
     }
 }

server/src/main/java/dev/plex/listener/impl/CommandListener.java

@@ -5,12 +5,9 @@ import dev.plex.cache.DataUtils;
 import dev.plex.command.blocking.BlockedCommand;
 import dev.plex.listener.PlexListener;
 import dev.plex.player.PlexPlayer;
+
 import dev.plex.services.impl.CommandBlockerService;
 import dev.plex.util.PlexLog;
-import java.util.Locale;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.apache.commons.lang3.StringUtils;
@@ -20,6 +17,11 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 public class CommandListener extends PlexListener
 {
     @EventHandler(priority = EventPriority.HIGHEST)

server/src/main/java/dev/plex/listener/impl/MobListener.java

@@ -3,7 +3,6 @@ package dev.plex.listener.impl;
 import dev.plex.listener.PlexListener;
 import dev.plex.util.BlockUtils;
 import dev.plex.util.PlexUtils;
-import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
@@ -12,7 +11,6 @@ import org.bukkit.entity.Ageable;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.LivingEntity;
 import org.bukkit.event.Event;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -37,7 +35,14 @@ public class MobListener extends PlexListener
         EntityType eggType;
         try
         {
-            eggType = EntityType.valueOf(mat.name().substring(0, mat.name().length() - 10));
+            if (mat == Material.MOOSHROOM_SPAWN_EGG)
+            {
+                eggType = EntityType.MUSHROOM_COW;
+            }
+            else
+            {
+                eggType = EntityType.valueOf(mat.name().substring(0, mat.name().length() - 10));
+            }
         }
         catch (IllegalArgumentException ignored)
         {
@@ -49,10 +54,7 @@ public class MobListener extends PlexListener
     @EventHandler
     public void onEntitySpawn(EntitySpawnEvent event)
     {
-        if (event.isCancelled())
-        {
-            return;
-        }
+        if (event.isCancelled()) return;
         if (event.getEntity().getEntitySpawnReason() == CreatureSpawnEvent.SpawnReason.SPAWNER_EGG)
         {
             // for the future, we can instead filter and restrict nbt tags right here.
@@ -68,17 +70,6 @@ public class MobListener extends PlexListener
             Collection<Player> coll = location.getNearbyEntitiesByType(Player.class, 10);
             PlexUtils.disabledEffectMultiple(coll.toArray(new Player[coll.size()]), location); // dont let intellij auto correct toArray to an empty array (for efficiency)
         }
-
-        if (plugin.config.getBoolean("entity_limit.mob_limit_enabled"))
-        {
-            Location location = event.getLocation();
-            Chunk chunk = location.getChunk();
-
-            if (isEntityLimitReached(chunk, plugin.config.getInt("entity_limit.max_mobs_per_chunk")))
-            {
-                event.setCancelled(true);
-            }
-        }
     }
 
     @EventHandler
@@ -102,10 +93,7 @@ public class MobListener extends PlexListener
     @EventHandler(priority = EventPriority.HIGH)
     public void onEntityClick(PlayerInteractEntityEvent event)
     {
-        if (event.isCancelled())
-        {
-            return;
-        }
+        if (event.isCancelled()) return;
         Material handItem = event.getPlayer().getEquipment().getItem(event.getHand()).getType();
         if (event.getRightClicked() instanceof Ageable entity)
         {
@@ -127,14 +115,8 @@ public class MobListener extends PlexListener
     @EventHandler(priority = EventPriority.HIGH)
     public void onPlayerInteract(PlayerInteractEvent event)
     {
-        if (event.useItemInHand() == Event.Result.DENY)
-        {
-            return;
-        }
-        if (event.useInteractedBlock() == Event.Result.DENY)
-        {
-            return;
-        }
+        if (event.useItemInHand() == Event.Result.DENY) return;
+        if (event.useInteractedBlock() == Event.Result.DENY) return;
         if (event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK)
         {
             if (SPAWN_EGGS.contains(event.getMaterial()))
@@ -153,11 +135,4 @@ public class MobListener extends PlexListener
             }
         }
     }
-
-    public static boolean isEntityLimitReached(Chunk chunk, int limit)
-    {
-        return Arrays.stream(chunk.getEntities())
-                .filter(entity -> entity instanceof LivingEntity && !(entity instanceof Player))
-                .count() >= limit;
-    }
 }

server/src/main/java/dev/plex/listener/impl/MuteListener.java

@@ -4,13 +4,14 @@ import dev.plex.listener.PlexListener;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import io.papermc.paper.event.player.AsyncChatEvent;
-import java.util.List;
 import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 
+import java.util.List;
+
 public class MuteListener extends PlexListener
 {
     List<String> commands = plugin.commands.getStringList("block_on_mute");

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

@@ -6,7 +6,9 @@ import dev.plex.meta.PlayerMeta;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
-import java.util.List;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -16,7 +18,9 @@ import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
-public class PlayerListener extends PlexListener
+import java.util.List;
+
+public class PlayerListener<T> extends PlexListener
 {
     // setting up a player's data
     @EventHandler(priority = EventPriority.HIGHEST)
@@ -59,18 +63,20 @@ public class PlayerListener extends PlexListener
         }
 
         String loginMessage = PlayerMeta.getLoginMessage(plexPlayer);
-        if (!loginMessage.isEmpty() && !PlayerMeta.isVanished(player))
+        if (!loginMessage.isEmpty())
         {
-            PlexUtils.broadcast(PlexUtils.stringToComponent(loginMessage));
+            PlexUtils.broadcast(loginMessage);
         }
 
         plexPlayer.loadNotes();
 
         plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
         {
+            String plural = notes.size() == 1 ? "note." : "notes.";
             if (!notes.isEmpty())
             {
-                PlexUtils.broadcastToAdmins(PlexUtils.messageComponent(notes.size() == 1 ? "playerNoteAlert" : "playerNoteAlertPlural", plexPlayer.getName(), notes.size()), "plex.notes.notify");
+                PlexUtils.broadcastToAdmins(Component.text(plexPlayer.getName() + " has " + notes.size() + " " + plural).color(NamedTextColor.GOLD), "plex.notes.notify");
+                PlexUtils.broadcastToAdmins(Component.text("Click to view their " + plural).clickEvent(ClickEvent.runCommand("/notes " + plexPlayer.getName() + " list")).color(NamedTextColor.GOLD), "plex.notes.notify");
             }
         });
     }
@@ -90,7 +96,7 @@ public class PlayerListener extends PlexListener
         PlexPlayer player = DataUtils.getPlayer(event.getPlayer().getUniqueId());
         if (player.isLockedUp())
         {
-            Bukkit.getGlobalRegionScheduler().runDelayed(plugin, (scheduledTask) -> event.getPlayer().openInventory(event.getInventory()), 1L);
+            Bukkit.getScheduler().runTaskLater(plugin, () -> event.getPlayer().openInventory(event.getInventory()), 1L);
         }
     }
 

server/src/main/java/dev/plex/listener/impl/ServerListener.java

@@ -4,11 +4,13 @@ import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
 import dev.plex.listener.PlexListener;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.RandomUtil;
-import java.util.concurrent.atomic.AtomicReference;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.event.EventHandler;
 
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
 public class ServerListener extends PlexListener
 {
     @EventHandler
@@ -32,7 +34,6 @@ public class ServerListener extends PlexListener
         {
             event.motd(PlexUtils.mmDeserialize(baseMotd.trim()));
         }
-        /* - Broken on 1.20.6
         if (plugin.config.contains("server.sample"))
         {
             List<String> samples = plugin.config.getStringList("server.sample");
@@ -41,6 +42,6 @@ public class ServerListener extends PlexListener
                 event.getPlayerSample().clear();
                 event.getPlayerSample().addAll(samples.stream().map(string -> string.replace("&", "§")).map(Bukkit::createProfile).toList());
             }
-        }*/
+        }
     }
 }

server/src/main/java/dev/plex/listener/impl/SignListener.java

@@ -0,0 +1,22 @@
+package dev.plex.listener.impl;
+
+import dev.plex.listener.PlexListener;
+import dev.plex.util.PlexUtils;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.SignChangeEvent;
+
+public class SignListener extends PlexListener
+{
+    private static final LegacyComponentSerializer LEGACY_COMPONENT_SERIALIZER = LegacyComponentSerializer.legacyAmpersand();
+
+    @EventHandler(priority = EventPriority.LOW)
+    public void onSignEdit(SignChangeEvent event)
+    {
+        for (int i = 0; i < event.lines().size(); i++)
+        {
+            event.line(i, LEGACY_COMPONENT_SERIALIZER.deserialize(PlexUtils.getTextFromComponent(event.line(i))));
+        }
+    }
+}

server/src/main/java/dev/plex/listener/impl/TogglesListener.java

@@ -1,31 +1,16 @@
 package dev.plex.listener.impl;
 
-import dev.plex.Plex;
 import dev.plex.listener.PlexListener;
-import dev.plex.util.PlexUtils;
-import io.papermc.paper.event.player.AsyncChatEvent;
-import io.papermc.paper.event.player.PrePlayerAttackEntityEvent;
-import java.util.List;
-import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.ThrownPotion;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.BlockExplodeEvent;
 import org.bukkit.event.block.BlockFromToEvent;
 import org.bukkit.event.block.BlockRedstoneEvent;
 import org.bukkit.event.entity.EntityExplodeEvent;
 import org.bukkit.event.entity.ExplosionPrimeEvent;
-import org.bukkit.event.entity.PotionSplashEvent;
-import org.bukkit.event.entity.ProjectileHitEvent;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.projectiles.ProjectileSource;
 
 public class TogglesListener extends PlexListener
 {
-    List<String> commands = plugin.commands.getStringList("block_on_mute");
-
     @EventHandler
     public void onExplosionPrime(ExplosionPrimeEvent event)
     {
@@ -37,8 +22,7 @@ public class TogglesListener extends PlexListener
     }
 
     @EventHandler
-    public void onBlockExplode(BlockExplodeEvent event)
-    {
+    public void onBlockExplode(BlockExplodeEvent event) {
         if (!plugin.toggles.getBoolean("explosions"))
         {
             event.getBlock().breakNaturally();
@@ -74,100 +58,6 @@ public class TogglesListener extends PlexListener
         }
     }
 
-    @EventHandler
-    public void onChat(AsyncChatEvent event)
-    {
-        Player player = event.getPlayer();
-        if (!plugin.toggles.getBoolean("chat") && !Plex.get().getPermissions().has(player, "plex.mute.bypass"))
-        {
-            event.getPlayer().sendMessage(PlexUtils.messageComponent("chatIsOff"));
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler
-    public void onCommand(PlayerCommandPreprocessEvent event)
-    {
-        Player player = event.getPlayer();
-        if (!plugin.toggles.getBoolean("chat") && !Plex.get().getPermissions().has(player, "plex.mute.bypass"))
-        {
-            String message = event.getMessage();
-            message = message.replaceAll("\\s.*", "").replaceFirst("/", "");
-            if (commands.contains(message.toLowerCase()))
-            {
-                event.getPlayer().sendMessage(PlexUtils.messageComponent("chatIsOff"));
-                event.setCancelled(true);
-                return;
-            }
-
-            for (String command : commands)
-            {
-                Command cmd = Bukkit.getCommandMap().getCommand(command);
-                if (cmd == null)
-                {
-                    return;
-                }
-                if (cmd.getAliases().contains(message.toLowerCase()))
-                {
-                    event.getPlayer().sendMessage(PlexUtils.messageComponent("chatIsOff"));
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-
-    }
-
-    @EventHandler
-    public void onPlayerAttack(PrePlayerAttackEntityEvent event)
-    {
-        if (!plugin.toggles.getBoolean("pvp"))
-        {
-            if (event.getAttacked() instanceof Player)
-            {
-                event.setCancelled(true);
-
-                event.getPlayer().sendMessage(PlexUtils.messageComponent("pvpDisabled"));
-            }
-        }
-    }
-
-    @EventHandler
-    public void onPotionSplash(PotionSplashEvent event)
-    {
-        if (!plugin.toggles.getBoolean("pvp"))
-        {
-            ProjectileSource shooter = event.getEntity().getShooter();
-            if (shooter instanceof Player)
-            {
-                ThrownPotion potion = event.getPotion();
-                if (potion.getEffects().stream().anyMatch(effect -> effect.getType().getName().startsWith("HARM") ||
-                        effect.getType().getName().startsWith("POISON")) &&
-                        event.getAffectedEntities().stream().anyMatch(entity -> entity instanceof Player))
-                {
-
-                    event.setCancelled(true);
-                    ((Player) shooter).sendMessage(PlexUtils.messageComponent("pvpDisabled"));
-                }
-            }
-        }
-    }
-
-    @EventHandler
-    public void onProjectileHit(ProjectileHitEvent event)
-    {
-        if (!plugin.toggles.getBoolean("pvp"))
-        {
-            ProjectileSource shooter = event.getEntity().getShooter();
-            if (shooter instanceof Player && event.getHitEntity() instanceof Player)
-            {
-                event.setCancelled(true);
-
-                ((Player) shooter).sendMessage(PlexUtils.messageComponent("pvpDisabled"));
-            }
-        }
-    }
-
     /* I have no idea if this is the best way to do this
     There is a very weird bug where if you try to create a loop using two repeaters and a lever, after disabling
     and re-enabling redstone, you are unable to recreate the loop with a lever. Using a redstone torch works fine.

server/src/main/java/dev/plex/listener/impl/VanishListener.java

@@ -1,32 +0,0 @@
-package dev.plex.listener.impl;
-
-import de.myzelyam.api.vanish.PlayerShowEvent;
-import dev.plex.cache.DataUtils;
-import dev.plex.listener.PlexListener;
-import dev.plex.meta.PlayerMeta;
-import dev.plex.player.PlexPlayer;
-import dev.plex.util.PlexUtils;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-
-public class VanishListener extends PlexListener
-{
-    @EventHandler(priority = EventPriority.MONITOR)
-    public void onPlayerUnvanish(PlayerShowEvent event)
-    {
-        if (!PlexUtils.hasVanishPlugin())
-        {
-            return;
-        }
-        if (event.isSilent())
-        {
-            return;
-        }
-        PlexPlayer plexPlayer = DataUtils.getPlayer(event.getPlayer().getUniqueId());
-        String loginMessage = PlayerMeta.getLoginMessage(plexPlayer);
-        if (!loginMessage.isEmpty())
-        {
-            PlexUtils.broadcast(PlexUtils.stringToComponent(loginMessage));
-        }
-    }
-}

server/src/main/java/dev/plex/listener/impl/WorldListener.java

@@ -1,8 +1,8 @@
 package dev.plex.listener.impl;
 
 import dev.plex.listener.PlexListener;
-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.minimessage.MiniMessage;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
@@ -17,11 +17,10 @@ import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntitySpawnEvent;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.event.player.PlayerInteractEntityEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerItemDamageEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.player.*;
+
+import java.util.Arrays;
+import java.util.List;
 
 public class WorldListener extends PlexListener
 {
@@ -113,8 +112,7 @@ public class WorldListener extends PlexListener
             boolean isFaweCommand = command instanceof PluginIdentifiableCommand && ((PluginIdentifiableCommand) command).getPlugin().equals(Bukkit.getPluginManager().getPlugin("FastAsyncWorldEdit"));
             if (isWeCommand || isFaweCommand || EDIT_COMMANDS.contains(message.toLowerCase()))
             {
-                String noEdit = plugin.config.getString("worlds." + event.getPlayer().getWorld().getName().toLowerCase() + ".modification.message");
-                event.getPlayer().sendMessage(MiniMessage.miniMessage().deserialize(noEdit));
+                event.getPlayer().sendMessage(Component.text("You do not have permission to use that command in this world.").color(NamedTextColor.RED));
                 event.setCancelled(true);
             }
         }
@@ -185,4 +183,4 @@ public class WorldListener extends PlexListener
         }
         return false;
     }
-}
+}

server/src/main/java/dev/plex/menu/AbstractMenu.java

@@ -2,7 +2,6 @@ package dev.plex.menu;
 
 import com.google.common.collect.Maps;
 import dev.plex.util.minimessage.SafeMiniMessage;
-import java.util.Map;
 import lombok.Getter;
 import lombok.experimental.Accessors;
 import net.kyori.adventure.text.Component;
@@ -12,6 +11,13 @@ import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryView;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.Map;
+
+/**
+ * @author Taah
+ * @since 6:49 AM [02-09-2023]
+ */
+
 @Getter
 @Accessors(fluent = true)
 public abstract class AbstractMenu

server/src/main/java/dev/plex/menu/impl/MaterialMenu.java

@@ -3,11 +3,16 @@ package dev.plex.menu.impl;
 import dev.plex.menu.AbstractMenu;
 import dev.plex.menu.pagination.PageableMenu;
 import dev.plex.util.item.ItemBuilder;
-import java.util.Arrays;
-import java.util.List;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Taah
+ * @since 8:44 AM [02-09-2023]
+ */
 public class MaterialMenu extends PageableMenu<Material>
 {
     public MaterialMenu()

server/src/main/java/dev/plex/menu/impl/PunishedPlayerMenu.java

@@ -7,10 +7,11 @@ import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.util.TimeUtils;
 import dev.plex.util.item.ItemBuilder;
-import java.util.List;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.List;
+
 public class PunishedPlayerMenu extends PageableMenu<Punishment>
 {
     private final PlexPlayer punishedPlayer;
@@ -25,7 +26,7 @@ public class PunishedPlayerMenu extends PageableMenu<Punishment>
     @Override
     protected ItemStack toItem(Punishment object)
     {
-        return new ItemBuilder(Material.PAPER).displayName("<!italic><red>" + object.getType().name()).lore("<!italic><red>By: <gold>" + (object.getPunisher() == null ? "CONSOLE" : Plex.get().getSqlPlayerData().getNameByUUID(object.getPunisher())), "<!italic><red>Expire(d/s): <gold>" + TimeUtils.useTimezone(object.getEndDate()), "<!italic><red>Reason: <gold>" + object.getReason()).build();
+        return new ItemBuilder(Material.PAPER).displayName("<!italic><red>" + object.getType().name()).lore("<!italic><red>By: <gold>" + (object.getPunisher() == null ? "CONSOLE" : Plex.get().getSqlPlayerData().getNameByUUID(object.getPunished())), "<!italic><red>Expire(d/s): <gold>" + TimeUtils.useTimezone(object.getEndDate()), "<!italic><red>Reason: <gold>" + object.getReason()).build();
     }
 
     @Override