upload

.github/workflows/maven.yml

@@ -0,0 +1,24 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: Java CI with Maven
+
+on:
+  push:
+    branches: [ master ]
+    
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK 8
+      uses: actions/setup-java@v2
+      with:
+        java-version: '8'
+        distribution: 'adopt'
+        
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml

.gitignore

@@ -0,0 +1,53 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Java template
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+.idea
+*.iml
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+### Kotlin template
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*

API/pom.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.solexgames</groupId>
+        <artifactId>Scandium</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <artifactId>API</artifactId>
+
+    <name>API</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.solexgames</groupId>
+            <artifactId>Bukkit</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>

API/src/main/java/com/solexgames/api/CoreAccess.java

@@ -0,0 +1,91 @@
+package com.solexgames.api;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.chat.IChatFormat;
+import com.solexgames.core.manager.PlayerManager;
+import com.solexgames.core.manager.ServerManager;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.player.global.NetworkPlayer;
+import com.solexgames.core.player.grant.Grant;
+import com.solexgames.core.player.prefixes.Prefix;
+import com.solexgames.core.player.punishment.Punishment;
+import com.solexgames.core.util.Color;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * @author GrowlyX
+ * @since 4/2/2021
+ */
+
+public class CoreAccess {
+
+    private final CorePlugin plugin;
+
+    public CoreAccess() {
+        this.plugin = CorePlugin.getInstance();
+    }
+
+    public ServerManager getServerManager() {
+        return this.plugin.getServerManager();
+    }
+
+    public PlayerManager getPlayerManager() {
+        return this.plugin.getPlayerManager();
+    }
+
+    public PotPlayer fetchProfile(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player);
+    }
+
+    public int getExperience(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player).getExperience();
+    }
+
+    public List<Punishment> getPunishments(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player).getPunishments();
+    }
+
+    public List<Prefix> getPrefixes(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player).getAllPrefixes().stream().map(Prefix::getByName).filter(Objects::nonNull).collect(Collectors.toList());
+    }
+
+    public List<Grant> getGrants(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player).getAllGrants();
+    }
+
+    public Prefix getPrefix(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player).getAppliedPrefix();
+    }
+
+    public String getRankPrefix(Player player) {
+        return Color.translate(this.plugin.getPlayerManager().getPlayer(player).getActiveGrant().getRank().getPrefix());
+    }
+
+    public String getRankSuffix(Player player) {
+        return Color.translate(this.plugin.getPlayerManager().getPlayer(player).getActiveGrant().getRank().getSuffix());
+    }
+
+    public boolean isRestricted(Player player) {
+        return this.plugin.getPlayerManager().getPlayer(player).isCurrentlyRestricted();
+    }
+
+    public NetworkPlayer fetchGlobalProfile(Player player) {
+        return this.plugin.getPlayerManager().getNetworkPlayer(player);
+    }
+
+    public PotPlayer fetchProfile(String player) {
+        return this.plugin.getPlayerManager().getPlayer(player);
+    }
+
+    public NetworkPlayer fetchGlobalProfile(String player) {
+        return this.plugin.getPlayerManager().getNetworkPlayer(player);
+    }
+
+    public void registerNewChatFormat(IChatFormat chatFormat) {
+        this.getServerManager().setChatFormat(chatFormat);
+    }
+}

API/src/main/java/com/solexgames/api/example/ExampleAccess.java

@@ -0,0 +1,32 @@
+package com.solexgames.api.example;
+
+import com.solexgames.api.CoreAccess;
+import com.solexgames.core.player.global.NetworkPlayer;
+
+/**
+ * @author GrowlyX
+ * @since 4/2/2021
+ * <p>
+ * Example of how the {@link CoreAccess} is used.
+ */
+
+public class ExampleAccess {
+
+    /**
+     * Starts the ExampleAccess class.
+     *
+     * @param args Startup Arguments
+     */
+    public static void main(String[] args) {
+        // Make sure to make a public variable for this to prevent memory leaks.
+        final CoreAccess coreAccess = new CoreAccess();
+        final NetworkPlayer networkPlayer = coreAccess.fetchGlobalProfile("GrowlyX");
+
+        // Do whatever with the methods available in the CoreAccess Class.
+        if (networkPlayer != null) {
+            System.out.println(networkPlayer.getServerName());
+        } else {
+            System.out.println("Growly's not online!");
+        }
+    }
+}

API/target/maven-archiver/pom.properties

@@ -0,0 +1,3 @@
+artifactId=API
+groupId=com.solexgames
+version=1.0-SNAPSHOT

API/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

@@ -0,0 +1,2 @@
+com\solexgames\api\CoreAccess.class
+com\solexgames\api\example\ExampleAccess.class

API/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

@@ -0,0 +1,2 @@
+C:\Users\lu\Downloads\scandium-core-plugin-master\scandium-core-plugin-master\API\src\main\java\com\solexgames\api\example\ExampleAccess.java
+C:\Users\lu\Downloads\scandium-core-plugin-master\scandium-core-plugin-master\API\src\main\java\com\solexgames\api\CoreAccess.java

Bukkit/.gitignore

@@ -0,0 +1,112 @@
+# User-specific stuff
+.idea/
+
+*.iml
+*.ipr
+*.iws
+
+# IntelliJ
+out/
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Package Files #
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+target/
+
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+.flattened-pom.xml
+
+# Common working directory
+run/

Bukkit/docs/documentation.txt

@@ -0,0 +1,86 @@
+Auth - scandium.2fa
+AuthSetup - scandium.2fa
+Force authentication for player - scandium.2fa.forced
+StaffChat - scandium.channels.staff
+AdminChat - scandium.channels.admin
+DevChat - scandium.channels.dev
+ManagerChat - scandium.channels.manager
+HostChat - scandium.channels.host
+HelpOP
+Broadcast - scandium.command.broadcast
+Kill - scandium.command.kill
+Feed - scandium.command.feed
+Heal - scandium.command.heal
+TPPos - scandium.command.tppos
+SocialSpy - scandium.command.socialspy
+Sudo - scandium.command.sudo
+SudoAll - scandium.command.sudoall
+TPHere - scandium.command.tphere
+GMC - scandium.command.gmc
+GMS - scandium.command.gms
+GMSP - scandium.command.gmsp
+StaffAnnounce - scandium.command.staffannounce
+TP - scandium.command.tp
+Report
+ShutDown - scandium.command.shutdown
+Freeze - scandium.command.freeze
+Ignore
+CheckDisguise - scandium.command.checkdisguise
+Rank [And Other Rank Commands such as rank create] - scandium.command.rank
+Media
+Discord
+Import
+Experience - scandium.experience.management
+Alts - scandium.command.alts
+Options -
+History - scandium.command.history
+Twitter
+Website
+Permissions - scandium.command.permissions
+Find - scandium.command.find
+ForceUpdate - scandium.command.forceupdate
+Network - scandium.command.network
+Store
+Sync
+Unsync
+Reply
+Grant - scandium.command.grant
+cGrant
+Prefix - scandium.command.prefix
+Grants - scandium.command.grants
+SetSlots - scandium.command.setslots
+Clear - scandium.command.clear
+Vanish - scandium.command.vanish
+ModMode - scandium.command.modmode
+ClearChat - scandium.command.clearchat
+TPAll - scandium.command.tpall
+Color - scandium.chat.colors
+OwnerChat - scandium.channels.owner
+MuteChat - scandium.command.mutechat
+Fly - scandium.command.fly
+User - scandium.command.user
+Language
+Give - scandium.command.give
+Craft - scandium.command.crafting
+Enchant - scandium.command.enchant
+EnderChest - scandium.command.enchant.other [To view other peoples thing its scandium.command.crafting.other]
+MaxItem - scandium.command.maxitem
+SetSpawn - scandium.command.setspawn
+Spawn - scandium.command.spawn
+ToggleTips
+ToggleStaffMessages - scandium.staff
+ToggleAutoModMode - scandium.staff
+ToggleAutoVanish - scandium.staff
+ToggleFilteredMessages - scandium.staff
+SlowChat - scandium.command.slowchat
+Message
+List - To show up as staff like in vanish or staff mode or something they need this node scandium.staff
+Ping
+Ban - scandium.command.ban
+Blacklist - scandium.command.blacklist
+Kick - scandium.command.kick
+Mute - scandium.command.mute
+Warn - scandium.command.warn
+Unban - scandium.command.unban
+Unblacklist - scandium.command.unblacklist
+Unmute - scandium.command.unmute

Bukkit/pom.xml

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.solexgames</groupId>
+        <artifactId>Scandium</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <artifactId>Bukkit</artifactId>
+
+    <properties>
+        <java.version>1.8</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <build>
+        <!--suppress UnresolvedMavenProperty -->
+        <finalName>Scandium</finalName>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+        <repository>
+            <id>sonatype</id>
+            <url>https://oss.sonatype.org/content/groups/public/</url>
+        </repository>
+        <repository>
+            <id>bintray-jcenter</id>
+            <url>https://jcenter.bintray.com</url>
+        </repository>
+        <repository>
+            <id>placeholderapi</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
+        <repository>
+            <id>papermc</id>
+            <url>https://papermc.io/repo/repository/maven-public/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <!-- External APIs/Helpers -->
+        <dependency>
+            <groupId>com.comphenix.protocol</groupId>
+            <artifactId>ProtocolLib</artifactId>
+            <version>4.6.0</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/ProtocolLib.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>com.solexgames.lib</groupId>
+            <artifactId>commons-bukkit</artifactId>
+            <version>devbuild</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/commonslibs-bukkit.jar</systemPath>
+        </dependency>
+
+        <!-- Provided APIs -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>LATEST</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.12.0</version>
+        </dependency>
+        <dependency>
+            <groupId>io.papermc</groupId>
+            <artifactId>paperlib</artifactId>
+            <version>1.0.6</version>
+            <scope>compile</scope>
+        </dependency>
+
+
+        <!-- Chat related APIs -->
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.10.9</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- Minecraft Client APIs -->
+        <dependency>
+            <groupId>com.lunarclient</groupId>
+            <artifactId>bukkitapi</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/LunarClientAPI.jar</systemPath>
+        </dependency>
+
+        <!-- Spigot maven dependencies -->
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-1_8-api</artifactId>
+            <version>1.8.8-R0.1-SNAPSHOT</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/Spigot_1_8.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-19-api</artifactId>
+            <version>1.9-R0.1-SNAPSHOT</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/Spigot_1_9.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-1_7-api</artifactId>
+            <version>1.7.10-R0.1-SNAPSHOT</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/Spigot_1_7.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-1_12-api</artifactId>
+            <version>1.12.1-R0.1-SNAPSHOT</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/Spigot_1_12.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-1_16-api</artifactId>
+            <version>1.16.5-R0.1-SNAPSHOT</version>
+            <scope>system</scope>
+            <systemPath>${basedir}/lib/Spigot_1_16.jar</systemPath>
+        </dependency>
+    </dependencies>
+</project>

Bukkit/src/main/java/com/solexgames/core/CorePlugin.java

