Release Plex v1.4

* Implemented the ability to toggle pvp

* Changed listener to  PrePlayerAttackEntityEvent

* ... Updated the formatting so I don't get screamed at !

* _

Jenkinsfile

@@ -14,6 +14,7 @@ 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

@@ -1,72 +0,0 @@
-plugins {
-    id "java"
-    id "maven-publish"
-    id "com.github.johnrengelman.shadow" version "8.1.1"
-}
-
-group = "dev.plex"
-version = "1.3"
-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

@@ -0,0 +1,91 @@
+plugins {
+    id("java")
+    id("maven-publish")
+    id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.8"
+    id("net.kyori.blossom") version "2.1.0"
+    id("io.github.goooler.shadow") version "8.1.7"
+}
+
+group = "dev.plex"
+version = "1.4"
+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 = "io.github.goooler.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(17))
+    }
+
+    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.create<Copy>("copyJars") {
+    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,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
 networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -83,10 +83,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+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
@@ -133,10 +131,13 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -144,7 +145,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +153,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -197,11 +198,15 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

proxy/build.gradle.kts

@@ -1,7 +1,3 @@
-plugins {
-    id("net.kyori.blossom") version "1.3.1"
-}
-
 group = rootProject.group
 version = rootProject.version
 description = "Plex-Velocity"
@@ -24,8 +20,14 @@ tasks {
     }
 }
 
-blossom {
-    replaceToken("@version@", rootProject.version)
+sourceSets {
+    main {
+        blossom {
+            javaSources {
+                property("version", project.version.toString())
+            }
+        }
+    }
 }
 
 publishing {
@@ -37,9 +39,9 @@ publishing {
 }
 
 dependencies {
-    compileOnly("org.projectlombok:lombok:1.18.28")
-    annotationProcessor("org.projectlombok:lombok:1.18.28")
-    compileOnly("org.json:json:20230618")
+    compileOnly("org.projectlombok:lombok:1.18.32")
+    annotationProcessor("org.projectlombok:lombok:1.18.32")
+    compileOnly("org.json:json:20240303")
     compileOnly("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT")
     annotationProcessor("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT")
 }

proxy/src/main/java-templates/dev/plex/BuildParameters.java.peb

@@ -0,0 +1,5 @@
+package dev.plex;
+
+class BuildParameters {
+    public static final String VERSION = "{{ version }}";
+}

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

@@ -28,7 +28,7 @@ import java.util.logging.Logger;
 @Plugin(
         name = "Plex",
         id = "plex",
-        version = "@version@",
+        version = BuildParameters.VERSION,
         url = "https://plex.us.org",
         description = "Plex provides a new experience for freedom servers.",
         authors = {"Telesphoreo", "Taah"}

server/build.gradle

@@ -1,146 +0,0 @@
-plugins {
-    id "net.minecrell.plugin-yml.paper" version "0.6.0"
-}
-
-dependencies {
-    library "org.projectlombok:lombok:1.18.28"
-    annotationProcessor "org.projectlombok:lombok:1.18.28"
-    library "org.json:json:20230618"
-    library "commons-io:commons-io:2.13.0"
-    library "dev.morphia.morphia:morphia-core:2.3.5"
-    library "redis.clients:jedis:5.0.0-beta2"
-    library "org.mariadb.jdbc:mariadb-java-client:3.1.4"
-    library "com.zaxxer:HikariCP:5.0.1"
-    library "org.apache.maven.resolver:maven-resolver-transport-http:1.9.13"
-    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'
-        }
-    }
-}
-
-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

@@ -0,0 +1,168 @@
+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("net.minecrell.plugin-yml.paper") version "0.6.0"
+}
+
+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.32")
+    library("org.json:json:20240303")
+    library("commons-io:commons-io:2.16.1")
+    library("redis.clients:jedis:5.1.3")
+    library("org.mariadb.jdbc:mariadb-java-client:3.4.0")
+    library("com.zaxxer:HikariCP:5.1.0")
+    library("org.apache.maven.resolver:maven-resolver-transport-http:1.9.20")
+    library("org.jetbrains:annotations:24.1.0")
+
+    compileOnly("dev.folia:folia-api:1.20.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.0.2")
+    implementation("org.bstats:bstats-bukkit:3.0.2")
+
+    implementation("com.github.LeonMangler:SuperVanish:6.2.18-3")
+
+    annotationProcessor("org.projectlombok:lombok:1.18.32")
+}
+
+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.19"
+    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,23 +1,19 @@
 package dev.plex;
 
-import dev.plex.admin.Admin;
-import dev.plex.admin.AdminList;
 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;
-import dev.plex.rank.RankManager;
 import dev.plex.services.ServiceManager;
-import dev.plex.storage.MongoConnection;
 import dev.plex.storage.RedisConnection;
 import dev.plex.storage.SQLConnection;
 import dev.plex.storage.StorageType;
-import dev.plex.storage.permission.SQLPermissions;
-import dev.plex.storage.player.MongoPlayerData;
 import dev.plex.storage.player.SQLPlayerData;
 import dev.plex.storage.punishment.SQLNotes;
 import dev.plex.storage.punishment.SQLPunishment;
@@ -52,30 +48,25 @@ 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;
-
-    private MongoPlayerData mongoPlayerData;
     private SQLPlayerData sqlPlayerData;
 
     private SQLPunishment sqlPunishment;
     private SQLNotes sqlNotes;
-    private SQLPermissions sqlPermissions;
 
     private ModuleManager moduleManager;
-    private RankManager rankManager;
     private ServiceManager serviceManager;
     private PunishmentManager punishmentManager;
-
-    private AdminList adminList;
     private UpdateChecker updateChecker;
-    private String system;
 
     private Permission permissions;
     private Chat chat;
 
+    private CoreProtectHook coreProtectHook;
+    private PrismHook prismHook;
+
     public static Plex get()
     {
         return plugin;
@@ -118,13 +109,10 @@ public class Plex extends JavaPlugin
         commands.load(false);
 
         sqlConnection = new SQLConnection();
-        mongoConnection = new MongoConnection();
         redisConnection = new RedisConnection();
 
         playerCache = new PlayerCache();
 
-        system = config.getString("system");
-
         PlexLog.log("Attempting to connect to DB: {0}", plugin.config.getString("data.central.db"));
         try
         {
@@ -137,15 +125,38 @@ public class Plex extends JavaPlugin
             e.printStackTrace();
         }
 
-        if (system.equals("permissions"))
+        if (!getServer().getPluginManager().isPluginEnabled("Vault"))
         {
-            if (!getServer().getPluginManager().isPluginEnabled("Vault"))
-            {
-                throw new RuntimeException("Vault is required to run on the server if you use permissions!");
-            }
+            throw new RuntimeException("Vault is required to run on the server alongside a permissions plugin, we recommend LuckPerms!");
+        }
 
-            permissions = setupPermissions();
-            chat = setupChat();
+        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();
@@ -167,27 +178,13 @@ public class Plex extends JavaPlugin
             PlexLog.log("Redis is disabled in the configuration file, not connecting.");
         }
 
-        if (storageType == StorageType.MONGODB)
-        {
-            mongoPlayerData = new MongoPlayerData();
-        }
-        else
-        {
-            sqlPlayerData = new SQLPlayerData();
-            sqlPunishment = new SQLPunishment();
-            sqlNotes = new SQLNotes();
-            sqlPermissions = new SQLPermissions();
-        }
+        sqlPlayerData = new SQLPlayerData();
+        sqlPunishment = new SQLPunishment();
+        sqlNotes = new SQLNotes();
 
         new ListenerHandler();
         new CommandHandler();
 
-        rankManager = new RankManager();
-        rankManager.generateDefaultRanks();
-        rankManager.importDefaultRanks();
-        adminList = new AdminList();
-        PlexLog.log("Rank Manager initialized");
-
         punishmentManager = new PunishmentManager();
         punishmentManager.mergeIndefiniteBans();
         PlexLog.log("Punishment System initialized");
@@ -222,20 +219,7 @@ public class Plex extends JavaPlugin
         Bukkit.getOnlinePlayers().forEach(player ->
         {
             PlexPlayer plexPlayer = playerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object
-
-            if (plugin.getRankManager().isAdmin(plexPlayer))
-            {
-                plugin.getAdminList().removeFromCache(plexPlayer.getUuid());
-            }
-
-            if (mongoPlayerData != null) //back to mongo checking
-            {
-                mongoPlayerData.update(plexPlayer); //update the player's document
-            }
-            else if (sqlPlayerData != null) //sql checking
-            {
-                sqlPlayerData.update(plexPlayer);
-            }
+            sqlPlayerData.update(plexPlayer);
         });
         if (redisConnection != null && redisConnection.isEnabled() && redisConnection.getJedis().isConnected())
         {
@@ -264,13 +248,6 @@ public class Plex extends JavaPlugin
         {
             PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
             playerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
-            if (plugin.getRankManager().isAdmin(plexPlayer))
-            {
-                Admin admin = new Admin(plexPlayer.getUuid());
-                admin.setRank(plexPlayer.getRankFromString());
-
-                plugin.getAdminList().addToCache(admin);
-            }
         });
     }
 

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

@@ -22,17 +22,16 @@ public class PlexLibraryManager implements PluginLoader
     @Override
     public void classloader(@NotNull PluginClasspathBuilder classpathBuilder)
     {
-
         MavenLibraryResolver resolver = new MavenLibraryResolver();
         PluginLibraries pluginLibraries = load();
         pluginLibraries.asDependencies().forEach(resolver::addDependency);
         pluginLibraries.asRepositories().forEach(resolver::addRepository);
         // The plugin is null, a hacky way to check whether to load Jetty or not
-        if (new File("plugins/Plex/modules/Plex-HTTPD.jar").isFile())
+        if (new File("plugins/Plex/modules/Module-HTTPD.jar").isFile())
         {
-            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-server:11.0.15"), null));
-            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-servlet:11.0.15"), null));
-            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-proxy:11.0.15"), null));
+            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-server:11.0.19"), null));
+            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-servlet:11.0.19"), null));
+            resolver.addDependency(new Dependency(new DefaultArtifact("org.eclipse.jetty:jetty-proxy:11.0.19"), null));
         }
         classpathBuilder.addLibrary(resolver);
     }

server/src/main/java/dev/plex/admin/Admin.java

@@ -1,56 +0,0 @@
-package dev.plex.admin;
-
-import dev.plex.rank.enums.Rank;
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.Setter;
-
-import java.util.UUID;
-
-/**
- * Admin object to handle cached admins
- */
-@Getter
-@Setter
-public class Admin
-{
-    /**
-     * Gets the unique ID of an admin (immutable)
-     */
-    @Setter(AccessLevel.NONE)
-    private UUID uuid;
-
-    /**
-     * Gets the rank of the admin
-     * <br>
-     * Contains a #setRank and #getRank by lombok
-     */
-    private Rank rank;
-
-    /**
-     * Returns if the admin has command spy or not
-     * <br>
-     * Contains a #isCommandSpy and #setCommandSpy by Lombok
-     */
-    private boolean commandSpy = false;
-
-    /**
-     * Returns if the admin has admin chat toggled or not
-     * <br>
-     * Contains a #isAdminChat and #setAdminChat by Lombok
-     */
-    private boolean adminChat = false;
-
-    /**
-     * Creates an admin with the ADMIN rank as the default rank
-     *
-     * @param uuid
-     * @see UUID
-     * @see Rank
-     */
-    public Admin(UUID uuid)
-    {
-        this.uuid = uuid;
-        this.rank = Rank.ADMIN;
-    }
-}

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

@@ -1,151 +0,0 @@
-package dev.plex.admin;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.reflect.TypeToken;
-import com.google.gson.Gson;
-import dev.morphia.Datastore;
-import dev.morphia.query.Query;
-import dev.plex.PlexBase;
-import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
-import dev.plex.storage.StorageType;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * Cached storage for Admin objects
- *
- * @see Admin
- */
-
-public class AdminList implements PlexBase
-{
-    /**
-     * Key / Value storage, where the key is the unique ID of the admin
-     */
-    private final Map<UUID, Admin> admins = Maps.newHashMap();
-
-    /**
-     * Adds the admin to cache
-     *
-     * @param admin The admin object
-     */
-    public void addToCache(Admin admin)
-    {
-        admins.put(admin.getUuid(), admin);
-    }
-
-    /**
-     * Removes an admin from the cache
-     *
-     * @param uuid The unique ID of the admin
-     * @see UUID
-     */
-    public void removeFromCache(UUID uuid)
-    {
-        admins.remove(uuid);
-    }
-
-    /**
-     * Gathers every admins username (cached and in the database)
-     *
-     * @return An array list of the names of every admin
-     */
-    public List<String> getAllAdmins()
-    {
-        List<String> admins = Lists.newArrayList();
-        if (plugin.getStorageType() == StorageType.MONGODB)
-        {
-            Datastore store = plugin.getMongoConnection().getDatastore();
-            Query<PlexPlayer> query = store.find(PlexPlayer.class);
-            admins.addAll(query.stream().filter(plexPlayer -> plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN) && plexPlayer.isAdminActive()).map(PlexPlayer::getName).toList());
-        }
-        else
-        {
-            try (Connection con = plugin.getSqlConnection().getCon())
-            {
-                PreparedStatement statement = con.prepareStatement("SELECT * FROM `players` WHERE rank IN(?, ?, ?) AND adminActive=true");
-                statement.setString(1, Rank.ADMIN.name().toLowerCase());
-                statement.setString(2, Rank.SENIOR_ADMIN.name().toLowerCase());
-                statement.setString(3, Rank.EXECUTIVE.name().toLowerCase());
-
-                ResultSet set = statement.executeQuery();
-                while (set.next())
-                {
-                    admins.add(set.getString("name"));
-                }
-            }
-            catch (SQLException throwables)
-            {
-                throwables.printStackTrace();
-            }
-        }
-        return admins;
-    }
-
-    /**
-     * Gathers every admin (cached and in the database)
-     *
-     * @return An array list of the names of every admin
-     */
-    public List<PlexPlayer> getAllAdminPlayers()
-    {
-        List<PlexPlayer> plexPlayers = Lists.newArrayList();
-        if (plugin.getStorageType() == StorageType.MONGODB)
-        {
-            Datastore store = plugin.getMongoConnection().getDatastore();
-            Query<PlexPlayer> query = store.find(PlexPlayer.class);
-            return query.stream().toList().stream().filter(player -> plugin.getRankManager().isAdmin(player)).collect(Collectors.toList());
-        }
-        else
-        {
-            try (Connection con = plugin.getSqlConnection().getCon())
-            {
-                PreparedStatement statement = con.prepareStatement("SELECT * FROM `players` WHERE rank IN(?, ?, ?) AND adminActive=true");
-                statement.setString(1, Rank.ADMIN.name().toLowerCase());
-                statement.setString(2, Rank.SENIOR_ADMIN.name().toLowerCase());
-                statement.setString(3, Rank.EXECUTIVE.name().toLowerCase());
-
-                ResultSet set = statement.executeQuery();
-                while (set.next())
-                {
-                    String uuid = set.getString("uuid");
-                    String name = set.getString("name");
-                    String loginMSG = set.getString("login_msg");
-                    String prefix = set.getString("prefix");
-                    String rankName = set.getString("rank").toUpperCase();
-                    long coins = set.getLong("coins");
-                    boolean vanished = set.getBoolean("vanished");
-                    boolean commandspy = set.getBoolean("commandspy");
-                    List<String> ips = new Gson().fromJson(set.getString("ips"), new TypeToken<List<String>>()
-                    {
-                    }.getType());
-
-                    PlexPlayer plexPlayer = new PlexPlayer(UUID.fromString(uuid));
-                    plexPlayer.setName(name);
-                    plexPlayer.setLoginMessage(loginMSG);
-                    plexPlayer.setPrefix(prefix);
-                    plexPlayer.setRank(rankName);
-                    plexPlayer.setIps(ips);
-                    plexPlayer.setCoins(coins);
-                    plexPlayer.setVanished(vanished);
-                    plexPlayer.setCommandSpy(commandspy);
-                    plexPlayers.add(plexPlayer);
-                }
-            }
-            catch (SQLException throwables)
-            {
-                throwables.printStackTrace();
-            }
-        }
-        return plexPlayers;
-    }
-}

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

@@ -20,26 +20,12 @@ public class DataUtils
      */
     public static boolean hasPlayedBefore(UUID uuid)
     {
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            return Plex.get().getMongoPlayerData().exists(uuid);
-        }
-        else
-        {
-            return Plex.get().getSqlPlayerData().exists(uuid);
-        }
+        return Plex.get().getSqlPlayerData().exists(uuid);
     }
 
     public static boolean hasPlayedBefore(String username)
     {
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            return Plex.get().getMongoPlayerData().exists(username);
-        }
-        else
-        {
-            return Plex.get().getSqlPlayerData().exists(username);
-        }
+        return Plex.get().getSqlPlayerData().exists(username);
     }
 
     /**
@@ -61,14 +47,7 @@ public class DataUtils
             return Plex.get().getPlayerCache().getPlexPlayerMap().get(uuid);
         }
 
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            return Plex.get().getMongoPlayerData().getByUUID(uuid);
-        }
-        else
-        {
-            return Plex.get().getSqlPlayerData().getByUUID(uuid, loadExtraData);
-        }
+        return Plex.get().getSqlPlayerData().getByUUID(uuid, loadExtraData);
     }
 
     public static PlexPlayer getPlayer(String username)
@@ -84,14 +63,7 @@ public class DataUtils
             return plexPlayer.get();
         }
 
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            return Plex.get().getMongoPlayerData().getByName(username);
-        }
-        else
-        {
-            return Plex.get().getSqlPlayerData().getByName(username, loadExtraData);
-        }
+        return Plex.get().getSqlPlayerData().getByName(username, loadExtraData);
     }
 
     /**
@@ -109,14 +81,7 @@ public class DataUtils
             return player;
         }
 
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            return Plex.get().getMongoPlayerData().getByIP(ip);
-        }
-        else
-        {
-            return Plex.get().getSqlPlayerData().getByIP(ip);
-        }
+        return Plex.get().getSqlPlayerData().getByIP(ip);
     }
 
     /**
@@ -127,14 +92,7 @@ public class DataUtils
      */
     public static void update(PlexPlayer plexPlayer)
     {
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            Plex.get().getMongoPlayerData().update(plexPlayer);
-        }
-        else
-        {
-            Plex.get().getSqlPlayerData().update(plexPlayer);
-        }
+        Plex.get().getSqlPlayerData().update(plexPlayer);
     }
 
     /**
@@ -145,16 +103,7 @@ public class DataUtils
      */
     public static void insert(PlexPlayer plexPlayer)
     {
-        if (Plex.get().getStorageType() == StorageType.MONGODB)
-        {
-            Plex.get().getMongoPlayerData().save(plexPlayer);
-        }
-        else
-        {
-            Plex.get().getSqlPlayerData().insert(plexPlayer);
-        }
+        Plex.get().getSqlPlayerData().insert(plexPlayer);
     }
 
-    /*           REDIS METHODS AT ONE POINT FOR BANS, AND JSON METHODS FOR PUNISHMENTS       */
-
 }

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

@@ -1,5 +1,6 @@
 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;
@@ -7,7 +8,6 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.*;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.audience.Audience;
@@ -15,14 +15,15 @@ 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.*;
 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.List;
 import java.util.UUID;
 
 /**
@@ -45,11 +46,6 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      */
     private final CommandPermissions perms;
 
-    /**
-     * Minimum required rank fetched from the permissions
-     */
-    private final Rank level;
-
     /**
      * Required command source fetched from the permissions
      */
@@ -67,16 +63,27 @@ 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)
         {
             setAliases(Arrays.asList(params.aliases().split(",")));
         }
-        this.level = perms.level();
         this.commandSource = perms.source();
 
         if (register)
         {
+            if (getMap().getKnownCommands().containsKey(this.getName().toLowerCase()))
+            {
+                getMap().getKnownCommands().remove(this.getName().toLowerCase());
+            }
+            this.getAliases().forEach(s ->
+            {
+                if (getMap().getKnownCommands().containsKey(s.toLowerCase()))
+                {
+                    getMap().getKnownCommands().remove(s.toLowerCase());
+                }
+            });
             getMap().register("plex", this);
         }
     }
@@ -130,34 +137,9 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
                 return false;
             }
 
-            if (plugin.getSystem().equalsIgnoreCase("ranks"))
+            if (!perms.permission().isEmpty() && !player.hasPermission(perms.permission()))
             {
-                if (!plexPlayer.getRankFromString().isAtLeast(getLevel()))
-                {
-                    send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
-                    return true;
-                }
-                else
-                {
-                    if (getLevel().isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
-                    {
-                        send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
-                        return true;
-                    }
-                }
-            }
-            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-            {
-                if (!perms.permission().isEmpty() && !player.hasPermission(perms.permission()))
-                {
-                    send(sender, messageComponent("noPermissionNode", perms.permission()));
-                    return true;
-                }
-            }
-            else
-            {
-                PlexLog.error("Neither permissions or ranks were selected to be used in the configuration file!");
-                send(sender, "There is a server misconfiguration. Please alert a developer or the owner");
+                send(sender, messageComponent("noPermissionNode", perms.permission()));
                 return true;
             }
         }
