(SOLVED) Plugin On/Off Command

I created a plugin and I'm curious on how to make a command that would disable the plugin. IE: (/thisplugin on) (/thisplugin off) Thanks!

 

post code

 

RawCode

PlayerListener

Code:java

package me.sphiinx;
 
import org.bukkit.ChatColor;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
 
public class PlayerListener implements Listener {
 
    public PlayerListener(DeathCoords plugin) {
        plugin.getServer().getPluginManager().registerEvents(this, plugin);
 
    }
 
    @EventHandler
    public void onPlayerDeath(PlayerDeathEvent event) {
 
        int x = (int) event.getEntity().getLocation().getX();
        int y = (int) event.getEntity().getLocation().getY();
        int z = (int) event.getEntity().getLocation().getZ();
        event.setDeathMessage(ChatColor.GREEN + "Death Coordinates: " + ChatColor.RED + "X: " + x + " Y: " + y + " Z: " + z);
        }
 
}
 

 

i see zero attempts to implement commands you want.

if you want someone to write plugin for you - visit plugin request section.

 

RawCode
I'm asking how to... I never said I knew anywhere to start. I have no Idea on how to do it, that's why I'm asking here because i'd like to learn....


Here is my DeathCoords.java if you need that too....

Code:java

package me.sphiinx;
 
import org.bukkit.plugin.java.JavaPlugin;
 
public class DeathCoords extends JavaPlugin {
 
    @Override
    public void onEnable() {
        getLogger().info("This was created by Sphiinx of VaultCraft Visit Vaultdarkrp.com for info or contact me @ [email][email protected][/email]");
        new PlayerListener(this);
    }
 
    @Override
    public void onDisable() {
 
    }
 
}
 

 

Create a boolean value that represents whether it is enabled or not. Then, check this value to determine whether to run your event code. You can for example create a public boolean in your main class:

Code:java

public boolean enabled = true;

And then, in your event:

Code:java

if (plugin.enabled) {
  // Plugin is enabled
}

 

coasterman10
How would this add a command ingame that would enable/disable the plugin? Thanks for the help!

 

Rex285
You would have to make that. Make a command and check the arguments. Set the Boolean value relative to the argument.

 

Rex285
http://wiki.bukkit.org/Plugin_Tutorial#Commands
Then just change the enabled boolean to true or false depends on what the argument is!

 

tryy3
Thanks! I like how the other people think I know how to do what they're saying. When they help someone they need to make it easier for someone to understand than what they understand in their own terms.

 

Rex285
Usually, I expect developers posting here to know at least some basic knowledge of Java and the Bukkit API. Other developers helping have their own expectations, also.
You should state specifically what you want to do, what you don't know (Anything even remotely relative to your problem), what you know, and what you have. That way, IMO, is the best way I can help you!

 

I have one more question. I know how to make permissions for a specific command but is it possible to make permissions for a plugin in general? For example the plugin I have made has no command but how would I make it so the plugin will only work on the player if the player has the permission?

 

Rex285
Check if the player has permission before executing the functions!

Code:java

if(player.hasPermission("insert.le.permission.node")){
    /* Player has permission so run code for them */
}

 

Gater12

Where would I put that line of code? xD Thanks for the help by the way. Lastly in my Plugin.yml when the player types the /help command and it displays the description it is cut off. How do i make it so it displays the whole description? (<-- Essentials Fixes this) Thanks!

Plugin.yml

Code:

name: DeathCoords
main: me.sphiinx.DeathCoords
version: 1.0
commands:
  help deathcoords:
      description: This plugin will display the players death coordinates.
      usage: Type /help deathcoords
      permission: <plugin name>.allow
      permission-message: You don't have <permission>

 

Rex285
If your questions/problems have been resolved please mark your thread as "solved" by editing it and setting the prefix to "Solved" this helps developers to know the issue(s) has/have been resolved without having to delve into the thread itself.

