Abbreviated Commands Tutorial (Organization).

Hello Bukkit.org learners! As you may know, having abbreviations for the commands in your plugins is a good thing to do when working with plugins that have similar if not the same command prefix, or it could be used as a way to of giving your plugin identity, either way really.

Requirements for this tutorial:

• A basic knowledge of Java(you may be able to complete this without, but you wont understand)
• A basic knowledge of the Bukkit API
• 2 Large Popsicle sticks.

Normally, as you should know if you've read any other tutorial or worked with Bukkit at all, the standard method of command register in the main class would be (after you have made 'exename' an object instance of your executor class.)

Code:Java

getCommand("acommandname").setExecutor(exename);

Well the way the getCommand method works, basically, it checks input against the supplied input, if it matches it will send that strings arguments to the the class object you created. You can then respond based on arguments.

Lets get right into the important stuff:
NOTE: Remember, this is the way I do it, some of this is personal preference.

So first off, in your main class, you only have to register 1, yes 1, command.
Everything else will become an argument. That's the idea.
This tutorial is more about good organization, rather then new concepts.

1) Make a main class.
2) Make a sub-package of that class with '.command' on the end of it.
3) In that new package, create a 'CommandCore' class.
4) Also in that new package create a 'basic' class.

In your main class, where you define your variables:

Code:Java

private CommandCore cmdc;

In your onEnable():

Code:Java

getCommand("basic").setExecutor(cmdc);

Now, head over to your CommandCore class.
Create your constructor

Code:Java

public CommandCore(Main main) {
// TODO Auto-generated constructor stub
}

Of course make your onCommand as usual:

Code:Java

@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {

Wait, wait, wait! slow down, go back to the top of the class, right after the class declaration, and define the the other class in your command package.

Code:Java

private Basic bsc = new Basic();

Now head over to your Basic class.
Only make boolean methods in your 'action' classes.
NOTE: CommandCore will point to actions based on args[].
In Basic.java

Code:Java

public boolean welcome(CommandSender sender, Command cmd, String label, String[] args)
{
sender.sendMessage(ChatColor.DARK_AQUA + "Welcome");
return true;
}

Okay, so hold on here a moment. (Ignore the main class for the moment, as there is nothing left to be written in it) we have a CommandCore class with a basic onCommand, so whenever the text "basic" is entered as a command, it will use the CommandCore executor. We don't need to check what the player entered because if it was sent to this executor, the command had to have been "basic" right? So the only thing we have to look for is arguments! yay! And because we have an object instance of the "basic" class, which holds actual command functions, we can access its methods.
So, if we want "Welcome" to display if the player dosen't enter any arguments we could( in CommandCore)

Code:Java

public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
{
if(args.length == 0)
{
return bsc.welcome(sender , cmd , label,  args);
}
} 

That will execute the code within the 'welcome' method in the 'basic' class AND return its boolean value. If you wanted to go more in in depth you could make another class, in the command package, called 'greet'.
within hello you could say

Code:Java

public boolean greet(CommandSender sender, Command cmd, String label, String[] args)
{
if(args.length == 1)
{
sender.sendMessage("Please specify kind of greeting");
return true;
}
else if(args[1].equalsIgnoreCase("hi"))
{
sender.sendMessage("Hi, yourself good sir.");
return true;
}
else if(args[1].equalsIgnoreCase("sup"))
{
sender.sendMessage("Sup Brah! Ya feel me?");
return true;
}
else
{
sender.sendMessage("I don't Recognize that one...");
return true;
}

So now you will be able to (in CommandCore)
at the top

Code:Java

private greet gt = new greet();

and in onCommand

Code:Java

 
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
{
if(args.length == 0)
{
return bsc.welcome(sender , cmd , label ,  args);
}
       else if(args[0].equalsIgnoreCase("hello"))
        {
      return gt.greet(sender , cmd , label , args);
        }      //All the other arguments are sent to these classes, so they too, must use the same
               //params. You can think of it as extending the onCommand method.
} 

Another thing that could be useful for users:
in the plugin.yml

Code:

name: meh
main: me.package.main.Main
version: 1.0
commands:
   Basic:
      aliases: [ b, bsc ]
      description: Shows welcome and instruction
      usage: /b <command>

The player will then only have to use '/b' as their prefix, because we have set 'basic's alias to 'b' or
'bsc'.

Here is an example of this method being used in a more fleshed out manner (Sorry for not giving any context, but this plugin is still in developement):

Code:java

package me.sajo.militaris.command;
 
import me.sajo.militaris.Militaris;
import me.sajo.militaris.command.data.MilitarisChat;
import me.sajo.militaris.command.data.MilitarisIO;
import me.sajo.militaris.command.data.MilitarisIndex;
import me.sajo.militaris.command.data.MilitarisMil;
import me.sajo.militaris.command.data.MilitarisPayRank;
import me.sajo.militaris.command.data.MilitarisRand;
import me.sajo.militaris.command.data.MilitarisRank;
import me.sajo.militaris.command.data.MilitarisRankE;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@SuppressWarnings("unused")
public class CommandCore implements CommandExecutor
{
//private MilitarisPayCommands   mpc = new MilitarisPayCommands();
private MilitarisIndex index = new MilitarisIndex();
private MilitarisChat chat = new MilitarisChat();
private MilitarisPayRank payrank = new MilitarisPayRank();
private MilitarisRank rank = new MilitarisRank();
private MilitarisRankE rankE = new MilitarisRankE();
private MilitarisRand rand = new MilitarisRand();
private MilitarisMil Mili = new MilitarisMil();
private MilitarisIO milio = new MilitarisIO();
 
public CommandCore(Militaris militaris) {
// TODO Auto-generated constructor stub
}
 
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
{
if(sender instanceof Player == false)
{
sender.sendMessage("You must be a player!");
return true;
}
else
{
 
if((args.length < 1))
{
//if here there was no args.
return Mili.Mil(sender, cmd, label, args);
}
 
if(args[0].equalsIgnoreCase("chat"))
{
return chat.milchat(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("reload"))
{
return milio.milreload(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("save"))
{
return milio.milsave(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("index"))
{
return index.index(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("ranks"))
{
return rank.milranks(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("setrank"))
{
return rank.setrank(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("promote"))
{
return rankE.promo(sender, cmd, label, args);
}
if(args[0].equalsIgnoreCase("demote"))
{
return rankE.dmote(sender, cmd, label, args);
}
 
}
 
return false;
}
 
}
 

So, maybe that tutorial meant something to you, maybe it didn't. Feel free to express your own ideas about how you would have done it, I enjoy hearing them.

 

great tutorial! I cant believe no one commented on this!