@@ -0,0 +1,397 @@
+package com.solexgames.core;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.solexgames.core.adapter.DateTypeAdapter;
+import com.solexgames.core.adapter.LocationTypeAdapter;
+import com.solexgames.core.chat.IChatCheck;
+import com.solexgames.core.command.impl.CoreCommand;
+import com.solexgames.core.command.impl.other.WebPostCommand;
+import com.solexgames.core.database.Database;
+import com.solexgames.core.disguise.DisguiseCache;
+import com.solexgames.core.enums.NetworkServerType;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.hooks.client.IClient;
+import com.solexgames.core.hooks.client.impl.LunarClientImpl;
+import com.solexgames.core.hooks.nms.INMS;
+import com.solexgames.core.hooks.nms.impl.*;
+import com.solexgames.core.hooks.protocol.AbstractPacketHandler;
+import com.solexgames.core.hooks.protocol.impl.ProtocolPacketHandler;
+import com.solexgames.core.manager.*;
+import com.solexgames.core.menu.impl.SettingsMenu;
+import com.solexgames.core.player.punishment.PunishmentStrings;
+import com.solexgames.core.server.NetworkServer;
+import com.solexgames.core.util.BungeeUtil;
+import com.solexgames.core.util.builder.ItemBuilder;
+import com.solexgames.core.util.external.Button;
+import com.solexgames.lib.commons.redis.JedisBuilder;
+import com.solexgames.lib.commons.redis.JedisManager;
+import com.solexgames.lib.commons.redis.JedisSettings;
+import com.solexgames.core.redis.JedisAdapter;
+import com.solexgames.core.serializer.DataLibrary;
+import com.solexgames.core.serializer.impl.ItemStackSerializer;
+import com.solexgames.core.serializer.impl.LocationSerializer;
+import com.solexgames.core.settings.ServerSettings;
+import com.solexgames.core.settings.player.ISettings;
+import com.solexgames.core.task.*;
+import com.solexgames.core.util.BukkitUtil;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.config.FileConfig;
+import com.solexgames.core.uuid.UUIDCache;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.commons.lang.time.DurationFormatUtils;
+import org.apache.http.client.HttpClient;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandMap;
+import org.bukkit.conversations.ConversationFactory;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.SimplePluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.reflect.Field;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * @author GrowlyX
+ * @since 3/1/2021
+ */
+
+@Getter
+@Setter
+public final class CorePlugin extends JavaPlugin {
+
+    public static final SimpleDateFormat FORMAT = new SimpleDateFormat("MM/dd/yyyy HH:mma");
+    public static final Random RANDOM = new Random();
+    public static final Gson GSON = new GsonBuilder()
+                .registerTypeAdapter(Location.class, new LocationTypeAdapter())
+                .registerTypeAdapter(Date.class, new DateTypeAdapter())
+                .setPrettyPrinting()
+                .disableHtmlEscaping()
+                .create();
+
+    @Getter
+    private static CorePlugin instance;
+
+    private ServerManager serverManager;
+    private ReportManager reportManager;
+    private PlayerManager playerManager;
+    private RankManager rankManager;
+    private ShutdownManager shutdownManager;
+    private DiscordManager discordManager;
+    private CryptoManager cryptoManager;
+    private FilterManager filterManager;
+    private PrefixManager prefixManager;
+    private PunishmentManager punishmentManager;
+    private NameTagManager nameTagManager;
+    private DisguiseManager disguiseManager;
+
+    private JedisManager jedisManager;
+    private JedisSettings defaultJedisSettings;
+
+    private UUIDCache uuidCache;
+    private DisguiseCache disguiseCache;
+    private ServerSettings serverSettings;
+
+    private String serverName;
+    private HttpClient httpClient;
+    private Database coreDatabase;
+    private String pluginName;
+
+    private FileConfig ranksConfig;
+    private FileConfig databaseConfig;
+    private FileConfig filterConfig;
+
+    private DataLibrary library;
+
+    private AbstractPacketHandler packetHandler;
+    private IClient clientHook;
+    private INMS NMS;
+
+    private boolean debugging;
+    private boolean disallow;
+
+    private final ConversationFactory conversationFactory = new ConversationFactory(this);
+    private final TPSUpdateTask tpsRunnable = new TPSUpdateTask();
+
+    private final List<ISettings> settingsList = new ArrayList<>();
+    private final List<IChatCheck> chatCheckList = new ArrayList<>();
+
+    @Override
+    public void onEnable() {
+        instance = this;
+
+        final long milli = System.currentTimeMillis();
+
+        this.httpClient = new DefaultHttpClient();
+
+        this.saveDefaultConfig();
+        this.getConfig().options().copyDefaults();
+
+        this.pluginName = this.getConfig().getString("theming.command-prefix");
+
+        CorePlugin.FORMAT.setTimeZone(TimeZone.getTimeZone(this.getConfig().getString("settings.time-zone")));
+
+        this.ranksConfig = new FileConfig("ranks");
+        this.databaseConfig = new FileConfig("database");
+        this.filterConfig = new FileConfig("filtered");
+
+        this.serverSettings = new ServerSettings();
+
+        this.library = new DataLibrary();
+        this.library.getDataManager().registerSerializer(new LocationSerializer());
+        this.library.getDataManager().registerSerializer(new ItemStackSerializer());
+
+        this.serverName = this.getConfig().getString("server.id");
+
+        this.setupSettings();
+        this.setupHooks();
+
+        this.debugging = false;
+        this.disallow = false;
+
+        this.disableLoggers();
+
+        this.coreDatabase = new Database();
+
+        this.uuidCache = new UUIDCache();
+        this.disguiseCache = new DisguiseCache();
+
+        this.punishmentManager = new PunishmentManager();
+        this.cryptoManager = new CryptoManager();
+        this.reportManager = new ReportManager();
+        this.serverManager = new ServerManager();
+        this.rankManager = new RankManager();
+        this.prefixManager = new PrefixManager();
+        this.playerManager = new PlayerManager();
+        this.discordManager = new DiscordManager();
+        this.filterManager = new FilterManager();
+        this.shutdownManager = new ShutdownManager();
+        this.nameTagManager = new NameTagManager();
+        this.disguiseManager = new DisguiseManager();
+
+        this.defaultJedisSettings = new JedisSettings(
+                this.databaseConfig.getString("redis.host"),
+                this.databaseConfig.getInt("redis.port"),
+                this.databaseConfig.getBoolean("redis.authentication.enabled"),
+                this.databaseConfig.getString("redis.authentication.password")
+        );
+
+        this.jedisManager = new JedisBuilder()
+                .withChannel("scandium:bukkit")
+                .withSettings(this.defaultJedisSettings)
+                .withHandler(new JedisAdapter())
+                .build();
+
+        this.setupExtra();
+        this.logInformation(milli);
+
+        new ServerLoadingTask();
+
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, "core:permissions");
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
+
+        new MenuAutoUpdateThread().start();
+        ISettings is = new ISettings() {
+            @Override
+            public List<Button> getButtons(Player player) {
+                return new ArrayList<>();
+            }
+
+            @Override
+            public Button getCategoryButton() {
+                return new Button() {
+                    @Override
+                    public ItemStack getButtonItem(Player player) {
+                        return new ItemBuilder(Material.STAINED_GLASS_PANE).setDisplayName("&aGeneral Settings").setDurability(5).addLore(Arrays.asList("&7The general settings.", "", "&aClick to browse!")).create();
+                    }
+
+                    @Override
+                    public void clicked(Player player, ClickType clickType) {
+                        new SettingsMenu(player).openMenu(player);
+                    }
+                };
+            }
+        };
+        CorePlugin.getInstance().getSettingsList().add(is);
+    }
+
+    private void disableLoggers() {
+        Logger.getLogger("org.mongodb.driver.connection").setLevel(Level.OFF);
+        Logger.getLogger("org.mongodb.driver.cluster").setLevel(Level.OFF);
+    }
+
+    private void setupSettings() {
+        this.serverSettings.setTabEnabled(this.getConfig().getBoolean("tablist.enabled"));
+        this.serverSettings.setTabHeader(Color.translate(this.getConfig().getString("tablist.header").replace("<nl>", "\n").replace("<server-name>", this.serverName)));
+        this.serverSettings.setTabFooter(Color.translate(this.getConfig().getString("tablist.footer").replace("<nl>", "\n").replace("<server-name>", this.serverName)));
+        this.serverSettings.setChatFormat(this.getConfig().getString("chat.format"));
+        this.serverSettings.setChatFormatEnabled(this.getConfig().getBoolean("chat.enabled"));
+        this.serverSettings.setNameMcEnabled(this.getConfig().getBoolean("name-mc.rewards"));
+        this.serverSettings.setAntiSpamEnabled(this.getConfig().getBoolean("anti-spam.chat"));
+        this.serverSettings.setAntiCommandSpamEnabled(this.getConfig().getBoolean("anti-spam.command"));
+        this.serverSettings.setStaffAlertsEnabled(this.getConfig().getBoolean("staff.command-alerts.enabled"));
+        this.serverSettings.setTwoFactorEnabled(this.getConfig().getBoolean("two-factor-auth.enabled"));
+        this.serverSettings.setUsingXenon(this.getConfig().getBoolean("settings.using-xenon"));
+        this.serverSettings.setAlertFormat(Color.translate(this.getConfig().getString("staff.command-alerts.format")));
+    }
+
+    private void setupHooks() {
+        if (this.getServer().getPluginManager().isPluginEnabled("ProtocolLib")) {
+            this.packetHandler = new ProtocolPacketHandler();
+        }
+        if (this.getServer().getPluginManager().isPluginEnabled("LunarClient-API")) {
+            this.clientHook = new LunarClientImpl();
+        }
+
+        if (this.getServer().getVersion().contains("1.7")) {
+            this.NMS = new NMSAccess_v1_7();
+        } else if (this.getServer().getVersion().contains("1.8")) {
+            this.NMS = new NMSAccess_v1_8();
+        } else if (this.getServer().getVersion().contains("1.9")) {
+            this.NMS = new NMSAccess_v1_9();
+        } else if (this.getServer().getVersion().contains("1.12")) {
+            this.NMS = new NMSAccess_v1_12();
+        } else if (this.getServer().getVersion().contains("1.16")) {
+            this.NMS = new NMSAccess_v1_16();
+        }
+
+        this.getNMS().swapCommandMap();
+        this.getLogger().info("[Bukkit] Hooked into Bukkit version " + this.getServer().getVersion() + "!");
+    }
+
+    public void setupExtra() {
+        if (this.packetHandler != null) {
+            this.packetHandler.initializePacketHandlers();
+        }
+
+        new PunishmentStrings().setupMessages();
+        Color.setup();
+
+        BukkitUtil.registerListenersIn("com.solexgames.core.listener");
+
+        this.registerDefaultTasks();
+        this.registerSpigotCommands();
+        this.registerBukkitCommands();
+
+        this.getServer().getScheduler().scheduleSyncRepeatingTask(this, this.tpsRunnable, 0L, 1L);
+    }
+
+    private void registerSpigotCommands() {
+        BukkitUtil.registerCommandModules(
+                "Auth", "Essential", "Syncing",
+                "Experience", "Grant", "Library",
+                "Moderation", "Network", "Other",
+                "Prefix", "Punish", "Rank",
+                "Shutdown", "Server", "Toggle",
+                "Disguise", "Library"
+        );
+    }
+
+    private void registerDefaultTasks() {
+        if (this.getConfig().getBoolean("tip-broadcasts.enabled")) {
+            new AutoMessageTask();
+        }
+
+        new PunishExpireTask();
+        new GrantExpireTask();
+        new ServerUpdateTask();
+//        new PunishSaveTask();
+        new FrozenMessageTask();
+        new BoardUpdateTask();
+        new ServerTimeoutTask();
+        new PlayerDataUpdateTask();
+    }
+
+    private void logInformation(long milli) {
+        this.getLogger().info("Initialized CorePlugin in " + (System.currentTimeMillis() - milli) + "ms (" + DurationFormatUtils.formatDurationWords((System.currentTimeMillis() - milli), true, true) + ").");
+    }
+
+    private void registerBukkitCommands() {
+        if (this.getServer().getPluginManager() instanceof SimplePluginManager) {
+            CommandMap commandMap = null;
+
+            try {
+                final Field commandMapField = SimplePluginManager.class.getDeclaredField("commandMap");
+
+                commandMapField.setAccessible(true);
+                commandMap = (CommandMap) commandMapField.get(this.getServer().getPluginManager());
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            if (commandMap != null) {
+                commandMap.register(this.pluginName, new CoreCommand());
+
+                if (this.getServerManager().getNetwork().equals(ServerType.PVPBAR)) {
+                    commandMap.register("lib", new WebPostCommand());
+                }
+            } else {
+                this.getServer().getPluginManager().disablePlugin(this);
+                this.getLogger().warning("Your server software's PluginManager does not contain a commandMap so I cannot register a command. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+            }
+        } else {
+            this.getLogger().warning("Your server software is running a PluginManager that is unrecognized. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+        }
+    }
+
+    public void registerCommand(Command command) {
+        if (this.getServer().getPluginManager() instanceof SimplePluginManager) {
+            CommandMap commandMap = null;
+
+            try {
+                final Field commandMapField = SimplePluginManager.class.getDeclaredField("commandMap");
+
+                commandMapField.setAccessible(true);
+                commandMap = (CommandMap) commandMapField.get(this.getServer().getPluginManager());
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            if (commandMap != null) {
+                commandMap.register(this.pluginName, command);
+            } else {
+                this.getServer().getPluginManager().disablePlugin(this);
+                this.getLogger().warning("Your server software's PluginManager does not contain a commandMap so I cannot register a command. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+            }
+        } else {
+            this.getLogger().warning("Your server software is running a PluginManager that is unrecognized. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+        }
+    }
+
+    public void logConsole(String message) {
+        this.getServer().getConsoleSender().sendMessage(Color.translate(message));
+    }
+
+    public void addNewSettingHandler(ISettings settings) {
+        this.getSettingsList().add(settings);
+    }
+
+    public void addNewChatCheck(IChatCheck chatCheck) {
+        this.getChatCheckList().add(chatCheck);
+    }
+
+    @Override
+    public void onDisable() {
+        RedisUtil.publishAsync(RedisUtil.onServerOffline());
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            this.playerManager.getPlayer(player).savePlayerData();
+            player.kickPlayer(ChatColor.translateAlternateColorCodes('&', "&cServer is restarting, please wait."));
+        }
+
+        this.serverSettings.setCanJoin(false);
+        this.prefixManager.savePrefixes();
+        this.rankManager.saveRanks();
+    }
+}

Bukkit/src/main/java/com/solexgames/core/adapter/DateTypeAdapter.java

@@ -0,0 +1,36 @@
+package com.solexgames.core.adapter;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * https://bukkit.org/threads/gsonfactory-gson-that-works-on-itemstack-potioneffect-location-objects.331161/
+ */
+
+public class DateTypeAdapter extends TypeAdapter<Date> {
+
+    @Override
+    public void write(JsonWriter jsonWriter, Date date) throws IOException {
+        if (date == null) {
+            jsonWriter.nullValue();
+            return;
+        }
+
+        jsonWriter.value(date.getTime());
+    }
+
+    @Override
+    public Date read(JsonReader jsonReader) throws IOException {
+        if (jsonReader.peek() == JsonToken.NULL) {
+            jsonReader.nextNull();
+            return null;
+        }
+
+        return new Date(jsonReader.nextLong());
+    }
+}

Bukkit/src/main/java/com/solexgames/core/adapter/LocationTypeAdapter.java

@@ -0,0 +1,72 @@
+package com.solexgames.core.adapter;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.solexgames.core.CorePlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * https://bukkit.org/threads/gsonfactory-gson-that-works-on-itemstack-potioneffect-location-objects.331161/
+ */
+
+public class LocationTypeAdapter extends TypeAdapter<Location> {
+
+    private final Type typeToken = new TypeToken<Map<String, Object>>() {}.getType();
+
+    private final String uuidPath = "uuid";
+    private final String xPath = "x";
+    private final String yPath = "y";
+    private final String zPath = "z";
+    private final String yawPath = "yaw";
+    private final String pitchPath = "pitch";
+
+    @Override
+    public void write(JsonWriter jsonWriter, Location location) throws IOException {
+        if (location == null) {
+            jsonWriter.nullValue();
+            return;
+        }
+
+        jsonWriter.value(this.getRaw(location));
+    }
+
+    @Override
+    public Location read(JsonReader jsonReader) throws IOException {
+        if (jsonReader.peek() == JsonToken.NULL) {
+            jsonReader.nextNull();
+            return null;
+        }
+
+        return this.fromRaw(jsonReader.nextString());
+    }
+
+    private String getRaw(Location location) {
+        final Map<String, Object> serial = new HashMap<>();
+
+        serial.put(this.uuidPath, location.getWorld().getUID().toString());
+        serial.put(this.xPath, Double.toString(location.getX()));
+        serial.put(this.yPath, Double.toString(location.getY()));
+        serial.put(this.zPath, Double.toString(location.getZ()));
+        serial.put(this.yawPath, Float.toString(location.getYaw()));
+        serial.put(this.pitchPath, Float.toString(location.getPitch()));
+
+        return CorePlugin.GSON.toJson(serial);
+    }
+
+    private Location fromRaw(String raw) {
+        final Map<String, Object> keys = CorePlugin.GSON.fromJson(raw, this.typeToken);
+        final World world = Bukkit.getWorld(java.util.UUID.fromString((String) keys.get(this.uuidPath)));
+
+        return new Location(world, Double.parseDouble((String) keys.get(this.xPath)), Double.parseDouble((String) keys.get(this.yPath)), Double.parseDouble((String) keys.get(this.zPath)), Float.parseFloat((String) keys.get(this.yawPath)), Float.parseFloat((String) keys.get(this.pitchPath)));
+    }
+}

Bukkit/src/main/java/com/solexgames/core/adapter/PotionEffectTypeAdapter.java

@@ -0,0 +1,53 @@
+package com.solexgames.core.adapter;
+
+import com.google.common.reflect.TypeToken;
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.solexgames.core.CorePlugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Map;
+
+public class PotionEffectTypeAdapter extends TypeAdapter<PotionEffect> {
+
+    private static Type seriType = new TypeToken<Map<String, Object>>(){}.getType();
+
+    private static String TYPE = "effect";
+    private static String DURATION = "duration";
+    private static String AMPLIFIER = "amplifier";
+    private static String AMBIENT = "ambient";
+
+    @Override
+    public void write(JsonWriter jsonWriter, PotionEffect potionEffect) throws IOException {
+        if(potionEffect == null) {
+            jsonWriter.nullValue();
+            return;
+        }
+        jsonWriter.value(getRaw(potionEffect));
+    }
+
+    @Override
+    public PotionEffect read(JsonReader jsonReader) throws IOException {
+        if(jsonReader.peek() == JsonToken.NULL) {
+            jsonReader.nextNull();
+            return null;
+        }
+        return fromRaw(jsonReader.nextString());
+    }
+
+    private String getRaw (PotionEffect potion) {
+        Map<String, Object> serial = potion.serialize();
+
+        return CorePlugin.GSON.toJson(serial);
+    }
+
+    private PotionEffect fromRaw (String raw) {
+        Map<String, Object> keys = CorePlugin.GSON.fromJson(raw, seriType);
+        return new PotionEffect(PotionEffectType.getById(((Double) keys.get(TYPE)).intValue()), ((Double) keys.get(DURATION)).intValue(), ((Double) keys.get(AMPLIFIER)).intValue(),  (Boolean) keys.get(AMBIENT));
+    }
+}

Bukkit/src/main/java/com/solexgames/core/board/ScoreBoard.java

@@ -0,0 +1,155 @@
+package com.solexgames.core.board;
+
+import com.solexgames.core.util.Color;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.DisplaySlot;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * @author GrowlyX
+ * @since 4/15/2021
+ */
+
+@Getter
+@Setter
+public abstract class ScoreBoard {
+
+    @Getter
+    private static HashMap<UUID, ScoreBoard> allBoards = new HashMap<>();
+
+    private Player player;
+    private Scoreboard scoreboard;
+    private Objective objective;
+
+    public ScoreBoard(Player player) {
+        this.player = player;
+
+        this.scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
+        this.objective = this.scoreboard.registerNewObjective("sidebar", "dummy");
+        this.objective.setDisplaySlot(DisplaySlot.SIDEBAR);
+
+        this.player.setScoreboard(this.scoreboard);
+
+        for (int i = 1; i <= 15; i++) {
+            final Team team = this.scoreboard.registerNewTeam("SLOT_" + i);
+            team.addEntry(this.getNewEntry(i));
+        }
+
+        ScoreBoard.getAllBoards().put(player.getUniqueId(), this);
+    }
+
+    public ScoreBoard enableBelowNameTagHearts() {
+        final Objective objective = this.scoreboard.registerNewObjective("name", "health");
+
+        objective.setDisplaySlot(DisplaySlot.BELOW_NAME);
+        objective.setDisplayName("§4❤");
+
+        return this;
+    }
+
+    public ScoreBoard enableTabListHearts() {
+        final Objective tab = this.scoreboard.registerNewObjective("tab", "health");
+        tab.setDisplaySlot(DisplaySlot.PLAYER_LIST);
+
+        return this;
+    }
+
+    public void setTitle(String title) {
+        if (title.length() > 32) {
+            title = title.substring(0, 32);
+        }
+
+        this.objective.setDisplayName(Color.translate(title));
+    }
+
+    private void setSlot(int slot, String text) {
+        if (slot < 15) {
+            final Team team = this.scoreboard.getTeam("SLOT_" + slot);
+            final String entry = this.getNewEntry(slot);
+
+            if (!this.scoreboard.getEntries().contains(entry)) {
+                this.objective.getScore(entry).setScore(slot);
+            }
+
+            String prefix = this.getFirstSplit(text);
+            int lastIndex = prefix.lastIndexOf(167);
+
+            String lastColor = lastIndex >= 14 ? prefix.substring(lastIndex) : ChatColor.getLastColors(prefix);
+
+            if (lastIndex >= 14) {
+                prefix = prefix.substring(0, lastIndex);
+            }
+
+            String suffix = this.getFirstSplit(lastColor + this.getSecondSplit(text));
+
+            if (!team.getPrefix().equals(prefix)) {
+                team.setPrefix(prefix);
+            }
+            if (!team.getSuffix().equals(suffix)) {
+                team.setSuffix(suffix);
+            }
+        }
+    }
+
+    private void removeSlot(int slot) {
+        final String entry = this.getNewEntry(slot);
+
+        if (scoreboard.getEntries().contains(entry)) {
+            this.scoreboard.resetScores(entry);
+        }
+    }
+
+    public void setSlotsFromList(List<String> list) {
+        int slot = list.size();
+
+        if (slot < 15) {
+            for (int i = (slot + 1); i <= 15; i++) {
+                this.removeSlot(i);
+            }
+        }
+
+        for (String line : list) {
+            this.setSlot(slot, line);
+            slot--;
+        }
+    }
+
+    private String getNewEntry(int slot) {
+        return ChatColor.values()[slot].toString();
+    }
+
+    private String getFirstSplit(String string) {
+        return string.length() > 16 ? string.substring(0, 16) : string;
+    }
+
+    private String getSecondSplit(String string) {
+        if (string.length() > 32) {
+            string = string.substring(0, 32);
+        }
+
+        return string.length() > 16 ? string.substring(16) : "";
+    }
+
+    public void remove() {
+        this.player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
+        ScoreBoard.getAllBoards().remove(this.getPlayer().getUniqueId());
+    }
+
+    public abstract List<String> getLines();
+    public abstract String getTitle();
+
+    public void update() {
+        this.setTitle(this.getTitle());
+        this.setSlotsFromList(this.getLines());
+    }
+}

Bukkit/src/main/java/com/solexgames/core/board/impl/ModModeBoard.java

@@ -0,0 +1,64 @@
+package com.solexgames.core.board.impl;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.board.ScoreBoard;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ModModeBoard extends ScoreBoard {
+
+    public final ServerType network;
+    public final PotPlayer potPlayer;
+
+    public ModModeBoard(Player player) {
+        super(player);
+
+        this.potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(this.getPlayer());
+        this.network = CorePlugin.getInstance().getServerManager().getNetwork();
+    }
+
+    @Override
+    public List<String> getLines() {
+        final List<String> lines = new ArrayList<>();
+
+        lines.add(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + "--------------------");
+        lines.add((!potPlayer.isVanished() ? ChatColor.GREEN + "Visible (Showing staff)" : ChatColor.RED + "Hidden (Showing staff)"));
+        lines.add(network.getSecondaryColor() + "Channel: " + network.getMainColor() + (potPlayer.getChannel() != null ? Color.translate(getChannel(potPlayer.getChannel())) : "Regular"));
+        lines.add(network.getSecondaryColor() + "Players: " + network.getMainColor() + Bukkit.getOnlinePlayers().size());
+        lines.add(network.getSecondaryColor() + "TPS: " + RedisUtil.getTicksPerSecondFormatted());
+        lines.add(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + "--------------------");
+
+        return lines;
+    }
+
+    @Override
+    public String getTitle() {
+        return network.getSecondaryColor() + ChatColor.BOLD.toString() + "Mod Mode";
+    }
+
+    public String getChannel(ChatChannelType chatChannelType) {
+        switch (chatChannelType) {
+            case DEV:
+                return "&3Developer";
+            case STAFF:
+                return "&bStaff";
+            case HOST:
+                return "&2Host";
+            case MANAGER:
+                return "&4Manager";
+            case ADMIN:
+                return "&cAdmin";
+            default:
+                return "Normal";
+        }
+    }
+}

Bukkit/src/main/java/com/solexgames/core/chat/IChatCheck.java

@@ -0,0 +1,15 @@
+package com.solexgames.core.chat;
+
+import com.solexgames.core.player.PotPlayer;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+
+/**
+ * @author GrowlyX
+ * @since 5/25/2021
+ */
+
+public interface IChatCheck {
+
+    void check(AsyncPlayerChatEvent event, PotPlayer potPlayer);
+
+}

Bukkit/src/main/java/com/solexgames/core/chat/IChatFormat.java

@@ -0,0 +1,9 @@
+package com.solexgames.core.chat;
+
+import org.bukkit.entity.Player;
+
+public interface IChatFormat {
+
+    String getFormatted(Player sender, Player receiver, String message);
+
+}

Bukkit/src/main/java/com/solexgames/core/chat/impl/DefaultChatFormat.java

@@ -0,0 +1,30 @@
+package com.solexgames.core.chat.impl;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.chat.IChatFormat;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+public class DefaultChatFormat implements IChatFormat {
+
+    @Override
+    public String getFormatted(Player sender, Player receiver, String message) {
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(sender);
+        final Rank activeRank = potPlayer.getActiveGrant().getRank();
+
+        final String defaultFormat = Color.translate(CorePlugin.getInstance().getServerSettings().getChatFormat()
+                .replace("<prefix>", (potPlayer.getAppliedPrefix() != null ? " " + potPlayer.getAppliedPrefix().getPrefix() : ""))
+                .replace("<rank_prefix>", (potPlayer.getDisguiseRank() != null ? potPlayer.getDisguiseRank().getPrefix() : activeRank.getPrefix()))
+                .replace("<rank_suffix>", (potPlayer.getDisguiseRank() != null ? potPlayer.getDisguiseRank().getSuffix() : activeRank.getSuffix()))
+                .replace("<rank_color>", (potPlayer.getDisguiseRank() != null ? potPlayer.getDisguiseRank().getColor() : activeRank.getColor()))
+                .replace("<custom_color>", (potPlayer.getCustomColor() != null ? potPlayer.getCustomColor().toString() : ""))
+                .replace(receiver.getName(), ChatColor.YELLOW + receiver.getName() + ChatColor.WHITE)
+                .replace("<player_name>", activeRank.getItalic() + sender.getName())
+        );
+
+        return defaultFormat.replace("<message>", message);
+    }
+}

Bukkit/src/main/java/com/solexgames/core/chat/impl/PAPIChatFormat.java

@@ -0,0 +1,15 @@
+package com.solexgames.core.chat.impl;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.chat.IChatFormat;
+import com.solexgames.core.util.Color;
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.bukkit.entity.Player;
+
+public class PAPIChatFormat implements IChatFormat {
+
+    @Override
+    public String getFormatted(Player sender, Player receiver, String message) {
+        return PlaceholderAPI.setPlaceholders(sender, Color.translate(CorePlugin.getInstance().getServerSettings().getChatFormat()));
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/BaseCommand.java

@@ -0,0 +1,187 @@
+package com.solexgames.core.command;
+
+import com.google.common.collect.Sets;
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.command.CommandHelpBuilder;
+import com.solexgames.core.util.command.CustomHelpTopic;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.*;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.SimplePluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * @author GrowlyX
+ * @since 2021
+ *
+ * @see CommandExecutor
+ * @see CorePlugin
+ */
+
+@Getter
+public abstract class BaseCommand extends Command {
+
+    protected final String ONLY_PLAYERS = ChatColor.RED + "Only players can execute this command.";
+    protected final String NO_PERMISSION = ChatColor.RED + "I'm sorry, but you do not have permission to perform this command.";
+
+    private boolean async;
+    private boolean hidden;
+    private boolean consoleOnly;
+
+    private String permissionNode;
+
+    protected BaseCommand() {
+        super("");
+
+        final Class<? extends BaseCommand> clazz = this.getClass();
+        if (!clazz.isAnnotationPresent(com.solexgames.core.command.annotation.Command.class)) {
+            return;
+        }
+
+        final com.solexgames.core.command.annotation.Command command = clazz.getAnnotation(com.solexgames.core.command.annotation.Command.class);
+
+        this.async = command.async();
+        this.hidden = command.hidden();
+        this.consoleOnly = command.consoleOnly();
+        this.permissionNode = consoleOnly ? "console" : command.permission();
+
+        this.setPermission(this.permissionNode);
+        this.setLabel(command.label());
+
+        try {
+            final Field declaredField = Command.class.getDeclaredField("name");
+
+            declaredField.setAccessible(true);
+            declaredField.set(this, command.label());
+        } catch (Exception exception) {
+            return;
+        }
+
+        this.setAliases(Arrays.asList(command.aliases().clone()));
+
+        CorePlugin.getInstance().registerCommand(this);
+        Bukkit.getHelpMap().addTopic(new CustomHelpTopic(this, Sets.newHashSet(this.getAliases())));
+    }
+
+    protected BaseCommand(JavaPlugin javaPlugin) {
+        super("");
+
+        final Class<? extends BaseCommand> clazz = this.getClass();
+        if (!clazz.isAnnotationPresent(com.solexgames.core.command.annotation.Command.class)) {
+            return;
+        }
+
+        final com.solexgames.core.command.annotation.Command command = clazz.getAnnotation(com.solexgames.core.command.annotation.Command.class);
+
+        this.async = command.async();
+        this.hidden = command.hidden();
+        this.consoleOnly = command.consoleOnly();
+        this.permissionNode = consoleOnly ? "console" : command.permission();
+
+        this.setPermission(this.permissionNode);
+        this.setLabel(command.label());
+
+        try {
+            final Field declaredField = Command.class.getDeclaredField("name");
+
+            declaredField.setAccessible(true);
+            declaredField.set(this, command.label());
+        } catch (Exception exception) {
+            return;
+        }
+
+        this.setAliases(Arrays.asList(command.aliases().clone()));
+
+        this.registerToCommandMap(javaPlugin);
+    }
+
+    public void registerToCommandMap(JavaPlugin javaPlugin) {
+        if (javaPlugin.getServer().getPluginManager() instanceof SimplePluginManager) {
+            CommandMap commandMap = null;
+
+            try {
+                final Field commandMapField = SimplePluginManager.class.getDeclaredField("commandMap");
+
+                commandMapField.setAccessible(true);
+                commandMap = (CommandMap) commandMapField.get(javaPlugin.getServer().getPluginManager());
+                commandMapField.setAccessible(false);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            if (commandMap != null) {
+                commandMap.register(javaPlugin.getName(), this);
+            } else {
+                javaPlugin.getServer().getPluginManager().disablePlugin(javaPlugin);
+                javaPlugin.getLogger().warning("Your server software's PluginManager does not contain a commandMap so I cannot register a command. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+            }
+        } else {
+            javaPlugin.getLogger().warning("Your server software is running a PluginManager that is unrecognized. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+        }
+
+        Bukkit.getHelpMap().addTopic(new CustomHelpTopic(this, Sets.newHashSet(this.getAliases())));
+    }
+
+    public abstract boolean command(CommandSender sender, String label, String[] args);
+
+    public boolean canShowOnTabCompletion(CommandSender sender) {
+        if (this.permissionNode == null || this.permissionNode.equals("")) {
+            return true;
+        }
+
+        if (this.hidden) {
+            return sender instanceof ConsoleCommandSender || sender.hasPermission(this.permissionNode) || sender.isOp();
+        }
+
+        switch (this.permissionNode) {
+            case "console":
+                return sender instanceof ConsoleCommandSender;
+            case "op":
+                return sender.isOp();
+            case "":
+                return true;
+        }
+
+        return sender.hasPermission(this.permissionNode);
+    }
+
+    @Override
+    public boolean execute(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof ConsoleCommandSender) && this.isConsoleOnly()) {
+            sender.sendMessage(this.NO_PERMISSION);
+            return false;
+        }
+
+        if (this.permissionNode != null && !this.permissionNode.equals("") && !sender.hasPermission(this.permissionNode)) {
+            sender.sendMessage(this.NO_PERMISSION);
+            return false;
+        }
+
+        if (this.async) {
+            CompletableFuture.runAsync(() -> this.command(sender, label, args));
+        } else {
+            this.command(sender, label, args);
+        }
+
+        return true;
+    }
+
+    public void getHelpMessage(int page, CommandSender sender, String... strings) {
+        final CommandHelpBuilder helpBuilder = new CommandHelpBuilder(10, this.getLabel());
+
+        helpBuilder.display(sender, page, Arrays.asList(strings));
+    }
+
+    public String getUsageMessage(String subCommand, String... arguments) {
+        return Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + this.getLabel() + " " + ChatColor.WHITE + subCommand + " " + String.join(" ", arguments) + "";
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/EBaseCommand.java

@@ -0,0 +1,83 @@
+package com.solexgames.core.command;
+
+import com.solexgames.core.util.command.CommandHelpBuilder;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandMap;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.SimplePluginManager;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * For external plugins which are using this command library.
+ * <p>
+ * <b>Note:</b> Does not register this command instance on instantiation you will have to register it in your {@link org.bukkit.plugin.java.JavaPlugin} onEnable method manually.
+ *
+ * @author GrowlyX
+ * @since 2021
+ * @revised 4/19/2021
+ *
+ * @see CommandExecutor
+ * @see org.bukkit.plugin.java.JavaPlugin
+ * @see BaseCommand Original BaseCommand
+ */
+
+public abstract class EBaseCommand extends Command {
+
+    protected final String ONLY_PLAYERS = ChatColor.RED + "Only players can execute this command.";
+    protected final String NO_PERMISSION = ChatColor.RED + "I'm sorry, but you do not have permission to perform this command.";
+
+    protected EBaseCommand() {
+        super("");
+
+        final String commandNameFromClazz = this.getClass().getSimpleName().replace("Command", "").toLowerCase();
+
+        this.setLabel(commandNameFromClazz);
+        this.setName(commandNameFromClazz);
+        this.setAliases((this.getAliases() == null ? new ArrayList<>() : this.getAliases()));
+    }
+
+    public abstract boolean execute(CommandSender sender, String label, String[] args);
+
+    public abstract List<String> getAliases();
+
+    public void getHelpMessage(int page, CommandSender sender, String... strings) {
+        final CommandHelpBuilder helpBuilder = new CommandHelpBuilder(10, this.getLabel());
+
+        helpBuilder.display(sender, page, Arrays.asList(strings));
+    }
+
+    public boolean isHidden() {
+        return true;
+    }
+
+    public void registerCommand(Plugin plugin) {
+        if (plugin.getServer().getPluginManager() instanceof SimplePluginManager) {
+            CommandMap commandMap = null;
+
+            try {
+                final Field commandMapField = SimplePluginManager.class.getDeclaredField("commandMap");
+
+                commandMapField.setAccessible(true);
+                commandMap = (CommandMap) commandMapField.get(plugin.getServer().getPluginManager());
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            if (commandMap != null) {
+                commandMap.register(plugin.getName(), this);
+            } else {
+                plugin.getServer().getPluginManager().disablePlugin(plugin);
+                plugin.getLogger().warning("Your server software's PluginManager does not contain a commandMap so I cannot register a command. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+            }
+        } else {
+            plugin.getLogger().warning("Your server software is running a PluginManager that is unrecognized. This may be due to the fact you might be running a custom Bukkit/Spigot version.");
+        }
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/annotation/Command.java

@@ -0,0 +1,21 @@
+package com.solexgames.core.command.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Command {
+
+    String label();
+
+    String[] aliases() default {};
+    String permission() default "";
+
+    boolean async() default false;
+    boolean consoleOnly() default false;
+    boolean hidden() default true;
+
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/CoreCommand.java

@@ -0,0 +1,70 @@
+package com.solexgames.core.command.impl;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.menu.impl.ScandiumMenu;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "scandium", permission = "scandium.command.core")
+public class CoreCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            this.getHelpMessage(1, sender,
+                    "/" + label + " debug",
+                    "/" + label + " panel",
+                    "/" + label + " threads"
+            );
+        }
+
+        if (args.length > 0) {
+            switch (args[0]) {
+                case "threads":
+                    Thread.getAllStackTraces().keySet().stream()
+                            .filter(thread -> thread.isAlive() && thread.isDaemon())
+                            .forEachOrdered(thread -> player.sendMessage(Color.MAIN_COLOR + thread.getName() + Color.SECONDARY_COLOR + " (ID: " + Color.MAIN_COLOR + thread.getId() + Color.SECONDARY_COLOR + ") (State: " + Color.MAIN_COLOR + thread.getState().name() + Color.SECONDARY_COLOR + ")"));
+                    break;
+                case "debug":
+                    player.sendMessage(new String[] {
+                            "  ",
+                            StringUtil.getCentered(Color.MAIN_COLOR + ChatColor.BOLD.toString() + CorePlugin.getInstance().getConfig().getString("theming.core-name") + " Server Instance:"),
+                            "",
+                            StringUtil.getCentered(Color.SECONDARY_COLOR + "Current Threads: " + Color.MAIN_COLOR + Thread.getAllStackTraces().keySet().stream().filter(thread -> thread.isAlive() && thread.isDaemon()).count()),
+                            StringUtil.getCentered(Color.SECONDARY_COLOR + "Jedis Active: " + Color.MAIN_COLOR + CorePlugin.getInstance().getJedisManager().getJedisPool().getNumActive()),
+                            StringUtil.getCentered(Color.SECONDARY_COLOR + "Jedis Idle: " + Color.MAIN_COLOR + CorePlugin.getInstance().getJedisManager().getJedisPool().getNumIdle()),
+                            StringUtil.getCentered(Color.SECONDARY_COLOR + "Jedis Waiters: " + Color.MAIN_COLOR + CorePlugin.getInstance().getJedisManager().getJedisPool().getNumWaiters()),
+                            StringUtil.getCentered(Color.SECONDARY_COLOR + "Current TPS: " + Color.MAIN_COLOR + String.format("%.2f", Math.min(CorePlugin.getInstance().getTpsRunnable().getTPS(), 20.0))),
+                            "",
+                            StringUtil.getCentered(ChatColor.GRAY + ChatColor.ITALIC.toString() + "For more information on threads, use /" + label + " threads."),
+                            "  "
+                    });
+                    break;
+                case "panel":
+                    new ScandiumMenu(player).open(player);
+                    break;
+                default:
+                    this.getHelpMessage(1, sender,
+                            "/" + label + "debug",
+                            "/" + label + "panel",
+                            "/" + label + "threads"
+                    );
+                    break;
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/auth/AuthBypassCommand.java

@@ -0,0 +1,57 @@
+package com.solexgames.core.command.impl.auth;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.LockedState;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(
+        label = "authbypass",
+        permission = "scandium.command.authbypass",
+        aliases = {"remove2fa", "2fabypass"},
+        consoleOnly = true
+)
+public class AuthBypassCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+            return false;
+        }
+
+        final Player target = Bukkit.getPlayer(args[0]);
+
+        if (target == null) {
+            sender.sendMessage(ChatColor.RED + "Error: A player by that name couldn't be found.");
+            return true;
+        }
+
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+        if (!potPlayer.isAuthBypassed()) {
+            target.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "An administrator has granted you two-factor authentication bypass.");
+            sender.sendMessage(Constants.STAFF_PREFIX + ChatColor.YELLOW + "You've just granted " + ChatColor.AQUA + target.getName() + ChatColor.YELLOW + " two-factor authentication bypass.");
+        } else {
+            target.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "An administrator has removed your two-factor authentication bypass.");
+            sender.sendMessage(Constants.STAFF_PREFIX + ChatColor.YELLOW + "You've just removed " + ChatColor.AQUA + target.getName() + ChatColor.YELLOW + "'s two-factor authentication bypass.");
+        }
+
+        potPlayer.saveWithoutRemove();
+        potPlayer.setAuthBypassed(!potPlayer.isAuthBypassed());
+
+        LockedState.release(target);
+
+        return true;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/auth/AuthCommand.java

@@ -0,0 +1,70 @@
+package com.solexgames.core.command.impl.auth;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.LockedState;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Command(label = "auth", permission = "scandium.2fa", aliases = {"2fa"}, async = true)
+public class AuthCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (!LockedState.isLocked(player)) {
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You do not have to authenticate right now.");
+            return false;
+        }
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <otp>");
+            return false;
+        }
+
+        final String input = StringUtils.join(args).replace(" ", "");
+
+        int code;
+        try {
+            code = Integer.parseInt(input);
+        } catch (NumberFormatException e) {
+            player.sendMessage(ChatColor.RED + "Error: " + ChatColor.YELLOW + input + ChatColor.RED + " is not an integer.");
+            return false;
+        }
+
+        final boolean valid = potPlayer.isAuthValid(code);
+
+        if (valid) {
+            LockedState.release(player);
+
+            potPlayer.setRequiredToAuth(false);
+            potPlayer.setLastAuth(System.currentTimeMillis());
+            potPlayer.saveWithoutRemove();
+
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.YELLOW + "You've " + ChatColor.GREEN + "verified" + ChatColor.YELLOW + " your identity!");
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.YELLOW + "Thanks for helping us keep our server safe! " + ChatColor.RED + "❤");
+        } else {
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "The code you provided was invalid, please try again.");
+        }
+
+        return true;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/auth/AuthSetupCommand.java

@@ -0,0 +1,46 @@
+package com.solexgames.core.command.impl.auth;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.prompt.DisclaimerPrompt;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.conversations.ConversationFactory;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Command(label = "authsetup", permission = "scandium.2fa", aliases = {"setupauth", "setup2fa"})
+public class AuthSetupCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(this.ONLY_PLAYERS);
+            return true;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (potPlayer.isHasSetup2FA() || potPlayer.getAuthSecret() != null) {
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You've already setup two-factor authentication.");
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "Contact a developer or management member to reset your 2FA.");
+            return false;
+        }
+
+        final ConversationFactory factory = CorePlugin.getInstance().getConversationFactory()
+                .withFirstPrompt(new DisclaimerPrompt())
+                .withLocalEcho(false)
+                .thatExcludesNonPlayersWithMessage(this.ONLY_PLAYERS);
+
+        player.beginConversation(factory.buildConversation(player));
+
+        return true;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/auth/ResetAuthCommand.java

@@ -0,0 +1,53 @@
+package com.solexgames.core.command.impl.auth;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.LockedState;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * @author GrowlyX
+ * @since 6/24/2021
+ */
+
+@Command(
+        label = "authreset",
+        permission = "scandium.command.authreset",
+        consoleOnly = true
+)
+public class ResetAuthCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+            return false;
+        }
+
+        final Player target = Bukkit.getPlayer(args[0]);
+
+        if (target == null) {
+            sender.sendMessage(ChatColor.RED + "Error: A player by that name couldn't be found.");
+            return true;
+        }
+
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+        potPlayer.setAuthSecret(null);
+        potPlayer.setHasSetup2FA(false);
+        potPlayer.setAuthBypassed(false);
+        potPlayer.setLastAuth(-1L);
+        potPlayer.saveWithoutRemove();
+
+        sender.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You've reset " + target.getDisplayName() + ChatColor.GREEN + "'s 2FA.");
+
+        return true;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/disguise/CheckDisguiseCommand.java

@@ -0,0 +1,52 @@
+package com.solexgames.core.command.impl.disguise;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Command(label = "checkdisguise", permission = "scandium.command.checkdisguise")
+public class CheckDisguiseCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+
+        if (args.length > 0) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target == null) {
+                return false;
+            }
+
+            final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+            if (potPlayer == null) {
+                sender.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            } else {
+                final boolean disguised = potPlayer.isDisguised();
+
+                if (disguised) {
+                    sender.sendMessage(potPlayer.getOriginalRankColor() + potPlayer.getOriginalName() + Color.SECONDARY_COLOR + " is disguised as " + Color.translate(potPlayer.getDisguiseRank().getColor()) + potPlayer.getName() + Color.SECONDARY_COLOR + " with the rank " + Color.translate(potPlayer.getDisguiseRank().getColor() + potPlayer.getDisguiseRank().getName()) + Color.SECONDARY_COLOR + ".");
+                } else {
+                    sender.sendMessage(target.getDisplayName() + ChatColor.RED + " is not disguised.");
+                }
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/disguise/DisguiseAdminCommand.java

@@ -0,0 +1,184 @@
+package com.solexgames.core.command.impl.disguise;
+
+import com.mongodb.client.model.Filters;
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.disguise.DisguiseData;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.VotingUtil;
+import com.solexgames.core.util.builder.PageListBuilder;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.net.URL;
+import java.util.Collections;
+import java.util.List;
+import java.util.Scanner;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+@Command(label = "disguiseadmin", permission = "scandium.command.disguiseadmin", aliases = {"nickadmin"}, async = true)
+public class DisguiseAdminCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            this.getHelpMessage(1, sender,
+                    "/disguiseadmin add <username>",
+                    "/disguiseadmin massadd <url>",
+                    "/disguiseadmin remove <username>",
+                    "/disguiseadmin list"
+            );
+        }
+
+        if (args.length > 0) {
+            switch (args[0].toLowerCase()) {
+                case "add":
+                    if (args.length < 2) {
+                        this.getHelpMessage(1, sender,
+                                "/disguiseadmin add <username>",
+                                "/disguiseadmin massadd <url>",
+                                "/disguiseadmin remove <username>",
+                                "/disguiseadmin list"
+                        );
+                    }
+                    if (args.length == 2) {
+                        final UUID uuid = CorePlugin.getInstance().getUuidCache().getUuidFromUsername(args[1]);
+
+                        if (uuid == null) {
+                            player.sendMessage(ChatColor.RED + "Error: That player is not valid.");
+                            return false;
+                        }
+
+                        if (CorePlugin.getInstance().getDisguiseCache().getByUuid(uuid) != null || CorePlugin.getInstance().getDisguiseCache().getByName(args[1]) != null) {
+                            player.sendMessage(ChatColor.RED + "Error: There's already a disguise profile with that name!");
+                            return false;
+                        }
+
+                        final DisguiseData disguiseData = CorePlugin.getInstance().getDisguiseManager().getDisguiseData(args[1], uuid);
+
+                        if (disguiseData == null) {
+                            player.sendMessage(ChatColor.RED + "Error: We couldn't create a new disguise profile for that username.");
+                            return false;
+                        }
+
+                        CorePlugin.getInstance().getDisguiseCache().registerNewDataPair(disguiseData);
+                        RedisUtil.publishAsync(RedisUtil.onDisguiseProfileCreate(disguiseData));
+
+                        disguiseData.saveData();
+
+                        player.sendMessage(Color.SECONDARY_COLOR + "You've registered a new disguise profile with the name " + Color.MAIN_COLOR + disguiseData.getName() + Color.SECONDARY_COLOR + "!");
+                    }
+                    break;
+                case "remove":
+                    if (args.length < 2) {
+                        this.getHelpMessage(1, sender,
+                                "/disguiseadmin add <username>",
+                                "/disguiseadmin massadd <url>",
+                                "/disguiseadmin remove <username>",
+                                "/disguiseadmin list"
+                        );
+                    }
+                    if (args.length == 2) {
+                        final DisguiseData disguiseData = CorePlugin.getInstance().getDisguiseCache().getDisguiseDataList().stream()
+                                .filter(disguiseData1 -> disguiseData1.getName().equalsIgnoreCase(args[1]))
+                                .findFirst().orElse(null);
+
+                        if (disguiseData == null) {
+                            player.sendMessage(ChatColor.RED + "Error: We couldn't find a disguise profile with that name.");
+                            return false;
+                        }
+
+                        CorePlugin.getInstance().getDisguiseCache().removeDataPair(disguiseData);
+
+                        CompletableFuture.runAsync(() -> CorePlugin.getInstance().getCoreDatabase().getDisguiseCollection().deleteOne(Filters.eq("_id", disguiseData.getUuid())));
+
+                        RedisUtil.publishAsync(RedisUtil.onDisguiseProfileRemove(disguiseData));
+
+                        player.sendMessage(Color.SECONDARY_COLOR + "You've removed the disguise profile with the name " + Color.MAIN_COLOR + disguiseData.getName() + Color.SECONDARY_COLOR + "!");
+                    }
+                    break;
+                case "massadd":
+                    if (args.length < 2) {
+                        this.getHelpMessage(1, sender,
+                                "/disguiseadmin add <username>",
+                                "/disguiseadmin massadd <url>",
+                                "/disguiseadmin remove <username>",
+                                "/disguiseadmin list"
+                        );
+                    }
+                    if (args.length == 2) {
+                        try (Scanner scanner = new Scanner(new URL(args[1]).openStream()).useDelimiter("\\A")) {
+                            player.sendMessage(Color.SECONDARY_COLOR + "Starting the process of mass adding disguise profiles...");
+
+                            String inputLine;
+                            while ((inputLine = scanner.nextLine()) != null) {
+                                final UUID uuid = CorePlugin.getInstance().getUuidCache().getUuidFromUsername(inputLine);
+
+                                if (uuid != null) {
+                                    if (CorePlugin.getInstance().getDisguiseCache().getByUuid(uuid) != null || CorePlugin.getInstance().getDisguiseCache().getByName(args[1]) != null) {
+                                        continue;
+                                    }
+
+                                    final DisguiseData disguiseData = CorePlugin.getInstance().getDisguiseManager().getDisguiseData(inputLine, uuid);
+
+                                    if (disguiseData != null) {
+                                        CorePlugin.getInstance().getDisguiseCache().registerNewDataPair(disguiseData);
+                                        RedisUtil.publishAsync(RedisUtil.onDisguiseProfileCreate(disguiseData));
+
+                                        disguiseData.saveData();
+
+                                        player.sendMessage(Color.SECONDARY_COLOR + "You've registered a new disguise profile with the name " + Color.MAIN_COLOR + disguiseData.getName() + Color.SECONDARY_COLOR + "!");
+                                    }
+                                }
+                            }
+
+                            return Boolean.parseBoolean(scanner.next());
+                        } catch (Exception ignored) {
+                            player.sendMessage();
+                        }
+                    }
+                    break;
+                case "list":
+                    final PageListBuilder pageListBuilder = new PageListBuilder(10, "Disguises");
+                    final List<String> stringList = CorePlugin.getInstance().getDisguiseCache().getDisguiseDataList().stream()
+                            .map(DisguiseData::getName)
+                            .collect(Collectors.toList());
+
+                    if (args.length == 1) {
+                        pageListBuilder.display(sender, 1, stringList);
+                    }
+                    if (args.length == 2) {
+                        try {
+                            final int page = Integer.parseInt(args[0]);
+
+                            pageListBuilder.display(sender, page, stringList);
+                        } catch (Exception ignored) {
+                            player.sendMessage(ChatColor.RED + "That's not a valid page integer!");
+                        }
+                    }
+                    break;
+                default:
+                    this.getHelpMessage(1, sender,
+                            "/disguiseadmin add <username>",
+                            "/disguiseadmin massadd <url>",
+                            "/disguiseadmin remove <username>",
+                            "/disguiseadmin list"
+                    );
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/disguise/DisguiseCommand.java

@@ -0,0 +1,47 @@
+package com.solexgames.core.command.impl.disguise;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.disguise.DisguiseData;
+import com.solexgames.core.listener.custom.PreDisguiseEvent;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "disguise", permission = "scandium.command.disguise", aliases = {"nick"})
+public class DisguiseCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (potPlayer.isDisguised()) {
+            player.sendMessage(ChatColor.RED + "You're already disguised with the name " + ChatColor.YELLOW + potPlayer.getName() + ChatColor.RED + "!");
+            return false;
+        }
+
+        final DisguiseData disguiseData = CorePlugin.getInstance().getDisguiseCache().getRandomData();
+        final DisguiseData skinData = CorePlugin.getInstance().getDisguiseCache().getRandomData();
+
+        if (disguiseData != null && skinData != null) {
+            CorePlugin.getInstance().getDisguiseManager().disguise(player, disguiseData, skinData, Rank.getDefault());
+        } else {
+            player.sendMessage(ChatColor.RED + "Something went wrong while trying to disguise you.");
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/disguise/DisguiseListCommand.java

@@ -0,0 +1,47 @@
+package com.solexgames.core.command.impl.disguise;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.builder.PageListBuilder;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Command(label = "disguiselist", permission = "scandium.command.disguiselist", aliases = {"nicklist"})
+public class DisguiseListCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PageListBuilder pageListBuilder = new PageListBuilder(10, "Disguised Players");
+        final List<String> stringList = CorePlugin.getInstance().getPlayerManager().getAllProfiles().values().stream()
+                .filter(uuidPotPlayerEntry -> uuidPotPlayerEntry != null && uuidPotPlayerEntry.isDisguised())
+                .map(potPlayer -> potPlayer.getColorByRankColorWithItalic() + potPlayer.getName() + ChatColor.GRAY + " (" + potPlayer.getOriginalName() + ")")
+                .collect(Collectors.toList());
+
+        if (args.length == 0) {
+            pageListBuilder.display(sender, 1, stringList);
+        }
+        if (args.length == 1) {
+            try {
+                final int page = Integer.parseInt(args[0]);
+
+                pageListBuilder.display(sender, page, stringList);
+            } catch (Exception ignored) {
+                player.sendMessage(ChatColor.RED + "That's not a valid page integer!");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/disguise/DisguiseManualCommand.java

@@ -0,0 +1,81 @@
+package com.solexgames.core.command.impl.disguise;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.disguise.DisguiseData;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+@Command(label = "disguisemanual", permission = "scandium.command.disguisemanual")
+public class DisguiseManualCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length < 3) {
+           player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/disguisemanual " + ChatColor.WHITE + "<rank> <name> <player>");
+        }
+        if (args.length == 3) {
+            final Player target = Bukkit.getPlayer(args[2]);
+
+            if (target != null) {
+                final Rank rank = Rank.getByName(args[0]);
+
+                if (rank == null) {
+                    player.sendMessage(ChatColor.RED + "Error: That rank is not valid.");
+                    return false;
+                }
+
+                final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                if (potPlayer.isDisguised()) {
+                    player.sendMessage(ChatColor.RED + "Error: That player's already disguised with the name " + ChatColor.YELLOW + potPlayer.getName() + ChatColor.RED + "!");
+                    return false;
+                }
+
+                final DisguiseData disguiseData = CorePlugin.getInstance().getDisguiseCache().getByName(args[1]);
+
+                if (disguiseData != null) {
+                    CorePlugin.getInstance().getDisguiseManager().disguise(target, disguiseData, disguiseData, rank);
+
+                    player.sendMessage(Color.SECONDARY_COLOR + "You've disguised " + Color.MAIN_COLOR + player.getDisplayName() + Color.SECONDARY_COLOR + " as " + Color.translate(rank.getColor() + rank.getItalic()) + disguiseData.getName() + ChatColor.GRAY + " (with a random skin)" + Color.SECONDARY_COLOR + ".");
+                } else {
+                    final UUID uuid = CorePlugin.getInstance().getUuidCache().getUuidFromUsername(args[1]);
+
+                    if (uuid == null) {
+                        player.sendMessage(ChatColor.RED + "Error: That disguise name is not valid.");
+                        return false;
+                    }
+
+                    final DisguiseData generatedData = CorePlugin.getInstance().getDisguiseManager().getDisguiseData(args[1], uuid);
+
+                    CorePlugin.getInstance().getDisguiseManager().disguise(target, generatedData, generatedData, rank);
+
+                    player.sendMessage(Color.SECONDARY_COLOR + "You've disguised " + Color.MAIN_COLOR + player.getDisplayName() + Color.SECONDARY_COLOR + " as " + Color.translate(rank.getColor() + rank.getItalic()) + generatedData.getName() + ChatColor.GRAY + " (with a random skin)" + Color.SECONDARY_COLOR + ".");
+                }
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/disguise/UnDisguiseCommand.java

@@ -0,0 +1,37 @@
+package com.solexgames.core.command.impl.disguise;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.disguise.DisguiseData;
+import com.solexgames.core.player.PotPlayer;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "undisguise", permission = "scandium.command.undisguise", aliases = {"unnick"})
+public class UnDisguiseCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (!potPlayer.isDisguised()) {
+            player.sendMessage(ChatColor.RED + "You aren't currently disguised!");
+            return false;
+        }
+
+        CorePlugin.getInstance().getDisguiseManager().unDisguise(potPlayer, player);
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/BroadcastCommand.java

@@ -0,0 +1,44 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "broadcast", permission = "scandium.command.broadcast", aliases = {"bc", "alert", "galert", "rgalert"})
+public class BroadcastCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " [l:] [g:] <message>");
+        }
+        if (args.length > 0) {
+            String message = StringUtil.buildMessage(args, 0);
+            if (message.startsWith("l:")) {
+                Bukkit.broadcastMessage(Color.translate(message.replace("l:", "")));
+            } else if (message.startsWith("g:")) {
+                RedisUtil.publishAsync(RedisUtil.onGlobalBroadcast(message.replace("g:", "")));
+            } else {
+                RedisUtil.publishAsync(RedisUtil.onGlobalBroadcast(message));
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/ClearCommand.java

@@ -0,0 +1,48 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "clear", permission = "scandium.command.clear", aliases = {"ci", "clearinv", "clearinventory"})
+public class ClearCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.getInventory().clear();
+            player.sendMessage(Color.SECONDARY_COLOR + "You've cleared your inventory.");
+
+            PlayerUtil.sendAlert(player, "cleared inventory");
+        }
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                player.getInventory().clear();
+
+                player.sendMessage(Color.SECONDARY_COLOR + "You've cleared " + target.getDisplayName() + Color.SECONDARY_COLOR + "'s inventory.");
+
+                PlayerUtil.sendAlert(player, "cleared inventory for " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+        return true;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/ColorCommand.java

@@ -0,0 +1,28 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.external.impl.NameColorSelectMenu;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "color", permission = "scandium.chat.colors", aliases = {"chatcolor"}, hidden = false)
+public class ColorCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        new NameColorSelectMenu().openMenu(player);
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/CraftingCommand.java

@@ -0,0 +1,27 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "craft", permission = "scandium.command.craft", aliases = {"crafting"})
+public class CraftingCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        player.openWorkbench(player.getLocation(), true);
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/DiscordCommand.java

@@ -0,0 +1,21 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import org.bukkit.command.CommandSender;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "discord", hidden = false)
+public class DiscordCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        sender.sendMessage(Color.SECONDARY_COLOR + "Discord: " + Color.MAIN_COLOR + CorePlugin.getInstance().getServerManager().getNetwork().getDiscordLink());
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/EnchantCommand.java

@@ -0,0 +1,32 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "enchant", permission = "scandium.command.enchant")
+public class EnchantCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (!player.hasPermission("scandium.command.enchant")) {
+            player.sendMessage(NO_PERMISSION);
+            return false;
+        }
+
+        player.openEnchanting(player.getLocation(), true);
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/EnderChestCommand.java

@@ -0,0 +1,47 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "enderchest", aliases = "echest", permission = "scandium.command.echest")
+public class EnderChestCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.openInventory(player.getEnderChest());
+        }
+
+        if (args.length == 1) {
+            if (!player.hasPermission("scandium.command.echest.other")) {
+                player.sendMessage(NO_PERMISSION);
+                return false;
+            }
+
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                player.openInventory(target.getEnderChest());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/FeedCommand.java

@@ -0,0 +1,47 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "feed", permission = "scandium.command.feed")
+public class FeedCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.setFoodLevel(20);
+
+            player.sendMessage(Color.SECONDARY_COLOR + "Set your food level to " + Color.MAIN_COLOR + "20" + Color.SECONDARY_COLOR +".");
+            player.sendMessage(Color.SECONDARY_COLOR + "You've reset your " + Color.MAIN_COLOR + "food level" + Color.SECONDARY_COLOR + ".");
+
+            PlayerUtil.sendAlert(player, "reset food level");
+        }
+
+        if (args.length > 0) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            } else {
+                target.setFoodLevel(20);
+                player.sendMessage(Color.SECONDARY_COLOR + "You've reset " + target.getDisplayName() + Color.SECONDARY_COLOR + "'s " + Color.MAIN_COLOR + "food level" + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "reset food level for " + target.getName());
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/FindCommand.java

@@ -0,0 +1,57 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.global.NetworkPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.clickable.Clickable;
+import net.md_5.bungee.api.ChatColor;
+import net.md_5.bungee.api.chat.ClickEvent;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Command(label = "find", aliases = "search", permission = "scandium.command.find")
+public class FindCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+
+        if (args.length > 0) {
+            final String target = args[0];
+            final NetworkPlayer networkPlayer = CorePlugin.getInstance().getPlayerManager().getNetworkPlayer(target);
+
+            sender.sendMessage(Color.SECONDARY_COLOR + "Searching for that player...");
+
+            if (networkPlayer == null) {
+                sender.sendMessage(ChatColor.RED + "Error: The player with the specified name does not exist.");
+            } else {
+                final Rank rank = Rank.getByName(networkPlayer.getRankName());
+                final String displayName = Color.translate((rank != null ? rank.getColor() + rank.getItalic() : ChatColor.GRAY) + networkPlayer.getName());
+
+                if (sender instanceof Player && sender.hasPermission("scandium.staff")) {
+                    final Player player = (Player) sender;
+                    final Clickable clickable = new Clickable("");
+
+                    clickable.add(Color.MAIN_COLOR + displayName + Color.SECONDARY_COLOR + " is currently online " + Color.MAIN_COLOR + networkPlayer.getServerName() + Color.SECONDARY_COLOR + "!", Color.SECONDARY_COLOR + "Click to jump to " + ChatColor.GREEN + networkPlayer.getServerName() + Color.SECONDARY_COLOR + "!", "/jump " + networkPlayer.getServerName(), ClickEvent.Action.RUN_COMMAND);
+
+                    player.spigot().sendMessage(clickable.asComponents());
+                } else {
+                    sender.sendMessage(Color.MAIN_COLOR + displayName + Color.SECONDARY_COLOR + " is currently online " + Color.MAIN_COLOR + networkPlayer.getServerName() + Color.SECONDARY_COLOR + "!");
+                }
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/FlyCommand.java

@@ -0,0 +1,76 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "fly", aliases = "flight", permission = "scandium.command.fly")
+public class FlyCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            if (player.isFlying()) {
+                player.setAllowFlight(false);
+                player.setFlying(false);
+
+                player.sendMessage(Color.SECONDARY_COLOR + "You've " + ChatColor.RED + "disabled" + Color.SECONDARY_COLOR + " flight mode.");
+
+                PlayerUtil.sendAlert(player, "disabled flight");
+            } else {
+                player.setAllowFlight(true);
+                player.setFlying(true);
+                player.sendMessage(Color.SECONDARY_COLOR + "You've " + ChatColor.GREEN + "enabled" + Color.SECONDARY_COLOR + " flight mode.");
+
+                PlayerUtil.sendAlert(player, "enabled flight");
+            }
+        }
+
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (!player.hasPermission("scandium.command.fly.others")) {
+                player.sendMessage(this.NO_PERMISSION);
+                return false;
+            }
+
+            if (target != null) {
+                if (target.isFlying()) {
+                    target.setFlying(false);
+                    target.setAllowFlight(false);
+
+                    player.sendMessage(Color.SECONDARY_COLOR + "You've " + ChatColor.RED + "disabled" + Color.SECONDARY_COLOR + " flight mode for " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+
+                    PlayerUtil.sendAlert(player, "disabled flight for " + target.getName());
+                } else {
+                    target.setAllowFlight(true);
+                    target.setFlying(true);
+
+                    player.sendMessage(Color.SECONDARY_COLOR + "You've " + ChatColor.GREEN + "enabled" + Color.SECONDARY_COLOR + " flight mode for " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+
+                    PlayerUtil.sendAlert(player, "enabled flight for " + target.getName());
+                }
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/GiveCommand.java

@@ -0,0 +1,74 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.cryptomorin.xseries.XMaterial;
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "give", permission = "scandium.command.give")
+public class GiveCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length < 2) {
+            player.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player> <amount> <item>"));
+        }
+        if (args.length > 2) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            int amount;
+            try {
+                amount = Integer.parseInt(args[1]);
+            } catch (Exception ignored) {
+                player.sendMessage(ChatColor.RED + ("Error: That amount is not an integer."));
+                return false;
+            }
+
+            final String message = StringUtil.buildMessage(args, 2);
+
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+
+            final String formatted = message.replace(" ", "_").toUpperCase();
+            final XMaterial material = XMaterial.matchXMaterial(formatted).orElse(null);
+
+            if (material == null) {
+                player.sendMessage(ChatColor.RED + ("Error: That material does not exist."));
+                return false;
+            }
+
+            final ItemStack itemStack = material.parseItem();
+
+            if (itemStack != null) {
+                itemStack.setAmount(amount);
+
+                target.getInventory().setItemInHand(itemStack);
+            }
+
+            player.sendMessage(Color.SECONDARY_COLOR + "You've given " + target.getDisplayName() + Color.MAIN_COLOR + " " + amount + Color.MAIN_COLOR + " " + StringUtils.capitalize(material.name().toLowerCase().replace("_", " ")) + Color.SECONDARY_COLOR + "!");
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/GmcCommand.java

@@ -0,0 +1,49 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "gmc", permission = "scandium.command.gmc")
+public class GmcCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.setGameMode(GameMode.CREATIVE);
+            player.sendMessage(Color.SECONDARY_COLOR + "You've set your gamemode to " + Color.MAIN_COLOR + "creative" + Color.SECONDARY_COLOR + ".");
+
+            PlayerUtil.sendAlert(player, "gamemode creative");
+        }
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                target.setGameMode(GameMode.CREATIVE);
+                player.sendMessage(Color.SECONDARY_COLOR + "You've set " + target.getDisplayName() + Color.SECONDARY_COLOR + "'s gamemode to " + Color.MAIN_COLOR + "creative" + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "gamemode creative for " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/GmsCommand.java

@@ -0,0 +1,45 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "gms", permission = "scandium.command.gms")
+public class GmsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        if (args.length == 0) {
+            player.setGameMode(GameMode.SURVIVAL);
+            player.sendMessage(Color.SECONDARY_COLOR + "You've set your gamemode to " + Color.MAIN_COLOR + "survival" + Color.SECONDARY_COLOR + ".");
+
+            PlayerUtil.sendAlert(player, "gamemode survival");
+        }
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                target.setGameMode(GameMode.SURVIVAL);
+                player.sendMessage(Color.SECONDARY_COLOR + "You've set " + target.getDisplayName() + Color.SECONDARY_COLOR + "'s gamemode to " + Color.MAIN_COLOR + "survival" + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "gamemode survival for " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/GmspCommand.java

@@ -0,0 +1,53 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "gmsp", permission = "scandium.command.gmsp")
+public class GmspCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (Bukkit.getServer().getVersion().contains("1.7")) {
+            return false;
+        }
+
+        if (args.length == 0) {
+            player.setGameMode(GameMode.SPECTATOR);
+            player.sendMessage(Color.SECONDARY_COLOR + "You've set your gamemode to " + Color.MAIN_COLOR + "spectator" + Color.SECONDARY_COLOR + ".");
+
+            PlayerUtil.sendAlert(player, "gamemode spectator");
+        }
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                target.setGameMode(GameMode.SPECTATOR);
+                player.sendMessage(Color.SECONDARY_COLOR + "You've set " + target.getDisplayName() + Color.SECONDARY_COLOR + "'s gamemode to " + Color.MAIN_COLOR + "spectator" + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "gamemode spectator for " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/HealCommand.java

@@ -0,0 +1,44 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "heal", permission = "scandium.command.heal")
+public class HealCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.setHealth(20);
+            player.sendMessage(Color.SECONDARY_COLOR + "Set your health level to " + Color.MAIN_COLOR + "20" + Color.SECONDARY_COLOR +".");
+
+            PlayerUtil.sendAlert(player, "healed");
+        }
+        if (args.length > 0) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                target.setHealth(20);
+                player.sendMessage(Color.SECONDARY_COLOR + "Set " + target.getDisplayName() + " health level to " + Color.MAIN_COLOR + "20" + Color.SECONDARY_COLOR +".");
+
+                PlayerUtil.sendAlert(player, "healed " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/HelpOpCommand.java

@@ -0,0 +1,62 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "helpop", aliases = "request", hidden = false)
+public class HelpOpCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <message>");
+        }
+
+        if (args.length > 0) {
+            final String reason = StringUtil.buildMessage(args, 0);
+
+            if (!potPlayer.isCanRequest()) {
+                player.sendMessage(ChatColor.RED + ("You cannot perform this action right now."));
+                return false;
+            }
+
+            RedisUtil.publishAsync(RedisUtil.onHelpOp(player, reason));
+            player.sendMessage(Color.SECONDARY_COLOR + "You've requested help from staff for: " + Color.MAIN_COLOR + reason);
+
+            potPlayer.setCanRequest(false);
+
+            if (CorePlugin.getInstance().getDiscordManager().getClient() != null) {
+                CorePlugin.getInstance().getDiscordManager().sendRequest(player, reason);
+            }
+
+            Bukkit.getScheduler().runTaskLater(CorePlugin.getInstance(), () -> {
+                final PotPlayer newPotPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+                if (newPotPlayer != null) {
+                    potPlayer.setCanRequest(true);
+                }
+            }, 60 * 20L);
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/IgnoreCommand.java

@@ -0,0 +1,93 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.builder.PageListBuilder;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@Command(label = "ignore", aliases = "unignore", hidden = false)
+public class IgnoreCommand extends BaseCommand {
+
+    public void sendHelp(Player player) {
+        this.getHelpMessage(1, player,
+                "/ignore <player>",
+                "/ignore list",
+                "/unignore <player>"
+        );
+    }
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            this.sendHelp(player);
+        }
+
+        if (args.length > 0) {
+            final String value = args[0];
+
+            switch (label.toLowerCase()) {
+                case "unignore":
+                    if (potPlayer.getName().equalsIgnoreCase(value)) {
+                        player.sendMessage(ChatColor.RED + ("You cannot remove yourself from your ignore list!"));
+                        return false;
+                    }
+
+                    if (!potPlayer.getAllIgnoring().contains(value)) {
+                        player.sendMessage(ChatColor.RED + ("That player's not on your ignore list!"));
+                        return false;
+                    }
+
+                    potPlayer.getAllIgnoring().remove(value);
+                    player.sendMessage(Color.SECONDARY_COLOR + "You've removed " + Color.MAIN_COLOR + value + Color.SECONDARY_COLOR + " from your ignored list!");
+
+                    break;
+                case "ignore":
+                    if ("list".equals(value.toLowerCase())) {
+                        if (potPlayer.getAllIgnoring().isEmpty()) {
+                            player.sendMessage(ChatColor.RED + ("Error: You do not have anyone added to your ignore list."));
+                            return false;
+                        }
+
+                        final PageListBuilder listBuilder = new PageListBuilder(50, "Ignored players");
+
+                        listBuilder.display(sender, 1, potPlayer.getAllIgnoring());
+                    } else {
+                        if (potPlayer.getName().equalsIgnoreCase(value)) {
+                            player.sendMessage(ChatColor.RED + ("You cannot add yourself to your ignore list!"));
+                            return false;
+                        }
+
+                        if (potPlayer.getAllIgnoring().contains(value)) {
+                            player.sendMessage(ChatColor.RED + ("That player's already on your ignore list!"));
+                            return false;
+                        }
+
+                        potPlayer.getAllIgnoring().add(value);
+                        player.sendMessage(Color.SECONDARY_COLOR + "You've added " + Color.MAIN_COLOR + value + Color.SECONDARY_COLOR + " to your ignored list.");
+                    }
+                    break;
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/JoinCommand.java

@@ -0,0 +1,50 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.global.NetworkPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.server.NetworkServer;
+import com.solexgames.core.util.BungeeUtil;
+import com.solexgames.core.util.Color;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * @author GrowlyX
+ * @since 6/5/2021
+ */
+
+@Command(label = "join")
+public class JoinCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <server>");
+        }
+        if (args.length == 1) {
+            final NetworkServer networkServer = NetworkServer.getByName(args[0]);
+
+            if (networkServer == null) {
+                player.sendMessage(ChatColor.RED + "Error: There is no online server named " + ChatColor.RED + args[0] + ChatColor.RED + ".");
+                return false;
+            }
+
+            player.sendMessage(Color.SECONDARY_COLOR + "Joining " + Color.MAIN_COLOR + networkServer.getServerName() + Color.SECONDARY_COLOR + "...");
+
+            BungeeUtil.sendToServer(player, networkServer.getServerName(), CorePlugin.getInstance());
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/JumpCommand.java

@@ -0,0 +1,51 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.global.NetworkPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.BungeeUtil;
+import com.solexgames.core.util.Color;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * @author GrowlyX
+ * @since 5/14/2021
+ */
+
+@Command(label = "jump", permission = "scandium.command.jump", aliases = "jtp")
+public class JumpCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+        if (args.length == 1) {
+            final NetworkPlayer networkPlayer = CorePlugin.getInstance().getPlayerManager().getNetworkPlayer(args[0]);
+
+            if (networkPlayer != null) {
+                final String formatted = Color.translate((Rank.getByName(networkPlayer.getRankName()) != null ? Rank.getByName(networkPlayer.getRankName()).getColor() : ChatColor.GRAY) + networkPlayer.getName());
+
+                player.sendMessage(Color.SECONDARY_COLOR + "You're being jumped to " + Color.MAIN_COLOR + formatted + Color.SECONDARY_COLOR + "'s server...");
+
+                BungeeUtil.sendToServer(player, networkPlayer.getServerName(), CorePlugin.getInstance());
+                CorePlugin.getInstance().getPlayerManager().sendToNetworkStaffFormatted(player.getDisplayName() + "&3 has jumped to &e" + formatted + "&3.");
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/KillCommand.java

@@ -0,0 +1,56 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "kill", permission = "scandium.command.kill")
+public class KillCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (CorePlugin.getInstance().getServerName().contains("um")) {
+            player.sendMessage(ChatColor.RED + "Error: This command is disabled on UHC Meetup servers.");
+            return false;
+        }
+
+        if (args.length == 0) {
+            player.setHealth(0);
+            player.sendMessage(Color.SECONDARY_COLOR + ("You've killed yourself."));
+
+            PlayerUtil.sendAlert(player, "killed themself");
+        }
+
+        if (args.length > 0) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                target.setHealth(0);
+                player.sendMessage(Color.SECONDARY_COLOR + "Killed " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "killed " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/ListCommand.java

@@ -0,0 +1,87 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Command(label = "list", aliases = {"who", "online"}, hidden = false)
+public class ListCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        final List<Player> playerList = new ArrayList<>(this.getOnlinePlayers(false, false));
+        final boolean split = Bukkit.getOnlinePlayers().size() > 350;
+
+        if (sender instanceof ConsoleCommandSender) {
+            final String ranks = CorePlugin.getInstance().getRankManager().getRanks().stream()
+                    .sorted(Comparator.comparingInt(rank -> -rank.getWeight()))
+                    .map(rank -> Color.translate((rank.isHidden() ? "&7*" : "") + rank.getColor() + rank.getItalic() + rank.getName()))
+                    .collect(Collectors.joining(ChatColor.WHITE + ", "));
+            final String players = playerList.stream()
+                    .map(player -> CorePlugin.getInstance().getPlayerManager().getPlayer(player.getUniqueId()))
+                    .sorted(Comparator.comparingInt(potPlayer -> -(potPlayer.getDisguiseRank() != null ? potPlayer.getDisguiseRank().getWeight() : potPlayer.getActiveGrant().getRank().getWeight())))
+                    .map(potPlayer -> Color.translate((potPlayer.isStaffMode() ? "&7[S] " : "") + (potPlayer.isVanished() ? "&7[V] " : "") + potPlayer.getActiveGrant().getRank().getColor() + potPlayer.getName()))
+                    .collect(Collectors.joining(ChatColor.WHITE + ", "));
+
+            sender.sendMessage(new String[]{
+                    ranks,
+                    Color.translate("&f(" + playerList.size() + "/" + Bukkit.getMaxPlayers() + ") ") + players
+            });
+
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final String ranks = CorePlugin.getInstance().getRankManager().getRanks().stream()
+                .filter(rank -> !rank.isHidden())
+                .sorted(Comparator.comparingInt(rank -> -rank.getWeight()))
+                .map(rank -> Color.translate(rank.getColor() + rank.getItalic() + rank.getName().replace("-", " ")))
+                .collect(Collectors.joining(ChatColor.WHITE + ", "));
+        final String players = this.getOnlinePlayers(!player.hasPermission("scandium.staff"), split).stream()
+                .map(player1 -> CorePlugin.getInstance().getPlayerManager().getPlayer(player1.getUniqueId()))
+                .sorted(Comparator.comparingInt(potPlayer -> -(potPlayer.getDisguiseRank() != null ? potPlayer.getDisguiseRank().getWeight() : potPlayer.getActiveGrant().getRank().getWeight())))
+                .map(potPlayer -> this.getFormattedName(potPlayer, player))
+                .collect(Collectors.joining(ChatColor.WHITE + ", "));
+
+        sender.sendMessage(new String[]{
+                ranks,
+                Color.translate("&f(" + this.getOnlinePlayers(true, split).size() + "/" + Bukkit.getMaxPlayers() + "): ") + players
+        });
+
+        if (split) {
+            sender.sendMessage(ChatColor.RED + "(Only displaying the first " + ChatColor.BOLD + "350 players" + ChatColor.RED + ")");
+        }
+
+        return false;
+    }
+
+    private String getFormattedName(PotPlayer potPlayer, Player viewer) {
+        return Color.translate((viewer.hasPermission("scandium.staff") ? (potPlayer.isStaffMode() ? "&7[S] " : "") + (potPlayer.isVanished() ? "&7[V] " : "") : "") + (potPlayer.getDisguiseRank() != null ? potPlayer.getDisguiseRank().getColor() : potPlayer.getActiveGrant().getRank().getColor()) + potPlayer.getName());
+    }
+
+    private Collection<Player> getOnlinePlayers(boolean filter, boolean split) {
+        final List<Player> playerList = new ArrayList<>(Bukkit.getOnlinePlayers());
+
+        if (!filter) {
+            return split ? playerList.subList(0, 350) : playerList;
+        } else {
+            final List<Player> finalList = playerList.stream()
+                    .filter(player -> !CorePlugin.getInstance().getPlayerManager().getPlayer(player).isVanished())
+                    .filter(player -> !CorePlugin.getInstance().getPlayerManager().getPlayer(player).isStaffMode())
+                    .collect(Collectors.toList());
+
+            return split ? finalList.subList(0, 350) : finalList;
+        }
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/MaxItemCommand.java

@@ -0,0 +1,43 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.cryptomorin.xseries.XMaterial;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "maxitem", permission = "scandium.command.maxitem", aliases = "more")
+public class MaxItemCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (!player.hasPermission("scandium.command.maxitem")) {
+            player.sendMessage(NO_PERMISSION);
+            return false;
+        }
+
+        final ItemStack itemStack = player.getItemInHand();
+
+        if (itemStack != null && !itemStack.getType().equals(XMaterial.AIR.parseMaterial())) {
+            itemStack.setAmount(itemStack.getMaxStackSize());
+            player.updateInventory();
+        } else {
+            player.sendMessage(ChatColor.RED + "Error: You aren't holding an item in your hand right now.");
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/MediaCommand.java

@@ -0,0 +1,43 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.menu.impl.media.MediaViewMenu;
+import com.solexgames.core.menu.impl.media.MediaManagerMenu;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "media", hidden = false)
+public class MediaCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            new MediaManagerMenu(player).open(player);
+        }
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                new MediaViewMenu(target).open(player);
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/MessageCommand.java

@@ -0,0 +1,94 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "message", aliases = {"m", "msg", "w", "dm"}, hidden = false)
+public class MessageCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length < 1) {
+            player.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player> <message>"));
+        }
+        if (args.length > 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+            final String message = StringUtil.buildMessage(args, 1);
+
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+
+            final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+            final PotPlayer potTarget = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+            if (potTarget == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+            if (potTarget == potPlayer) {
+                player.sendMessage(ChatColor.RED + ("Error: You cannot message yourself."));
+                return false;
+            }
+            if (potTarget.isVanished() || potTarget.isDisguised() && (potPlayer.getActiveGrant().getRank().getWeight() < potTarget.getActiveGrant().getRank().getWeight())) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+            if (!potTarget.isIgnoring(potPlayer.getPlayer())) {
+                player.sendMessage(ChatColor.RED + ("Error: That player is currently ignoring you."));
+                return false;
+            }
+            if (!potPlayer.isIgnoring(potTarget.getPlayer())) {
+                player.sendMessage(ChatColor.RED + ("You are currently ignoring that player."));
+                return false;
+            }
+            if (!potPlayer.isCanReceiveDms()) {
+                player.sendMessage(ChatColor.RED + ("You've your dms disabled."));
+                return false;
+            }
+            if (potTarget.isCurrentlyRestricted()) {
+                player.sendMessage(ChatColor.RED + ("You cannot message this player right now."));
+                return false;
+            }
+            if (potTarget.isCurrentlyMuted()) {
+                player.sendMessage(ChatColor.RED + ("You cannot message this player right now."));
+                return false;
+            }
+            if (!potTarget.isCanReceiveDms()) {
+                player.sendMessage(ChatColor.RED + ("Error: That player has their dms disabled."));
+                return false;
+            }
+            if (!player.hasPermission("scandium.filter.bypass") && CorePlugin.getInstance().getFilterManager().isDmFiltered(player, potTarget.getName(), message)) {
+                player.sendMessage(ChatColor.RED + ("You cannot use censored words in a direct message."));
+                return false;
+            }
+
+            StringUtil.sendPrivateMessage(player, target, message);
+
+            potPlayer.setLastRecipient(target.getName());
+            potTarget.setLastRecipient(player.getName());
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/OptionsCommand.java

@@ -0,0 +1,27 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.menu.impl.SettingsMenu;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "options", aliases = {"settings"}, hidden = false)
+public class OptionsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        new SettingsMenu(player).openMenu(player);
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/PermissionsCommand.java

@@ -0,0 +1,42 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Command(label = "permissions", permission = "scandium.command.permissions", aliases = {"perms"})
+public class PermissionsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        final List<String> permissions = player.getEffectivePermissions().stream()
+                .map(PermissionAttachmentInfo::getPermission)
+                .collect(Collectors.toList());
+        final int permissionsCount = permissions.size();
+
+        player.sendMessage(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + StringUtils.repeat("-", 53));
+        StringUtil.sendCenteredMessage(player, Color.SECONDARY_COLOR + "You currently have " + Color.MAIN_COLOR + "" + permissionsCount + Color.SECONDARY_COLOR + " permissions!");
+        player.sendMessage("  ");
+        permissions.forEach(s -> player.sendMessage(ChatColor.GRAY + " * " + Color.MAIN_COLOR + s));
+        player.sendMessage(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + StringUtils.repeat("-", 53));
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/PingCommand.java

@@ -0,0 +1,43 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "ping", aliases = "latency", hidden = false)
+public class PingCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Your ping is currently: " + Color.MAIN_COLOR + PlayerUtil.getPing(player) + "ms" + Color.SECONDARY_COLOR + "!");
+        }
+
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                player.sendMessage(target.getDisplayName() + Color.SECONDARY_COLOR + "'s ping is currently: " + Color.MAIN_COLOR + PlayerUtil.getPing(target) + "ms" + Color.SECONDARY_COLOR + "!");
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/ProfileCommand.java

@@ -0,0 +1,45 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.menu.impl.player.PlayerInfoMenu;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * @author GrowlyX
+ * @since 5/20/2021
+ */
+
+@Command(label = "profile", hidden = false)
+public class ProfileCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            new PlayerInfoMenu(player).open(player);
+        }
+
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                new PlayerInfoMenu(target).open(player);
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/ReplyCommand.java

@@ -0,0 +1,100 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "reply", aliases = "r", hidden = false)
+public class ReplyCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (potPlayer.getLastRecipient() == null) {
+            player.sendMessage(ChatColor.RED + ("You aren't in a conversation with anyone."));
+            return false;
+        }
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "You're currently messaging " + Color.MAIN_COLOR + potPlayer.getLastRecipient() + Color.SECONDARY_COLOR + ".");
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            final PotPlayer potTarget = CorePlugin.getInstance().getPlayerManager().getPlayer(potPlayer.getLastRecipient());
+
+            if (potTarget == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+
+            if (Bukkit.getPlayer(potPlayer.getLastRecipient()) == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+
+            if (potTarget.isVanished() || potTarget.isDisguised() && (potPlayer.getActiveGrant().getRank().getWeight() < potTarget.getActiveGrant().getRank().getWeight())) {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+                return false;
+            }
+
+            if (!potTarget.isIgnoring(potPlayer.getPlayer())) {
+                player.sendMessage(ChatColor.RED + ("Error: That player is currently ignoring you."));
+                return false;
+            }
+
+            if (!potPlayer.isIgnoring(potTarget.getPlayer())) {
+                player.sendMessage(ChatColor.RED + ("Error: You are currently ignoring that player."));
+                return false;
+            }
+
+            if (!potPlayer.isCanReceiveDms()) {
+                player.sendMessage(ChatColor.RED + ("Error: You've your dms disabled."));
+                return false;
+            }
+
+            if (potTarget.isCurrentlyRestricted()) {
+                player.sendMessage(ChatColor.RED + ("Error: You cannot message this player right now."));
+                return false;
+            }
+
+            if (potTarget.isCurrentlyMuted()) {
+                player.sendMessage(ChatColor.RED + ("Error: You cannot message this player right now."));
+                return false;
+            }
+
+            if (!potTarget.isCanReceiveDms()) {
+                player.sendMessage(ChatColor.RED + ("Error: That player has their dms disabled."));
+                return false;
+            }
+
+            if (!player.hasPermission("scandium.filter.bypass") && CorePlugin.getInstance().getFilterManager().isDmFiltered(player, potTarget.getName(), message)) {
+                player.sendMessage(ChatColor.RED + ("You cannot use censored words in a direct message."));
+                return false;
+            }
+
+            StringUtil.sendPrivateMessage(player, potTarget.getPlayer(), message);
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/ReportCommand.java

@@ -0,0 +1,50 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.menu.impl.ReportMenu;
+import com.solexgames.core.util.Color;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "report", hidden = false)
+public class ReportCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            player.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>"));
+        }
+
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                if (target == player) {
+                    player.sendMessage(ChatColor.RED + "You cannot report yourself.");
+                    return true;
+                }
+
+                new ReportMenu(player, target).open(player);
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/StoreCommand.java

@@ -0,0 +1,21 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import org.bukkit.command.CommandSender;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "store", hidden = false)
+public class StoreCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        sender.sendMessage(Color.SECONDARY_COLOR + "Store: " + Color.MAIN_COLOR + CorePlugin.getInstance().getServerManager().getNetwork().getStoreLink());
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/SudoAllCommand.java