Also, I'd just like to mention that please don't let people discourage you from asking what they consider "stupid" questions (not saying you are). This is the "Plugin Development" section and not the "Experienced Plugin Development" section. There are no bounds to questions no matter how simple or complicated. Developers who respond with snarky comments are an eye sore to the community IMO because they're not being welcoming and encouraging (not to mention unhelpful sometimes) to the OP.

You've been (as far as I can see) straight to the point and communicating with good grammar. It makes it easy for a developer to respond to those kind of threads, thanks!

Although I do have a few tips about posting questions here (and for any other people viewing this thread):

1. Try to stay away from purely Java related questions. Googling around should be sufficient to finding more than a couple dozen articles/threads/posts etc relating to the topic you're looking for. There are websites out there that will more than likely already have asked the question you have or relate to it such as stackoverflow.
2. Be sure to put all questions in the OP (if you have them all at the time of posting).
3. Request details/sources if you need them as not all developers respond in as much detail as others do.
4. Update your main post via "Edit <#>: ..." so that people can track the progress of the thread easily.

Just a few suggestions for posting questions. Also, I'm glad your problem seems to be solved

 

If you disable the plugin by a command, when disabled you cannot enable him by a command... Maybe by passing through an another plugin? And i'm not sure.
And yes, please put 'solved'

 

I believe he was looking for a toggle for his functionality and not to actually disable the plugin. Although, you can disable/enable plugins freely via the PluginManager.

To disable a plugin, simply call PluginManager#disablePlugin(Plugin plugin) like so:

Code:java

Bukkit.getPluginManager().disablePlugin(plugin);

To enable a plugin, simply call PluginManager#enablePlugin(Plugin plugin) like so:

Code:java

Bukkit.getPluginManager().enablePlugin(plugin);

