Changed warning for disable-sync

pom.xml

@@ -4,18 +4,323 @@
          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>
 
-    <groupId>de.rayzs.controlplayer</groupId>
-    <artifactId>ProAntiTab-Addons</artifactId>
-    <version>1.0-SNAPSHOT</version>
-    <packaging>pom</packaging>
-    <modules>
-        <module>subarguments</module>
-    </modules>
+    <groupId>de.rayzs.pat</groupId>
+    <artifactId>ProAntiTab</artifactId>
+    <version>1.9.2</version>
 
     <properties>
-        <maven.compiler.source>16</maven.compiler.source>
-        <maven.compiler.target>16</maven.compiler.target>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
     </properties>
 
+    <repositories>
+        <repository>
+            <id>spigot-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
+        </repository>
+
+        <repository>
+            <id>bungeecord-repo</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+        </repository>
+
+        <repository>
+            <id>papermc</id>
+            <url>https://repo.papermc.io/repository/maven-public/</url>
+        </repository>
+
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+
+        <repository>
+            <id>velocity</id>
+            <url>https://repo.velocitypowered.com/snapshots/</url>
+        </repository>
+
+        <repository>
+            <id>minecraft-libraries</id>
+            <name>Minecraft Libraries</name>
+            <url>https://libraries.minecraft.net/</url>
+        </repository>
+
+        <repository>
+            <id>sonatype</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+        </repository>
+
+        <repository>
+            <id>placeholderapi</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
+
+        <repository>
+            <id>viaversion-repo</id>
+            <url>https://repo.viaversion.com</url>
+        </repository>
+
+        <repository>
+            <id>william278-velocity</id>
+            <name>William278</name>
+            <url>https://repo.william278.net/velocity</url>
+        </repository>
+
+        <repository>
+            <id>william278-papiproxybridge</id>
+            <name>William278</name>
+            <url>https://repo.william278.net/papiproxybridge</url>
+        </repository>
+
+        <repository>
+            <id>skript-releases</id>
+            <name>Skript Repository</name>
+            <url>https://repo.skriptlang.org/releases</url>
+        </repository>
+
+    </repositories>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>org.skriptlang</groupId>
+            <artifactId>Skript</artifactId>
+            <version>2.10.1</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>dev.folia</groupId>
+            <artifactId>folia-api</artifactId>
+            <version>1.20.1-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.19-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+            <version>4.0.23.Final</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.md-5</groupId>
+            <artifactId>bungeecord-api</artifactId>
+            <version>1.20-R0.3-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.md-5</groupId>
+            <artifactId>bungeecord-protocol</artifactId>
+            <version>1.16-R0.4</version>
+            <scope>provided</scope>
+        </dependency>
+
+
+        <dependency>
+            <groupId>com.mojang</groupId>
+            <artifactId>authlib</artifactId>
+            <version>4.0.43</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.mojang</groupId>
+            <artifactId>brigadier</artifactId>
+            <version>1.1.8</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.mojang</groupId>
+            <artifactId>datafixerupper</artifactId>
+            <version>6.0.8</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.mojang</groupId>
+            <artifactId>logging</artifactId>
+            <version>1.1.1</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-resolver-provider</artifactId>
+            <version>3.8.5</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-connector-basic</artifactId>
+            <version>1.7.3</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-transport-http</artifactId>
+            <version>1.7.3</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.18.0</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.github.waterfallmc</groupId>
+            <artifactId>waterfall-api</artifactId>
+            <version>1.20-R0.3-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.william278</groupId>
+            <artifactId>papiproxybridge</artifactId>
+            <version>1.4</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.velocitypowered</groupId>
+            <artifactId>velocity-api</artifactId>
+            <version>3.1.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.velocitypowered</groupId>
+            <artifactId>velocity-proxy</artifactId>
+            <version>3.3.0-SNAPSHOT</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.velocitypowered</groupId>
+                    <artifactId>velocity-proxy-log4j2-plugin</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.sonatype.sisu</groupId>
+            <artifactId>sisu-guice</artifactId>
+            <version>2.1.7</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.spongepowered</groupId>
+            <artifactId>configurate-hocon</artifactId>
+            <version>4.1.2</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-text-minimessage</artifactId>
+            <version>4.18.0</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-api</artifactId>
+            <version>4.18.0</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-platform-api</artifactId>
+            <version>4.3.3</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-platform-bungeecord</artifactId>
+            <version>4.3.3</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-platform-bukkit</artifactId>
+            <version>4.3.2</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.11.5</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>net.luckperms</groupId>
+            <artifactId>api</artifactId>
+            <version>5.4</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.viaversion</groupId>
+            <artifactId>viaversion-api</artifactId>
+            <version>LATEST</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.papermc.paper</groupId>
+            <artifactId>paper-api</artifactId>
+            <version>1.17-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>IgnoreThisJar</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.3.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <finalName>ProAntiTab</finalName>
+                    <shadedArtifactAttached>false</shadedArtifactAttached>
+                    <shadedClassifierName>shaded</shadedClassifierName>
+                    <artifactSet>
+                        <excludes/>
+                    </artifactSet>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+
 </project>

src/main/java/de/rayzs/pat/api/brand/CustomServerBrand.java

@@ -0,0 +1,24 @@
+package de.rayzs.pat.api.brand;
+
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.PacketUtils;
+import de.rayzs.pat.utils.Reflection;
+import de.rayzs.pat.api.brand.impl.*;
+
+public class CustomServerBrand {
+
+    public static final String CHANNEL_NAME = Reflection.getMinor() < 13 ? "MC|Brand" : "minecraft:brand";
+    private static final ServerBrand SERVER_BRAND = Reflection.isVelocityServer() ? new VelocityServerBrand() : Reflection.isProxyServer() ? new BungeeServerBrand() : new BukkitServerBrand();
+
+    public static void initialize() { refreshTask(); }
+    public static void refreshTask() { SERVER_BRAND.initializeTask(); }
+    public static void preparePlayer(Object playerObj) { SERVER_BRAND.preparePlayer(playerObj); }
+    public static void sendBrandToPlayer(Object playerObj) { SERVER_BRAND.send(playerObj); }
+
+    public static PacketUtils.BrandManipulate createBrandPacket(Object playerObj) { return SERVER_BRAND.createPacket(playerObj); }
+    public static boolean isEnabled() { return Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED; }
+
+    public static boolean isBrandTag(String tag) {
+        return tag.equals("MC|Brand") || tag.equals("minecraft:brand");
+    }
+}

src/main/java/de/rayzs/pat/api/brand/ServerBrand.java

@@ -0,0 +1,10 @@
+package de.rayzs.pat.api.brand;
+
+import de.rayzs.pat.utils.PacketUtils;
+
+public interface ServerBrand {
+    void preparePlayer(Object playerObj);
+    void send(Object playerObj);
+    PacketUtils.BrandManipulate createPacket(Object playerObj);
+    void initializeTask();
+}

src/main/java/de/rayzs/pat/api/brand/impl/BukkitServerBrand.java

