start admin chat, except there is a bug where we have to now add optional arguments

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

@@ -4,14 +4,16 @@ import com.destroystokyo.paper.brigadier.BukkitBrigadierCommandSource;
 import com.google.common.collect.Maps;
 import com.google.gson.GsonBuilder;
 import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.*;
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.tree.CommandNode;
+import com.mojang.brigadier.tree.LiteralCommandNode;
 import dev.plex.Plex;
 import dev.plex.cache.DataUtils;
-import dev.plex.command.annotation.CommandName;
+import dev.plex.command.annotation.*;
-import dev.plex.command.annotation.CommandPermission;
+import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.command.annotation.Default;
-import dev.plex.command.annotation.SubCommand;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
@@ -25,10 +27,10 @@ import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 
+import java.lang.System;
 import java.lang.reflect.Method;
-import java.util.HashMap;
+import java.lang.reflect.Parameter;
-import java.util.Map;
+import java.util.*;
-import java.util.UUID;
 
 /**
  * @author Taah
@@ -47,8 +49,6 @@ public abstract class PlexBrigadierCommand
         {
             final Object dedicatedServer = ReflectionsUtil.callFunction(getCraftServer(), "getServer");
             final Object minecraftServer = Class.forName("net.minecraft.server.MinecraftServer").cast(dedicatedServer);
-            //            System.out.println(Arrays.toString(Arrays.stream(minecraftServer.getClass().getDeclaredMethods()).map(Method::getName).toArray(String[]::new)));
-
             final Object serverFunctionsManager = ReflectionsUtil.callFunction(minecraftServer, "aA");
             this.commandDispatcher = ReflectionsUtil.callFunction(serverFunctionsManager, "b");
         }
@@ -60,7 +60,10 @@ public abstract class PlexBrigadierCommand
 
         if (!this.getClass().isAnnotationPresent(CommandName.class))
         {
-            PlexLog.error("Cannot find command name for class " + this.getClass().getName());
+            if (this.commandDispatcher != null)
+            {
+                this.commandDispatcher.register(execute());
+            }
             return;
         }
 
@@ -89,128 +92,203 @@ public abstract class PlexBrigadierCommand
 
         if (this.commandDispatcher != null)
         {
-            for (String s : commandName)
+            for (String name : commandName)
             {
-                PlexLog.debug("registering command " + s);
+                LiteralArgumentBuilder<BukkitBrigadierCommandSource> builder = LiteralArgumentBuilder.literal(name.toLowerCase());
-                LiteralArgumentBuilder<BukkitBrigadierCommandSource> builder = LiteralArgumentBuilder.literal(s.toLowerCase());
+
                 for (Map.Entry<String, Method> stringMethodEntry : subcommands.entrySet())
                 {
-                    PlexLog.debug("registering subcommand " + stringMethodEntry.getKey());
                     String[] subCommandArgs = stringMethodEntry.getKey().split(" ");
-                    LiteralArgumentBuilder<BukkitBrigadierCommandSource> parentBuilder = LiteralArgumentBuilder.literal(subCommandArgs[0]);
+                    LinkedList<LiteralArgumentBuilder<BukkitBrigadierCommandSource>> builders = new LinkedList<>();
-                    LiteralArgumentBuilder<BukkitBrigadierCommandSource> currSubCommand = parentBuilder;
+                    for (int i = 0; i < subCommandArgs.length; i++)
-                    if (subCommandArgs.length == 1)
                     {
-                        parentBuilder.executes(context ->
+                        LiteralArgumentBuilder<BukkitBrigadierCommandSource> newNode = LiteralArgumentBuilder.literal(subCommandArgs[i]);
-                        {
+                        builders.addLast(newNode);
-                            if (stringMethodEntry.getValue().isAnnotationPresent(CommandPermission.class))
-                            {
-                                String permission = stringMethodEntry.getValue().getAnnotation(CommandPermission.class).value();
-                                if (!context.getSource().getBukkitSender().hasPermission(permission))
-                                {
-                                    send(context, PlexUtils.messageString("noPermissionNode", permission));
-                                    return 0;
                     }
-                            }
+
-                            try
+                    if (builders.size() == 1)
                     {
-                                stringMethodEntry.getValue().invoke(this, context.getSource().getBukkitSender());
+                        LiteralArgumentBuilder<BukkitBrigadierCommandSource> parent = builders.removeFirst();
-                            }
+                        LinkedList<RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> argumentBuilders = new LinkedList<>();
-                            catch (Exception e)
+
+                        LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> arguments = getArguments(stringMethodEntry.getValue());
+                        for (Map.Entry<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> parameterArgumentBuilderEntry : arguments.entrySet())
                         {
-                                PlexLog.error(e.getMessage());
+                            argumentBuilders.addLast(parameterArgumentBuilderEntry.getValue());
-                                for (StackTraceElement stackTraceElement : e.getStackTrace())
+                        }
+                        boolean setExecution = false;
+                        CommandNode<BukkitBrigadierCommandSource> parentArg = null;
+                        CommandNode<BukkitBrigadierCommandSource> currArg = null;
+                        while (!argumentBuilders.isEmpty())
                         {
-                                    PlexLog.error(stackTraceElement.toString());
+                            if (parentArg == null)
+                            {
+                                RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newParent = argumentBuilders.removeFirst();
+                                if (argumentBuilders.isEmpty())
+                                {
+                                    newParent.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
+                                    setExecution = true;
                                 }
-                                return 0;
+                                parentArg = newParent.build();
-                            }
+                                parent.then(parentArg);
-                            return 1;
+                                currArg = parentArg;
-                        });
                             }
                             else
                             {
-                        for (int i = 1; i < subCommandArgs.length; i++)
+                                RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newCurr = argumentBuilders.removeFirst();
+                                if (argumentBuilders.isEmpty())
                                 {
-                            LiteralArgumentBuilder<BukkitBrigadierCommandSource> curr = LiteralArgumentBuilder.literal(subCommandArgs[i]);
+                                    newCurr.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
-                            if (i == subCommandArgs.length - 1)
+                                    setExecution = true;
-                            {
+                                }
-                                curr.executes(context ->
+                                CommandNode<BukkitBrigadierCommandSource> newCurrNode = newCurr.build();
-                                {
+                                currArg.addChild(newCurrNode);
-                                    if (stringMethodEntry.getValue().isAnnotationPresent(CommandPermission.class))
+                                currArg = newCurrNode;
-                                    {
-                                        String permission = stringMethodEntry.getValue().getAnnotation(CommandPermission.class).value();
-                                        if (!context.getSource().getBukkitSender().hasPermission(permission))
-                                        {
-                                            send(context, PlexUtils.messageString("noPermissionNode", permission));
-                                            return 0;
                             }
                         }
-                                    try
+                        if (!setExecution)
                         {
-                                        stringMethodEntry.getValue().invoke(this, context.getSource().getBukkitSender());
+                            parent.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
                         }
-                                    catch (Exception e)
+                        builder.then(parent);
+                    }
+                    else if (builders.size() > 1)
                     {
-                                        PlexLog.error(e.getMessage());
+                        LiteralCommandNode<BukkitBrigadierCommandSource> parent = builders.removeFirst().build();
-                                        for (StackTraceElement stackTraceElement : e.getStackTrace())
+                        LiteralCommandNode<BukkitBrigadierCommandSource> curr = null;
+                        while (!builders.isEmpty())
                         {
-                                            PlexLog.error(stackTraceElement.toString());
+                            LiteralArgumentBuilder<BukkitBrigadierCommandSource> newCurr = builders.removeFirst();
+                            PlexLog.debug("Adding subcommand " + newCurr.getLiteral());
+                            if (builders.isEmpty())
+                            {
+                                LinkedList<RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> argumentBuilders = new LinkedList<>();
+                                LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> arguments = getArguments(stringMethodEntry.getValue());
+                                for (Map.Entry<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> parameterArgumentBuilderEntry : arguments.entrySet())
+                                {
+                                    argumentBuilders.addLast(parameterArgumentBuilderEntry.getValue());
                                 }
-                                        return 0;
+                                boolean setExecution = false;
+                                CommandNode<BukkitBrigadierCommandSource> parentArg = null;
+                                CommandNode<BukkitBrigadierCommandSource> currArg = null;
+                                while (!argumentBuilders.isEmpty())
+                                {
+                                    if (parentArg == null)
+                                    {
+                                        RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newParent = argumentBuilders.removeFirst();
+                                        if (argumentBuilders.isEmpty())
+                                        {
+                                            newParent.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
+                                            setExecution = true;
                                         }
-                                    return 1;
+                                        parentArg = newParent.build();
-                                });
+                                        newCurr.then(parentArg);
+                                        currArg = parentArg;
                                     }
-                            currSubCommand.then(curr);
+                                    else
-                            currSubCommand = curr;
+                                    {
+                                        RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newCurrArg = argumentBuilders.removeFirst();
+                                        if (argumentBuilders.isEmpty())
+                                        {
+                                            newCurrArg.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
+                                            setExecution = true;
                                         }
+                                        CommandNode<BukkitBrigadierCommandSource> newCurrNode = newCurrArg.build();
+                                        currArg.addChild(newCurrNode);
+                                        currArg = newCurrNode;
+                                    }
+                                }
+                                if (!setExecution)
+                                {
+                                    newCurr.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
+                                }
+                            }
+                            if (curr == null)
+                            {
+                                LiteralCommandNode<BukkitBrigadierCommandSource> temp = newCurr.build();
+                                parent.addChild(temp);
+                                curr = temp;
+                            }
+                            else
+                            {
+                                LiteralCommandNode<BukkitBrigadierCommandSource> temp = newCurr.build();
+                                curr.addChild(temp);
+                                curr = temp;
+                            }
+                        }
+                        builder.then(parent);
+                    }
+                    PlexLog.debug("Overall Builder: " + new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create().toJson(builder));
                 }
 
-                    PlexLog.debug(new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create().toJson(parentBuilder));
-
-                    builder = builder.then(
-                            parentBuilder
-                    );
-                }
                 if (defaultMethod != null)
                 {
-                    PlexLog.debug("registering default method");
+                    LinkedList<RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> argumentBuilders = new LinkedList<>();
+                    LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> arguments = getArguments(defaultMethod);
+                    for (Map.Entry<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> parameterArgumentBuilderEntry : arguments.entrySet())
+                    {
+                        argumentBuilders.addLast(parameterArgumentBuilderEntry.getValue());
+                    }
+                    boolean setExecution = false;
+                    CommandNode<BukkitBrigadierCommandSource> parentArg = null;
+                    CommandNode<BukkitBrigadierCommandSource> currArg = null;
+                    while (!argumentBuilders.isEmpty())
+                    {
+                        if (parentArg == null)
+                        {
+                            RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newParent = argumentBuilders.removeFirst();
+                            if (argumentBuilders.isEmpty())
+                            {
                                 Method finalDefaultMethod = defaultMethod;
-                    finalDefaultMethod.setAccessible(true);
+                                newParent.executes(context -> execute(finalDefaultMethod, context, arguments.keySet()));
-                    builder = builder.executes(context ->
+                                setExecution = true;
+                            }
+                            parentArg = newParent.build();
+                            builder.then(parentArg);
+                            currArg = parentArg;
+                        }
+                        else
                         {
-                        if (finalDefaultMethod.isAnnotationPresent(CommandPermission.class))
+                            RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newCurrArg = argumentBuilders.removeFirst();
+                            if (argumentBuilders.isEmpty())
                             {
-                            String permission = finalDefaultMethod.getAnnotation(CommandPermission.class).value();
+                                Method finalDefaultMethod1 = defaultMethod;
-                            if (!context.getSource().getBukkitSender().hasPermission(permission))
+                                newCurrArg.executes(context -> execute(finalDefaultMethod1, context, arguments.keySet()));
-                            {
+                                setExecution = true;
-                                send(context, PlexUtils.messageString("noPermissionNode", permission));
+                            }
-                                return 0;
+                            CommandNode<BukkitBrigadierCommandSource> newCurrNode = newCurrArg.build();
+                            currArg.addChild(newCurrNode);
+                            currArg = newCurrNode;
                         }
                     }
-                        try
+                    if (!setExecution)
                     {
-                            finalDefaultMethod.invoke(this, context.getSource().getBukkitSender());
+                        Method finalDefaultMethod2 = defaultMethod;
+                        builder.executes(context -> execute(finalDefaultMethod2, context, arguments.keySet()));
                     }
-                        catch (Exception e)
-                        {
-                            PlexLog.error(e.getMessage());
-                            for (StackTraceElement stackTraceElement : e.getStackTrace())
-                            {
-                                PlexLog.error(stackTraceElement.toString());
                 }
-                            return 0;
+
-                        }
-                        return 1;
-                    });
-                }
-                PlexLog.debug(new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create().toJson(builder));
                 this.commandDispatcher.register(builder);
             }
+
+            this.commandDispatcher.register(LiteralArgumentBuilder.<BukkitBrigadierCommandSource>literal("testing")
+                    .then(RequiredArgumentBuilder.<BukkitBrigadierCommandSource, Integer>argument("test0", IntegerArgumentType.integer())
+                            .then(RequiredArgumentBuilder.<BukkitBrigadierCommandSource, String>argument("test", StringArgumentType.word())
+                                    .then(RequiredArgumentBuilder.<BukkitBrigadierCommandSource, String>argument("test1", StringArgumentType.word())
+                                            .executes(context ->
+                                            {
+                                                send(context, context.getArgument("test", String.class));
+                                                send(context, context.getArgument("test1", String.class));
+                                                return 1;
+                                            })))));
         }
     }
 
+    public LiteralArgumentBuilder<BukkitBrigadierCommandSource> execute()
+    {
+        return LiteralArgumentBuilder.literal(this.getClass().getName().toLowerCase());
+    }
+
     /**
      * Gets a PlexPlayer from Player object
      *
@@ -355,6 +433,128 @@ public abstract class PlexBrigadierCommand
         return player.getUniqueId();
     }
 
+    private LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> getArguments(Method method)
+    {
+        LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> result = new LinkedHashMap<>();
+        if (!method.canAccess(this))
+        {
+            method.setAccessible(true);
+        }
+        for (Parameter parameter : method.getParameters())
+        {
+            if (parameter.isAnnotationPresent(Argument.class))
+            {
+                Argument argument = parameter.getAnnotation(Argument.class);
+                if (String.class.isAssignableFrom(parameter.getType()))
+                {
+                    result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), argument.argumentType() == StringArgumentType.StringType.SINGLE_WORD ? StringArgumentType.word() : StringArgumentType.greedyString()));
+                }
+                else if (int.class.isAssignableFrom(parameter.getType()))
+                {
+                    result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), IntegerArgumentType.integer(argument.min() == Double.MIN_VALUE ? Integer.MIN_VALUE : (int) argument.min(), argument.max() == Double.MAX_VALUE ? Integer.MAX_VALUE : (int) argument.max())));
+                }
+                else if (double.class.isAssignableFrom(parameter.getType()))
+                {
+                    result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), DoubleArgumentType.doubleArg(argument.min(), argument.max())));
+                }
+                else if (float.class.isAssignableFrom(parameter.getType()))
+                {
+                    result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), FloatArgumentType.floatArg(argument.min() == Double.MIN_VALUE ? Float.MIN_VALUE : (int) argument.min(), argument.max() == Double.MAX_VALUE ? Float.MAX_VALUE : (int) argument.max())));
+                }
+                else if (boolean.class.isAssignableFrom(parameter.getType()))
+                {
+                    result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), BoolArgumentType.bool()));
+                }
+                else if (long.class.isAssignableFrom(parameter.getType()))
+                {
+                    result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), LongArgumentType.longArg(argument.min() == Double.MIN_VALUE ? Long.MIN_VALUE : (int) argument.min(), argument.max() == Double.MAX_VALUE ? Long.MAX_VALUE : (int) argument.max())));
+                }
+            }
+        }
+        return result;
+    }
+
+    private Object getArgument(Class<?> clazz, CommandContext<BukkitBrigadierCommandSource> context, String name)
+    {
+        if (String.class.isAssignableFrom(clazz))
+        {
+            return StringArgumentType.getString(context, name);
+        }
+        else if (int.class.isAssignableFrom(clazz))
+        {
+            return IntegerArgumentType.getInteger(context, name);
+        }
+        else if (double.class.isAssignableFrom(clazz))
+        {
+            return DoubleArgumentType.getDouble(context, name);
+        }
+        else if (float.class.isAssignableFrom(clazz))
+        {
+            return FloatArgumentType.getFloat(context, name);
+        }
+        else if (boolean.class.isAssignableFrom(clazz))
+        {
+            return BoolArgumentType.getBool(context, name);
+        }
+        else if (long.class.isAssignableFrom(clazz))
+        {
+            return LongArgumentType.getLong(context, name);
+        }
+        return null;
+    }
+
+    private int execute(Method method, CommandContext<BukkitBrigadierCommandSource> context, Set<Parameter> arguments)
+    {
+        if (method.isAnnotationPresent(CommandPermission.class))
+        {
+            String permission = method.getAnnotation(CommandPermission.class).value();
+            if (!context.getSource().getBukkitSender().hasPermission(permission))
+            {
+                send(context, PlexUtils.messageComponent("noPermissionNode", permission));
+                return 1;
+            }
+        }
+        try
+        {
+            List<Object> params = arguments
+                    .stream().map(bukkitBrigadierCommandSourceArgumentBuilder -> getArgument(bukkitBrigadierCommandSourceArgumentBuilder.getType(), context, bukkitBrigadierCommandSourceArgumentBuilder.getAnnotation(Argument.class).value())).toList();
+            LinkedList<Object> parameters = new LinkedList<>(params);
+//            parameters.addFirst(context.getSource().getBukkitSender());
+            if (method.isAnnotationPresent(CommandSource.class)) {
+                RequiredCommandSource commandSource = method.getAnnotation(CommandSource.class).value();
+                if (commandSource == RequiredCommandSource.IN_GAME) {
+                    if (!(context.getSource().getBukkitSender() instanceof Player player)) {
+                        send(context, PlexUtils.messageComponent("noPermissionConsole"));
+                        return 1;
+                    } else {
+                        parameters.addFirst(player);
+                    }
+                } else if (commandSource == RequiredCommandSource.CONSOLE) {
+                    if (context.getSource().getBukkitSender() instanceof Player) {
+                        send(context, PlexUtils.messageComponent("noPermissionInGame"));
+                        return 1;
+                    }
+                    parameters.addFirst(context.getSource().getBukkitSender());
+                } else {
+                    parameters.addFirst(context.getSource().getBukkitSender());
+                }
+            }
+            System.out.println(Arrays.toString(parameters.stream().map(Object::getClass).map(Class::getName).toArray()));
+            System.out.println(Arrays.toString(Arrays.stream(method.getParameterTypes()).map(Class::getName).toArray()));
+            method.invoke(this, parameters.toArray());
+            return 1;
+        }
+        catch (Exception e)
+        {
+            PlexLog.error(e.getMessage());
+            for (StackTraceElement stackTraceElement : e.getStackTrace())
+            {
+                PlexLog.error(stackTraceElement.toString());
+            }
+            return 0;
+        }
+    }
+
     private Object getCraftServer()
     {
         String nmsVersion = Bukkit.getServer().getClass().getPackage().getName();

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

@@ -0,0 +1,25 @@
+package dev.plex.command.annotation;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Taah
+ * @project Plex
+ * @since 4:31 AM [08-07-2023]
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface Argument
+{
+    String value();
+
+    StringArgumentType.StringType argumentType() default StringArgumentType.StringType.SINGLE_WORD;
+
+    double min() default Double.MIN_VALUE;
+    double max() default Double.MAX_VALUE;
+}

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

@@ -0,0 +1,20 @@
+package dev.plex.command.annotation;
+
+import dev.plex.command.source.RequiredCommandSource;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Taah
+ * @project Plex
+ * @since 7:08 AM [09-07-2023]
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface CommandSource
+{
+    RequiredCommandSource value() default RequiredCommandSource.ANY;
+}

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

@@ -0,0 +1,33 @@
+package dev.plex.command.impl.brigadier;
+
+import dev.plex.cache.DataUtils;
+import dev.plex.command.PlexBrigadierCommand;
+import dev.plex.command.annotation.CommandName;
+import dev.plex.command.annotation.CommandPermission;
+import dev.plex.command.annotation.CommandSource;
+import dev.plex.command.annotation.Default;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.player.PlexPlayer;
+import org.apache.commons.lang3.BooleanUtils;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import static dev.plex.util.PlexUtils.messageComponent;
+
+/**
+ * @author Taah
+ * @project Plex
+ * @since 6:54 AM [09-07-2023]
+ */
+@CommandName({"adminchat", "o", "sc", "ac", "staffchat"})
+public class AdminChatCMD extends PlexBrigadierCommand
+{
+    @Default
+    @CommandPermission("plex.adminchat")
+    @CommandSource(RequiredCommandSource.IN_GAME)
+    public void toggle(Player sender) {
+        PlexPlayer player = DataUtils.getPlayer(sender.getUniqueId());
+        player.setStaffChat(!player.isStaffChat());
+        send(sender, messageComponent("adminChatToggled", BooleanUtils.toStringOnOff(player.isStaffChat())));
+    }
+}