@@ -0,0 +1,41 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+@Command(label = "sudoall", permission = "scandium.command.sudoall")
+public class SudoAllCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " [c:] [e:] <message>"));
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+
+            if (message.contains("/sudoall") || message.contains("/scandium:sudoall") || message.contains("e:sudoall") || message.contains("e:scandium:sudoall")) {
+                sender.sendMessage(ChatColor.RED + "Error: That message contains a blacklisted phrase.");
+                return false;
+            }
+
+            if (message.startsWith("c:")) {
+                Bukkit.getOnlinePlayers().forEach(player1 -> player1.chat(message.replace("c:", "")));
+                sender.sendMessage(Color.SECONDARY_COLOR + "Made all online players chat '" + Color.MAIN_COLOR + message.replace("c:", "") + Color.SECONDARY_COLOR + "'.");
+            } else if (message.startsWith("e:")) {
+                Bukkit.getOnlinePlayers().forEach(player1 -> player1.performCommand(message.replace("e:", "")));
+                sender.sendMessage(Color.SECONDARY_COLOR + "Made all online players execute '" + Color.MAIN_COLOR + message.replace("e:", "") + Color.SECONDARY_COLOR + "'.");
+            } else {
+                Bukkit.getOnlinePlayers().forEach(player1 -> player1.chat(message));
+                sender.sendMessage(Color.SECONDARY_COLOR + "Made all online players chat '" + Color.MAIN_COLOR + message + Color.SECONDARY_COLOR + "'.");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/SudoCommand.java

@@ -0,0 +1,54 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "sudo", permission = "scandium.command.sudo")
+public class SudoCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!sender.hasPermission("scandium.command.sudo")) {
+            sender.sendMessage(NO_PERMISSION);
+            return false;
+        }
+
+        if (args.length <= 1) {
+            sender.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " [c:] [e:] <message>"));
+        }
+
+        if (args.length > 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+            final String message = StringUtil.buildMessage(args, 1);
+
+            if (target != null) {
+                if (message.startsWith("c:")) {
+                    target.chat(message.replace("c:", ""));
+                    sender.sendMessage(Color.SECONDARY_COLOR + "Made " + target.getDisplayName() + Color.SECONDARY_COLOR + " chat '" + Color.MAIN_COLOR + message.replace("c:", "") + Color.SECONDARY_COLOR + "'.");
+                } else if (message.startsWith("e:")) {
+                    target.performCommand(message.replace("e:", ""));
+                    sender.sendMessage(Color.SECONDARY_COLOR + "Made " + target.getDisplayName() + Color.SECONDARY_COLOR + " execute '" + Color.MAIN_COLOR + message.replace("e:", "") + Color.SECONDARY_COLOR + "'.");
+                } else {
+                    target.chat(message);
+                    sender.sendMessage(Color.SECONDARY_COLOR + "Made " + target.getDisplayName() + Color.SECONDARY_COLOR + " chat '" + Color.MAIN_COLOR + message + Color.SECONDARY_COLOR + "'.");
+                }
+
+                if (sender instanceof Player) {
+                    final Player player = (Player) sender;
+
+                    PlayerUtil.sendAlert(player, "sudoed " + target.getName());
+                }
+            } else {
+                sender.sendMessage(ChatColor.RED + "That player does not exist");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/TpAllCommand.java

@@ -0,0 +1,46 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "tpall", permission = "scandium.command.tpall")
+public class TpAllCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        Bukkit.getOnlinePlayers().forEach(player1 -> {
+            PaperLib.teleportAsync(player1, player.getLocation())
+                    .whenComplete((aBoolean, throwable) -> {
+                       if (aBoolean) {
+                           player1.sendMessage(ChatColor.GREEN + "You've been teleported to " + player.getDisplayName() + ChatColor.GREEN + ".");
+                       } else {
+                           player1.sendMessage(ChatColor.RED + "Sorry, we couldn't teleport you to " + player.getDisplayName() + ChatColor.RED + ".");
+                       }
+                    });
+        });
+
+        player.sendMessage(Color.SECONDARY_COLOR + "You've teleported all online players to you.");
+
+        PlayerUtil.sendAlert(player, "teleported all players");
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/TpCommand.java

@@ -0,0 +1,46 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "tp", aliases = "teleport", permission = "scandium.command.tp")
+public class TpCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>"));
+        }
+
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                player.teleport(target.getLocation());
+
+                player.sendMessage(Color.SECONDARY_COLOR + "You've been teleported to " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "teleported to " + target.getName());
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/TpHereCommand.java