@@ -0,0 +1,135 @@
+package de.rayzs.pat.api.brand.impl;
+
+import de.rayzs.pat.api.netty.bukkit.BukkitPacketAnalyzer;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import java.util.concurrent.atomic.AtomicInteger;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BukkitLoader;
+import de.rayzs.pat.utils.scheduler.PATScheduler;
+import de.rayzs.pat.utils.scheduler.PATSchedulerTask;
+import io.netty.channel.Channel;
+import de.rayzs.pat.api.brand.*;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import de.rayzs.pat.utils.*;
+import java.lang.reflect.*;
+import org.bukkit.*;
+import java.util.*;
+
+public class BukkitServerBrand implements ServerBrand {
+
+    private static final List<Player> MODIFIED_BRAND_PLAYERS = new ArrayList<>();
+    private static final Server SERVER = Bukkit.getServer();
+    private static String BRAND = Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(0);
+    private static PATSchedulerTask  TASK;
+    private static boolean INITIALIZED = false;
+    private static Class<?> brandPayloadClass, clientBoundCustomPacketPayloadPacketClass, customPacketPayloadPacketClass;
+
+    @Override
+    public void initializeTask() {
+
+        if(Reflection.isWeird()) {
+            if (brandPayloadClass == null)
+                brandPayloadClass = Reflection.getClass("net.minecraft.network.protocol.common.custom.BrandPayload");
+
+            if (clientBoundCustomPacketPayloadPacketClass == null)
+                clientBoundCustomPacketPayloadPacketClass = Reflection.getClass("net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket");
+
+            if (customPacketPayloadPacketClass == null)
+                customPacketPayloadPacketClass = Reflection.getClass("net.minecraft.network.protocol.common.custom.CustomPacketPayload");
+        }
+
+        Bukkit.getOnlinePlayers().forEach(this::preparePlayer);
+        if(!INITIALIZED)
+            try {
+                Method method = Reflection.getMethodsByParameterAndName(SERVER.getMessenger(), "addToOutgoing", Plugin.class, String.class).get(0);
+                Reflection.invokeMethode(method, SERVER.getMessenger(), BukkitLoader.getPlugin(), CustomServerBrand.CHANNEL_NAME);
+                SERVER.getMessenger().registerOutgoingPluginChannel(BukkitLoader.getPlugin(), CustomServerBrand.CHANNEL_NAME);
+                INITIALIZED = true;
+            } catch (Exception exception) {
+                exception.printStackTrace();
+            }
+
+        if(TASK != null && TASK.isActive()) {
+            TASK.cancelTask();
+            TASK = null;
+            MODIFIED_BRAND_PLAYERS.clear();
+        }
+
+        if(!Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+
+        if(Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY == -1) {
+            BRAND = Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(0) + "§r";
+
+            PATScheduler.createAsyncScheduler(() -> {
+                Bukkit.getOnlinePlayers().forEach(this::send);
+            }, 1, 1);
+
+        } else {
+            AtomicInteger animationState = new AtomicInteger(0);
+            TASK = PATScheduler.createAsyncScheduler(() -> {
+                if (animationState.getAndIncrement() >= Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().size() - 1)
+                    animationState.set(0);
+                BRAND = Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(animationState.get()) + "§r";
+                Bukkit.getOnlinePlayers().forEach(this::send);
+            }, 1, Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY);
+        }
+    }
+
+    @Override
+    public void preparePlayer(Object playerObj) {
+        if(!(playerObj instanceof Player) || !Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+        Player player = (Player) playerObj;
+
+        try {
+            Field channelsField = Reflection.getFieldByName(player.getClass(), "channels");
+            Set<String> channels = (Set<String>) channelsField.get(player);
+            channels.add(CustomServerBrand.CHANNEL_NAME);
+            Reflection.closeAccess(channelsField);
+            if(!MODIFIED_BRAND_PLAYERS.contains(player)) MODIFIED_BRAND_PLAYERS.add(player);
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public void send(Object playerObj) {
+        if(!(playerObj instanceof Player) || !Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+        Player player = (Player) playerObj;
+        String playerName = player.getName(), displayName = player.getDisplayName(), worldName = player.getWorld().getName(),
+                customBrand = BRAND.replace("%player%", playerName).replace("%displayname%", displayName).replace("%world%", worldName);
+
+        if(!Reflection.isWeird()) {
+            PacketUtils.BrandManipulate serverBrand = new PacketUtils.BrandManipulate(MessageTranslator.replaceMessage(player, customBrand));
+            player.sendPluginMessage(BukkitLoader.getPlugin(), CustomServerBrand.CHANNEL_NAME, serverBrand.getBytes());
+            return;
+        }
+
+        try {
+            Channel channel = BukkitPacketAnalyzer.INJECTED_PLAYERS.get(player.getUniqueId());
+            if(channel == null) return;
+
+            Object brandPayloadObj = brandPayloadClass.getDeclaredConstructor(String.class).newInstance(MessageTranslator.replaceMessage(player, customBrand)),
+                    customPacketPayloadPacket = clientBoundCustomPacketPayloadPacketClass.getDeclaredConstructor(customPacketPayloadPacketClass).newInstance(brandPayloadObj);
+            channel.pipeline().writeAndFlush(customPacketPayloadPacket);
+
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public PacketUtils.BrandManipulate createPacket(Object playerObj) {
+        return null;
+    }
+
+    private boolean isModified(Player player) {
+        if(!Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED || Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY != -1) return false;
+        return MODIFIED_BRAND_PLAYERS.contains(player);
+    }
+
+    public static void removeFromModified(Player player) {
+        MODIFIED_BRAND_PLAYERS.remove(player);
+    }
+}

src/main/java/de/rayzs/pat/api/brand/impl/BungeeServerBrand.java

@@ -0,0 +1,73 @@
+package de.rayzs.pat.api.brand.impl;
+
+import de.rayzs.pat.utils.message.MessageTranslator;
+import net.md_5.bungee.api.scheduler.ScheduledTask;
+import net.md_5.bungee.protocol.ProtocolConstants;
+import java.util.concurrent.atomic.AtomicInteger;
+import de.rayzs.pat.api.brand.ServerBrand;
+import net.md_5.bungee.api.connection.*;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BungeeLoader;
+import net.md_5.bungee.api.ProxyServer;
+import de.rayzs.pat.utils.PacketUtils;
+import java.util.concurrent.TimeUnit;
+
+public class BungeeServerBrand implements ServerBrand {
+
+    private static final ProxyServer SERVER = BungeeLoader.getPlugin().getProxy();
+    private static ScheduledTask TASK;
+    private static String BRAND = Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(0);
+
+    public BungeeServerBrand() { }
+
+    @Override
+    public void initializeTask() {
+        if(TASK != null) TASK.cancel();
+
+        if(!Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+
+        if(Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY == -1) {
+            BRAND = MessageTranslator.replaceMessage(Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(0)) + "§r";
+            SERVER.getPlayers().forEach(this::send);
+        } else {
+            AtomicInteger animationState = new AtomicInteger(0);
+            TASK = SERVER.getScheduler().schedule(BungeeLoader.getPlugin(), () -> {
+                if (animationState.getAndIncrement() >= Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().size() - 1)
+                    animationState.set(0);
+                BRAND = MessageTranslator.replaceMessage(Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(animationState.get())) + "§r";
+                SERVER.getPlayers().forEach(this::send);
+            }, 1, Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    @Override
+    public void preparePlayer(Object playerObj) { }
+
+    @Override
+    public void send(Object playerObj) {
+        if (!(playerObj instanceof ProxiedPlayer) || !Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+        ProxiedPlayer player = (ProxiedPlayer) playerObj;
+
+        String serverName = "", playerName = player.getName(), customBrand;
+        Server server = player.getServer();
+        if(server != null) serverName = server.getInfo().getName();
+        customBrand = BRAND.replace("%player%", playerName).replace("%server%", serverName);
+
+        PacketUtils.BrandManipulate serverBrand = new PacketUtils.BrandManipulate(customBrand);
+        String brand = player.getPendingConnection().getVersion() >= ProtocolConstants.MINECRAFT_1_13 ? "minecraft:brand" : "MC|Brand";
+        player.sendData(brand, serverBrand.getBytes());
+    }
+
+    @Override
+    public PacketUtils.BrandManipulate createPacket(Object playerObj) {
+        if (!(playerObj instanceof ProxiedPlayer) || !Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return null;
+        ProxiedPlayer player = (ProxiedPlayer) playerObj;
+
+        String serverName = "", playerName = player.getName(), customBrand;
+        Server server = player.getServer();
+        if(server != null) serverName = server.getInfo().getName();
+        customBrand = BRAND.replace("%player%", playerName).replace("%server%", serverName);
+
+        return new PacketUtils.BrandManipulate(customBrand);
+    }
+}

src/main/java/de/rayzs/pat/api/brand/impl/VelocityServerBrand.java

@@ -0,0 +1,104 @@
+package de.rayzs.pat.api.brand.impl;
+
+import com.velocitypowered.api.scheduler.ScheduledTask;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import net.md_5.bungee.protocol.ProtocolConstants;
+import java.util.concurrent.atomic.AtomicInteger;
+import de.rayzs.pat.api.brand.ServerBrand;
+import de.rayzs.pat.plugin.VelocityLoader;
+import de.rayzs.pat.api.storage.Storage;
+import com.velocitypowered.api.proxy.*;
+import java.util.concurrent.TimeUnit;
+import java.lang.reflect.Method;
+import io.netty.buffer.ByteBuf;
+import de.rayzs.pat.utils.*;
+import java.util.Optional;
+
+public class VelocityServerBrand implements ServerBrand {
+
+    private static final ProxyServer SERVER = VelocityLoader.getServer();
+    private static Class<?> pluginMessagePacketClass, minecraftConnectionClass, connectedPlayerConnectionClass;
+    private static Method connectionMethod;
+    private static ScheduledTask TASK;
+    private static String BRAND = Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(0);
+
+    @Override
+    public void initializeTask() {
+        if(TASK != null) TASK.cancel();
+
+        if(!Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+
+        if(pluginMessagePacketClass == null)
+            pluginMessagePacketClass = Reflection.getClass("com.velocitypowered.proxy.protocol.packet.PluginMessagePacket");
+
+        if(minecraftConnectionClass == null)
+            minecraftConnectionClass = Reflection.getClass("com.velocitypowered.proxy.connection.MinecraftConnection");
+
+        if(connectedPlayerConnectionClass == null)
+            connectedPlayerConnectionClass = Reflection.getClass("com.velocitypowered.proxy.connection.client.ConnectedPlayer");
+
+        if(connectionMethod == null)
+            connectionMethod = Reflection.getMethodByName(connectedPlayerConnectionClass, "getConnection");
+
+        if(Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY == -1) {
+            BRAND = MessageTranslator.replaceMessage(Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(0)) + "§r";
+            SERVER.getAllPlayers().forEach(this::send);
+        } else {
+            AtomicInteger animationState = new AtomicInteger(0);
+            TASK = SERVER.getScheduler().buildTask(VelocityLoader.getInstance(), () -> {
+                if (animationState.getAndIncrement() >= Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().size() - 1)
+                    animationState.set(0);
+                BRAND = MessageTranslator.replaceMessage(Storage.ConfigSections.Settings.CUSTOM_BRAND.BRANDS.getLines().get(animationState.get())) + "§r";
+                SERVER.getAllPlayers().forEach(this::send);
+            }).repeat(Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY, TimeUnit.MILLISECONDS).schedule();
+        }
+    }
+
+
+    @Override
+    public void preparePlayer(Object playerObj) { }
+
+    @Override
+    public void send(Object playerObj) {
+        if (!(playerObj instanceof Player) || !Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return;
+
+        try {
+            Player player = (Player) playerObj;
+            Object connectedPlayerObj = connectedPlayerConnectionClass.cast(player),
+                    minecraftConnectionObj = connectionMethod.invoke(connectedPlayerObj);
+
+            String serverName = "", playerName = player.getUsername(), customBrand;
+            Optional<ServerConnection> serverConnection = player.getCurrentServer();
+            if(serverConnection.isPresent()) serverName = serverConnection.get().getServerInfo().getName();
+            customBrand = BRAND.replace("%player%", playerName).replace("%server%", serverName).replace("%ping%", String.valueOf(player.getPing()));
+
+            PacketUtils.BrandManipulate serverBrand = new PacketUtils.BrandManipulate(customBrand, false);
+            String brand = player.getProtocolVersion().getProtocol() >= ProtocolConstants.MINECRAFT_1_13 ? "minecraft:brand" : "MC|Brand";
+            Object pluginMessagePacket = pluginMessagePacketClass.getConstructor(String.class, ByteBuf.class).newInstance(brand, serverBrand.getByteBuf());
+            Reflection.getMethodsByParameterAndName(minecraftConnectionObj, "write", Object.class).get(0).invoke(minecraftConnectionObj, pluginMessagePacket);
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public PacketUtils.BrandManipulate createPacket(Object playerObj) {
+        if (!(playerObj instanceof Player) || !Storage.ConfigSections.Settings.CUSTOM_BRAND.ENABLED) return null;
+
+        try {
+            Player player = (Player) playerObj;
+
+            String serverName = "", playerName = player.getUsername(), customBrand;
+            Optional<ServerConnection> serverConnection = player.getCurrentServer();
+
+            if(serverConnection.isPresent()) serverName = serverConnection.get().getServerInfo().getName();
+            customBrand = BRAND.replace("%player%", playerName).replace("%server%", serverName).replace("%ping%", String.valueOf(player.getPing()));
+
+            return new PacketUtils.BrandManipulate(customBrand, false);
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+
+        return null;
+    }
+}

src/main/java/de/rayzs/pat/api/communication/BackendUpdater.java

@@ -0,0 +1,39 @@
+package de.rayzs.pat.api.communication;
+
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.scheduler.*;
+import org.bukkit.Bukkit;
+
+public class BackendUpdater {
+
+    private static PATSchedulerTask TASK;
+
+    public static void handle() {
+        if(isRunning() || !shouldRun() || !Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED) return;
+        start();
+    }
+
+    public static boolean isRunning() {
+        return TASK != null && TASK.isActive();
+    }
+
+    public static void start() {
+        if(isRunning()) return;
+
+        TASK = PATScheduler.createScheduler(() -> {
+            if (shouldRun()) Communicator.sendRequest();
+            else stop();
+        }, 5, 20);
+    }
+
+    public static void stop() {
+        if(TASK == null || !TASK.isActive()) return;
+        TASK.cancelTask();
+        TASK = null;
+    }
+
+    private static boolean shouldRun() {
+        int onlinePlayerSize = Bukkit.getOnlinePlayers().size();
+        return onlinePlayerSize >= 1;
+    }
+}

src/main/java/de/rayzs/pat/api/communication/Client.java

@@ -0,0 +1,6 @@
+package de.rayzs.pat.api.communication;
+
+public interface Client {
+    String CHANNEL_NAME = "pat:channel";
+    void send(Object packet);
+}

src/main/java/de/rayzs/pat/api/communication/Communicator.java

@@ -0,0 +1,205 @@
+package de.rayzs.pat.api.communication;
+
+import de.rayzs.pat.api.communication.client.ClientInfo;
+import de.rayzs.pat.api.communication.client.impl.*;
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.api.storage.blacklist.impl.*;
+import de.rayzs.pat.api.communication.impl.*;
+import de.rayzs.pat.plugin.BukkitLoader;
+import de.rayzs.pat.api.storage.Storage;
+import java.util.concurrent.TimeUnit;
+import de.rayzs.pat.utils.group.*;
+import de.rayzs.pat.utils.*;
+import java.util.*;
+
+public class Communicator {
+
+    private static final Client CLIENT = Reflection.isVelocityServer() ? new VelocityClient() : Reflection.isProxyServer() ? new BungeeClient() : new BukkitClient();
+    private static final UUID SERVER_ID = UUID.randomUUID();
+    public static final List<ClientInfo> CLIENTS = new ArrayList<>();
+    private static final ExpireCache<String, ClientInfo> QUEUE_CLIENTS = new ExpireCache<>(15, TimeUnit.SECONDS);
+    public static long LAST_DATA_UPDATE = System.currentTimeMillis(), LAST_SENT_REQUEST = 0, LAST_BUKKIT_SYNC = System.currentTimeMillis();
+    public static int SERVER_DATA_SYNC_COUNT = 0;
+
+    public static void sendPacket(Object packet) {
+        CLIENT.send(packet);
+    }
+
+    public static void sendPacket(ClientInfo clientInfo, Object packet) {
+        clientInfo.sendBytes(CommunicationPackets.convertToBytes(packet));
+    }
+
+    public static void receiveInformation(String serverName, Object packet) {
+        if(packet instanceof CommunicationPackets.RequestPacket) {
+            CommunicationPackets.RequestPacket requestPacket = (CommunicationPackets.RequestPacket) packet;
+            if (!requestPacket.isToken(Storage.TOKEN)) return;
+
+            ClientInfo client = getClientByName(serverName);
+            if (client == null) {
+                client = Reflection.isVelocityServer() ? new VelocityClientInfo(requestPacket.getServerId(), serverName) : new BungeeClientInfo(requestPacket.getServerId(), serverName);
+                CLIENTS.add(client);
+            }
+
+            if (!client.compareId(requestPacket.getServerId())) client.setId(requestPacket.getServerId());
+
+            syncData(client.getId());
+            return;
+        }
+
+        if(packet instanceof CommunicationPackets.ForcePermissionResetPacket) {
+            if(Reflection.isProxyServer()) return;
+            CommunicationPackets.ForcePermissionResetPacket permissionResetPacket = (CommunicationPackets.ForcePermissionResetPacket) packet;
+            if(!permissionResetPacket.isToken(Storage.TOKEN)) return;
+
+            if(permissionResetPacket.hasTarget()) PermissionUtil.setPlayerPermissions(permissionResetPacket.getTargetUUID());
+            else PermissionUtil.reloadPermissions();
+            return;
+        }
+
+        if(packet instanceof CommunicationPackets.BackendDataPacket) {
+            CommunicationPackets.BackendDataPacket backendDataPacket = (CommunicationPackets.BackendDataPacket) packet;
+            if (!backendDataPacket.isToken(Storage.TOKEN)) return;
+            Storage.SERVER_NAME = backendDataPacket.getServerName();
+            return;
+        }
+
+        if(packet instanceof CommunicationPackets.FeedbackPacket) {
+            CommunicationPackets.FeedbackPacket feedbackPacket = (CommunicationPackets.FeedbackPacket) packet;
+            if (!feedbackPacket.isToken(Storage.TOKEN)) return;
+            String serverId = feedbackPacket.getServerId();
+
+            ClientInfo client = getClientByName(serverName);
+            if (client == null) {
+                client = Reflection.isVelocityServer() ? new VelocityClientInfo(feedbackPacket.getServerId(), serverName) : new BungeeClientInfo(feedbackPacket.getServerId(), serverName);
+                CLIENTS.add(client);
+            }
+
+            if (!client.compareId(feedbackPacket.getServerId())) client.setId(feedbackPacket.getServerId());
+            if (client.hasSentFeedback()) return;
+            client.setFeedback(true);
+            client.syncTime();
+            SERVER_DATA_SYNC_COUNT++;
+
+            CommunicationPackets.BackendDataPacket backendDataPacket = new CommunicationPackets.BackendDataPacket(Storage.TOKEN, serverId, serverName);
+            sendPacket(client, backendDataPacket);
+            return;
+        }
+
+        if(packet instanceof CommunicationPackets.PacketBundle) {
+            CommunicationPackets.PacketBundle packetBundle =  (CommunicationPackets.PacketBundle) packet;
+            if(!packetBundle.isToken(Storage.TOKEN) || !packetBundle.isId(SERVER_ID.toString())) return;
+
+            Storage.USE_VELOCITY = packetBundle.isVelocity();
+            LAST_BUKKIT_SYNC = System.currentTimeMillis();
+            BukkitLoader.synchronize(packetBundle);
+        }
+    }
+
+    public static void syncData() {
+        syncData(null);
+    }
+
+    public static void syncData(String serverId) {
+        if (Storage.ConfigSections.Settings.DISABLE_SYNC.DISABLED) return;
+
+        LAST_DATA_UPDATE = System.currentTimeMillis();
+        ClientInfo clientInfo;
+        if(serverId == null) {
+            SERVER_DATA_SYNC_COUNT = 0;
+            CLIENTS.forEach(currentClient -> syncData(currentClient.getId()));
+            return;
+        } else {
+            clientInfo = getClientById(serverId);
+            if(clientInfo != null) clientInfo.setFeedback(false);
+
+            SERVER_DATA_SYNC_COUNT = SERVER_DATA_SYNC_COUNT -1;
+            if(SERVER_DATA_SYNC_COUNT <= 0) SERVER_DATA_SYNC_COUNT = 0;
+        }
+
+        CommunicationPackets.CommandsPacket commandsPacket = new CommunicationPackets.CommandsPacket();
+        CommunicationPackets.GroupsPacket groupsPacket;
+        CommunicationPackets.PacketBundle bundle;
+        List<String> commands = new ArrayList<>();
+        String tempServerName = "";
+
+        if(clientInfo != null && clientInfo.getName() != null) {
+            tempServerName = clientInfo.getName().toLowerCase();
+            if(!Storage.Blacklist.isOnIgnoredServer(tempServerName))
+                commands.addAll(Storage.Blacklist.getBlacklist().getCommands());
+
+            List<GeneralBlacklist> serverBlacklists = Storage.Blacklist.getBlacklists(clientInfo.getName());
+            serverBlacklists.stream().filter(serverBlacklist -> serverBlacklist != null && serverBlacklist.getCommands() != null).forEach(serverBlacklist -> commands.addAll(serverBlacklist.getCommands()));
+        }
+
+        final String serverName = tempServerName;
+        List<TinyGroup> groups = new ArrayList<>();
+
+        TinyGroup tinyGroup;
+        for (Group group : GroupManager.getGroups()) {
+            if(groups.stream().anyMatch(cTG -> cTG.getGroupName().equals(group.getGroupName()))) continue;
+
+            tinyGroup = new TinyGroup(group.getGroupName(), group.getPriority(), group.getAllCommands(serverName));
+            for (GroupBlacklist groupBlacklist : group.getAllServerGroupBlacklist(serverName))
+                tinyGroup.addAll(groupBlacklist.getCommands());
+
+            groups.add(tinyGroup);
+        }
+
+        groupsPacket = new CommunicationPackets.GroupsPacket(groups);
+        commandsPacket.setTurnBlacklistToWhitelist(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED);
+        commandsPacket.setCommands(commands);
+
+        bundle = new CommunicationPackets.PacketBundle(Storage.TOKEN, serverId, commandsPacket, groupsPacket);
+        clientInfo.sendBytes(CommunicationPackets.convertToBytes(bundle));
+
+        PATEventHandler.callSentSyncEvents(bundle, serverName);
+    }
+
+    public static void sendRequest() {
+        if(System.currentTimeMillis() - LAST_SENT_REQUEST >= 5000) {
+            LAST_SENT_REQUEST = System.currentTimeMillis();
+            sendPacket(new CommunicationPackets.RequestPacket(Storage.TOKEN, SERVER_ID.toString()));
+        }
+    }
+
+    public static void sendPermissionReset() {
+        if(Reflection.isProxyServer())
+            sendPacket(new CommunicationPackets.ForcePermissionResetPacket(Storage.TOKEN));
+    }
+
+    public static void sendFeedback(UUID targetUUID) {
+        if(Reflection.isProxyServer())
+            sendPacket(new CommunicationPackets.ForcePermissionResetPacket(Storage.TOKEN, targetUUID));
+    }
+
+    public static void sendFeedback() {
+        sendPacket(new CommunicationPackets.FeedbackPacket(Storage.TOKEN, SERVER_ID.toString()));
+    }
+
+    public static Client getClient() {
+        return CLIENT;
+    }
+
+    public static ClientInfo getClientById(String id) {
+        return CLIENTS.isEmpty() ? null : CLIENTS.stream().filter(client -> client != null && client.compareId(id)).findFirst().orElse(null);
+    }
+
+    public static ClientInfo getClientByName(String name) {
+        return CLIENTS.isEmpty() ? null : CLIENTS.stream().filter(client -> client != null && client.getName().equalsIgnoreCase(name)).findFirst().orElse(null);
+    }
+
+    public static ClientInfo getQueueClientById(String id) {
+        return QUEUE_CLIENTS.get(id);
+    }
+
+    public static void resetAllFeedbacks() {
+        CLIENTS.forEach(client -> client.setFeedback(false));
+    }
+
+    public static List<String> getRegisteredServerNames() {
+        List<String> result = new ArrayList<>();
+        CLIENTS.stream().filter(client -> client != null && client.getName() != null).forEach(client -> result.add(client.getName()));
+        return result;
+    }
+}

src/main/java/de/rayzs/pat/api/communication/client/ClientInfo.java

@@ -0,0 +1,58 @@
+package de.rayzs.pat.api.communication.client;
+
+import de.rayzs.pat.utils.TimeConverter;
+
+public abstract class ClientInfo {
+
+    private String id, name;
+
+    private boolean sentFeedback = false;
+    private long syncTime = System.currentTimeMillis();
+
+    public ClientInfo(String serverId) {
+        this.id = serverId;
+    }
+
+    public ClientInfo(String serverId, String name) {
+        this.id = serverId;
+        this.name = name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setId(String serverId) {
+        this.id = serverId;
+    }
+
+    public abstract void sendBytes(byte[] bytes);
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean compareId(String id) {
+        return this.id.equals(id);
+    }
+
+    public void syncTime() {
+        syncTime = System.currentTimeMillis();
+    }
+
+    public String getSyncTime() {
+        return TimeConverter.calcAndGetTime(syncTime);
+    }
+
+    public void setFeedback(boolean state) {
+        this.sentFeedback = state;
+    }
+
+    public boolean hasSentFeedback() {
+        return sentFeedback;
+    }
+
+    public String getId() {
+        return id;
+    }
+}

src/main/java/de/rayzs/pat/api/communication/client/impl/BungeeClientInfo.java

@@ -0,0 +1,52 @@
+package de.rayzs.pat.api.communication.client.impl;
+
+import de.rayzs.pat.api.communication.client.ClientInfo;
+import de.rayzs.pat.api.communication.Client;
+import net.md_5.bungee.api.ProxyServer;
+
+public class BungeeClientInfo extends ClientInfo {
+
+    public BungeeClientInfo(String serverId) {
+        super(serverId);
+    }
+
+    public BungeeClientInfo(String serverId, String name) {
+        super(serverId, name);
+    }
+
+    @Override
+    public void sendBytes(byte[] bytes) {
+        ProxyServer.getInstance().getServers().entrySet().stream().filter(entry -> entry.getKey().equalsIgnoreCase(getName())).forEach(entry -> entry.getValue().sendData(Client.CHANNEL_NAME, bytes));
+    }
+
+    @Override
+    public String getId() {
+        return super.getId();
+    }
+
+    @Override
+    public String getName() {
+        return super.getName();
+    }
+
+    @Override
+    public String getSyncTime() {
+        return super.getSyncTime();
+    }
+
+    @Override
+    public void setFeedback(boolean state) {
+        super.setFeedback(state);
+    }
+
+    @Override
+    public void setId(String serverId) {
+        super.setId(serverId);
+    }
+
+    @Override
+    public void setName(String name) {
+        super.setName(name);
+    }
+}
+

src/main/java/de/rayzs/pat/api/communication/client/impl/VelocityClientInfo.java

@@ -0,0 +1,51 @@
+package de.rayzs.pat.api.communication.client.impl;
+
+import de.rayzs.pat.api.communication.impl.VelocityClient;
+import de.rayzs.pat.api.communication.client.ClientInfo;
+import de.rayzs.pat.plugin.VelocityLoader;
+
+public class VelocityClientInfo extends ClientInfo {
+
+    public VelocityClientInfo(String serverId) {
+        super(serverId);
+    }
+
+    public VelocityClientInfo(String serverId, String name) {
+        super(serverId, name);
+    }
+
+    @Override
+    public void sendBytes(byte[] bytes) {
+        VelocityLoader.getServer().getAllServers().stream().filter(server -> server.getServerInfo().getName().equalsIgnoreCase(getName())).forEach(server -> server.sendPluginMessage(VelocityClient.getIdentifier(), bytes));
+    }
+
+    @Override
+    public String getId() {
+        return super.getId();
+    }
+
+    @Override
+    public String getName() {
+        return super.getName();
+    }
+
+    @Override
+    public String getSyncTime() {
+        return super.getSyncTime();
+    }
+
+    @Override
+    public void setFeedback(boolean state) {
+        super.setFeedback(state);
+    }
+
+    @Override
+    public void setId(String serverId) {
+        super.setId(serverId);
+    }
+
+    @Override
+    public void setName(String name) {
+        super.setName(name);
+    }
+}

src/main/java/de/rayzs/pat/api/communication/impl/BukkitClient.java

@@ -0,0 +1,36 @@
+package de.rayzs.pat.api.communication.impl;
+
+import de.rayzs.pat.utils.scheduler.PATScheduler;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import de.rayzs.pat.utils.CommunicationPackets;
+import de.rayzs.pat.plugin.BukkitLoader;
+import de.rayzs.pat.api.communication.*;
+import org.bukkit.entity.Player;
+import org.bukkit.*;
+
+public class BukkitClient implements Client, PluginMessageListener {
+
+    private static final Server SERVER = Bukkit.getServer();
+
+    public BukkitClient() {
+        SERVER.getMessenger().registerIncomingPluginChannel(BukkitLoader.getPlugin(), CHANNEL_NAME, this);
+        SERVER.getMessenger().registerOutgoingPluginChannel(BukkitLoader.getPlugin(), CHANNEL_NAME);
+    }
+
+    @Override
+    public void send(Object packet) {
+        try { SERVER.sendPluginMessage(BukkitLoader.getPlugin(), CHANNEL_NAME, CommunicationPackets.convertToBytes(packet));
+        } catch (Throwable throwable) { throwable.printStackTrace(); }
+    }
+
+    @Override
+    public void onPluginMessageReceived(String channel, Player player, byte[] bytes) {
+        if(!channel.equals(CHANNEL_NAME)) return;
+        try {
+            Object packetObj = CommunicationPackets.buildFromBytes(bytes);
+            if(!CommunicationPackets.isPacket(packetObj)) return;
+
+            PATScheduler.createScheduler(() -> Communicator.receiveInformation("proxy", packetObj));
+        } catch (Throwable throwable) { throwable.printStackTrace(); }
+    }
+}

src/main/java/de/rayzs/pat/api/communication/impl/BungeeClient.java

@@ -0,0 +1,41 @@
+package de.rayzs.pat.api.communication.impl;
+
+import net.md_5.bungee.api.event.PluginMessageEvent;
+import de.rayzs.pat.utils.CommunicationPackets;
+import net.md_5.bungee.api.connection.Server;
+import net.md_5.bungee.api.config.ServerInfo;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+import de.rayzs.pat.plugin.BungeeLoader;
+import de.rayzs.pat.api.communication.*;
+import net.md_5.bungee.api.ProxyServer;
+
+public class BungeeClient implements Client, Listener {
+
+    private static final ProxyServer SERVER = ProxyServer.getInstance();
+
+    public BungeeClient() {
+        SERVER.registerChannel(CHANNEL_NAME);
+        SERVER.getPluginManager().registerListener(BungeeLoader.getPlugin(), this);
+    }
+
+    @Override
+    public void send(Object packet) {
+        for(ServerInfo serverInfo : ProxyServer.getInstance().getServers().values()) {
+            try { serverInfo.sendData(CHANNEL_NAME, CommunicationPackets.convertToBytes(packet));
+            } catch (Throwable throwable) { throwable.printStackTrace(); }
+        }
+    }
+
+    @EventHandler
+    public void onQueryReceive(PluginMessageEvent event) {
+        if (!event.getTag().equalsIgnoreCase(CHANNEL_NAME)) return;
+        try {
+            Object packetObj = CommunicationPackets.buildFromBytes(event.getData());
+            if(!CommunicationPackets.isPacket(packetObj)) return;
+
+            Server server = (Server) event.getSender();
+            Communicator.receiveInformation(server.getInfo().getName().toLowerCase(), packetObj);
+        } catch (Throwable throwable) { throwable.printStackTrace(); }
+    }
+}

src/main/java/de/rayzs/pat/api/communication/impl/VelocityClient.java

@@ -0,0 +1,43 @@
+package de.rayzs.pat.api.communication.impl;
+
+import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
+import com.velocitypowered.api.event.connection.PluginMessageEvent;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import de.rayzs.pat.utils.CommunicationPackets;
+import com.velocitypowered.api.event.Subscribe;
+import de.rayzs.pat.plugin.VelocityLoader;
+import de.rayzs.pat.api.communication.*;
+import com.velocitypowered.api.proxy.*;
+
+public class VelocityClient implements Client {
+
+    private static final ProxyServer SERVER = VelocityLoader.getServer();
+    private static final MinecraftChannelIdentifier IDENTIFIER = MinecraftChannelIdentifier.from(CHANNEL_NAME);
+
+    public VelocityClient() {
+        SERVER.getChannelRegistrar().register(IDENTIFIER);
+        SERVER.getEventManager().register(VelocityLoader.getInstance(), this);
+    }
+
+    @Override
+    public void send(Object packet) {
+        for (RegisteredServer registeredServer : SERVER.getAllServers()) {
+            try { registeredServer.sendPluginMessage(IDENTIFIER, CommunicationPackets.convertToBytes(packet));
+            } catch (Throwable throwable) { throwable.printStackTrace(); }
+        }
+    }
+
+    @Subscribe
+    public void onQueryReceive(PluginMessageEvent event) {
+        if (event.getIdentifier() != IDENTIFIER) return;
+        Object packetObj = CommunicationPackets.buildFromBytes(event.getData());
+        if(!CommunicationPackets.isPacket(packetObj)) return;
+
+        ServerConnection server = (ServerConnection) event.getSource();
+        Communicator.receiveInformation(server.getServerInfo().getName().toLowerCase(), packetObj);
+    }
+
+    public static MinecraftChannelIdentifier getIdentifier() {
+        return IDENTIFIER;
+    }
+}

src/main/java/de/rayzs/pat/api/event/PATEvent.java

@@ -0,0 +1,24 @@
+package de.rayzs.pat.api.event;
+
+public abstract class PATEvent<T> {
+
+    private final Object senderObj;
+    private boolean cancelled = false;
+
+    public PATEvent(Object senderObj) {
+        this.senderObj = senderObj;
+    }
+
+    public abstract void handle(T t);
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+    public Object getSenderObj() {
+        return senderObj;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+}

src/main/java/de/rayzs/pat/api/event/PATEventHandler.java

@@ -0,0 +1,199 @@
+package de.rayzs.pat.api.event;
+
+import de.rayzs.pat.api.event.events.*;
+import de.rayzs.pat.utils.CommunicationPackets;
+
+import java.util.*;
+
+public class PATEventHandler {
+
+    private static List<PATEvent> EVENTS = new ArrayList<>();
+
+    public static ExecuteCommandEvent callExecuteCommandEvents(Object senderObj, String command, boolean blocked) {
+        ExecuteCommandEvent event = EmptyEvent.createEmptyExecuteCommandEvent(senderObj, command, blocked);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof ExecuteCommandEvent) {
+                ExecuteCommandEvent executeCommandEvent = (ExecuteCommandEvent) patEvent;
+                executeCommandEvent.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static FilteredSuggestionEvent callFilteredSuggestionEvents(Object senderObj, List<String> suggestions) {
+        FilteredSuggestionEvent event = EmptyEvent.createEmptyFilteredSuggestionEvent(senderObj, suggestions);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof FilteredSuggestionEvent) {
+                FilteredSuggestionEvent filteredSuggestion = (FilteredSuggestionEvent) patEvent;
+                filteredSuggestion.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static FilteredTabCompletionEvent callFilteredTabCompletionEvents(Object senderObj, String cursor, List<String> completion) {
+        FilteredTabCompletionEvent event = EmptyEvent.createEmptyFilteredTabCompletion(senderObj, cursor, completion);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof FilteredTabCompletionEvent) {
+                FilteredTabCompletionEvent filteredTabCompletion = (FilteredTabCompletionEvent) patEvent;
+                filteredTabCompletion.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static ServerPlayersChangeEvent callServerPlayersChangeEvents(Object senderObj, ServerPlayersChangeEvent.Type type) {
+        ServerPlayersChangeEvent event = EmptyEvent.createEmptyServerPlayersChangeEvent(senderObj, type);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof ServerPlayersChangeEvent) {
+                ServerPlayersChangeEvent serverPlayersChangeEvent = (ServerPlayersChangeEvent) patEvent;
+                serverPlayersChangeEvent.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static UpdatePluginEvent callUpdatePluginEvents() {
+        UpdatePluginEvent event = EmptyEvent.createEmptyUpdatePluginEvent();
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof UpdatePluginEvent) {
+                UpdatePluginEvent updatePluginEvent = (UpdatePluginEvent) patEvent;
+                updatePluginEvent.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static UpdatePlayerCommandsEvent callUpdatePlayerCommandsEvents(Object playerObj, List<String> commands, boolean serverBased) {
+        UpdatePlayerCommandsEvent event = EmptyEvent.createEmptyUpdatePlayerCommandsEvent(playerObj, commands, serverBased);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof UpdatePlayerCommandsEvent) {
+                UpdatePlayerCommandsEvent updatePlayerCommandsEvent = (UpdatePlayerCommandsEvent) patEvent;
+                updatePlayerCommandsEvent.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static SentSyncEvent callSentSyncEvents(CommunicationPackets.PacketBundle packetBundle, String serverName) {
+        SentSyncEvent event = EmptyEvent.createEmptySentSyncEvent(packetBundle, serverName);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof SentSyncEvent) {
+                SentSyncEvent sentSyncEvent = (SentSyncEvent) patEvent;
+                sentSyncEvent.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static ReceiveSyncEvent callReceiveSyncEvents(CommunicationPackets.PacketBundle packetBundle) {
+        ReceiveSyncEvent event = EmptyEvent.createEmptyReceiveSyncEvent(packetBundle);
+
+        for (PATEvent patEvent : EVENTS) {
+            if(patEvent instanceof ReceiveSyncEvent) {
+                ReceiveSyncEvent proxySyncEvent = (ReceiveSyncEvent) patEvent;
+                proxySyncEvent.handle(event);
+            }
+        }
+
+        return event;
+    }
+
+    public static void register(PATEvent event) {
+        EVENTS.add(event);
+    }
+
+    public static void unregister(PATEvent event) {
+        EVENTS.remove(event);
+    }
+
+    public static class EmptyEvent {
+
+        public static ServerPlayersChangeEvent createEmptyServerPlayersChangeEvent(Object senderObj, ServerPlayersChangeEvent.Type type) {
+            return new ServerPlayersChangeEvent(senderObj, type) {
+                @Override
+                public void handle(ServerPlayersChangeEvent event) {
+
+                }
+            };
+        }
+
+        public static SentSyncEvent createEmptySentSyncEvent(CommunicationPackets.PacketBundle packetBundle, String serverName) {
+            return new SentSyncEvent(null, packetBundle, serverName) {
+                @Override
+                public void handle(SentSyncEvent event) {
+
+                }
+            };
+        }
+
+        public static ReceiveSyncEvent createEmptyReceiveSyncEvent(CommunicationPackets.PacketBundle packetBundle) {
+            return new ReceiveSyncEvent(null, packetBundle) {
+                @Override
+                public void handle(ReceiveSyncEvent event) {
+
+                }
+            };
+        }
+
+        public static UpdatePlayerCommandsEvent createEmptyUpdatePlayerCommandsEvent(Object playerObj, List<String> commands, boolean serverBased) {
+            return new UpdatePlayerCommandsEvent(playerObj, commands, serverBased) {
+                @Override
+                public void handle(UpdatePlayerCommandsEvent event) {
+
+                }
+            };
+        }
+
+        public static UpdatePluginEvent createEmptyUpdatePluginEvent() {
+            return new UpdatePluginEvent(null) {
+                @Override
+                public void handle(UpdatePluginEvent event) {
+
+                }
+            };
+        }
+
+        public static ExecuteCommandEvent createEmptyExecuteCommandEvent(Object senderObj, String command, boolean blocked) {
+            return new ExecuteCommandEvent(senderObj, command, blocked) {
+                @Override
+                public void handle(ExecuteCommandEvent event) {
+
+                }
+            };
+        }
+
+        public static FilteredSuggestionEvent createEmptyFilteredSuggestionEvent(Object senderObj, List<String> suggestions) {
+            return new FilteredSuggestionEvent(senderObj, suggestions) {
+                @Override
+                public void handle(FilteredSuggestionEvent event) {
+
+                }
+            };
+        }
+
+        public static FilteredTabCompletionEvent createEmptyFilteredTabCompletion(Object senderObj, String cursor, List<String> completion) {
+            return new FilteredTabCompletionEvent(senderObj, cursor, completion) {
+                @Override
+                public void handle(FilteredTabCompletionEvent event) {
+
+                }
+            };
+        }
+
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/ExecuteCommandEvent.java

@@ -0,0 +1,33 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.api.event.PATEvent;
+
+public abstract class ExecuteCommandEvent extends PATEvent<ExecuteCommandEvent> {
+
+    private final String command;
+    private boolean blocked;
+
+    public ExecuteCommandEvent() {
+        super(null);
+        this.blocked = false;
+        this.command = null;
+    }
+
+    public ExecuteCommandEvent(Object senderObj, String command, boolean blocked) {
+        super(senderObj);
+        this.blocked = blocked;
+        this.command = command;
+    }
+
+    public String getCommand() {
+        return command;
+    }
+
+    public boolean isBlocked() {
+        return blocked;
+    }
+
+    public void setBlocked(boolean blocked) {
+        this.blocked = blocked;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/FilteredSuggestionEvent.java

@@ -0,0 +1,27 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.api.event.PATEvent;
+import java.util.*;
+
+public abstract class FilteredSuggestionEvent extends PATEvent<FilteredSuggestionEvent> {
+
+    private List<String> suggestions;
+
+    public FilteredSuggestionEvent() {
+        super(null);
+        this.suggestions = null;
+    }
+
+    public FilteredSuggestionEvent(Object senderObj, List<String> suggestions) {
+        super(senderObj);
+        this.suggestions = suggestions;
+    }
+
+    public List<String> getSuggestions() {
+        return suggestions;
+    }
+
+    public void setSuggestions(List<String> suggestions) {
+        this.suggestions = suggestions;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/FilteredTabCompletionEvent.java

@@ -0,0 +1,36 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.api.event.PATEvent;
+import java.util.*;
+
+public abstract class FilteredTabCompletionEvent extends PATEvent<FilteredTabCompletionEvent> {
+
+    private String cursor;
+    private List<String> completion;
+
+    public FilteredTabCompletionEvent() {
+        super(null);
+        this.cursor = null;
+        this.completion = null;
+    }
+
+    public FilteredTabCompletionEvent(Object senderObj, String cursor, List<String> completion) {
+        super(senderObj);
+        this.cursor = cursor;
+        this.completion = completion;
+    }
+
+    public abstract void handle(FilteredTabCompletionEvent event);
+
+    public String getCursor() {
+        return cursor;
+    }
+
+    public List<String> getCompletion() {
+        return completion;
+    }
+
+    public void setCompletion(List<String> completion) {
+        this.completion = completion;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/ReceiveSyncEvent.java

@@ -0,0 +1,23 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.utils.CommunicationPackets;
+import de.rayzs.pat.api.event.PATEvent;
+
+public abstract class ReceiveSyncEvent extends PATEvent<ReceiveSyncEvent> {
+
+    private final CommunicationPackets.PacketBundle packetBundle;
+
+    public ReceiveSyncEvent() {
+        super(null);
+        this.packetBundle = null;
+    }
+
+    public ReceiveSyncEvent(Object senderObj, CommunicationPackets.PacketBundle packetBundle) {
+        super(senderObj);
+        this.packetBundle = packetBundle;
+    }
+
+    public CommunicationPackets.PacketBundle getPacketBundle() {
+        return packetBundle;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/SentSyncEvent.java

@@ -0,0 +1,30 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.utils.CommunicationPackets;
+import de.rayzs.pat.api.event.PATEvent;
+
+public abstract class SentSyncEvent extends PATEvent<SentSyncEvent> {
+
+    private final CommunicationPackets.PacketBundle packetBundle;
+    private final String serverName;
+
+    public SentSyncEvent() {
+        super(null);
+        this.packetBundle = null;
+        this.serverName = null;
+    }
+
+    public SentSyncEvent(Object senderObj, CommunicationPackets.PacketBundle packetBundle, String serverName) {
+        super(senderObj);
+        this.packetBundle = packetBundle;
+        this.serverName = serverName;
+    }
+
+    public String getServerName() {
+        return serverName;
+    }
+
+    public CommunicationPackets.PacketBundle getPacketBundle() {
+        return packetBundle;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/ServerPlayersChangeEvent.java

@@ -0,0 +1,20 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.api.event.PATEvent;
+
+public abstract class ServerPlayersChangeEvent extends PATEvent<ServerPlayersChangeEvent> {
+
+    private final Type type;
+
+    public ServerPlayersChangeEvent(Object senderObj, Type type) {
+        super(senderObj);
+        this.type = type;
+    }
+
+    public ServerPlayersChangeEvent() {
+        super(null);
+        this.type = Type.UNKNOWN;
+    }
+
+    public enum Type { JOINED, LEFT, UNKNOWN }
+}

src/main/java/de/rayzs/pat/api/event/events/UpdatePlayerCommandsEvent.java

@@ -0,0 +1,28 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.api.event.PATEvent;
+import java.util.List;
+
+public abstract class UpdatePlayerCommandsEvent extends PATEvent<UpdatePlayerCommandsEvent> {
+
+    private List<String> commands;
+    private boolean serverBased;
+
+    public UpdatePlayerCommandsEvent() {
+        super(null);;
+    }
+
+    public UpdatePlayerCommandsEvent(Object senderObj, List<String> commands, boolean serverBased) {
+        super(senderObj);
+        this.commands = commands;
+        this.serverBased = serverBased;
+    }
+
+    public List<String> getCommands() {
+        return commands;
+    }
+
+    public boolean isServerBased() {
+        return serverBased;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/UpdatePluginEvent.java

@@ -0,0 +1,14 @@
+package de.rayzs.pat.api.event.events;
+
+import de.rayzs.pat.api.event.PATEvent;
+
+public abstract class UpdatePluginEvent extends PATEvent<UpdatePluginEvent> {
+
+    public UpdatePluginEvent() {
+        super(null);;
+    }
+
+    public UpdatePluginEvent(Object senderObj) {
+        super(senderObj);
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/bukkit/ExecuteCommandEvent.java

@@ -0,0 +1,43 @@
+package de.rayzs.pat.api.event.events.bukkit;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+
+public abstract class ExecuteCommandEvent extends Event implements Cancellable {
+
+    private final String command;
+    private boolean blocked;
+
+    public ExecuteCommandEvent() {
+        this.blocked = false;
+        this.command = null;
+    }
+
+    public ExecuteCommandEvent(Player player, String command, boolean blocked) {
+        this.blocked = blocked;
+        this.command = command;
+    }
+
+    public String getCommand() {
+        return command;
+    }
+
+    public boolean isBlocked() {
+        return blocked;
+    }
+
+    public void setBlocked(boolean blocked) {
+        this.blocked = blocked;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return blocked;
+    }
+
+    @Override
+    public void setCancelled(boolean cancel) {
+        this.blocked = cancel;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/bukkit/FilteredSuggestionEvent.java

@@ -0,0 +1,26 @@
+package de.rayzs.pat.api.event.events.bukkit;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import java.util.List;
+
+public abstract class FilteredSuggestionEvent extends Event {
+
+    private List<String> suggestions;
+
+    public FilteredSuggestionEvent() {
+        this.suggestions = null;
+    }
+
+    public FilteredSuggestionEvent(Player player, List<String> suggestions) {
+        this.suggestions = suggestions;
+    }
+
+    public List<String> getSuggestions() {
+        return suggestions;
+    }
+
+    public void setSuggestions(List<String> suggestions) {
+        this.suggestions = suggestions;
+    }
+}

src/main/java/de/rayzs/pat/api/event/events/bukkit/FilteredTabCompletionEvent.java

@@ -0,0 +1,35 @@
+package de.rayzs.pat.api.event.events.bukkit;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import java.util.List;
+
+public abstract class FilteredTabCompletionEvent extends Event {
+
+    private String cursor;
+    private List<String> completion;
+
+    public FilteredTabCompletionEvent() {
+        this.cursor = null;
+        this.completion = null;
+    }
+
+    public FilteredTabCompletionEvent(Player player, String cursor, List<String> completion) {
+        this.cursor = cursor;
+        this.completion = completion;
+    }
+
+    public abstract void handle(FilteredTabCompletionEvent event);
+
+    public String getCursor() {
+        return cursor;
+    }
+
+    public List<String> getCompletion() {
+        return completion;
+    }
+
+    public void setCompletion(List<String> completion) {
+        this.completion = completion;
+    }
+}

src/main/java/de/rayzs/pat/api/netty/bukkit/BukkitPacketAnalyzer.java

@@ -0,0 +1,139 @@
+package de.rayzs.pat.api.netty.bukkit;
+
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.api.netty.bukkit.handlers.*;
+import java.util.concurrent.ConcurrentHashMap;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.ExpireCache;
+import de.rayzs.pat.utils.Reflection;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.entity.Player;
+import io.netty.channel.*;
+import org.bukkit.Bukkit;
+import java.util.*;
+
+public class BukkitPacketAnalyzer {
+
+    public static final ConcurrentHashMap<UUID, Channel> INJECTED_PLAYERS = new ConcurrentHashMap<>();
+    private static final ExpireCache<UUID, Object> SENT_PACKET = new ExpireCache<>(2, TimeUnit.SECONDS);
+
+    private static final String HANDLER_NAME = "pat-bukkit-handler", PIPELINE_NAME = "packet_handler";
+    private static final BukkitPacketHandler PACKET_HANDLER = Reflection.getMinor() >= 16 ? new ModernPacketHandler() : new LegacyPacketHandler();
+    private static final HashMap<Player, String> PLAYER_INPUT_CACHE = new HashMap<>();
+
+    public static void injectAll() {
+        Bukkit.getOnlinePlayers().forEach(BukkitPacketAnalyzer::inject);
+    }
+
+    public static void uninjectAll() {
+        BukkitPacketAnalyzer.INJECTED_PLAYERS.keySet().forEach(BukkitPacketAnalyzer::uninject);
+        BukkitPacketAnalyzer.INJECTED_PLAYERS.clear();
+    }
+
+    public static void sendPacket(UUID uuid, Object object) {
+        Channel channel = INJECTED_PLAYERS.get(uuid);
+        if(channel == null) return;
+
+        SENT_PACKET.put(uuid, object);
+        channel.pipeline().writeAndFlush(object);
+    }
+
+    public static boolean inject(Player player) {
+        if(Storage.USE_VELOCITY) return true;
+
+        try {
+            Channel channel = Reflection.getPlayerChannel(player);
+            if(channel == null) {
+                System.err.println("Failed to inject " + player.getName() + "! Channel is null.");
+                return false;
+            }
+
+            if(channel.pipeline().names().contains(BukkitPacketAnalyzer.HANDLER_NAME))
+                uninject(channel);
+
+            channel.pipeline().addBefore(BukkitPacketAnalyzer.PIPELINE_NAME, BukkitPacketAnalyzer.HANDLER_NAME, new PacketDecoder(player));
+            BukkitPacketAnalyzer.INJECTED_PLAYERS.put(player.getUniqueId(), channel);
+        } catch (Throwable throwable) {
+            throwable.printStackTrace();
+            return false;
+        } return true;
+    }
+
+    public static void uninject(UUID uuid) {
+        if(Storage.USE_VELOCITY) return;
+
+        if(BukkitPacketAnalyzer.INJECTED_PLAYERS.containsKey(uuid)) {
+            Channel channel = BukkitPacketAnalyzer.INJECTED_PLAYERS.get(uuid);
+            uninject(channel);
+        }
+    }
+
+    public static void uninject(Channel channel) {
+        if(Storage.USE_VELOCITY) return;
+
+        if(channel != null) {
+            channel.eventLoop().submit(() -> {
+                ChannelPipeline pipeline = channel.pipeline();
+                if (pipeline.names().contains(BukkitPacketAnalyzer.HANDLER_NAME)) pipeline.remove(BukkitPacketAnalyzer.HANDLER_NAME);
+            });
+        }
+    }
+
+    public static String getPlayerInput(Player player) {
+        String input = PLAYER_INPUT_CACHE.get(player);
+        PLAYER_INPUT_CACHE.remove(player);
+        return input;
+    }
+
+    public static void insertPlayerInput(Player player, String text) {
+        PLAYER_INPUT_CACHE.put(player, text);
+    }
+
+    private static class PacketDecoder extends ChannelDuplexHandler {
+
+        private final Player player;
+        private PacketDecoder(Player player) {
+            this.player = player;
+        }
+
+        @Override
+        public void channelRead(ChannelHandlerContext channel, Object packetObj) {
+            try {
+                if (!PermissionUtil.hasBypassPermission(player) && packetObj.getClass() != null) {
+                    String packetName = packetObj.getClass().getSimpleName();
+
+                    if (packetName.equals("PacketPlayInTabComplete") || packetName.equals("ServerboundCommandSuggestionPacket")) {
+                        if (!PACKET_HANDLER.handleIncomingPacket(player, packetObj)) return;
+                    }
+                }
+
+                super.channelRead(channel, packetObj);
+            } catch (Throwable exception) { exception.printStackTrace(); }
+        }
+
+        @Override
+        public void write(ChannelHandlerContext channel, Object packetObj, ChannelPromise promise) {
+            try {
+                if(packetObj.getClass() != null)
+                    if (!PermissionUtil.hasBypassPermission(player)) {
+                        String packetName = packetObj.getClass().getSimpleName();
+                        if (packetName.equals("PacketPlayOutTabComplete") || packetName.equals("ClientboundCommandSuggestionsPacket")) {
+
+                            UUID uuid = player.getUniqueId();
+
+                            if((packetName.equals("ClientboundCommandSuggestionsPacket") || Reflection.isFoliaServer()) && SENT_PACKET.contains(player.getUniqueId())) {
+                                Object newPacketObj = SENT_PACKET.get(uuid);
+                                SENT_PACKET.remove(uuid);
+                                super.write(channel, newPacketObj, promise);
+                                return;
+                            }
+
+                            if(!PACKET_HANDLER.handleOutgoingPacket(player, packetObj)) return;
+                        }
+                    }
+
+                super.write(channel, packetObj, promise);
+            } catch (Throwable exception) { exception.printStackTrace(); }
+        }
+    }
+}

src/main/java/de/rayzs/pat/api/netty/bukkit/BukkitPacketHandler.java

@@ -0,0 +1,8 @@
+package de.rayzs.pat.api.netty.bukkit;
+
+import org.bukkit.entity.Player;
+
+public interface BukkitPacketHandler {
+    boolean handleIncomingPacket(Player player, Object packetObj) throws Exception;
+    boolean handleOutgoingPacket(Player player, Object packetObj) throws Exception;
+}

src/main/java/de/rayzs/pat/api/netty/bukkit/handlers/LegacyPacketHandler.java

@@ -0,0 +1,89 @@
+package de.rayzs.pat.api.netty.bukkit.handlers;
+
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.api.event.events.FilteredTabCompletionEvent;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BukkitLoader;
+import de.rayzs.pat.api.netty.bukkit.*;
+import org.bukkit.entity.Player;
+import java.lang.reflect.Field;
+import de.rayzs.pat.utils.*;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class LegacyPacketHandler implements BukkitPacketHandler {
+
+    @Override
+    public boolean handleIncomingPacket(Player player, Object packetObj) throws Exception {
+        Field stringField = Reflection.getFirstFieldByType(packetObj.getClass(), "String", Reflection.SearchOption.ENDS);
+        if(stringField == null) {
+            Logger.warning("Failed PacketAnalyze process! (#1)");
+            return false;
+        }
+
+        String text = (String) stringField.get(packetObj);
+        BukkitPacketAnalyzer.insertPlayerInput(player, text);
+        return true;
+    }
+
+    @Override
+    public boolean handleOutgoingPacket(Player player, Object packetObj) throws Exception {
+        String input = BukkitPacketAnalyzer.getPlayerInput(player);
+
+        if(input == null) return false;
+
+        boolean cancelsBeforeHand;
+        int spaces = 0;
+
+        if(input.startsWith("/")) {
+            input = input.replace("/", "");
+            if(input.contains(" ")) {
+                String[] split = input.split(" ");
+                spaces = split.length;
+                if(spaces > 0) input = split[0];
+            }
+
+            cancelsBeforeHand = Storage.Blacklist.isBlocked(player, input, !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED);
+            if(!cancelsBeforeHand) cancelsBeforeHand = Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(input) || Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(input);
+        } else return true;
+
+        for (Field field : Reflection.getFields(packetObj)) {
+            field.setAccessible(true);
+            Object result = field.get(packetObj);
+
+            if (!(result instanceof String[])) continue;
+            List<String> newResultList = new ArrayList<>();
+            String[] tR = (String[]) result;
+
+            String tempName;
+
+            if(spaces == 0) {
+                for (String s : tR) {
+                    if(!BukkitLoader.isLoaded()) continue;
+                    if(!s.startsWith("/")) {
+                        newResultList.add(s);
+                        continue;
+                    }
+
+                    tempName = s.replaceFirst("/", "");
+
+                    if (!Storage.Blacklist.isBlocked(player, tempName, !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED))
+                        newResultList.add(s);
+                }
+            } else {
+                if(!cancelsBeforeHand) {
+                    FilteredTabCompletionEvent filteredTabCompletionEvent = PATEventHandler.callFilteredTabCompletionEvents(player.getUniqueId(), input, Arrays.asList(tR));
+                    if(!filteredTabCompletionEvent.isCancelled()) {
+                        List<String> suggestions = Arrays.stream(tR).filter(s -> filteredTabCompletionEvent.getCompletion().contains(s)).collect(Collectors.toList());
+                        newResultList.addAll(suggestions);
+                    }
+                }
+            }
+
+            field.set(packetObj, newResultList.toArray(new String[0]));
+        }
+
+        return true;
+    }
+}

src/main/java/de/rayzs/pat/api/netty/bukkit/handlers/ModernPacketHandler.java

@@ -0,0 +1,173 @@
+package de.rayzs.pat.api.netty.bukkit.handlers;
+
+import de.rayzs.pat.api.event.events.FilteredTabCompletionEvent;
+import de.rayzs.pat.api.event.PATEventHandler;
+import com.mojang.brigadier.suggestion.*;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BukkitLoader;
+import de.rayzs.pat.api.netty.bukkit.*;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.scheduler.PATScheduler;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import de.rayzs.pat.utils.*;
+import java.lang.reflect.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ModernPacketHandler implements BukkitPacketHandler {
+
+    @Override
+    public boolean handleIncomingPacket(Player player, Object packetObj) throws Exception {
+        Field stringField = Reflection.getFirstFieldByType(packetObj.getClass(), "String", Reflection.SearchOption.ENDS);
+
+        if(stringField == null) {
+            Logger.warning("Failed PacketAnalyze process! (#1)");
+            return false;
+        }
+
+        String text = (String) stringField.get(packetObj);
+        if(Storage.ConfigSections.Settings.PATCH_EXPLOITS.isMalicious(text)) {
+            MessageTranslator.send(Bukkit.getConsoleSender(), Storage.ConfigSections.Settings.PATCH_EXPLOITS.ALERT_MESSAGE.get().replace("%player%", player.getName()));
+            PATScheduler.createScheduler(() -> player.kickPlayer(ChatColor.translateAlternateColorCodes('&', Storage.ConfigSections.Settings.PATCH_EXPLOITS.KICK_MESSAGE.get())));
+            return false;
+        }
+
+        BukkitPacketAnalyzer.insertPlayerInput(player, text);
+        return true;
+    }
+
+    @Override
+    public boolean handleOutgoingPacket(Player player, Object packetObj) throws Exception {
+        Object suggestionObj;
+        String rawInput = BukkitPacketAnalyzer.getPlayerInput(player), input = rawInput;
+        if(input == null) return false;
+
+
+        boolean is121Packet = packetObj.getClass().getSimpleName().equals("ClientboundCommandSuggestionsPacket"),
+                cancelsBeforeHand = false;
+
+        int spaces = 0;
+        if(input.startsWith("/") || is121Packet) {
+            input = input.replace("/", "");
+            if(input.contains(" ")) {
+                String[] split = input.split(" ");
+                spaces = split.length;
+                if(spaces > 0) input = split[0];
+            }
+
+            cancelsBeforeHand = Storage.Blacklist.isBlocked(player, input, !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED);
+            if(!cancelsBeforeHand) cancelsBeforeHand = Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(input) || Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(input);
+        }
+
+        if(is121Packet || Reflection.isFoliaServer() && packetObj.getClass().getSimpleName().equals("PacketPlayOutTabComplete")) {
+            try {
+                Field suggestionsField = Reflection.getFieldsByTypeNormal(packetObj.getClass(), "List", Reflection.SearchOption.ENDS).get(0);
+                List<?> suggestionsTmp = (List<?>) suggestionsField.get(packetObj),
+                suggestions = new ArrayList<>(suggestionsTmp);
+
+                List<Field> intFields = Reflection.getFieldsByTypeNormal(packetObj.getClass(), "int", Reflection.SearchOption.ENDS);
+                int id = (int) intFields.get(0).get(packetObj),
+                        start = (int) intFields.get(1).get(packetObj),
+                        length = (int) intFields.get(2).get(packetObj);
+
+                Class<?> clientboundCommandSuggestionsPacketClass = Class.forName("net.minecraft.network.protocol.game."  + (packetObj.getClass().getSimpleName().equals("PacketPlayOutTabComplete") ? "PacketPlayOutTabComplete" : "ClientboundCommandSuggestionsPacket"));
+                if ((input.isEmpty() || cancelsBeforeHand) && Reflection.isWeird()) return false;
+                if (spaces >= 1 && cancelsBeforeHand || !BukkitLoader.isLoaded()) {
+                    suggestions.clear();
+                    return true;
+                }
+
+                if (spaces == 0) {
+                    suggestions.removeIf(suggestion -> {
+                        String command = getSuggestionFromEntry(suggestion);
+                        return Storage.Blacklist.isBlocked(player, command);
+                    });
+                    return true;
+
+                } else {
+                    List<String> suggestionsAsString = new ArrayList<>();
+                    for (Object suggestion : suggestions)
+                        suggestionsAsString.add(getSuggestionFromEntry(suggestion));
+
+                    FilteredTabCompletionEvent filteredTabCompletionEvent = PATEventHandler.callFilteredTabCompletionEvents(player.getUniqueId(), rawInput, suggestionsAsString);
+                    if (filteredTabCompletionEvent.isCancelled()) suggestions.clear();
+
+                    for (int i = 0; i < suggestions.size(); i++) {
+                        Object csO = suggestions.get(i);
+
+                        String suggestionAsString = getSuggestionFromEntry(csO);
+                        if (!filteredTabCompletionEvent.getCompletion().contains(suggestionAsString))
+                            suggestions.remove(csO);
+                    }
+
+                    suggestions.removeIf(suggestion -> !filteredTabCompletionEvent.getCompletion().contains(getSuggestionFromEntry(suggestion)));
+                }
+
+                if(!suggestions.isEmpty()) {
+                    Object clientboundCommandSuggestionsPacketObj = clientboundCommandSuggestionsPacketClass
+                            .getConstructor(int.class, int.class, int.class, List.class)
+                            .newInstance(id, start, length, suggestions);
+                    BukkitPacketAnalyzer.sendPacket(player.getUniqueId(), clientboundCommandSuggestionsPacketObj);
+                }
+
+                return false;
+
+            } catch (Throwable throwable) { throwable.printStackTrace(); }
+            return !cancelsBeforeHand;
+        }
+
+        if (Reflection.getMinor() < 17) {
+            Field suggestionsField = Reflection.getFieldsByType(packetObj.getClass(), "Suggestions", Reflection.SearchOption.ENDS).get(0);
+            if (suggestionsField == null) return false;
+            suggestionObj = suggestionsField.get(packetObj);
+        } else {
+            Method suggestionsMethod = Reflection.getMethodsByReturnType(packetObj.getClass(), "Suggestions", Reflection.SearchOption.ENDS).get(0);
+            if (suggestionsMethod == null) return false;
+            suggestionObj = suggestionsMethod.invoke(packetObj);
+        }
+
+        Suggestions suggestions = (Suggestions) suggestionObj;
+
+        if((input.isEmpty() || cancelsBeforeHand) && Reflection.isWeird()) return false;
+        if(spaces >= 1 && cancelsBeforeHand || !BukkitLoader.isLoaded()) {
+            suggestions.getList().clear();
+            return true;
+        }
+
+        if(spaces == 0) {
+            suggestions.getList().removeIf(suggestion -> {
+                String command = suggestion.getText();
+                return Storage.Blacklist.isBlocked(player, command);
+            });
+            return true;
+        } else {
+            List<String> suggestionsAsString = new ArrayList<>();
+            for (Suggestion suggestion : suggestions.getList())
+                suggestionsAsString.add(suggestion.getText());
+
+            FilteredTabCompletionEvent filteredTabCompletionEvent = PATEventHandler.callFilteredTabCompletionEvents(player.getUniqueId(), rawInput, suggestionsAsString);
+            if(filteredTabCompletionEvent.isCancelled()) suggestions.getList().clear();
+            suggestions.getList().removeIf(suggestion -> !filteredTabCompletionEvent.getCompletion().contains(suggestion.getText()));
+            return !suggestions.getList().isEmpty();
+        }
+    }
+
+    private String getSuggestionFromEntry(Object suggestionObj) {
+        try {
+            List<Field> fields = Reflection.getFieldsByTypeNormal(suggestionObj.getClass(), "String", Reflection.SearchOption.ENDS);
+            if(fields.isEmpty()) return "";
+
+            Field field = fields.get(0);
+            String result = (String) field.get(suggestionObj);
+            field.setAccessible(false);
+            return result;
+        } catch (Throwable throwable) {
+            throwable.printStackTrace();
+        }
+
+        return "";
+    }
+}

src/main/java/de/rayzs/pat/api/netty/proxy/BungeePacketAnalyzer.java

@@ -0,0 +1,249 @@
+package de.rayzs.pat.api.netty.proxy;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+import de.rayzs.pat.api.brand.CustomServerBrand;
+import de.rayzs.pat.api.communication.client.ClientInfo;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.MessageToMessageDecoder;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import de.rayzs.pat.api.communication.Communicator;
+import net.md_5.bungee.protocol.DefinedPacket;
+import net.md_5.bungee.protocol.PacketWrapper;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.ConcurrentHashMap;
+import com.mojang.brigadier.tree.CommandNode;
+import net.md_5.bungee.api.plugin.Command;
+import net.md_5.bungee.protocol.packet.*;
+import de.rayzs.pat.api.storage.Storage;
+import net.md_5.bungee.api.ProxyServer;
+import com.mojang.brigadier.builder.*;
+import java.lang.reflect.Field;
+import de.rayzs.pat.utils.*;
+import io.netty.channel.*;
+import java.util.*;
+
+public class BungeePacketAnalyzer {
+
+    public static final ConcurrentHashMap<ProxiedPlayer, Channel> INJECTED_PLAYERS = new ConcurrentHashMap<>();
+
+    private static final String HANDLER_NAME = "pat-bungee-handler", PIPELINE_NAME = "packet-decoder";
+    private static final HashMap<ProxiedPlayer, Boolean> PLAYER_MODIFIED = new HashMap<>();
+    private static final HashMap<ProxiedPlayer, String> PLAYER_INPUT_CACHE = new HashMap<>();
+
+    private static final com.mojang.brigadier.Command DUMMY_COMMAND = (context) -> 0;
+    private static final List<String> PLUGIN_COMMANDS = new ArrayList<>();
+
+    private static Class<?> channelWrapperClass, serverConnectionClass;
+
+    public static void injectAll() {
+        ProxyServer.getInstance().getPlayers().forEach(BungeePacketAnalyzer::inject);
+    }
+
+    public static void uninjectAll() {
+        BungeePacketAnalyzer.INJECTED_PLAYERS.keySet().forEach(BungeePacketAnalyzer::uninject);
+        BungeePacketAnalyzer.INJECTED_PLAYERS.clear();
+    }
+
+    public static void setPluginCommands() {
+        if(!PLUGIN_COMMANDS.isEmpty()) return;
+        ProxyServer.getInstance().getPluginManager().getCommands().stream().filter(entry -> !PLUGIN_COMMANDS.contains(entry.getKey())).forEach(entry -> PLUGIN_COMMANDS.add(entry.getKey()));
+    }
+
+    public static boolean inject(ProxiedPlayer player) {
+
+        if(channelWrapperClass == null)
+            channelWrapperClass = Reflection.getClass("net.md_5.bungee.netty.ChannelWrapper");
+
+        if(serverConnectionClass == null)
+            serverConnectionClass = Reflection.getClass("net.md_5.bungee.ServerConnection");
+
+        Object channelWrapperObj;
+        Field channelField;
+        Channel channel;
+
+        try {
+            channelField = Reflection.getFieldByName(serverConnectionClass, "ch");
+            channelWrapperObj = channelField.get(player.getServer());
+            channel = (Channel) Reflection.getFieldsByType(channelWrapperClass, "Channel", Reflection.SearchOption.ENDS).get(0).get(channelWrapperObj);
+
+            if(channel == null) {
+                System.err.println("Failed to inject " + player.getName() + "! Channel is null.");
+                return false;
+            }
+
+            channelField.setAccessible(false);
+
+            if(channel.pipeline().names().contains(BungeePacketAnalyzer.HANDLER_NAME))
+                uninject(player);
+
+            channel.pipeline().addAfter(BungeePacketAnalyzer.PIPELINE_NAME, BungeePacketAnalyzer.HANDLER_NAME, new PacketDecoder(player));
+            BungeePacketAnalyzer.INJECTED_PLAYERS.put(player, channel);
+        } catch (Throwable throwable) {
+            throwable.printStackTrace();
+            return false;
+        } return true;
+    }
+
+    public static void uninject(ProxiedPlayer player) {
+        BungeePacketAnalyzer.PLAYER_INPUT_CACHE.remove(player);
+        BungeePacketAnalyzer.PLAYER_MODIFIED.remove(player);
+
+        if(BungeePacketAnalyzer.INJECTED_PLAYERS.containsKey(player)) {
+            Channel channel = BungeePacketAnalyzer.INJECTED_PLAYERS.get(player);
+            if(channel != null) {
+                BungeePacketAnalyzer.INJECTED_PLAYERS.remove(player);
+                channel.eventLoop().submit(() -> {
+                    ChannelPipeline pipeline = channel.pipeline();
+                    if (pipeline.names().contains(BungeePacketAnalyzer.HANDLER_NAME)) pipeline.remove(BungeePacketAnalyzer.HANDLER_NAME);
+                });
+            }
+        }
+    }
+
+    public static String getPlayerInput(ProxiedPlayer player) {
+        String input = PLAYER_INPUT_CACHE.get(player);
+        PLAYER_INPUT_CACHE.remove(player);
+        return input;
+    }
+
+    public static void insertPlayerInput(ProxiedPlayer player, String text) {
+        PLAYER_INPUT_CACHE.put(player, text.toLowerCase());
+    }
+
+    private static void modifyCommands(ProxiedPlayer player, Commands commands, List<String> list) {
+        final String serverName = player.getServer().getInfo().getName();
+        final boolean turn = Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED;
+        list.clear();
+
+        for (Map.Entry<String, Command> command : ProxyServer.getInstance().getPluginManager().getCommands()) {
+            if (!ProxyServer.getInstance().getDisabledCommands().contains(command.getKey()) && commands.getRoot().getChild(command.getKey()) == null && command.getValue().hasPermission(player)) {
+
+                List<String> commandsToCheck =
+                        new ArrayList<>(Arrays.asList(command.getValue().getAliases()));
+                if(!commandsToCheck.contains(command.getValue().getName()))
+                    commandsToCheck.add(command.getValue().getName());
+                if(!commandsToCheck.contains(command.getKey()))
+                    commandsToCheck.add(command.getKey());
+
+                commandsToCheck.removeAll(list);
+                commandsToCheck.removeIf(commandName -> commandName.startsWith("/"));
+
+                for (String commandName : commandsToCheck) {
+                    if (!list.contains(commandName)) {
+                        if (!Storage.Blacklist.isBlocked(player, commandName, !turn, serverName)) {
+                            list.add(commandName);
+                            CommandNode dummy = LiteralArgumentBuilder.literal(commandName)
+                                    .executes(DUMMY_COMMAND)
+                                    .then(RequiredArgumentBuilder.argument("args", StringArgumentType.greedyString())
+                                            .suggests(Commands.SuggestionRegistry.ASK_SERVER).executes(DUMMY_COMMAND))
+                                    .build();
+
+                            commands.getRoot().addChild(dummy);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static class PacketDecoder extends MessageToMessageDecoder<PacketWrapper> {
+
+        private final ProxiedPlayer player;
+        private final List<String> commands = new ArrayList<>();
+
+        private PacketDecoder(ProxiedPlayer player) {
+            this.player = player;
+        }
+
+        @Override
+        protected void decode(ChannelHandlerContext channelHandlerContext, PacketWrapper wrapper, List<Object> list) {
+            if (wrapper.packet == null) {
+                list.add(wrapper);
+                return;
+            }
+
+            if(wrapper.packet instanceof PluginMessage) {
+                PluginMessage pluginMessage = (PluginMessage) wrapper.packet;
+                if(CustomServerBrand.isEnabled() && CustomServerBrand.isBrandTag(pluginMessage.getTag()))
+                    return;
+
+            } else if (wrapper.packet instanceof Commands) {
+                Commands response = (Commands) wrapper.packet;
+                modifyCommands(player, response, commands);
+                player.unsafe().sendPacket(response);
+                return;
+
+            } else if (wrapper.packet instanceof TabCompleteResponse) {
+                TabCompleteResponse response = (TabCompleteResponse) wrapper.packet;
+
+                if(player.getPendingConnection().getVersion() < 754) {
+                    if(!PermissionUtil.hasBypassPermission(player)) {
+
+                        ClientInfo clientInfo = Communicator.getClientByName(player.getServer().getInfo().getName());
+                        if (clientInfo == null || !PLAYER_INPUT_CACHE.containsKey(player))
+                            return;
+
+                        boolean cancelsBeforeHand = false;
+                        String playerInput = getPlayerInput(player), server = player.getServer().getInfo().getName();
+                        int spaces = 0;
+
+                        if(playerInput.contains(" ")) {
+                            String[] split = playerInput.split(" ");
+                            spaces = split.length;
+                            if(spaces > 0) playerInput = split[0];
+                        }
+
+                        if(!playerInput.equals("/")) {
+                            cancelsBeforeHand = Storage.Blacklist.isBlocked(player, StringUtils.replaceFirst(playerInput, "/", ""), !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED, server);
+
+                            if(!cancelsBeforeHand) cancelsBeforeHand = Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(StringUtils.replaceFirst(playerInput, "/", "")) ||  Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(StringUtils.replaceFirst(playerInput, "/", ""));
+                        }
+                        final String cursor = playerInput;
+                        if(cursor.startsWith("/")) {
+                            if(spaces == 0) {
+                                List<String> suggestions = new ArrayList<>(response.getCommands());
+
+                                if (Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED) {
+                                    setPluginCommands();
+
+                                    Storage.Blacklist.getAllBlacklists(server).forEach(blacklist -> blacklist.getCommands().stream().filter(command -> !suggestions.contains("/" + command)).forEach(command -> {
+                                        if (BungeePacketAnalyzer.PLUGIN_COMMANDS.contains(command))
+                                            suggestions.add("/" + command);
+                                    }));
+
+                                    BungeePacketAnalyzer.PLUGIN_COMMANDS.stream().filter(command -> !suggestions.contains(command)).forEach(command -> {
+                                        if(command.startsWith("/")) command = StringUtils.replaceFirst(command, "/", "");
+                                        if(PermissionUtil.hasBypassPermission(player, command, server)) {
+                                            suggestions.add("/" + command);
+                                        }
+                                    });
+
+                                    suggestions.stream().filter(suggestion -> suggestion.startsWith(cursor) && !response.getCommands().contains(suggestion)).forEach(command -> response.getCommands().add(command));
+
+                                } else {
+                                    BungeePacketAnalyzer.PLUGIN_COMMANDS.stream().filter(command -> !suggestions.contains(command)).forEach(suggestions::add);
+                                    suggestions.removeIf(command -> {
+                                        if(command.startsWith("/")) command = StringUtils.replaceFirst(command, "/", "");
+                                        return Storage.Blacklist.isBlocked(player, command, true, server, true);
+                                    });
+                                    response.getCommands().clear();
+                                    suggestions.forEach(command -> response.getCommands().add(command));
+                                }
+
+                                if (response.getCommands().isEmpty()) return;
+                            } else {
+                                if(cancelsBeforeHand) return;
+                            }
+
+                            player.unsafe().sendPacket(new TabCompleteResponse(response.getCommands()));
+                        }
+                    }
+                }
+            }
+
+            list.add(wrapper);
+        }
+    }
+}

src/main/java/de/rayzs/pat/api/netty/proxy/VelocityPacketAnalyzer.java

@@ -0,0 +1,265 @@
+package de.rayzs.pat.api.netty.proxy;
+
+import com.mojang.brigadier.tree.CommandNode;
+import com.velocitypowered.api.command.CommandSource;
+import com.velocitypowered.proxy.crypto.SignedChatCommand;
+import com.velocitypowered.proxy.protocol.MinecraftPacket;
+import com.velocitypowered.proxy.protocol.packet.chat.session.UnsignedPlayerCommandPacket;
+import de.rayzs.pat.api.brand.CustomServerBrand;
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.api.event.events.FilteredTabCompletionEvent;
+import de.rayzs.pat.plugin.listeners.velocity.VelocityBlockCommandListener;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import com.velocitypowered.proxy.protocol.packet.*;
+
+import java.lang.reflect.Field;
+import java.util.concurrent.ConcurrentHashMap;
+import com.velocitypowered.api.proxy.Player;
+import de.rayzs.pat.plugin.VelocityLoader;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.*;
+import io.netty.channel.*;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+import java.util.*;
+
+public class VelocityPacketAnalyzer {
+
+    public static final ConcurrentHashMap<Player, Channel> INJECTED_PLAYERS = new ConcurrentHashMap<>();
+
+    private static final String PIPELINE_NAME = "pat-velocity-handler", HANDLER_NAME = "handler";
+    private static final HashMap<Player, String> PLAYER_INPUT_CACHE = new HashMap<>();
+    private static HashMap<String, CommandsCache> COMMANDS_CACHE_MAP = new HashMap<>();
+
+    private static Class<?> minecraftConnectionClass, connectedPlayerConnectionClass, signedChatCommandPacketClass;
+
+    public static void injectAll() {
+        VelocityLoader.getServer().getAllPlayers().forEach(VelocityPacketAnalyzer::inject);
+    }
+
+    public static void uninjectAll() {
+        VelocityPacketAnalyzer.INJECTED_PLAYERS.keySet().forEach(VelocityPacketAnalyzer::uninject);
+        VelocityPacketAnalyzer.INJECTED_PLAYERS.clear();
+    }
+
+    public static boolean isInjected(Player player) {
+        return INJECTED_PLAYERS.containsKey(player);
+    }
+
+    public static boolean inject(Player player) {
+
+        if(connectedPlayerConnectionClass == null)
+            connectedPlayerConnectionClass = Reflection.getClass("com.velocitypowered.proxy.connection.client.ConnectedPlayer");
+
+        if(minecraftConnectionClass == null)
+            minecraftConnectionClass = Reflection.getClass("com.velocitypowered.proxy.connection.MinecraftConnection");
+
+        Channel channel;
+
+        try {
+            Object connectedPlayerObj = connectedPlayerConnectionClass.cast(player),
+                    minecraftConnectionObj = Reflection.getMethodsByName(connectedPlayerConnectionClass, "getConnection").get(0).invoke(connectedPlayerObj);
+
+            channel = (Channel) Reflection.getMethodsByName(minecraftConnectionClass, "getChannel").get(0).invoke(minecraftConnectionObj);
+
+            if(channel == null) {
+                System.out.println("Failed to inject " + player.getUsername() + "! Channel is null.");
+                return false;
+            }
+
+            if(channel.pipeline().names().contains(VelocityPacketAnalyzer.PIPELINE_NAME))
+                uninject(player);
+
+            channel.pipeline().addBefore(VelocityPacketAnalyzer.HANDLER_NAME, VelocityPacketAnalyzer.PIPELINE_NAME, new PacketDecoder(player));
+            VelocityPacketAnalyzer.INJECTED_PLAYERS.put(player, channel);
+        } catch (Throwable throwable) {
+            throwable.printStackTrace();
+            return false;
+        } return true;
+    }
+
+    public static void uninject(Player player) {
+        VelocityPacketAnalyzer.PLAYER_INPUT_CACHE.remove(player);
+
+        if(VelocityPacketAnalyzer.INJECTED_PLAYERS.containsKey(player)) {
+            Channel channel = VelocityPacketAnalyzer.INJECTED_PLAYERS.get(player);
+            if(channel != null) {
+                VelocityPacketAnalyzer.INJECTED_PLAYERS.remove(player);
+                channel.eventLoop().submit(() -> {
+                    ChannelPipeline pipeline = channel.pipeline();
+                    if (pipeline.names().contains(VelocityPacketAnalyzer.PIPELINE_NAME)) pipeline.remove(VelocityPacketAnalyzer.PIPELINE_NAME);
+                });
+            }
+        }
+    }
+
+    public static String getPlayerInput(Player player) {
+        String input = PLAYER_INPUT_CACHE.get(player);
+        PLAYER_INPUT_CACHE.remove(player);
+        return input;
+    }
+
+    public static void insertPlayerInput(Player player, String text) {
+        PLAYER_INPUT_CACHE.put(player, text.toLowerCase());
+    }
+
+    private static class PacketDecoder extends ChannelDuplexHandler {
+
+        private final Player player;
+
+        private PacketDecoder(Player player) {
+            this.player = player;
+        }
+
+        @Override
+        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+            if (!(msg instanceof MinecraftPacket)) {
+                super.channelRead(ctx, msg);
+                return;
+            }
+
+            MinecraftPacket packet = (MinecraftPacket) msg;
+
+            if(packet.getClass().getSimpleName().equals("SignedChatCommand")) {
+                try {
+                    if(signedChatCommandPacketClass == null)
+                        signedChatCommandPacketClass = Class.forName("com.velocitypowered.proxy.crypto.SignedChatCommand");
+
+                    Object signedChatCommandPacket = signedChatCommandPacketClass.cast(packet);
+                    Field commandField = signedChatCommandPacket.getClass().getField("command");
+                    String command = (String) commandField.get(signedChatCommandPacket);
+
+                    if(!VelocityBlockCommandListener.handleCommand(player, command))
+                        return;
+
+                } catch (Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+
+            if(packet instanceof UnsignedPlayerCommandPacket) {
+
+                UnsignedPlayerCommandPacket unsignedPlayerCommandPacket = (UnsignedPlayerCommandPacket) packet;
+                if(VelocityBlockCommandListener.handleCommand(player, unsignedPlayerCommandPacket.getCommand()))
+                    return;
+            }
+
+            if(packet instanceof TabCompleteRequestPacket) {
+                TabCompleteRequestPacket request = (TabCompleteRequestPacket) msg;
+                if(request.getCommand() != null) {
+
+                    if(Storage.ConfigSections.Settings.PATCH_EXPLOITS.isMalicious(request.getCommand())) {
+                        MessageTranslator.send(VelocityLoader.getServer().getConsoleCommandSource(), Storage.ConfigSections.Settings.PATCH_EXPLOITS.ALERT_MESSAGE.get().replace("%player%", player.getUsername()));
+                        player.disconnect(LegacyComponentSerializer.legacyAmpersand().deserialize(Storage.ConfigSections.Settings.PATCH_EXPLOITS.KICK_MESSAGE.get()));
+                    } else {
+                        insertPlayerInput(player, request.getCommand());
+                        super.channelRead(ctx, msg);
+                    }
+                }
+            } else super.channelRead(ctx, msg);
+        }
+
+        @Override
+        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+            if (!(msg instanceof MinecraftPacket)) {
+                super.write(ctx, msg, promise);
+                return;
+            }
+
+            MinecraftPacket packet = (MinecraftPacket) msg;
+
+            if(packet instanceof PluginMessagePacket) {
+                PluginMessagePacket pluginMessagePacket = (PluginMessagePacket) packet;
+                if(CustomServerBrand.isEnabled() && CustomServerBrand.isBrandTag(pluginMessagePacket.getChannel()) && !player.getCurrentServer().isPresent()) {
+                    PacketUtils.BrandManipulate brandManipulatePacket = CustomServerBrand.createBrandPacket(player);
+                    super.write(ctx, new PluginMessagePacket(pluginMessagePacket.getChannel(), brandManipulatePacket.getByteBuf()), promise);
+                    return;
+                }
+
+            } else if(packet instanceof TabCompleteResponsePacket) {
+                if (!PermissionUtil.hasBypassPermission(player) && player.getCurrentServer().isPresent()) {
+                    TabCompleteResponsePacket response = (TabCompleteResponsePacket) packet;
+
+                    boolean cancelsBeforeHand = false;
+                    String playerInput = getPlayerInput(player), rawPlayerInput = playerInput, server = player.getCurrentServer().get().getServerInfo().getName();
+                    int spaces = 0;
+
+                    if(playerInput.contains(" ")) {
+                        String[] split = playerInput.split(" ");
+                        spaces = split.length;
+                        if(spaces > 0) playerInput = split[0];
+                    }
+
+                    if(!playerInput.equals("/")) {
+                        cancelsBeforeHand = Storage.Blacklist.isBlocked(player, StringUtils.replaceFirst(playerInput, "/", ""), !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED, server);
+                        if(!cancelsBeforeHand) cancelsBeforeHand = Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(StringUtils.replaceFirst(playerInput, "/", "")) || Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(StringUtils.replaceFirst(playerInput, "/", ""));
+                    }
+
+                    final String cursor = playerInput;
+
+                    if(!cursor.startsWith("/") && spaces < 2 && player.getProtocolVersion().getProtocol() >= 754) {
+                        Logger.debug("Player won't receive TabCompleteResponsePacket because the client protocol id is " + player.getProtocolVersion().getProtocol() + "! This doesn't makes sense, that's why.");
+                        return;
+                    }
+
+                    if(cursor.startsWith("/")) {
+                        if (spaces == 0) {
+                            response.getOffers().removeIf(offer -> {
+                                String command = offer.getText();
+                                if (command.startsWith("/")) command = StringUtils.replaceFirst(command, "/", "");
+
+                                return Storage.Blacklist.isBlocked(player, command, !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED, player.getCurrentServer().get().getServerInfo().getName(), !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED);
+                            });
+                        } else {
+                            if (cancelsBeforeHand) return;
+                            List<String> suggestionsAsString = new ArrayList<>();
+                            response.getOffers().forEach(offer -> suggestionsAsString.add(offer.getText()));
+
+                            FilteredTabCompletionEvent filteredTabCompletionEvent = PATEventHandler.callFilteredTabCompletionEvents(player.getUniqueId(), rawPlayerInput, suggestionsAsString);
+                            if(filteredTabCompletionEvent.isCancelled()) return;
+                            response.getOffers().removeIf(offer -> !filteredTabCompletionEvent.getCompletion().contains(offer.getText()));
+
+                            if(response.getOffers().isEmpty()) return;
+                        }
+                    }
+                }
+
+            } else if(packet instanceof AvailableCommandsPacket) {
+                if (!PermissionUtil.hasBypassPermission(player) && player.getCurrentServer().isPresent()) {
+                    AvailableCommandsPacket commands = (AvailableCommandsPacket) packet;
+
+                    if(!commands.getRootNode().getChildren().isEmpty()) {
+                        String serverName = player.getCurrentServer().get().getServer().getServerInfo().getName();
+
+                        if (!COMMANDS_CACHE_MAP.containsKey(serverName))
+                            COMMANDS_CACHE_MAP.put(serverName, new CommandsCache().reverse());
+                        CommandsCache commandsCache = COMMANDS_CACHE_MAP.get(serverName);
+
+                        List<String> commandsAsString = new ArrayList<>();
+                        commands.getRootNode().getChildren().stream().filter(command -> command != null && command.getName() != null).forEach(command -> commandsAsString.add(command.getName()));
+                        commandsCache.handleCommands(commandsAsString, serverName);
+
+                        if (PermissionUtil.hasBypassPermission(player)) return;
+
+                        final boolean newer = player.getProtocolVersion().getProtocol() > 340;
+                        final List<String> playerCommands = commandsCache.getPlayerCommands(commandsAsString, player, player.getUniqueId(), serverName);
+
+                        if(commands.getRootNode().getChildren().size() == 1 && newer
+                                && commands.getRootNode().getChild("args") != null
+                                && commands.getRootNode().getChild("args").getChildren().isEmpty()) {
+
+                            super.write(ctx, msg, promise);
+                            return;
+                        }
+
+                        commands.getRootNode().getChildren().removeIf(command -> command == null || command.getName() == null || playerCommands.contains(command.getName()));
+                    }
+                }
+            }
+
+            super.write(ctx, msg, promise);
+        }
+    }
+}

src/main/java/de/rayzs/pat/api/storage/Storage.java

@@ -0,0 +1,475 @@
+package de.rayzs.pat.api.storage;
+
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.api.storage.placeholders.commands.general.*;
+import de.rayzs.pat.api.storage.placeholders.commands.group.*;
+import de.rayzs.pat.api.storage.blacklist.BlacklistCreator;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.api.storage.placeholders.general.*;
+import de.rayzs.pat.api.storage.placeholders.groups.*;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.api.storage.config.messages.*;
+import de.rayzs.pat.api.storage.config.settings.*;
+import de.rayzs.pat.api.storage.blacklist.impl.*;
+import de.rayzs.pat.api.storage.storages.*;
+import de.rayzs.pat.utils.configuration.*;
+import java.util.concurrent.TimeUnit;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+import de.rayzs.pat.plugin.*;
+import de.rayzs.pat.utils.*;
+import java.util.*;
+
+public class Storage {
+
+    public static final List<UUID> NOTIFY_PLAYERS = new ArrayList<>();
+
+    public static String TOKEN = "", SERVER_NAME = null, CURRENT_VERSION = "", NEWER_VERSION = "";
+    public static boolean OUTDATED = false, SEND_CONSOLE_NOTIFICATION = true;
+    public static Object PLUGIN_OBJECT;
+    public static boolean USE_LUCKPERMS = false, USE_PLACEHOLDERAPI = false, USE_PAPIPROXYBRIDGE = false, USE_VIAVERSION = false, USE_VELOCITY = false, USE_SIMPLECLOUD;
+    public static long LAST_SYNC = System.currentTimeMillis();
+
+    public static void loadAll(boolean loadBlacklist) {
+        loadConfig();
+        loadToken();
+        if(loadBlacklist) Blacklist.loadAll();
+
+        PATEventHandler.callUpdatePluginEvents();
+    }
+
+    public static void loadToken() {
+        TOKEN = Reflection.isProxyServer() ? (String) Files.TOKEN.getOrSet("token", UUID.randomUUID().toString()) : ConfigSections.Settings.HANDLE_THROUGH_PROXY.TOKEN;
+    }
+
+    public static void loadConfig() {
+        ConfigSections.Settings.initialize();
+        ConfigSections.Messages.initialize();
+        ConfigSections.SECTIONS.forEach(ConfigStorage::load);
+
+        if(USE_PLACEHOLDERAPI)
+            ConfigSections.PLACEHOLDERS.forEach(PlaceholderStorage::load);
+    }
+
+    public static List<String> getServers() {
+        return getServers(false);
+    }
+
+    public static List<String> getServers(boolean withBlacklist) {
+        List<String> servers = new ArrayList<>();
+        if(Reflection.isVelocityServer())
+            servers.addAll(VelocityLoader.getServerNames());
+        else if(Reflection.isProxyServer())
+            servers.addAll(BungeeLoader.getServerNames());
+
+        if(withBlacklist) Blacklist.getBlacklistServers().stream().filter(server -> !servers.contains(server.toLowerCase())).forEach(server -> servers.add(server.toLowerCase()));
+        return servers;
+    }
+
+    public static boolean isServer(String originServer, Set<String> targetServers) {
+        List<String> list = new ArrayList<>(targetServers);
+        return isServer(originServer, list);
+    }
+
+    public static boolean isServer(String targetServers, List<String> servers) {
+        for (String originServer : servers)
+            if(isServer(originServer, targetServers))
+                return true;
+        return false;
+    }
+
+    public static boolean isServer(String originServer, String targetServer) {
+        originServer = originServer.toLowerCase();
+        targetServer = targetServer.toLowerCase();
+
+        if(originServer.endsWith("*")) {
+            originServer = originServer.replace("*", "");
+            return targetServer.startsWith(originServer);
+        }
+        return originServer.equalsIgnoreCase(targetServer);
+    }
+
+    public static class Files {
+        public static final ConfigurationBuilder
+                CONFIGURATION = Configurator.get("config"),
+                STORAGE = Configurator.get("storage"),
+                PLACEHOLDERS = Configurator.get("placeholders"),
+                CUSTOM_RESPONSES = Configurator.get("custom-responses"),
+                TOKEN = Configurator.get("token");
+
+        public static void initialize() {}
+    }
+
+    public static class ConfigSections {
+
+        public static List<ConfigStorage> SECTIONS = new ArrayList<>();
+        public static List<PlaceholderStorage> PLACEHOLDERS = new ArrayList<>();
+
+        public static class Settings {
+
+            public static BlockNamespaceCommandsSection BLOCK_NAMESPACE_COMMANDS = new BlockNamespaceCommandsSection();
+            public static HandleThroughProxySection HANDLE_THROUGH_PROXY = new HandleThroughProxySection();
+            public static PatchExploitSection PATCH_EXPLOITS = new PatchExploitSection();
+            public static CustomBrandSection CUSTOM_BRAND = new CustomBrandSection();
+            public static CancelCommandSection CANCEL_COMMAND = new CancelCommandSection();
+            public static CustomPluginsSection CUSTOM_PLUGIN = new CustomPluginsSection();
+            public static CustomVersionSection CUSTOM_VERSION = new CustomVersionSection();
+            public static DisableSyncSection DISABLE_SYNC = new DisableSyncSection();
+            public static CustomProtocolPingSection CUSTOM_PROTOCOL_PING = new CustomProtocolPingSection();
+            public static CustomUnknownCommandSection CUSTOM_UNKNOWN_COMMAND = new CustomUnknownCommandSection();
+            public static TurnBlacklistToWhitelistSection TURN_BLACKLIST_TO_WHITELIST = new TurnBlacklistToWhitelistSection();
+            public static UpdateSection UPDATE = new UpdateSection();
+
+            public static void initialize() {}
+        }
+
+        public static class Messages {
+
+            public static PrefixSection PREFIX = new PrefixSection();
+            public static BlacklistSection BLACKLIST = new BlacklistSection();
+            public static CommandFailedSection COMMAND_FAILED = new CommandFailedSection();
+            public static GroupSection GROUP = new GroupSection();
+            public static HelpSection HELP = new HelpSection();
+            public static InfoSection INFO = new InfoSection();
+            public static NoPermissionSection NO_PERMISSION = new NoPermissionSection();
+            public static NotificationSection NOTIFICATION = new NotificationSection();
+            public static PermsCheckSection PERMS_CHECK = new PermsCheckSection();
+            public static PostDebugSection POST_DEBUG = new PostDebugSection();
+            public static OnlyForProxySection NO_PROXY = new OnlyForProxySection();
+            public static ReloadSection RELOAD = new ReloadSection();
+            public static ServerListSection SERV_LIST = new ServerListSection();
+            public static StatsSection STATS = new StatsSection();
+            public static UpdatePermissionsSection UPDATE_PERMISSIONS = new UpdatePermissionsSection();
+
+            public static void initialize() {}
+        }
+
+        public static class Placeholders {
+
+            public static GeneralUserPlaceholder USER = new GeneralUserPlaceholder();
+            public static GeneralCurrentVersionPlaceholder CURRENT_VERSION = new GeneralCurrentVersionPlaceholder();
+            public static GeneralNewestVersionPlaceholder NEWEST_VERSION = new GeneralNewestVersionPlaceholder();
+
+            public static ListGroupsPlaceholder LIST_GROUP = new ListGroupsPlaceholder();
+            public static ListGroupsReversedPlaceholder LIST_GROUP_REVERSED = new ListGroupsReversedPlaceholder();
+            public static ListGroupsSortedPlaceholder LIST_GROUP_SORTED = new ListGroupsSortedPlaceholder();
+            public static ListSizeGroupsPlaceholder LIST_SIZE_GROUPS = new ListSizeGroupsPlaceholder();
+
+            public static ListGroupCommandsPlaceholder LIST_GROUP_COMMANDS = new ListGroupCommandsPlaceholder();
+            public static ListGroupReversedCommandsPlaceholder LIST_GROUP_REVERSED_COMMANDS = new ListGroupReversedCommandsPlaceholder();
+            public static ListGroupSortedCommandsPlaceholder LIST_GROUP_SORTED_COMMANDS = new ListGroupSortedCommandsPlaceholder();
+            public static ListGroupSizeCommandsPlaceholder LIST_GROUP_SIZE_GROUP = new ListGroupSizeCommandsPlaceholder();
+
+            public static ListCommandsPlaceholder LIST_COMMANDS = new ListCommandsPlaceholder();
+            public static ListReversedCommandsPlaceholder LIST_REVERSED_COMMANDS = new ListReversedCommandsPlaceholder();
+            public static ListSortedCommandsPlaceholder LIST_SORTED_COMMANDS = new ListSortedCommandsPlaceholder();
+            public static ListSizeCommandsPlaceholder LIST_SIZE_COMMANDS = new ListSizeCommandsPlaceholder();
+
+            public static void initialize() {}
+
+            public static String findAndReplace(Player player, String request) {
+                String result = null, param = "";
+
+                if(USE_PLACEHOLDERAPI)
+                    for (PlaceholderStorage storage : PLACEHOLDERS) {
+                        if(!storage.getRequest().startsWith(request)) continue;
+
+                        if(storage.getRequest().endsWith("group_") && request.contains("group_"))
+                            param = request.split("group_")[1];
+
+                        result = storage.onRequest(player, param);
+                        if(result == null) continue;
+                        else result = result.replace("\\n", "\n");
+
+                        break;
+                    }
+
+                return result;
+            }
+        }
+    }
+
+    public static class Blacklist {
+
+        private static final HashMap<String, GeneralBlacklist> SERVER_BLACKLISTS = new HashMap<>();
+        private static final GeneralBlacklist BLACKLIST = BlacklistCreator.createGeneralBlacklist();
+        private static final IgnoredServersStorage IGNORED_SERVERS = new GeneralIgnoredServers();
+        private static final ExpireCache<String, List<GeneralBlacklist>> CACHED_SERVER_BLACKLIST = new ExpireCache<>(1, TimeUnit.HOURS);
+
+        public static void loadAll() {
+            CACHED_SERVER_BLACKLIST.clear();
+            SERVER_BLACKLISTS.clear();
+            BLACKLIST.load();
+
+            if(!Reflection.isProxyServer()) return;
+            IGNORED_SERVERS.load();
+            BLACKLIST.getConfig().getKeys("global.servers", true).forEach(key -> {
+                GeneralBlacklist blacklist = BlacklistCreator.createGeneralBlacklist(key);
+                blacklist.load();
+                SERVER_BLACKLISTS.put(key, blacklist);
+            });
+        }
+
+        public static boolean isOnIgnoredServer(String server) {
+            return IGNORED_SERVERS.isListed(server);
+        }
+
+        public static boolean isBlockedGloballyOnServer(boolean blocked, String server, boolean turn) {
+            if(isOnIgnoredServer(server)) return turn;
+            else return blocked;
+        }
+
+        public static List<String> getBlacklistServers() {
+            return new ArrayList<>(SERVER_BLACKLISTS.keySet());
+        }
+
+        public static GeneralBlacklist getBlacklist() {
+            return BLACKLIST;
+        }
+
+        public static GeneralBlacklist getBlacklist(String server) {
+            GeneralBlacklist blacklist;
+
+            if(!SERVER_BLACKLISTS.containsKey(server)) {
+                blacklist = BlacklistCreator.createGeneralBlacklist(server);
+                blacklist.load();
+                SERVER_BLACKLISTS.put(server, blacklist);
+            } else blacklist = SERVER_BLACKLISTS.get(server);
+
+            return SERVER_BLACKLISTS.getOrDefault(server, blacklist);
+        }
+
+        public static List<GeneralBlacklist> getAllBlacklists(String server) {
+            List<GeneralBlacklist> blacklists = getBlacklists(server);
+            if (isOnIgnoredServer(server)) return blacklists;
+
+            blacklists.add(Storage.Blacklist.getBlacklist());
+            return blacklists;
+        }
+
+        public static void clearServerBlacklists(String server) {
+            CACHED_SERVER_BLACKLIST.remove(server.toLowerCase());
+        }
+
+        public static List<GeneralBlacklist> getBlacklists(String server) {
+            final String finalServer = server.toLowerCase();
+
+            if (CACHED_SERVER_BLACKLIST.contains(finalServer))
+                return CACHED_SERVER_BLACKLIST.get(finalServer);
+
+            List<GeneralBlacklist> blacklists = new ArrayList<>();
+            SERVER_BLACKLISTS.entrySet()
+                    .stream().filter(entry -> entry.getKey().endsWith("*")
+                    ? isServer(entry.getKey(), finalServer)
+                    : entry.getKey().equalsIgnoreCase(finalServer))
+                    .forEach(entry -> blacklists.add(entry.getValue()));
+
+            return CACHED_SERVER_BLACKLIST.putAndGet(finalServer, blacklists);
+        }
+
+        public static boolean isListed(String command, String server) {
+            boolean turn = ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED,
+                    blocked = isBlockedGloballyOnServer(isBlocked(command, server), server, turn);
+
+            if(!blocked) for (GeneralBlacklist blacklist : getBlacklists(server)) {
+                blocked = blacklist.isBlocked(command, server, !turn);
+                if(blocked) break;
+            }
+
+            return blocked;
+        }
+
+        public static boolean isListed(String command, boolean intensive, String server) {
+            boolean turn = ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED,
+                    blocked = isBlockedGloballyOnServer(isListed(command, intensive), server, turn);
+
+            if(!blocked) for (GeneralBlacklist blacklist : getBlacklists(server)) {
+                blocked = blacklist.isListed(command, intensive);
+                if(blocked) break;
+            }
+            return blocked;
+        }
+
+        public static boolean doesGroupBypass(Object playerObj, String command, boolean intensive, String server) {
+            int priority = -1;
+            for (Group group : GroupManager.getGroups()) {
+                for (GroupBlacklist groupBlacklist : group.getAllServerGroupBlacklist(server)) {
+
+                    if(priority == -1 || group.getPriority() <= priority)
+                        if(group.hasPermission(playerObj)) {
+                            priority = group.getPriority();
+                            if (groupBlacklist.isListed(command, intensive)) return true;
+                        }
+                }
+            }
+
+            return false;
+        }
+
+        public static boolean doesGroupBypass(Object playerObj, String command, boolean intensive, boolean convert, boolean slash, String server) {
+            int priority = -1;
+            for (Group group : GroupManager.getGroups()) {
+                for (GroupBlacklist groupBlacklist : group.getAllServerGroupBlacklist(server, true)) {
+                    if(priority == -1 || group.getPriority() <= priority)
+                        if(group.hasPermission(playerObj)) {
+                            priority = group.getPriority();
+                            if (groupBlacklist.isListed(command, intensive, convert, slash)) return true;
+                        }
+                }
+            }
+
+            return false;
+        }
+
+        public static boolean isListed(Object playerObj, String command, boolean intensive, String server) {
+            if(GroupManager.getGroupsByServer(server).stream().anyMatch(group -> isInListed(command, group.getAllCommands(server), intensive) && group.hasPermission(playerObj)))
+                return false;
+
+            boolean listed = isListed(command, intensive);
+
+            if(!listed) for (GeneralBlacklist blacklist : getBlacklists(server)) {
+                listed = blacklist.isListed(command, intensive);
+                if(listed) break;
+            }
+            return listed;
+        }
+
+        public static boolean isListed(Object playerObj, String command, boolean intensive, boolean listed, String server) {
+            if(GroupManager.getGroupsByServer(server).stream().anyMatch(group -> isInListed(command, group.getAllCommands(server), intensive) && group.hasPermission(playerObj)))
+                return false;
+
+            if(!listed) for (GeneralBlacklist blacklist : getBlacklists(server)) {
+                listed = blacklist.isListed(command, intensive);
+                if(listed) break;
+            }
+            return listed;
+        }
+
+        public static boolean isListed(Object playerObj, String command, boolean intensive, boolean listed, boolean slash, String server) {
+            return isListed(playerObj, command, intensive, listed, slash, server, false);
+        }
+
+        public static boolean isListed(Object playerObj, String command, boolean intensive, boolean listed, boolean slash, String server, boolean instantReturn) {
+            if(GroupManager.getGroupsByServer(server).stream().anyMatch(group -> isInListed(command, group.getAllCommands(server), intensive) && group.hasPermission(playerObj)))
+                return false;
+
+            if(listed) return true;
+
+            for (GeneralBlacklist blacklist : getBlacklists(server)) {
+                listed = blacklist.isListed(command, intensive, true, slash);
+                if(instantReturn) return listed;
+
+                if(listed) break;
+            }
+
+            return listed;
+        }
+
+        public static boolean isBlocked(String command, boolean intensive, String server) {
+            return isBlocked(command, intensive, server, false);
+        }
+
+        public static boolean isBlocked(Object targetObj, String command, boolean intensive, String server) {
+            return isBlocked(targetObj, command, intensive, server, false);
+        }
+
+        public static boolean isBlocked(String command, boolean intensive, String server, boolean focusOnBlock) {
+            server = server.toLowerCase();
+
+            boolean turn = ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED,
+                    blocked,
+                    blockedGlobal = isBlockedGloballyOnServer(BLACKLIST.isBlockedIgnorePermission(command, intensive), server, turn),
+                    blockedServer = false;
+
+            if(focusOnBlock && blockedGlobal) return true;
+
+            for (GeneralBlacklist blacklist : getBlacklists(server)) {
+                if(focusOnBlock && blacklist.isBlocked(command, intensive))
+                    return true;
+
+                blockedServer = blacklist.isBlockedIgnorePermission(command, intensive);
+                break;
+            }
+
+            blocked = turn ? blockedGlobal && blockedServer : blockedServer || blockedGlobal;
+
+            // The reason which there's no tab-completion and also why every server-based list needs to exist to avoid this issue.
+
+            if (turn && !blocked
+                    && CACHED_SERVER_BLACKLIST.contains(server)
+                    && CACHED_SERVER_BLACKLIST.get(server).isEmpty())
+                blocked = true;
+
+            return blocked;
+        }
+
+        public static boolean isBlocked(Object targetObj, String command, boolean intensive, String server, boolean focusOnBlock) {
+            if(server != null) server = server.toLowerCase();
+
+            if(doesGroupBypass(targetObj, command, intensive, server))
+                return false;
+
+            boolean blocked = isBlocked(command, intensive, server, focusOnBlock);
+
+            if(blocked)
+                if(PermissionUtil.hasBypassPermission(targetObj, command))
+                    blocked = false;
+
+            return blocked;
+        }
+
+        public static boolean isListed(String command) {
+            return BLACKLIST.isListed(command);
+        }
+
+        public static boolean isListed(String command, boolean intensive) {
+            return BLACKLIST.isListed(command, intensive);
+        }
+
+        public static boolean isListed(String command, boolean intensive, boolean convert) {
+            return BLACKLIST.isListed(command, intensive, convert);
+        }
+
+        public static boolean isListed(String command, boolean intensive, boolean convert, boolean slash) {
+            return BLACKLIST.isListed(command, intensive, convert, slash);
+        }
+
+        public static boolean isBlocked(Object targetObj, String command) {
+            return BLACKLIST.isBlocked(targetObj, command);
+        }
+
+        public static boolean isBlocked(Object targetObj, String command, boolean intensive) {
+            return BLACKLIST.isBlocked(targetObj, command, intensive);
+        }
+
+        public static boolean isBlocked(Object targetObj, String command, boolean intensive, boolean convert, boolean slash) {
+            return BLACKLIST.isBlocked(targetObj, command, intensive, convert, slash);
+        }
+
+        public static boolean isBlocked(String command, boolean intensive, boolean convert) {
+            return BLACKLIST.isBlocked(command, intensive, convert);
+        }
+
+        public static boolean isBlocked(String command, boolean intensive, boolean convert, boolean slash) {
+            return BLACKLIST.isBlocked(command, intensive, convert);
+        }
+
+        public static String convertCommand(String command, boolean intensive, boolean lowercase) {
+            return BLACKLIST.convertCommand(command, intensive, lowercase);
+        }
+
+        public static String convertCommand(String command, boolean intensive, boolean lowercase, boolean slash) {
+            return BLACKLIST.convertCommand(command, intensive, lowercase, slash);
+        }
+
+        public static boolean isInListed(String command, List<String> commandList, boolean intensive) {
+            command = StringUtils.replaceFirst(command, "/", "");
+            command = convertCommand(command, intensive, false);
+
+            for (String commands : commandList)
+                if(commands.equals(command)) return true;
+
+            return false;
+        }
+    }
+}

src/main/java/de/rayzs/pat/api/storage/StorageTemplate.java

@@ -0,0 +1,39 @@
+package de.rayzs.pat.api.storage;
+
+import de.rayzs.pat.utils.configuration.*;
+import java.io.Serializable;
+
+public abstract class StorageTemplate implements Serializable {
+
+    private final String navigatePath;
+    private final ConfigurationBuilder configuration;
+
+    public StorageTemplate(ConfigurationBuilder configuration, String navigatePath) {
+        this.navigatePath = navigatePath;
+        this.configuration = configuration;
+        this.load();
+    }
+
+    public StorageTemplate setIfEmpty(String target, Object obj) {
+        configuration.getOrSet(target, obj);
+        return this;
+    }
+
+    public StorageTemplate set(String target, Object obj) {
+        configuration.setAndSave(target, obj);
+        return this;
+    }
+
+    public Object get(String target, Object obj) {
+        configuration.getOrSet(target, obj);
+        return this;
+    }
+
+    public ConfigurationBuilder getConfig() {
+        return configuration;
+    }
+    public String getNavigatePath() { return navigatePath; }
+
+    public abstract void save();
+    public abstract void load();
+}

src/main/java/de/rayzs/pat/api/storage/blacklist/BlacklistCreator.java

@@ -0,0 +1,39 @@
+package de.rayzs.pat.api.storage.blacklist;
+
+import de.rayzs.pat.api.storage.blacklist.impl.*;
+import de.rayzs.pat.api.storage.Storage;
+
+public class BlacklistCreator {
+
+    public static GeneralBlacklist createGeneralBlacklist() {
+        return new GeneralBlacklist("commands");
+    }
+
+    public static GeneralBlacklist createGeneralBlacklist(String server) {
+        server = server.toLowerCase();
+        return new GeneralBlacklist("servers." + server + ".commands");
+    }
+
+    public static GroupBlacklist createGroupBlacklist(String group) {
+        return new GroupBlacklist(group, "commands");
+    }
+
+    public static GroupBlacklist createGroupBlacklist(String group, String server, boolean ignoreExist) {
+        server = server.toLowerCase();
+        if (!exist(group, server) && !ignoreExist)
+            return null;
+        return new GroupBlacklist(group, "servers." + server + ".commands");
+    }
+
+    public static boolean exist(String server) {
+        server = server.toLowerCase();
+        Object obj = Storage.Blacklist.getBlacklist().getConfig().get("global.servers." + server);
+        return obj != null;
+    }
+
+    public static boolean exist(String group, String server) {
+        server = server.toLowerCase();
+        Object obj = Storage.Blacklist.getBlacklist().getConfig().get("groups." + group + ".servers." + server);
+        return obj != null;
+    }
+}

src/main/java/de/rayzs/pat/api/storage/blacklist/impl/GeneralBlacklist.java

@@ -0,0 +1,60 @@
+package de.rayzs.pat.api.storage.blacklist.impl;
+
+import de.rayzs.pat.api.storage.storages.BlacklistStorage;
+import de.rayzs.pat.api.storage.StorageTemplate;
+import java.util.List;
+
+public class GeneralBlacklist extends BlacklistStorage {
+
+    public GeneralBlacklist(String navigatePath) { super("global." + navigatePath); }
+
+    @Override
+    public List<String> getCommands() {
+        return super.getCommands();
+    }
+
+    @Override
+    public BlacklistStorage add(String command) {
+        return super.add(command);
+    }
+
+    @Override
+    public BlacklistStorage remove(String command) {
+        return super.remove(command);
+    }
+
+    @Override
+    public BlacklistStorage clear() {
+        return super.clear();
+    }
+
+    @Override
+    public StorageTemplate setIfEmpty(String target, Object obj) {
+        return super.setIfEmpty(target, obj);
+    }
+
+    @Override
+    public StorageTemplate set(String target, Object obj) {
+        return super.set(target, obj);
+    }
+
+    @Override
+    public void setList(List<String> commands) {
+        super.setList(commands);
+    }
+
+    @Override
+    public Object get(String target, Object obj) {
+        return super.get(target, obj);
+    }
+
+    @Override
+    public void save() {
+        super.save();
+    }
+
+    @Override
+    public void load() {
+        super.load();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/blacklist/impl/GeneralIgnoredServers.java

@@ -0,0 +1,40 @@
+package de.rayzs.pat.api.storage.blacklist.impl;
+
+import de.rayzs.pat.api.storage.storages.IgnoredServersStorage;
+
+public class GeneralIgnoredServers extends IgnoredServersStorage {
+
+    public GeneralIgnoredServers() {
+        super("global.ignored-servers");
+    }
+
+    @Override
+    public IgnoredServersStorage add(String server) {
+        return super.add(server);
+    }
+
+    @Override
+    public IgnoredServersStorage remove(String server) {
+        return super.remove(server);
+    }
+
+    @Override
+    public boolean isListed(String server) {
+        return super.isListed(server);
+    }
+
+    @Override
+    public boolean isListEmpty() {
+        return super.isListEmpty();
+    }
+
+    @Override
+    public void load() {
+        super.load();
+    }
+
+    @Override
+    public void save() {
+        super.save();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/blacklist/impl/GroupBlacklist.java

@@ -0,0 +1,58 @@
+package de.rayzs.pat.api.storage.blacklist.impl;
+
+import de.rayzs.pat.api.storage.storages.BlacklistStorage;
+import de.rayzs.pat.api.storage.StorageTemplate;
+import java.util.List;
+
+public class GroupBlacklist extends BlacklistStorage {
+
+    public GroupBlacklist(String group, String navigatePath) { super("groups." + group + "." + navigatePath); }
+
+    @Override
+    public List<String> getCommands() {
+        return super.getCommands();
+    }
+
+    @Override
+    public BlacklistStorage add(String command) {
+        return super.add(command);
+    }
+
+    @Override
+    public BlacklistStorage remove(String command) { return super.remove(command); }
+
+    @Override
+    public BlacklistStorage clear() {
+        return super.clear();
+    }
+
+    @Override
+    public StorageTemplate setIfEmpty(String target, Object obj) {
+        return super.setIfEmpty(target, obj);
+    }
+
+    @Override
+    public StorageTemplate set(String target, Object obj) {
+        return super.set(target, obj);
+    }
+
+    @Override
+    public void setList(List<String> commands) {
+        super.setList(commands);
+    }
+
+    @Override
+    public Object get(String target, Object obj) {
+        return super.get(target, obj);
+    }
+
+    @Override
+    public void save() {
+        super.save();
+    }
+
+    @Override
+    public void load() {
+        super.load();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/BlacklistSection.java

@@ -0,0 +1,53 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+
+public class BlacklistSection extends ConfigStorage {
+
+    public String CLEAR, CLEAR_CONFIRM, CLEAR_SERVER, CLEAR_SERVER_CONFIRM, CLEAR_SERVER_NOT_FOUND;
+    public String LIST_MESSAGE, LIST_SPLITTER, LIST_COMMAND, LIST_SERVER_MESSAGE, LIST_SERVER_SPLITTER, LIST_SERVER_COMMAND;
+
+    public String ADD_SUCCESS, ADD_FAILED;
+    public String REMOVE_SUCCESS, REMOVE_FAILED;
+
+    public String ADD_SERVER_SUCCESS, ADD_SERVER_FAILED;
+    public String REMOVE_SERVER_SUCCESS, REMOVE_SERVER_FAILED;
+
+    public BlacklistSection() {
+        super("blacklist");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        CLEAR = new ConfigSectionHelper<String>(this, "clear", "&aList has been cleared!").getOrSet();
+        CLEAR_CONFIRM = new ConfigSectionHelper<String>(this, "clear-confirmation", "&4Warning! &7This command will &cclear the entire list&7! &7Repeat the &esame command &7to confirm this action.").getOrSet();
+
+        LIST_MESSAGE = new ConfigSectionHelper<String>(this, "list.message", "&7Listed commands (&f%size%&7)&8: &f%commands%").getOrSet();
+        LIST_SPLITTER = new ConfigSectionHelper<String>(this, "list.splitter", "&7, ").getOrSet();
+        LIST_COMMAND = new ConfigSectionHelper<String>(this, "list.command", "&f%command%").getOrSet();
+
+        ADD_SUCCESS = new ConfigSectionHelper<String>(this, "add.success", "&aSuccessfully added %command% into the list!").getOrSet();
+        ADD_FAILED = new ConfigSectionHelper<String>(this, "add.failed", "&c%command% is already in the list!").getOrSet();
+
+        REMOVE_SUCCESS = new ConfigSectionHelper<String>(this, "remove.success", "&aSuccessfully removed %command% from the list!").getOrSet();
+        REMOVE_FAILED = new ConfigSectionHelper<String>(this, "remove.failed", "&c%command% is not listed!").getOrSet();
+        if(!Reflection.isProxyServer()) return;
+
+        CLEAR_SERVER = new ConfigSectionHelper<String>(this, "clear-server", "&aList has been cleared!").getOrSet();
+        CLEAR_SERVER_CONFIRM = new ConfigSectionHelper<String>(this, "clear-confirmation-server", "&4Warning! &7This command will &cclear the entire list of this server&7! &7Repeat the &esame command &7to confirm this action.").getOrSet();
+        CLEAR_SERVER_NOT_FOUND = new ConfigSectionHelper<String>(this, "clear-server-not-found", "&cThe server %server% does not have any commands!").getOrSet();
+
+        LIST_SERVER_MESSAGE = new ConfigSectionHelper<String>(this, "list.message-server", "&7Listed commands of %server% (&f%size%&7)&8: &f%commands%").getOrSet();
+        LIST_SERVER_SPLITTER = new ConfigSectionHelper<String>(this, "list.splitter-server", "&7, ").getOrSet();
+        LIST_SERVER_COMMAND = new ConfigSectionHelper<String>(this, "list.command-server", "&f%command%").getOrSet();
+
+        ADD_SERVER_SUCCESS = new ConfigSectionHelper<String>(this, "add.success-server", "&aSuccessfully added %command% into the list of %server%!").getOrSet();
+        ADD_SERVER_FAILED = new ConfigSectionHelper<String>(this, "add.failed-server", "&c%command% is already in the list of %server%!").getOrSet();
+
+        REMOVE_SERVER_SUCCESS = new ConfigSectionHelper<String>(this, "remove.success-server", "&aSuccessfully removed %command% from the list of %server%!").getOrSet();
+        REMOVE_SERVER_FAILED = new ConfigSectionHelper<String>(this, "remove.failed-server", "&c%command% is not the list of %server%!").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/CommandFailedSection.java

@@ -0,0 +1,19 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class CommandFailedSection extends ConfigStorage {
+
+    public String MESSAGE;
+
+    public CommandFailedSection() {
+        super("command-failed");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        MESSAGE = new ConfigSectionHelper<String>(this, null, "&cFailed to execute this command! Use \"/pat\" to see all available commands.").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/GroupSection.java

@@ -0,0 +1,86 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+
+public class GroupSection extends ConfigStorage {
+
+    public String CREATE, ALREADY_EXIST, DOES_NOT_EXIST, DELETE, DELETE_CONFIRM, CREATE_SERVER, ALREADY_SERVER_EXIST, DOES_NOT_EXIST_SERVER, DELETE_SERVER, DELETE_SERVER_CONFIRM;
+    public String CLEAR, CLEAR_CONFIRM, CLEAR_SERVER, CLEAR_SERVER_CONFIRM;
+    public String PRIORITY_SUCCESS, PRIORITY_FAILED;
+
+    public String LIST_MESSAGE, LIST_SPLITTER, LIST_COMMAND, LIST_SERVER_MESSAGE, LIST_SERVER_SPLITTER, LIST_SERVER_COMMAND;
+    public String LIST_GROUP_MESSAGE, LIST_GROUP_SPLITTER, LIST_GROUP_GROUPS, LIST_GROUP_SERVER_MESSAGE, LIST_GROUP_SERVER_SPLITTER, LIST_GROUP_SERVER_GROUPS;
+    public String LIST_PRIORITY_MESSAGE, LIST_PRIORITY_SPLITTER, LIST_PRIORITY_GROUPS;
+
+    public String ADD_SUCCESS, ADD_FAILED;
+    public String REMOVE_SUCCESS, REMOVE_FAILED;
+
+    public String ADD_SERVER_SUCCESS, ADD_SERVER_FAILED;
+    public String REMOVE_SERVER_SUCCESS, REMOVE_SERVER_FAILED;
+
+    public GroupSection() {
+        super("group");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+
+        CREATE = new ConfigSectionHelper<String>(this, "create", "&aGroup %group% has been created!").getOrSet();
+        ALREADY_EXIST = new ConfigSectionHelper<String>(this, "already-exist", "&cGroup %group% already exist!").getOrSet();
+        DOES_NOT_EXIST = new ConfigSectionHelper<String>(this, "does-not-exist", "&cGroup %group% does not exist!").getOrSet();
+        DELETE = new ConfigSectionHelper<String>(this, "delete", "&cGroup %group% has been deleted!").getOrSet();
+        DELETE_CONFIRM = new ConfigSectionHelper<String>(this, "delete-confirmation", "&4Warning! &7This command will &cdelete the group with the whole list&7 of this group! &7Repeat the &esame command &7to confirm this action.").getOrSet();
+
+        CLEAR = new ConfigSectionHelper<String>(this, "clear", "&aList of group %group% has been cleared!").getOrSet();
+        CLEAR_CONFIRM = new ConfigSectionHelper<String>(this, "clear-confirmation", "&4Warning! &7This command will &cclear the entire list&7 of this group! &7Repeat the &esame command &7to confirm this action.").getOrSet();
+
+        PRIORITY_SUCCESS = new ConfigSectionHelper<String>(this, "priority.success", "&aSuccessfully set the priority of group &e%group% &ato &e%priority%&a!").getOrSet();
+        PRIORITY_FAILED = new ConfigSectionHelper<String>(this, "priority.failed", "&cInvalid priority! Please choose a number which is greater than 0.").getOrSet();
+
+        LIST_MESSAGE = new ConfigSectionHelper<String>(this, "list.message", "&7Listed commands of group %group% (&f%size%&7)&8: &f%commands%").getOrSet();
+        LIST_SPLITTER = new ConfigSectionHelper<String>(this, "list.splitter", "&7, ").getOrSet();
+        LIST_COMMAND = new ConfigSectionHelper<String>(this, "list.command", "&f").getOrSet();
+
+        LIST_PRIORITY_MESSAGE = new ConfigSectionHelper<String>(this, "list-priorities.message", "&7List of all group priorities (&f%size%&7)&8: &f%groups%").getOrSet();
+        LIST_PRIORITY_SPLITTER = new ConfigSectionHelper<String>(this, "list-priorities.splitter", "\\n").getOrSet();
+        LIST_PRIORITY_GROUPS = new ConfigSectionHelper<String>(this, "list-priorities.group", "&8- &e%priority%&8: &f%group%").getOrSet();
+
+        LIST_GROUP_MESSAGE = new ConfigSectionHelper<String>(this, "list-groups.message", "&7All groups (&f%size%&7)&8: &f%groups%").getOrSet();
+        LIST_GROUP_SPLITTER = new ConfigSectionHelper<String>(this, "list-groups.splitter", "&7, ").getOrSet();
+        LIST_GROUP_GROUPS = new ConfigSectionHelper<String>(this, "list-groups.command", "&f").getOrSet();
+
+        ADD_SUCCESS = new ConfigSectionHelper<String>(this, "add.success", "&aSuccessfully added %command% into the list of group %group%!").getOrSet();
+        ADD_FAILED = new ConfigSectionHelper<String>(this, "add.failed", "&c%command% is already in the list of group %group%!").getOrSet();
+
+        REMOVE_SUCCESS = new ConfigSectionHelper<String>(this, "remove.success", "&aSuccessfully removed %command% from the list of group %group%!").getOrSet();
+        REMOVE_FAILED = new ConfigSectionHelper<String>(this, "remove.failed", "&c%command% is not listed in the group %group%!").getOrSet();
+        if(!Reflection.isProxyServer()) return;
+
+        CREATE_SERVER = new ConfigSectionHelper<String>(this, "create-server", "&aGroup %group% for %server% has been created!").getOrSet();
+        ALREADY_SERVER_EXIST = new ConfigSectionHelper<String>(this, "already-exist-server", "&cGroup %group% for %server% already exist!").getOrSet();
+        DOES_NOT_EXIST_SERVER = new ConfigSectionHelper<String>(this, "does-not-exist-server", "&cGroup %group% of %server% does not exist!").getOrSet();
+        DELETE_SERVER = new ConfigSectionHelper<String>(this, "delete-server", "&cGroup %group% of %server% has been deleted!").getOrSet();
+        DELETE_SERVER_CONFIRM = new ConfigSectionHelper<String>(this, "delete-confirmation-server", "&4Warning! &7This command will &cdelete the group of the server %server% with the whole list&7 of this group! &7Repeat the &esame command &7to confirm this action.").getOrSet();
+
+        CLEAR_SERVER = new ConfigSectionHelper<String>(this, "clear-server", "&aList of group %group% from %server% has been cleared!").getOrSet();
+        CLEAR_SERVER_CONFIRM = new ConfigSectionHelper<String>(this, "clear-confirmation-server", "&4Warning! &7This command will &cclear the entire list&7 of this group for %server%! &7Repeat the &esame command &7to confirm this action.").getOrSet();
+
+        LIST_SERVER_MESSAGE = new ConfigSectionHelper<String>(this, "list.message-server", "&7Listed commands of group %group% from %server% (&f%size%&7)&8: &f%commands%").getOrSet();
+        LIST_SERVER_SPLITTER = new ConfigSectionHelper<String>(this, "list.splitter-server", "&7, ").getOrSet();
+        LIST_SERVER_COMMAND = new ConfigSectionHelper<String>(this, "list.command-server", "&f%group%").getOrSet();
+
+        LIST_GROUP_SERVER_MESSAGE = new ConfigSectionHelper<String>(this, "list-groups.message-server", "&7All groups from %server% (&f%size%&7)&8: &f%groups%").getOrSet();
+        LIST_GROUP_SERVER_SPLITTER = new ConfigSectionHelper<String>(this, "list-groups.splitter-server", "&7, ").getOrSet();
+        LIST_GROUP_SERVER_GROUPS = new ConfigSectionHelper<String>(this, "list-groups.command-server", "&f%group%").getOrSet();
+
+        ADD_SERVER_SUCCESS = new ConfigSectionHelper<String>(this, "add.success-server", "&aSuccessfully added %command% into the list of group %group% for %server%!").getOrSet();
+        ADD_SERVER_FAILED = new ConfigSectionHelper<String>(this, "add.failed-server", "&c%command% is already in the list of group %group% of %server%!").getOrSet();
+
+        REMOVE_SERVER_SUCCESS = new ConfigSectionHelper<String>(this, "remove.success-server", "&aSuccessfully removed %command% from the list of group %group% from %server%!").getOrSet();
+        REMOVE_SERVER_FAILED = new ConfigSectionHelper<String>(this, "remove.failed-server", "&c%command% is not listed in the group %group% of %server%!").getOrSet();
+
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/HelpSection.java

@@ -0,0 +1,61 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.MultipleMessagesHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+import java.util.Arrays;
+
+public class HelpSection extends ConfigStorage {
+
+    public MultipleMessagesHelper MESSAGE;
+
+    public HelpSection() {
+        super("help");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        MESSAGE = new MultipleMessagesHelper(this, null, Reflection.isProxyServer() ?
+                Arrays.asList(
+                        "&7Available commands are: &f/%label%&7..."
+                        , "&7Format: &8<optional> (required)"
+                        , "&f  reload &7to reload the plugin"
+                        , "&f  notify &7to get alerted"
+                        , "&f  info &7to get a few information"
+                        , "&f  postdebug &7to post the PAT logs"
+                        , "&f  update <player> &7to update player(s) permissions"
+                        , "&f  perms <player> &7to check a player's permissions"
+                        , "&f  creategroup (group) &7Create a group"
+                        , "&f  deletegroup (group) &7Delete a group"
+                        , "&f  setpriority (group) (priority) &7to set the priority"
+                        , "&f  list &8(optional: group) &7to see all listed commands"
+                        , "&f  listgroups &7List all groups"
+                        , "&f  listpriorities &7to list all group priorities"
+                        , "&f  add/rem (command) &8<group> &7to manage the list"
+                        , "&f  clear &8<group> &7to clear the list")
+                :
+                Arrays.asList(
+                        "&7Available commands are: &f/%label%&7..."
+                        , "&7Format: &8<optional> (required)"
+                        , "&f  reload &7to reload the plugin"
+                        , "&f  notify &7to get alerted"
+                        , "&f  info &7to get a few information"
+                        , "&f  postdebug &7to post the PAT logs"
+                        , "&f  update <player> &7to update player(s) permissions"
+                        , "&f  perms <player> &7to check a player's permissions"
+                        , "&f  creategroup (group) &7Create a group"
+                        , "&f  deletegroup (group) &7Delete a group"
+                        , "&f  setpriority (group) (priority) &7to set the priority"
+                        , "&f  list &8<group> &7to see all listed commands"
+                        , "&f  listgroups &8<server> &7List all groups"
+                        , "&f  listpriorities &7to list all group priorities"
+                        , "&f  add/rem (command) &8<group> &7to manage the list"
+                        , "&f  clear &8<group> &7to clear the list"
+                        , "&7 For a specific server:"
+                        , "&f  serv list (server) &8<group>"
+                        , "&f  serv add/rem (server) (command) &8<group>"
+                        , "&f  serv clear (server) &8<group>"
+                ));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/InfoSection.java

@@ -0,0 +1,36 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import java.util.Arrays;
+
+public class InfoSection extends ConfigStorage {
+
+    public String VERSION_OUTDATED, VERSION_UPDATED, SYNC_TIME, SYNC_DISABLED;
+    public MultipleMessagesHelper MESSAGE;
+
+    public InfoSection() {
+        super("info");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+
+        VERSION_UPDATED = new ConfigSectionHelper<String>(this, "version.updated", "&aLatest version").getOrSet();
+        VERSION_OUTDATED = new ConfigSectionHelper<String>(this, "version.outdated", "&cOutdated (%newest_version%)").getOrSet();
+        SYNC_TIME = new ConfigSectionHelper<String>(this, "proxy-sync.time", "&e%time%").getOrSet();
+        SYNC_DISABLED = new ConfigSectionHelper<String>(this, "proxy-sync.disabled", "&cDisabled").getOrSet();
+
+        MESSAGE = new MultipleMessagesHelper(this, "message",
+                Arrays.asList(
+                        "&7Necessary information about &fPAT&8:"
+                        , "&7  Version: &e%current_version%"
+                        , "&7  Status: %version_status%"
+                        , "&7  Last sync with proxy: &e%sync_time%"
+                        , "&7  Proxy sync-token: &e%token%"
+                        , "&7  Proxy-received server name: &e%sync_server_name%"
+                )
+        );
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/NoPermissionSection.java

@@ -0,0 +1,19 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class NoPermissionSection extends ConfigStorage {
+
+    public String MESSAGE;
+
+    public NoPermissionSection() {
+        super("no-permissions");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        MESSAGE = new ConfigSectionHelper<String>(this, null, "&cYou are not allowed to execute this command! Missing permission: &4proantitab.%permission%").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/NotificationSection.java

@@ -0,0 +1,24 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import de.rayzs.pat.utils.Reflection;
+import java.util.Collections;
+
+public class NotificationSection extends ConfigStorage {
+
+    public String ENABLED, DISABLED;
+    public MultipleMessagesHelper ALERT;
+
+    public NotificationSection() {
+        super("notification");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<String>(this, "enabled", "&aEnabled notifications").getOrSet();
+        DISABLED = new ConfigSectionHelper<String>(this, "disabled", "&cDisabled notifications").getOrSet();
+        ALERT = new MultipleMessagesHelper(this, "alert", Collections.singletonList("&8[&4ALERT&8] &c%player% &8(&7" + (Reflection.isProxyServer() ? "server: &e%server%" : "world: &e%world%") + "&8) &ctried to execute the following blocked command: &4%command%"));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/OnlyForProxySection.java

@@ -0,0 +1,21 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+
+public class OnlyForProxySection extends ConfigStorage {
+
+    public String MESSAGE;
+
+    public OnlyForProxySection() {
+        super("only-for-proxy");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        if(Reflection.isProxyServer()) return;
+        MESSAGE = new ConfigSectionHelper<String>(this, null, "&cThis command works on Bungeecord/Velocity servers only!").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/PermsCheckSection.java

@@ -0,0 +1,21 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+
+public class PermsCheckSection extends ConfigStorage {
+
+    public String MESSAGE, PLAYER_MISSING, PLAYER_NOT_ONLINE;
+
+    public PermsCheckSection() {
+        super("perms-check");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        MESSAGE = new ConfigSectionHelper<String>(this, "message", "&7All of &e%player%'s &7PAT-related permission: &e%permissions%").getOrSet();
+        PLAYER_MISSING = new ConfigSectionHelper<String>(this, "player-is-missing", "&cPlease specify the player whose permission you want to check.").getOrSet();
+        PLAYER_NOT_ONLINE = new ConfigSectionHelper<String>(this, "player-not-online", "&c%player% is not online!").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/PostDebugSection.java

@@ -0,0 +1,20 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class PostDebugSection extends ConfigStorage {
+
+    public String SUCCESS, FAILED;
+
+    public PostDebugSection() {
+        super("post-debug");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SUCCESS = new ConfigSectionHelper<String>(this, "success", "&aSuccessfully uploaded debug logs: &e%link% &8(<click:open_url:%link%><gray>CLICK</click>&8)").getOrSet();
+        FAILED = new ConfigSectionHelper<String>(this, "failed", "&cFailed to upload debug logs!").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/PrefixSection.java

@@ -0,0 +1,19 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class PrefixSection extends ConfigStorage {
+
+    public String PREFIX;
+
+    public PrefixSection() {
+        super("prefix");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        PREFIX = new ConfigSectionHelper<String>(this, null, "&8[&4ProAntiTab&8]").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/ReloadSection.java

@@ -0,0 +1,20 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class ReloadSection extends ConfigStorage {
+
+    public String LOADING, DONE;
+
+    public ReloadSection() {
+        super("reload");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        LOADING = new ConfigSectionHelper<String>(this, "loading", "&eReloading all configuration files...").getOrSet();
+        DONE = new ConfigSectionHelper<String>(this, "done", "&aSuccessfully reloaded all configuration files!").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/ServerListSection.java

@@ -0,0 +1,32 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+
+public class ServerListSection extends ConfigStorage {
+
+    public String SERVER_DOES_NOT_EXIST, GROUP_DOES_NOT_EXIST;
+    public String LIST_SERVER_MESSAGE, LIST_SERVER_SPLITTER, LIST_SERVER_COMMAND, LIST_GROUP_MESSAGE, LIST_GROUP_SPLITTER, LIST_GROUP_COMMAND;
+
+    public ServerListSection() {
+        super("server-list");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        if(!Reflection.isProxyServer()) return;
+
+        SERVER_DOES_NOT_EXIST = new ConfigSectionHelper<String>(this, "server-not-found", "&cThe server %server% does not have any commands!").getOrSet();
+        GROUP_DOES_NOT_EXIST = new ConfigSectionHelper<String>(this, "group-does-not-exist", "&cGroup %group% does not exist for %server%!").getOrSet();
+
+        LIST_SERVER_MESSAGE = new ConfigSectionHelper<String>(this, "list.server.message", "&7Listed commands of %server% (&f%size%&7)&8: &f%commands%").getOrSet();
+        LIST_SERVER_SPLITTER = new ConfigSectionHelper<String>(this, "list.server.splitter", "&7, ").getOrSet();
+        LIST_SERVER_COMMAND = new ConfigSectionHelper<String>(this, "list.server.command", "&f%command%").getOrSet();
+
+        LIST_GROUP_MESSAGE = new ConfigSectionHelper<String>(this, "list.group.message", "&7Listed commands of %group% from %server% (&f%size%&7)&8: &f%commands%").getOrSet();
+        LIST_GROUP_SPLITTER = new ConfigSectionHelper<String>(this, "list.group.splitter", "&7, ").getOrSet();
+        LIST_GROUP_COMMAND = new ConfigSectionHelper<String>(this, "list.group.command", "&f%command%").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/StatsSection.java

@@ -0,0 +1,30 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import de.rayzs.pat.utils.Reflection;
+
+import java.util.Arrays;
+
+public class StatsSection extends ConfigStorage {
+
+    public String NO_SERVER, SPLITTER, SERVER;
+    public MultipleMessagesHelper STATISTIC;
+
+    public StatsSection() {
+        super("stats");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        if(!Reflection.isProxyServer()) return;
+        NO_SERVER = new ConfigSectionHelper<String>(this, "no-server", "&cNone!").getOrSet();
+        SPLITTER = new ConfigSectionHelper<String>(this, "message.splitter", "&7, ").getOrSet();
+        SERVER = new ConfigSectionHelper<String>(this, "message.server", "&f%servername% &8(%updated%)").getOrSet();
+        STATISTIC = new MultipleMessagesHelper(this, "message.statistic", Arrays.asList(
+                "&7Last sync sent to &f%server_count% &7servers. &8&o(%last_sync_time% ago)",
+                "&7Sent to servers: &f%servers%"
+                ));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/messages/UpdatePermissionsSection.java

@@ -0,0 +1,21 @@
+package de.rayzs.pat.api.storage.config.messages;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class UpdatePermissionsSection extends ConfigStorage {
+
+    public String UPDATE_ALL, UPDATE_SPECIFIC, PLAYER_NOT_ONLINE;
+
+    public UpdatePermissionsSection() {
+        super("update-permissions");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        UPDATE_ALL = new ConfigSectionHelper<String>(this, "all-players", "&aUpdated permissions!").getOrSet();
+        UPDATE_SPECIFIC = new ConfigSectionHelper<String>(this, "specific-player", "&aUpdated %target%'s permissions!").getOrSet();
+        PLAYER_NOT_ONLINE = new ConfigSectionHelper<String>(this, "player-not-online", "&c%target% is not online!").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/BlockNamespaceCommandsSection.java

@@ -0,0 +1,34 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+
+import java.util.UUID;
+
+public class BlockNamespaceCommandsSection extends ConfigStorage {
+
+    public boolean ENABLED;
+
+    public BlockNamespaceCommandsSection() {
+        super("block-namespace-commands");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+    }
+
+    public boolean isCommand(String command) {
+        if(!ENABLED || Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED) return false;
+        return StringUtils.getFirstArg(command).contains(":");
+    }
+
+    public boolean doesBypass(Object targetObj) {
+
+        return !ENABLED || PermissionUtil.hasPermission(targetObj, "namespace");
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/CancelCommandSection.java

@@ -0,0 +1,23 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import java.util.Collections;
+
+public class CancelCommandSection extends ConfigStorage {
+
+    public boolean ENABLED;
+    public MultipleMessagesHelper BASE_COMMAND_RESPONSE, SUB_COMMAND_RESPONSE;
+
+    public CancelCommandSection() {
+        super("cancel-blocked-commands");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        BASE_COMMAND_RESPONSE = new MultipleMessagesHelper(this, "base-command-message", Collections.singletonList("&cThe command %command% is blocked!"));
+        SUB_COMMAND_RESPONSE = new MultipleMessagesHelper(this, "sub-command-message", Collections.singletonList("&cThis sub-argument is blocked!"));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/CustomBrandSection.java

@@ -0,0 +1,38 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import java.util.Arrays;
+
+public class CustomBrandSection extends ConfigStorage {
+
+    public boolean ENABLED;
+    public int REPEAT_DELAY;
+    public MultipleMessagesHelper BRANDS;
+
+    public CustomBrandSection() {
+        super("custom-server-brand");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", false).getOrSet();
+        REPEAT_DELAY = new ConfigSectionHelper<Integer>(this, "repeat-delay", 3).getOrSet();
+        BRANDS = new MultipleMessagesHelper(this, "brands", Arrays.asList(
+                "&f&lP&froAntiTab |",
+                "&fP&lr&foAntiTab /",
+                "&fPr&lo&fAntiTab -",
+                "&fPro&lA&fntiTab |",
+                "&fProA&ln&ftiTab \\",
+                "&fProAn&lt&fiTab |",
+                "&fProAnt&li&fTab /",
+                "&fProAnti&lT&fab -",
+                "&fProAnti&lT&fab \\",
+                "&fProAntiT&la&fb |",
+                "&fProAntiTa&lb&f /",
+                "&fProAntiTab -",
+                "&fProAntiTab \\"
+        ));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/CustomPluginsSection.java

@@ -0,0 +1,47 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import java.util.*;
+
+public class CustomPluginsSection extends ConfigStorage {
+
+    public boolean ENABLED, ALWAYS_TAB_COMPLETABLE;
+    public MultipleMessagesHelper MESSAGE, COMMANDS;
+
+    public CustomPluginsSection() {
+        super("custom-plugins");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        ALWAYS_TAB_COMPLETABLE = new ConfigSectionHelper<Boolean>(this, "always-tab-completable", false).getOrSet();
+        COMMANDS = new MultipleMessagesHelper(this, "commands", Arrays.asList("pl", "plugins"));
+        MESSAGE = new MultipleMessagesHelper(this, "message", Collections.singletonList("&fPlugins (0):"));
+    }
+
+    public boolean isTabCompletable(String command) {
+        if (!isCommand(command))
+            return false;
+
+        return ALWAYS_TAB_COMPLETABLE;
+    }
+
+    public boolean isCommand(String command) {
+        if(!ENABLED) return false;
+
+        if (command.contains(" ")) {
+            String[] split = command.split(" ");
+            if (split.length > 0)
+                command = split[0];
+            command = command.split(" ")[0];
+        }
+        for (String currentCommand : COMMANDS.getLines()) {
+            if (currentCommand.equalsIgnoreCase(command))
+                return true;
+        }
+        return false;
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/CustomProtocolPingSection.java

@@ -0,0 +1,33 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+
+public class CustomProtocolPingSection extends ConfigStorage {
+
+    public boolean ENABLED, ALWAYS_SHOW, HIDE_PLAYERS, USE_EXTEND_AS_MAX_COUNT;
+    public String PROTOCOL;
+    public int EXTEND_COUNT;
+
+    public CustomProtocolPingSection() {
+        super("custom-protocol-ping");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        if(!Reflection.isProxyServer()) {
+            if(!Reflection.isPaper() || Reflection.getMinor() < 12)
+            return;
+        }
+
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        ALWAYS_SHOW = new ConfigSectionHelper<Boolean>(this, "always-show", Reflection.isProxyServer() || Reflection.isPaper()).getOrSet();
+        USE_EXTEND_AS_MAX_COUNT = new ConfigSectionHelper<Boolean>(this, "use-as-maxplayers", false).getOrSet();
+        PROTOCOL = new ConfigSectionHelper<String>(this, "protocol", "&f&lProAntiTab &7(&a%online%&7/&c%max%&7)").getOrSet();
+        EXTEND_COUNT = new ConfigSectionHelper<Integer>(this, "extend-online-count", 1).getOrSet();
+        if(Reflection.isProxyServer()) return;
+        HIDE_PLAYERS = new ConfigSectionHelper<Boolean>(this, "hide-players", true).getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/CustomUnknownCommandSection.java

@@ -0,0 +1,25 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import de.rayzs.pat.api.storage.Storage;
+import java.util.Collections;
+
+public class CustomUnknownCommandSection extends ConfigStorage {
+
+    public boolean ENABLED;
+    public MultipleMessagesHelper MESSAGE;
+
+    public CustomUnknownCommandSection() {
+        super("custom-unknown-command");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+
+        if(Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED) return;
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        MESSAGE = new MultipleMessagesHelper(this, "message", Collections.singletonList("&cThis command does not exist!"));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/CustomVersionSection.java

@@ -0,0 +1,43 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import de.rayzs.pat.utils.StringUtils;
+import java.util.*;
+
+public class CustomVersionSection extends ConfigStorage {
+
+    public boolean ENABLED, ALWAYS_TAB_COMPLETABLE;
+    public MultipleMessagesHelper MESSAGE, COMMANDS;
+
+    public CustomVersionSection() {
+        super("custom-version");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        ALWAYS_TAB_COMPLETABLE = new ConfigSectionHelper<Boolean>(this, "always-tab-completable", false).getOrSet();
+        COMMANDS = new MultipleMessagesHelper(this, "commands", Arrays.asList("icanhasbukkit", "about", "ver", "version"));
+        MESSAGE = new MultipleMessagesHelper(this, "message", Collections.singletonList("&fThis server is running CraftBukkit version git-NasaSpigot-294 (MC: X)"));
+    }
+
+    public boolean isTabCompletable(String command) {
+        if (!isCommand(command))
+            return false;
+
+        return ALWAYS_TAB_COMPLETABLE;
+    }
+
+    public boolean isCommand(String command) {
+        if(!ENABLED) return false;
+        command = StringUtils.getFirstArg(command);
+
+        for (String currentCommand : COMMANDS.getLines()) {
+            if (currentCommand.equalsIgnoreCase(command))
+                return true;
+        }
+        return false;
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/DisableSyncSection.java

@@ -0,0 +1,22 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.utils.Reflection;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+
+public class DisableSyncSection extends ConfigStorage {
+
+    public boolean DISABLED;
+
+    public DisableSyncSection() {
+        super("disable-sync");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+
+        if(!Reflection.isProxyServer()) return;
+        DISABLED = new ConfigSectionHelper<Boolean>(this, null, false).getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/HandleThroughProxySection.java

@@ -0,0 +1,24 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.Reflection;
+
+public class HandleThroughProxySection extends ConfigStorage {
+
+    public boolean ENABLED;
+    public String TOKEN;
+
+    public HandleThroughProxySection() {
+        super("handle-through-proxy");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        if(Reflection.isProxyServer()) return;
+
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", false).getOrSet();
+        TOKEN = new ConfigSectionHelper<String>(this, "token", "insert-token-of-proxy-here").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/PatchExploitSection.java

@@ -0,0 +1,32 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import de.rayzs.pat.utils.StringUtils;
+import java.util.Collections;
+
+public class PatchExploitSection extends ConfigStorage {
+
+    public boolean ENABLED;
+    public ConfigSectionHelper<String> ALERT_MESSAGE, KICK_MESSAGE;
+
+    public PatchExploitSection() {
+        super("patch-exploits");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        ALERT_MESSAGE = new ConfigSectionHelper<>(this, "alert-message", "%prefix% &4%player% &ctried to crash/lag the server.");
+        KICK_MESSAGE = new ConfigSectionHelper(this, "kick-message", "&cFailed to read packet! Please reconnect.");
+    }
+
+    public boolean isMalicious(String text) {
+        if(!ENABLED) return false;
+
+        return text.length() > 256
+                || text.contains("nbt")
+                && (StringUtils.countMatches('[', text) > 15 || StringUtils.countMatches('{', text) > 25);
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/TurnBlacklistToWhitelistSection.java

@@ -0,0 +1,19 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+
+public class TurnBlacklistToWhitelistSection extends ConfigStorage {
+
+    public boolean ENABLED;
+
+    public TurnBlacklistToWhitelistSection() {
+        super("turn-blacklist-to-whitelist");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, null, false).getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/config/settings/UpdateSection.java

@@ -0,0 +1,30 @@
+package de.rayzs.pat.api.storage.config.settings;
+
+import de.rayzs.pat.api.storage.storages.ConfigStorage;
+import de.rayzs.pat.utils.configuration.helper.*;
+import java.util.*;
+
+public class UpdateSection extends ConfigStorage {
+
+    public boolean ENABLED, AUTO_UPDATE_CONFIG;
+    public int PERIOD;
+    public MultipleMessagesHelper OUTDATED, UPDATED;
+
+    public UpdateSection() {
+        super("updater");
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        PERIOD = new ConfigSectionHelper<Integer>(this, "period", 10000).getOrSet();
+        AUTO_UPDATE_CONFIG = new ConfigSectionHelper<Boolean>(this, "auto-update-config", true).getOrSet();
+        UPDATED = new MultipleMessagesHelper(this, "updated", Collections.singletonList("&aYou are using the newest version! ^^"));
+        OUTDATED = new MultipleMessagesHelper(this, "outdated", Arrays.asList(
+                "&8[&4ProAntiTab&8] &cThere is a new version available! (%newest_version%)",
+                "&8[&4ProAntiTab&8] &cYou are still using the %current_version%.",
+                "&8[&4ProAntiTab&8] &cGet the newest version here:",
+                "&8[&4ProAntiTab&8] &ehttps://www.rayzs.de/products/proantitab/page"));
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/general/ListCommandsPlaceholder.java

@@ -0,0 +1,31 @@
+package de.rayzs.pat.api.storage.placeholders.commands.general;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+
+public class ListCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListCommandsPlaceholder() { super("list_commands"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return StringUtils.buildStringList(
+                Storage.Blacklist.getBlacklist().getCommands(),
+                SPLITTER,
+                COMMAND,
+                "%command%"
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "command", "&f%command%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/general/ListReversedCommandsPlaceholder.java

@@ -0,0 +1,32 @@
+package de.rayzs.pat.api.storage.placeholders.commands.general;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+
+public class ListReversedCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListReversedCommandsPlaceholder() { super("list_reversed_commands"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return StringUtils.buildSortedStringList(
+                Storage.Blacklist.getBlacklist().getCommands(),
+                SPLITTER,
+                COMMAND,
+                "%command%",
+                true
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "command", "&f%command%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/general/ListSizeCommandsPlaceholder.java

@@ -0,0 +1,20 @@
+package de.rayzs.pat.api.storage.placeholders.commands.general;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import org.bukkit.entity.Player;
+
+public class ListSizeCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListSizeCommandsPlaceholder() { super("list_size_commands"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return String.valueOf(Storage.Blacklist.getBlacklist().getCommands().size());
+    }
+
+    @Override
+    public void load() {
+        super.load();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/general/ListSortedCommandsPlaceholder.java

@@ -0,0 +1,32 @@
+package de.rayzs.pat.api.storage.placeholders.commands.general;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+
+public class ListSortedCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListSortedCommandsPlaceholder() { super("list_sorted_commands"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return StringUtils.buildSortedStringList(
+                Storage.Blacklist.getBlacklist().getCommands(),
+                SPLITTER,
+                COMMAND,
+                "%command%",
+                false
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "command", "&f%command%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/group/ListGroupCommandsPlaceholder.java

@@ -0,0 +1,34 @@
+package de.rayzs.pat.api.storage.placeholders.commands.group;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListGroupCommandsPlaceholder() { super("list_commands_group_"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+
+        return StringUtils.buildStringList(
+                group.getCommands(),
+                SPLITTER,
+                COMMAND,
+                "%command%"
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "command", "&f%command%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/group/ListGroupReversedCommandsPlaceholder.java

@@ -0,0 +1,35 @@
+package de.rayzs.pat.api.storage.placeholders.commands.group;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupReversedCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListGroupReversedCommandsPlaceholder() { super("list_reversed_commands_group_"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+
+        return StringUtils.buildSortedStringList(
+                group.getCommands(),
+                SPLITTER,
+                COMMAND,
+                "%command%",
+                true
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "command", "&f%command%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/group/ListGroupSizeCommandsPlaceholder.java

@@ -0,0 +1,22 @@
+package de.rayzs.pat.api.storage.placeholders.commands.group;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupSizeCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListGroupSizeCommandsPlaceholder() { super("list_size_commands_group_"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+        return String.valueOf(group.getCommands().size());
+    }
+
+    @Override
+    public void load() {
+        super.load();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/commands/group/ListGroupSortedCommandsPlaceholder.java

@@ -0,0 +1,35 @@
+package de.rayzs.pat.api.storage.placeholders.commands.group;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupSortedCommandsPlaceholder extends PlaceholderStorage {
+
+    public ListGroupSortedCommandsPlaceholder() { super("list_sorted_commands_group_"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+
+        return StringUtils.buildSortedStringList(
+                group.getCommands(),
+                SPLITTER,
+                COMMAND,
+                "%command%",
+                false
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "command", "&f%command%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/general/GeneralCurrentVersionPlaceholder.java

@@ -0,0 +1,15 @@
+package de.rayzs.pat.api.storage.placeholders.general;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import org.bukkit.entity.Player;
+
+public class GeneralCurrentVersionPlaceholder extends PlaceholderStorage {
+
+    public GeneralCurrentVersionPlaceholder() { super("general_version_current"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return Storage.CURRENT_VERSION;
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/general/GeneralNewestVersionPlaceholder.java

@@ -0,0 +1,15 @@
+package de.rayzs.pat.api.storage.placeholders.general;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import org.bukkit.entity.Player;
+
+public class GeneralNewestVersionPlaceholder extends PlaceholderStorage {
+
+    public GeneralNewestVersionPlaceholder() { super("general_version_newest"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return Storage.NEWER_VERSION;
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/general/GeneralUserPlaceholder.java

@@ -0,0 +1,23 @@
+package de.rayzs.pat.api.storage.placeholders.general;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import org.bukkit.entity.Player;
+
+public class GeneralUserPlaceholder extends PlaceholderStorage {
+
+    public GeneralUserPlaceholder() { super("general_user"); }
+
+    public String CONSOLE;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return player == null ? CONSOLE : player.getName();
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        CONSOLE = new ConfigSectionHelper<String>(this, "console-name", "Server console").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/groups/ListGroupsPlaceholder.java

@@ -0,0 +1,34 @@
+package de.rayzs.pat.api.storage.placeholders.groups;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupsPlaceholder extends PlaceholderStorage {
+
+    public ListGroupsPlaceholder() { super("list_groups"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+
+        return StringUtils.buildStringList(
+                GroupManager.getGroupNames(),
+                SPLITTER,
+                COMMAND,
+                "%group%"
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "group", "&f%group%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/groups/ListGroupsReversedPlaceholder.java

@@ -0,0 +1,35 @@
+package de.rayzs.pat.api.storage.placeholders.groups;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupsReversedPlaceholder extends PlaceholderStorage {
+
+    public ListGroupsReversedPlaceholder() { super("list_reversed_groups"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+
+        return StringUtils.buildSortedStringList(
+                GroupManager.getGroupNames(),
+                SPLITTER,
+                COMMAND,
+                "%group%",
+                true
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "group", "&f%group%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/groups/ListGroupsSortedPlaceholder.java

@@ -0,0 +1,35 @@
+package de.rayzs.pat.api.storage.placeholders.groups;
+
+import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import de.rayzs.pat.utils.group.*;
+import org.bukkit.entity.Player;
+
+public class ListGroupsSortedPlaceholder extends PlaceholderStorage {
+
+    public ListGroupsSortedPlaceholder() { super("list_sorted_groups"); }
+
+    public String COMMAND, SPLITTER;
+
+    @Override
+    public String onRequest(Player player, String param) {
+        Group group = GroupManager.getGroupByName(param);
+        if(group == null) return null;
+
+        return StringUtils.buildSortedStringList(
+                GroupManager.getGroupNames(),
+                SPLITTER,
+                COMMAND,
+                "%command%",
+                false
+        );
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        SPLITTER = new ConfigSectionHelper<String>(this, "splitter", "&7-> ").getOrSet();
+        COMMAND = new ConfigSectionHelper<String>(this, "group", "&f%group%\\n").getOrSet();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/groups/ListSizeGroupsPlaceholder.java

@@ -0,0 +1,20 @@
+package de.rayzs.pat.api.storage.placeholders.groups;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.group.GroupManager;
+import org.bukkit.entity.Player;
+
+public class ListSizeGroupsPlaceholder extends PlaceholderStorage {
+
+    public ListSizeGroupsPlaceholder() { super("list_size_groups"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return String.valueOf(GroupManager.getGroups().size());
+    }
+
+    @Override
+    public void load() {
+        super.load();
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/messages/BlockedBaseCommandPlaceholder.java

@@ -0,0 +1,16 @@
+package de.rayzs.pat.api.storage.placeholders.messages;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+
+public class BlockedBaseCommandPlaceholder extends PlaceholderStorage {
+
+    public BlockedBaseCommandPlaceholder() { super("message_base_blocked"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return StringUtils.buildStringList(Storage.ConfigSections.Settings.CANCEL_COMMAND.BASE_COMMAND_RESPONSE.getLines());
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/messages/BlockedSubCommandPlaceholder.java

@@ -0,0 +1,16 @@
+package de.rayzs.pat.api.storage.placeholders.messages;
+
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+
+public class BlockedSubCommandPlaceholder extends PlaceholderStorage {
+
+    public BlockedSubCommandPlaceholder() { super("message_sub_blocked"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return StringUtils.buildStringList(Storage.ConfigSections.Settings.CANCEL_COMMAND.SUB_COMMAND_RESPONSE.getLines());
+    }
+}

src/main/java/de/rayzs/pat/api/storage/placeholders/messages/UnknownCommandPlaceholder.java

@@ -0,0 +1,16 @@
+package de.rayzs.pat.api.storage.placeholders.messages;
+
+import de.rayzs.pat.api.storage.storages.PlaceholderStorage;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+
+public class UnknownCommandPlaceholder extends PlaceholderStorage {
+
+    public UnknownCommandPlaceholder() { super("message_unknowncommand"); }
+
+    @Override
+    public String onRequest(Player player, String param) {
+        return StringUtils.buildStringList(Storage.ConfigSections.Settings.CUSTOM_UNKNOWN_COMMAND.MESSAGE.getLines());
+    }
+}

src/main/java/de/rayzs/pat/api/storage/storages/BlacklistStorage.java

@@ -0,0 +1,189 @@
+package de.rayzs.pat.api.storage.storages;
+
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.api.storage.*;
+import java.io.Serializable;
+import java.util.*;
+
+public class BlacklistStorage extends StorageTemplate implements Serializable {
+
+    private List<String> commands = new ArrayList<>();
+
+    public BlacklistStorage(String navigatePath) {
+        super(Storage.Files.STORAGE, navigatePath);
+    }
+
+    public boolean isListed(String command) {
+        return isListed(command, false);
+    }
+
+    public boolean isConverted(String command, boolean intensive) {
+        return !command.contains(" ") && (intensive && !command.contains(":"));
+    }
+
+    public String convertCommand(String command, boolean intensive, boolean lowerCase) {
+        return convertCommand(command, intensive, lowerCase, true);
+    }
+
+    public String convertCommand(String command, boolean intensive, boolean lowerCase, boolean slash) {
+        if(isConverted(command, intensive)) return command;
+        if(lowerCase) command = command.toLowerCase();
+
+        if(slash)
+            if(command.startsWith("/")) command = command.replaceFirst("/", "");
+
+        String[] split;
+        if(command.contains(" ")) {
+            split = command.split(" ");
+            if(split.length > 0) command = split[0];
+        }
+
+        if(intensive && command.contains(":")) {
+            split = command.split(":");
+            if(split.length > 0)
+                command = command.replaceFirst(split[0] + ":", "");
+        }
+
+        return command;
+    }
+
+    public boolean isListed(String command, boolean intensive) {
+        if(commands == null) {
+            Logger.warning("&cFailed to check command \"" + command + "\"! PAT couldn't read the commands from the storage.yml at section &4" + getNavigatePath() + "&c! Please ensure that your storage.yml isn't corrupt or contains any spaces or empty commands. If this problem still remains, please join my Discord server to ask for help there. &8(&erayzs.de/discord&8)");
+            return false;
+        }
+
+        if(!isConverted(command, intensive)) command = convertCommand(command, intensive, true);
+
+        for (String commands : commands) {
+            if(commands == null) continue;
+            if (commands.equals(command)) return true;
+        }
+
+        return false;
+    }
+
+    public boolean isListed(String command, boolean intensive, boolean convert, boolean slash) {
+        if(commands == null) {
+            Logger.warning("&cFailed to check command \"" + command + "\"! PAT couldn't read the commands from the storage.yml at section &4" + getNavigatePath() + "&c! Please ensure that your storage.yml isn't corrupt or contains any spaces or empty commands. If this problem still remains, please join my Discord server to ask for help there. &8(&erayzs.de/discord&8)");
+            return false;
+        }
+
+        if(convert)
+            if(!isConverted(command, intensive)) command = convertCommand(command, intensive, true, slash);
+
+        for (String commands : commands) {
+            if(commands == null) continue;
+            if (commands.equals(command)) return true;
+        }
+
+        return false;
+    }
+
+    public boolean isListed(String command, boolean intensive, boolean convert) {
+        if(commands == null) {
+            Logger.warning("&cFailed to check command \"" + command + "\"! PAT couldn't read the commands from the storage.yml at section &4" + getNavigatePath() + "&c! Please ensure that your storage.yml isn't corrupt or contains any spaces or empty commands. If this problem still remains, please join my Discord server to ask for help there. &8(&erayzs.de/discord&8)");
+            return false;
+        }
+
+        if(convert)
+            if(!isConverted(command, intensive)) command = convertCommand(command, intensive, true);
+
+        for (String commands : commands) {
+            if(commands == null) continue;
+            if (commands.equals(command)) return true;
+        }
+        return false;
+    }
+
+    public boolean isBlocked(Object targetObj, String command) {
+        return isBlocked(targetObj, command, false);
+    }
+
+    public boolean isBlocked(Object targetObj, String command, boolean intensive) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive) && !PermissionUtil.hasBypassPermission(targetObj, command);
+        else
+            return isListed(command, intensive) && !PermissionUtil.hasBypassPermission(targetObj, command);
+    }
+
+    public boolean isBlockedIgnorePermission(String command, boolean intensive) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive);
+        else
+            return isListed(command, intensive);
+    }
+
+    public boolean isBlocked(Object targetObj, String command, boolean intensive, boolean convert) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive, convert) && !PermissionUtil.hasBypassPermission(targetObj, command);
+        else
+            return isListed(command, intensive, convert) && !PermissionUtil.hasBypassPermission(targetObj, command);
+    }
+
+    public boolean isBlocked(Object targetObj, String command, boolean intensive, boolean convert, boolean slash) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive, convert, slash) && !PermissionUtil.hasBypassPermission(targetObj, command);
+        else
+            return isListed(command, intensive, convert, slash) && !PermissionUtil.hasBypassPermission(targetObj, command);
+    }
+
+    public boolean isBlocked(String command, boolean intensive) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive);
+        else
+            return isListed(command, intensive);
+    }
+
+    public boolean isBlocked(String command, boolean intensive, boolean convert) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive, convert);
+        else
+            return isListed(command, intensive, convert);
+    }
+
+    public boolean isBlocked(String command, boolean intensive, boolean convert, boolean slash) {
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED)
+            return !isListed(command, intensive, convert, slash);
+        else
+            return isListed(command, intensive, convert, slash);
+    }
+
+    public void setList(List<String> commands) {
+        this.commands = commands;
+    }
+
+    public BlacklistStorage add(String command) {
+        command = command.toLowerCase();
+        if(!commands.contains(command))
+            commands.add(command);
+        return this;
+    }
+
+    public BlacklistStorage remove(String command) {
+        command = command.toLowerCase();
+        commands.remove(command);
+        return this;
+    }
+
+    public BlacklistStorage clear() {
+        commands.clear();
+        return this;
+    }
+
+    public List<String> getCommands() {
+        return commands;
+    }
+
+    @Override
+    public void save() {
+        getConfig().setAndSave(getNavigatePath(), commands);
+    }
+
+    @Override
+    public void load() {
+        getConfig().reload();
+        commands = (ArrayList<String>) getConfig().getOrSet(getNavigatePath(), commands);
+    }
+}

src/main/java/de/rayzs/pat/api/storage/storages/ConfigStorage.java

@@ -0,0 +1,17 @@
+package de.rayzs.pat.api.storage.storages;
+
+import de.rayzs.pat.api.storage.*;
+
+public class ConfigStorage extends StorageTemplate {
+
+    public ConfigStorage(String navigatePath) {
+        super(Storage.Files.CONFIGURATION, navigatePath);
+        Storage.ConfigSections.SECTIONS.add(this);
+    }
+
+    @Override
+    public void save() { getConfig().save(); }
+
+    @Override
+    public void load() { getConfig().reload(); }
+}

src/main/java/de/rayzs/pat/api/storage/storages/IgnoredServersStorage.java

@@ -0,0 +1,46 @@
+package de.rayzs.pat.api.storage.storages;
+
+import de.rayzs.pat.utils.Reflection;
+import de.rayzs.pat.api.storage.*;
+import java.util.*;
+
+public class IgnoredServersStorage extends StorageTemplate {
+
+    private List<String> servers = new ArrayList<>();
+
+    public IgnoredServersStorage(String navigatePath) {
+        super(Storage.Files.STORAGE, navigatePath);
+    }
+
+    public IgnoredServersStorage add(String server) {
+        server = server.toLowerCase();
+        if(!servers.contains(server))
+            servers.add(server);
+        return this;
+    }
+
+    public IgnoredServersStorage remove(String server) {
+        server = server.toLowerCase();
+        servers.remove(server);
+        return this;
+    }
+
+    public boolean isListed(String server) {
+        if(servers.isEmpty()) return false;
+        return Storage.isServer(server, servers);
+    }
+
+    public boolean isListEmpty() {
+        return servers.isEmpty();
+    }
+
+    @Override
+    public void save() { getConfig().save(); }
+
+    @Override
+    public void load() {
+        if(!Reflection.isProxyServer()) return;
+        getConfig().reload();
+        servers = (ArrayList<String>) getConfig().getOrSet(getNavigatePath(), servers);
+   }
+}

src/main/java/de/rayzs/pat/api/storage/storages/PlaceholderStorage.java

@@ -0,0 +1,27 @@
+package de.rayzs.pat.api.storage.storages;
+
+import de.rayzs.pat.api.storage.*;
+import org.bukkit.entity.Player;
+
+public abstract class PlaceholderStorage extends StorageTemplate {
+
+    private final String request;
+
+    public PlaceholderStorage(String request) {
+        super(Storage.Files.PLACEHOLDERS, request);
+        this.request = request;
+        Storage.ConfigSections.PLACEHOLDERS.add(this);
+    }
+
+    @Override
+    public void save() { getConfig().save(); }
+
+    @Override
+    public void load() { getConfig().reload(); }
+
+    public String getRequest() {
+        return request;
+    }
+
+    public abstract String onRequest(Player player, String param);
+}

src/main/java/de/rayzs/pat/plugin/BukkitLoader.java

@@ -0,0 +1,297 @@
+package de.rayzs.pat.plugin;
+
+import de.rayzs.pat.plugin.modules.subargs.SubArgsModule;
+import de.rayzs.pat.utils.configuration.updater.ConfigUpdater;
+import de.rayzs.pat.api.netty.bukkit.BukkitPacketAnalyzer;
+import de.rayzs.pat.api.communication.BackendUpdater;
+import de.rayzs.pat.utils.configuration.Configurator;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.utils.adapter.ViaVersionAdapter;
+import de.rayzs.pat.api.communication.Communicator;
+import de.rayzs.pat.utils.adapter.LuckPermsAdapter;
+import de.rayzs.pat.plugin.commands.BukkitCommand;
+import de.rayzs.pat.api.brand.CustomServerBrand;
+import de.rayzs.pat.utils.hooks.PlaceholderHook;
+import de.rayzs.pat.plugin.listeners.bukkit.*;
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.utils.group.GroupManager;
+import de.rayzs.pat.plugin.metrics.bStats;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.utils.response.action.ActionHandler;
+import org.bukkit.plugin.java.JavaPlugin;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.scheduler.*;
+import org.bukkit.entity.Player;
+import java.lang.reflect.Field;
+import de.rayzs.pat.utils.*;
+import org.bukkit.command.*;
+import org.bukkit.plugin.*;
+import org.bukkit.Bukkit;
+import java.util.*;
+
+public class BukkitLoader extends JavaPlugin {
+
+    private static Plugin plugin;
+    private static java.util.logging.Logger logger;
+    private static boolean loaded = false, checkUpdate = false, suggestions = false;
+    private static Map<String, Command> commandsMap = null;
+    private PATSchedulerTask updaterTask;
+
+    @Override
+    public void onLoad() {
+        Configurator.createResourcedFile(getDataFolder(), "files\\bukkit-config.yml", "config.yml", false);
+        Configurator.createResourcedFile(getDataFolder(), "files\\bukkit-storage.yml", "storage.yml", false);
+        Configurator.createResourcedFile(getDataFolder(), "files\\bukkit-placeholders.yml", "placeholders.yml", false);
+        Configurator.createResourcedFile(getDataFolder(), "files\\bukkit-custom-responses.yml", "custom-responses.yml", false);
+    }
+
+    @Override
+    public void onEnable() {
+        plugin = this;
+        logger = getLogger();
+
+        loadCommandMap();
+
+        Reflection.initialize(getServer());
+        ConfigUpdater.initialize();
+
+        Storage.CURRENT_VERSION = getDescription().getVersion();
+        VersionComparer.setCurrentVersion(Storage.CURRENT_VERSION);
+
+        Storage.loadAll(true);
+
+        if(Bukkit.getServer().getPluginManager().getPlugin("PlaceholderAPI") != null)
+            new PlaceholderHook().register();
+
+        MessageTranslator.initialize();
+        CustomServerBrand.initialize();
+        bStats.initialize(this);
+
+        PluginManager manager = getServer().getPluginManager();
+
+        if(!Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED) {
+            loaded = true;
+            GroupManager.initialize();
+            BukkitPacketAnalyzer.injectAll();
+        } else BackendUpdater.handle();
+
+        manager.registerEvents(new BukkitPlayerConnectionListener(), this);
+        manager.registerEvents(new BukkitBlockCommandListener(), this);
+        if(Reflection.getMinor() >= 13) {
+            suggestions = true;
+            manager.registerEvents(new BukkitAntiTabListener(), this);
+        }
+
+        if(Reflection.isPaper() && Reflection.getMinor() >= 12)
+            manager.registerEvents(new PaperServerListPing(), this);
+
+        registerCommand("proantitab", "pat");
+        startUpdaterTask();
+
+        Storage.PLUGIN_OBJECT = this;
+
+        if(getServer().getPluginManager().getPlugin("LuckPerms") != null) {
+            LuckPermsAdapter.initialize();
+            Bukkit.getOnlinePlayers().forEach(player -> PermissionUtil.setPlayerPermissions(player.getUniqueId()));
+        }
+
+        if(getServer().getPluginManager().getPlugin("ViaVersion") != null)
+            ViaVersionAdapter.initialize();
+
+        if(Storage.USE_SIMPLECLOUD)
+            Logger.warning("Detected SimpleCloud. Therefore, MiniMessages are disabled!");
+
+        ConfigUpdater.broadcastMissingParts();
+        ActionHandler.initialize();
+        SubArgsModule.initialize();
+    }
+
+    @Override
+    public void onDisable() {
+        BackendUpdater.stop();
+        BukkitPacketAnalyzer.uninjectAll();
+        MessageTranslator.closeAudiences();
+    }
+
+    public void registerCommand(String... commands) {
+        BukkitCommand command = new BukkitCommand();
+        for (String commandName : commands) {
+            PluginCommand pluginCommand = getCommand(commandName);
+            pluginCommand.setExecutor(command);
+            pluginCommand.setTabCompleter(command);
+        }
+    }
+
+    public static List<String> getPlayerNames() {
+        List<String> result = new LinkedList<>();
+        Bukkit.getServer().getOnlinePlayers().forEach(player -> result.add(player.getName()));
+        return result;
+    }
+
+    public static UUID getUUIDByName(String playerName) {
+        Player player = Bukkit.getServer().getPlayer(playerName);
+        return player != null ? player.getUniqueId() : null;
+    }
+
+    public void startUpdaterTask() {
+        if (!Storage.ConfigSections.Settings.UPDATE.ENABLED) return;
+        updaterTask = PATScheduler.createAsyncScheduler(() -> {
+            String result = new ConnectionBuilder().setUrl("https://www.rayzs.de/proantitab/api/version.php")
+                    .setProperties("ProAntiTab", "4654").connect().getResponse();
+
+            if(result == null) result = "internet";
+            Storage.NEWER_VERSION = result;
+            VersionComparer.setNewestVersion(Storage.NEWER_VERSION);
+
+            if(VersionComparer.isDeveloperVersion()) {
+                updaterTask.cancelTask();
+                Logger.info("§8[§fPAT | Bukkit§8] §7Please be aware that you are currently using a §bdeveloper §7version of ProAntiTab. Bugs, errors and a lot of debug messages might be included.");
+
+            } else if(!checkUpdate && (VersionComparer.isNewest() || VersionComparer.isUnreleased())) {
+                updaterTask.cancelTask();
+                checkUpdate = true;
+
+                if(VersionComparer.isUnreleased()) {
+                    Logger.info("§8[§fPAT | Bukkit§8] §7Please be aware that you are currently using an §eunreleased §7version of ProAntiTab.");
+                    return;
+                }
+
+                Storage.ConfigSections.Settings.UPDATE.UPDATED.getLines().forEach(Logger::warning);
+
+            } else if(VersionComparer.isOutdated()) {
+                updaterTask.cancelTask();
+                Storage.OUTDATED = true;
+                Storage.ConfigSections.Settings.UPDATE.OUTDATED.getLines().forEach(Logger::warning);
+
+            } else if(!Storage.NEWER_VERSION.equals(Storage.CURRENT_VERSION)) {
+                updaterTask.cancelTask();
+                switch (result) {
+                    case "internet":
+                        Logger.warning("Failed to build connection to website! (No internet?)");
+                        break;
+                    case "unknown":
+                        Logger.warning("Failed to build connection to website! (Firewall enabled or website down?)");
+                        break;
+                    case "exception":
+                        Logger.warning("Failed to build connection to website! (Outdated java version?)");
+                        break;
+                }
+            }
+        }, 20L, 20L * Storage.ConfigSections.Settings.UPDATE.PERIOD);
+    }
+
+    public static void synchronize(CommunicationPackets.PacketBundle packetBundle) {
+        Storage.LAST_SYNC = System.currentTimeMillis();
+        Communicator.sendFeedback();
+        CommunicationPackets.UnknownCommandPacket unknownCommandPacket = packetBundle.getUnknownCommandPacket();
+
+        if(!Storage.USE_VELOCITY) {
+            CommunicationPackets.CommandsPacket commandsPacket = packetBundle.getCommandsPacket();
+            CommunicationPackets.GroupsPacket groupsPacket = packetBundle.getGroupsPacket();
+            CommunicationPackets.NamespaceCommandsPacket namespaceCommandsPacket = packetBundle.getNamespaceCommandsPacket();
+
+            if(Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.ENABLED != namespaceCommandsPacket.isEnabled())
+                Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.ENABLED = namespaceCommandsPacket.isEnabled();
+
+            if (commandsPacket.getCommands() == null || commandsPacket.getCommands().isEmpty())
+                Storage.Blacklist.getBlacklist().setList(new ArrayList<>());
+
+            else if (!ArrayUtils.compareStringArrays(Storage.Blacklist.getBlacklist().getCommands(), commandsPacket.getCommands())) {
+                if(Reflection.getMinor() >= 13) BukkitAntiTabListener.setChangeStatus();
+                Storage.Blacklist.getBlacklist().setList(commandsPacket.getCommands());
+            }
+
+            if (Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED != commandsPacket.turnBlacklistToWhitelistEnabled())
+                Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED = commandsPacket.turnBlacklistToWhitelistEnabled();
+
+            GroupManager.clearAllGroups();
+            groupsPacket.getGroups().forEach(group -> GroupManager.setGroup(group.getGroupName(), group.getPriority(), group.getCommands()));
+        }
+
+        Storage.ConfigSections.Settings.CUSTOM_UNKNOWN_COMMAND.MESSAGE = unknownCommandPacket.getMessage();
+        if(Storage.ConfigSections.Settings.CUSTOM_UNKNOWN_COMMAND.ENABLED != unknownCommandPacket.isEnabled())
+            Storage.ConfigSections.Settings.CUSTOM_UNKNOWN_COMMAND.ENABLED = unknownCommandPacket.isEnabled();
+
+        if(!loaded) loaded = true;
+
+        if(Reflection.getMinor() >= 16) {
+
+            if (Storage.USE_VELOCITY)
+                BukkitAntiTabListener.updateCommands();
+
+            Logger.debug("Force server to load all players tab-completion due to received sync!");
+            BukkitAntiTabListener.handleTabCompletion(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED ? Storage.Blacklist.getBlacklist().getCommands() : getNotBlockedCommands());
+        }
+
+        PATEventHandler.callReceiveSyncEvents(packetBundle);
+    }
+
+    public static boolean doesCommandExist(String command, boolean replace) {
+        if(commandsMap == null) return false;
+        if(replace) command = StringUtils.replaceFirst(command, "/", "");
+        return getAllCommands().contains(command);
+    }
+
+    private void loadCommandMap() {
+        try {
+            if (Bukkit.getPluginManager() instanceof SimplePluginManager) {
+                Field commandMapField = SimplePluginManager.class.getDeclaredField("commandMap");
+                commandMapField.setAccessible(true);
+                SimpleCommandMap simpleCommandMap = (SimpleCommandMap) commandMapField.get(Bukkit.getPluginManager());
+                Field knownCommandsField = SimpleCommandMap.class.getDeclaredField("knownCommands");
+                knownCommandsField.setAccessible(true);
+                commandsMap = (Map<String, Command>)knownCommandsField.get(simpleCommandMap);
+            }
+        }catch (Throwable ignored) { }
+
+        if(commandsMap == null)
+            Logger.warning("Failed to get server commands!");
+    }
+
+    public static List<String> getNotBlockedCommands() {
+        List<String> commands = new ArrayList<>();
+        Bukkit.getHelpMap().getHelpTopics().stream()
+                .filter(topic -> !topic.getName().contains(":") && topic.getName().startsWith("/") && !Storage.Blacklist.getBlacklist().isListed(topic.getName().replaceFirst("/", "")))
+                .forEach(topic -> commands.add(topic.getName().replaceFirst("/", "")));
+        return commands;
+    }
+
+    public static List<String> getAllCommands() {
+        if(commandsMap == null) return getNotBlockedCommands();
+
+        List<String> result = new LinkedList<>();
+        for (String command : commandsMap.keySet()) if(!result.contains(command)) result.add(command);
+
+        if(Reflection.getMinor() == 20 && Reflection.getRelease() >= 5 || Reflection.getMinor() >= 21)
+            for (String s : commandsMap.keySet())
+                    if (commandsMap.containsKey(s)) {
+                        if(!commandsMap.get(s).getAliases().isEmpty()) {
+                            for (String alias : commandsMap.get(s).getAliases())
+                                if (!result.contains(alias)) result.add(alias);
+
+                        } else if(Bukkit.getServer().getCommandAliases().get(s) != null)
+                            for (String alias : Bukkit.getServer().getCommandAliases().get(s))
+                                if (!result.contains(alias)) result.add(alias);
+                    }
+
+        return result;
+    }
+
+
+    public static boolean useSuggestions() {
+        return suggestions;
+    }
+
+    public static Plugin getPlugin() {
+        return plugin;
+    }
+
+    public static java.util.logging.Logger getPluginLogger() {
+        return logger;
+    }
+
+    public static boolean isLoaded() {
+        return loaded;
+    }
+}

src/main/java/de/rayzs/pat/plugin/BungeeLoader.java

@@ -0,0 +1,194 @@
+package de.rayzs.pat.plugin;
+
+
+import de.rayzs.pat.utils.configuration.updater.ConfigUpdater;
+import de.rayzs.pat.plugin.modules.subargs.SubArgsModule;
+import de.rayzs.pat.api.netty.proxy.BungeePacketAnalyzer;
+import de.rayzs.pat.utils.configuration.Configurator;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.adapter.LuckPermsAdapter;
+import de.rayzs.pat.api.communication.Communicator;
+import de.rayzs.pat.utils.response.action.ActionHandler;
+import net.md_5.bungee.api.scheduler.ScheduledTask;
+import de.rayzs.pat.plugin.commands.BungeeCommand;
+import de.rayzs.pat.api.brand.CustomServerBrand;
+import de.rayzs.pat.plugin.listeners.bungee.*;
+import de.rayzs.pat.utils.group.GroupManager;
+import net.md_5.bungee.api.config.ServerInfo;
+import de.rayzs.pat.plugin.metrics.bStats;
+import de.rayzs.pat.plugin.logger.Logger;
+import net.md_5.bungee.api.connection.*;
+import de.rayzs.pat.api.storage.Storage;
+import net.md_5.bungee.api.ProxyServer;
+import java.util.concurrent.TimeUnit;
+import net.md_5.bungee.api.plugin.*;
+import de.rayzs.pat.utils.*;
+import java.util.*;
+
+public class BungeeLoader extends Plugin {
+
+    private static Plugin plugin;
+    private static java.util.logging.Logger logger;
+    private ScheduledTask updaterTask;
+    private static boolean checkUpdate = false;
+
+    @Override
+    public void onLoad() {
+        Configurator.createResourcedFile(getDataFolder(), "files\\proxy-config.yml", "config.yml", false);
+        Configurator.createResourcedFile(getDataFolder(), "files\\proxy-storage.yml", "storage.yml", false);
+        Configurator.createResourcedFile(getDataFolder(), "files\\proxy-placeholders.yml", "placeholders.yml", false);
+        Configurator.createResourcedFile(getDataFolder(), "files\\proxy-custom-responses.yml", "custom-responses.yml", false);
+    }
+
+    @Override
+    public void onEnable() {
+        plugin = this;
+        logger = getLogger();
+
+        Reflection.initialize(getProxy());
+        ConfigUpdater.initialize();
+
+        Storage.USE_SIMPLECLOUD = Reflection.doesClassExist("eu.thesimplecloud.plugin.startup.CloudPlugin");
+        Storage.CURRENT_VERSION = getDescription().getVersion();
+        VersionComparer.setCurrentVersion(Storage.CURRENT_VERSION);
+
+        Storage.loadAll(true);
+
+        MessageTranslator.initialize();
+        CustomServerBrand.initialize();
+        GroupManager.initialize();
+        bStats.initialize(this);
+        PluginManager manager = ProxyServer.getInstance().getPluginManager();
+
+        registerCommand("bungeeproantitab", "bpat");
+
+        manager.registerListener(this, new BungeePlayerConnectionListener());
+        manager.registerListener(this, new BungeeAntiTabListener());
+        manager.registerListener(this, new BungeeBlockCommandListener());
+        manager.registerListener(this, new BungeePingListener());
+
+        if(Reflection.isPaper())
+            manager.registerListener(this, new WaterfallAntiTabListener());
+
+        startUpdaterTask();
+
+        if (!Storage.ConfigSections.Settings.DISABLE_SYNC.DISABLED)
+            ProxyServer.getInstance().getScheduler().schedule(this, Communicator::syncData, 5, TimeUnit.SECONDS);
+
+        Storage.PLUGIN_OBJECT = this;
+
+        if (manager.getPlugin("LuckPerms") != null)
+            LuckPermsAdapter.initialize();
+
+        if(manager.getPlugin("PAPIProxyBridge") != null) {
+            Storage.USE_PAPIPROXYBRIDGE = true;
+            Logger.info("Successfully hooked into PAPIProxyBridge!");
+        }
+
+        if(Storage.USE_SIMPLECLOUD)
+            Logger.warning("Detected SimpleCloud and therefore MiniMessages by Kyori are disabled!");
+
+        BungeePacketAnalyzer.injectAll();
+        ConfigUpdater.broadcastMissingParts();
+        ActionHandler.initialize();
+        SubArgsModule.initialize();
+    }
+
+    @Override
+    public void onDisable() {
+        BungeePacketAnalyzer.uninjectAll();
+        MessageTranslator.closeAudiences();
+    }
+
+    private static void registerCommand(String... commands) {
+        for (String commandName : commands) {
+            BungeeCommand command = new BungeeCommand(commandName);
+            ProxyServer.getInstance().getPluginManager().registerCommand(plugin, command);
+        }
+    }
+
+    public static List<String> getPlayerNames() {
+        List<String> result = new LinkedList<>();
+        ProxyServer.getInstance().getPlayers().forEach(player -> result.add(player.getName()));
+        return result;
+    }
+
+    public static UUID getUUIDByName(String playerName) {
+        ProxiedPlayer proxiedPlayer = ProxyServer.getInstance().getPlayer(playerName);
+        return proxiedPlayer != null ? proxiedPlayer.getUniqueId() : null;
+    }
+
+    public void startUpdaterTask() {
+        if (!Storage.ConfigSections.Settings.UPDATE.ENABLED) return;
+        updaterTask = getProxy().getScheduler().schedule(this, () -> {
+            String result = new ConnectionBuilder().setUrl("https://www.rayzs.de/proantitab/api/version.php")
+                    .setProperties("ProAntiTab", "4654").connect().getResponse();
+            Storage.NEWER_VERSION = result;
+            VersionComparer.setNewestVersion(Storage.NEWER_VERSION);
+
+            if(VersionComparer.isDeveloperVersion()) {
+                getProxy().getScheduler().cancel(updaterTask);
+                Logger.info("§8[§fPAT | Proxy§8] §7Please be aware that you are currently using a §bdeveloper §7version of ProAntiTab. Bugs, errors and a lot of debug messages might be included.");
+
+            } else if(!checkUpdate && (VersionComparer.isNewest() || VersionComparer.isUnreleased())) {
+                getProxy().getScheduler().cancel(updaterTask);
+                checkUpdate = true;
+
+                if(VersionComparer.isUnreleased()) {
+                    Logger.info("§8[§fPAT | Proxy§8] §7Please be aware that you are currently using an §eunreleased §7version of ProAntiTab.");
+                    return;
+                }
+
+                checkUpdate = true;
+                Storage.ConfigSections.Settings.UPDATE.UPDATED.getLines().forEach(Logger::warning);
+
+            } else if(VersionComparer.isOutdated()) {
+                Storage.OUTDATED = true;
+                Storage.ConfigSections.Settings.UPDATE.OUTDATED.getLines().forEach(Logger::warning);
+
+            } else if(!Storage.NEWER_VERSION.equals(Storage.CURRENT_VERSION)) {
+                getProxy().getScheduler().cancel(updaterTask);
+                switch (result) {
+                    case "internet":
+                        Logger.warning("Failed to build connection to website! (No internet?)");
+                        break;
+                    case "unknown":
+                        Logger.warning("Failed to build connection to website! (Firewall enabled or website down?)");
+                        break;
+                    case "exception":
+                        Logger.warning("Failed to build connection to website! (Outdated java version?)");
+                        break;
+                }
+            }
+        }, 20L, Storage.ConfigSections.Settings.UPDATE.PERIOD, TimeUnit.MILLISECONDS);
+    }
+
+    public static String getServerNameByPlayerUUID(UUID uuid) {
+        ProxiedPlayer proxiedPlayer = ProxyServer.getInstance().getPlayer(uuid);
+        if(proxiedPlayer == null) return null;
+
+        Server server = proxiedPlayer.getServer();
+        if(server == null) return null;
+
+        ServerInfo serverInfo = server.getInfo();
+        if(serverInfo == null) return null;
+
+        return serverInfo.getName();
+    }
+
+    public static Plugin getPlugin() {
+        return plugin;
+    }
+
+    public static java.util.logging.Logger getPluginLogger() {
+        return logger;
+    }
+
+    public static List<String> getServerNames() {
+        List<String> servers = new LinkedList<>();
+        for (String serverName : ProxyServer.getInstance().getServers().keySet())
+            servers.add(serverName.toLowerCase());
+
+        return servers;
+    }
+}

src/main/java/de/rayzs/pat/plugin/VelocityLoader.java

@@ -0,0 +1,206 @@
+package de.rayzs.pat.plugin;
+
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ServerConnection;
+import de.rayzs.pat.plugin.modules.subargs.SubArgsModule;
+import de.rayzs.pat.utils.configuration.updater.ConfigUpdater;
+import de.rayzs.pat.plugin.metrics.impl.VelocityMetrics;
+import com.velocitypowered.api.scheduler.ScheduledTask;
+import de.rayzs.pat.utils.configuration.Configurator;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.plugin.commands.VelocityCommand;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.api.communication.Communicator;
+import de.rayzs.pat.utils.adapter.LuckPermsAdapter;
+import com.velocitypowered.api.proxy.ProxyServer;
+import de.rayzs.pat.api.brand.CustomServerBrand;
+import de.rayzs.pat.plugin.listeners.velocity.*;
+import de.rayzs.pat.utils.group.GroupManager;
+import de.rayzs.pat.utils.ConnectionBuilder;
+import de.rayzs.pat.utils.VersionComparer;
+import de.rayzs.pat.plugin.logger.Logger;
+import com.velocitypowered.api.plugin.*;
+import de.rayzs.pat.api.storage.Storage;
+import com.velocitypowered.api.event.*;
+import de.rayzs.pat.utils.Reflection;
+import java.util.concurrent.TimeUnit;
+
+
+import com.google.inject.Inject;
+import de.rayzs.pat.utils.response.action.ActionHandler;
+
+import java.util.*;
+
+@Plugin(name = "ProAntiTab",
+id = "proantitab",
+version = "1.9.2",
+authors = "Rayzs_YT",
+description = "Hide more than just your plugins. Hide almost everything!",
+dependencies = {
+        @Dependency(id = "luckperms", optional = true),
+        @Dependency(id = "papiproxybridge", optional = true)
+})
+public class VelocityLoader {
+
+    private static VelocityLoader instance;
+    private static ProxyServer server;
+    private final EventManager manager;
+    private final VelocityMetrics.Factory metricsFactory;
+    private ScheduledTask updaterTask;
+    private static boolean checkUpdate = false;
+
+    @Inject
+    public VelocityLoader(ProxyServer server, VelocityMetrics.Factory metricsFactory) {
+        VelocityLoader.instance = this;
+        VelocityLoader.server = server;
+        this.manager = server.getEventManager();
+        this.metricsFactory = metricsFactory;
+    }
+
+    @Subscribe
+    public void onProxyInitialization(ProxyInitializeEvent event) {
+        PluginContainer pluginContainer = server.getPluginManager().getPlugin("proantitab").get();
+
+        Configurator.createResourcedFile("./plugins/ProAntiTab", "files\\proxy-config.yml", "config.yml", false);
+        Configurator.createResourcedFile("./plugins/ProAntiTab", "files\\proxy-storage.yml", "storage.yml", false);
+        Configurator.createResourcedFile("./plugins/ProAntiTab", "files\\proxy-placeholders.yml", "placeholders.yml", false);
+        Configurator.createResourcedFile("./plugins/ProAntiTab", "files\\proxy-custom-responses.yml", "custom-responses.yml", false);
+
+        Reflection.initialize(server);
+        ConfigUpdater.initialize();
+
+        Storage.USE_SIMPLECLOUD = Reflection.doesClassExist("eu.thesimplecloud.plugin.startup.CloudPlugin");
+        Storage.CURRENT_VERSION = pluginContainer.getDescription().getVersion().get();
+        VersionComparer.setCurrentVersion(Storage.CURRENT_VERSION);
+
+        Storage.loadAll(true);
+        MessageTranslator.initialize();
+        CustomServerBrand.initialize();
+        GroupManager.initialize();
+
+
+        metricsFactory.make(this, 21638);
+
+        server.getCommandManager().register("bpat", new VelocityCommand(), "bungeeproantitab");
+        server.getEventManager().register(this, new VelocityBlockCommandListener(server));
+        server.getEventManager().register(this, new VelocityAntiTabListener(server));
+        server.getEventManager().register(this, new VelocityConnectionListener(server, this));
+        server.getEventManager().register(this, new VelocityPingListener(server));
+
+        startUpdaterTask();
+
+        if (!Storage.ConfigSections.Settings.DISABLE_SYNC.DISABLED)
+            server.getScheduler().buildTask(this, Communicator::syncData).delay(5, TimeUnit.SECONDS).schedule();
+
+        Storage.PLUGIN_OBJECT = this;
+
+        if(server.getPluginManager().getPlugin("luckperms").isPresent())
+            LuckPermsAdapter.initialize();
+
+        if(server.getPluginManager().getPlugin("papiproxybridge").isPresent()) {
+            Storage.USE_PAPIPROXYBRIDGE = true;
+            Logger.info("Successfully hooked into PAPIProxyBridge!");
+        }
+
+        if(Storage.USE_SIMPLECLOUD)
+            Logger.warning("Detected SimpleCloud and therefore MiniMessages by Kyori are disabled!");
+
+        ConfigUpdater.broadcastMissingParts();
+        ActionHandler.initialize();
+        SubArgsModule.initialize();
+    }
+
+    public static void delayedPermissionsReload() {
+        server.getScheduler().buildTask(VelocityLoader.instance, () -> {
+            PermissionUtil.reloadPermissions();
+            VelocityAntiTabListener.updateCommands();
+        }).delay(1, TimeUnit.SECONDS).schedule();
+    }
+
+    public static List<String> getPlayerNames() {
+        List<String> result = new LinkedList<>();
+        server.getAllPlayers().forEach(player -> result.add(player.getUsername()));
+        return result;
+    }
+
+    public static UUID getUUIDByName(String playerName) {
+        if (!server.getPlayer(playerName).isPresent()) return null;
+        return server.getPlayer(playerName).get().getUniqueId();
+    }
+
+    public void startUpdaterTask() {
+        if (!Storage.ConfigSections.Settings.UPDATE.ENABLED) return;
+
+        updaterTask = server.getScheduler().buildTask(this, () -> {
+            String result = new ConnectionBuilder().setUrl("https://www.rayzs.de/proantitab/api/version.php")
+                    .setProperties("ProAntiTab", "4654").connect().getResponse();
+
+            Storage.NEWER_VERSION = result;
+            VersionComparer.setNewestVersion(Storage.NEWER_VERSION);
+
+            if(VersionComparer.isDeveloperVersion()) {
+                updaterTask.cancel();
+                MessageTranslator.send(server.getConsoleCommandSource(), "<dark_gray>[</dark_gray><white>PAT | Proxy</white><dark_gray>]</dark_gray> <gray>Please be aware that you are currently using a</gray> <aqua>developer</aqua> <gray>version of ProAntiTab. Bugs, errors and a lot of debug messages might be included.</gray>");
+
+            } else if(!checkUpdate && (VersionComparer.isNewest() || VersionComparer.isUnreleased())) {
+                updaterTask.cancel();
+                checkUpdate = true;
+
+                if(VersionComparer.isUnreleased()) {
+                    MessageTranslator.send(server.getConsoleCommandSource(), "<dark_gray>[</dark_gray><white>PAT | Proxy</white><dark_gray>]</dark_gray> <gray>Please be aware that you are currently using an</gray> <yellow>unreleased</yellow> <gray>version of ProAntiTab.</gray>");
+                    return;
+                }
+
+                checkUpdate = true;
+                MessageTranslator.send(server.getConsoleCommandSource(), Storage.ConfigSections.Settings.UPDATE.UPDATED.getLines());
+
+            } else if(VersionComparer.isOutdated()) {
+                Storage.OUTDATED = true;
+                MessageTranslator.send(server.getConsoleCommandSource(), Storage.ConfigSections.Settings.UPDATE.OUTDATED.getLines());
+
+            } else if(!Storage.NEWER_VERSION.equals(Storage.CURRENT_VERSION)) {
+                updaterTask.cancel();
+                switch (result) {
+                    case "internet":
+                        Logger.warning("[PAT | Proxy] Failed to build connection to website! (No internet?)");
+                        break;
+                    case "unknown":
+                        Logger.warning("[PAT | Proxy] Failed to build connection to website! (Firewall enabled or website down?)");
+                        break;
+                    case "exception":
+                        Logger.warning("[PAT | Proxy] Failed to build connection to website! (Outdated java version?)");
+                        break;
+                }
+            }
+        }).delay(1, TimeUnit.SECONDS).repeat(Storage.ConfigSections.Settings.UPDATE.PERIOD, TimeUnit.SECONDS).schedule();
+    }
+
+    public static String getServerNameByPlayerUUID(UUID uuid) {
+        Optional<Player> optPlayer = server.getPlayer(uuid);
+        if(!optPlayer.isPresent()) return null;
+
+        Player player = optPlayer.get();
+        Optional<ServerConnection> optServer = player.getCurrentServer();
+        if(!optServer.isPresent()) return null;
+
+        ServerConnection server = optServer.get();
+        if(server.getServerInfo() == null) return null;
+
+        return server.getServerInfo().getName();
+    }
+
+    public static ProxyServer getServer() {
+        return server;
+    }
+
+    public static VelocityLoader getInstance() {
+        return instance;
+    }
+
+    public static List<String> getServerNames() {
+        List<String> servers = new ArrayList<>();
+        server.getAllServers().forEach(server -> servers.add(server.getServerInfo().getName().toLowerCase()));
+        return servers;
+    }
+}

src/main/java/de/rayzs/pat/plugin/commands/BukkitCommand.java

@@ -0,0 +1,26 @@
+package de.rayzs.pat.plugin.commands;
+
+import de.rayzs.pat.plugin.process.CommandProcess;
+import org.bukkit.entity.Player;
+import org.bukkit.command.*;
+import java.util.List;
+
+public class BukkitCommand implements CommandExecutor, TabCompleter {
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, Command command, String s, String[] strings) {
+        if(commandSender instanceof Player) {
+            Player player = (Player) commandSender;
+            CommandProcess.handleCommand(player, strings, s);
+            return true;
+        }
+
+        CommandProcess.handleCommand(commandSender, strings, s);
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender commandSender, Command command, String s, String[] strings) {
+        return CommandProcess.handleTabComplete(commandSender, strings);
+    }
+}

src/main/java/de/rayzs/pat/plugin/commands/BungeeCommand.java

@@ -0,0 +1,22 @@
+package de.rayzs.pat.plugin.commands;
+
+import de.rayzs.pat.plugin.process.CommandProcess;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.plugin.*;
+
+public class BungeeCommand extends Command implements TabExecutor {
+
+    public BungeeCommand(String name) {
+        super(name);
+    }
+
+    @Override
+    public void execute(CommandSender commandSender, String[] strings) {
+        CommandProcess.handleCommand(commandSender, strings, "bpat");
+    }
+
+    @Override
+    public Iterable<String> onTabComplete(CommandSender commandSender, String[] strings) {
+        return CommandProcess.handleTabComplete(commandSender, strings);
+    }
+}

src/main/java/de/rayzs/pat/plugin/commands/VelocityCommand.java

@@ -0,0 +1,18 @@
+package de.rayzs.pat.plugin.commands;
+
+import com.velocitypowered.api.command.SimpleCommand;
+import de.rayzs.pat.plugin.process.CommandProcess;
+import java.util.List;
+
+public class VelocityCommand implements SimpleCommand {
+
+    @Override
+    public void execute(Invocation invocation) {
+        CommandProcess.handleCommand(invocation.source(), invocation.arguments(), "bpat");
+    }
+
+    @Override
+    public List<String> suggest(Invocation invocation) {
+        return CommandProcess.handleTabComplete(invocation.source(), invocation.arguments());
+    }
+}

src/main/java/de/rayzs/pat/plugin/listeners/bukkit/BukkitAntiTabListener.java

@@ -0,0 +1,140 @@
+package de.rayzs.pat.plugin.listeners.bukkit;
+
+import de.rayzs.pat.api.event.events.FilteredSuggestionEvent;
+import org.bukkit.event.player.PlayerCommandSendEvent;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.utils.adapter.ViaVersionAdapter;
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BukkitLoader;
+import org.bukkit.entity.Player;
+import de.rayzs.pat.utils.*;
+import org.bukkit.event.*;
+import org.bukkit.Bukkit;
+import java.util.*;
+
+public class BukkitAntiTabListener implements Listener {
+
+    private static final CommandsCache COMMANDS_CACHE = new CommandsCache();
+
+    @EventHandler (priority = EventPriority.LOWEST)
+    public void onPlayerCommandSend(PlayerCommandSendEvent event) {
+        Player player = event.getPlayer();
+        UUID uuid = player.getUniqueId();
+        String uuidSubstring = uuid.toString().substring(uuid.toString().length() - 5);
+
+        if(Storage.USE_VELOCITY || player.isOp()) {
+            Logger.debug("Doesn't even tried to create the commands list for player with uuid " + uuidSubstring + ". (Veloctiy? " + Storage.USE_VELOCITY + ". OP? " + player.isOp() + ")");
+            return;
+        }
+
+        if(!BukkitLoader.isLoaded()) {
+            event.getCommands().clear();
+            Logger.debug("Doesn't even tried to create the commands list for player with uuid " + uuidSubstring + ". (not loaded)");
+            return;
+        }
+
+        if(event.getCommands().isEmpty()) {
+            Logger.debug("No available commands to filter! Ignoring rest of the code until at least one command is listed in there.");
+            return;
+        }
+        List<String> allCommands = getCommands();
+
+        COMMANDS_CACHE.handleCommands(allCommands);
+
+        if (PermissionUtil.hasBypassPermission(player)) {
+            Logger.debug("Player with uuid " + uuidSubstring + " skipped the commands-list creation due to its permissions.");
+            return;
+        }
+
+        if(Storage.USE_VIAVERSION)
+            if(Reflection.getMinor() >= 16 && ViaVersionAdapter.getPlayerProtocol(uuid) < 754)
+                event.getCommands().clear();
+
+        final List<String> playerCommands = COMMANDS_CACHE.getPlayerCommands(event.getCommands(), player, player.getUniqueId());
+        event.getCommands().clear();
+
+        FilteredSuggestionEvent filteredSuggestionEvent = PATEventHandler.callFilteredSuggestionEvents(player, playerCommands);
+        if(filteredSuggestionEvent.isCancelled()) return;
+
+        event.getCommands().addAll(filteredSuggestionEvent.getSuggestions());
+
+        Logger.debug("Player with uuid " + uuidSubstring + " has a total of " + playerCommands.size() + " commands.");
+    }
+
+    public static void updateCommands(Player player) {
+        if(notUpdatablePlayer(player.getUniqueId())) return;
+        if(Reflection.getMinor() >= 16) player.updateCommands();
+    }
+
+    public static void updateCommands() {
+        if(Reflection.getMinor() >= 16) Bukkit.getOnlinePlayers().forEach(BukkitAntiTabListener::updateCommands);
+    }
+
+    public static void setChangeStatus() {
+        COMMANDS_CACHE.updateChangeState();
+    }
+
+    public static void handleTabCompletion(List<String> commands) {
+        if(Storage.USE_VELOCITY) return;
+        COMMANDS_CACHE.reset();
+        Bukkit.getOnlinePlayers().forEach(player -> handleTabCompletion(player, commands));
+    }
+
+    public static void handleTabCompletion() {
+        COMMANDS_CACHE.reset();
+        Bukkit.getOnlinePlayers().forEach(BukkitAntiTabListener::handleTabCompletion);
+    }
+
+    public static void handleTabCompletion(Player player) {
+        handleTabCompletion(player, getCommands());
+    }
+
+    public static List<String> getCommands() {
+        return Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED
+                ? Storage.Blacklist.getBlacklist().getCommands() : BukkitLoader.getAllCommands();
+    }
+
+    public static void handleTabCompletion(UUID uuid) {
+        if(notUpdatablePlayer(uuid)) return;
+
+        Player player = Bukkit.getPlayer(uuid);
+        if(player == null) return;
+        handleTabCompletion(player);
+    }
+
+    public static void handleTabCompletion(UUID uuid, List<String> commands) {
+        if(notUpdatablePlayer(uuid)) return;
+
+        Player player = Bukkit.getPlayer(uuid);
+        if(player == null) return;
+        handleTabCompletion(player, commands);
+    }
+
+    public static void luckpermsNetworkSync() {
+        Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(BukkitLoader.getPlugin(), PermissionUtil::reloadPermissions, 40);
+    }
+
+    public static void luckpermsNetworkUserSync(UUID uuid) {
+        Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(BukkitLoader.getPlugin(), () -> PermissionUtil.reloadPermissions(uuid));
+    }
+
+    public static void handleTabCompletion(Player player, List<String> commands) {
+        if(Storage.USE_VELOCITY) return;
+        if(notUpdatablePlayer(player.getUniqueId())) return;
+
+        List<String> dummy = new ArrayList<>(commands);
+        PlayerCommandSendEvent event = new PlayerCommandSendEvent(player, dummy);
+        Bukkit.getPluginManager().callEvent(event);
+        updateCommands(player);
+    }
+
+    private static boolean notUpdatablePlayer(UUID uuid) {
+        if(Storage.USE_VIAVERSION)
+            return Reflection.getMinor() >= 16 && ViaVersionAdapter.getPlayerProtocol(uuid) < 754;
+
+        return false;
+    }
+
+}

src/main/java/de/rayzs/pat/plugin/listeners/bukkit/BukkitBlockCommandListener.java

@@ -0,0 +1,142 @@
+package de.rayzs.pat.plugin.listeners.bukkit;
+
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import de.rayzs.pat.api.event.events.ExecuteCommandEvent;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.plugin.logger.Logger;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BukkitLoader;
+import de.rayzs.pat.utils.StringUtils;
+import org.bukkit.entity.Player;
+import de.rayzs.pat.api.event.*;
+import org.bukkit.event.*;
+import java.util.List;
+import org.bukkit.*;
+
+public class BukkitBlockCommandListener implements Listener {
+
+    @EventHandler (priority = EventPriority.HIGHEST)
+    public void onUnknownCommandRecognition(PlayerCommandPreprocessEvent event) {
+        Player player = event.getPlayer();
+        World world = player.getWorld();
+        String rawCommand = StringUtils.getFirstArg(event.getMessage()), command =  StringUtils.replaceFirst(rawCommand, "/", "");
+
+        if(!Storage.ConfigSections.Settings.CUSTOM_UNKNOWN_COMMAND.ENABLED || event.isCancelled()) return;
+        if(BukkitLoader.doesCommandExist(command, false)) return;
+        if(Bukkit.getHelpMap().getHelpTopic(rawCommand) != null) return;
+
+        event.setCancelled(true);
+        MessageTranslator.send(player, Storage.ConfigSections.Settings.CUSTOM_UNKNOWN_COMMAND.MESSAGE, "%command%", command, "%world%", world.getName());
+    }
+
+    @EventHandler (priority = EventPriority.LOWEST)
+    public void onPlayerCommandProcess(PlayerCommandPreprocessEvent event) {
+        Player player = event.getPlayer();
+        World world = player.getWorld();
+        String rawCommand = event.getMessage(), command = rawCommand, worldName = world.getName();
+
+        command = StringUtils.replaceFirst(command, "/", "");
+        command = StringUtils.getFirstArg(command);
+        command = StringUtils.replaceTriggers(command, "", "\\", "<", ">", "&");
+
+        List<String> notificationMessage = MessageTranslator.replaceMessageList(Storage.ConfigSections.Messages.NOTIFICATION.ALERT, "%player%", player.getName(), "%command%", command, "%world%", worldName);
+
+        if(Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isCommand(command) && !PermissionUtil.hasBypassPermission(player, command)) {
+            ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, true);
+            if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+            if(executeCommandEvent.isCancelled()) return;
+
+            MessageTranslator.send(player, Storage.ConfigSections.Settings.CUSTOM_PLUGIN.MESSAGE,  "%command%", command);
+
+            if(Storage.SEND_CONSOLE_NOTIFICATION) Logger.info(notificationMessage);
+            Storage.NOTIFY_PLAYERS.stream().filter(uuid -> Bukkit.getServer().getPlayer(uuid) != null).forEach(uuid -> {
+                Player target = Bukkit.getServer().getPlayer(uuid);
+                MessageTranslator.send(target, notificationMessage);
+            });
+
+            return;
+        }
+
+        if(Storage.ConfigSections.Settings.CUSTOM_VERSION.isCommand(command) && !PermissionUtil.hasBypassPermission(player, command)) {
+            ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, true);
+            if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+            if(executeCommandEvent.isCancelled()) return;
+
+            MessageTranslator.send(player, Storage.ConfigSections.Settings.CUSTOM_VERSION.MESSAGE,  "%command%", command);
+
+            if(Storage.SEND_CONSOLE_NOTIFICATION) Logger.info(notificationMessage);
+            Storage.NOTIFY_PLAYERS.stream().filter(uuid -> Bukkit.getServer().getPlayer(uuid) != null).forEach(uuid -> {
+                Player target = Bukkit.getServer().getPlayer(uuid);
+                MessageTranslator.send(target, notificationMessage);
+            });
+
+            return;
+        }
+
+        if(!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED || Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED || rawCommand.equals("/")) return;
+        List<String> cancelCommandMessage = MessageTranslator.replaceMessageList(Storage.ConfigSections.Settings.CANCEL_COMMAND.BASE_COMMAND_RESPONSE, "%command%", command);
+
+        if(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED) {
+
+            if(Storage.Blacklist.isListed(command, true)) {
+                ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, false);
+                if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+                return;
+            }
+
+            if(PermissionUtil.hasBypassPermission(player, command, false)) {
+                ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, false);
+                if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+                return;
+            }
+
+            ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, true);
+            if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+            if(executeCommandEvent.isCancelled()) return;
+            MessageTranslator.send(player, cancelCommandMessage);
+            return;
+        }
+
+        if(Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.isCommand(command) && !Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesBypass(player)) {
+
+            ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, true);
+            if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+            if(executeCommandEvent.isCancelled()) return;
+
+            MessageTranslator.send(player, cancelCommandMessage);
+
+            if(Storage.SEND_CONSOLE_NOTIFICATION) Logger.info(notificationMessage);
+            Storage.NOTIFY_PLAYERS.stream().filter(uuid -> Bukkit.getServer().getPlayer(uuid) != null).forEach(uuid -> {
+                Player target = Bukkit.getServer().getPlayer(uuid);
+                MessageTranslator.send(target, notificationMessage);
+            });
+
+            return;
+        }
+
+        if (!Storage.Blacklist.isListed(command, false)) {
+            ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, false);
+            if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+            return;
+        }
+
+        if (PermissionUtil.hasBypassPermission(player, command, false)) {
+            ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, false);
+            if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+            return;
+        }
+
+        ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(player, rawCommand, true);
+        if(executeCommandEvent.isBlocked()) event.setCancelled(true);
+        if(executeCommandEvent.isCancelled()) return;
+
+        MessageTranslator.send(player, cancelCommandMessage);
+
+        if(Storage.SEND_CONSOLE_NOTIFICATION) Logger.info(notificationMessage);
+        Storage.NOTIFY_PLAYERS.stream().filter(uuid -> Bukkit.getServer().getPlayer(uuid) != null).forEach(uuid -> {
+            Player target = Bukkit.getServer().getPlayer(uuid);
+            MessageTranslator.send(target, notificationMessage);
+        });
+    }
+}

src/main/java/de/rayzs/pat/plugin/listeners/bukkit/BukkitPlayerConnectionListener.java

@@ -0,0 +1,63 @@
+package de.rayzs.pat.plugin.listeners.bukkit;
+
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.api.event.events.ServerPlayersChangeEvent;
+import de.rayzs.pat.api.netty.bukkit.BukkitPacketAnalyzer;
+import de.rayzs.pat.api.brand.impl.BukkitServerBrand;
+import de.rayzs.pat.api.communication.BackendUpdater;
+import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import de.rayzs.pat.api.brand.CustomServerBrand;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.plugin.BukkitLoader;
+import org.bukkit.event.player.*;
+import org.bukkit.entity.Player;
+import org.bukkit.event.*;
+import org.bukkit.Bukkit;
+
+public class BukkitPlayerConnectionListener implements Listener {
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        PATEventHandler.callServerPlayersChangeEvents(player, ServerPlayersChangeEvent.Type.JOINED);
+
+        if(Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED)
+            BackendUpdater.handle();
+
+        PermissionUtil.setPlayerPermissions(player.getUniqueId());
+        CustomServerBrand.preparePlayer(player);
+
+        if(CustomServerBrand.isEnabled())
+            CustomServerBrand.sendBrandToPlayer(player);
+
+        if(!BukkitPacketAnalyzer.inject(player)) player.kickPlayer("Failed to inject player!");
+
+        if(Storage.OUTDATED && PermissionUtil.hasPermission(player, "joinupdate")) {
+            Bukkit.getScheduler().runTaskLater(BukkitLoader.getPlugin(), () -> {
+                if(player.isOnline()) {
+                    MessageTranslator.send(player, Storage.ConfigSections.Settings.UPDATE.OUTDATED.getLines());
+                }
+            }, 20);
+        }
+    }
+
+    @EventHandler (priority = EventPriority.LOWEST)
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        PATEventHandler.callServerPlayersChangeEvents(player, ServerPlayersChangeEvent.Type.LEFT);
+
+        BukkitPacketAnalyzer.uninject(player.getUniqueId());
+        PermissionUtil.resetPermissions(player.getUniqueId());
+        if(Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY != -1) return;
+        BukkitServerBrand.removeFromModified(player);
+    }
+
+    @EventHandler (priority = EventPriority.LOWEST)
+    public void onPlayerChangedWorld(PlayerChangedWorldEvent event) {
+        Player player = event.getPlayer();
+        if(Storage.ConfigSections.Settings.CUSTOM_BRAND.REPEAT_DELAY != -1) return;
+        BukkitServerBrand.removeFromModified(player);
+        CustomServerBrand.sendBrandToPlayer(player);
+    }
+}

src/main/java/de/rayzs/pat/plugin/listeners/bukkit/PaperServerListPing.java

@@ -0,0 +1,32 @@
+package de.rayzs.pat.plugin.listeners.bukkit;
+
+import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
+import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.message.replacer.PlaceholderReplacer;
+import org.bukkit.event.*;
+import org.bukkit.Bukkit;
+
+public class PaperServerListPing implements Listener {
+
+    @EventHandler (priority = EventPriority.LOWEST)
+    public void onPaperServerListPing(PaperServerListPingEvent event) {
+        if(!Storage.ConfigSections.Settings.CUSTOM_PROTOCOL_PING.ENABLED) return;
+        if(Storage.ConfigSections.Settings.CUSTOM_PROTOCOL_PING.ALWAYS_SHOW) event.setProtocolVersion(0);
+
+        int online = Bukkit.getOnlinePlayers().size(),
+                onlineExtend = online + Storage.ConfigSections.Settings.CUSTOM_PROTOCOL_PING.EXTEND_COUNT,
+                max = Bukkit.getMaxPlayers();
+
+        if(Storage.ConfigSections.Settings.CUSTOM_PROTOCOL_PING.USE_EXTEND_AS_MAX_COUNT)
+            event.setMaxPlayers(onlineExtend);
+
+        String versionName = Storage.ConfigSections.Settings.CUSTOM_PROTOCOL_PING.PROTOCOL.replace("%online_extended%", String.valueOf(onlineExtend)).replace("%online%", String.valueOf(online)).replace("%max%", String.valueOf(max));
+        if(Storage.ConfigSections.Settings.CUSTOM_PROTOCOL_PING.HIDE_PLAYERS)
+            event.getPlayerSample().clear();
+
+        if(versionName.contains("%"))
+            PlaceholderReplacer.replace(null, versionName);
+
+        event.setVersion(versionName);
+    }
+}

src/main/java/de/rayzs/pat/plugin/listeners/bungee/BungeeAntiTabListener.java

@@ -0,0 +1,37 @@
+package de.rayzs.pat.plugin.listeners.bungee;
+
+import de.rayzs.pat.api.event.PATEventHandler;
+import de.rayzs.pat.api.event.events.FilteredSuggestionEvent;
+import de.rayzs.pat.api.event.events.FilteredTabCompletionEvent;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import de.rayzs.pat.utils.permission.PermissionUtil;
+import net.md_5.bungee.api.plugin.Listener;
+import de.rayzs.pat.api.storage.Storage;
+import net.md_5.bungee.api.event.*;
+import net.md_5.bungee.event.*;
+
+public class BungeeAntiTabListener implements Listener {
+
+    @EventHandler
+    public void onTabComplete(TabCompleteEvent event) {
+        if(!(event.getSender() instanceof ProxiedPlayer)) return;
+
+        ProxiedPlayer player = (ProxiedPlayer) event.getSender();
+        if(PermissionUtil.hasBypassPermission(player)) return;
+        if(Storage.Blacklist.isBlocked(player, event.getCursor(), !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED, player.getServer().getInfo().getName()))
+            event.getSuggestions().clear();
+    }
+
+    @EventHandler
+    public void onTabComplete(TabCompleteResponseEvent event) {
+        if(!(event.getSender() instanceof ProxiedPlayer)) return;
+
+        ProxiedPlayer player = (ProxiedPlayer) event.getSender();
+        if(PermissionUtil.hasBypassPermission(player)) return;
+
+        event.getSuggestions().removeIf(command -> Storage.Blacklist.isBlocked(player, command, !Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED, player.getServer().getInfo().getName()));
+
+        FilteredSuggestionEvent filteredSuggestionEvent = PATEventHandler.callFilteredSuggestionEvents(player, event.getSuggestions());
+        if(filteredSuggestionEvent.isCancelled()) event.getSuggestions().clear();
+    }
+}