Command Executor Plugin name prefix?

Hey guys,

Just wondering if anyone's come up with a good way to use command executors with a prefix. So, all my plugins commands would be /td reload, /td give <player> <amount>, etc.

The obvious way, and from my searching it seems this is how most people do it, is by having only a single executor, which then reads the args as separate commands, which seems really awful to me. I'd really like to know if anyone has got a way to NOT to it this way. Separate CommandExecutors for each command, as well as a prefix for every command.

Thanks in advance (unless you just tell me to read the args, lol)

 

You could remove the space in the command ("/tdreload" instead of "/td reload") and just create several command executors that handle the diffrent commands. Or you could have one main command executor wich handles all commands but simply calls external classes and their methods for doing the work instead of having all the logic in the executor

Like this:

Code:

if(args[0].equalsIgnoreCase("reload") {
    PluginNameReload reload = new PluginNameReload();
 
    switch(args[1]):
 
        case "whatever":
            reload.whatever();
            return true;
        case "somethingelse":
            reload.somethingelse();
            return true;
        etc...

 

switch statements with strings doesn't work in java.

 

You can do that since Java 7: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html @ Using Strings in switch Statements, but it's recommended to compile against Java 6 at most because not everybody upgraded to Java 7 and plugins compiled on Java 7 that are run on Java 6 give the Major.Minor error.

 

Thanks for the info though :3

 

hmmm.

I've haven't tried any of this out yet. But does it seem like a really terrible idea to catch PlayerCommandPreprocess, check if its got my prefix, then if it does, set the message to something else so that I can have separate command executors?

pseudo code, like this;

Code:

 
@EventHandler
public void onCommandPreprocess(PlayerCommandPreprocessEvent event){
    String[] split = event.getMessage().split(" ");
       if (split[0] is my plugin name || an alias){
           event.setMessage(String.format("cmd-%s " + args, split[1]));
       }
}
 

And then I could have the Command Executor be checking for my reformatted commands

Code:

CmdReload reload = new CmdReload(this);
this.getCommand("cmd-reload").setExecutor(reload);

I'm not sure if that makes it cleaner or messier, but it does get me the separate executors that I want.

Any thoughts?

 

Well it seems like an awfull amount of extra work to just have a cleaner command executor.

 

If you don't mind to make the implemention a bit more complicated but the final usage easier, you could have a look at the command implemention of worldguard and implement a simple one yourself in your plugin.

I worte a basic version of this system myself for my plugin and vorks very well. (Thank you sk89q for making this code available!)

edit: I don't know what it is actually used for but in my opinion it is a bad style to use onCommandPreprocess.

 

You can delegate from one commandExecutor to another one, but you would need a handle to the other commandExecutor you are delegating to.

 

I'm not sure what exactly is going on in world guard's code. It still seems like they're handling a bunch of commands all in one class. Perhaps I'm just not understanding what command.setInjector is doing.

 

Thats what I do and it works well!

 

Is it poor practice to go the command preprocess route, tho?

 

Kind of, the bukkit's new /help system can only detect registered commands, not commands processed in events.

You should use the plugin.yml registered commands... best way would be to register them without spaces, but if you want spaces, the prefix registered as command and the 1st argument as sub-commands is just as fine.

 

I quite like the idea to use Annotations like WorldEdit does. You use it to specify a new subcommand for your maincommand. In my implementation it basically checks every method for the specific Command-Annotation and reads detailed information about the command from it.
Although this code is fairly new written and some things could be done better, it works just fine for me.

In the spoiler below is the code for an example CommandExecutor i currently use:

Show Spoiler Hide Spoiler

Code:java

 
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
 
 
public class MyCommandExecutor implements CommandExecutor
{
private <PluginClass> plugin;
 
public MyCommandExecutor(<PluginClass> plugin) {
this.plugin = plugin;
}
 
//##### HANDLER ITSELF #####
 
@Override
public boolean onCommand(CommandSender sender, org.bukkit.command.Command cmd, String commandLabel, String[] args)
{
if(args.length >= 1) //a work was given
{
for (Method m: this.getClass().getMethods()) //search on every method a command annotation
{
Command ann = m.getAnnotation(Command.class);
 
if(ann == null) continue; //not a command method
 
if(ann.cmd().equals(args[0])) //if the method is responsible for issued command
{
if(hasPermission(sender, ann)) //and has the permission
{
if(hasEnoughArgs(ann, args)) //are there enough
{
try {
m.invoke(this, sender, args); //run!
}
catch (Exception e) {
e.printStackTrace();
}
}
else
{
sender.sendMessage(ann.usage());
}
return true;
}
else
{
sender.sendMessage("You don't have the permission!");
return true;
}
}
 
}
sender.sendMessage("Subcommand was not found!");
}
else
{
cmdHelp(sender, args);
}
return true;
}
 
private boolean hasPermission(CommandSender sender, Command ann) {
 
if(ann.permissions().length == 0) //no permissions needed
{
return true;
}
 
if(!(sender instanceof Player)) //assume it came from console... Maybe TODO
{
return true;
}
 
Player p = (Player) sender;
for(String perm : ann.permissions()) //check for bukkit permission; OR system, to be changed into AND
{
if(p.hasPermission(perm))
{
return true;
}
}
 
return false;
}
 
//##### COMMANDS #####
@Command(cmd = "help", permissions={"ultrahardcoremc.gamemaster"})
public void cmdHelp(CommandSender sender, String[] args)
{
sender.sendMessage("Helpfile to be written!"); //TODO Help file
}
 
@Command(cmd = "reload")
public void cmdReload(CommandSender sender, String[] args)
{
plugin.reloadConfig();
sender.sendMessage("Config reloaded!");
}
 
@Command(cmd = "by", permissions={"test.developer"})
public void cmdBy(CommandSender sender, String[] args)
{
sender.sendMessage("Plugin created by Someone!");
}
 
//##### HELPER #####
private static boolean hasEnoughArgs(Command ann, String[] args)
{
int numargs = args.length-1; //don't count command itself
 
if(numargs < ann.minArgs())
{
//System.out.print("Too less args!");
return false;
}
 
if(ann.maxArgs() != -1 && numargs > ann.maxArgs())
{
//System.out.print("Too much args!");
return false;
}
return true;
}
}
 
@Retention(RetentionPolicy.RUNTIME)
@interface Command
{
String cmd();
String[] permissions() default {}; //made it so that it can require more than one permission node
 
String usage() default "No usage found!";
 
int minArgs() default 0;
int maxArgs() default -1;
}
 

I went this way with command processing. You will have to find the way you like and want to work with because it's never good to use something you can't really understand which will end with a complete mess^^

 

Tempelchat

Alright, thanks for the example : ) Appreciate it.

How exactly do you do that?

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Woah. Thanks. Ive always wondered how to do this. Almost impossibru. XD