@@ -166,34 +148,9 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         {
             PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
 
-            if (plugin.getSystem().equalsIgnoreCase("ranks"))
+            if (!perms.permission().isEmpty() && !plugin.getPermissions().playerHas(null, Bukkit.getPlayer(plexPlayer.getName()), perms.permission()))
             {
-                if (!plexPlayer.getRankFromString().isAtLeast(getLevel()))
-                {
-                    send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
-                    return true;
-                }
-                else
-                {
-                    if (getLevel().isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
-                    {
-                        send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
-                        return true;
-                    }
-                }
-            }
-            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-            {
-                if (!perms.permission().isEmpty() && !plugin.getPermissions().playerHas(null, Bukkit.getPlayer(plexPlayer.getName()), perms.permission()))
-                {
-                    send(sender, messageComponent("noPermissionNode", perms.permission()));
-                    return true;
-                }
-            }
-            else
-            {
-                PlexLog.error("Neither permissions or ranks were selected to be used in the configuration file!");
-                send(sender, "There is a server misconfiguration. Please alert a developer or the owner");
+                send(sender, messageComponent("noPermissionNode", perms.permission()));
                 return true;
             }
         }
@@ -213,6 +170,17 @@ 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
      *
@@ -276,111 +244,31 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      * Checks whether a sender has enough permissions or is high enough a rank
      *
      * @param sender     A CommandSender
-     * @param rank       The rank to check (if the server is using ranks)
-     * @param permission The permission to check (if the server is using permissions)
+     * @param permission The permission to check
      * @return true if the sender has enough permissions
-     * @see Rank
      */
-    protected boolean checkRank(CommandSender sender, Rank rank, String permission)
+    protected boolean checkPermission(CommandSender sender, String permission)
     {
         if (!isConsole(sender))
         {
-            return checkRank((Player) sender, rank, permission);
-        }
-        if (!sender.getName().equalsIgnoreCase("console"))
-        {
-            PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
-            if (plugin.getSystem().equalsIgnoreCase("ranks"))
-            {
-                if (!plexPlayer.getRankFromString().isAtLeast(rank))
-                {
-                    throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
-                }
-                if (rank.isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
-                {
-                    throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
-                }
-            }
-            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-            {
-                if (!perms.permission().isEmpty() && !plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(plexPlayer.getName()), perms.permission()))
-                {
-                    throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
-                }
-            }
+            return checkPermission((Player) sender, 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 checkRank(Player player, Rank rank, String permission)
-    {
-        if (player instanceof ConsoleCommandSender)
-        {
-            return true;
-        }
-        PlexPlayer plexPlayer = getPlexPlayer(player);
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            if (!plexPlayer.getRankFromString().isAtLeast(rank))
-            {
-                throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
-            }
-            if (rank.isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
-            {
-                throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
-            }
-        }
-        else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-        {
-            if (!perms.permission().isEmpty() && !player.hasPermission(perms.permission()))
-            {
-                throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
-            }
-        }
-        return true;
-    }
-
-    protected boolean silentCheckRank(Player player, Rank rank, String permission)
-    {
-        if (player instanceof ConsoleCommandSender)
-        {
-            return true;
-        }
-        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 !perms.permission().isEmpty() && player.hasPermission(permission);
-        }
-        return false;
-    }
-
     /**
      * 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)
+     * @param sender     A CommandSender
+     * @param permission The permission to check
      * @return true if the sender has enough permissions
-     * @see Rank
      */
-    protected boolean checkTab(CommandSender sender, Rank rank, String permission)
+    protected boolean silentCheckPermission(CommandSender sender, String permission)
     {
+        PlexLog.debug("Checking {0} with {1}", sender.getName(), permission);
         if (!isConsole(sender))
         {
-            return checkTab((Player) sender, rank, permission);
+            return silentCheckPermission((Player) sender, permission);
         }
         return true;
     }
@@ -389,79 +277,25 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      * 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)
+     * @param permission The permission to check
      * @return true if the sender has enough permissions
-     * @see Rank
      */
-    protected boolean checkTab(Player player, Rank rank, String permission)
+    protected boolean checkPermission(Player player, String permission)
     {
-        PlexPlayer plexPlayer = getPlexPlayer(player);
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        if (player instanceof ConsoleCommandSender)
         {
-            return rank.isAtLeast(Rank.ADMIN) ? plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(rank) : plexPlayer.getRankFromString().isAtLeast(rank);
+            return true;
         }
-        else if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        if (!permission.isEmpty() && !player.hasPermission(permission))
         {
-            return !perms.permission().isEmpty() && player.hasPermission(permission);
+            throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
         }
         return true;
     }
 
-    /**
-     * Checks if a player is an admin
-     *
-     * @param plexPlayer The PlexPlayer object
-     * @return true if the player is an admin
-     * @see PlexPlayer
-     */
-    protected boolean isAdmin(PlexPlayer plexPlayer)
+    protected boolean silentCheckPermission(Player player, String permission)
     {
-        return Plex.get().getRankManager().isAdmin(plexPlayer);
-    }
-
-    /**
-     * Checks if a sender is an admin
-     *
-     * @param sender A command sender
-     * @return true if the sender is an admin or if console
-     */
-    protected boolean isAdmin(CommandSender sender)
-    {
-        if (!(sender instanceof Player player))
-        {
-            return true;
-        }
-        PlexPlayer plexPlayer = getPlexPlayer(player);
-        return plugin.getRankManager().isAdmin(plexPlayer);
-    }
-
-    /**
-     * Checks if a username is an admin
-     *
-     * @param name The username
-     * @return true if the username is an admin
-     */
-    protected boolean isAdmin(String name)
-    {
-        PlexPlayer plexPlayer = DataUtils.getPlayer(name);
-        return plugin.getRankManager().isAdmin(plexPlayer);
-    }
-
-    /**
-     * Checks if a sender is a senior admin
-     *
-     * @param sender A command sender
-     * @return true if the sender is a senior admin or if console
-     */
-    protected boolean isSeniorAdmin(CommandSender sender)
-    {
-        if (!(sender instanceof Player player))
-        {
-            return true;
-        }
-        PlexPlayer plexPlayer = getPlexPlayer(player);
-        return plugin.getRankManager().isSeniorAdmin(plexPlayer);
+        return !permission.isEmpty() && player.hasPermission(permission);
     }
 
     /**
@@ -639,11 +473,6 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return PlexUtils.mmDeserialize(s);
     }
 
-    public Rank getLevel()
-    {
-        return level;
-    }
-
     public CommandMap getMap()
     {
         return Plex.get().getServer().getCommandMap();

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

@@ -1,7 +1,6 @@
 package dev.plex.command.annotation;
 
 import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.rank.enums.Rank;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -12,14 +11,6 @@ import java.lang.annotation.RetentionPolicy;
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CommandPermissions
 {
-    /**
-     * Minimum rank required
-     *
-     * @return Minimum rank required for the command
-     * @see Rank
-     */
-    Rank level() default Rank.IMPOSTOR;
-
     /**
      * Required command source
      *

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

@@ -1,12 +0,0 @@
-package dev.plex.command.annotation;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-@Retention(RetentionPolicy.RUNTIME)
-public @interface System
-{
-    String value() default "";
-
-    boolean debug() default false;
-}

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

@@ -1,187 +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.annotation.System;
-import dev.plex.command.exception.ConsoleOnlyException;
-import dev.plex.command.exception.PlayerNotFoundException;
-import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.event.AdminAddEvent;
-import dev.plex.event.AdminRemoveEvent;
-import dev.plex.event.AdminSetRankEvent;
-import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-import net.kyori.adventure.text.Component;
-import org.apache.commons.lang3.StringUtils;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Arrays;
-import java.util.List;
-
-@CommandPermissions(level = Rank.OP, source = RequiredCommandSource.ANY)
-@CommandParameters(name = "admin", usage = "/<command> <add <player> | remove <player> | setrank <player> <rank> | list>", aliases = "saconfig,slconfig,adminconfig,adminmanage", description = "Manage all admins")
-@System(value = "ranks")
-public class AdminCMD extends PlexCommand
-{
-    //TODO: Better return messages
-
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length == 0)
-        {
-            return usage();
-        }
-
-        if (args[0].equalsIgnoreCase("add"))
-        {
-            if (args.length != 2)
-            {
-                return usage("/admin add <player>");
-            }
-
-            if (!isConsole(sender))
-            {
-                throw new ConsoleOnlyException();
-            }
-
-            /*UUID targetUUID = PlexUtils.getFromName(args[1]);
-
-            if (targetUUID != null)
-            {
-                PlexLog.debug("Admin Adding UUID: " + targetUUID);
-            }*/
-
-            if (!DataUtils.hasPlayedBefore(args[1]))
-            {
-                throw new PlayerNotFoundException();
-            }
-            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
-
-            if (isAdmin(plexPlayer))
-            {
-                return messageComponent("playerIsAdmin");
-            }
-
-            Bukkit.getServer().getPluginManager().callEvent(new AdminAddEvent(sender, plexPlayer));
-            return null;
-        }
-        if (args[0].equalsIgnoreCase("remove"))
-        {
-            if (args.length != 2)
-            {
-                return usage("/admin remove <player>");
-            }
-
-            if (!isConsole(sender))
-            {
-                throw new ConsoleOnlyException();
-            }
-
-            //            UUID targetUUID = PlexUtils.getFromName(args[1]);
-
-            if (!DataUtils.hasPlayedBefore(args[1]))
-            {
-                throw new PlayerNotFoundException();
-            }
-            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
-
-            if (!isAdmin(plexPlayer))
-            {
-                return messageComponent("playerNotAdmin");
-            }
-
-            Bukkit.getServer().getPluginManager().callEvent(new AdminRemoveEvent(sender, plexPlayer));
-            return null;
-        }
-
-        if (args[0].equalsIgnoreCase("setrank"))
-        {
-            if (args.length != 3)
-            {
-                return usage("/admin setrank <player> <rank>");
-            }
-
-            if (!isConsole(sender))
-            {
-                throw new ConsoleOnlyException();
-            }
-
-            //            UUID targetUUID = PlexUtils.getFromName(args[1]);
-
-            if (!DataUtils.hasPlayedBefore(args[1]))
-            {
-                throw new PlayerNotFoundException();
-            }
-
-            if (!rankExists(args[2]))
-            {
-                return messageComponent("rankNotFound");
-            }
-
-            Rank rank = Rank.valueOf(args[2].toUpperCase());
-
-            if (!rank.isAtLeast(Rank.ADMIN))
-            {
-                return messageComponent("rankMustBeHigherThanAdmin");
-            }
-
-            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
-
-            if (!isAdmin(plexPlayer))
-            {
-                return messageComponent("playerNotAdmin");
-            }
-
-            Bukkit.getServer().getPluginManager().callEvent(new AdminSetRankEvent(sender, plexPlayer, rank));
-
-            return null;
-        }
-
-        if (args[0].equalsIgnoreCase("list"))
-        {
-            if (args.length != 1)
-            {
-                return usage("/admin list");
-            }
-
-            return componentFromString("Admins: " + StringUtils.join(plugin.getAdminList().getAllAdmins(), ", "));
-        }
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (args.length == 1)
-        {
-            return Arrays.asList("add", "remove", "setrank", "list");
-        }
-        else if (args.length == 2 && !args[0].equalsIgnoreCase("list"))
-        {
-            return PlexUtils.getPlayerNameList();
-        }
-        return ImmutableList.of();
-    }
-
-
-    private boolean rankExists(String rank)
-    {
-        for (Rank ranks : Rank.values())
-        {
-            if (ranks.name().equalsIgnoreCase(rank))
-            {
-                return true;
-            }
-        }
-        return false;
-    }
-}

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

@@ -1,12 +1,12 @@
 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;
 import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.hook.VaultHook;
 import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.minimessage.SafeMiniMessage;
 import dev.plex.util.redis.MessageUtil;
@@ -18,29 +18,49 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Collections;
+import java.util.List;
 import java.util.UUID;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.adminchat", source = RequiredCommandSource.ANY)
+@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
 {
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
     {
+        PlexPlayer player;
         if (args.length == 0)
         {
             if (playerSender != null)
             {
-                PlexPlayer player = DataUtils.getPlayer(playerSender.getUniqueId());
+                player = plugin.getPlayerCache().getPlexPlayer(playerSender.getUniqueId());
                 player.setStaffChat(!player.isStaffChat());
                 return messageComponent("adminChatToggled", BooleanUtils.toStringOnOff(player.isStaffChat()));
             }
             return usage();
         }
 
+        String prefix;
+        if (playerSender != null)
+        {
+            player = plugin.getPlayerCache().getPlexPlayer(playerSender.getUniqueId());
+            prefix = PlexUtils.mmSerialize(VaultHook.getPrefix(player));
+        }
+        else
+        {
+            prefix = "<dark_gray>[<dark_purple>Console<dark_gray>]";
+        }
+        PlexLog.debug("admin chat prefix: {0}", prefix);
         String message = StringUtils.join(args, " ");
-        plugin.getServer().getConsoleSender().sendMessage(messageComponent("adminChatFormat", sender.getName(), message));
-        MessageUtil.sendStaffChat(sender, SafeMiniMessage.mmDeserialize(message), PlexUtils.adminChat(sender.getName(), message).toArray(UUID[]::new));
+        plugin.getServer().getConsoleSender().sendMessage(messageComponent("adminChatFormat", sender.getName(), prefix, message));
+        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,7 +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 dev.plex.rank.enums.Rank;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -13,7 +12,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.adminworld", source = RequiredCommandSource.IN_GAME)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.adminworld", source = RequiredCommandSource.IN_GAME)
 @CommandParameters(name = "adminworld", aliases = "aw", description = "Teleport to the adminworld")
 public class AdminworldCMD extends PlexCommand
 {
@@ -30,4 +32,10 @@ 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

@@ -7,7 +7,6 @@ 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.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -19,7 +18,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.gamemode.adventure", source = RequiredCommandSource.ANY)
+@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
 {
@@ -36,29 +35,27 @@ public class AdventureCMD extends PlexCommand
             return null;
         }
 
-        if (checkRank(sender, Rank.ADMIN, "plex.gamemode.adventure.others"))
+        checkPermission(sender, "plex.gamemode.adventure.others");
+        if (args[0].equals("-a"))
         {
-            if (args[0].equals("-a"))
+            for (Player targetPlayer : Bukkit.getServer().getOnlinePlayers())
             {
-                for (Player targetPlayer : Bukkit.getServer().getOnlinePlayers())
-                {
-                    targetPlayer.setGameMode(GameMode.ADVENTURE);
-                    messageComponent("gameModeSetTo", "adventure");
-                }
-                PlexUtils.broadcast(messageComponent("setEveryoneGameMode", sender.getName(), "adventure"));
-                return null;
+                targetPlayer.setGameMode(GameMode.ADVENTURE);
+                messageComponent("gameModeSetTo", "adventure");
             }
-
-            Player nPlayer = getNonNullPlayer(args[0]);
-            Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, nPlayer, GameMode.ADVENTURE));
+            PlexUtils.broadcast(messageComponent("setEveryoneGameMode", sender.getName(), "adventure"));
+            return null;
         }
+
+        Player nPlayer = getNonNullPlayer(args[0]);
+        Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, nPlayer, GameMode.ADVENTURE));
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (checkTab(sender, Rank.ADMIN, "plex.gamemode.adventure.others"))
+        if (silentCheckPermission(sender, "plex.gamemode.adventure.others"))
         {
             return PlexUtils.getPlayerNameList();
         }

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

@@ -1,7 +1,5 @@
 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;
@@ -11,8 +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.rank.enums.Rank;
-import dev.plex.util.*;
+import dev.plex.util.BungeeUtil;
+import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
+import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -23,11 +23,11 @@ import org.jetbrains.annotations.Nullable;
 
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
+import java.util.Collections;
 import java.util.List;
-import java.util.UUID;
 
-@CommandParameters(name = "ban", usage = "/<command> <player> [reason]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.ban", source = RequiredCommandSource.ANY)
+@CommandParameters(name = "ban", usage = "/<command> <player> [reason] [-rb]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
+@CommandPermissions(permission = "plex.ban", source = RequiredCommandSource.ANY)
 
 public class BanCMD extends PlexCommand
 {
@@ -39,32 +39,16 @@ public class BanCMD extends PlexCommand
             return usage();
         }
 
-        UUID targetUUID = WebUtils.getFromName(args[0]);
+        final PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
 
-        if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+        if (plexPlayer == null)
         {
             throw new PlayerNotFoundException();
         }
-        PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
-        Player player = Bukkit.getPlayer(targetUUID);
 
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            if (isAdmin(plexPlayer))
-            {
-                if (!isConsole(sender))
-                {
-                    assert playerSender != null;
-                    PlexPlayer plexPlayer1 = getPlexPlayer(playerSender);
-                    if (!plexPlayer1.getRankFromString().isAtLeast(plexPlayer.getRankFromString()))
-                    {
-                        return messageComponent("higherRankThanYou");
-                    }
-                }
-            }
-        }
+        Player player = Bukkit.getPlayer(plexPlayer.getUuid());
 
-        plugin.getPunishmentManager().isAsyncBanned(targetUUID).whenComplete((aBoolean, throwable) ->
+        plugin.getPunishmentManager().isAsyncBanned(plexPlayer.getUuid()).whenComplete((aBoolean, throwable) ->
         {
             if (aBoolean)
             {
@@ -72,29 +56,29 @@ public class BanCMD extends PlexCommand
                 return;
             }
             String reason;
-            Punishment punishment = new Punishment(targetUUID, getUUID(sender));
+            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);
-                punishment.setReason(reason);
+                String newReason = StringUtils.normalizeSpace(reason.replace("-rb", ""));
+                punishment.setReason(newReason.trim().isEmpty() ? messageString("noReasonProvided") : newReason);
+                rollBack = reason.startsWith("-rb") || reason.endsWith("-rb");
             }
             else
             {
-                punishment.setReason("No reason provided.");
+                punishment.setReason(messageString("noReasonProvided"));
             }
             punishment.setPunishedUsername(plexPlayer.getName());
             ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
             punishment.setEndDate(date.plusDays(1));
             punishment.setCustomTime(false);
-            punishment.setActive(!isAdmin(plexPlayer));
-            if (player != null)
-            {
-                punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
-            }
+            punishment.setActive(true);
+            punishment.setIp(player != null ? player.getAddress().getAddress().getHostAddress().trim() : plexPlayer.getIps().get(plexPlayer.getIps().size() - 1));
             plugin.getPunishmentManager().punish(plexPlayer, punishment);
             PlexUtils.broadcast(messageComponent("banningPlayer", sender.getName(), plexPlayer.getName()));
-            Bukkit.getScheduler().runTask(Plex.get(), () ->
+            Bukkit.getGlobalRegionScheduler().execute(plugin, () ->
             {
                 if (player != null)
                 {
@@ -102,14 +86,59 @@ 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> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.ban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        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();
     }
 }

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

@@ -0,0 +1,61 @@
+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 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;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@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

@@ -0,0 +1,59 @@
+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 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.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

@@ -4,7 +4,6 @@ import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.listener.impl.BlockListener;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -13,7 +12,12 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.blockedit")
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.blockedit")
 @CommandParameters(name = "blockedit", usage = "/<command> [list | purge | all | <player>]", aliases = "bedit", description = "Prevent players from modifying blocks")
 public class BlockEditCMD extends PlexCommand
 {
@@ -63,7 +67,7 @@ public class BlockEditCMD extends PlexCommand
             int count = 0;
             for (final Player player : Bukkit.getOnlinePlayers())
             {
-                if (!silentCheckRank(player, Rank.ADMIN, "plex.blockedit"))
+                if (!silentCheckPermission(player, "plex.blockedit"))
                 {
                     bl.blockedPlayers.add(player.getName());
                     ++count;
@@ -76,7 +80,7 @@ public class BlockEditCMD extends PlexCommand
         final Player player = getNonNullPlayer(args[0]);
         if (!bl.blockedPlayers.contains(player.getName()))
         {
-            if (silentCheckRank(player, Rank.ADMIN, "plex.blockedit"))
+            if (silentCheckPermission(player, "plex.blockedit"))
             {
                 send(sender, messageComponent("higherRankThanYou"));
                 return null;
@@ -95,4 +99,20 @@ 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,14 +6,16 @@ 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.rank.enums.Rank;
 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(level = Rank.ADMIN, permission = "plex.commandspy", source = RequiredCommandSource.IN_GAME)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.commandspy", source = RequiredCommandSource.IN_GAME)
 @CommandParameters(name = "commandspy", aliases = "cmdspy", description = "Spy on other player's commands")
 public class CommandSpyCMD extends PlexCommand
 {
@@ -31,4 +33,10 @@ 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

@@ -4,7 +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 dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
@@ -13,7 +12,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.consolesay", source = RequiredCommandSource.CONSOLE)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.consolesay", source = RequiredCommandSource.CONSOLE)
 @CommandParameters(name = "consolesay", usage = "/<command> <message>", description = "Displays a message to everyone", aliases = "csay")
 public class ConsoleSayCMD extends PlexCommand
 {
@@ -28,4 +30,10 @@ 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

@@ -7,7 +7,6 @@ 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.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -19,7 +18,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.gamemode.creative", source = RequiredCommandSource.ANY)
+@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
 {
@@ -39,30 +38,27 @@ public class CreativeCMD extends PlexCommand
             return null;
         }
 
-        if (checkRank(sender, Rank.ADMIN, "plex.gamemode.creative.others"))
+        checkPermission(sender, "plex.gamemode.creative.others");
+        if (args[0].equals("-a"))
         {
-            if (args[0].equals("-a"))
+            for (Player targetPlayer : Bukkit.getServer().getOnlinePlayers())
             {
-                for (Player targetPlayer : Bukkit.getServer().getOnlinePlayers())
-                {
-                    targetPlayer.setGameMode(GameMode.CREATIVE);
-                    messageComponent("gameModeSetTo", "creative");
-                }
-                PlexUtils.broadcast(messageComponent("setEveryoneGameMode", sender.getName(), "creative"));
-                return null;
+                targetPlayer.setGameMode(GameMode.CREATIVE);
+                messageComponent("gameModeSetTo", "creative");
             }
-
-            Player nPlayer = getNonNullPlayer(args[0]);
-            Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, nPlayer, GameMode.CREATIVE));
+            PlexUtils.broadcast(messageComponent("setEveryoneGameMode", sender.getName(), "creative"));
             return null;
         }
+
+        Player nPlayer = getNonNullPlayer(args[0]);
+        Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, nPlayer, GameMode.CREATIVE));
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (checkTab(sender, Rank.ADMIN, "plex.gamemode.creative.others"))
+        if (silentCheckPermission(sender, "plex.gamemode.creative.others"))
         {
             return PlexUtils.getPlayerNameList();
         }

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

@@ -4,8 +4,7 @@ import com.google.common.collect.ImmutableList;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
-import dev.plex.command.annotation.System;
-import dev.plex.rank.enums.Rank;
+import dev.plex.menu.impl.MaterialMenu;
 import dev.plex.util.GameRuleUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
@@ -24,8 +23,7 @@ import java.util.List;
 import java.util.Locale;
 
 @CommandParameters(name = "pdebug", description = "Plex's debug command", usage = "/<command> <aliases <command> | redis-reset <player> | gamerules>")
-@CommandPermissions(level = Rank.EXECUTIVE, permission = "plex.debug")
-@System(debug = true)
+@CommandPermissions(permission = "plex.debug")
 public class DebugCMD extends PlexCommand
 {
     @Override
@@ -43,9 +41,9 @@ public class DebugCMD extends PlexCommand
                 if (plugin.getRedisConnection().getJedis().exists(player.getUniqueId().toString()))
                 {
                     plugin.getRedisConnection().getJedis().del(player.getUniqueId().toString());
-                    return componentFromString("Successfully reset " + player.getName() + "'s Redis punishments!").color(NamedTextColor.YELLOW);
+                    return messageComponent("redisResetSuccessful", player.getName());
                 }
-                return componentFromString("Couldn't find player in Redis punishments.");
+                return messageComponent("redisResetPlayerNotFound");
             }
         }
         if (args[0].equalsIgnoreCase("gamerules"))
@@ -64,7 +62,7 @@ public class DebugCMD extends PlexCommand
                     PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
                 }
             }
-            return mmString("<aqua>Re-applied game all the game rules!");
+            return messageComponent("reappliedGamerules");
         }
         if (args[0].equalsIgnoreCase("aliases"))
         {
@@ -74,17 +72,26 @@ public class DebugCMD extends PlexCommand
                 Command command = plugin.getServer().getCommandMap().getCommand(commandName);
                 if (command == null)
                 {
-                    return mmString("<red>That command could not be found!");
+                    return messageComponent("commandNotFound");
                 }
-                return mmString("<aqua>Aliases for " + commandName + " are: " + Arrays.toString(command.getAliases().toArray(new String[0])));
+                return messageComponent("commandAliases", commandName, Arrays.toString(command.getAliases().toArray(new String[0])));
             }
         }
