Using the bukkit CommandMap

Hey.

Recently I've been working on this class so you don't need to input your commands into the plugin.yml. I've been attempting different approaches all day to get this working, thought no luck. Mind pointing me in the right direction?

RetronCommand:

Code:

/**
* ****************************************************************************************
* All code contained within this document is sole property of WesJD. All rights reserved.*
* Do NOT distribute/reproduce any of this code without permission from WesJD.            *
* Not following this statement will result in a void of all agreements made.             *
* Enjoy.                                                                                 *
* ****************************************************************************************
*/
public abstract class RetronCommand extends Command {

    public RetronCommand(String name) {
        super(name);
        Main.registerCommand(this);
    }

    @Override
    public boolean execute(CommandSender sender, String string, String[] args) {
        if (sender instanceof Player) {
            RetronPlayer p = new RetronPlayer((Player) sender);

            if (p.isGhosted()) {
                p.message(Main.getPrefix() + ChatColor.RED + "Error: You are currenty ghosted. Please relog to fix this.");
                return false;
            }

            onCmd(p, string, args);

        } else {
            sender.sendMessage(ChatColor.RED + "Only players can use commands.");
        }
        return false;
    }

    public abstract void onCmd(RetronPlayer p, String string, String[] args);

}

The register command method & how I get the bukkit CommandMap:

Code:

public static void registerCommand(Command cmd) {
        cmap.register("", cmd);
    }

Code:

//cmap is just a CommandMap instance

