Fixed exception

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>de.rayzs.pat</groupId>
     <artifactId>ProAntiTab</artifactId>
-    <version>2.1.2</version>
+    <version>2.2.0</version>
 
     <properties>
         <maven.compiler.source>8</maven.compiler.source>
@@ -291,6 +291,16 @@
 
     <build>
         <finalName>IgnoreThisJar</finalName>
+
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <excludes>
+                    <exclude>*.txt</exclude>
+                </excludes>
+            </resource>
+        </resources>
+
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>

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

@@ -42,7 +42,7 @@ public class BukkitPacketAnalyzer {
     }
 
     public static boolean inject(Player player) {
-        if (Storage.USE_VELOCITY)
+        if (Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED)
             return true;
 
         try {
@@ -81,7 +81,7 @@ public class BukkitPacketAnalyzer {
     }
 
     public static void uninject(UUID uuid) {
-        if (Storage.USE_VELOCITY)
+        if (Storage.SEND_CONSOLE_NOTIFICATION)
             return;
 
         if (BukkitPacketAnalyzer.INJECTED_PLAYERS.containsKey(uuid)) {
@@ -91,7 +91,7 @@ public class BukkitPacketAnalyzer {
     }
 
     public static void uninject(Channel channel) {
-        if (Storage.USE_VELOCITY)
+        if (Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED)
             return;
 
         if (channel != null) {
@@ -124,22 +124,25 @@ public class BukkitPacketAnalyzer {
         @Override
         public void channelRead(ChannelHandlerContext channel, Object packetObj) {
             try {
-                if (packetObj.getClass() != null) {
-                    String packetName = packetObj.getClass().getSimpleName();
-
-                    if (!packetName.equals("PacketPlayInTabComplete") && !packetName.equals("ServerboundCommandSuggestionPacket")) {
-                        super.channelRead(channel, packetObj);
-                        return;
-                    }
-
-                    if (!PermissionUtil.hasBypassPermission(player)) {
-
-                        if (!PACKET_HANDLER.handleIncomingPacket(player, packetObj))
-                            return;
-
-                    }
+                if (packetObj.getClass() == null || Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED) {
+                    super.channelRead(channel, packetObj);
+                    return;
                 }
 
+                String packetName = packetObj.getClass().getSimpleName();
+
+                if (!packetName.equals("PacketPlayInTabComplete") && !packetName.equals("ServerboundCommandSuggestionPacket")) {
+                    super.channelRead(channel, packetObj);
+                    return;
+                }
+
+                if (!PermissionUtil.hasBypassPermission(player)) {
+
+                    if (!PACKET_HANDLER.handleIncomingPacket(player, packetObj))
+                        return;
+                }
+
+
                 super.channelRead(channel, packetObj);
             } catch (Throwable exception) { exception.printStackTrace(); }
         }
@@ -148,30 +151,33 @@ public class BukkitPacketAnalyzer {
         public void write(ChannelHandlerContext channel, Object packetObj, ChannelPromise promise) {
             try {
 
-                if(packetObj.getClass() != null) {
-                    String packetName = packetObj.getClass().getSimpleName();
+                if(packetObj.getClass() == null || Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED) {
+                    super.write(channel, packetObj, promise);
+                    return;
+                }
 
-                    if (!packetName.equals("PacketPlayOutTabComplete") && !packetName.equals("ClientboundCommandSuggestionsPacket")) {
-                        super.write(channel, packetObj, promise);
-                        return;
-                    }
+                String packetName = packetObj.getClass().getSimpleName();
 
-                    if (!PermissionUtil.hasBypassPermission(player)) {
+                if (!packetName.equals("PacketPlayOutTabComplete") && !packetName.equals("ClientboundCommandSuggestionsPacket")) {
+                    super.write(channel, packetObj, promise);
+                    return;
+                }
 
-                        UUID uuid = player.getUniqueId();
-                        Object sentPacketObj = SENT_PACKET.get(uuid);
+                if (!PermissionUtil.hasBypassPermission(player)) {
 
-                        if (sentPacketObj != null) {
-                            if (sentPacketObj == packetObj) {
-                                SENT_PACKET.remove(uuid);
-                                super.write(channel, sentPacketObj, promise);
-                                return;
-                            }
-                        }
+                    UUID uuid = player.getUniqueId();
+                    Object sentPacketObj = SENT_PACKET.get(uuid);
 
-                        if (!PACKET_HANDLER.handleOutgoingPacket(player, packetObj))
+                    if (sentPacketObj != null) {
+                        if (sentPacketObj == packetObj) {
+                            SENT_PACKET.remove(uuid);
+                            super.write(channel, sentPacketObj, promise);
                             return;
+                        }
                     }
+
+                    if (!PACKET_HANDLER.handleOutgoingPacket(player, packetObj))
+                        return;
                 }
 
                 super.write(channel, packetObj, promise);

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

@@ -3,6 +3,7 @@ package de.rayzs.pat.api.netty.proxy;
 import java.lang.reflect.Field;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
@@ -18,6 +19,7 @@ import de.rayzs.pat.api.storage.Storage;
 import de.rayzs.pat.plugin.logger.Logger;
 import de.rayzs.pat.plugin.modules.SubArgsModule;
 import de.rayzs.pat.utils.CommandsCache;
+import de.rayzs.pat.utils.ExpireCache;
 import de.rayzs.pat.utils.node.CommandNodeHelper;
 import de.rayzs.pat.utils.Reflection;
 import de.rayzs.pat.utils.StringUtils;
@@ -33,6 +35,7 @@ import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.protocol.PacketWrapper;
 import net.md_5.bungee.protocol.packet.Commands;
 import net.md_5.bungee.protocol.packet.PluginMessage;
+import net.md_5.bungee.protocol.packet.TabCompleteRequest;
 import net.md_5.bungee.protocol.packet.TabCompleteResponse;
 
 public class BungeePacketAnalyzer {
@@ -41,7 +44,7 @@ public class BungeePacketAnalyzer {
 
     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 ExpireCache<UUID, String> PLAYER_INPUT_CACHE = new ExpireCache<>(5, TimeUnit.SECONDS);
 
     private static final List<String> PLUGIN_COMMANDS = new ArrayList<>();
 
@@ -115,7 +118,7 @@ public class BungeePacketAnalyzer {
     }
 
     public static void uninject(ProxiedPlayer player) {
-        BungeePacketAnalyzer.PLAYER_INPUT_CACHE.remove(player);
+        BungeePacketAnalyzer.PLAYER_INPUT_CACHE.remove(player.getUniqueId());
         BungeePacketAnalyzer.PLAYER_MODIFIED.remove(player);
 
         if(BungeePacketAnalyzer.INJECTED_PLAYERS.containsKey(player)) {
@@ -132,46 +135,51 @@ public class BungeePacketAnalyzer {
         }
     }
 
+    public static void setPlayerInput(ProxiedPlayer player, String input) {
+        PLAYER_INPUT_CACHE.putIgnoreIfContains(player.getUniqueId(), input);
+    }
+
     public static String getPlayerInput(ProxiedPlayer player) {
-        String input = PLAYER_INPUT_CACHE.get(player);
-        PLAYER_INPUT_CACHE.remove(player);
+        String input = PLAYER_INPUT_CACHE.get(player.getUniqueId());
+        PLAYER_INPUT_CACHE.remove(player.getUniqueId());
         return input;
     }
 
     private static void modifyCommands(ProxiedPlayer player, Commands commands) {
-        if (PermissionUtil.hasBypassPermission(player))
-            return;
-
         ServerInfo serverInfo = player.getServer().getInfo();
         String serverName = serverInfo.getName();
 
-        if (Storage.Blacklist.isDisabledServer(serverName))
-            return;
+        final boolean ignore = PermissionUtil.hasBypassPermission(player) || Storage.Blacklist.isDisabledServer(serverName);
 
         CommandNodeHelper helper = new CommandNodeHelper<CommandNode>(commands.getRoot());
 
-        Map<String, CommandsCache> cache = Storage.getLoader().getCommandsCacheMap();
-
-        if (!cache.containsKey(serverName))
-            cache.put(serverName, new CommandsCache());
-
-        CommandsCache commandsCache = cache.get(serverName);
-
         List<String> commandsAsString = new ArrayList<>(PROXY_COMMANDS);
         commandsAsString.addAll(helper.getChildrenNames());
 
-        commandsCache.handleCommands(commandsAsString, serverName);
+        List<String> playerCommands = new ArrayList<>();
 
-        List<String> playerCommands = commandsCache.getPlayerCommands(commandsAsString, player, serverName);
+        if (!ignore) {
 
-        helper.removeIf(str -> !playerCommands.contains(str));
+            Map<String, CommandsCache> cache = Storage.getLoader().getCommandsCacheMap();
+            if (!cache.containsKey(serverName)) {
+                cache.put(serverName, new CommandsCache());
+            }
 
-        if (Storage.ConfigSections.Settings.CUSTOM_VERSION.ALWAYS_TAB_COMPLETABLE) {
-            Storage.ConfigSections.Settings.CUSTOM_VERSION.COMMANDS.getLines().forEach(input -> helper.add(input, false));
-        }
+            CommandsCache commandsCache = cache.get(serverName);
+            commandsCache.handleCommands(commandsAsString, serverName);
 
-        if (Storage.ConfigSections.Settings.CUSTOM_PLUGIN.ALWAYS_TAB_COMPLETABLE) {
-            Storage.ConfigSections.Settings.CUSTOM_PLUGIN.COMMANDS.getLines().forEach(input -> helper.add(input, false));
+            List<String> tmpPlayerCommands = commandsCache.getPlayerCommands(commandsAsString, player, serverName);
+            helper.removeIf(str -> !tmpPlayerCommands.contains(str));
+
+            if (Storage.ConfigSections.Settings.CUSTOM_VERSION.ALWAYS_TAB_COMPLETABLE) {
+                Storage.ConfigSections.Settings.CUSTOM_VERSION.COMMANDS.getLines().forEach(input -> helper.add(input, false));
+            }
+
+            if (Storage.ConfigSections.Settings.CUSTOM_PLUGIN.ALWAYS_TAB_COMPLETABLE) {
+                Storage.ConfigSections.Settings.CUSTOM_PLUGIN.COMMANDS.getLines().forEach(input -> helper.add(input, false));
+            }
+
+            playerCommands = tmpPlayerCommands;
         }
 
         for (Map.Entry<String, Command> command : ProxyServer.getInstance().getPluginManager().getCommands()) {
@@ -189,11 +197,13 @@ public class BungeePacketAnalyzer {
             String commandName = command.getKey();
             commandName = commandName.startsWith("/") ? commandName.substring(1) : commandName;
 
-            boolean tabablePluginCommand = Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(commandName);
-            boolean tabableVersionCommand = Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(commandName);
+            if (!ignore) {
+                boolean tabablePluginCommand = Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(commandName);
+                boolean tabableVersionCommand = Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(commandName);
 
-            if (!tabablePluginCommand && !tabableVersionCommand && !playerCommands.contains(commandName)) {
-                continue;
+                if (!tabablePluginCommand && !tabableVersionCommand && !playerCommands.contains(commandName)) {
+                    continue;
+                }
             }
 
             CommandNode dummy = CommandNodeHelper.createDummyCommandNode(command.getKey());
@@ -201,12 +211,22 @@ public class BungeePacketAnalyzer {
         }
 
 
-        PROXY_COMMANDS.stream().filter(playerCommands::contains).forEach(input -> helper.add(input, true));
-        SubArgsModule.handleCommandNode(player.getUniqueId(), helper);
+        for (String command : PROXY_COMMANDS) {
+            if (ignore || playerCommands.contains(command)) {
+                helper.add(command, true);
+            }
+        }
+
+        if (!ignore) {
+            SubArgsModule.handleCommandNode(player.getUniqueId(), helper);
+        }
     }
 
     public static void sendCommandsPacket() {
         for (ProxiedPlayer player : ProxyServer.getInstance().getPlayers()) {
+            if (player.getPendingConnection().getVersion() < 754)
+                continue;
+
             RootCommandNode root = new RootCommandNode();
             Commands packet = new Commands(root);
 
@@ -230,7 +250,7 @@ public class BungeePacketAnalyzer {
                 return;
             }
 
-            if(wrapper.packet instanceof PluginMessage) {
+            if (wrapper.packet instanceof PluginMessage) {
                 PluginMessage pluginMessage = (PluginMessage) wrapper.packet;
                 if(CustomServerBrand.isEnabled() && CustomServerBrand.isBrandTag(pluginMessage.getTag()))
                     return;
@@ -242,25 +262,32 @@ public class BungeePacketAnalyzer {
                 player.unsafe().sendPacket(response);
                 return;
 
+                /*
             } else if (wrapper.packet instanceof TabCompleteResponse) {
                 TabCompleteResponse response = (TabCompleteResponse) wrapper.packet;
                 String serverName = player.getServer().getInfo().getName();
 
+                System.out.println("damn");
+
                 if (!Storage.Blacklist.isDisabledServer(serverName) && player.getPendingConnection().getVersion() < 754) {
                     if (!PermissionUtil.hasBypassPermission(player)) {
 
-                        ClientInfo clientInfo = Communicator.getClientByName(player.getServer().getInfo().getName());
-                        if (clientInfo == null || !PLAYER_INPUT_CACHE.containsKey(player))
+                        System.out.println("Further!");
+                        System.out.println("Got: " + PLAYER_INPUT_CACHE.get(player.getUniqueId()));
+
+                        if (!PLAYER_INPUT_CACHE.contains(player.getUniqueId()))
                             return;
 
                         boolean cancelsBeforeHand = false;
 
-                        String rawPlayerInput = getPlayerInput(player);
+                        String rawPlayerInput = PLAYER_INPUT_CACHE.get(player.getUniqueId());
                         int spaces = rawPlayerInput.contains(" ") ? rawPlayerInput.split(" ").length : 0;
 
                         String playerInput = StringUtils.getFirstArg(rawPlayerInput),
                                 server = player.getServer().getInfo().getName();
 
+                        System.out.println("NETTY -> " + playerInput);
+
                         if (!playerInput.equals("/")) {
                             cancelsBeforeHand = !Storage.Blacklist.canPlayerAccessTab(player, StringUtils.replaceFirst(playerInput, "/", ""), server);
 
@@ -318,7 +345,7 @@ public class BungeePacketAnalyzer {
                             player.unsafe().sendPacket(new TabCompleteResponse(response.getCommands()));
                         }
                     }
-                }
+                }*/
             }
 
             list.add(wrapper);

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

@@ -108,6 +108,7 @@ public class Storage {
     }
 
     public static void loadToken() {
+        Files.TOKEN.reload();
 
         boolean invalidEnv = false;
 
@@ -340,6 +341,7 @@ public class Storage {
 
         public static class Settings {
 
+            public static AllowGroupOverrulingSection ALLOW_GROUP_OVERRULING = new AllowGroupOverrulingSection();
             public static AutoLowercaseCommandsSection AUTO_LOWERCASE_COMMANDS = new AutoLowercaseCommandsSection();
             public static BlockNamespaceCommandsSection BLOCK_NAMESPACE_COMMANDS = new BlockNamespaceCommandsSection();
             public static HandleThroughProxySection HANDLE_THROUGH_PROXY = new HandleThroughProxySection();
@@ -577,7 +579,28 @@ public class Storage {
         }
 
         public static boolean canPlayerAccess(Object player, String command, BlockType type, String server) {
-            boolean blocked = isBlocked(command, type, server);
+            final boolean allowGroupOverruling = ConfigSections.Settings.ALLOW_GROUP_OVERRULING.ENABLED;
+            final boolean blocked = isBlocked(command, type, server);
+
+            if (allowGroupOverruling) {
+                GroupManager.AccessResult groupResult = GroupManager.canAccessCommand(player, command, type, server);
+                if (groupResult == GroupManager.AccessResult.NEGATED) {
+                    return false;
+                }
+
+                if (!blocked) {
+                    return true;
+                }
+
+                if (Storage.getPermissionPlugin() != PermissionPlugin.NONE) {
+                    if (PermissionUtil.hasBypassPermission(player, command)) {
+                        return true;
+                    }
+                }
+
+                return groupResult.asBoolean();
+            }
+
 
             if (!blocked) {
                 return true;
@@ -589,9 +612,37 @@ public class Storage {
                 }
             }
 
-            return GroupManager.canAccessCommand(player, command, type, server);
+            return GroupManager.canAccessCommand(player, command, type, server).asBoolean();
         }
 
+        /*
+        Experimental:
+
+        It allows to negate commands inside a PAT group to block them off,
+        even though it is allowed inside the global section.
+
+        public static boolean canPlayerAccess(Object player, String command, BlockType type, String server) {
+            boolean blocked = isBlocked(command, type, server);
+            GroupManager.AccessResult groupResult = GroupManager.canAccessCommand(player, command, type, server);
+
+            if (groupResult == GroupManager.AccessResult.NEGATED) {
+                return false;
+            }
+
+            if (!blocked) {
+                return true;
+            }
+
+            if (Storage.getPermissionPlugin() != PermissionPlugin.NONE) {
+                if (PermissionUtil.hasBypassPermission(player, command)) {
+                    return true;
+                }
+            }
+
+            return groupResult.asBoolean();
+        }
+         */
+
         public static boolean isBlockedChat(String command) {
             return isBlocked(command, BlockType.CHAT, null);
         }
@@ -617,34 +668,45 @@ public class Storage {
             BlockType negation = BlockType.NEGATE;
             String negatedCommand = negation + command;
 
-            boolean listed = isListed(command, type, server),
+            boolean all = isListed("*", type, server),
+                    listed = isListed(command, type, server),
                     negatedListed = isListed(negatedCommand, type, server),
                     turn = ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED;
 
+            if (all) {
+                // Only listens to negated commands
+                if (negatedListed) {
+                    return turn;
+                }
 
-            if (!turn && negatedListed) {
-                listed = !listed;
+                return !turn;
             }
 
+
+
+            /*
             if (turn) {
                 return !listed;
             } else {
                 return listed;
             }
+             */
+
+            return turn != listed; // Shorter version of above's code
 
         }
 
         private static boolean isListed(String unmodifiedCommand, BlockType type, String server) {
-            if (server != null && isDisabledServer(server))
+            if (server != null && isDisabledServer(server)) {
                 return false;
+            }
 
-            boolean turn = Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED;
             boolean listed = false;
 
             String command = type.toString() + unmodifiedCommand;
 
             if (server == null || !isIgnoredServer(server)) {
-                listed = BLACKLIST.isListed(command, false/*!turn*/);
+                listed = BLACKLIST.isListed(command, false);
             }
 
             if (server == null) {
@@ -661,11 +723,11 @@ public class Storage {
                 blacklists.add(BLACKLIST);
 
             for (GeneralBlacklist blacklist : blacklists) {
-                if (listed/* && turn*/) {
+                if (listed) {
                     break;
                 }
 
-                listed = blacklist.isListed(command, false/*turn*/);
+                listed = blacklist.isListed(command, false);
             }
 
             if (!listed && type != BlockType.BOTH) {

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

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

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

@@ -1,6 +1,5 @@
 package de.rayzs.pat.api.storage.config.settings;
 
-import de.rayzs.pat.api.storage.Storage;
 import de.rayzs.pat.api.storage.storages.ConfigStorage;
 import de.rayzs.pat.utils.StringUtils;
 import de.rayzs.pat.utils.configuration.helper.ConfigSectionHelper;
@@ -8,7 +7,7 @@ import de.rayzs.pat.utils.permission.PermissionUtil;
 
 public class BlockNamespaceCommandsSection extends ConfigStorage {
 
-    public boolean ENABLED;
+    public boolean ENABLED, ALWAYS_BLOCK_COMMAND;
 
     public BlockNamespaceCommandsSection() {
         super("block-namespace-commands");
@@ -18,15 +17,22 @@ public class BlockNamespaceCommandsSection extends ConfigStorage {
     public void load() {
         super.load();
         ENABLED = new ConfigSectionHelper<Boolean>(this, "enabled", true).getOrSet();
+        ALWAYS_BLOCK_COMMAND = new ConfigSectionHelper<Boolean>(this, "always-block-command", true).getOrSet();
+    }
+
+    public boolean doesAlwaysBlock(String command) {
+        return ALWAYS_BLOCK_COMMAND && isCommand(command);
     }
 
     public boolean isCommand(String command) {
-        if(!ENABLED || Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED) return false;
+        if (!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/storages/BlacklistStorage.java

@@ -9,13 +9,14 @@ import java.util.*;
 public class BlacklistStorage extends StorageTemplate implements Serializable {
 
     private List<String> commands = new ArrayList<>();
+    private List<String> hiddenCommands = new ArrayList<>();
 
     public BlacklistStorage(String navigatePath) {
         super(Storage.Files.STORAGE, navigatePath);
     }
 
     public boolean isListed(String command) {
-        return isListed(command, false/*!Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED*/);
+        return isListed(command, false);
     }
 
     public boolean isListed(String command, boolean ignoreColons) {
@@ -25,11 +26,19 @@ public class BlacklistStorage extends StorageTemplate implements Serializable {
             return false;
         }
 
+        /*
         if (!isNegated(command) && commands.contains("*")) {
             return true;
         }
+        */
 
-        for (String listedCommand : commands) {
+        boolean isNegated = isNegated(command);
+
+        if (!isNegated) {
+            command = StringUtils.getFirstArg(command);
+        }
+
+        for (String listedCommand : hiddenCommands) {
             if (listedCommand == null)
                 continue;
 
@@ -40,14 +49,14 @@ public class BlacklistStorage extends StorageTemplate implements Serializable {
                     command = command.substring(command.indexOf(':'));
             }
 
-            if (caseSensitive) {
-                if (StringUtils.getFirstArg(listedCommand).equals(StringUtils.getFirstArg(command))) {
-                    return true;
-                }
-            } else {
-                if (StringUtils.getFirstArg(listedCommand).equalsIgnoreCase(StringUtils.getFirstArg(command))) {
-                    return true;
-                }
+            if (!isNegated) {
+                listedCommand = StringUtils.getFirstArg(listedCommand);
+            }
+
+            if (caseSensitive && listedCommand.equals(command)) {
+                return true;
+            } else if (!caseSensitive && listedCommand.equalsIgnoreCase(command)) {
+                return true;
             }
         }
 
@@ -59,14 +68,17 @@ public class BlacklistStorage extends StorageTemplate implements Serializable {
     }
 
     public BlacklistStorage add(String command) {
-        if (!commands.contains(command))
+        if (!commands.contains(command)) {
             commands.add(command);
+            hiddenCommands.add(command);
+        }
 
         return this;
     }
 
     public BlacklistStorage remove(String command) {
         commands.remove(command);
+        hiddenCommands.remove(command);
         return this;
     }
 
@@ -79,6 +91,10 @@ public class BlacklistStorage extends StorageTemplate implements Serializable {
         return commands;
     }
 
+    public List<String> getHiddenCommands() {
+        return hiddenCommands;
+    }
+
     @Override
     public void save() {
         getConfig().setAndSave(getNavigatePath(), commands);
@@ -87,7 +103,35 @@ public class BlacklistStorage extends StorageTemplate implements Serializable {
     @Override
     public void load() {
         getConfig().reload();
+
         commands = (ArrayList<String>) getConfig().getOrSet(getNavigatePath(), commands);
+
+        List<String> tmpCommands = commands != null ? new ArrayList<>(commands) : new ArrayList<>();
+        Set<String> pluginListCommands = new HashSet<>();
+
+        final String pluginCommandPrefix = "plugin=";
+
+        for (String command : tmpCommands) {
+            if (command.startsWith(pluginCommandPrefix)) {
+                pluginListCommands.add(command);
+            }
+        }
+
+        tmpCommands.removeAll(pluginListCommands);
+
+        for (String pluginListCommand : pluginListCommands) {
+            pluginListCommand = pluginListCommand.substring(pluginCommandPrefix.length());
+
+            List<String> pluginCommands = Storage.getLoader().getPluginCommands(pluginListCommand, false);
+
+            for (String pluginCommand : pluginCommands) {
+                if (!commands.contains(Storage.Blacklist.BlockType.NEGATE + pluginCommand)) {
+                    tmpCommands.add(pluginCommand);
+                }
+            }
+        }
+
+        hiddenCommands = tmpCommands;
     }
 
     private boolean isNegated(String command) {

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

@@ -139,7 +139,10 @@ public class BukkitLoader extends JavaPlugin implements PluginLoader {
 
         StorageConverter.initialize();
 
-        PATScheduler.createScheduler(this::loadAllCommands);
+        PATScheduler.createScheduler(() -> {
+            Storage.reload();
+            loadAllCommands();
+        });
     }
 
     @Override
@@ -394,6 +397,29 @@ public class BukkitLoader extends JavaPlugin implements PluginLoader {
         return pluginNames;
     }
 
+    @Override
+    public List<String> getPluginCommands(String pluginName, boolean useColons) {
+        List<String> commands = new ArrayList<>();
+
+        if (pluginName.isBlank()) return commands;
+
+        pluginName = pluginName.toLowerCase();
+
+        for (Map.Entry<String, Command> entry : BukkitLoader.getCommandsMap().entrySet()) {
+            if (entry.getKey().toLowerCase().startsWith(pluginName + ":")) {
+                String command = entry.getKey().substring(pluginName.length() + 1);
+
+                commands.add(command);
+
+                if (useColons) {
+                    commands.add(entry.getKey());
+                }
+            }
+        }
+
+        return commands;
+    }
+
     private void loadCommandMap() {
         try {
             if (Bukkit.getPluginManager() instanceof SimplePluginManager) {

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

@@ -272,6 +272,11 @@ public class BungeeLoader extends Plugin implements PluginLoader {
         return pluginNames;
     }
 
+    @Override
+    public List<String> getPluginCommands(String pluginName, boolean useColons) {
+        return List.of();
+    }
+
     public void startUpdaterTask() {
         if (!Storage.ConfigSections.Settings.UPDATE.ENABLED)
             return;

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

@@ -41,6 +41,8 @@ public interface PluginLoader {
     List<String> getOnlinePlayerNames();
     List<String> getOfflinePlayerNames();
 
+    List<String> getPluginCommands(String pluginName, boolean useColons);
+
     /**
      * <pre>
      * %n = Plugin name

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

@@ -38,7 +38,7 @@ import java.util.*;
 
 @Plugin(name = "ProAntiTab",
 id = "proantitab",
-version = "2.1.2",
+version = "2.2.0",
 authors = "Rayzs_YT",
 description = "Hide more than just your plugins. Hide almost everything!",
 url = "https://www.rayzs.de/products/proantitab/page",
@@ -297,6 +297,11 @@ public class VelocityLoader implements PluginLoader {
         return pluginNames;
     }
 
+    @Override
+    public List<String> getPluginCommands(String pluginName, boolean useColons) {
+        return List.of();
+    }
+
     public void startUpdaterTask() {
         if (!Storage.ConfigSections.Settings.UPDATE.ENABLED) return;
 

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

@@ -2,6 +2,8 @@ package de.rayzs.pat.plugin.listeners.bukkit;
 
 import java.util.List;
 
+import de.rayzs.pat.utils.sender.CommandSender;
+import de.rayzs.pat.utils.sender.CommandSenderHandler;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
@@ -45,7 +47,9 @@ public class BukkitBlockCommandListener implements Listener {
 
     @EventHandler (priority = EventPriority.LOWEST)
     public void onPlayerCommandProcess(PlayerCommandPreprocessEvent event) {
-        Player player = event.getPlayer();
+        final Player player = event.getPlayer();
+        final CommandSender sender = CommandSenderHandler.from(player);
+
         final String commandFirstArg = StringUtils.getFirstArg(event.getMessage());
 
         if (Storage.ConfigSections.Settings.AUTO_LOWERCASE_COMMANDS.isCommand(commandFirstArg)) {
@@ -71,6 +75,14 @@ public class BukkitBlockCommandListener implements Listener {
         command = command.substring(1);
         command = StringUtils.getFirstArg(command);
 
+        if (Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED) {
+            return;
+        }
+
+        if (PermissionUtil.hasBypassPermission(player, command)) {
+            return;
+        }
+
         final String displayCommand = StringUtils.replaceTriggers(command, "", "\\", "<", ">", "&");
 
         List<String> notificationMessage = MessageTranslator.replaceMessageList(
@@ -79,10 +91,6 @@ public class BukkitBlockCommandListener implements Listener {
                 "%command%", displayCommand,
                 "%world%", worldName);
 
-        if (PermissionUtil.hasBypassPermission(player, command)) {
-            return;
-        }
-
         if (Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isCommand(command)) {
 
             MessageTranslator.send(
@@ -127,13 +135,24 @@ public class BukkitBlockCommandListener implements Listener {
             return;
         }
 
-        if (!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED)
-            return;
-        
-        if (Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED)
-            return;
+        final boolean cancelBlockedCommand = Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED;
 
-        if (!Storage.Blacklist.canPlayerAccessChat(player, command)) {
+        boolean allowed = Storage.Blacklist.canPlayerAccessChat(player, command);
+        boolean blockedNamespace = false;
+
+        if (!Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesBypass(sender)) {
+            blockedNamespace = cancelBlockedCommand
+                    ? Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.isCommand(command)
+                    : Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesAlwaysBlock(command);
+
+            if (blockedNamespace) allowed = false;
+        }
+
+        if (!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED && !blockedNamespace) {
+            return;
+        }
+
+        if (!allowed) {
             ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(
                     player,
                     event.getMessage(),

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

@@ -2,7 +2,9 @@ package de.rayzs.pat.plugin.listeners.bungee;
 
 import de.rayzs.pat.api.event.PATEventHandler;
 import de.rayzs.pat.api.event.events.FilteredTabCompletionEvent;
+import de.rayzs.pat.api.netty.proxy.BungeePacketAnalyzer;
 import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
 import de.rayzs.pat.utils.permission.PermissionUtil;
 import net.md_5.bungee.api.config.ServerInfo;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
@@ -10,19 +12,32 @@ import net.md_5.bungee.api.event.TabCompleteEvent;
 import net.md_5.bungee.api.event.TabCompleteResponseEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
-import java.util.List;
+
+import java.util.ArrayList;
 
 public class BungeeAntiTabListener implements Listener {
 
     @EventHandler
-    public void onTabComplete(TabCompleteEvent event) {
-        if(!(event.getSender() instanceof ProxiedPlayer)) return;
+    public void onTabCompleteResponse(TabCompleteResponseEvent event) {
 
-        ProxiedPlayer player = (ProxiedPlayer) event.getSender();
+        if(!(event.getReceiver() instanceof ProxiedPlayer)) return;
+
+        ProxiedPlayer player = (ProxiedPlayer) event.getReceiver();
 
         ServerInfo serverInfo = player.getServer().getInfo();
         String serverName = serverInfo.getName();
-        String cursor = event.getCursor().substring(1);
+
+        String rawCursor = BungeePacketAnalyzer.getPlayerInput(player);
+
+        if (rawCursor == null) {
+            return;
+        }
+
+        if (!rawCursor.startsWith("/")) {
+            return;
+        }
+
+        String cursor = rawCursor.substring(1);
 
         if (event.getSuggestions().isEmpty())
             return;
@@ -33,16 +48,59 @@ public class BungeeAntiTabListener implements Listener {
         if (PermissionUtil.hasBypassPermission(player))
             return;
 
-        FilteredTabCompletionEvent filteredTabCompletionEvent = PATEventHandler.callFilteredTabCompletionEvents(player, cursor, event.getSuggestions());
-        List<String> suggestions = filteredTabCompletionEvent.getCompletion();
 
-        event.getSuggestions().removeIf(suggestion -> {
 
-            if (Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(suggestion) || Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(suggestion)) {
+        final boolean doesBypassNamespace = Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesBypass(player);
+        final boolean spaces = cursor.contains(" ");
+
+        boolean cancelsBeforeHand = false;
+
+        if (Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.isCommand(cursor) && !doesBypassNamespace) {
+            cancelsBeforeHand = true;
+        }
+
+        if (!cancelsBeforeHand && !cursor.isEmpty()) {
+            cancelsBeforeHand = !Storage.Blacklist.canPlayerAccessTab(player, StringUtils.getFirstArg(cursor), serverName);
+        }
+
+        if (!cancelsBeforeHand) {
+            cancelsBeforeHand = Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isCommand(cursor) || Storage.ConfigSections.Settings.CUSTOM_VERSION.isCommand(cursor);
+        }
+
+        if (spaces) {
+            if (cancelsBeforeHand) {
+                event.getSuggestions().clear();
+                return;
+            }
+
+            FilteredTabCompletionEvent filteredTabCompletionEvent = PATEventHandler.callFilteredTabCompletionEvents(player.getUniqueId(), rawCursor, new ArrayList<>(event.getSuggestions()));
+
+            if (filteredTabCompletionEvent.isCancelled()) {
+                event.getSuggestions().clear();
+            } else {
+                event.getSuggestions().removeIf(s -> !filteredTabCompletionEvent.getCompletion().contains(s));
+            }
+
+            return;
+        }
+
+        event.getSuggestions().removeIf(s -> {
+            String cpy = s;
+            if (cpy.startsWith("/")) {
+                cpy = cpy.substring(1);
+            }
+
+            if (Storage.ConfigSections.Settings.CUSTOM_PLUGIN.isTabCompletable(cpy) || Storage.ConfigSections.Settings.CUSTOM_VERSION.isTabCompletable(cpy)) {
                 return false;
             }
 
-            return !suggestions.contains(suggestion);
+            return !Storage.Blacklist.canPlayerAccessTab(player, cpy, serverName);
         });
     }
+
+    @EventHandler
+    public void onTabComplete(TabCompleteEvent event) {
+        ProxiedPlayer player = (ProxiedPlayer) event.getSender();
+        BungeePacketAnalyzer.setPlayerInput(player, event.getCursor());
+    }
 }

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

@@ -3,6 +3,8 @@ package de.rayzs.pat.plugin.listeners.bungee;
 import de.rayzs.pat.api.event.events.ExecuteCommandEvent;
 import de.rayzs.pat.utils.permission.PermissionUtil;
 import de.rayzs.pat.utils.message.MessageTranslator;
+import de.rayzs.pat.utils.sender.CommandSender;
+import de.rayzs.pat.utils.sender.CommandSenderHandler;
 import net.md_5.bungee.api.event.ChatEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import de.rayzs.pat.plugin.logger.Logger;
@@ -20,12 +22,14 @@ public class BungeeBlockCommandListener implements Listener {
     public void onChat(ChatEvent event) {
         if (event.isCancelled()) return;
 
-        Connection connection = event.getSender();
+        final Connection connection = event.getSender();
         if (! (connection instanceof ProxiedPlayer) || !event.getMessage().startsWith("/"))
             return;
 
-        ProxiedPlayer player = (ProxiedPlayer) connection;
-        String serverName = player.getServer().getInfo().getName();
+        final ProxiedPlayer player = (ProxiedPlayer) connection;
+        final CommandSender sender = CommandSenderHandler.from(player);
+        final String serverName = player.getServer().getInfo().getName();
+
         String command = event.getMessage();
 
         if (PermissionUtil.hasBypassPermission(player, command) || Storage.Blacklist.isDisabledServer(serverName))
@@ -87,10 +91,24 @@ public class BungeeBlockCommandListener implements Listener {
             return;
         }
 
-        if (!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED)
-            return;
+        final boolean cancelBlockedCommand = Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED;
 
-        if (!Storage.Blacklist.canPlayerAccessChat(player, command, serverName)) {
+        boolean allowed = Storage.Blacklist.canPlayerAccessChat(player, command, serverName);
+        boolean blockedNamespace = false;
+
+        if (!Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesBypass(sender)) {
+            blockedNamespace = cancelBlockedCommand
+                    ? Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.isCommand(command)
+                    : Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesAlwaysBlock(command);
+
+            if (blockedNamespace) allowed = false;
+        }
+
+        if (!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED && !blockedNamespace) {
+            return;
+        }
+
+        if (!allowed) {
             ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(
                     player,
                     event.getMessage(),

src/main/java/de/rayzs/pat/plugin/listeners/velocity/VelocityBlockCommandListener.java

@@ -10,6 +10,9 @@ import com.velocitypowered.api.proxy.Player;
 import de.rayzs.pat.api.storage.Storage;
 import de.rayzs.pat.utils.StringUtils;
 import de.rayzs.pat.api.event.*;
+import de.rayzs.pat.utils.sender.CommandSender;
+import de.rayzs.pat.utils.sender.CommandSenderHandler;
+
 import java.util.List;
 
 public class VelocityBlockCommandListener {
@@ -27,19 +30,20 @@ public class VelocityBlockCommandListener {
         if(!event.getResult().isAllowed())
             return event;
 
-        CommandSource commandSource = event.getCommandSource();
-        Object consoleSender = Storage.getLoader().getConsoleSender();
+        final CommandSource commandSource = event.getCommandSource();
+        final Object consoleSender = Storage.getLoader().getConsoleSender();
 
         if(! (commandSource instanceof Player))
             return event;
 
-        Player player = (Player) commandSource;
-        String command = StringUtils.getFirstArg(event.getCommand());
-
-        String serverName = player.getCurrentServer().isPresent()
+        final Player player = (Player) commandSource;
+        final CommandSender sender = CommandSenderHandler.from(player);
+        final String serverName = player.getCurrentServer().isPresent()
                 ? player.getCurrentServer().get().getServerInfo().getName()
                 : "unknown";
 
+        String command = StringUtils.getFirstArg(event.getCommand());
+
         if (PermissionUtil.hasBypassPermission(player, command) || Storage.Blacklist.isDisabledServer(serverName))
             return event;
 
@@ -97,10 +101,24 @@ public class VelocityBlockCommandListener {
             return event;
         }
 
-        if (!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED)
-            return event;
+        final boolean cancelBlockedCommand = Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED;
 
-        if (!Storage.Blacklist.canPlayerAccessChat(player, command, serverName)) {
+        boolean allowed = Storage.Blacklist.canPlayerAccessChat(player, command, serverName);
+        boolean blockedNamespace = false;
+
+        if (!Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesBypass(sender)) {
+            blockedNamespace = cancelBlockedCommand
+                    ? Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.isCommand(command)
+                    : Storage.ConfigSections.Settings.BLOCK_NAMESPACE_COMMANDS.doesAlwaysBlock(command);
+
+            if (blockedNamespace) allowed = false;
+        }
+
+        if (!Storage.ConfigSections.Settings.CANCEL_COMMAND.ENABLED && !blockedNamespace) {
+            return event;
+        }
+
+        if (!allowed) {
             ExecuteCommandEvent executeCommandEvent = PATEventHandler.callExecuteCommandEvents(
                     player,
                     event.getCommand(),

src/main/java/de/rayzs/pat/plugin/logger/Logger.java

@@ -90,13 +90,15 @@ public class Logger {
                 .append(Storage.ConfigSections.Settings.TURN_BLACKLIST_TO_WHITELIST.ENABLED ? "WHITELIST" : "BLACKLIST")
                 .append("\n");
 
-        builder.append("Detected Software-API: ")
-                .append(Reflection.isProxyServer()
-                        ? Reflection.isPaper() ? "Waterfall" :
-                        Reflection.isVelocityServer() ? "Velocity" : "Bungeecord"
-                        : Reflection.isFoliaServer() ? "Folia"
-                        : Reflection.isPaper() ? "Paper" : "Spigot")
-                .append("\n");
+        builder.append("Detected Software-API: ");
+
+        if (Reflection.isProxyServer()) {
+            builder.append(Reflection.isPaper() ? "Waterfall" : Reflection.isVelocityServer() ? "Velocity" : "Bungeecord");
+        } else {
+            builder.append(Reflection.isFoliaServer() ? "Folia" : Reflection.isPaper() ? "Paper" : "Spigot");
+        }
+
+        builder.append("\n");
 
         builder.append("Installed plugins: \n  ")
                 .append(String.join("\n  ", Storage.getLoader().getPluginNames("%n (%v)")))
@@ -129,7 +131,7 @@ public class Logger {
                     .append("\n");
 
             builder.append("last-received-sync: ")
-                    .append(Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED ? Storage.LAST_SYNC : "Deactivated")
+                    .append(Storage.ConfigSections.Settings.HANDLE_THROUGH_PROXY.ENABLED ? TimeConverter.calcAndGetTime(Storage.LAST_SYNC) : "Deactivated")
                     .append("\n");
         }
 
@@ -143,7 +145,7 @@ public class Logger {
                     .append("\n");
 
             builder.append("last-sent-sync: ")
-                    .append(Storage.ConfigSections.Settings.DISABLE_SYNC.DISABLED ? "Deactivated" : (System.currentTimeMillis() - Storage.LAST_SYNC))
+                    .append(Storage.ConfigSections.Settings.DISABLE_SYNC.DISABLED ? "Deactivated" : (TimeConverter.calcAndGetTime(Storage.LAST_SYNC)))
                     .append("\n\n");
 
             for (ClientInfo client : Communicator.CLIENTS) {

src/main/java/de/rayzs/pat/plugin/process/impl/local/modify/AddCommand.java

@@ -58,6 +58,7 @@ public class AddCommand extends ProCommand {
         if (command.isEmpty())
             return false;
 
+        final boolean loadBlacklist = command.startsWith("plugin=") || command.startsWith("!");
         final int length = args.length;
 
         if (length == 1) {
@@ -67,6 +68,8 @@ public class AddCommand extends ProCommand {
 
             if (!exist) {
                 Storage.Blacklist.getBlacklist().add(command).save();
+                if (loadBlacklist) Storage.Blacklist.getBlacklist().load();
+
                 Storage.handleChange();
             }
 

src/main/java/de/rayzs/pat/plugin/process/impl/local/modify/ClearCommand.java

@@ -34,6 +34,7 @@ public class ClearCommand extends ProCommand {
             }
 
             Storage.Blacklist.getBlacklist().clear().save();
+            Storage.Blacklist.getBlacklist().load();
             Storage.handleChange();
 
             CONFIRMATION.remove(sender.getUniqueId());

src/main/java/de/rayzs/pat/plugin/process/impl/local/modify/ExtractCommand.java

@@ -94,17 +94,7 @@ public class ExtractCommand extends ProCommand {
             return true;
         }
 
-        List<String> commands = new ArrayList<>();
-        for (Map.Entry<String, Command> entry : BukkitLoader.getCommandsMap().entrySet()) {
-            if (entry.getKey().toLowerCase().startsWith(pluginName + ":")) {
-                String command = entry.getKey().substring(args[0].length() + 1);
-                commands.add(command);
-
-                if (useColons) {
-                    commands.add(entry.getKey());
-                }
-            }
-        }
+        List<String> commands = Storage.getLoader().getPluginCommands(args[0], useColons);
 
         BlacklistStorage storage = group == null
                 ? Storage.Blacklist.getBlacklist()

src/main/java/de/rayzs/pat/plugin/process/impl/local/modify/RemoveCommand.java

@@ -57,6 +57,7 @@ public class RemoveCommand extends ProCommand {
         if (command.isEmpty())
             return false;
 
+        final boolean loadBlacklist = command.startsWith("plugin=") || command.startsWith("!");
         final int length = args.length;
 
         if (length == 1) {
@@ -64,6 +65,8 @@ public class RemoveCommand extends ProCommand {
 
             if (exist) {
                 Storage.Blacklist.getBlacklist().remove(command).save();
+                if (loadBlacklist) Storage.Blacklist.getBlacklist().load();
+
                 Storage.handleChange();
             }
 

src/main/java/de/rayzs/pat/plugin/process/impl/server/ServAddCommand.java

@@ -90,7 +90,15 @@ public class ServAddCommand extends ProCommand {
         Group group = GroupManager.getGroupByName(groupName);
 
         if (group == null) {
-            sender.sendMessage(Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER.replace("%group%", groupName));
+
+            String message = Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER;
+
+            message = StringUtils.replace(message,
+                    "%group%", groupName,
+                    "%server%", serverName
+            );
+
+            sender.sendMessage(message);
             return true;
         }
 

src/main/java/de/rayzs/pat/plugin/process/impl/server/ServClearCommand.java

@@ -2,6 +2,7 @@ package de.rayzs.pat.plugin.process.impl.server;
 
 import de.rayzs.pat.api.command.ProCommand;
 import de.rayzs.pat.api.storage.Storage;
+import de.rayzs.pat.utils.StringUtils;
 import de.rayzs.pat.utils.sender.CommandSender;
 import de.rayzs.pat.utils.ExpireCache;
 import de.rayzs.pat.utils.group.Group;
@@ -66,12 +67,14 @@ public class ServClearCommand extends ProCommand {
 
         if (group == null) {
 
-            sender.sendMessage(
-                    Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER
-                            .replace("%group%", groupName)
-                            .replace("%server%", serverName)
+            String message = Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER;
+
+            message = StringUtils.replace(message,
+                    "%group%", groupName,
+                    "%server%", serverName
             );
 
+            sender.sendMessage(message);
             return true;
         }
 

src/main/java/de/rayzs/pat/plugin/process/impl/server/ServRemoveCommand.java

@@ -95,12 +95,14 @@ public class ServRemoveCommand extends ProCommand {
 
         if (group == null) {
 
-            sender.sendMessage(
-                    Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER
-                            .replace("%group%", groupName)
-                            .replace("%server%", serverName)
+            String message = Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER;
+
+            message = StringUtils.replace(message,
+                    "%group%", groupName,
+                    "%server%", serverName
             );
 
+            sender.sendMessage(message);
             return true;
         }
 

src/main/java/de/rayzs/pat/plugin/process/impl/server/list/ServListCommand.java

@@ -43,6 +43,7 @@ public class ServListCommand extends ProCommand {
             );
 
             String message = Storage.ConfigSections.Messages.BLACKLIST.LIST_SERVER_MESSAGE;
+
             message = StringUtils.replace(message,
                     "%size%", String.valueOf(blacklist.getCommands().size()),
                     "%commands%", commandsListMessage,
@@ -57,7 +58,15 @@ public class ServListCommand extends ProCommand {
         Group group = GroupManager.getGroupByName(groupName);
 
         if (group == null) {
-            sender.sendMessage(Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER.replace("%group%", groupName));
+
+            String message = Storage.ConfigSections.Messages.GROUP.DOES_NOT_EXIST_SERVER;
+
+            message = StringUtils.replace(message,
+                    "%group%", groupName,
+                    "%server%", serverName
+            );
+
+            sender.sendMessage(message);
             return true;
         }
 

src/main/java/de/rayzs/pat/utils/CommandsCache.java

@@ -9,6 +9,14 @@ import de.rayzs.pat.utils.permission.PermissionUtil;
 
 public class CommandsCache {
 
+    /**
+     *
+     *
+     * RECODE PLANNED
+     *
+     *
+     */
+
     private List<String> filteredCommands = null, allCommands = null;
     private boolean change = false;
 
@@ -46,7 +54,7 @@ public class CommandsCache {
             return;
 
         LinkedList<String> tmpFilteredCommands = new LinkedList<>();
-        List<String> tmpAllCommands = Collections.unmodifiableList(commands);
+        List<String> tmpAllCommands = new ArrayList<>(commands);
         allCommands = tmpAllCommands;
 
         final int length = allCommands.size();

src/main/java/de/rayzs/pat/utils/group/Group.java

@@ -108,6 +108,10 @@ public class Group implements Serializable {
 
     public void add(String command) {
         this.generalGroupBlacklist.add(command).save();
+
+        if (command.startsWith("plugin=") || command.startsWith("!")) {
+            this.generalGroupBlacklist.load();
+        }
     }
 
     public void add(String command, String server) {
@@ -118,6 +122,10 @@ public class Group implements Serializable {
 
     public void remove(String command) {
         this.generalGroupBlacklist.remove(command).save();
+
+        if (command.startsWith("plugin=") || command.startsWith("!")) {
+            this.generalGroupBlacklist.load();
+        }
     }
 
     public void remove(String command, String server) {
@@ -128,6 +136,7 @@ public class Group implements Serializable {
 
     public void clear() {
         this.generalGroupBlacklist.clear().save();
+        this.generalGroupBlacklist.load();
     }
 
     public void clear(String server) {

src/main/java/de/rayzs/pat/utils/group/GroupManager.java

@@ -55,30 +55,38 @@ public class GroupManager {
         return playerGroups;
     }
 
-    public static boolean canAccessCommand(Object targetObj, String unmodifiedCommand, Storage.Blacklist.BlockType type) {
+    public static AccessResult canAccessCommand(Object targetObj, String unmodifiedCommand, Storage.Blacklist.BlockType type) {
         return canAccessCommand(targetObj, unmodifiedCommand, type, null);
     }
 
-    public static boolean canAccessCommand(Object targetObj, String unmodifiedCommand, Storage.Blacklist.BlockType type, String server) {
+    public static AccessResult
+    canAccessCommand(Object targetObj, String unmodifiedCommand, Storage.Blacklist.BlockType type, String server) {
         final CommandSender sender = CommandSenderHandler.from(targetObj);
 
         if (sender == null) {
-            Logger.warning("Failed to load player! (GroupManager#62)");
-            return false;
+            Logger.warning("Failed to load player! (GroupManager#66)");
+            return AccessResult.UNKNOWN;
         }
 
         final List<Group> playerGroups = sender.getGroups();
 
         if (playerGroups == null || playerGroups.isEmpty()) {
-            return false;
+            return AccessResult.NO_GROUPS;
         }
-        
-        String command = type.toString() + unmodifiedCommand;
 
-        boolean permitted = false;
+        String command = type.toString() + unmodifiedCommand;
+        String allCommand = type + "*";
+        String negatedCommand = type.toString() + BlockType.NEGATE + unmodifiedCommand;
+
+        boolean all = false,
+                permitted = false,
+                negated = false;
+
         for (Group group : playerGroups) {
 
+            all = group.contains(allCommand);
             permitted = group.contains(command);
+            negated = group.contains(negatedCommand);
 
             if (permitted) {
                 break;
@@ -90,21 +98,35 @@ public class GroupManager {
 
                 for (String s : servers) {
 
-                    if (group.contains(command, s)) {
-                        permitted = true;
-                        break;
+                    if (!all) {
+                        all = group.contains(allCommand, s);
                     }
 
+                    if (!permitted) {
+                        permitted = group.contains(command, s);
+                    }
+
+                    if (!negated) {
+                        negated = group.contains(negatedCommand, s);
+                    }
                 }
 
             }
 
         }
 
+        if (negated) {
+            return AccessResult.NEGATED;
+        }
+
+        if (all) {
+            return AccessResult.ALLOWED;
+        }
+
         if (!permitted && type != BlockType.BOTH)
             return canAccessCommand(targetObj, unmodifiedCommand, Storage.Blacklist.BlockType.BOTH, server);
         
-        return permitted;
+        return permitted ? AccessResult.ALLOWED : AccessResult.NOT_LISTED;
     }
 
     public static void setGroup(String groupName, List<String> commands) {
@@ -251,4 +273,19 @@ public class GroupManager {
     public static boolean isGroupRegistered(String groupName) {
         return getGroupByName(groupName) != null;
     }
+
+    public enum AccessResult {
+        ALLOWED(true), NEGATED(false),
+        NO_GROUPS(false), NOT_LISTED(false),
+        UNKNOWN(false);
+
+        private final boolean bool;
+        AccessResult(boolean bool) {
+            this.bool = bool;
+        }
+
+        public boolean asBoolean() {
+            return this.bool;
+        }
+    }
 }

src/main/resources/bungee.yml

@@ -3,7 +3,7 @@ description: Hide more than just your plugins. Hide almost everything!
 website: https://www.rayzs.de/products/proantitab/page
 
 author: Rayzs_YT
-version: 2.1.2
+version: 2.2.0
 main: de.rayzs.pat.plugin.BungeeLoader
 
 softDepends: [LuckPerms, PAPIProxyBridge]

src/main/resources/files/bukkit-config.yml

@@ -64,6 +64,15 @@ turn-blacklist-to-whitelist: true
 # Pro tip: You can also just use auto-lowercase-commands feature instead. ^^
 base-command-case-sensitive: true
 
+# (!) Warning:
+#     Enabling this could lead to performance issues depending on
+#     the amount of players and commands. (> 1100)
+#
+# This allows PAT groups to block commands, which have been allowed
+# inside the global section. This can be achieved by negating commands
+# inside a PAT group.
+allow-group-overruling: false
+
 # (!) Warning:
 #     Enabling this could lead to performance issues if many players
 #     change worlds frequently in a short amount of time.
@@ -178,6 +187,9 @@ custom-version:
 # You can bypass this restriction with the proantitab.namespace permission.
 block-namespace-commands:
   enabled: false
+  # Basically blocks the command execution no matter if
+  # 'cancel-blocked-commands' is enabled or not.
+  always-block-command: true
 
 #>> HTP (Overwritten)
 # Auto lowercase all commands when being executed,

src/main/resources/files/proxy-config.yml

@@ -32,7 +32,6 @@ updater:
 # In other words, the backend servers won't receive any updates from the proxy about the storage.yml.
 # It's here to prevent any unnecessary communication between the proxy and the backend servers, if PAT is being used on the proxy alone.
 # For why this can be the case, read the following: https://github.com/RayzsYT/ProAntiTab/wiki/FAQ#can-i-install-pat-just-on-my-proxy-server
-# It is NOT recommended to enable this option, unless you know what you are doing.
 disable-sync: false
 
 # This is a very necessary feature if you have way too many commands to block and instead decide
@@ -48,6 +47,15 @@ turn-blacklist-to-whitelist: true
 #   /HelP --> Allowed
 base-command-case-sensitive: true
 
+# (!) Warning:
+#     Enabling this could lead to performance issues depending on
+#     the amount of players and commands. (> 1100)
+#
+# This allows PAT groups to block commands, which have been allowed
+# inside the global section. This can be achieved by negating commands
+# inside a PAT group.
+allow-group-overruling: false
+
 # Here you can customize the server version that is displayed on a ping. (The text at the player-count)
 custom-protocol-ping:
   enabled: true
@@ -145,6 +153,9 @@ custom-version:
 # You can bypass this restriction with the proantitab.namespace permission.
 block-namespace-commands:
   enabled: false
+  # Basically blocks the command execution no matter if
+  # 'cancel-blocked-commands' is enabled or not.
+  always-block-command: true
 
 # Patches a small exploit which causes the server to lag.
 # Due to the fact that PAT interacts directly with Tab-Completions and their packets,

src/main/resources/plugin.yml

@@ -3,7 +3,7 @@ description: Hide more than just your plugins. Hide almost everything!
 website: https://www.rayzs.de/products/proantitab/page
 
 author: Rayzs_YT
-version: 2.1.2
+version: 2.2.0
 api-version: 1.13
 folia-supported: true
 main: de.rayzs.pat.plugin.BukkitLoader