+        if (args[0].equalsIgnoreCase("pagination"))
+        {
+            if (playerSender == null)
+            {
+                return messageComponent("noPermissionConsole");
+            }
+            new MaterialMenu().open(playerSender);
+            return null;
+        }
         return usage();
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
-}
+}

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

@@ -1,31 +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.annotation.System;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-import net.kyori.adventure.text.Component;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-@CommandParameters(name = "deopall", description = "Deop everyone on the server", aliases = "deopa")
-@CommandPermissions(level = Rank.ADMIN)
-@System(value = "ranks")
-public class DeopAllCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        for (Player player : Bukkit.getOnlinePlayers())
-        {
-            player.setOp(false);
-        }
-        PlexUtils.broadcast(messageComponent("deoppedAllPlayers", sender.getName()));
-        return null;
-    }
-}

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

@@ -1,41 +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.command.annotation.System;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-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 = "deop", description = "Deop a player on the server", usage = "/<command> <player>")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.deop")
-@System(value = "ranks")
-public class DeopCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length != 1)
-        {
-            return usage();
-        }
-        Player player = getNonNullPlayer(args[0]);
-        player.setOp(false);
-        PlexUtils.broadcast(messageComponent("deoppedPlayer", sender.getName(), player.getName()));
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
-}

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

@@ -4,7 +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 dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -18,8 +18,8 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 
-@CommandPermissions(level = Rank.ADMIN, 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> [name]", aliases = "ew,rd")
+@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
 {
     @Override
@@ -29,6 +29,22 @@ public class EntityWipeCMD extends PlexCommand
 
         List<String> entityWhitelist = new LinkedList<>(Arrays.asList(args));
 
+        boolean radiusSpecified = !entityWhitelist.isEmpty() && isNumeric(entityWhitelist.get(entityWhitelist.size() - 1)); // try and detect if the last argument of the command is a number
+        boolean useBlacklist = args.length == 0 || (args.length == 1 && radiusSpecified); // if there are no arguments or the one argument is a number
+        int radius = 0;
+
+        PlexLog.debug("using blacklist: " + useBlacklist);
+        PlexLog.debug("radius specified: " + radiusSpecified);
+
+        if (radiusSpecified)
+        {
+            radius = parseInt(sender, args[entityWhitelist.size() - 1]); // get the args length as the size of the list
+            radius *= radius;
+            entityWhitelist.remove(entityWhitelist.size() - 1); // remove the radius from the list
+        }
+
+        PlexLog.debug("radius: " + radius);
+
         EntityType[] entityTypes = EntityType.values();
         entityWhitelist.removeIf(name ->
         {
@@ -40,8 +56,6 @@ public class EntityWipeCMD extends PlexCommand
             return res;
         });
 
-        boolean useBlacklist = args.length == 0;
-
         HashMap<String, Integer> entityCounts = new HashMap<>();
 
         for (World world : Bukkit.getWorlds())
@@ -54,6 +68,16 @@ public class EntityWipeCMD extends PlexCommand
 
                     if (useBlacklist ? entityBlacklist.stream().noneMatch(entityName -> entityName.equalsIgnoreCase(type)) : entityWhitelist.stream().anyMatch(entityName -> entityName.equalsIgnoreCase(type)))
                     {
+                        if (radius > 0)
+                        {
+                            PlexLog.debug("we got here, radius is > 0");
+                            if (playerSender != null && entity.getWorld() == playerSender.getWorld() && playerSender.getLocation().distanceSquared(entity.getLocation()) > radius)
+                            {
+                                PlexLog.debug("continuing");
+                                continue;
+                            }
+                        }
+                        PlexLog.debug("removed entity: " + entity.getType().name());
                         entity.remove();
 
                         entityCounts.put(type, entityCounts.getOrDefault(type, 0) + 1);
@@ -82,19 +106,53 @@ public class EntityWipeCMD extends PlexCommand
         return null;
     }
 
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        List<String> entities = new ArrayList<>();
-        for (World world : Bukkit.getWorlds())
+        if (silentCheckPermission(sender, this.getPermission()))
         {
-            for (Entity entity : world.getEntities())
+            List<String> entities = new ArrayList<>();
+            for (World world : Bukkit.getWorlds())
             {
-                if (entity.getType() != EntityType.PLAYER)
+                for (Entity entity : world.getEntities())
                 {
-                    entities.add(entity.getType().name());
+                    if (entity.getType() != EntityType.PLAYER)
+                    {
+                        entities.add(entity.getType().name());
+                    }
                 }
             }
+            return entities.stream().toList();
         }
-        return entities.stream().toList();
+        return Collections.emptyList();
     }
-}
+
+    private Integer parseInt(CommandSender sender, String string)
+    {
+        try
+        {
+            return Integer.parseInt(string);
+        }
+        catch (NumberFormatException ex)
+        {
+            sender.sendMessage(messageComponent("notANumber", string));
+        }
+        return null;
+    }
+
+    private boolean isNumeric(String string)
+    {
+        if (string == null)
+        {
+            return false;
+        }
+        try
+        {
+            int num = Integer.parseInt(string);
+        }
+        catch (NumberFormatException nfe)
+        {
+            return false;
+        }
+        return true;
+    }
+}

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

@@ -4,7 +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 dev.plex.rank.enums.Rank;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -13,7 +12,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.flatlands", source = RequiredCommandSource.IN_GAME)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.flatlands", source = RequiredCommandSource.IN_GAME)
 @CommandParameters(name = "flatlands", description = "Teleport to the flatlands")
 public class FlatlandsCMD extends PlexCommand
 {
@@ -29,4 +31,10 @@ 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,7 +7,6 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
@@ -21,7 +20,7 @@ import java.time.ZonedDateTime;
 import java.util.List;
 
 @CommandParameters(name = "freeze", description = "Freeze a player on the server", usage = "/<command> <player>", aliases = "fr")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.freeze")
+@CommandPermissions(permission = "plex.freeze")
 public class FreezeCMD extends PlexCommand
 {
     @Override
@@ -39,27 +38,15 @@ public class FreezeCMD extends PlexCommand
             return messageComponent("playerFrozen");
         }
 
-        if (isAdmin(getPlexPlayer(player)))
-        {
-            if (!isConsole(sender))
-            {
-                assert playerSender != null;
-                PlexPlayer plexPlayer1 = getPlexPlayer(playerSender);
-                if (!plexPlayer1.getRankFromString().isAtLeast(getPlexPlayer(player).getRankFromString()) && getPlexPlayer(player).isAdminActive())
-                {
-                    return messageComponent("higherRankThanYou");
-                }
-            }
-        }
-
         Punishment punishment = new Punishment(punishedPlayer.getUuid(), getUUID(sender));
         punishment.setCustomTime(false);
         ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
-        punishment.setEndDate(date.plusMinutes(5));
+        punishment.setEndDate(date.plusSeconds(plugin.config.getInt("punishments.freeze-timer", 300)));
         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()));
@@ -67,8 +54,8 @@ public class FreezeCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.freeze") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -6,7 +6,6 @@ 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.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -21,7 +20,7 @@ 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(level = Rank.OP, permission = "plex.gamemode", source = RequiredCommandSource.ANY)
+@CommandPermissions(permission = "plex.gamemode", source = RequiredCommandSource.ANY)
 public class GamemodeCMD extends PlexCommand
 {
     private GameMode gamemode;
@@ -62,14 +61,14 @@ public class GamemodeCMD extends PlexCommand
             case "spectator", "sp", "3", "6" ->
             {
                 gamemode = GameMode.SPECTATOR;
-                checkRank(sender, Rank.ADMIN, "plex.gamemode.spectator");
+                checkPermission(sender, "plex.gamemode.spectator");
                 update(sender, playerSender, GameMode.SPECTATOR);
                 return null;
             }
         }
         if (args.length > 1)
         {
-            checkRank(sender, Rank.ADMIN, "plex.gamemode.others");
+            checkPermission(sender, "plex.gamemode.others");
             Player player = getNonNullPlayer(args[1]);
             Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, player, gamemode));
         }
@@ -89,7 +88,7 @@ public class GamemodeCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
         if (args.length == 1)
         {
@@ -97,7 +96,10 @@ public class GamemodeCMD extends PlexCommand
         }
         if (args.length == 2)
         {
-            return PlexUtils.getPlayerNameList();
+            if (silentCheckPermission(sender, "plex.gamemode.others"))
+            {
+                return PlexUtils.getPlayerNameList();
+            }
         }
         return Collections.emptyList();
     }

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

@@ -1,5 +1,6 @@
 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;
@@ -9,11 +10,9 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.BungeeUtil;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import dev.plex.util.WebUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -24,10 +23,10 @@ import org.jetbrains.annotations.Nullable;
 
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
-import java.util.UUID;
+import java.util.List;
 
 @CommandParameters(name = "kick", description = "Kicks a player", usage = "/<command> <player>")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.kick", source = RequiredCommandSource.ANY)
+@CommandPermissions(permission = "plex.kick", source = RequiredCommandSource.ANY)
 public class KickCMD extends PlexCommand
 {
     @Override
@@ -38,21 +37,20 @@ public class KickCMD extends PlexCommand
             return usage();
         }
 
-        UUID targetUUID = WebUtils.getFromName(args[0]);
-        String reason = "No reason provided";
+        PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
+        String reason = messageString("noReasonProvided");
 
-        if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+        if (plexPlayer == null)
         {
             throw new PlayerNotFoundException();
         }
-        PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
-        Player player = Bukkit.getPlayer(targetUUID);
+        Player player = Bukkit.getPlayer(plexPlayer.getUuid());
 
         if (player == null)
         {
             throw new PlayerNotFoundException();
         }
-        Punishment punishment = new Punishment(targetUUID, getUUID(sender));
+        Punishment punishment = new Punishment(plexPlayer.getUuid(), getUUID(sender));
         punishment.setType(PunishmentType.KICK);
         if (args.length > 1)
         {
@@ -67,7 +65,13 @@ public class KickCMD extends PlexCommand
         punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
         plugin.getPunishmentManager().punish(plexPlayer, punishment);
         PlexUtils.broadcast(messageComponent("kickedPlayer", sender.getName(), plexPlayer.getName()));
-        BungeeUtil.kickPlayer(player, Punishment.generateBanMessage(punishment));
+        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

@@ -2,10 +2,11 @@ package dev.plex.command.impl;
 
 import com.google.common.collect.Lists;
 import dev.plex.command.PlexCommand;
+import dev.plex.util.PlexUtils;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.hook.VaultHook;
-import dev.plex.rank.enums.Rank;
+import dev.plex.meta.PlayerMeta;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
@@ -14,43 +15,48 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Collections;
 import java.util.List;
 
-@CommandParameters(name = "list", description = "Show a list of all online players", aliases = "lsit,who,playerlist,online")
-@CommandPermissions(level = Rank.OP, permission = "plex.list")
+@CommandParameters(name = "list", description = "Show a list of all online players", usage = "/<command> [-d | -v]", aliases = "lsit,who,playerlist,online")
+@CommandPermissions(permission = "plex.list")
 public class ListCMD extends PlexCommand
 {
     @Override
     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 = 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));
+        Component header = PlexUtils.messageComponent(players.size() == 1 ? "listHeader" : "listHeaderPlural", players.size(), Bukkit.getMaxPlayers());
         send(sender, header);
-        if (players.size() == 0)
+        if (players.isEmpty())
         {
             return null;
         }
         for (int i = 0; i < players.size(); i++)
         {
             Player player = players.get(i);
-            if (plugin.getSystem().equals("ranks"))
+            Component prefix = VaultHook.getPrefix(getPlexPlayer(player));
+            if (prefix != null && !prefix.equals(Component.empty()) && !prefix.equals(Component.space()))
             {
-                list = list.append(getPlexPlayer(player).getRankFromString().getPrefix()).append(Component.space()).append(Component.text(player.getName()).color(NamedTextColor.WHITE));
+                list = list.append(prefix).append(Component.space());
             }
-            else
+            list = list.append(Component.text(player.getName()).color(NamedTextColor.WHITE));
+            if (args.length > 0 && args[0].equalsIgnoreCase("-d"))
             {
-                list = list.append(VaultHook.getPrefix(getPlexPlayer(player))).append(Component.space()).append(Component.text(player.getName()).color(NamedTextColor.WHITE));
+                list = list.append(Component.space());
+                list = list.append(Component.text("(").color(NamedTextColor.WHITE));
+                list = list.append(player.displayName());
+                list = list.append(Component.text(")").color(NamedTextColor.WHITE));
             }
             if (i != players.size() - 1)
             {
@@ -59,4 +65,13 @@ public class ListCMD extends PlexCommand
         }
         return list;
     }
+
+    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 List.of("-d", "-v");
+        }
+        return Collections.emptyList();
+    }
 }

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

@@ -4,15 +4,18 @@ 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.rank.enums.Rank;
+
 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.Collections;
+import java.util.List;
+
 @CommandParameters(name = "localspawn", description = "Teleport to the spawnpoint of the world you are in")
-@CommandPermissions(level = Rank.OP, permission = "plex.localspawn", source = RequiredCommandSource.IN_GAME)
+@CommandPermissions(permission = "plex.localspawn", source = RequiredCommandSource.IN_GAME)
 public class LocalSpawnCMD extends PlexCommand
 {
     @Override
@@ -22,4 +25,10 @@ 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,7 +5,6 @@ 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.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
@@ -16,7 +15,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.List;
 
 @CommandParameters(name = "lockup", description = "Lockup a player on the server", usage = "/<command> <player>")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.lockup")
+@CommandPermissions(permission = "plex.lockup")
 public class LockupCMD extends PlexCommand
 {
     @Override
@@ -29,19 +28,6 @@ public class LockupCMD extends PlexCommand
         Player player = getNonNullPlayer(args[0]);
         PlexPlayer punishedPlayer = getOfflinePlexPlayer(player.getUniqueId());
 
-        if (isAdmin(getPlexPlayer(player)))
-        {
-            if (!isConsole(sender))
-            {
-                assert playerSender != null;
-                PlexPlayer plexPlayer1 = getPlexPlayer(playerSender);
-                if (!plexPlayer1.getRankFromString().isAtLeast(getPlexPlayer(player).getRankFromString()))
-                {
-                    return messageComponent("higherRankThanYou");
-                }
-            }
-        }
-
         punishedPlayer.setLockedUp(!punishedPlayer.isLockedUp());
         if (punishedPlayer.isLockedUp())
         {
@@ -52,8 +38,8 @@ public class LockupCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.lockup") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -4,7 +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 dev.plex.rank.enums.Rank;
+
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -13,7 +13,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.masterbuilderworld", source = RequiredCommandSource.IN_GAME)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.masterbuilderworld", source = RequiredCommandSource.IN_GAME)
 @CommandParameters(name = "masterbuilderworld", aliases = "mbw", description = "Teleport to the Master Builder world")
 public class MasterbuilderworldCMD extends PlexCommand
 {
@@ -30,4 +33,10 @@ 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

@@ -0,0 +1,96 @@
+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 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;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@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,50 +4,119 @@ 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.rank.enums.Rank;
+import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 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.Mob;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.mobpurge", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "mobpurge", description = "Purge all mobs.", usage = "/<command>", aliases = "mp")
+@CommandPermissions(permission = "plex.mobpurge", source = RequiredCommandSource.ANY)
+@CommandParameters(name = "mobpurge", description = "Purge all mobs.", usage = "/<command> [mob]", 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)
     {
-        HashMap<String, Integer> entityCounts = new HashMap<>();
+        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;
+    }
 
+    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.getEntities())
+            for (Entity entity : world.getLivingEntities())
             {
-                if (entity instanceof Mob)
+                if (entity instanceof LivingEntity && !(entity instanceof Player))
                 {
-                    String type = entity.getType().name();
+                    if (type != null && !entity.getType().equals(type))
+                    {
+                        continue;
+                    }
                     entity.remove();
-
-                    entityCounts.put(type, entityCounts.getOrDefault(type, 0) + 1);
+                    removed++;
                 }
             }
         }
+        return removed;
+    }
 
-        int entityCount = entityCounts.values().stream().mapToInt(a -> a).sum();
+    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;
+    }
 
-        PlexUtils.broadcast(messageComponent("removedMobs", sender.getName(), entityCount));
-
-        /*entityCounts.forEach((entityName, numRemoved) -> {
-            sender.sendMessage(messageComponent("removedEntitiesOfType", sender.getName(), numRemoved, entityName));
-        });*/
-        return null;
+    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();
     }
 }

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

@@ -7,7 +7,6 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
@@ -21,7 +20,7 @@ import java.time.ZonedDateTime;
 import java.util.List;
 
 @CommandParameters(name = "mute", description = "Mute a player on the server", usage = "/<command> <player>", aliases = "stfu")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.mute")
+@CommandPermissions(permission = "plex.mute")
 public class MuteCMD extends PlexCommand
 {
     @Override
@@ -39,7 +38,7 @@ public class MuteCMD extends PlexCommand
             return messageComponent("playerMuted");
         }
 
-        if (silentCheckRank(player, Rank.ADMIN, "plex.mute"))
+        if (silentCheckPermission(player, "plex.mute"))
         {
             send(sender, messageComponent("higherRankThanYou"));
             return null;
@@ -48,11 +47,12 @@ 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.plusMinutes(5));
+        punishment.setEndDate(date.plusSeconds(plugin.config.getInt("punishments.mute-timer", 300)));
         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()));