@@ -0,0 +1,53 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "tphere", permission = "scandium.command.tphere", aliases = "s")
+public class TpHereCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (!sender.hasPermission("scandium.command.tphere")) {
+            sender.sendMessage(NO_PERMISSION);
+            return false;
+        }
+
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                target.teleport(player.getLocation());
+
+                player.sendMessage(Color.SECONDARY_COLOR + "Teleported " + target.getDisplayName() + Color.SECONDARY_COLOR + " to your location.");
+                target.sendMessage(Color.SECONDARY_COLOR + "You've been teleported to " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "teleported " + target.getName() + " to themselves");
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/TpPosCommand.java

@@ -0,0 +1,51 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "tppos", permission = "scandium.command.tppos")
+public class TpPosCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (!player.hasPermission("scandium.command.tppos")) {
+            player.sendMessage(NO_PERMISSION);
+            return false;
+        }
+
+        if (args.length <= 2) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <x> <y> <z>");
+        }
+        if (args.length == 3) {
+            try {
+                final int x1 = Integer.parseInt(args[0]);
+                final int y1 = Integer.parseInt(args[1]);
+                final int z1 = Integer.parseInt(args[2]);
+
+                player.teleport(new Location(player.getWorld(), x1, y1, z1, 0.0F, 0.0F));
+                player.sendMessage(Color.SECONDARY_COLOR + "Teleported you to " + Color.MAIN_COLOR + x1 + Color.SECONDARY_COLOR + ", " + Color.MAIN_COLOR + y1 + Color.SECONDARY_COLOR + ", " + Color.MAIN_COLOR + z1 + Color.SECONDARY_COLOR + ".");
+
+                PlayerUtil.sendAlert(player, "teleported to " + x1 + ", " + y1 + ", " + z1);
+            } catch (Exception e) {
+                player.sendMessage(ChatColor.RED + ("One of those values was not an integer."));
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/TwitterCommand.java

@@ -0,0 +1,22 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import org.bukkit.command.CommandSender;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "twitter", hidden = false)
+public class TwitterCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        sender.sendMessage(Color.SECONDARY_COLOR + "Twitter: " + Color.MAIN_COLOR + CorePlugin.getInstance().getServerManager().getNetwork().getTwitterLink());
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/UserCommand.java

@@ -0,0 +1,194 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "user", permission = "scandium.command.user")
+public class UserCommand extends BaseCommand {
+
+    public final ServerType NETWORK = CorePlugin.getInstance().getServerManager().getNetwork();
+
+    public void sendHelp(CommandSender player) {
+        this.getHelpMessage(0, player,
+                "/user permission add <player>",
+                "/user permission remove <player>",
+                "/user permission list <player>",
+                "/user disguise <player> <rank>"
+        );
+    }
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        /*
+         * Prepare for spaghetti code!
+         */
+
+        if (args.length == 0) {
+            sendHelp(sender);
+        }
+        if (args.length > 0) {
+            switch (args[0]) {
+                case "permission":
+                    if (args.length == 1) {
+                        this.sendHelp(sender);
+                    }
+                    if (args.length > 1) {
+                        switch (args[1]) {
+                            case "add":
+                                if (args.length < 4) {
+                                    this.sendHelp(sender);
+                                }
+                                if (args.length == 4) {
+                                    final String permission = args[3];
+                                    final Player target = Bukkit.getPlayer(args[2]);
+
+                                    if (target != null) {
+                                        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                                        if (potPlayer.getUserPermissions().contains(permission.toLowerCase())) {
+                                            sender.sendMessage(Color.translate("&cThat player already has that permission."));
+                                        } else {
+                                            potPlayer.getUserPermissions().add(permission.toLowerCase());
+                                            potPlayer.resetPermissions();
+                                            potPlayer.setupPermissions();
+
+                                            sender.sendMessage(ChatColor.GREEN + Color.translate("Added the permission '" + permission + "' to " + target.getDisplayName() + ChatColor.GREEN + "!"));
+                                        }
+                                    } else {
+                                        sender.sendMessage(ChatColor.RED + "That player does not exist");
+                                    }
+                                }
+                                break;
+                            case "remove":
+                                if (args.length < 4) {
+                                    this.sendHelp(sender);
+                                }
+                                if (args.length == 4) {
+                                    final String permission = args[3];
+                                    final Player target = Bukkit.getPlayer(args[2]);
+
+                                    if (target != null) {
+                                        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                                        if (!potPlayer.getUserPermissions().contains(permission.toLowerCase())) {
+                                            sender.sendMessage(Color.translate("&cThat player does not have that permission."));
+                                        } else {
+                                            potPlayer.getUserPermissions().remove(permission.toLowerCase());
+                                            potPlayer.resetPermissions();
+                                            potPlayer.setupPermissions();
+                                            sender.sendMessage(ChatColor.GREEN + Color.translate("Removed the permission '" + permission + "' from " + target.getDisplayName() + ChatColor.GREEN + "!"));
+                                        }
+                                    } else {
+                                        sender.sendMessage(ChatColor.RED + "That player does not exist");
+                                    }
+                                }
+                                break;
+                            case "list":
+                                if (args.length == 2) {
+                                    this.sendHelp(sender);
+                                }
+                                if (args.length == 3) {
+                                    final Player target = Bukkit.getPlayer(args[2]);
+
+                                    if (target != null) {
+                                        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                                        if (potPlayer.getUserPermissions().isEmpty()) {
+                                            sender.sendMessage(Color.translate("&cThat player does not have any permissions."));
+                                        } else {
+                                            sender.sendMessage(Color.translate("&7&m" + StringUtils.repeat("-", 53)));
+                                            sender.sendMessage(Color.translate(NETWORK.getMainColor() + ChatColor.BOLD.toString() + "User Permissions:"));
+                                            potPlayer.getUserPermissions().forEach(string -> sender.sendMessage(Color.translate(" &7* &a" + string)));
+                                            sender.sendMessage(Color.translate("&7&m" + StringUtils.repeat("-", 53)));
+                                        }
+                                    } else {
+                                        sender.sendMessage(ChatColor.RED + "That player does not exist");
+                                    }
+                                }
+                                break;
+                        }
+                    }
+                    break;
+                case "disguise":
+                    if (args.length < 3) {
+                        this.sendHelp(sender);
+                    }
+                    if (args.length == 3) {
+                        final Player target = Bukkit.getPlayer(args[1]);
+                        final Rank rank = Rank.getByName(args[2]);
+
+                        if (target != null) {
+                            final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                            if (rank != null) {
+                                potPlayer.setDisguiseRank(rank);
+
+                                sender.sendMessage(ChatColor.GREEN + "You've disguised " + potPlayer.getColorByRankColorWithItalic() + potPlayer.getName() + ChatColor.GREEN + " as " + Color.translate(rank.getColor() + rank.getItalic()) + rank.getName() + ChatColor.GREEN + "!");
+                                potPlayer.setupPlayerList();
+
+                                CorePlugin.getInstance().getNMS().updateTablist();
+                            } else {
+                                if (args[2].equalsIgnoreCase("reset")) {
+                                    potPlayer.setDisguiseRank(null);
+
+                                    sender.sendMessage(ChatColor.GREEN + "You've undisguised " + potPlayer.getColorByRankColorWithItalic() + potPlayer.getPlayer().getName());
+                                    potPlayer.setupPlayerList();
+
+                                    CorePlugin.getInstance().getNMS().updateTablist();
+                                } else {
+                                    sender.sendMessage(Color.translate("&cThat rank does not exist."));
+                                }
+                            }
+                        } else {
+                            if (args[1].equals("@all")) {
+                                if (rank != null) {
+                                    Bukkit.getOnlinePlayers().forEach(player -> {
+                                        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+                                        potPlayer.setDisguiseRank(rank);
+                                        potPlayer.setupPlayerList();
+                                    });
+
+                                    sender.sendMessage(ChatColor.RED + "You've disguised all players online as " + Color.translate(rank.getColor() + rank.getItalic()) + rank.getName() + ChatColor.RED + ".");
+
+                                } else {
+                                    Bukkit.getOnlinePlayers().forEach(player -> {
+                                        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+                                        potPlayer.setDisguiseRank(null);
+                                        potPlayer.setupPlayerList();
+                                    });
+
+                                    sender.sendMessage(ChatColor.RED + "You've reset all players' rank disguises.");
+
+                                }
+
+                                CorePlugin.getInstance().getNMS().updateTablist();
+                            }
+
+                            sender.sendMessage(ChatColor.RED + "That player does not exist");
+                        }
+                    }
+                    break;
+                default:
+                    this.sendHelp(sender);
+                    break;
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/WebsiteCommand.java

@@ -0,0 +1,21 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import org.bukkit.command.CommandSender;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "website", hidden = false)
+public class WebsiteCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        sender.sendMessage(Color.SECONDARY_COLOR + "Website: " + Color.MAIN_COLOR + CorePlugin.getInstance().getServerManager().getNetwork().getWebsiteLink());
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/essential/WhatServerAmIOnCommand.java

@@ -0,0 +1,40 @@
+package com.solexgames.core.command.impl.essential;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.global.NetworkPlayer;
+import com.solexgames.core.util.Color;
+import org.apache.commons.lang3.time.DurationFormatUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * @author GrowlyX
+ * @since 5/30/2021
+ */
+
+@Command(label = "whatserveramion", aliases = {"whatamion", "myserver"}, permission = "scandium.staff")
+public class WhatServerAmIOnCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final NetworkPlayer networkPlayer = CorePlugin.getInstance().getPlayerManager().getNetworkPlayer(player);
+
+        if (networkPlayer == null) {
+            player.sendMessage(ChatColor.GRAY + "[SG] " + ChatColor.RED + "Something went terribly wrong while trying to execute this command.");
+            return false;
+        }
+
+        player.sendMessage(Color.SECONDARY_COLOR + "You've been connected to " + Color.MAIN_COLOR + CorePlugin.getInstance().getServerName() + Color.SECONDARY_COLOR + " for " + Color.MAIN_COLOR + DurationFormatUtils.formatDurationWords(System.currentTimeMillis() - networkPlayer.getConnectionTime(), true, true) + Color.SECONDARY_COLOR + ".");
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/experience/ExperienceCommand.java

@@ -0,0 +1,141 @@
+package com.solexgames.core.command.impl.experience;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.menu.impl.experience.ExperienceMainMenu;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.ExperienceUtil;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "experience", aliases = "xp", hidden = false)
+public class ExperienceCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            if (sender instanceof Player) {
+                Player player = (Player) sender;
+
+                new ExperienceMainMenu(player).open(player);
+            } else {
+                this.sendHelpMessage(sender);
+            }
+        }
+
+        // We're checking for permissions during each arg since there may be an argument
+        // that allows players without any permissions to execute them.
+        if (args.length > 0) {
+            switch (args[0].toLowerCase()) {
+                case "add":
+                    if (!sender.hasPermission("scandium.experience.management")) {
+                        sender.sendMessage(NO_PERMISSION);
+                        return false;
+                    }
+                    if (args.length < 3) {
+                        this.sendHelpMessage(sender);
+                    }
+                    if (args.length == 3) {
+                        final Player target = Bukkit.getPlayer(args[1]);
+                        int amount;
+
+                        if (target != null) {
+                            try {
+                                amount = Integer.parseInt(args[2]);
+                            } catch (NumberFormatException exception) {
+                                sender.sendMessage(ChatColor.RED + "Error: That is not a valid integer!");
+                                return false;
+                            }
+
+                            ExperienceUtil.addExperience(target, amount);
+
+                            sender.sendMessage(ChatColor.GREEN + "Added " + ChatColor.WHITE + amount + ChatColor.GREEN + " experience to " + ChatColor.WHITE + target.getDisplayName() + ChatColor.GREEN + "!");
+                        } else {
+                            sender.sendMessage(ChatColor.RED + "Error: That player does not exist!");
+                        }
+                    }
+                    break;
+                case "remove":
+                    if (!sender.hasPermission("scandium.experience.management")) {
+                        sender.sendMessage(NO_PERMISSION);
+                        return false;
+                    }
+
+                    if (args.length < 3) {
+                        this.sendHelpMessage(sender);
+                    }
+                    if (args.length == 3) {
+                        final Player target = Bukkit.getPlayer(args[1]);
+                        int amount;
+
+                        if (target != null) {
+                            try {
+                                amount = Integer.parseInt(args[2]);
+                            } catch (NumberFormatException exception) {
+                                sender.sendMessage(ChatColor.RED + "Error: That is not a valid integer!");
+                                return false;
+                            }
+
+                            ExperienceUtil.removeExperience(target, amount);
+
+                            sender.sendMessage(ChatColor.GREEN + "Removed " + ChatColor.WHITE + amount + ChatColor.GREEN + " experience from " + ChatColor.WHITE + target.getDisplayName() + ChatColor.GREEN + "!");
+                        } else {
+                            sender.sendMessage(ChatColor.RED + "Error: That player does not exist!");
+                        }
+                    }
+                    break;
+                case "set":
+                    if (!sender.hasPermission("scandium.experience.management")) {
+                        sender.sendMessage(NO_PERMISSION);
+                        return false;
+                    }
+
+                    if (args.length < 3) {
+                        this.sendHelpMessage(sender);
+                    }
+                    if (args.length == 3) {
+                        final Player target = Bukkit.getPlayer(args[1]);
+                        int amount;
+
+                        if (target != null) {
+                            try {
+                                amount = Integer.parseInt(args[2]);
+                            } catch (NumberFormatException exception) {
+                                sender.sendMessage(ChatColor.RED + "Error: That is not a valid integer!");
+                                return false;
+                            }
+
+                            ExperienceUtil.setExperience(target, amount);
+
+                            sender.sendMessage(ChatColor.GREEN + "Set " + ChatColor.WHITE + amount + ChatColor.GREEN + " experience to " + ChatColor.WHITE + target.getDisplayName() + ChatColor.GREEN + "!");
+                        } else {
+                            sender.sendMessage(ChatColor.RED + "Error: That player does not exist!");
+                        }
+                    }
+                    break;
+                case "help":
+                default:
+                    this.sendHelpMessage(sender);
+                    break;
+            }
+        }
+        return false;
+    }
+
+    public void sendHelpMessage(CommandSender sender) {
+        this.getHelpMessage(1, sender,
+                "/experience",
+                "/experience help",
+                "/experience amount <player>",
+                "/experience set <player> <amount>",
+                "/experience add <player> <amount>",
+                "/experience remove <player> <amount>"
+        );
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/grant/GrantCommand.java

@@ -0,0 +1,51 @@
+package com.solexgames.core.command.impl.grant;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.external.impl.grant.GrantMainPaginatedMenu;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+
+@Command(label = "grant", permission = "scandium.command.grant")
+public class GrantCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+        if (args.length > 0) {
+            final UUID uuid = CorePlugin.getInstance().getUuidCache().getUuidFromUsername(args[0]);
+
+            if (uuid == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player is not valid.");
+                return false;
+            }
+
+            CorePlugin.getInstance().getPlayerManager().findOrMake(args[0], uuid)
+                    .thenAccept(document -> {
+                        if (document != null) {
+                            new GrantMainPaginatedMenu(document, player).openMenu(player);
+                        } else {
+                            player.sendMessage(ChatColor.RED + "That player does not exist in our database or something went wrong while trying to create their profile.");
+                        }
+                    });
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/grant/GrantManualCommand.java

@@ -0,0 +1,75 @@
+package com.solexgames.core.command.impl.grant;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.grant.Grant;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.DateUtil;
+import com.solexgames.core.util.StringUtil;
+import lombok.SneakyThrows;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+@Command(label = "grantmanual", permission = "scandium.command.grantmanual")
+public class GrantManualCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length <= 2) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player> <rank> <duration> <reason>");
+        }
+        if (args.length > 2) {
+            final UUID uuid = CorePlugin.getInstance().getUuidCache().getUuidFromUsername(args[0]);
+
+            if (uuid == null) {
+                sender.sendMessage(ChatColor.RED + "Error: That uuid is not valid.");
+                return false;
+            }
+
+            CorePlugin.getInstance().getPlayerManager().findOrMake(args[0], uuid)
+                    .thenAcceptAsync(document -> {
+                        if (document == null) {
+                            sender.sendMessage(ChatColor.RED + "Error: That player does not exist in our database.");
+                            return;
+                        }
+
+                        final Rank rank = Rank.getByName(args[1]);
+
+                        if (rank == null) {
+                            sender.sendMessage(ChatColor.RED + "Error: That rank does not exist.");
+                            return;
+                        }
+
+                        final String reason = StringUtil.buildMessage(args, 3);
+                        final Grant newGrant = new Grant(null, rank, System.currentTimeMillis(), -1L, reason, true, true, "global");
+
+                        switch (args[2].toLowerCase()) {
+                            case "perm": case "permanent": case "forever":
+                                newGrant.setPermanent(true);
+                                break;
+                            default:
+                                final long date = DateUtil.parseDateDiff(args[2], false);
+
+                                if (date == -1L) {
+                                    newGrant.setPermanent(true);
+                                    break;
+                                }
+
+                                final long duration = System.currentTimeMillis() - date;
+
+                                newGrant.setDuration(duration);
+                                break;
+                        }
+
+                        CorePlugin.getInstance().getPlayerManager().handleGrant(newGrant, document, sender instanceof Player ? (Player) sender : null, CorePlugin.getInstance().getServerName(), false);
+                    });
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/grant/GrantsCommand.java

@@ -0,0 +1,54 @@
+package com.solexgames.core.command.impl.grant;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.external.impl.grant.GrantMainPaginatedMenu;
+import com.solexgames.core.util.external.impl.grant.GrantViewPaginatedMenu;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+
+@Command(label = "grants", permission = "scandium.command.grants")
+public class GrantsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+
+        if (args.length == 1) {
+            final UUID uuid = CorePlugin.getInstance().getUuidCache().getUuidFromUsername(args[0]);
+
+            if (uuid == null) {
+                player.sendMessage(ChatColor.RED + "Error: That player is not valid.");
+                return false;
+            }
+
+            CorePlugin.getInstance().getPlayerManager().findOrMake(args[0], uuid)
+                    .thenAccept(document -> {
+                        if (document != null) {
+                            new GrantViewPaginatedMenu(document).openMenu(player);
+                        } else {
+                            player.sendMessage(ChatColor.RED + "That player does not exist in our database or something went wrong while trying to create their profile.");
+                        }
+                    });
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/AdminChatCommand.java

@@ -0,0 +1,48 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "adminchat", permission = "scandium.channels.admin", aliases = {"ac"})
+public class AdminChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            if (potPlayer.getChannel() == null || !potPlayer.getChannel().equals(ChatChannelType.ADMIN)) {
+                potPlayer.setChannel(ChatChannelType.ADMIN);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You're now chatting in the " + ChatColor.RED + "Admin" + ChatColor.GREEN + " channel.");
+            } else {
+                potPlayer.setChannel(null);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You're no longer chatting in the " + ChatColor.RED + "Admin" + ChatColor.RED + " channel.");
+            }
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            RedisUtil.publishAsync(RedisUtil.onChatChannel(ChatChannelType.ADMIN, message, player));
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/AltsCommand.java

@@ -0,0 +1,110 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.mongodb.Block;
+import com.mongodb.client.model.Filters;
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.bson.Document;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+@Command(label = "alts", permission = "scandium.command.alts")
+public class AltsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+        if (args.length == 1) {
+            final String target = args[0];
+            final PotPlayer targetPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+            if (targetPlayer != null) {
+                final String playerFormattedDisplay = Color.translate(targetPlayer.getActiveGrant().getRank().getColor() + targetPlayer.getName());
+
+                CompletableFuture.supplyAsync(() -> {
+                    final List<Document> documentList = new ArrayList<>();
+
+                    CorePlugin.getInstance().getCoreDatabase().getPlayerCollection()
+                            .find(Filters.eq("previousIpAddress", targetPlayer.getEncryptedIpAddress()))
+                            .forEach((Block<? super Document>) documentList::add);
+
+                    return documentList;
+                }).thenAcceptAsync(potentialAlts -> {
+                    final String altsMessage = potentialAlts.stream()
+                            .map(this::getFancyName)
+                            .collect(Collectors.joining(ChatColor.WHITE + ", "));
+                    final int altsAmount = potentialAlts.size();
+
+                    if (altsAmount > 100) {
+                        sender.sendMessage(ChatColor.RED + "This player has more than 100 alts, if we show all of them to you, you'll be disconnected.");
+                        return;
+                    }
+
+                    sender.sendMessage(new String[]{
+                            "",
+                            StringUtil.getCentered(playerFormattedDisplay + Color.SECONDARY_COLOR + "'s Alt Accounts " + ChatColor.GRAY + "(x" + altsAmount + "):"),
+                            "",
+                            StringUtil.getCentered(altsMessage),
+                            "",
+                            StringUtil.getCentered(ChatColor.GRAY + "[" + ChatColor.GREEN + "Online" + ChatColor.GRAY + "]" + ChatColor.GRAY + " [" + ChatColor.RED + "Offline" + ChatColor.GRAY + "]" + ChatColor.GRAY + " [" + ChatColor.GOLD + "Banned" + ChatColor.GRAY + "]" + ChatColor.GRAY + " [" + ChatColor.DARK_RED + "Blacklisted" + ChatColor.GRAY + "]"),
+                            "",
+                    });
+                });
+            } else {
+                sender.sendMessage(ChatColor.RED + "Error: That player is not online the network right now.");
+            }
+        }
+
+        return false;
+    }
+
+    private String getFancyName(Document document) {
+        StringBuilder stringBuilder = new StringBuilder();
+
+        if (document == null) {
+            return stringBuilder.toString();
+        }
+
+        if (Bukkit.getPlayer(document.getString("name")) != null) {
+            stringBuilder.append(ChatColor.GREEN);
+        } else {
+            stringBuilder.append(ChatColor.RED);
+        }
+
+        if (document.getBoolean("restricted") != null) {
+            if (document.getBoolean("restricted")) {
+                stringBuilder.append(ChatColor.GOLD);
+            }
+        }
+
+        if (document.getBoolean("blacklisted") != null) {
+            if (document.getBoolean("blacklisted")) {
+                stringBuilder.append(ChatColor.DARK_RED);
+            }
+        }
+
+        stringBuilder.append(document.getString("name"));
+
+        return stringBuilder.toString();
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/ClearAltsCommand.java

@@ -0,0 +1,60 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.mongodb.client.model.Filters;
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import org.bson.Document;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @author GrowlyX
+ * @since 5/22/2021
+ */
+
+@Command(label = "clearalts", aliases = "removealts", permission = "scandium.command.clearalts", async = true)
+public class ClearAltsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+
+        if (args.length == 1) {
+            final Document document = CorePlugin.getInstance().getPlayerManager().getDocumentByName(args[0]).orElse(null);
+
+            if (document != null) {
+                final String ipAddress = document.getString("previousIpAddress");
+                final Iterator<Document> cursor = CorePlugin.getInstance().getCoreDatabase().getPlayerCollection().find(Filters.eq("previousIpAddress", ipAddress)).iterator();
+                final AtomicInteger amount = new AtomicInteger();
+
+                cursor.forEachRemaining(alt -> {
+                    if (!alt.getString("name").equals(document.getString("name"))) {
+                        CorePlugin.getInstance().getCoreDatabase().getPlayerCollection().deleteOne(alt);
+                        amount.getAndIncrement();
+                    }
+                });
+
+                player.sendMessage(Color.SECONDARY_COLOR + "You've just deleted " + Color.MAIN_COLOR + amount.get() + Color.SECONDARY_COLOR + " alternate accounts from " + Color.MAIN_COLOR + document.getString("name") + "'s" + Color.SECONDARY_COLOR + " history.");
+            } else {
+                player.sendMessage(ChatColor.RED + "Couldn't find any alts related to " + ChatColor.YELLOW + args[0] + ChatColor.RED + ".");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/ClearChatCommand.java

@@ -0,0 +1,52 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.PlayerUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "clearchat", permission = "scandium.command.clearchat", aliases = {"cc"})
+public class ClearChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        for (int lines = 0; lines < 250; lines++) {
+            Bukkit.broadcastMessage(StringUtils.repeat(" ", CorePlugin.RANDOM.nextInt(20)));
+        }
+
+        final String broadcast = ChatColor.GREEN + "The chat has been cleared by " + (sender instanceof Player ? ((Player) sender).getDisplayName() : ChatColor.DARK_RED + "Console") + ChatColor.GREEN + ".";
+
+        Bukkit.broadcastMessage(broadcast);
+
+        if (sender instanceof Player) {
+            PlayerUtil.sendAlert((Player) sender, "cleared chat");
+        }
+
+//        final boolean silent = args[0] != null && args[0].equals("-s");
+//        final boolean randomized = args[1] != null && args[1].equals("-r");
+//        final int amount = randomized ? CorePlugin.RANDOM.nextInt(250) : 250;
+//        final String broadcast = silent ? ChatColor.RED + "The chat has been cleared by " + ChatColor.BOLD + "Staff" + ChatColor.RED + "." : "The chat has been cleared by " + (sender instanceof Player ? ((Player) sender).getDisplayName() : ChatColor.DARK_RED + "Console") + ChatColor.GREEN + ".";
+//
+//        Bukkit.getOnlinePlayers().stream()
+//                .filter(player -> !player.hasPermission("scandium.staff"))
+//                .forEach(player -> {
+//                    for (int lines = 0; lines <= amount; lines++) {
+//                        player.sendMessage("  ");
+//                    }
+//                });
+//
+//        Bukkit.broadcastMessage(broadcast);
+//
+//        if (sender instanceof Player) {
+//            PlayerUtil.sendAlert((Player) sender, "cleared chat");
+//        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/DevChatCommand.java

@@ -0,0 +1,48 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "devchat", permission = "scandium.channels.dev", aliases = {"dc"})
+public class DevChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            if (potPlayer.getChannel() == null || !potPlayer.getChannel().equals(ChatChannelType.DEV)) {
+                potPlayer.setChannel(ChatChannelType.DEV);
+                player.sendMessage(ChatColor.GREEN + Color.translate("You've entered the developer chat channel."));
+            } else {
+                potPlayer.setChannel(null);
+                player.sendMessage(ChatColor.RED + ("You've exited the developer chat channel."));
+            }
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            RedisUtil.publishAsync(RedisUtil.onChatChannel(ChatChannelType.DEV, message, player));
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/FreezeCommand.java

@@ -0,0 +1,67 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.RedisUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "freeze", permission = "scandium.command.freeze", aliases = "ss")
+public class FreezeCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+
+        if (args.length == 1) {
+            final Player target = Bukkit.getPlayer(args[0]);
+
+            if (target != null) {
+                final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                if (potPlayer.isFrozen()) {
+                    potPlayer.setFrozen(false);
+
+                    RedisUtil.publishAsync(RedisUtil.onUnfreeze(player, target));
+
+                    player.sendMessage(Color.SECONDARY_COLOR + "You've unfrozen " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+                } else {
+                    final PotPlayer mainPotPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+                    final PotPlayer targetPotPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(target);
+
+                    if (mainPotPlayer.getActiveGrant().getRank() != null) {
+                        if (player.isOp() || (mainPotPlayer.getActiveGrant().getRank().getWeight() >= targetPotPlayer.getActiveGrant().getRank().getWeight())) {
+                            targetPotPlayer.setFrozen(true);
+
+                            RedisUtil.publishAsync(RedisUtil.onFreeze(player, target));
+
+                            player.sendMessage(Color.SECONDARY_COLOR + "You've frozen " + target.getDisplayName() + Color.SECONDARY_COLOR + ".");
+                        } else {
+                            player.sendMessage(ChatColor.RED + ("You cannot freeze this player as their rank weight is higher than yours!"));
+                        }
+                    }
+                }
+            } else {
+                player.sendMessage(ChatColor.RED + "Error: That player does not exist.");
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/HistoryCommand.java

@@ -0,0 +1,39 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.menu.impl.punish.history.PunishHistoryViewMainMenu;
+import com.solexgames.core.util.Color;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.concurrent.CompletableFuture;
+
+@Command(label = "history", permission = "scandium.command.history", aliases = "c")
+public class HistoryCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        if (args.length == 0) {
+            player.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <player>");
+        }
+        if (args.length == 1) {
+            CompletableFuture.supplyAsync(() -> CorePlugin.getInstance().getUuidCache().getUuidFromUsername(args[0]))
+                    .thenAccept(uuid -> {
+                        player.sendMessage(Color.SECONDARY_COLOR + "Viewing punishment history for: " + Color.MAIN_COLOR + args[0]);
+
+                        new PunishHistoryViewMainMenu(player, uuid, args[0]).open(player);
+                    });
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/HostChatCommand.java

@@ -0,0 +1,48 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "hostchat", aliases = "hc", permission = "scandium.channels.host")
+public class HostChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            if (potPlayer.getChannel() == null || !potPlayer.getChannel().equals(ChatChannelType.HOST)) {
+                potPlayer.setChannel(ChatChannelType.HOST);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You're now chatting in the " + ChatColor.DARK_GREEN + "Host" + ChatColor.GREEN + " channel.");
+            } else {
+                potPlayer.setChannel(null);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You're no longer chatting in the " + ChatColor.DARK_GREEN + "Host" + ChatColor.RED + " channel.");
+            }
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            RedisUtil.publishAsync(RedisUtil.onChatChannel(ChatChannelType.HOST, message, player));
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/ManagerChatCommand.java

@@ -0,0 +1,49 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "managerchat", permission = "scandium.channels.manager", aliases = "mc")
+public class ManagerChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            if (potPlayer.getChannel() == null || !potPlayer.getChannel().equals(ChatChannelType.MANAGER)) {
+                potPlayer.setChannel(ChatChannelType.MANAGER);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You're now chatting in the " + ChatColor.DARK_RED + "Manager" + ChatColor.GREEN + " channel.");
+            } else {
+                potPlayer.setChannel(null);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You're no longer chatting in the " + ChatColor.DARK_RED + "Manager" + ChatColor.RED + " channel.");
+            }
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            RedisUtil.publishAsync(RedisUtil.onChatChannel(ChatChannelType.MANAGER, message, player));
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/ModModeCommand.java

@@ -0,0 +1,37 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.manager.PlayerManager;
+import com.solexgames.core.player.PotPlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "modmode", permission = "scandium.command.modmode", aliases = {"mm", "staffmode", "mod", "staff"})
+public class ModModeCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PlayerManager playerManager = CorePlugin.getInstance().getPlayerManager();
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (potPlayer.isStaffMode()) {
+            playerManager.unModModePlayer(player);
+        } else {
+            playerManager.modModePlayer(player);
+        }
+
+        return false;
+    }
+}
+

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/MuteChatCommand.java