try {
            Field f = Bukkit.getServer().getClass().getDeclaredField("commandMap");
            f.setAccessible(true);
            cmap = (CommandMap) f.get(Bukkit.getServer());
            f.setAccessible(false);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

(no errors.)

 

@WesJD I'm not sure if this is possible, I was trying this the other day and was trying everything under the sun.

I wouldn't say give up trying, maybe there is. But it's not likely..

 

create your own command registration

 

@ESSHD http://bukkit.org/threads/resource-...nds-without-accessing-your-plugin-yml.195990/

If you're trying to do it, use this resource. I'm basically doing it to improve my understanding of how this works.

 

That might be wrong but mabe use reflection to override the unknown command message and process commands on preprocesscommand event :-3 but yes command map will be the ideal way

 

It's certainly possible, but I don't know why you would bother when the plugin yml is only a couple lines to add.

 

API's.. API's..

 

@1Rogue So I can create a command in 5 seconds with no hassle of setting it up.

 

Code:

commands:
  mycommand:
    description: such hassle very ptsd

 

@1Rogue Don't forget to set the executor class.

 

Well you certainly can do that, but that's up to you for java. There are very simple ways of abstracting your own command system to handle commands from bukkit, such as defining your own Command class and having a CommandHandler or something of the sort.

 

Changed the code up to this, but still no luck.

Code:

/**
* ****************************************************************************************
* All code contained within this document is sole property of WesJD. All rights reserved.*
* Do NOT distribute/reproduce any of this code without permission from WesJD.            *
* Not following this statement will result in a void of all agreements made.             *
* Enjoy.                                                                                 *
* ****************************************************************************************
*/
public abstract class RetronCommand implements CommandExecutor {

    private final class HandleCommand extends Command {

        private RetronCommand rcmd = null;

        public HandleCommand(String name) {
            super(name);
        }

        public void setExecutor(RetronCommand rcmd) {
            rcmd = rcmd;
        }

        @Override
        public boolean execute(CommandSender sender, String s, String[] args) {
            return rcmd.onCommand(sender, this, s, args);
        }

    }

    private CommandMap cmap = null;
    private String name;

    public RetronCommand(String name) {
        this.name = name;
        registerCommand();
    }

    private void registerCommand() {
        HandleCommand hcmd = new HandleCommand(name);
        if(cmap == null) {
            try {
                final Field f = Bukkit.getServer().getClass().getDeclaredField("commandMap");
                f.setAccessible(true);
                cmap = (CommandMap) f.get(Bukkit.getServer());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        cmap.register("", hcmd);
        hcmd.setExecutor(this);
    }

    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) {
        if (sender instanceof Player) {
            RetronPlayer p = new RetronPlayer((Player) sender);

            if (p.isGhosted()) {
                p.message(Main.getPrefix() + ChatColor.RED + "Error: You are currenty ghosted. Please relog to fix this.");
                return false;
            }

            onCmd(p, s, args);

        } else {
            sender.sendMessage(ChatColor.RED + "Only players can use commands.");
        }
        return false;
    }

    public abstract void onCmd(RetronPlayer p, String string, String[] args);

}

 

Well not quite, you don't use bukkit's command class, you implement your own. For instance the one I use for subcommands:

Code:java

/*
 * Copyright (C) 2015 Codelanx, All Rights Reserved
 *
 * This work is licensed under a Creative Commons
 * Attribution-NonCommercial-NoDerivs 3.0 Unported License.
 *
 * This program is protected software: You are free to distrubute your
 * own use of this software under the terms of the Creative Commons BY-NC-ND
 * license as published by Creative Commons in the year 2015 or as published
 * by a later date. You may not provide the source files or provide a means
 * of running the software outside of those licensed to use it.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the Creative Commons BY-NC-ND license
 * long with this program. If not, see <[url]https://creativecommons.org/licenses/>[/url].
 */
package com.codelanx.codelanxlib.command;
 
import com.codelanx.codelanxlib.config.lang.Lang;
import com.codelanx.codelanxlib.implementers.Commandable;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.Plugin;
 
/**
* Skeleton class representing the structure of a sub-command for
* {@link CommandHandler}
*
* @since 0.0.1
* @author 1Rogue
* @version 0.0.1
*
* @param <T> Represents a {@link Plugin} that implements the
*            {@link Commandable} interface
*/
public abstract class SubCommand<T extends Plugin & Commandable<T>> {
 
    /** The main {@link Plugin} instance */
    protected final T plugin;
 
    /**
     * {@link SubCommand} constructor
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @param plugin The {@link Plugin} associated with this command
     */
    public SubCommand(T plugin) {
        this.plugin = plugin;
    }
 
    /**
     * Executes a relevant command grabbed from the {@link CommandHandler}.
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @param sender The command executor
     * @param args The command arguments, starting after the command name
     *
     * @return The {@link CommandStatus} representing the result of the command
     */
    public abstract CommandStatus execute(CommandSender sender, String... args);
 
    /**
     * Returns the name of the command, used for storing a
     * {@link java.util.HashMap} of the commands as well as the subcommand
     * argument
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @return The command's name
     */
    public abstract String getName();
 
    /**
     * Returns the command usage
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @return Usage for this {@link SubCommand}
     */
    public String getUsage() {
        return "/" + this.plugin.getCommandHandler().getMainCommand() + " " + this.getName();
    }
 
    /**
     * Information about this specific command. Should be kept concise
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @return A small string about the command
     */
    public abstract Lang info();
 
    /**
     * Returns a permissions check for
     * {@code <plugin-name>.cmd.<subcommand-name>}, can be nested into further
     * permissions by passing tokens to append to the end of the permission
     * string
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @param sender The {@link CommandSender} executing this command
     * @param tokens Any additional tokens to append to the end of the string
     * @return {@code true} if they have permission, {@code false} otherwise
     */
    public boolean hasPermission(CommandSender sender, String... tokens) {
        List<String> lis = new LinkedList<>();
        lis.add(this.plugin.getName().toLowerCase());
        lis.add("cmd");
        lis.add(this.getName());
        lis.addAll(Arrays.asList(tokens));
        return sender.hasPermission(String.join(".", lis));
    }
 
}

If you want, since you'd be extending your class, rather than even have a command manager you can simply have the command objects register themselves:

Code:java

 
public abstract class SubCommand<T extends Plugin & Commandable<T>> {
 
    /** The main {@link Plugin} instance */
    protected final T plugin;
 
    /**
     * {@link SubCommand} constructor
     *
     * @since 0.0.1
     * @version 0.0.1
     *
     * @param plugin The {@link Plugin} associated with this command
     */
    public SubCommand(T plugin) {
        this.plugin = plugin;
        this.plugin.getCommand(this.getName()).setExecutor(this); //register the command upon construction
    }
 
}

 

@1Rogue I've just decided to use the plugin.yml, as I just wasted a day for where I am now. Maybe I'll work on it again when everything else is done. Thanks for the help though!