@@ -60,8 +60,8 @@ public class MuteCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.mute") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -1,68 +0,0 @@
-package dev.plex.command.impl;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import dev.plex.command.PlexCommand;
-import dev.plex.command.annotation.CommandParameters;
-import dev.plex.command.annotation.CommandPermissions;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.*;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Arrays;
-import java.util.List;
-
-@CommandParameters(name = "namehistory", description = "Get the name history of a player", usage = "/<command> <player>", aliases = "nh")
-@CommandPermissions(level = Rank.OP, permission = "plex.namehistory")
-public class NameHistoryCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length != 1)
-        {
-            return usage();
-        }
-        String username = args[0];
-
-        AshconInfo info = MojangUtils.getInfo(username);
-        if (info == null)
-        {
-            return messageComponent("nameHistoryDoesntExist");
-        }
-        PlexLog.debug("NameHistory UUID: " + info.getUuid());
-        PlexLog.debug("NameHistory Size: " + info.getUsernameHistories().length);
-        List<Component> historyList = Lists.newArrayList();
-        Arrays.stream(info.getUsernameHistories()).forEach(history ->
-        {
-            if (history.getZonedDateTime() != null)
-            {
-                historyList.add(
-                        messageComponent("nameHistoryBody",
-                                history.getUsername(),
-                                TimeUtils.useTimezone(history.getZonedDateTime())));
-            }
-            else
-            {
-                historyList.add(
-                        Component.text(history.getUsername()).color(NamedTextColor.GOLD)
-                                .append(Component.space()));
-            }
-        });
-        send(sender, messageComponent("nameHistoryTitle", username));
-        send(sender, messageComponent("nameHistorySeparator"));
-        historyList.forEach(component -> send(sender, component));
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
-}

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

@@ -6,8 +6,6 @@ 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.rank.enums.Rank;
-import dev.plex.storage.StorageType;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
@@ -27,7 +25,7 @@ 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(level = Rank.ADMIN, permission = "plex.notes")
+@CommandPermissions(permission = "plex.notes")
 public class NotesCMD extends PlexCommand
 {
     @Override
@@ -49,27 +47,15 @@ public class NotesCMD extends PlexCommand
         {
             case "list":
             {
-                if (plugin.getStorageType() != StorageType.MONGODB)
+                plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
                 {
-                    plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
-                    {
-                        if (notes.size() == 0)
-                        {
-                            send(sender, messageComponent("noNotes"));
-                            return;
-                        }
-                        readNotes(sender, plexPlayer, notes);
-                    });
-                }
-                else
-                {
-                    List<Note> notes = plexPlayer.getNotes();
                     if (notes.size() == 0)
                     {
-                        return messageComponent("noNotes");
+                        send(sender, messageComponent("noNotes"));
+                        return;
                     }
                     readNotes(sender, plexPlayer, notes);
-                }
+                });
                 return null;
             }
             case "add":
@@ -83,14 +69,7 @@ public class NotesCMD extends PlexCommand
                 {
                     Note note = new Note(plexPlayer.getUuid(), content, playerSender.getUniqueId(), ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)));
                     plexPlayer.getNotes().add(note);
-                    if (plugin.getStorageType() != StorageType.MONGODB)
-                    {
-                        plugin.getSqlNotes().addNote(note);
-                    }
-                    else
-                    {
-                        DataUtils.update(plexPlayer);
-                    }
+                    plugin.getSqlNotes().addNote(note);
                     return messageComponent("noteAdded");
                 }
             }
@@ -109,59 +88,32 @@ public class NotesCMD extends PlexCommand
                 {
                     return messageComponent("unableToParseNumber", args[2]);
                 }
-                if (plugin.getStorageType() != StorageType.MONGODB)
+                plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
                 {
-                    plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
+                    boolean deleted = false;
+                    for (Note note : notes)
                     {
-                        boolean deleted = false;
-                        for (Note note : notes)
+                        if (note.getId() == id)
                         {
-                            if (note.getId() == id)
-                            {
-                                plugin.getSqlNotes().deleteNote(id, plexPlayer.getUuid()).whenComplete((notes1, ex1) ->
-                                        send(sender, messageComponent("removedNote", id)));
-                                deleted = true;
-                            }
+                            plugin.getSqlNotes().deleteNote(id, plexPlayer.getUuid()).whenComplete((notes1, ex1) ->
+                                    send(sender, messageComponent("removedNote", id)));
+                            deleted = true;
                         }
-                        if (!deleted)
-                        {
-                            send(sender, messageComponent("noteNotFound"));
-                        }
-                        plexPlayer.getNotes().removeIf(note -> note.getId() == id);
-                    });
-                }
-                else
-                {
-                    if (plexPlayer.getNotes().removeIf(note -> note.getId() == id))
-                    {
-                        return messageComponent("removedNote", id);
                     }
-                    return messageComponent("noteNotFound");
-                }
+                    if (!deleted)
+                    {
+                        send(sender, messageComponent("noteNotFound"));
+                    }
+                    plexPlayer.getNotes().removeIf(note -> note.getId() == id);
+                });
                 return null;
             }
             case "clear":
             {
-                if (plugin.getStorageType() != StorageType.MONGODB)
-                {
-                    plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
-                    {
-                        for (Note note : notes)
-                        {
-                            plugin.getSqlNotes().deleteNote(note.getId(), plexPlayer.getUuid());
-                        }
-                        plexPlayer.getNotes().clear();
-                        send(sender, messageComponent("clearedNotes", notes.size()));
-                    });
-                }
-                else
-                {
-                    int count = plexPlayer.getNotes().size();
-                    plexPlayer.getNotes().clear();
-                    DataUtils.update(plexPlayer);
-                    return messageComponent("clearedNotes", count);
-                }
-                return null;
+                int count = plexPlayer.getNotes().size();
+                plexPlayer.getNotes().clear();
+                DataUtils.update(plexPlayer);
+                return messageComponent("clearedNotes", count);
             }
             default:
             {
@@ -172,11 +124,11 @@ public class NotesCMD extends PlexCommand
 
     private void readNotes(@NotNull CommandSender sender, PlexPlayer plexPlayer, List<Note> notes)
     {
-        AtomicReference<Component> noteList = new AtomicReference<>(Component.text("Player notes for: " + plexPlayer.getName()).color(NamedTextColor.GREEN));
+        AtomicReference<Component> noteList = new AtomicReference<>(messageComponent("notesHeader", plexPlayer.getName()));
         for (Note note : notes)
         {
-            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()));
+            Component noteLine = messageComponent("notePrefix", note.getId(), DataUtils.getPlayer(note.getWrittenBy()).getName(), TimeUtils.useTimezone(note.getTimestamp()));
+            noteLine = noteLine.append(messageComponent("noteLine", note.getNote()));
             noteList.set(noteList.get().append(Component.newline()));
             noteList.set(noteList.get().append(noteLine));
         }
@@ -184,16 +136,20 @@ public class NotesCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (args.length == 1)
+        if (silentCheckPermission(sender, this.getPermission()))
         {
-            return PlexUtils.getPlayerNameList();
-        }
-        if (args.length == 2)
-        {
-            return Arrays.asList("list", "add", "remove", "clear");
+            if (args.length == 1)
+            {
+                return PlexUtils.getPlayerNameList();
+            }
+            if (args.length == 2)
+            {
+                return Arrays.asList("list", "add", "remove", "clear");
+            }
+            return Collections.emptyList();
         }
         return Collections.emptyList();
     }
-}
+}

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

@@ -1,31 +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.annotation.System;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-import net.kyori.adventure.text.Component;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-@CommandParameters(name = "opall", description = "Op everyone on the server", aliases = "opa")
-@CommandPermissions(level = Rank.ADMIN)
-@System(value = "ranks")
-public class OpAllCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        for (Player player : Bukkit.getOnlinePlayers())
-        {
-            player.setOp(true);
-        }
-        PlexUtils.broadcast(messageComponent("oppedAllPlayers", sender.getName()));
-        return null;
-    }
-}

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

@@ -1,41 +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.command.annotation.System;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-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 = "op", description = "Op a player on the server", usage = "/<command> <player>")
-@CommandPermissions(level = Rank.OP)
-@System(value = "ranks")
-public class OpCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length != 1)
-        {
-            return usage();
-        }
-        Player player = getNonNullPlayer(args[0]);
-        player.setOp(true);
-        PlexUtils.broadcast(messageComponent("oppedPlayer", sender.getName(), player.getName()));
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
-    }
-}

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

@@ -7,7 +7,6 @@ import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.module.PlexModule;
 import dev.plex.module.PlexModuleFile;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.BuildInfo;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
@@ -25,7 +24,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-@CommandPermissions(level = Rank.IMPOSTOR, source = RequiredCommandSource.ANY)
+@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
 {
@@ -36,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.getHead()));
+            send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion() + " #" + BuildInfo.getNumber() + " <light_purple>Git: <gold>" + BuildInfo.getCommit()));
             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."));