server/src/main/java/dev/plex/command/impl/brigadier/PlexBrigadierCMD.java

@@ -1,17 +1,11 @@
 package dev.plex.command.impl.brigadier;
 
-import com.destroystokyo.paper.brigadier.BukkitBrigadierCommandSource;
-import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import dev.plex.command.PlexBrigadierCommand;
-import dev.plex.command.annotation.CommandName;
+import dev.plex.command.annotation.*;
-import dev.plex.command.annotation.CommandPermission;
-import dev.plex.command.annotation.Default;
-import dev.plex.command.annotation.SubCommand;
 import dev.plex.command.exception.CommandFailException;
 import dev.plex.module.PlexModule;
 import dev.plex.module.PlexModuleFile;
 import dev.plex.util.BuildInfo;
-import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
@@ -23,7 +17,7 @@ import java.util.stream.Collectors;
  * @project Plex
  * @since 3:46 PM [07-07-2023]
  */
-@CommandName({"plex"})
+@CommandName({"plex", "pplexx"})
 public class PlexBrigadierCMD extends PlexBrigadierCommand
 {
     @SubCommand("reload")
@@ -54,6 +48,14 @@ public class PlexBrigadierCMD extends PlexBrigadierCommand
         send(sender, "Plex successfully reloaded.");
     }
 