@@ -0,0 +1,34 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.manager.ServerManager;
+import com.solexgames.core.util.PlayerUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "mutechat", permission = "scandium.command.mutechat")
+public class MuteChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        final ServerManager serverManager = CorePlugin.getInstance().getServerManager();
+        final String displayName = ((sender instanceof Player) ? ((Player) sender).getDisplayName() : ChatColor.DARK_RED + "Console");
+
+        serverManager.setChatEnabled(!serverManager.isChatEnabled());
+
+        final boolean silent = args.length > 0 && args[0] != null && args[0].equals("-s");
+        final String broadcast = silent ? ChatColor.RED + "The chat has been " + (serverManager.isChatEnabled() ? "enabled" : "disabled") + " by " + ChatColor.BOLD + "Staff" + ChatColor.RED + "." : ChatColor.GREEN + "The chat has been " + (serverManager.isChatEnabled() ? "enabled" : "disabled") + " by " + displayName + ".";
+
+        Bukkit.broadcastMessage(broadcast);
+        CorePlugin.getInstance().getPlayerManager().sendToNetworkStaffFormatted(displayName + ChatColor.DARK_AQUA + " has " + (serverManager.isChatEnabled() ? ChatColor.GREEN + "enabled" : ChatColor.RED + "disabled") + ChatColor.DARK_AQUA + " chat.");
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/NoteCommand.java