@@ -45,7 +44,7 @@ public class PlexCMD extends PlexCommand
         }
         if (args[0].equalsIgnoreCase("reload"))
         {
-            checkRank(sender, Rank.SENIOR_ADMIN, "plex.reload");
+            checkPermission(sender, "plex.reload");
             plugin.config.load();
             send(sender, "Reloaded config file");
             plugin.messages.load();
@@ -55,10 +54,7 @@ public class PlexCMD extends PlexCommand
             send(sender, "Reloaded indefinite bans");
             plugin.commands.load();
             send(sender, "Reloaded blocked commands file");
-            plugin.getRankManager().importDefaultRanks();
-            send(sender, "Imported ranks");
-            plugin.setSystem(plugin.config.getString("system"));
-            if (plugin.getSystem().equalsIgnoreCase("permissions") && !plugin.getServer().getPluginManager().isPluginEnabled("Vault"))
+            if (!plugin.getServer().getPluginManager().isPluginEnabled("Vault"))
             {
                 throw new RuntimeException("Vault is required to run on the server if you use permissions!");
             }
@@ -72,7 +68,7 @@ public class PlexCMD extends PlexCommand
         }
         else if (args[0].equalsIgnoreCase("redis"))
         {
-            checkRank(sender, Rank.SENIOR_ADMIN, "plex.redis");
+            checkPermission(sender, "plex.redis");
             if (!plugin.getRedisConnection().isEnabled())
             {
                 throw new CommandFailException("&cRedis is not enabled.");
@@ -91,7 +87,7 @@ public class PlexCMD extends PlexCommand
             }
             if (args[1].equalsIgnoreCase("reload"))
             {
-                checkRank(sender, Rank.EXECUTIVE, "plex.modules.reload");
+                checkPermission(sender, "plex.modules.reload");
                 plugin.getModuleManager().reloadModules();
                 return mmString("<green>All modules reloaded!");
             }
@@ -99,7 +95,7 @@ public class PlexCMD extends PlexCommand
             {
                 if (!hasUpdateAccess(playerSender, sender))
                 {
-                    return messageComponent("noPermissionRank", "an Owner or Developer");
+                    return messageComponent("noPermissionRank", "a Developer");
                 }
                 for (PlexModule module : plugin.getModuleManager().getModules())
                 {
@@ -113,7 +109,7 @@ public class PlexCMD extends PlexCommand
         {
             if (!hasUpdateAccess(playerSender, sender))
             {
-                return messageComponent("noPermissionRank", "an Owner or Developer");
+                return messageComponent("noPermissionRank", "a Developer");
             }
             if (!plugin.getUpdateChecker().getUpdateStatusMessage(sender, false, 0))
             {
@@ -130,7 +126,7 @@ public class PlexCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
         if (args.length == 1)
         {
@@ -156,13 +152,11 @@ public class PlexCMD extends PlexCommand
             OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(sender.getName());
             if (offlinePlayer.hasPlayedBefore())
             {
-                return PlexUtils.DEVELOPERS.contains(offlinePlayer.getUniqueId().toString())
-                        || plugin.config.getStringList("titles.owners").contains(sender.getName());
+                return PlexUtils.DEVELOPERS.contains(offlinePlayer.getUniqueId().toString());
             }
             return false;
         }
         assert player != null;
-        return PlexUtils.DEVELOPERS.contains(player.getUniqueId().toString())
-                || plugin.config.getStringList("titles.owners").contains(player.getName());
+        return PlexUtils.DEVELOPERS.contains(player.getUniqueId().toString());
     }
 }

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

@@ -1,14 +1,19 @@
 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.menu.PunishmentMenu;
-import dev.plex.rank.enums.Rank;
+import dev.plex.menu.impl.PunishedPlayerMenu;
+import dev.plex.menu.impl.PunishmentMenu;
+import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -17,19 +22,35 @@ import org.jetbrains.annotations.Nullable;
 import java.util.List;
 
 @CommandParameters(name = "punishments", usage = "/<command> [player]", description = "Opens the Punishments GUI", aliases = "punishlist,punishes")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.punishments", source = RequiredCommandSource.IN_GAME)
+@CommandPermissions(permission = "plex.punishments", source = RequiredCommandSource.IN_GAME)
 public class PunishmentsCMD extends PlexCommand
 {
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
     {
-        new PunishmentMenu().openInv(playerSender, 0);
+        if (args.length == 0)
+        {
+            new PunishmentMenu().open(playerSender);
+        }
+        else
+        {
+            if (!DataUtils.hasPlayedBefore(args[0]))
+            {
+                throw new PlayerNotFoundException();
+            }
+
+            final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(args[0]);
+            final PlexPlayer player = offlinePlayer.isOnline() ? getOnlinePlexPlayer(args[0]) : getOfflinePlexPlayer(offlinePlayer.getUniqueId());
+
+            new PunishedPlayerMenu(player).open(playerSender);
+        }
+
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -1,58 +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.annotation.System;
-import dev.plex.command.exception.CommandFailException;
-import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-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.Collections;
-import java.util.List;
-
-@CommandPermissions(level = Rank.OP, permission = "plex.rank", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "rank", description = "Displays your rank")
-@System(value = "ranks")
-public class RankCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
-    {
-        if (args.length == 0)
-        {
-            if (isConsole(sender))
-            {
-                throw new CommandFailException("<red>When using the console, you must specify a player's rank.");
-            }
-            if (!(playerSender == null))
-            {
-                Rank rank = getPlexPlayer(playerSender).getRankFromString();
-                return messageComponent("yourRank", rank.isAtLeast(Rank.ADMIN) && !getPlexPlayer(playerSender).isAdminActive() ? (playerSender.isOp() ? Rank.OP.getReadable() : Rank.NONOP.getReadable()) : rank.getReadable());
-            }
-        }
-        else
-        {
-            Player player = getNonNullPlayer(args[0]);
-            Rank rank = getPlexPlayer(player).getRankFromString();
-            return messageComponent("otherRank", player.getName(), rank.isAtLeast(Rank.ADMIN) && !getPlexPlayer(player).isAdminActive() ? (player.isOp() ? Rank.OP.getReadable() : Rank.NONOP.getReadable()) : rank.getReadable());
-        }
-        return null;
-    }
-
-    @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
-    {
-        if (args.length == 1)
-        {
-            return PlexUtils.getPlayerNameList();
-        }
-        return Collections.emptyList();
-    }
-}

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

@@ -4,7 +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 dev.plex.rank.enums.Rank;
+
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
@@ -13,7 +13,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.SENIOR_ADMIN, permission = "plex.rawsay", source = RequiredCommandSource.ANY)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.rawsay", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "rawsay", usage = "/<command> <message>", description = "Displays a raw message to everyone")
 public class RawSayCMD extends PlexCommand
 {
@@ -28,4 +31,10 @@ 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,19 +1,22 @@
 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.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
 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(level = Rank.ADMIN, permission = "plex.removeloginmessage", source = RequiredCommandSource.ANY)
+import java.util.List;
+
+@CommandPermissions(permission = "plex.removeloginmessage", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "removeloginmessage", usage = "/<command> [-o <player>]", description = "Remove your own (or someone else's) login message", aliases = "rlm,removeloginmsg")
 public class RemoveLoginMessageCMD extends PlexCommand
 {
@@ -31,7 +34,7 @@ public class RemoveLoginMessageCMD extends PlexCommand
         }
         else if (args[0].equalsIgnoreCase("-o"))
         {
-            checkRank(sender, Rank.SENIOR_ADMIN, "plex.removeloginmessage.others");
+            checkPermission(sender, "plex.removeloginmessage.others");
 
             if (args.length < 2)
             {
@@ -52,4 +55,17 @@ 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,7 +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 dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
@@ -13,7 +12,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.say", source = RequiredCommandSource.ANY)
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.say", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "say", usage = "/<command> <message>", description = "Displays a message to everyone")
 public class SayCMD extends PlexCommand
 {
@@ -28,4 +30,10 @@ 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,5 +1,6 @@
 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;
@@ -7,21 +8,23 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
 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;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.setloginmessage", source = RequiredCommandSource.ANY)
+import java.util.List;
+
+@CommandPermissions(permission = "plex.setloginmessage", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "setloginmessage", usage = "/<command> [-o <player>] <message>", description = "Sets your (or someone else's) login message", aliases = "slm,setloginmsg")
 public class SetLoginMessageCMD extends PlexCommand
 {
     private final boolean nameRequired = plugin.getConfig().getBoolean("loginmessages.name");
-    private final boolean rankRequired = plugin.getConfig().getBoolean("loginmessages.rank");
 
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
@@ -34,7 +37,7 @@ public class SetLoginMessageCMD extends PlexCommand
         {
             if (args[0].equals("-o"))
             {
-                checkRank(sender, Rank.SENIOR_ADMIN, "plex.setloginmessage.others");
+                checkPermission(sender, "plex.setloginmessage.others");
 
                 if (args.length < 2)
                 {
@@ -54,21 +57,18 @@ public class SetLoginMessageCMD extends PlexCommand
                 validateMessage(message);
                 plexPlayer.setLoginMessage(message);
                 return messageComponent("setOtherPlayersLoginMessage", plexPlayer.getName(),
-                        message.replace("%player%", plexPlayer.getName())
-                                .replace("%rank%", plexPlayer.getRank()));
+                        MiniMessage.miniMessage().serialize(PlexUtils.stringToComponent(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);
-            message = message.replace(plexPlayer.getName(), "%player%");
+            String message = StringUtils.join(args, " ", 0, args.length)
+                    .replace(plexPlayer.getName(), "%player%");
             validateMessage(message);
             plexPlayer.setLoginMessage(message);
-            return messageComponent("setOwnLoginMessage",
-                    message.replace("%player%", plexPlayer.getName())
-                            .replace("%rank%", plexPlayer.getRank()));
+            return messageComponent("setOwnLoginMessage", PlexUtils.stringToComponent(message.replace("%player%", plexPlayer.getName())));
         }
         return null;
     }
@@ -80,10 +80,18 @@ public class SetLoginMessageCMD extends PlexCommand
             PlexLog.debug("Validating login message has a valid name in it");
             throw new CommandFailException(messageString("nameRequired"));
         }
-        if (plugin.getSystem().equalsIgnoreCase("ranks") && rankRequired && !message.contains("%rank%"))
+    }
+
+    @Override
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    {
+        if (args.length == 1)
         {
-            PlexLog.debug("Validating login message has a valid rank in it");
-            throw new CommandFailException(messageString("rankRequired"));
+            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,7 +7,6 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
-import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
@@ -28,7 +27,7 @@ import java.time.ZonedDateTime;
 import java.util.Collections;
 import java.util.List;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.smite", source = RequiredCommandSource.ANY)
+@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
 {
@@ -79,27 +78,16 @@ public class SmiteCMD extends PlexCommand
         final Player player = getNonNullPlayer(args[0]);
         final PlexPlayer plexPlayer = getPlexPlayer(player);
 
-        Title title = Title.title(Component.text("You've been smitten.").color(NamedTextColor.RED), Component.text("Be sure to follow the rules!").color(NamedTextColor.YELLOW));
+        Title title = Title.title(messageComponent("smiteTitleHeader"), messageComponent("smiteTitleMessage", reason, sender.getName()));
         player.showTitle(title);
 
         if (!silent)
         {
-            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()));
+            PlexUtils.broadcast(messageComponent("smiteBroadcast", player.getName(), reason != null ? reason : messageString("noReasonProvided"), sender.getName()));
         }
         else
         {
-            send(sender, "Smitten " + player.getName() + " quietly.");
-        }
-
-        // Deop
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            player.setOp(false);
+            send(sender, messageComponent("smittenQuietly", player.getName()));
         }
 
         // Set gamemode to survival
@@ -136,18 +124,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> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (checkTab(sender, Rank.ADMIN, "plex.smite") && args.length == 1)
+        if (silentCheckPermission(sender, this.getPermission()) && args.length == 1)
         {
             return PlexUtils.getPlayerNameList();
         }
         return Collections.emptyList();
     }
-}
+}

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

@@ -7,7 +7,7 @@ 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.rank.enums.Rank;
+
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -19,7 +19,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.gamemode.spectator", source = RequiredCommandSource.ANY)
+@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
 {
@@ -36,7 +36,7 @@ public class SpectatorCMD extends PlexCommand
             return null;
         }
 
-        if (checkRank(sender, Rank.ADMIN, "plex.gamemode.spectator.others"))
+        if (checkPermission(sender,"plex.gamemode.spectator.others"))
         {
             if (args[0].equals("-a"))
             {
@@ -56,9 +56,9 @@ public class SpectatorCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (checkTab(sender, Rank.ADMIN, "plex.gamemode.spectator.others"))
+        if (silentCheckPermission(sender,"plex.gamemode.spectator.others"))
         {
             return PlexUtils.getPlayerNameList();
         }

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

@@ -7,7 +7,7 @@ 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.rank.enums.Rank;
+
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
@@ -19,7 +19,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.gamemode.survival", source = RequiredCommandSource.ANY)
+@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
 {
@@ -36,7 +36,7 @@ public class SurvivalCMD extends PlexCommand
             return null;
         }
 
-        if (checkRank(sender, Rank.ADMIN, "plex.gamemode.survival.others"))
+        if (checkPermission(sender,"plex.gamemode.survival.others"))
         {
             if (args[0].equals("-a"))
             {
@@ -57,9 +57,9 @@ public class SurvivalCMD extends PlexCommand
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (checkTab(sender, Rank.ADMIN, "plex.gamemode.survival.others"))
+        if (silentCheckPermission(sender,"plex.gamemode.survival.others"))
         {
             return PlexUtils.getPlayerNameList();
         }

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

@@ -1,47 +0,0 @@
-package dev.plex.command.impl;
-
-import com.google.common.base.Splitter;
-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.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-import net.kyori.adventure.inventory.Book;
-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.ArrayList;
-import java.util.List;
-
-@CommandParameters(name = "totalfreedommod", description = "You can't simpy do that.", aliases = "tfm")
-@CommandPermissions(level = Rank.OP, source = RequiredCommandSource.ANY)
-
-public class TFMCMD extends PlexCommand
-{
-    @Override
-    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
-    {
-        if (playerSender != null)
-        {
-            String simpy = "It's not about credit or discredit, it's about copyright of TFM. Looking at Plex's source code, it looks like a bunch of copy-pasted source code from TFM and Aero (utility plugin). You just put it under a different license and pretended it's yours. You can't simpy do that. You have to remove all parts which infringe on the TFM license (as per the TFM repository) and the Aero License (as per the Aero repository) or otherwise comply to the license requirements.";
-            List<String> pages = Splitter.fixedLength(256).splitToList(simpy);
-            List<Component> pageComponents = new ArrayList<>();
-
-            for (String page : pages)
-            {
-                pageComponents.add(PlexUtils.mmDeserialize("<rainbow>" + page + "</rainbow>"));
-            }
-
-            playerSender.openBook(Book.builder()
-                    .title(Component.text("TFM License"))
-                    .author(Component.text("Prozza"))
-                    .pages(pageComponents));
-        }
-
-        return PlexUtils.mmDeserialize("<rainbow>It's not about credit or discredit, it's about copyright of TFM.<br>Looking at Plex's source code, it looks like a bunch of copy-pasted source code from TFM and Aero (utility plugin). You just put it under a different license and pretended it's yours.<br>You can't simpy do that. You have to remove all parts which infringe on the TFM license (as per the TFM repository) and the Aero License (as per the Aero repository) or otherwise comply to the license requirements.</rainbow>");
-    }
-}

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

@@ -6,7 +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 dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.minimessage.SafeMiniMessage;
 import net.kyori.adventure.text.Component;
@@ -19,7 +18,11 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.tag", source = RequiredCommandSource.ANY)
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@CommandPermissions(permission = "plex.tag", source = RequiredCommandSource.ANY)
 @CommandParameters(name = "tag", aliases = "prefix", description = "Set or clear your prefix", usage = "/<command> <set <prefix> | clear <player>>")
 public class TagCMD extends PlexCommand
 {
@@ -47,16 +50,15 @@ public class TagCMD extends PlexCommand
             {
                 return usage("/tag set <prefix>");
             }
-            String prefix = PlexUtils.cleanString(StringUtils.join(args, " ", 1, args.length));
 
-            Component convertedComponent = SafeMiniMessage.mmDeserializeWithoutEvents(prefix);
+            Component convertedComponent = PlexUtils.stringToComponent(StringUtils.join(args, " ", 1, args.length));
 
             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(prefix);
+            player.setPrefix(MiniMessage.miniMessage().serialize(convertedComponent));
             DataUtils.update(player);
             return messageComponent("prefixSetTo", MiniMessage.miniMessage().serialize(convertedComponent));
         }
@@ -76,20 +78,39 @@ public class TagCMD extends PlexCommand
                 }
 
                 PlexPlayer player = DataUtils.getPlayer(playerSender.getUniqueId());
-                player.setPrefix("");
+                player.setPrefix(null);
                 DataUtils.update(player);
                 return messageComponent("prefixCleared");
             }
-
-            checkRank(sender, Rank.ADMIN, "plex.tag.clear.others");
+            checkPermission(sender, "plex.tag.clear.others");
             Player target = getNonNullPlayer(args[1]);
             PlexPlayer plexTarget = DataUtils.getPlayer(target.getUniqueId());
-            plexTarget.setPrefix("");
+            plexTarget.setPrefix(null);
             DataUtils.update(plexTarget);
             return messageComponent("otherPrefixCleared", target.getName());
         }
         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,11 +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.rank.enums.Rank;
 import dev.plex.util.BungeeUtil;
+import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
-import dev.plex.util.WebUtils;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
@@ -23,11 +22,11 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Collections;
 import java.util.List;
-import java.util.UUID;
 
-@CommandParameters(name = "tempban", usage = "/<command> <player> <time> [reason]", description = "Temporarily ban a player")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.tempban", source = RequiredCommandSource.ANY)
+@CommandParameters(name = "tempban", usage = "/<command> <player> <time> [reason] [-rb]", description = "Temporarily ban a player")
+@CommandPermissions(permission = "plex.tempban", source = RequiredCommandSource.ANY)
 
 public class TempbanCMD extends PlexCommand
 {
@@ -39,65 +38,87 @@ public class TempbanCMD extends PlexCommand
             return usage();
         }
 
-        UUID targetUUID = WebUtils.getFromName(args[0]);
+        PlexPlayer target = DataUtils.getPlayer(args[0]);
         String reason;
 
-        if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+        if (target == null)
         {
             throw new PlayerNotFoundException();
         }
+        Player player = Bukkit.getPlayer(target.getUuid());
 
-        PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
-        Player player = Bukkit.getPlayer(targetUUID);
-
-        if (isAdmin(plexPlayer))
-        {
-            if (!isConsole(sender))
-            {
-                assert playerSender != null;
-                PlexPlayer plexPlayer1 = getPlexPlayer(playerSender);
-                if (!plexPlayer1.getRankFromString().isAtLeast(plexPlayer.getRankFromString()) && plexPlayer.isAdminActive())
-                {
-                    return messageComponent("higherRankThanYou");
-                }
-            }
-        }
-
-        if (plugin.getPunishmentManager().isBanned(targetUUID))
+        if (plugin.getPunishmentManager().isBanned(target.getUuid()))
         {
             return messageComponent("playerBanned");
         }
-        Punishment punishment = new Punishment(targetUUID, getUUID(sender));
+        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);
-            punishment.setReason(reason);
+            String newReason = StringUtils.normalizeSpace(reason.replace("-nrb", ""));
+            punishment.setReason(newReason.trim().isEmpty() ? messageString("noReasonProvided") : newReason);
+            rollBack = reason.startsWith("-rb") || reason.endsWith("-rb");
         }
         else
         {
-            punishment.setReason("No reason provided.");
+            punishment.setReason(messageString("noReasonProvided"));
         }
-        punishment.setPunishedUsername(plexPlayer.getName());
+        punishment.setPunishedUsername(target.getName());
         punishment.setEndDate(TimeUtils.createDate(args[1]));
         punishment.setCustomTime(false);
-        punishment.setActive(!isAdmin(plexPlayer));
+        punishment.setActive(true);
         if (player != null)
         {
             punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
         }
-        plugin.getPunishmentManager().punish(plexPlayer, punishment);
-        PlexUtils.broadcast(messageComponent("banningPlayer", sender.getName(), plexPlayer.getName()));
+        plugin.getPunishmentManager().punish(target, punishment);
+        PlexUtils.broadcast(messageComponent("banningPlayer", sender.getName(), target.getName()));
         if (player != null)
         {
             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> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.tempban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -0,0 +1,92 @@
+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 your TimeUtils
+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.ZonedDateTime;
+import java.util.Arrays;
+import java.util.List;
+
+@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

@@ -5,8 +5,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 dev.plex.menu.ToggleMenu;
-import dev.plex.rank.enums.Rank;
+import dev.plex.menu.impl.ToggleMenu;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
@@ -18,7 +17,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.List;
 
 @CommandParameters(name = "toggle", description = "Allows toggling various server aspects through a GUI", aliases = "toggles")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.toggle", source = RequiredCommandSource.ANY)
+@CommandPermissions(permission = "plex.toggle", source = RequiredCommandSource.ANY)
 public class ToggleCMD extends PlexCommand
 {
     @Override
@@ -33,6 +32,8 @@ 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,20 +54,29 @@ 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");
                 }
             }
         }
-        new ToggleMenu().openInv(playerSender, 0);
+        new ToggleMenu().open(playerSender);
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 
     private String status(String toggle)

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

@@ -9,9 +9,7 @@ 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.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
-import dev.plex.util.WebUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -19,10 +17,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.UUID;
 
 @CommandParameters(name = "unban", usage = "/<command> <player>", description = "Unbans a player, offline or online")
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.ban", source = RequiredCommandSource.ANY)
+@CommandPermissions(permission = "plex.ban", source = RequiredCommandSource.ANY)
 
 public class UnbanCMD extends PlexCommand
 {
@@ -36,31 +33,30 @@ public class UnbanCMD extends PlexCommand
 
         if (args.length == 1)
         {
-            UUID targetUUID = WebUtils.getFromName(args[0]);
+            PlexPlayer target = DataUtils.getPlayer(args[0]);
 
-            if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+            if (target == null)
             {
                 throw new PlayerNotFoundException();
             }
 
-            plugin.getPunishmentManager().isAsyncBanned(targetUUID).whenComplete((aBoolean, throwable) ->
+            plugin.getPunishmentManager().isAsyncBanned(target.getUuid()).whenComplete((aBoolean, throwable) ->
             {
-                PlexPlayer plexPlayer = getOfflinePlexPlayer(targetUUID);
                 if (!aBoolean)
                 {
                     send(sender, PlexUtils.mmDeserialize(new PlayerNotBannedException().getMessage()));
                     return;
                 }
-                plugin.getPunishmentManager().unban(targetUUID);
-                PlexUtils.broadcast(messageComponent("unbanningPlayer", sender.getName(), plexPlayer.getName()));
+                plugin.getPunishmentManager().unban(target.getUuid());
+                PlexUtils.broadcast(messageComponent("unbanningPlayer", sender.getName(), target.getName()));
             });
         }
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.unban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -1,12 +1,14 @@
 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.rank.enums.Rank;
+import dev.plex.punishment.PunishmentType;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
@@ -16,7 +18,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.unfreeze")
+@CommandPermissions(permission = "plex.unfreeze")
 @CommandParameters(name = "unfreeze", description = "Unfreeze a player", usage = "/<command> <player>")
 public class UnfreezeCMD extends PlexCommand
 {
@@ -27,20 +29,28 @@ public class UnfreezeCMD extends PlexCommand
         {
             return usage();
         }
-        Player player = getNonNullPlayer(args[0]);
-        PlexPlayer punishedPlayer = getOfflinePlexPlayer(player.getUniqueId());
+        PlexPlayer punishedPlayer = DataUtils.getPlayer(args[0]);
+        if (punishedPlayer == null)
+        {
+            throw new PlayerNotFoundException();
+        }
+
         if (!punishedPlayer.isFrozen())
         {
             throw new CommandFailException(PlexUtils.messageString("playerNotFrozen"));
         }
         punishedPlayer.setFrozen(false);
-        PlexUtils.broadcast(messageComponent("unfrozePlayer", sender.getName(), player.getName()));
+        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()));
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.unfreeze") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -1,12 +1,14 @@
 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.rank.enums.Rank;
+import dev.plex.punishment.PunishmentType;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
@@ -16,7 +18,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@CommandPermissions(level = Rank.ADMIN, permission = "plex.unmute")
+@CommandPermissions(permission = "plex.unmute")
 @CommandParameters(name = "unmute", description = "Unmute a player", usage = "/<command> <player>")
 public class UnmuteCMD extends PlexCommand
 {
@@ -27,20 +29,28 @@ public class UnmuteCMD extends PlexCommand
         {
             return usage();
         }
-        Player player = getNonNullPlayer(args[0]);
-        PlexPlayer punishedPlayer = getOfflinePlexPlayer(player.getUniqueId());
+        PlexPlayer punishedPlayer = DataUtils.getPlayer(args[0]);
+        if (punishedPlayer == null)
+        {
+            throw new PlayerNotFoundException();
+        }
+
         if (!punishedPlayer.isMuted())
         {
             throw new CommandFailException(PlexUtils.messageString("playerNotMuted"));
         }
         punishedPlayer.setMuted(false);
-        PlexUtils.broadcast(messageComponent("unmutedPlayer", sender.getName(), player.getName()));
+        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()));
         return null;
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.unfreeze") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+        return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
     }
 }

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

@@ -0,0 +1,79 @@
+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 net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+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.Collections;
+
+@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
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+
+        final Material material = Material.getMaterial(args[0].toUpperCase());
+
+        if (material == null)
+        {
+            return messageComponent("materialNotFound", args[0]);
+        }
+
+        boolean clearInventory = args.length > 1 && args[1].equalsIgnoreCase("clear");
+
+        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)));
+    }
+
+    @Override
+    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 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();
+    }
+}

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

@@ -1,14 +1,13 @@
 package dev.plex.command.impl;
 
-import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import dev.plex.Plex;
 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.rank.enums.Rank;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
-import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -16,12 +15,15 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.stream.Collectors;
+import java.util.UUID;
+import java.util.regex.Pattern;
 
-@CommandPermissions(level = Rank.OP, permission = "plex.world", source = RequiredCommandSource.IN_GAME)
+@CommandPermissions(permission = "plex.world", source = RequiredCommandSource.IN_GAME)
 @CommandParameters(name = "world", description = "Teleport to a world.", usage = "/<command> <world>")
 public class WorldCMD extends PlexCommand
 {
+    private static final Pattern UUID_PATTERN = Pattern.compile("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
+
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
     {
@@ -30,18 +32,44 @@ public class WorldCMD extends PlexCommand
         {
             return usage();
         }
+
         World world = getNonNullWorld(args[0]);
-        playerSender.teleportAsync(new Location(world, 0, world.getHighestBlockYAt(0, 0) + 1, 0, 0, 0));
+        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");
+        }
+        playerSender.teleportAsync(world.getSpawnLocation());
         return messageComponent("playerWorldTeleport", world.getName());
     }
 
     @Override
-    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (args.length == 1)
+        final List<String> completions = Lists.newArrayList();
+        final Player player = (Player) sender;
+        if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
         {
-            return Bukkit.getWorlds().stream().map(World::getName).collect(Collectors.toList());
+            @NotNull List<World> worlds = Bukkit.getWorlds();
+            for (World world : worlds)
+            {
+                String worldName = world.getName();
+
+                try
+                {
+                    final UUID uuid = UUID.fromString(worldName);
+                    if (uuid.equals(player.getUniqueId()) || silentCheckPermission(player, "plex.world.playerworlds"))
+                    {
+                        completions.add(worldName);
+                    }
+                }
+                catch (Exception e)
+                {
+                    completions.add(worldName);
+                }
+            }
         }
-        return ImmutableList.of();
+
+        return completions;
     }
 }

server/src/main/java/dev/plex/event/AdminAddEvent.java

@@ -1,39 +0,0 @@
-package dev.plex.event;
-
-import dev.plex.player.PlexPlayer;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import org.bukkit.command.CommandSender;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-/**
- * Event that is run when a player is added to the admin list
- */
-@EqualsAndHashCode(callSuper = false)
-@Data
-public class AdminAddEvent extends Event
-{
-    private static final HandlerList handlers = new HandlerList();
-
-    /**
-     * The sender who added the player
-     */
-    private final CommandSender sender;
-
-    /**
-     * The PlexPlayer that was added
-     */
-    private final PlexPlayer plexPlayer;
-
-    public static HandlerList getHandlerList()
-    {
-        return handlers;
-    }
-
-    @Override
-    public HandlerList getHandlers()
-    {
-        return handlers;
-    }
-}

server/src/main/java/dev/plex/event/AdminRemoveEvent.java

@@ -1,39 +0,0 @@
-package dev.plex.event;
-
-import dev.plex.player.PlexPlayer;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import org.bukkit.command.CommandSender;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-/**
- * Event that is run when a player is removed from the admin list
- */
-@EqualsAndHashCode(callSuper = false)
-@Data
-public class AdminRemoveEvent extends Event
-{
-    private static final HandlerList handlers = new HandlerList();
-
-    /**
-     * The sender who added the player
-     */
-    private final CommandSender sender;
-
-    /**
-     * The PlexPlayer that was removed
-     */
-    private final PlexPlayer plexPlayer;
-
-    public static HandlerList getHandlerList()
-    {
-        return handlers;
-    }
-
-    @Override
-    public HandlerList getHandlers()
-    {
-        return handlers;
-    }
-}

server/src/main/java/dev/plex/event/AdminSetRankEvent.java

@@ -1,45 +0,0 @@
-package dev.plex.event;
-
-import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import org.bukkit.command.CommandSender;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-/**
- * Event that is run when an admins rank is set
- */
-@EqualsAndHashCode(callSuper = false)
-@Data
-public class AdminSetRankEvent extends Event
-{
-    private static final HandlerList handlers = new HandlerList();
-
-    /**
-     * The sender who added the player
-     */
-    private final CommandSender sender;
-
-    /**
-     * The PlexPlayer that was removed
-     */
-    private final PlexPlayer plexPlayer;
-
-    /**
-     * The rank the player was set to
-     */
-    private final Rank rank;
-
-    public static HandlerList getHandlerList()
-    {
-        return handlers;
-    }
-
-    @Override
-    public HandlerList getHandlers()
-    {
-        return handlers;
-    }
-}

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

@@ -3,7 +3,7 @@ package dev.plex.handlers;
 import com.google.common.collect.Lists;
 import dev.plex.PlexBase;
 import dev.plex.command.PlexCommand;
-import dev.plex.command.annotation.System;
+import dev.plex.command.impl.DebugCMD;
 import dev.plex.util.PlexLog;
 import dev.plex.util.ReflectionsUtil;
 