These methods differ from actually loading/unloading the plugin so they should be able to be called freely without issues (unless of course a plugin depending on it doesn't properly do checks to ensure it is enabled then that dependency wouldn't function properly- but I doubt the OP's plugin has any plugins depending on it).

 

Wingzzz ok.. Maybe i didn't understand what he really wanted.

 

Wingzzz
I'm sorry, I'm a little new to this. Where would I add this into my code at? You can look at my code above. I have some ideas where to put it, but i'm not totally sure.

 

Well posts above already described an alternative. You can create boolean such as "enabled" or "on" and then toggle it via a command (for how to create a command visit the tutorial here: http://wiki.bukkit.org/Plugin_Tutorial#Commands) and then reference the boolean to see if code should be executed (ie: check to see if(enabled == true) when you're say listening for an event).

Now that's one way, or you could do what I mentioned with actually just disabling the plugin. The problem with this approach is that you can't re-enable it via a command since your plugin will be disabled (unless you execute /reload but this can have negative side-effects on your server). Although if you want to disable your plugin you can create a command and in that command call PluginManager#disablePlugin(Plugin plugin).

I would recommend the boolean approach as it is more robust. You can easily accomplish this by doing something such as:

Code:java

public class MyPlugin extends JavaPlugin {
 
    private static MyPlugin instance;
    private boolean on;
 
    @Override
    public void onEnable() {
        instance = this;
        on = true;
        Bukkit.getPluginManager().registerEvents(new PlayerListener(), this);
    }
 
    public boolean isOn() {
        return on;
    }
 
    public void setOn(boolean on) {
        this.on = on;
    }
 
    public static MyPlugin getInstance() {
        return instance;
    }
 
}

I used "isOn()" because "isEnabled()" is used by Plugin and we don't want to check if the plugin is actually enabled, but rather whether or not it is toggled or "on". Feel free to change this to meet your needs or to better suit what you think it should be named. We also set "on" to 'true' onEnable() because by default it is 'false'.

Then say in my Listener that I've registered in another class I only want it to work if I've set my plugin to "on":

Code:java

public class PlayerListener implements Listener {
 
    @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
    public void onPlayerJoin(PlayerJoinEvent event) {
    if(MyPlugin.getInstance().isOn()) {
        event.getPlayer().sendMessage(ChatColor.GREEN + "MyPlugin is on (aside from being enabled)!");
        }
    }
 
}

Interested in learning more about Listeners? View Bukkit's documentation here.

So to go over what we did here, was we made a boolean in the Plugin that we can reference via an instance of the MyPlugin class by calling MyPlugin.getInstance().isOn() and MyPlugin.getInstance().setOn(boolean on) or by any instance of the class (assume "plugin" is an instance of MyPlugin) like: plugin.isOn() and plugin.setOn(boolean on).

Then we made a dummy test by creating and registering a Listener that listens for when players join. If they join and the plugin is set to "on" (separate functionality to that of Plugin#isEnabled()) then it will display a debug message stating it is on. This means if the plugin is set to "off" it will not do anything. You can mimic this functionality in commands, other event handlers, or any method you have. Simply do a quick check to make sure the plugin is "on" so that you know you're good to go to execute the code, otherwise if not and the plugin is "off" you can either do nothing or log some information, inform the person attempting to do the command or anything you want!

Note, instead I could've referenced the "on" variable by passing an instance of MyPlugin to PlayerListener through its constructor as "plugin" and then called 'plugin.isOn();' although in my example I used a static method called "getInstance();" that returned MyPlugin due to the fact that a Plugin is already a singleton.

Also, note that this example excludes imports- you will need to import all references that aren't in the same package, we aren't magicians... (Unless you are and you can, then please TEACH ME!)

If you're still fuzzy on what I've explained above please let me know! I can go over it in simpler terms or step by step with you if need be. Hopefully my explanation didn't stray from the point and(or) didn't become complicated in the way I referenced things.

 

Wingzzz
I am still a little Fuzzy on what you explained. Do you have a Skype where you could explain it in simpler terms? Also thank you for helping me.

 

No problem Unfortunately I won't have time to help in real time so we'll have to make due on the bukkit forums. Either through forum posts or inboxing.

At what part aren't you understanding? We can start there.

 

Wingzzz
Thats fine, the part I'm not understanding is do I have to make the command "/deathcoords on" and "/deathcoords off" and then link them to the Public Void onenables, etc.. Like that? How would I setup this. I am baffled atm. Sorry I am fairly new to this.

 

Ah I see, your problem lies in creating commands. Alright, well first things first Bukkit has documentation on how to create a command via the Bukkit API here: http://wiki.bukkit.org/Plugin_Tutorial#Commands.

So I highly recommend reading through that and testing, and then reading some more, and then testing some more. So that you can grasp a it well, but since I'm here I'll reference this tutorial and walk you through a very basic command.

So- for this example I'll be using a Plugin implementation (ie: your main class that extends JavaPlugin). This way I don't need to touch on CommandExecutor's and we can get straight to making the command.

Step #1:
We need to set up our plugin, so let's go ahead and get our Plugin class going:

Code:java

public class MyPlugin extends JavaPlugin {
 
    @Override
    public void onEnable() {
        // do something
    }
 
}

Step #2:
Now that we've got our plugin set up, we need to start creating a command. To do this we need to use the CommandExecutor#onCommand(CommandSender sender, Command command, String label, String[] args) method.

This method is only available to classes implementing CommandExecutor but lucky for us, Plugin extends CommandExecutor (interfaces extend other interfaces, whilst classes implement interfaces- just a quick tip- if you don't follow, don't worry it's not necessary to the example). This means that if you extend JavaPlugin then your class inherits the method CommandExecutor#onCommand(...);

In other words, this means we're good to go to create commands inside our Plugin class.

So, let's go ahead and override the onCommand(...) method like so:

Code:java

public class MyPlugin extends JavaPlugin {
 
    @Override
    public void onEnable() {
        // do something
    }
 
    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        // do something
    }
 
}

Step #3:
We've now got our basic plugin set up, we've got our command handling method set up- we're going good. Now, what we need to do is create a command. Although before we do this- let me describe the parameters of the onCommand(...) method.

• ( CommandSender) sender - This is the "sender" who sent the command. CommandSender is the interface for those who can send commands. Two interfaces that extend this are Player (meaning the command was sent from a player) and ConsoleCommandSender (meaning the command was sent from the console)
• (Command) command - This is the command that was sent. The object contains methods such as the command name, its permission, usage, and other methods. Do not confuse this with the material Command, they're different.
• (String) label - This is the command's label which is essentially the alias of the command that was used. I recommend staying away from using this- instead favour "command.getName()".
• (String[]) args - These are the arguments that were typed after the command. Example: "/mycommand arg0 arg1 arg2 arg3". Remember Java starts indexing at 0 so the first arg is args[0]. Learn more about arrays here.

Okay, with that out of the way let's go ahead and quickly create a command and then we'll go over it again:

Code:java

public class MyPlugin extends JavaPlugin {
 
    @Override
    public void onEnable() {
        // do something
    }
 
    @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if(command.getName().equalsIgnoreCase("deathcoords")) {
            // Check to see if the sender is a player
            if(sender instanceof Player) {
                // Cast the sender to a player
                Player player = (Player) sender;
                // Check to see if the player has the proper permissions or is OP, otherwise don't execute the command.
                if(!player.hasPermission("deathcoords.toggle") && !player.isOp()) {
                    // inform them they don't have permission if you want to
                    return true;
                }
            }
 
            // Check to make sure they input at least 1 argument after typing /deathcoords
            if(args.length > 0) {
                 // Check to make sure a sender input 1 argument. ie: /deathcoords one-argument
                if(args.length == 1) {
                    // Check to see regardless of case if the argument was "on"
                    if(args[0].equalsIgnoreCase("on")) {
                        // Check to see if the plugin isn't "on", if so then set on. Otherwise it is already on and do nothing.
                        if(!MyPlugin.getInstance().isOn()) {
                            MyPlugin.getInstance().setOn(true);
                            // inform the sender they turned on the plugin's functionality
                        }
                    // Check to see regardless of case if the argument was "off"
                    } else if(args[0].equalsIgnoreCase("off")) {
                        // Check to see if the plugin is "on", if so then set off. Otherwise it is already off and do nothing.
                        if(MyPlugin.getInstance().isOn()) {
                            MyPlugin.getInstance().setOn(false);
                            // inform the sender they turned off the plugin's functionality
                        }
 
                    // If the argument was not "on" or "off"
                    } else {
                        // inform the sender they input an invalid arguments, inform them the only valid args are "on" and "off"
                    }
 
                 // Else if the args.length isn't 1, check if they input more than 1 argument.
                } else if(args.length > 1) {
                    // inform the sender they input too many arguments
                }
 
             // Else if args.length isn't greater than 0, this means they only typed /deathcoords
            } else {
                // inform the sender they need to input args, either on or off
            }
        }
 
        return true;
    }
 
}

Step #4:
Alright, we've got a basic command going. Hopefully the comments in the code are sufficient enough to explain what's going on but just remember in arrays indexing starts at 0. If we have 1 element, meaning 1 "thing" in the array, in this case args is an array of strings, so if we have 1 String in the array, it's index will be 0. If we have 2 elements (meaning the array's length is 2), the indexes will be 0(first element) and 1(second element). So:

If args.length == 0:
/deathcoords

If args.length == 1:
/deathcoords args[0]

If args.length == 2:
/deathcoords args[0] args[1]

If args.length == 3:
/deathcoords args[0] args[1] args[2]

Arguments are separated by spaces in commands.

So now that we've created a command, we need to actually say "who" handles it. In order to do so, we must register it. To do this we go into our onEnable() insert the following:

Code:java

public class MyPlugin extends JavaPlugin {
 
    @Override
    public void onEnable() {
         this.getCommand("deathcoords").setExecutor(this);
    }
 
    @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if(command.getName().equalsIgnoreCase("deathcoords")) {
            // Check to see if the sender is a player
            if(sender instanceof Player) {
                // Cast the sender to a player
                Player player = (Player) sender;
                // Check to see if the player has the proper permissions or is OP, otherwise don't execute the command.
                if(!player.hasPermission("deathcoords.toggle") && !player.isOp()) {
                    // inform them they don't have permission if you want to
                    return true;
                }
            }
 
            // Check to make sure they input at least 1 argument after typing /deathcoords
            if(args.length > 0) {
                 // Check to make sure a sender input 1 argument. ie: /deathcoords one-argument
                if(args.length == 1) {
                    // Check to see regardless of case if the argument was "on"
                    if(args[0].equalsIgnoreCase("on")) {
                        // Check to see if the plugin isn't "on", if so then set on. Otherwise it is already on and do nothing.
                        if(!MyPlugin.getInstance().isOn()) {
                            MyPlugin.getInstance().setOn(true);
                            // inform the sender they turned on the plugin's functionality
                        }
                    // Check to see regardless of case if the argument was "off"
                    } else if(args[0].equalsIgnoreCase("off")) {
                        // Check to see if the plugin is "on", if so then set off. Otherwise it is already off and do nothing.
                        if(MyPlugin.getInstance().isOn()) {
                            MyPlugin.getInstance().setOn(false);
                            // inform the sender they turned off the plugin's functionality
                        }
 
                    // If the argument was not "on" or "off"
                    } else {
                        // inform the sender they input an invalid arguments, inform them the only valid args are "on" and "off"
                    }
 
                 // Else if the args.length isn't 1, check if they input more than 1 argument.
                } else if(args.length > 1) {
                    // inform the sender they input too many arguments
                }
 
             // Else if args.length isn't greater than 0, this means they only typed /deathcoords
            } else {
                // inform the sender they need to input args, either on or off
            }
        }
 
        return true;
    }
 
}