@@ -0,0 +1,9 @@
+package com.solexgames.core.command.impl.moderation;
+
+/**
+ * @author GrowlyX
+ * @since 5/31/2021
+ */
+
+public class NoteCommand {
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/OwnerChatCommand.java

@@ -0,0 +1,48 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "ownerchat", permission = "scandium.channels.owner", aliases = {"oc"})
+public class OwnerChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (args.length == 0) {
+            if (potPlayer.getChannel() == null || !potPlayer.getChannel().equals(ChatChannelType.OWNER)) {
+                potPlayer.setChannel(ChatChannelType.OWNER);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You're now chatting in the " + ChatColor.BLUE + "Owner" + ChatColor.GREEN + " channel.");
+            } else {
+                potPlayer.setChannel(null);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You're no longer chatting in the " + ChatColor.BLUE + "Owner" + ChatColor.RED + " channel.");
+            }
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            RedisUtil.publishAsync(RedisUtil.onChatChannel(ChatChannelType.OWNER, message, player));
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/RemoveProfileCommand.java

@@ -0,0 +1,43 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import org.bson.Document;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import java.util.UUID;
+
+/**
+ * @author GrowlyX
+ * @since 6/9/2021
+ */
+
+@Command(label = "removeprofile", consoleOnly = true)
+public class RemoveProfileCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <uuid>");
+        }
+
+        if (args.length > 0) {
+            final Document document = CorePlugin.getInstance().getPlayerManager().getDocumentByUuid(UUID.fromString(args[0]))
+                    .orElse(null);
+
+            if (document != null) {
+                CorePlugin.getInstance().getCoreDatabase().getPlayerCollection().deleteOne(document);
+
+                sender.sendMessage(Constants.STAFF_PREFIX + Color.SECONDARY_COLOR + "You've deleted the profile with the uuid " + Color.MAIN_COLOR + args[0] + Color.SECONDARY_COLOR + ".");
+            } else {
+                sender.sendMessage(ChatColor.RED + "Failed to find that player.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/ReportsCommand.java

@@ -0,0 +1,28 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.util.external.impl.ReportViewPaginatedMenu;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "reports", permission = "scandium.command.reports")
+public class ReportsCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+
+        new ReportViewPaginatedMenu().openMenu(player);
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/SlowChatCommand.java

@@ -0,0 +1,42 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(label = "slowchat", permission = "scandium.command.slowchat", aliases = "chatdelay")
+public class SlowChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        final String displayName = ((sender instanceof Player) ? ((Player) sender).getDisplayName() : ChatColor.DARK_RED + "Console");
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <time> " + ChatColor.GRAY + "(Use 0 to disable slow chat)");
+        }
+
+        if (args.length == 1) {
+            try {
+                final int time = Integer.parseInt(args[0]);
+
+                CorePlugin.getInstance().getServerManager().setChatSlow(time * 1000L);
+                Bukkit.broadcastMessage(CorePlugin.getInstance().getServerManager().getChatSlow() > 0L ? ChatColor.GREEN + "Public chat is now in slow mode. " + ChatColor.GRAY + "(" + time + " seconds)" : ChatColor.RED + "Public chat is no longer in slow mode.");
+
+                CorePlugin.getInstance().getPlayerManager().sendToNetworkStaffFormatted(displayName + " &3has slowed the chat to &e" + time + " seconds&3.");
+            } catch (NumberFormatException e) {
+                sender.sendMessage(ChatColor.RED + "Error: That's not a valid integer.");
+            }
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/SocialSpyCommand.java

@@ -0,0 +1,39 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "socialspy", permission = "scandium.command.socialspy")
+public class SocialSpyCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (potPlayer.isSocialSpy()) {
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You're now viewing other users' private messages.");
+            potPlayer.setSocialSpy(false);
+        } else {
+            player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You've stopped viewing other users' private messages.");
+            potPlayer.setSocialSpy(true);
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/StaffAnnounceCommand.java

@@ -0,0 +1,36 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ServerType;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Command(label = "staffannounce", permission = "scandium.command.staffannounce")
+public class StaffAnnounceCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        if (args.length == 0) {
+            sender.sendMessage(Color.translate(Color.SECONDARY_COLOR + "Usage: " + Color.MAIN_COLOR + "/" + label + ChatColor.WHITE + " <message>"));
+        }
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            CorePlugin.getInstance().getPlayerManager().sendToNetworkStaff("&b[S] &c[Alert]&f: &b" + message);
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/StaffChatCommand.java

@@ -0,0 +1,51 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.enums.ChatChannelType;
+import com.solexgames.core.player.PotPlayer;
+import com.solexgames.core.util.Color;
+import com.solexgames.core.util.Constants;
+import com.solexgames.core.util.RedisUtil;
+import com.solexgames.core.util.StringUtil;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(label = "staffchat", permission = "scandium.channels.staff", aliases = "sc")
+public class StaffChatCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ONLY_PLAYERS);
+            return false;
+        }
+
+        final Player player = (Player) sender;
+        final PotPlayer potPlayer = CorePlugin.getInstance().getPlayerManager().getPlayer(player);
+
+        if (!player.hasPermission(ChatChannelType.STAFF.getPermission())) {
+            player.sendMessage(NO_PERMISSION);
+            return false;
+        }
+
+        if (args.length == 0) {
+            if (potPlayer.getChannel() == null || !potPlayer.getChannel().equals(ChatChannelType.STAFF)) {
+                potPlayer.setChannel(ChatChannelType.STAFF);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.GREEN + "You're now chatting in the " + ChatColor.AQUA + "Staff" + ChatColor.GREEN + " channel.");
+            } else {
+                potPlayer.setChannel(null);
+                player.sendMessage(Constants.STAFF_PREFIX + ChatColor.RED + "You're no longer chatting in the " + ChatColor.AQUA + "Staff" + ChatColor.RED + " channel.");
+            }
+        }
+
+        if (args.length > 0) {
+            final String message = StringUtil.buildMessage(args, 0);
+            RedisUtil.publishAsync(RedisUtil.onChatChannel(ChatChannelType.STAFF, message, player));
+        }
+
+        return false;
+    }
+}

