# Modules
Modules expand the capabilities of the main plugin. They are practically a plugin themselves. \
That is why module can have own folder inside the **modules** folder inside the main **plugin's** folder.\
Because of this you can easily create any config or any other file and put it inside separate folder to store information for example. By default it's turned off, but below you can find how to enable it.
Creating a module is almost similar to plugin creation. \
So, to create addon you need follow this:
1. **Main** class of your module should extend **Module** class of our plugin
```java
public class Main extends Module {
}
```
Main class of Module also has own **onEnable** method, so your **Main** should look like this:
public class Main extends Module {
@Override
public void onEnable() {
// Some code here
}
}
2. But **Module** also needs commands and listeners, right? So, you need to use this command system:
```java
public class ExampleCommand extends BukkitCommand {
public BukkitCommand exampleCommand;
public ExampleCommand(@NotNull String permission, @NotNull String name, @NotNull String description, @NotNull String usage, @NotNull List aliases) {
super(name, description, usage, aliases);
this.setName(name);
this.setDescription(description);
this.setUsage(usage);
this.setAliases(aliases);
this.setPermission(permission);
try {
Field f = Bukkit.getServer().getClass().getDeclaredField("commandMap");
f.setAccessible(true);
CommandMap commandMap = (CommandMap) f.get(Bukkit.getServer());
commandMap.register(name, this);
} catch (NoSuchFieldException | IllegalAccessException e) {
e.printStackTrace();
}
}
@Override
public boolean execute(@NotNull CommandSender commandSender, @NotNull String name, @NotNull String[] args) {
// Code of command here
return true;
}
public void registerCommands() {
if(exampleCommand != null) exampleCommand.unregister(getCommandMap());
registerTestCommand();
}
private void registerTestCommand() {
ArrayList aliases = new ArrayList<>();
aliases.add("example"); // Our main command name
aliases.add("ex"); // Aliases for main command
String usage = "/"; // How to use this command
String description = "An example command"; // Description of this command
String permission = "example.command"; // And permission of this command
BukkitCommand command = new ExampleCommand(permission, aliases.get(0), description, usage, aliases);
exampleCommand = command;
}
public CommandMap getCommandMap() {
CommandMap commandMap = null;
try {
Field f = Bukkit.getPluginManager().getClass().getDeclaredField("commandMap");
f.setAccessible(true);
commandMap = (CommandMap) f.get(Bukkit.getPluginManager());
} catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException | SecurityException e) {
e.printStackTrace();
}
return commandMap;
}
}
```
So, you need to register this command. Go to your **Main** class and make some changes:
```java
public class Main extends Module {
@Override
public void onEnable() {
new ExampleCommand( // New class object
"em.admin", // Permission of the command
"example", // Name of the command(it will be also our command)
"An example command", // Description of the command
"example", // Usage of this command (/)
Collections.singletonList("ex")) // Alliases of the command, as List
.registerCommands(); // Optional i think, method from ExampleCommand class
}
}
```
Also you can use **ColorManager** class from **DiscordWhitelist** to color your text, or build something into one String. For example:
```java
commandSender.sendMessage(ColorManager.translate("&aColored &ctext&f!")) // Will color this text
commandSender.sendMessage(ColorManager.buildString(args, 2)); // Will build args with spaces, etc. into one String, for example:
// /test player a b c d
// Using this method you can build "a b c d" into one String
```
3. Event listeners. They're default, but for now we found only one method of how to register them.
```java
public class Main extends Module {
@Override
public void onEnable() {
Bukkit.getPluginManager().registerEvents(
new Listener(),
com.windstudio.discordwl.Main.getInstance()); // Instance of DiscordWhitelist plugin
// So this listener will be registered
// in DiscordWhitelist plugin. For now
// this is only way :(
}
}
```
4. Nice, but our module needs description. Without this it won't startup.
Find **resources** directory where usually **plugin.yml** is located in, and create there **module.yml**.\
This file should contain next information:
```yaml
main: path # Path to Main class
name: name # Name of the module
author: author # Author of the module
version: version # Version of the module
description: description # Description of the module
folder: false # Should module have own folder inside "modules" directory named like module's name
```
For example:
```yaml
main: dev.windstudio.examplemodule.Main
name: ExampleModule
author: WIND STUDIO
version: 1.0
description: Example of the module creation
folder: false
```
Now you made your own module for **DiscordWhitelist** :hearts:
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://windstudio.gitbook.io/discordwhitelist/developers/modules.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.