Alright, now what we did was say "this" meaning "this class that the word this is being typed in" .getCommand("deathcoords") so we want to get the command "deathcoords", .setExecutor(this) we want to set the command's executor (the class that handles its execution- ie: what it does) to be "this" meaning "this class that the word this is being typed in" ie: MyPlugin.

Step #5:
We're almost done! Woo! All that's left to do is set up our plugin.yml. Okay let's create it and input a bit of information shall we?

Code:

main: <your-package>.MyPlugin
name: MyPlugin
author: <your-name>
version: <plugin-version ie: 1.0.0>

Awesome! Now we've got a plugin that will run. But, wait... Uh-oh! This won't run our command. We're missing something crucial in our plugin.yml. How about we fix that?

In a plugin.yml you must define your commands. So let's revisit our plugin.yml and add in our command:

Code:

main: <your-package>.MyPlugin
name: MyPlugin
author: <your-name>
version: <plugin-version ie: 1.0.0>
commands:
    deathcoords:

This will work although you can also add some optional command attributes such as a description, usage, permission, permission-message (although these will only show when onCommand(...) returns false although in my example I always return true so that we can handle the command messaging ourself. This allows us to have more custom messages when people do things.)

You can find a full list of command attributes as well as other plugin.yml attributes here: http://wiki.bukkit.org/Plugin_YAML