Bukkit/src/main/java/com/solexgames/core/command/impl/moderation/StaffListCommand.java

@@ -0,0 +1,64 @@
+package com.solexgames.core.command.impl.moderation;
+
+import com.solexgames.core.CorePlugin;
+import com.solexgames.core.command.BaseCommand;
+import com.solexgames.core.command.annotation.Command;
+import com.solexgames.core.player.global.NetworkPlayer;
+import com.solexgames.core.player.ranks.Rank;
+import com.solexgames.core.util.Color;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang3.time.DurationFormatUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author GrowlyX
+ * @since 5/26/2021
+ */
+
+@Command(label = "stafflist", aliases = "sl", permission = "scandium.staff")
+public class StaffListCommand extends BaseCommand {
+
+    @Override
+    public boolean command(CommandSender sender, String label, String[] args) {
+        final List<Rank> ranksWithStaffPermissions = CorePlugin.getInstance().getRankManager().getSortedRanksFromTop().stream()
+                .filter(rank -> rank.getPermissions().contains("scandium.staff"))
+                .collect(Collectors.toList());
+
+        if (ranksWithStaffPermissions.isEmpty()) {
+            sender.sendMessage(ChatColor.RED + "I'm sorry, but there aren't any staff ranks available.");
+            return false;
+        }
+
+        sender.sendMessage(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + StringUtils.repeat("-", 53));
+        sender.sendMessage(Color.MAIN_COLOR + ChatColor.BOLD + "Online Staff:");
+        sender.sendMessage(" ");
+
+        ranksWithStaffPermissions.forEach(rank -> {
+            final List<NetworkPlayer> playersWithSpecifiedRank = CorePlugin.getInstance().getPlayerManager().getAllNetworkProfiles().stream()
+                    .filter(networkPlayer -> networkPlayer.getRankName().equals(rank.getName()))
+                    .collect(Collectors.toList());
+
+            if (playersWithSpecifiedRank.isEmpty()) {
+                return;
+            }
+
+            sender.sendMessage(Color.translate(rank.getColor() + rank.getItalic()) + ChatColor.BOLD.toString() + rank.getName() + ":");
+
+            playersWithSpecifiedRank.stream()
+                    .map(networkPlayer -> ChatColor.GRAY + " * " + Color.SECONDARY_COLOR + networkPlayer.getName() + ChatColor.GRAY + " (" + CorePlugin.FORMAT.format(new Date(networkPlayer.getConnectionTime())) + ") (" + DurationFormatUtils.formatDurationWords(System.currentTimeMillis() - networkPlayer.getConnectionTime(), true, true) + ") (" + networkPlayer.getServerName() + ")")
+                    .collect(Collectors.toList())
+                    .forEach(sender::sendMessage);
+
+            sender.sendMessage(" ");
+        });
+
+        sender.sendMessage(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + StringUtils.repeat("-", 53));
+
+        return false;
+    }
+}