@@ -22,18 +22,9 @@ public class CommandHandler implements PlexBase
         {
             try
             {
-                if (clazz.isAnnotationPresent(System.class))
+                if (plugin.config.getBoolean("debug") && DebugCMD.class.isAssignableFrom(clazz))
                 {
-                    System annotation = clazz.getDeclaredAnnotation(System.class);
-                    if (annotation.value().equalsIgnoreCase(plugin.getSystem().toLowerCase()))
-                    {
-                        commands.add(clazz.getConstructor().newInstance());
-                    }
-
-                    if (plugin.config.getBoolean("debug") && annotation.debug())
-                    {
-                        commands.add(clazz.getConstructor().newInstance());
-                    }
+                    commands.add(clazz.getConstructor().newInstance());
                 }
                 else
                 {

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

@@ -0,0 +1,63 @@
+package dev.plex.hook;
+
+import dev.plex.Plex;
+import dev.plex.player.PlexPlayer;
+import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
+import dev.plex.util.minimessage.SafeMiniMessage;
+import net.coreprotect.CoreProtect;
+import net.coreprotect.CoreProtectAPI;
+import net.kyori.adventure.text.Component;
+import net.milkbowl.vault.chat.Chat;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+import java.util.UUID;
+
+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

@@ -0,0 +1,34 @@
+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

@@ -1,15 +1,18 @@
 package dev.plex.hook;
 
-import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
+import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
+import dev.plex.util.minimessage.SafeMiniMessage;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import net.milkbowl.vault.chat.Chat;
 import net.milkbowl.vault.permission.Permission;
 import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.plugin.RegisteredServiceProvider;
 
+import java.util.UUID;
+
 public class VaultHook
 {
     private static Chat CHAT;
@@ -51,20 +54,36 @@ public class VaultHook
         return PERMISSIONS;
     }
 
+    public static Component getPrefix(UUID uuid)
+    {
+        return getPrefix(Bukkit.getOfflinePlayer(uuid));
+    }
+
     public static Component getPrefix(PlexPlayer plexPlayer)
+    {
+        return getPrefix(Bukkit.getOfflinePlayer(plexPlayer.getUuid()));
+    }
+
+    public static Component getPrefix(OfflinePlayer player)
     {
         if (VaultHook.getChat() == null || VaultHook.getPermission() == null)
         {
-            return null;
+            return Component.empty();
         }
-        if (Plex.get().getRankManager().getConfigPrefixes(plexPlayer) != null)
+        if (PlexUtils.DEVELOPERS.contains(player.getUniqueId().toString()))
         {
-            return Plex.get().getRankManager().getConfigPrefixes(plexPlayer);
+            return PlexUtils.mmDeserialize("<dark_gray>[<dark_purple>Developer<dark_gray>]");
         }
-        Player bukkitPlayer = Bukkit.getPlayer(plexPlayer.getUuid());
-        String group = VaultHook.getPermission().getPrimaryGroup(bukkitPlayer);
-        String vaultPrefix = VaultHook.getChat().getGroupPrefix(bukkitPlayer.getWorld(), group);
-        return LegacyComponentSerializer.legacyAmpersand().deserialize(vaultPrefix);
+        String group = VaultHook.getPermission().getPrimaryGroup(null, player);
+        if (group == null || group.isEmpty()) {
+            return Component.empty();
+        }
+        String vaultPrefix = VaultHook.getChat().getGroupPrefix((String) null, group);
+        if (vaultPrefix == null || vaultPrefix.isEmpty()) {
+            return Component.empty();
+        }
+        PlexLog.debug("prefix: {0}", SafeMiniMessage.mmSerializeWithoutEvents(PlexUtils.stringToComponent(vaultPrefix)).replace("<", "\\<"));
+        return PlexUtils.stringToComponent(vaultPrefix);
     }
 
     public static Permission getPermission()

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

@@ -1,55 +0,0 @@
-package dev.plex.listener.impl;
-
-import dev.plex.cache.DataUtils;
-import dev.plex.event.AdminAddEvent;
-import dev.plex.event.AdminRemoveEvent;
-import dev.plex.event.AdminSetRankEvent;
-import dev.plex.listener.PlexListener;
-import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
-import dev.plex.util.PlexUtils;
-import org.bukkit.event.EventHandler;
-
-import static dev.plex.util.PlexUtils.messageComponent;
-
-public class AdminListener extends PlexListener
-{
-    @EventHandler
-    public void onAdminAdd(AdminAddEvent event)
-    {
-        String userSender = event.getSender().getName();
-        PlexPlayer target = event.getPlexPlayer();
-        if (target.getRankFromString().isAtLeast(Rank.ADMIN))
-        {
-            PlexUtils.broadcast(messageComponent("adminReadded", userSender, target.getName(), target.getRankFromString().getReadable()));
-        }
-        else
-        {
-            target.setRank(Rank.ADMIN.name());
-            PlexUtils.broadcast(messageComponent("newAdminAdded", userSender, target.getName()));
-        }
-        target.setAdminActive(true);
-        DataUtils.update(target);
-    }
-
-    @EventHandler
-    public void onAdminRemove(AdminRemoveEvent event)
-    {
-        String userSender = event.getSender().getName();
-        PlexPlayer target = event.getPlexPlayer();
-        target.setAdminActive(false);
-        DataUtils.update(target);
-        PlexUtils.broadcast(messageComponent("adminRemoved", userSender, target.getName()));
-    }
-
-    @EventHandler
-    public void onAdminSetRank(AdminSetRankEvent event)
-    {
-        String userSender = event.getSender().getName();
-        PlexPlayer target = event.getPlexPlayer();
-        Rank newRank = event.getRank();
-        target.setRank(newRank.name().toLowerCase());
-        DataUtils.update(target);
-        PlexUtils.broadcast(messageComponent("adminSetRank", userSender, target.getName(), newRank.getReadable()));
-    }
-}

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

@@ -1,6 +1,7 @@
 package dev.plex.listener.impl;
 
 import dev.plex.listener.PlexListener;
+import dev.plex.util.PlexUtils;
 import dev.plex.services.impl.TimingService;
 import net.kyori.adventure.text.Component;
 import org.bukkit.event.EventHandler;
@@ -19,7 +20,7 @@ public class AntiNukerListener extends PlexListener
         if (getCount(event.getPlayer().getUniqueId()) > 200L)
         {
             TimingService.strikes.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
-            event.getPlayer().kick(Component.text("Please turn off your nuker!"));
+            event.getPlayer().kick(PlexUtils.messageComponent("nukerKickMessage"));
             event.setCancelled(true);
         }
     }
@@ -31,7 +32,7 @@ public class AntiNukerListener extends PlexListener
         if (getCount(event.getPlayer().getUniqueId()) > 200L)
         {
             TimingService.strikes.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
-            event.getPlayer().kick(Component.text("Please turn off your nuker!"));
+            event.getPlayer().kick(PlexUtils.messageComponent("nukerKickMessage"));
             event.setCancelled(true);
         }
     }

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

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

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

@@ -1,10 +1,15 @@
 package dev.plex.listener.impl;
 
+import dev.plex.Plex;
 import dev.plex.cache.DataUtils;
 import dev.plex.listener.PlexListener;
 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;
 
@@ -13,33 +18,53 @@ public class BanListener extends PlexListener
     @EventHandler
     public void onPreLogin(AsyncPlayerPreLoginEvent event)
     {
-        if (plugin.getPunishmentManager().isIndefUUIDBanned(event.getUniqueId()))
+        final PunishmentManager.IndefiniteBan uuidBan = plugin.getPunishmentManager().getIndefiniteBanByUUID(event.getUniqueId());
+        if (uuidBan != null)
         {
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    Punishment.generateIndefBanMessage("UUID"));
+                    !uuidBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("UUID", uuidBan.getReason()) : Punishment.generateIndefBanMessage("UUID"));
             return;
         }
 
-        if (plugin.getPunishmentManager().isIndefIPBanned(event.getAddress().getHostAddress()))
+        final PunishmentManager.IndefiniteBan ipBan = plugin.getPunishmentManager().getIndefiniteBanByIP(event.getAddress().getHostAddress());
+        if (ipBan != null)
         {
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    Punishment.generateIndefBanMessage("IP"));
+                    !ipBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("IP", ipBan.getReason()) : Punishment.generateIndefBanMessage("IP"));
             return;
         }
 
-        if (plugin.getPunishmentManager().isIndefUserBanned(event.getName()))
+        final PunishmentManager.IndefiniteBan userBan = plugin.getPunishmentManager().getIndefiniteBanByUsername(event.getName());
+
+        if (userBan != null)
         {
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    Punishment.generateIndefBanMessage("username"));
+                    !userBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("username", userBan.getReason()) : Punishment.generateIndefBanMessage("username"));
             return;
         }
 
         if (plugin.getPunishmentManager().isBanned(event.getUniqueId()))
         {
+            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/BookListener.java

@@ -14,7 +14,7 @@ import java.util.List;
 
 public class BookListener extends PlexListener
 {
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.LOW)
     public void onBookEdit(PlayerEditBookEvent event)
     {
         List<Component> pages = new ArrayList<>();

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

@@ -1,7 +1,9 @@
 package dev.plex.listener.impl;
 
+import dev.plex.hook.VaultHook;
 import dev.plex.listener.PlexListener;
 import dev.plex.listener.annotation.Toggleable;
+import dev.plex.meta.PlayerMeta;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.minimessage.SafeMiniMessage;
@@ -15,15 +17,16 @@ import net.kyori.adventure.text.event.ClickEvent;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.entity.Player;
 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 static final TextReplacementConfig URL_REPLACEMENT_CONFIG = TextReplacementConfig
             .builder()
             .match("(https?|ftp|file)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]")
@@ -32,22 +35,24 @@ public class ChatListener extends PlexListener
                     .clickEvent(ClickEvent.openUrl(
                             matchResult.group()
                     ))).build();
+    public static BiConsumer<AsyncChatEvent, PlexPlayer> PRE_RENDERER = ChatListener::defaultChatProcessing;
     private final PlexChatRenderer renderer = new PlexChatRenderer();
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
     public void onChat(AsyncChatEvent event)
     {
         PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(event.getPlayer().getUniqueId());
         if (plexPlayer.isStaffChat())
         {
-            MessageUtil.sendStaffChat(event.getPlayer(), event.message(), PlexUtils.adminChat(event.getPlayer().getName(), SafeMiniMessage.mmSerialize(event.message())).toArray(UUID[]::new));
-            plugin.getServer().getConsoleSender().sendMessage(PlexUtils.messageComponent("adminChatFormat", event.getPlayer().getName(), SafeMiniMessage.mmSerialize(event.message())).replaceText(URL_REPLACEMENT_CONFIG));
+            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))));
             event.setCancelled(true);
             return;
         }
-        Component prefix = plugin.getRankManager().getPrefix(plexPlayer);
+        Component prefix = PlayerMeta.getPrefix(plexPlayer);
 
-        if (prefix != null)
+        if (prefix != null && !prefix.equals(Component.empty()) && !prefix.equals(Component.space()))
         {
             renderer.hasPrefix = true;
             renderer.prefix = prefix;
@@ -58,6 +63,8 @@ public class ChatListener extends PlexListener
             renderer.prefix = null;
         }
 
+        PRE_RENDERER.accept(event, plexPlayer);
+
         event.renderer(renderer);
     }
 
@@ -70,8 +77,6 @@ public class ChatListener extends PlexListener
         @Override
         public @NotNull Component render(@NotNull Player source, @NotNull Component sourceDisplayName, @NotNull Component message, @NotNull Audience viewer)
         {
-            String text = PlexUtils.cleanString(PlexUtils.getTextFromComponent(message));
-
             Component component = Component.empty();
 
             if (before != null)
@@ -92,8 +97,14 @@ public class ChatListener extends PlexListener
                     .append(Component.space())
                     .append(Component.text("»").color(NamedTextColor.GRAY))
                     .append(Component.space())
-                    .append(SafeMiniMessage.mmDeserializeWithoutEvents(text))
+                    .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));
+    }
 }

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

@@ -1,10 +1,11 @@
 package dev.plex.listener.impl;
 
+import dev.plex.Plex;
 import dev.plex.cache.DataUtils;
 import dev.plex.command.blocking.BlockedCommand;
 import dev.plex.listener.PlexListener;
 import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
+
 import dev.plex.services.impl.CommandBlockerService;
 import dev.plex.util.PlexLog;
 import net.kyori.adventure.text.Component;
@@ -46,6 +47,7 @@ public class CommandListener extends PlexListener
     {
         String command = "/" + event.getMessage().replaceFirst("/", "").trim();
         Player player = event.getPlayer();
+        if (Plex.get().getPermissions() != null && Plex.get().getPermissions().has(player, "plex.commandblocker.bypass")) return;
         PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
         String commandName = StringUtils.normalizeSpace(command).split(" ")[0].replaceFirst("/", "");
         String arguments = StringUtils.normalizeSpace(StringUtils.normalizeSpace(command).replace(command.split(" ")[0], ""));
@@ -106,7 +108,10 @@ public class CommandListener extends PlexListener
         if (cmdRef.get() != null)
         {
             BlockedCommand cmd = cmdRef.get();
-            switch (cmd.getRequiredLevel().toLowerCase(Locale.ROOT))
+            event.setCancelled(true);
+            event.getPlayer().sendMessage(cmd.getMessage());
+            //TODO: Look into removing this or fixing it so they require permissions instead
+            /*switch (cmd.getRequiredLevel().toLowerCase(Locale.ROOT))
             {
                 case "e" ->
                 {
@@ -131,20 +136,12 @@ public class CommandListener extends PlexListener
                     event.setCancelled(true);
                     event.getPlayer().sendMessage(cmd.getMessage());
                 }
-            }
+            }*/
         }
     }
 
     private boolean hasCommandSpy(PlexPlayer plexPlayer)
     {
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            return plexPlayer.isAdminActive();
-        }
-        else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-        {
-            return plexPlayer.getPlayer().hasPermission("plex.commandspy");
-        }
-        return false;
+        return plexPlayer.getPlayer().hasPermission("plex.commandspy");
     }
 }

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

@@ -0,0 +1,70 @@
+package dev.plex.listener.impl;
+
+import dev.plex.listener.PlexListener;
+import dev.plex.menu.AbstractMenu;
+import dev.plex.menu.pagination.PageableMenu;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.meta.ItemMeta;
+
+/**
+ * @author Taah
+ * @since 7:01 AM [02-09-2023]
+ */
+public class MenuListener extends PlexListener
+{
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onClick(InventoryClickEvent event)
+    {
+        if (event.getClickedInventory() == null)
+        {
+            return;
+        }
+
+        if (event.getCurrentItem() == null)
+        {
+            return;
+        }
+
+        if (!(event.getWhoClicked() instanceof Player player))
+        {
+            return;
+        }
+
+        AbstractMenu.INVENTORIES.entrySet().stream().filter(entry -> entry.getKey().equals(event.getView().title()))
+                .findFirst()
+                .ifPresent(entry ->
+                {
+                    if (entry.getValue() instanceof PageableMenu.Page page)
+                    {
+                        final ItemMeta meta = event.getCurrentItem().getItemMeta();
+                        if (meta != null && meta.displayName() != null)
+                        {
+                            if (meta.displayName().equals(PageableMenu.PREVIOUS.getItemMeta().displayName()))
+                            {
+                                page.parent().currentPage(page.parent().currentPage() - 1);
+                                page.parent().open(player, page.parent().currentPage());
+                                event.setCancelled(true);
+                                return;
+                            }
+                            else if (meta.displayName().equals(PageableMenu.NEXT.getItemMeta().displayName()))
+                            {
+                                page.parent().currentPage(page.parent().currentPage() + 1);
+                                page.parent().open(player, page.parent().currentPage());
+                                event.setCancelled(true);
+                                return;
+                            }
+                            else if (meta.displayName().equals(PageableMenu.CLOSE.getItemMeta().displayName()))
+                            {
+                                player.closeInventory();
+                                event.setCancelled(true);
+                                return;
+                            }
+                        }
+                    }
+                    event.setCancelled(entry.getValue().onClick(event.getView(), event.getClickedInventory(), player, event.getCurrentItem()));
+                });
+    }
+}

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

@@ -3,6 +3,7 @@ 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;
@@ -11,6 +12,8 @@ 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;
 import org.bukkit.event.block.Action;
@@ -53,6 +56,7 @@ public class MobListener extends PlexListener
     @EventHandler
     public void onEntitySpawn(EntitySpawnEvent event)
     {
+        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,6 +72,17 @@ 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
@@ -84,12 +99,14 @@ public class MobListener extends PlexListener
             {
                 blockLoc.getWorld().spawnEntity(blockLoc, eggType);
             }
+            event.setCancelled(true);
         }
     }
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onEntityClick(PlayerInteractEntityEvent event)
     {
+        if (event.isCancelled()) return;
         Material handItem = event.getPlayer().getEquipment().getItem(event.getHand()).getType();
         if (event.getRightClicked() instanceof Ageable entity)
         {
@@ -111,6 +128,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.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK)
         {
             if (SPAWN_EGGS.contains(event.getMaterial()))
@@ -129,4 +148,11 @@ 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/PlayerListener.java

@@ -2,11 +2,11 @@ package dev.plex.listener.impl;
 
 import dev.plex.cache.DataUtils;
 import dev.plex.listener.PlexListener;
+import dev.plex.meta.PlayerMeta;
 import dev.plex.player.PlexPlayer;
-import dev.plex.storage.StorageType;
-import dev.plex.util.PermissionsUtil;
 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;
@@ -19,9 +19,7 @@ import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
-import java.util.List;
-
-public class PlayerListener<T> extends PlexListener
+public class PlayerListener extends PlexListener
 {
     // setting up a player's data
     @EventHandler(priority = EventPriority.HIGHEST)
@@ -30,17 +28,6 @@ public class PlayerListener<T> extends PlexListener
         Player player = event.getPlayer();
         PlexPlayer plexPlayer;
 
-        if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            player.setOp(true);
-            PlexLog.debug("Automatically opped " + player.getName() + " since ranks are enabled.");
-        }
-        else if (plugin.getSystem().equalsIgnoreCase("permissions"))
-        {
-            player.setOp(false);
-            PlexLog.debug("Automatically deopped " + player.getName() + " since ranks are disabled.");
-        }
-
         if (!DataUtils.hasPlayedBefore(player.getUniqueId()))
         {
             PlexLog.log("A player with this name has not joined the server before, creating new entry.");
@@ -74,36 +61,21 @@ public class PlayerListener<T> extends PlexListener
             player.openInventory(player.getInventory());
         }
 
-        String loginMessage = plugin.getRankManager().getLoginMessage(plexPlayer);
-        if (!loginMessage.isEmpty())
+        String loginMessage = PlayerMeta.getLoginMessage(plexPlayer);
+        if (!loginMessage.isEmpty() && !PlayerMeta.isVanished(player))
         {
-            PlexUtils.broadcast(loginMessage);
+            PlexUtils.broadcast(PlexUtils.stringToComponent(loginMessage));
         }
 
-        PermissionsUtil.setupPermissions(player);
+        plexPlayer.loadNotes();
 
-        if (plugin.getStorageType() != StorageType.MONGODB)
+        plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
         {
-            plexPlayer.loadNotes();
-        }
-
-        if (plugin.getStorageType() == StorageType.MONGODB)
-        {
-            plexPlayer.loadPunishments();
-        }
-
-        if (plugin.getStorageType() != StorageType.MONGODB)
-        {
-            plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
+            if (!notes.isEmpty())
             {
-                String plural = notes.size() == 1 ? "note." : "notes.";
-                if (!notes.isEmpty())
-                {
-                    PlexUtils.broadcastToAdmins(Component.text(plexPlayer.getName() + " has " + notes.size() + " " + plural).color(NamedTextColor.GOLD));
-                    PlexUtils.broadcastToAdmins(Component.text("Click to view their " + plural).clickEvent(ClickEvent.runCommand("/notes " + plexPlayer.getName() + " list")).color(NamedTextColor.GOLD));
-                }
-            });
-        }
+                PlexUtils.broadcastToAdmins(PlexUtils.messageComponent(notes.size() == 1 ? "playerNoteAlert" : "playerNoteAlertPlural", plexPlayer.getName(), notes.size()), "plex.notes.notify");
+            }
+        });
     }
 
     // saving the player's data
@@ -111,12 +83,6 @@ public class PlayerListener<T> extends PlexListener
     public void onPlayerSave(PlayerQuitEvent event)
     {
         PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(event.getPlayer().getUniqueId()); //get the player because it's literally impossible for them to not have an object
-
-        if (plugin.getRankManager().isAdmin(plexPlayer))
-        {
-            plugin.getAdminList().removeFromCache(plexPlayer.getUuid());
-        }
-
         DataUtils.update(plexPlayer);
         plugin.getPlayerCache().getPlexPlayerMap().remove(event.getPlayer().getUniqueId()); //remove them from cache
     }
@@ -127,7 +93,7 @@ public class PlayerListener<T> extends PlexListener
         PlexPlayer player = DataUtils.getPlayer(event.getPlayer().getUniqueId());
         if (player.isLockedUp())
         {
-            Bukkit.getScheduler().runTaskLater(plugin, () -> event.getPlayer().openInventory(event.getInventory()), 1L);
+            Bukkit.getGlobalRegionScheduler().runDelayed(plugin, (scheduledTask) -> event.getPlayer().openInventory(event.getInventory()), 1L);
         }
     }
 

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

@@ -1,20 +0,0 @@
-package dev.plex.listener.impl;
-
-import dev.plex.listener.PlexListener;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.minimessage.SafeMiniMessage;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.block.SignChangeEvent;
-
-public class SignListener extends PlexListener
-{
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onSignEdit(SignChangeEvent event)
-    {
-        for (int i = 0; i < event.lines().size(); i++)
-        {
-            event.line(i, SafeMiniMessage.mmDeserialize(PlexUtils.getTextFromComponent(event.line(i))));
-        }
-    }
-}

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

@@ -1,12 +1,12 @@
 package dev.plex.listener.impl;
 
 import dev.plex.cache.DataUtils;
-import dev.plex.event.AdminAddEvent;
-import dev.plex.event.AdminRemoveEvent;
-import dev.plex.event.AdminSetRankEvent;
+import dev.plex.hook.VaultHook;
 import dev.plex.listener.PlexListener;
+import dev.plex.meta.PlayerMeta;
 import dev.plex.player.PlexPlayer;