Step #6:
Test your plugin! You should be able to toggle your plugin on and off freely.

Notes:

• I exclude imports in the examples above. Please ensure you use the proper imports.
• This is the basic way to do commands with the Bukkit API, there are other ways with community created libs/apis. You can use annotations/command objects. Separate commands into CommandExecutors in other classes. Feel free to explore these!
• Forgive any issues with the code above, it was all written in this forum post and not tested.

 

Wingzzz
Thank you so much! You are a person who can actually explain something to someone and help them! I appreciate it so much. I now understand things a lot more! I have one question though.

Here is the whole set of code. In the part where it checks to see if the plugin is on, and if it is it does nothing for some reason I am getting an error for the ".getInstance()" saying that "The method .getInstance() is undefined for the type DeathCoords. Thanks again for your help!

Code:java

package me.sphiinx;
 
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
 
public class DeathCoords extends JavaPlugin {
 
    @Override
    public void onEnable() {
        getLogger().info("This was created by Sphiinx of VaultCraft Visit Vaultdarkrp.com for info or contact me @ [email][email protected][/email]");
        new PlayerListener(this);
            this.getCommand("deathcoords").setExecutor(this);
            // Do Something
    }
 
    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
      if(command.getName().equalsIgnoreCase("deathcoords")) {
          // Check to see if the sender is a player
          if(sender instanceof Player) {
              // Cast the sender to a player
              Player player = (Player) sender;
              // Check to see if the player has the proper permissions or is OP, otherwise don't execute the command.
              if(!player.hasPermission("deathcoords.toggle") && !player.isOp()) {
                  // inform them they don't have permission if you want to
                  return true;
              }
          }
 
          // Check to make sure they input at least 1 argument after typing /deathcoords
          if(args.length > 0) {
                // Check to make sure a sender input 1 argument. ie: /deathcoords one-argument
              if(args.length == 1) {
                  // Check to see regardless of case if the argument was "on"
                  if(args[0].equalsIgnoreCase("on")) {
                      // Check to see if the plugin isn't "on", if so then set on. Otherwise it is already on and do nothing.
                      if(!DeathCoords.getInstance().isOn()) {
                          DeathCoords.getInstance().setOn(true);
                          // inform the sender they turned on the plugin's functionality
                      }
                  // Check to see regardless of case if the argument was "off"
                  } else if(args[0].equalsIgnoreCase("off")) {
                      // Check to see if the plugin is "on", if so then set off. Otherwise it is already off and do nothing.
                      if(DeathCoords.getInstance().isOn()) {
                          DeathCoords.getInstance().setOn(false);
                          // inform the sender they turned off the plugin's functionality
                      }
 
                  // If the argument was not "on" or "off"
                  } else {
                      // inform the sender they input an invalid arguments, inform them the only valid args are "on" and "off"
                  }
 
                // Else if the args.length isn't 1, check if they input more than 1 argument.
              } else if(args.length > 1) {
                  // inform the sender they input too many arguments
              }
 
            // Else if args.length isn't greater than 0, this means they only typed /deathcoords
          } else {
              // inform the sender they need to input args, either on or off
          }
      }
 