+    /*@SubCommand("test yourmom")
+    @CommandPermission("plex.test")
+    public void testPlex(CommandSender sender, @Argument(value = "test", min =  0, max = 100) int i, @Argument(value = "test2", min =  0, max = 100) int j*//*, @Argument(value = "param", argumentType = StringArgumentType.StringType.GREEDY_PHRASE) String param*//*) {
+//        send(sender, String.valueOf(i));
+        send(sender, String.valueOf(j));
+//        send(sender, param);
+    }*/
+
     @SubCommand("redis")
     @CommandPermission("plex.redis")
     public void testRedis(CommandSender sender)
@@ -83,6 +85,15 @@ public class PlexBrigadierCMD extends PlexBrigadierCommand
         send(sender, mmString("<green>All modules reloaded!"));
     }
 
+    /*@SubCommand("modules testing more args")
+    @CommandPermission("plex.modules.reload")
+    public void viewViewModules(CommandSender sender)
+    {
+        send(sender, "leave me alone");
+//        send(sender, mmString("<gold>Modules (" + plugin.getModuleManager().getModules().size() + "): <yellow>" + StringUtils.join(plugin.getModuleManager().getModules().stream().map(PlexModule::getPlexModuleFile).map(PlexModuleFile::getName).collect(Collectors.toList()), ", ")));
+
+    }*/
+
     @Default
     public void defaultCommand(CommandSender sender)
     {