-import net.kyori.adventure.text.Component;
+import dev.plex.util.PlexUtils;
+import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -19,42 +19,6 @@ public class TabListener extends PlexListener
     {
         Player player = event.getPlayer();
         PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
-        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onAdminAdd(AdminAddEvent event)
-    {
-        PlexPlayer plexPlayer = event.getPlexPlayer();
-        Player player = event.getPlexPlayer().getPlayer();
-        if (player == null)
-        {
-            return;
-        }
-        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onAdminRemove(AdminRemoveEvent event)
-    {
-        PlexPlayer plexPlayer = event.getPlexPlayer();
-        Player player = event.getPlexPlayer().getPlayer();
-        if (player == null)
-        {
-            return;
-        }
-        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onAdminSetRank(AdminSetRankEvent event)
-    {
-        PlexPlayer plexPlayer = event.getPlexPlayer();
-        Player player = event.getPlexPlayer().getPlayer();
-        if (player == null)
-        {
-            return;
-        }
-        player.playerListName(Component.text(player.getName()).color(plugin.getRankManager().getColor(plexPlayer)));
+        player.playerListName(PlexUtils.mmDeserialize(PlayerMeta.getColor(plexPlayer) + player.getName()));
     }
 }

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

@@ -1,20 +1,45 @@
 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 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.*;
 import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.projectiles.ProjectileSource;
+
+import java.util.List;
 
 public class TogglesListener extends PlexListener
 {
+    List<String> commands = plugin.commands.getStringList("block_on_mute");
+
     @EventHandler
-    public void onBlockExplode(ExplosionPrimeEvent event)
+    public void onExplosionPrime(ExplosionPrimeEvent event)
     {
         if (!plugin.toggles.getBoolean("explosions"))
         {
+            event.getEntity().remove();
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onBlockExplode(BlockExplodeEvent event)
+    {
+        if (!plugin.toggles.getBoolean("explosions"))
+        {
+            event.getBlock().breakNaturally();
             event.setCancelled(true);
         }
     }
@@ -24,6 +49,7 @@ public class TogglesListener extends PlexListener
     {
         if (!plugin.toggles.getBoolean("explosions"))
         {
+            event.getEntity().remove();
             event.setCancelled(true);
         }
     }
@@ -46,6 +72,100 @@ 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

@@ -0,0 +1,32 @@
+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,17 +1,12 @@
 package dev.plex.listener.impl;
 
-import dev.plex.Plex;
 import dev.plex.listener.PlexListener;
-import dev.plex.player.PlexPlayer;
-import dev.plex.rank.enums.Rank;
-import dev.plex.rank.enums.Title;
-import dev.plex.util.PlexLog;
-import dev.plex.util.PlexUtils;
 import 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;
+import org.bukkit.block.data.Openable;
 import org.bukkit.command.Command;
 import org.bukkit.command.PluginIdentifiableCommand;
 import org.bukkit.entity.EntityType;
@@ -20,20 +15,18 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 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.PlayerTeleportEvent;
-import org.jetbrains.annotations.NotNull;
+import org.bukkit.event.player.*;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Locale;
 
 public class WorldListener extends PlexListener
 {
     private final List<String> EDIT_COMMANDS = Arrays.asList("bigtree", "ebigtree", "largetree", "elargetree", "break", "ebreak", "antioch", "nuke", "editsign", "tree", "etree");
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
     public void onBlockPlace(BlockPlaceEvent event)
     {
         if (!canModifyWorld(event.getPlayer(), true))
@@ -42,7 +35,7 @@ public class WorldListener extends PlexListener
         }
     }
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
     public void onBlockBreak(BlockBreakEvent event)
     {
         if (!canModifyWorld(event.getPlayer(), true))
@@ -51,7 +44,45 @@ public class WorldListener extends PlexListener
         }
     }
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onInteractWorld(PlayerInteractEvent event)
+    {
+        if (event.getInteractionPoint() != null && event.getInteractionPoint().getBlock().getBlockData() instanceof Openable) return;
+        if (!canModifyWorld(event.getPlayer(), true))
+        {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onInteractWorld(PlayerInteractEntityEvent event)
+    {
+        if (!canModifyWorld(event.getPlayer(), true))
+        {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onInteractWorld(PlayerItemDamageEvent event)
+    {
+        if (!canModifyWorld(event.getPlayer(), true))
+        {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onInteractWorld(EntityDamageByEntityEvent event)
+    {
+        if (!(event.getDamager() instanceof Player player)) return;
+        if (!canModifyWorld(player, true))
+        {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
     public void onEntitySpawn(EntitySpawnEvent event)
     {
         if (event.getEntityType() != EntityType.SLIME)
@@ -81,62 +112,22 @@ 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()))
             {
-                event.getPlayer().sendMessage(Component.text("You do not have permission to use that command in this world.").color(NamedTextColor.RED));
+                String noEdit = plugin.config.getString("worlds." + event.getPlayer().getWorld().getName().toLowerCase() + ".modification.message");
+                event.getPlayer().sendMessage(MiniMessage.miniMessage().deserialize(noEdit));
                 event.setCancelled(true);
             }
         }
     }
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
     public void onWorldTeleport(PlayerTeleportEvent event)
     {
-        if (!canEnterWorld(event.getPlayer()))
+        if (!canEnterWorld(event.getPlayer(), event.getTo().getWorld()))
         {
             event.setCancelled(true);
         }
     }
 
-    private boolean checkLevel(PlexPlayer player, String[] requiredList)
-    {
-        PlexLog.debug("Checking world required levels " + Arrays.toString(requiredList));
-        boolean hasAccess = false;
-        for (String required : requiredList)
-        {
-            PlexLog.debug("Checking if player has " + required);
-            if (required.startsWith("Title"))
-            {
-                String titleString = required.split("\\.")[1];
-                Title title = Title.valueOf(titleString.toUpperCase(Locale.ROOT));
-                switch (title)
-                {
-                    case DEV ->
-                    {
-                        hasAccess = PlexUtils.DEVELOPERS.contains(player.getUuid().toString());
-                    }
-                    case MASTER_BUILDER ->
-                    {
-                        hasAccess = Plex.get().config.contains("titles.masterbuilders") && Plex.get().config.getStringList("titles.masterbuilders").contains(player.getName());
-                    }
-                    case OWNER ->
-                    {
-                        hasAccess = Plex.get().config.contains("titles.owners") && Plex.get().config.getStringList("titles.owners").contains(player.getName());
-                    }
-                    default ->
-                    {
-                        return false;
-                    }
-                }
-            }
-            else if (required.startsWith("Rank"))
-            {
-                String rankString = required.split("\\.")[1];
-                Rank rank = Rank.valueOf(rankString.toUpperCase(Locale.ROOT));
-                hasAccess = rank.isAtLeast(Rank.ADMIN) ? player.isAdminActive() && player.getRankFromString().isAtLeast(rank) : player.getRankFromString().isAtLeast(rank);
-            }
-        }
-        return hasAccess;
-    }
-
     /**
      * Check if a Player has the ability to modify the world they are in
      *
@@ -146,34 +137,15 @@ public class WorldListener extends PlexListener
      */
     private boolean canModifyWorld(Player player, boolean showMessage)
     {
-        PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(player.getUniqueId());
         World world = player.getWorld();
-        if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        String permission = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".modification.permission");
+        if (permission == null)
         {
-            String permission = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".modification.permission");
-            if (permission == null)
-            {
-                return true;
-            }
-            if (player.hasPermission(permission))
-            {
-                return true;
-            }
+            return true;
         }
-        else if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        if (player.hasPermission(permission))
         {
-            if (plugin.config.contains("worlds." + world.getName().toLowerCase() + ".modification.requiredLevels"))
-            {
-                @NotNull List<String> requiredLevel = plugin.config.getStringList("worlds." + world.getName().toLowerCase() + ".modification.requiredLevels");
-                if (checkLevel(plexPlayer, requiredLevel.toArray(String[]::new)))
-                {
-                    return true;
-                }
-            }
-            else
-            {
-                return true;
-            }
+            return true;
         }
 
         if (showMessage)
@@ -193,43 +165,23 @@ public class WorldListener extends PlexListener
      * @param player The player who wants to enter the world
      * @return Returns true if the person has the ability to enter the world
      */
-    private boolean canEnterWorld(Player player)
+    private boolean canEnterWorld(Player player, World destination)
     {
-        PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(player.getUniqueId());
-        World world = player.getWorld();
-        if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        String permission = plugin.config.getString("worlds." + destination.getName().toLowerCase() + ".entry.permission");
+        if (permission == null)
         {
-            String permission = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".entry.permission");
-            if (permission == null)
-            {
-                return true;
-            }
-            if (player.hasPermission(permission))
-            {
-                return true;
-            }
+            return true;
         }
-        else if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        if (player.hasPermission(permission))
         {
-            if (plugin.config.contains("worlds." + world.getName().toLowerCase() + ".entry.requiredLevels"))
-            {
-                @NotNull List<String> requiredLevel = plugin.config.getStringList("worlds." + world.getName().toLowerCase() + ".entry.requiredLevels");
-                if (checkLevel(plexPlayer, requiredLevel.toArray(String[]::new)))
-                {
-                    return true;
-                }
-            }
-            else
-            {
-                return true;
-            }
+            return true;
         }
 
-        String noEntry = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".entry.message");
+        String noEntry = plugin.config.getString("worlds." + destination.getName().toLowerCase() + ".entry.message");
         if (noEntry != null)
         {
             player.sendMessage(MiniMessage.miniMessage().deserialize(noEntry));
         }
         return false;
     }
-}
+}

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

@@ -0,0 +1,66 @@
+package dev.plex.menu;
+
+import com.google.common.collect.Maps;
+import dev.plex.util.minimessage.SafeMiniMessage;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+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
+{
+    public static final Map<Component, AbstractMenu> INVENTORIES = Maps.newHashMap();
+    private final Component name;
+    private final Inventory inventory;
+
+    public AbstractMenu(Component name, Rows rows)
+    {
+        this.name = name;
+        this.inventory = Bukkit.createInventory(null, rows.slots, name);
+
+        INVENTORIES.put(name, this);
+    }
+
+    public AbstractMenu(String name, Rows rows)
+    {
+        this(SafeMiniMessage.mmDeserializeWithoutEvents(name), rows);
+    }
+
+    public abstract boolean onClick(InventoryView view, Inventory inventory, Player player, ItemStack clicked);
+
+    public void open(Player player)
+    {
+        player.openInventory(this.inventory);
+    }
+
+    public enum Rows
+    {
+        ONE(9), TWO(18), THREE(27), FOUR(36), FIVE(45), SIX(54);
+
+        private final int slots;
+
+        Rows(int slots)
+        {
+            this.slots = slots;
+        }
+
+        public int slots()
+        {
+            return this.slots;
+        }
+    }
+
+}

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

@@ -1,192 +0,0 @@
-package dev.plex.menu;
-
-import com.google.common.collect.Lists;
-import dev.plex.Plex;
-import dev.plex.cache.DataUtils;
-import dev.plex.player.PlexPlayer;
-import dev.plex.punishment.Punishment;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.menu.AbstractMenu;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.inventory.meta.SkullMeta;
-
-import java.util.Collections;
-import java.util.List;
-
-public class PunishedPlayerMenu extends AbstractMenu
-{
-    private final PlexPlayer punishedPlayer;
-
-    private final List<Inventory> inventories = Lists.newArrayList();
-
-    public PunishedPlayerMenu(PlexPlayer player)
-    {
-        super("§c§lPunishments");
-        this.punishedPlayer = player;
-        for (int i = 0; i <= punishedPlayer.getPunishments().size() / 53; i++)
-        {
-            Inventory inventory = Bukkit.createInventory(null, 54, PlexUtils.mmDeserialize("Punishments Page " + (i + 1)));
-            ItemStack nextPage = new ItemStack(Material.FEATHER);
-            ItemMeta meta = nextPage.getItemMeta();
-            meta.displayName(Component.text("Next Page").color(NamedTextColor.LIGHT_PURPLE));
-            nextPage.setItemMeta(meta);
-
-            ItemStack previousPage = new ItemStack(Material.FEATHER);
-            ItemMeta meta2 = previousPage.getItemMeta();
-            meta2.displayName(Component.text("Next Page").color(NamedTextColor.LIGHT_PURPLE));
-            previousPage.setItemMeta(meta2);
-
-            ItemStack back = new ItemStack(Material.BARRIER);
-            ItemMeta meta3 = back.getItemMeta();
-            meta3.displayName(Component.text("Next Page").color(NamedTextColor.LIGHT_PURPLE));
-            back.setItemMeta(meta3);
-
-            inventory.setItem(50, nextPage);
-            inventory.setItem(49, back);
-            inventory.setItem(48, previousPage);
-            inventories.add(inventory);
-        }
-    }
-
-    public List<Inventory> getInventory()
-    {
-        return inventories;
-    }
-
-    public void openInv(Player player, int index)
-    {
-        int currentItemIndex = 0;
-        int currentInvIndex = 0;
-        for (Punishment punishment : punishedPlayer.getPunishments())
-        {
-            Inventory inv = inventories.get(currentInvIndex);
-            if (currentInvIndex > inventories.size() - 1)
-            {
-                break;
-            }
-
-            if (currentItemIndex == inv.getSize() - 1)
-            {
-                currentInvIndex++;
-                currentItemIndex = 0;
-                inv = inventories.get(currentInvIndex);
-            }
-
-
-            ItemStack item = new ItemStack(Material.NETHER_STAR);
-            ItemMeta meta = item.getItemMeta();
-            meta.displayName(Component.text(punishment.getType().name().toUpperCase()).color(NamedTextColor.RED));
-            meta.lore(Collections.singletonList(Component.text("Reason: ").color(NamedTextColor.YELLOW).append(Component.newline()).append(Component.text(punishment.getReason()).color(NamedTextColor.GRAY))));
-            item.setItemMeta(meta);
-
-            inv.setItem(currentItemIndex, item);
-
-            currentItemIndex++;
-        }
-        player.openInventory(inventories.get(index));
-    }
-
-    @EventHandler
-    public void onClick(InventoryClickEvent event)
-    {
-        if (event.getClickedInventory() == null)
-        {
-            return;
-        }
-        Inventory inv = event.getClickedInventory();
-        if (!isValidInventory(inv))
-        {
-            return;
-        }
-        if (event.getCurrentItem() == null)
-        {
-            return;
-        }
-        ItemStack item = event.getCurrentItem();
-        if (!item.hasItemMeta())
-        {
-            return;
-        }
-        if (!item.getItemMeta().hasDisplayName())
-        {
-            return;
-        }
-        event.setCancelled(true);
-        if (item.getType() == Material.FEATHER)
-        {
-            if (item.getItemMeta().displayName().equals(Component.text("Next Page").color(NamedTextColor.LIGHT_PURPLE)))
-            {
-                if (getCurrentInventoryIndex(inv) + 1 > inventories.size() - 1)
-                {
-                    return;
-                }
-                if (inventories.get(getCurrentInventoryIndex(inv) + 1).getContents().length == 0)
-                {
-                    return;
-                }
-                openInv((Player) event.getWhoClicked(), getCurrentInventoryIndex(inv) + 1);
-            }
-            else if (item.getItemMeta().displayName().equals(Component.text("Previous Page").color(NamedTextColor.LIGHT_PURPLE)))
-            {
-                if (getCurrentInventoryIndex(inv) - 1 < 0)
-                {
-                    return;
-                }
-                if (getCurrentInventoryIndex(inv) - 1 > inventories.size() - 1)
-                {
-                    return;
-                }
-                if (inventories.get(getCurrentInventoryIndex(inv) - 1).getContents().length == 0)
-                {
-                    return;
-                }
-                openInv((Player) event.getWhoClicked(), getCurrentInventoryIndex(inv) - 1);
-            }
-
-        }
-        else if (item.getType() == Material.BARRIER)
-        {
-            new PunishmentMenu().openInv((Player) event.getWhoClicked(), 0);
-        }
-        else if (item.getType() == Material.PLAYER_HEAD)
-        {
-            SkullMeta meta = (SkullMeta) item.getItemMeta();
-            OfflinePlayer player = meta.getOwningPlayer();
-            assert player != null;
-            PlexPlayer punishedPlayer = DataUtils.getPlayer(player.getUniqueId()) == null ? null : Plex.get().getPlayerCache().getPlexPlayer(player.getUniqueId());
-            if (punishedPlayer == null)
-            {
-                event.getWhoClicked().sendMessage(Component.text("This player does not exist. Try doing /punishments <player> instead.").color(NamedTextColor.RED));
-                event.getWhoClicked().closeInventory();
-            }
-        }
-
-    }
-
-    public int getCurrentInventoryIndex(Inventory inventory)
-    {
-        for (int i = 0; i <= inventories.size() - 1; i++)
-        {
-            if (inventories.get(i).hashCode() == inventory.hashCode())
-            {
-                return i;
-            }
-        }
-        return 0;
-    }
-
-    private boolean isValidInventory(Inventory inventory)
-    {
-        return inventories.contains(inventory);
-    }
-}

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

@@ -1,179 +0,0 @@
-package dev.plex.menu;
-
-import com.google.common.collect.Lists;
-import dev.plex.cache.DataUtils;
-import dev.plex.player.PlexPlayer;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.menu.AbstractMenu;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.inventory.meta.SkullMeta;
-
-import java.util.List;
-
-public class PunishmentMenu extends AbstractMenu
-{
-
-    private final List<Inventory> inventories = Lists.newArrayList();
-
-    public PunishmentMenu()
-    {
-        super("§c§lPunishments");
-        for (int i = 0; i <= Bukkit.getOnlinePlayers().size() / 53; i++)
-        {
-            Inventory inventory = Bukkit.createInventory(null, 54, PlexUtils.mmDeserialize("Punishments Page " + (i + 1)));
-            ItemStack nextPage = new ItemStack(Material.FEATHER);
-            ItemMeta meta = nextPage.getItemMeta();
-            meta.displayName(PlexUtils.mmDeserialize("<light_purple>Next Page"));
-            nextPage.setItemMeta(meta);
-
-            ItemStack previousPage = new ItemStack(Material.FEATHER);
-            ItemMeta meta2 = previousPage.getItemMeta();
-            meta2.displayName(PlexUtils.mmDeserialize("<light_purple>Previous Page"));
-            previousPage.setItemMeta(meta2);
-
-            inventory.setItem(50, nextPage);
-            inventory.setItem(48, previousPage);
-            inventories.add(inventory);
-        }
-    }
-
-    public List<Inventory> getInventory()
-    {
-        return inventories;
-    }
-
-    public void openInv(Player player, int index)
-    {
-        int currentItemIndex = 0;
-        int currentInvIndex = 0;
-        for (Player players : Bukkit.getOnlinePlayers())
-        {
-            Inventory inv = inventories.get(currentInvIndex);
-            if (currentInvIndex > inventories.size() - 1)
-            {
-                break;
-            }
-
-            if (currentItemIndex == inv.getSize() - 1)
-            {
-                currentInvIndex++;
-                currentItemIndex = 0;
-                inv = inventories.get(currentInvIndex);
-            }
-
-
-            ItemStack item = new ItemStack(Material.PLAYER_HEAD);
-            SkullMeta meta = (SkullMeta) item.getItemMeta();
-            meta.setOwningPlayer(players);
-            meta.displayName(PlexUtils.mmDeserialize("<!italic><yellow>" + players.getName()));
-            item.setItemMeta(meta);
-
-            inv.setItem(currentItemIndex, item);
-
-            currentItemIndex++;
-        }
-        player.openInventory(inventories.get(index));
-    }
-
-    @EventHandler
-    public void onClick(InventoryClickEvent event)
-    {
-        if (event.getClickedInventory() == null)
-        {
-            return;
-        }
-        Inventory inv = event.getClickedInventory();
-        if (!isValidInventory(inv))
-        {
-            return;
-        }
-        if (event.getCurrentItem() == null)
-        {
-            return;
-        }
-        if (!event.getCurrentItem().hasItemMeta())
-        {
-            return;
-        }
-        if (!event.getCurrentItem().getItemMeta().hasDisplayName())
-        {
-            return;
-        }
-        ItemStack item = event.getCurrentItem();
-        event.setCancelled(true);
-        if (item.getType() == Material.FEATHER)
-        {
-            if (item.getItemMeta().displayName().equals(PlexUtils.mmDeserialize("<light_purple>Next Page")))
-            {
-                if (getCurrentInventoryIndex(inv) + 1 > inventories.size() - 1)
-                {
-                    return;
-                }
-                if (inventories.get(getCurrentInventoryIndex(inv) + 1).getContents().length == 0)
-                {
-                    return;
-                }
-                openInv((Player) event.getWhoClicked(), getCurrentInventoryIndex(inv) + 1);
-            }
-            else if (item.getItemMeta().displayName().equals(PlexUtils.mmDeserialize("<light_purple>Previous Page")))
-            {
-                if (getCurrentInventoryIndex(inv) - 1 < 0)
-                {
-                    return;
-                }
-                if (getCurrentInventoryIndex(inv) - 1 > inventories.size() - 1)
-                {
-                    return;
-                }
-                if (inventories.get(getCurrentInventoryIndex(inv) - 1).getContents().length == 0)
-                {
-                    return;
-                }
-                openInv((Player) event.getWhoClicked(), getCurrentInventoryIndex(inv) - 1);
-            }
-
-        }
-        else if (item.getType() == Material.PLAYER_HEAD)
-        {
-            SkullMeta meta = (SkullMeta) item.getItemMeta();
-            OfflinePlayer player = meta.getOwningPlayer();
-            assert player != null;
-            PlexPlayer punishedPlayer = DataUtils.getPlayer(player.getUniqueId());
-            if (punishedPlayer == null)
-            {
-                event.getWhoClicked().sendMessage(Component.text("This player does not exist. Try doing /punishments <player> instead.").color(NamedTextColor.RED));
-                event.getWhoClicked().closeInventory();
-                return;
-            }
-            new PunishedPlayerMenu(punishedPlayer).openInv((Player) event.getWhoClicked(), 0);
-        }
-
-    }
-
-    public int getCurrentInventoryIndex(Inventory inventory)
-    {
-        for (int i = 0; i <= inventories.size() - 1; i++)
-        {
-            if (inventories.get(i).hashCode() == inventory.hashCode())
-            {
-                return i;
-            }
-        }
-        return 0;
-    }
-
-    private boolean isValidInventory(Inventory inventory)
-    {
-        return inventories.contains(inventory);
-    }
-}

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

@@ -1,146 +0,0 @@
-package dev.plex.menu;
-
-import com.google.common.collect.Lists;
-import dev.plex.PlexBase;
-import dev.plex.util.PlexUtils;
-import dev.plex.util.menu.AbstractMenu;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-
-import java.util.List;
-
-public class ToggleMenu extends AbstractMenu implements PlexBase
-{
-    private final List<Inventory> inventories = Lists.newArrayList();
-
-    public ToggleMenu()
-    {
-        super("§a§lToggles");
-        Inventory inventory = Bukkit.createInventory(null, 9, PlexUtils.mmDeserialize("Toggles"));
-        resetExplosionItem(inventory);
-        resetFluidspreadItem(inventory);
-        resetDropsItem(inventory);
-        resetRedstoneItem(inventory);
-        inventories.add(inventory);
-    }
-
-    public void openInv(Player player, int index)
-    {
-        player.openInventory(inventories.get(index));
-    }
-
-    @EventHandler
-    public void onClick(InventoryClickEvent event)
-    {
-        if (event.getClickedInventory() == null)
-        {
-            return;
-        }
-        Inventory inv = event.getClickedInventory();
-        if (!isValidInventory(inv))
-        {
-            return;
-        }
-        if (event.getCurrentItem() == null)
-        {
-            return;
-        }
-        if (!event.getCurrentItem().hasItemMeta())
-        {
-            return;
-        }
-        if (!event.getCurrentItem().getItemMeta().hasDisplayName())
-        {
-            return;
-        }
-        ItemStack item = event.getCurrentItem();
-        event.setCancelled(true);
-        if (item.getType() == Material.TNT)
-        {
-            plugin.toggles.set("explosions", !plugin.toggles.getBoolean("explosions"));
-            resetExplosionItem(inv);
-            event.getWhoClicked().sendMessage(PlexUtils.mmDeserialize("<gray>Toggled explosions."));
-        }
-        if (item.getType() == Material.WATER_BUCKET)
-        {
-            plugin.toggles.set("fluidspread", !plugin.toggles.getBoolean("fluidspread"));
-            resetFluidspreadItem(inv);
-            event.getWhoClicked().sendMessage(PlexUtils.mmDeserialize("<gray>Toggled fluid spread."));
-        }
-        if (item.getType() == Material.FEATHER)
-        {
-            plugin.toggles.set("drops", !plugin.toggles.getBoolean("drops"));
-            resetDropsItem(inv);
-            event.getWhoClicked().sendMessage(PlexUtils.mmDeserialize("<gray>Toggled drops."));
-        }
-        if (item.getType() == Material.REDSTONE)
-        {
-            plugin.toggles.set("redstone", !plugin.toggles.getBoolean("redstone"));
-            resetRedstoneItem(inv);
-            event.getWhoClicked().sendMessage(PlexUtils.mmDeserialize("<gray>Toggled redstone."));
-        }
-    }
-
-    public int getCurrentInventoryIndex(Inventory inventory)
-    {
-        for (int i = 0; i <= inventories.size() - 1; i++)
-        {
-            if (inventories.get(i).hashCode() == inventory.hashCode())
-            {
-                return i;
-            }
-        }
-        return 0;
-    }
-
-    private boolean isValidInventory(Inventory inventory)
-    {
-        return inventories.contains(inventory);
-    }
-
-    private void resetExplosionItem(Inventory inventory)
-    {
-        ItemStack explosions = new ItemStack(Material.TNT);
-        ItemMeta explosionsItemMeta = explosions.getItemMeta();
-        explosionsItemMeta.displayName(PlexUtils.mmDeserialize("<light_purple>Toggle explosions"));
-        explosionsItemMeta.lore(List.of(PlexUtils.mmDeserialize("<yellow>Explosions are " + (plugin.toggles.getBoolean("explosions") ? "<red>enabled" : "<green>disabled"))));
-        explosions.setItemMeta(explosionsItemMeta);
-        inventory.setItem(0, explosions);
-    }
-
-    private void resetFluidspreadItem(Inventory inventory)
-    {
-        ItemStack water = new ItemStack(Material.WATER_BUCKET);
-        ItemMeta waterItemMeta = water.getItemMeta();
-        waterItemMeta.displayName(PlexUtils.mmDeserialize("<light_purple>Toggle fluid spread"));
-        waterItemMeta.lore(List.of(PlexUtils.mmDeserialize("<yellow>Fluid spread is " + (plugin.toggles.getBoolean("fluidspread") ? "<green>enabled" : "<red>disabled"))));
-        water.setItemMeta(waterItemMeta);
-        inventory.setItem(1, water);
-    }
-
-    private void resetDropsItem(Inventory inventory)
-    {
-        ItemStack feather = new ItemStack(Material.FEATHER);
-        ItemMeta featherItemMeta = feather.getItemMeta();
-        featherItemMeta.displayName(PlexUtils.mmDeserialize("<light_purple>Toggle drops"));
-        featherItemMeta.lore(List.of(PlexUtils.mmDeserialize("<yellow>Drops are " + (plugin.toggles.getBoolean("drops") ? "<green>enabled" : "<red>disabled"))));
-        feather.setItemMeta(featherItemMeta);
-        inventory.setItem(2, feather);
-    }
-
-    private void resetRedstoneItem(Inventory inventory)
-    {
-        ItemStack redstone = new ItemStack(Material.REDSTONE);
-        ItemMeta redstoneItemMeta = redstone.getItemMeta();
-        redstoneItemMeta.displayName(PlexUtils.mmDeserialize("<light_purple>Redstone"));
-        redstoneItemMeta.lore(List.of(PlexUtils.mmDeserialize("<yellow>Redstone is " + (plugin.toggles.getBoolean("redstone") ? "<green>enabled" : "<red>disabled"))));
-        redstone.setItemMeta(redstoneItemMeta);
-        inventory.setItem(3, redstone);
-    }
-}

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

@@ -0,0 +1,40 @@
+package dev.plex.menu.impl;
+
+import dev.plex.menu.AbstractMenu;
+import dev.plex.menu.pagination.PageableMenu;
+import dev.plex.util.item.ItemBuilder;
+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()
+    {
+        super("<dark_aqua><bold>Materials", AbstractMenu.Rows.SIX);
+        onClick((inventoryView, inventory, player, itemStack) ->
+        {
+            player.sendMessage(itemStack.displayName());
+            return true;
+        });
+        this.init();
+    }
+
+    @Override
+    protected ItemStack toItem(Material object)
+    {
+        return new ItemBuilder(object).displayName("<blue>" + object.name()).build();
+    }
+
+    @Override
+    protected List<Material> list()
+    {
+        return Arrays.stream(Material.values()).filter(material -> !material.isAir()).toList();
+    }
+}

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

@@ -0,0 +1,37 @@
+package dev.plex.menu.impl;
+
+import dev.plex.Plex;
+import dev.plex.menu.AbstractMenu;
+import dev.plex.menu.pagination.PageableMenu;
+import dev.plex.player.PlexPlayer;
+import dev.plex.punishment.Punishment;
+import dev.plex.util.TimeUtils;
+import dev.plex.util.item.ItemBuilder;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+
+public class PunishedPlayerMenu extends PageableMenu<Punishment>
+{
+    private final PlexPlayer punishedPlayer;
+    public PunishedPlayerMenu(PlexPlayer player)
+    {
+        super("<red><bold>Punishments - " + player.getName(), AbstractMenu.Rows.SIX);
+        this.punishedPlayer = player;
+        onClick((inventoryView, itemStacks, player1, itemStack) -> true);
+        this.init();
+    }
+
+    @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();
+    }
+
+    @Override
+    protected List<Punishment> list()
+    {
+        return this.punishedPlayer.getPunishments();
+    }
+}

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

@@ -0,0 +1,63 @@
+package dev.plex.menu.impl;
+
+import dev.plex.cache.DataUtils;
+import dev.plex.menu.AbstractMenu;
+import dev.plex.menu.pagination.PageableMenu;
+import dev.plex.player.PlexPlayer;
+import dev.plex.util.PlexLog;
+import dev.plex.util.item.ItemBuilder;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+
+import java.util.List;
+
+/**
+ * @author Taah
+ * @since 9:27 AM [02-09-2023]
+ */
+public class PunishmentMenu extends PageableMenu<Player>
+{
+    public PunishmentMenu()
+    {
+        super("<aqua><bold>Punishments", AbstractMenu.Rows.SIX);
+        PlexLog.debug("list: {0}", list().size());
+        onClick((inventoryView, itemStacks, player, itemStack) ->
+        {
+            if (itemStack.getType() != Material.PLAYER_HEAD) return true;
+            final SkullMeta meta = (SkullMeta) itemStack.getItemMeta();
+            if (meta.getOwningPlayer() == null)
+            {
+                meta.setOwningPlayer(Bukkit.getOfflinePlayer("markbyron"));
+            }
+            PlexPlayer punishedPlayer = DataUtils.getPlayer(meta.getOwningPlayer().getUniqueId());
+            if (punishedPlayer == null)
+            {
+                player.sendMessage(Component.text("This player does not exist. Try doing /punishments <player> instead.").color(NamedTextColor.RED));
+                player.closeInventory();
+                return true;
+            }
+            new PunishedPlayerMenu(punishedPlayer).open(player);
+            return true;
+        });
+
+        this.init();
+    }
+
+    @Override
+    protected ItemStack toItem(Player object)
+    {
+        return new ItemBuilder(Material.PLAYER_HEAD).owner(object).displayName("<!italic><yellow>" + object.getName()).build();
+    }
+
+    @Override
+    protected List<Player> list()
+    {
+        return Bukkit.getOnlinePlayers().stream().map(OfflinePlayer::getPlayer).toList();
+    }
+}

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

@@ -0,0 +1,135 @@
+package dev.plex.menu.impl;
+
+import dev.plex.Plex;
+import dev.plex.menu.AbstractMenu;
+import dev.plex.util.PlexUtils;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.List;
+
+public class ToggleMenu extends AbstractMenu
+{
+    private final Plex plugin;
+
+    public ToggleMenu()
+    {
+        super("<green><bold>Toggles", Rows.ONE);
+        this.plugin = Plex.get();
+        resetExplosionItem(this.inventory());
+        resetFluidspreadItem(this.inventory());
+        resetDropsItem(this.inventory());
+        resetRedstoneItem(this.inventory());
+        resetPVPItem(this.inventory());
+        resetChatItem(this.inventory());
+    }
+
+    private void resetExplosionItem(Inventory inventory)
+    {
+        ItemStack explosions = new ItemStack(Material.TNT);
+        ItemMeta explosionsItemMeta = explosions.getItemMeta();
+        explosionsItemMeta.displayName(PlexUtils.mmDeserialize("<!italic><light_purple>Toggle explosions"));
+        explosionsItemMeta.lore(List.of(PlexUtils.mmDeserialize("<!italic><yellow>Explosions are " + (plugin.toggles.getBoolean("explosions") ? "<red>enabled" : "<green>disabled"))));
+        explosions.setItemMeta(explosionsItemMeta);
+        inventory.setItem(0, explosions);
+    }
+
+    private void resetFluidspreadItem(Inventory inventory)
+    {
+        ItemStack water = new ItemStack(Material.WATER_BUCKET);
+        ItemMeta waterItemMeta = water.getItemMeta();
+        waterItemMeta.displayName(PlexUtils.mmDeserialize("<!italic><light_purple>Toggle fluid spread"));
+        waterItemMeta.lore(List.of(PlexUtils.mmDeserialize("<!italic><yellow>Fluid spread is " + (plugin.toggles.getBoolean("fluidspread") ? "<green>enabled" : "<red>disabled"))));
+        water.setItemMeta(waterItemMeta);
+        inventory.setItem(1, water);
+    }
+
+    private void resetDropsItem(Inventory inventory)
+    {
+        ItemStack feather = new ItemStack(Material.FEATHER);
+        ItemMeta featherItemMeta = feather.getItemMeta();
+        featherItemMeta.displayName(PlexUtils.mmDeserialize("<!italic><light_purple>Toggle drops"));
+        featherItemMeta.lore(List.of(PlexUtils.mmDeserialize("<!italic><yellow>Drops are " + (plugin.toggles.getBoolean("drops") ? "<green>enabled" : "<red>disabled"))));
+        feather.setItemMeta(featherItemMeta);
+        inventory.setItem(2, feather);
+    }
+
+    private void resetRedstoneItem(Inventory inventory)
+    {
+        ItemStack redstone = new ItemStack(Material.REDSTONE);
+        ItemMeta redstoneItemMeta = redstone.getItemMeta();
+        redstoneItemMeta.displayName(PlexUtils.mmDeserialize("<!italic><light_purple>Redstone"));
+        redstoneItemMeta.lore(List.of(PlexUtils.mmDeserialize("<!italic><yellow>Redstone is " + (plugin.toggles.getBoolean("redstone") ? "<green>enabled" : "<red>disabled"))));
+        redstone.setItemMeta(redstoneItemMeta);
+        inventory.setItem(3, redstone);
+    }
+
+    private void resetPVPItem(Inventory inventory)
+    {
+        ItemStack pvp = new ItemStack(Material.IRON_SWORD);
+        ItemMeta pvpItemMeta = pvp.getItemMeta();
+        pvpItemMeta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES);
+        pvpItemMeta.displayName(PlexUtils.mmDeserialize("<!italic><light_purple>PVP"));
+        pvpItemMeta.lore(List.of(PlexUtils.mmDeserialize("<!italic><yellow>PVP is " + (plugin.toggles.getBoolean("pvp") ? "<green>enabled" : "<red>disabled"))));
+        pvp.setItemMeta(pvpItemMeta);
+        inventory.setItem(4, pvp);
+    }
+
+    private void resetChatItem(Inventory inventory)
+    {
+        ItemStack chat = new ItemStack(Material.OAK_SIGN);
+        ItemMeta chatItemMeta = chat.getItemMeta();
+        chatItemMeta.displayName(PlexUtils.mmDeserialize("<!italic><light_purple>Toggle chat"));
+        chatItemMeta.lore(List.of(PlexUtils.mmDeserialize("<!italic><yellow>Chat is currently " + (plugin.toggles.getBoolean("chat") ? "<green>on" : "<red>off"))));
+        chat.setItemMeta(chatItemMeta);
+        inventory.setItem(5, chat);
+    }
+
+    @Override
+    public boolean onClick(InventoryView view, Inventory inventory, Player player, ItemStack clicked)
+    {
+        if (clicked.getType() == Material.TNT)
+        {
+            plugin.toggles.set("explosions", !plugin.toggles.getBoolean("explosions"));
+            resetExplosionItem(inventory);
+            player.sendMessage(PlexUtils.mmDeserialize("<gray>Toggled explosions."));
+        }
+        if (clicked.getType() == Material.WATER_BUCKET)
+        {
+            plugin.toggles.set("fluidspread", !plugin.toggles.getBoolean("fluidspread"));
+            resetFluidspreadItem(inventory);
+            player.sendMessage(PlexUtils.mmDeserialize("<gray>Toggled fluid spread."));
+        }
+        if (clicked.getType() == Material.FEATHER)
+        {
+            plugin.toggles.set("drops", !plugin.toggles.getBoolean("drops"));
+            resetDropsItem(inventory);
+            player.sendMessage(PlexUtils.mmDeserialize("<gray>Toggled drops."));
+        }
+        if (clicked.getType() == Material.REDSTONE)
+        {
+            plugin.toggles.set("redstone", !plugin.toggles.getBoolean("redstone"));
+            resetRedstoneItem(inventory);
+            player.sendMessage(PlexUtils.mmDeserialize("<gray>Toggled redstone."));
+        }
+        if (clicked.getType() == Material.IRON_SWORD)
+        {
+            plugin.toggles.set("pvp", !plugin.toggles.getBoolean("pvp"));
+            resetPVPItem(inventory);
+            player.sendMessage(PlexUtils.mmDeserialize("<gray>Toggled PVP"));
+        }
+        if (clicked.getType() == Material.OAK_SIGN)
+        {
+            plugin.toggles.set("chat", !plugin.toggles.getBoolean("chat"));
+            PlexUtils.broadcast(PlexUtils.messageComponent("chatToggled", player.getName(), plugin.toggles.getBoolean("chat") ? "on" : "off"));
+            resetChatItem(inventory);
+            player.sendMessage(PlexUtils.mmDeserialize("<gray>Toggled chat."));
+        }
+        return true;
+    }
+}

server/src/main/java/dev/plex/menu/pagination/PageableMenu.java

@@ -0,0 +1,176 @@
+package dev.plex.menu.pagination;
+
+import com.google.common.collect.Maps;
+import dev.plex.menu.AbstractMenu;
+import dev.plex.util.PlexUtils;
+import dev.plex.util.function.ConditionalQuadConsumer;
+import dev.plex.util.item.ItemBuilder;
+import dev.plex.util.minimessage.SafeMiniMessage;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Taah
+ * @since 8:04 AM [02-09-2023]
+ */
+
+@Getter
+@Setter
+@Accessors(fluent = true)
+public abstract class PageableMenu<T>
+{
+    public static final ItemStack NEXT = new ItemBuilder(Material.FEATHER).displayName("<light_purple>Next Page").build();
+    public static final ItemStack PREVIOUS = new ItemBuilder(Material.FEATHER).displayName("<light_purple>Previous Page").build();
+    public static final ItemStack CLOSE = new ItemBuilder(Material.BARRIER).displayName("<red>Close").build();
+    protected final Map<Integer, Page> pages = Maps.newHashMap();
+    private final Component name;
+    private final AbstractMenu.Rows rows;
+    private final Inventory inventory;
+    private int currentPage;
+    private boolean initialized;
+
+    @Setter(AccessLevel.NONE)
+    private ConditionalQuadConsumer<InventoryView, Inventory, Player, ItemStack> onClick;
+
+    public PageableMenu(Component name, AbstractMenu.Rows rows)
+    {
+        this.name = name;
+        this.rows = rows;
+        this.inventory = Bukkit.createInventory(null, rows.slots(), name);
+
+        if (rows.slots() < AbstractMenu.Rows.TWO.slots())
+        {
+            throw new RuntimeException("A pageable menu must have at least two rows to compensate for the navigation!");
+        }
+    }
+
+    protected void init()
+    {
+        this.initialized = true;
+        // Preload all needed pages, a better solution is probably just to dynamically create the pages as they go but no!
+        if (list().size() < (rows.slots() - 9))
+        {
+            final Page page = new Page(name.append(Component.space()).append(PlexUtils.mmDeserialize("(1)")), rows);
+            page.parent = this;
+            page.inventory().setItem(rows.slots() - 5, CLOSE);
+            this.pages.put(0, page);
+        }
+        else
+        {
+            for (int i = 0; i < Math.ceil(list().size() / (double) (rows.slots() - 9)); i++)
+            {
+                final Page page = new Page(name.append(Component.space()).append(PlexUtils.mmDeserialize("(" + (i + 1) + ")")), rows);
+                page.parent = this;
+                if (i > 0) // If not first page set previous page button
+                {
+                    page.inventory().setItem(rows.slots() - 6, PREVIOUS);
+                }
+                page.inventory().setItem(rows.slots() - 5, CLOSE);
+                if (i < (list().size() / (rows.slots() - 9)) - 1) // If not last page set next page button
+                {
+                    page.inventory().setItem(rows.slots() - 4, NEXT);
+                }
+                this.pages.put(i, page);
+            }
+        }
+
+        int currentSlotIndex = 0;
+        int currentPageIndex = 0;
+        int currentIndex = 0;
+        while (currentSlotIndex < rows.slots() - 9 && currentIndex < list().size())
+        {
+            final Page page = this.pages.get(currentPageIndex);
+            if (page == null)
+            {
+                return;
+            }
+            page.inventory().setItem(currentSlotIndex, toItem(list().get(currentIndex)));
+            currentIndex++;
+            currentSlotIndex++;
+            if (currentSlotIndex == rows.slots() - 9)
+            {
+                currentSlotIndex = 0;
+                currentPageIndex++;
+            }
+        }
+        if (onClick != null) // To make sure this wasn't declared already
+        {
+            this.pages.forEach((integer, page) -> page.onClick(this.onClick));
+        }
+    }
+
+    public PageableMenu(String name, AbstractMenu.Rows rows)
+    {
+        this(SafeMiniMessage.mmDeserializeWithoutEvents(name), rows);
+    }
+
+    protected abstract ItemStack toItem(T object);
+
+    protected abstract List<T> list();
+
+    public void open(Player player)
+    {
+        open(player, 0);
+    }
+
+    public void open(Player player, int pageNum)
+    {
+        if (!this.initialized)
+        {
+            player.sendMessage(Component.text("Looks like this inventory was not initialized! Please contact a developer to report this.").color(NamedTextColor.RED));
+            return;
+        }
+        final Page page = this.pages.get(pageNum);
+        if (page == null)
+        {
+            player.sendMessage(Component.text("Could not find a page to open").color(NamedTextColor.RED));
+            return;
+        }
+        player.openInventory(page.inventory());
+    }
+
+    public void onClick(ConditionalQuadConsumer<InventoryView, Inventory, Player, ItemStack> onClick)
+    {
+        this.onClick = onClick;
+        this.pages.forEach((integer, page) -> page.onClick(this.onClick));
+    }
+
+
+    @Getter
+    @Setter
+    @Accessors(fluent = true)
+    public static class Page extends AbstractMenu
+    {
+        private ConditionalQuadConsumer<InventoryView, Inventory, Player, ItemStack> onClick;
+        private PageableMenu<?> parent;
+
+        private Page(Component name, Rows rows)
+        {
+            super(name, rows);
+        }
+
+        private Page(String name, AbstractMenu.Rows rows)
+        {
+            this(SafeMiniMessage.mmDeserializeWithoutEvents(name), rows);
+        }
+
+        @Override
+        public boolean onClick(InventoryView view, Inventory inventory, Player player, ItemStack clicked)
+        {
+            return onClick.accept(view, inventory, player, clicked);
+        }
+    }
+}