      return true;
  }
 
}

 

If you look at your code, it does not have the method in it. So you need to insert the field and methods used in the toggling.

What you're missing are the following:

Code:java

private static DeathCoords instance;
private boolean on;
 
public boolean isOn() {
    return on;
}
 
public void setOn(boolean on) {
    this.on = on;
}
 
public static DeathCoords getInstance() {
    return instance;
}

The above is in addition to the other code in you DeathCoords.java. In order to make the above code that you should now have in the DeathCoords.java work, you must ensure onEnable(), you insert the following:

Code:java

instance = this;
this.on = true;

The above will go inside of your exising onEnable() method so that we can access the singleton (which is your plugin class DeathCoords) statically via the method DeathCoords#getInstance() which we can then do things such as:

Code:java

// Check the DeathCoords "on" state.
DeathCoords.getInstance().isOn();
// Change the DeathCoords "on" state.
DeathCoords.getInstance().setOn(false);

 

Wingzzz
Thank you so much for your help. Lastly, is my Plugin.yml correct? Thank you!

Code:

name: DeathCoords
main: me.sphiinx.DeathCoords
version: 1.0
author: Sphiinx
website: http://www.vaultdarkrp.com
commands:
  deathcoords:
      description: This plugin will display the players death coordinates.
      permission: deathcoords.toggle
      default: op

 

If it works it must be right?
I'm not sure if the website works as it has a colon, I think it has to be www.vaultdarkrp.com

 

Konkz
Thanks! I am testing the plugin atm, and adding messages.

Wingzzz
Konkz
Why am I getting this warning all of the sudden and my plugin stopped working? It was just working...

Code:

Description    Resource    Path    Location    Type
Build path specifies execution environment JavaSE-1.7. There are no JREs installed in the workspace that are strictly compatible with this environment.    Tutorial 2        Build path    JRE System Library Problem

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

 

Should still be able to work, although if you do have issues you can enclose String scalars in single or double quotations.

Rex285
The issue is that the workspace doesn't define any JREs that are compatible with the specified execution environment . IE: I specify Java SE 1.6 and yet define either none or the JRE for the workspace to be greater or lesser than the specified execution environment. Go to your project's build path, and ensure its execution environment is defined. If you use the default workspace jre then ensure that it is valid.