Sponge support

README.md

@@ -1,27 +1,34 @@
-# LuckPerms
-A (fairly bad) permissions implementation for Bukkit/BungeeCord.
+# LuckPerms [![Build Status](https://ci.lucko.me/job/LuckPerms/badge/icon)](https://ci.lucko.me/job/LuckPerms/)
+A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
+
+## Links
+* **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
+* **Javadocs** - <https://jd.lucko.me/LuckPerms>
 
 ## Features
 * **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
 * **Temporary permissions** - users/groups can be given permissions that expire after a given time
 * **Temporary groups** - users/groups can be added to/inherit other groups temporarily
 * **Multi-server support** - data is synced across all servers/platforms
+* **Full offline-mode/mixed-mode support** - player permissions are synced properly over offline-mode or mixed online/offline-mode networks.
 * **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
-* **Server-specific groups** - define groups that only apply on certain servers
-* **Tracks / paths** - users can be promoted/demoted along multiple group tracks
+* **Per-world permissions/groups** - define user/group permissions that only apply on certain worlds (on BungeeCord, a connected Bukkit/Spigot instance is treated as a world)
+* **Tracks / paths / ladders** - users can be promoted/demoted along multiple group tracks
 * **Vault Support** - hooks into Vault to integrate with other plugins
 * **Developer API** - easily integrate LuckPerms into your own projects
 * **Easy and simple setup and configuration using commands** - no editing yml files, yuck
+* **Negated permissions and groups** - define special rules for certain users/groups
+* **Full support for UUIDs, even in Offline Mode** - users can change their usernames without losing permissions. In offline mode, a single user has the same internal UUID across a network.
+* **Permission data stored within MySQL in a json format** - easily integrate the LuckPerms backend into your other projects
+* **Well documented** - API methods have comprehensive Java docs, it's clear what each method does.
 * **Efficient/lightweight** - maybe? Who knows, it might be.
-* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
+* **Open Sourced, Free...** - you shouldn't have to pay $10+ for a "powerful" permissions plugin.
+* **BungeeCord compatible** - permissions, users and groups are synced across all LuckPerms instances
+* **Sponge compatible** - permissions, users and groups are synced across all LuckPerms instances (bukkit --> sponge, for example)
 * **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
 
-##### Possible Caveats
-* Currently only supports MySQL, SQLite & Flatfile (JSON) (support for more methods might come in the future)
-* Not at all tested and could produce unexpected/buggy results and errors
-
 ## Setup
-All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
+All configuration options are in the **config.yml/luckperms.conf** file, which is generated automagically when the plugin first starts.
 
 You can define the settings for per-server permissions, the storage method and credentials within this file.
 
@@ -33,13 +40,17 @@ Permissions are calculated based on a priority system as follows.
 
 Example: if a user has a false permission set for "test.node", and a temporary true permission set for "test.node", the temporary permission will override the permanent one, and the user will be granted the true node.
 
+* World specific permissions will override generic permissions.
+
+Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission in the "world_nether" world, the world specific permission will override the globally defined one, and the user will be granted the negated node (provided they're in that world, of course.).
+
 * Server specific permissions will override generic/global permissions.
 
 Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission on the "factions" server, the server specific permission will override the globally defined one, and the user will be granted the negated node.
 
 * Inherited permissions will be overridden by an objects own permissions.
 
-Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node.
+Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node (provided they're on that server).
 
 ### Temporary Permissions
 Temporary permissions are checked each time a user/group is loaded, and when the sync task runs. This means if you set a temporary permission to expire after 30 seconds, it won't actually be removed until the sync task runs.
@@ -47,11 +58,20 @@ Temporary permissions are checked each time a user/group is loaded, and when the
 The only way around this is to decrease the sync interval.
 
 ## API
-LuckPerms has an extensive API, allowing for easy integration with other projects. To use the Api, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in two ways, (one way on BungeeCord).
+LuckPerms has an extensive API, allowing for easy integration with other projects. To use the Api, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in a number of ways.
 
 ```java
+// On all platforms
 final LuckPermsApi api = LuckPerms.getApi();
+
+// On Bukkit/Spigot
 final LuckPermsApi api = Bukkit.getServicesManager().getRegistration(LuckPermsApi.class).getProvider();
+
+// On Sponge
+Optional<LuckPermsApi> provider = Sponge.getServiceManager().provide(LuckPermsApi.class);
+if (provider.isPresent()) {
+    final LuckPermsApi api = provider.get();
+}
 ```
 
 If you want to use LuckPerms in your onEnable method, you need to add the following to your plugins `plugin.yml`.
@@ -60,6 +80,24 @@ depend: [LuckPerms]
 ```
 All of the available methods can be seen in the various interfaces in the `luckperms-api` module.
 
+You can add LuckPerms as a Maven dependency by adding the following to your projects `pom.xml`.
+````xml
+<repositories>
+    <repository>
+        <id>luck-repo</id>
+        <url>https://repo.lucko.me/</url>
+    </repository>
+</repositories>
+
+<dependencies>
+    <dependency>
+        <groupId>me.lucko.luckperms</groupId>
+        <artifactId>luckperms-api</artifactId>
+        <version>1.5</version>
+    </dependency>
+</dependencies>
+````
+
 ## Commands
 
 Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
@@ -74,7 +112,7 @@ Command usage is printed to the console/chat whenever invalid arguments are prov
 | /lp              | /lpb             |
 | /perm            | /bperm           |
 
-Arguments: <required> [optional]
+Arguments: \<required\> [optional]
 
 Users with OP have access to all commands.
 
@@ -89,55 +127,56 @@ Additionally, you can use wildcards to grant users access to a selection of comm
 *  /perms sync - luckperms.sync
 *  /perms info - luckperms.info
 *  /perms debug - luckperms.debug
-*  /perms creategroup <group> - luckperms.creategroup
-*  /perms deletegroup <group> - luckperms.deletegroup
+*  /perms creategroup \<group\> - luckperms.creategroup
+*  /perms deletegroup \<group\> - luckperms.deletegroup
 *  /perms listgroups - luckperms.listgroups
-*  /perms createtrack <track> - luckperms.createtrack
-*  /perms deletetrack <track> - luckperms.deletetrack
+*  /perms createtrack \<track\> - luckperms.createtrack
+*  /perms deletetrack \<track\> - luckperms.deletetrack
 *  /perms listtracks - luckperms.listtracks
 
 ### User
-*  /perms user <user> info - luckperms.user.info
-*  /perms user <user> getuuid - luckperms.user.getuuid
-*  /perms user <user> listnodes - luckperms.user.listnodes
-*  /perms user <user> haspermission <node> [server] - luckperms.user.haspermission
-*  /perms user <user> inheritspermission <node> [server] - luckperms.user.inheritspermission
-*  /perms user <user> set <node> <true/false> [server] - luckperms.user.setpermission
-*  /perms user <user> unset <node> [server] -  luckperms.user.unsetpermission
-*  /perms user <user> addgroup <group> [server] - luckperms.user.addgroup
-*  /perms user <user> removegroup <group> [server] - luckperms.user.removegroup
-*  /perms user <user> settemp <node> <true/false> <duration> [server] - luckperms.user.settemppermission
-*  /perms user <user> addtempgroup <group> <duration> [server] - luckperms.user.addtempgroup
-*  /perms user <user> removetempgroup <group> [server] - luckperms.user.removetempgroup
-*  /perms user <user> setprimarygroup <group> - luckperms.user.setprimarygroup
-*  /perms user <user> showtracks - luckperms.user.showtracks
-*  /perms user <user> promote <track> - luckperms.user.promote
-*  /perms user <user> demote <track> - luckperms.user.demote
-*  /perms user <user> showpos <track> - luckperms.user.showpos
-*  /perms user <user> clear - luckperms.user.clear
+*  /perms user \<user\> info - luckperms.user.info
+*  /perms user \<user\> getuuid - luckperms.user.getuuid
+*  /perms user \<user\> listnodes - luckperms.user.listnodes
+*  /perms user \<user\> haspermission \<node\> [server] [world] - luckperms.user.haspermission
+*  /perms user \<user\> inheritspermission \<node\> [server] [world] - luckperms.user.inheritspermission
+*  /perms user \<user\> set \<node\> \<true/false\> [server] [world] - luckperms.user.setpermission
+*  /perms user \<user\> unset \<node\> [server] [world] -  luckperms.user.unsetpermission
+*  /perms user \<user\> addgroup \<group\> [server] [world] - luckperms.user.addgroup
+*  /perms user \<user\> removegroup \<group\> [server] [world] - luckperms.user.removegroup
+*  /perms user \<user\> settemp \<node\> \<true/false\> \<duration\> [server] [world] - luckperms.user.settemppermission
+*  /perms user \<user\> unsettemp \<node\> [server] [world] - luckperms.user.unsettemppermission
+*  /perms user \<user\> addtempgroup \<group\> \<duration\> [server] [world] - luckperms.user.addtempgroup
+*  /perms user \<user\> removetempgroup \<group\> [server] [world] - luckperms.user.removetempgroup
+*  /perms user \<user\> setprimarygroup \<group\> - luckperms.user.setprimarygroup
+*  /perms user \<user\> showtracks - luckperms.user.showtracks
+*  /perms user \<user\> promote \<track\> - luckperms.user.promote
+*  /perms user \<user\> demote \<track\> - luckperms.user.demote
+*  /perms user \<user\> showpos \<track\> - luckperms.user.showpos
+*  /perms user \<user\> clear - luckperms.user.clear
 
 ### Group
-*  /perms group <group> info - 	luckperms.group.info
-*  /perms group <group> listnodes - luckperms.group.listnodes
-*  /perms group <group> haspermission <node> [server] - luckperms.group.haspermission
-*  /perms group <group> inheritspermission <node> [server] - luckperms.group.inheritspermission
-*  /perms group <group> set <node> <true/false> [server] - luckperms.group.setpermission
-*  /perms group <group> unset <node> [server] - luckperms.group.unsetpermission
-*  /perms group <group> setinherit <group> [server] - luckperms.group.setinherit
-*  /perms group <group> unsetinherit <group> [server] - luckperms.group.unsetinherit
-*  /perms group <group> settemp <node> <true/false> <duration> [server] - settemppermission
-*  /perms group <group> unsettemp <node> [server] - luckperms.group.unsettemppermission
-*  /perms group <group> settempinherit <group> <duration> [server] - luckperms.group.settempinherit
-*  /perms group <group> unsettempinherit <group> [server] - luckperms.group.unsettempinherit
-*  /perms group <group> showtracks - luckperms.group.showtracks
-*  /perms group <group> clear - luckperms.group.clear
+*  /perms group \<group\> info - 	luckperms.group.info
+*  /perms group \<group\> listnodes - luckperms.group.listnodes
+*  /perms group \<group\> haspermission \<node\> [server] [world] - luckperms.group.haspermission
+*  /perms group \<group\> inheritspermission \<node\> [server] [world] - luckperms.group.inheritspermission
+*  /perms group \<group\> set \<node\> \<true/false\> [server] [world] - luckperms.group.setpermission
+*  /perms group \<group\> unset \<node\> [server] [world] - luckperms.group.unsetpermission
+*  /perms group \<group\> setinherit \<group\> [server] [world] - luckperms.group.setinherit
+*  /perms group \<group\> unsetinherit \<group\> [server] [world] - luckperms.group.unsetinherit
+*  /perms group \<group\> settemp \<node\> \<true/false\> \<duration\> [server] [world] - settemppermission
+*  /perms group \<group\> unsettemp \<node\> [server] [world] - luckperms.group.unsettemppermission
+*  /perms group \<group\> settempinherit \<group\> \<duration\> [server] [world] - luckperms.group.settempinherit
+*  /perms group \<group\> unsettempinherit \<group\> [server] [world] - luckperms.group.unsettempinherit
+*  /perms group \<group\> showtracks - luckperms.group.showtracks
+*  /perms group \<group\> clear - luckperms.group.clear
 
 ### Track
-*  /perms track <track> info - luckperms.track.info
-*  /perms track <track> append <group> - luckperms.track.append
-*  /perms track <track> insert <group> <position> - luckperms.track.insert
-*  /perms track <track> remove <group> - luckperms.track.remove
-*  /perms track <track> clear - luckperms.track.clear
+*  /perms track \<track\> info - luckperms.track.info
+*  /perms track \<track\> append \<group\> - luckperms.track.append
+*  /perms track \<track\> insert \<group\> \<position\> - luckperms.track.insert
+*  /perms track \<track\> remove \<group\> - luckperms.track.remove
+*  /perms track \<track\> clear - luckperms.track.clear
 
 ## License
-See LICENSE.md.
+See LICENSE.md.

api/pom.xml

@@ -4,11 +4,12 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
-        <groupId>me.lucko</groupId>
-        <version>1.3</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
+    <version>1.5</version>
     <artifactId>luckperms-api</artifactId>
     <build>
         <plugins>

api/src/main/java/me/lucko/luckperms/api/Datastore.java

@@ -19,21 +19,21 @@ public interface Datastore {
     Sync sync();
 
     interface Async {
-        void loadOrCreateUser(UUID uuid, String username, Callback callback);
-        void loadUser(UUID uuid, Callback callback);
-        void saveUser(User user, Callback callback);
-        void createAndLoadGroup(String name, Callback callback);
-        void loadGroup(String name, Callback callback);
-        void loadAllGroups(Callback callback);
-        void saveGroup(Group group, Callback callback);
-        void deleteGroup(Group group, Callback callback);
-        void createAndLoadTrack(String name, Callback callback);
-        void loadTrack(String name, Callback callback);
-        void loadAllTracks(Callback callback);
-        void saveTrack(Track track, Callback callback);
-        void deleteTrack(Track track, Callback callback);
-        void saveUUIDData(String username, UUID uuid, Callback callback);
-        void getUUID(String username, Callback.GetUUID callback);
+        void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback);
+        void loadUser(UUID uuid, Callback<Boolean> callback);
+        void saveUser(User user, Callback<Boolean> callback);
+        void createAndLoadGroup(String name, Callback<Boolean> callback);
+        void loadGroup(String name, Callback<Boolean> callback);
+        void loadAllGroups(Callback<Boolean> callback);
+        void saveGroup(Group group, Callback<Boolean> callback);
+        void deleteGroup(Group group, Callback<Boolean> callback);
+        void createAndLoadTrack(String name, Callback<Boolean> callback);
+        void loadTrack(String name, Callback<Boolean> callback);
+        void loadAllTracks(Callback<Boolean> callback);
+        void saveTrack(Track track, Callback<Boolean> callback);
+        void deleteTrack(Track track, Callback<Boolean> callback);
+        void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback);
+        void getUUID(String username, Callback<UUID> callback);
     }
 
     interface Sync {

api/src/main/java/me/lucko/luckperms/api/Group.java

@@ -1,5 +1,10 @@
 package me.lucko.luckperms.api;
 
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
 /**
  * Wrapper interface for internal Group instances
  * The implementations of this interface limit access to the Group and add parameter checks to further prevent
@@ -8,11 +13,160 @@ package me.lucko.luckperms.api;
 @SuppressWarnings("unused")
 public interface Group extends PermissionObject {
 
+    /**
+     * @return the name of the group
+     */
     String getName();
 
+    /**
+     * check to see if a group inherits a group
+     * @param group The group to check membership of
+     * @return true if the user is a member of the group
+     */
+    boolean inheritsGroup(Group group);
+
+    /**
+     * check to see if the group inherits a group on a specific server
+     * @param group The group to check membership of
+     * @param server The server to check on
+     * @return true if the group inherits the group
+     */
+    boolean inheritsGroup(Group group, String server);
+
+    /**
+     * check to see if the group inherits a group on a specific server
+     * @param group The group to check membership of
+     * @param server The server to check on
+     * @param world The world to check on
+     * @return true if the group inherits the group
+     */
+    boolean inheritsGroup(Group group, String server, String world);
+
+    /**
+     * Make this group inherit another group
+     * @param group the group to be inherited
+     * @throws ObjectAlreadyHasException if the group already inherits the group
+     */
+    void setInheritGroup(Group group) throws ObjectAlreadyHasException;
+
+    /**
+     * Make this group inherit another group on a specific server
+     * @param group the group to be inherited
+     * @param server The server to add the group on
+     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     */
+    void setInheritGroup(Group group, String server) throws ObjectAlreadyHasException;
+
+    /**
+     * Make this group inherit another group on a specific server
+     * @param group the group to be inherited
+     * @param server The server to add the group on
+     * @param world The world to add the group on
+     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     */
+    void setInheritGroup(Group group, String server, String world) throws ObjectAlreadyHasException;
+
+    /**
+     * Make this group inherit another group on a specific server
+     * @param group the group to be inherited
+     * @param expireAt when the group should expire
+     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     */
+    void setInheritGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Make this group inherit another group on a specific server
+     * @param group the group to be inherited
+     * @param server The server to add the group on
+     * @param expireAt when the group should expire
+     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     */
+    void setInheritGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Make this group inherit another group on a specific server
+     * @param group the group to be inherited
+     * @param server The server to add the group on
+     * @param world The world to add the group on
+     * @param expireAt when the group should expire
+     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     */
+    void setInheritGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Remove a previously set inheritance
+     * @param group the group to uninherit
+     * @throws ObjectLacksException if the group does not already inherit the group
+     */
+    void unsetInheritGroup(Group group) throws ObjectLacksException;
+
+    /**
+     * Remove a previously set inheritance
+     * @param group the group to uninherit
+     * @param temporary if the group being removed is temporary
+     * @throws ObjectLacksException if the group does not already inherit the group
+     */
+    void unsetInheritGroup(Group group, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Remove a previously set inheritance
+     * @param group the group to uninherit
+     * @param server The server to remove the group on
+     * @throws ObjectLacksException if the group does not already inherit the group
+     */
+    void unsetInheritGroup(Group group, String server) throws ObjectLacksException;
+
+    /**
+     * Remove a previously set inheritance
+     * @param group the group to uninherit
+     * @param server The server to remove the group on
+     * @param world The world to remove the group on
+     * @throws ObjectLacksException if the group does not already inherit the group
+     */
+    void unsetInheritGroup(Group group, String server, String world) throws ObjectLacksException;
+
+    /**
+     * Remove a previously set inheritance
+     * @param group the group to uninherit
+     * @param server The server to remove the group on
+     * @param temporary if the group being removed is temporary
+     * @throws ObjectLacksException if the group does not already inherit the group
+     */
+    void unsetInheritGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Remove a previously set inheritance
+     * @param group the group to uninherit
+     * @param server The server to remove the group on
+     * @param world The world to remove the group on
+     * @param temporary if the group being removed is temporary
+     * @throws ObjectLacksException if the group does not already inherit the group
+     */
+    void unsetInheritGroup(Group group, String server, String world, boolean temporary) throws ObjectLacksException;
+
     /**
      * Clear all of the groups permission nodes
      */
     void clearNodes();
 
+    /**
+     * Get a {@link List} of all of the groups the group inherits, on all servers
+     * @return a {@link List} of group names
+     */
+    List<String> getGroupNames();
+
+    /**
+     * Get a {@link List} of the groups the group inherits on a specific server
+     * @param server the server to check
+     * @param world the world to check
+     * @return a {@link List} of group names
+     */
+    List<String> getLocalGroups(String server, String world);
+
+    /**
+     * Get a {@link List} of the groups the group inherits on a specific server
+     * @param server the server to check
+     * @return a {@link List} of group names
+     */
+    List<String> getLocalGroups(String server);
 }

api/src/main/java/me/lucko/luckperms/api/Logger.java

@@ -0,0 +1,9 @@
+package me.lucko.luckperms.api;
+
+public interface Logger {
+
+    void info(String s);
+    void warn(String s);
+    void severe(String s);
+
+}

api/src/main/java/me/lucko/luckperms/api/LuckPermsApi.java

@@ -9,6 +9,7 @@ public interface LuckPermsApi {
     String getVersion();
 
     Datastore getDatastore();
+    Logger getLogger();
 
     User getUser(UUID uuid);
     User getUser(String name);

api/src/main/java/me/lucko/luckperms/api/PermissionObject.java

@@ -35,6 +35,16 @@ public interface PermissionObject {
      */
     boolean hasPermission(String node, boolean b, String server);
 
+    /**
+     * Checks to see the the object has a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @param world The world
+     * @return true if the user has the permission
+     */
+    boolean hasPermission(String node, boolean b, String server, String world);
+
     /**
      * Checks to see the the object has a permission on a certain server
      * @param node The permission node
@@ -44,6 +54,27 @@ public interface PermissionObject {
      */
     boolean hasPermission(String node, boolean b, boolean temporary);
 
+    /**
+     * Checks to see the the object has a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server to check on
+     * @param temporary if the permission is temporary
+     * @return true if the user has the permission
+     */
+    boolean hasPermission(String node, boolean b, String server, boolean temporary);
+
+    /**
+     * Checks to see the the object has a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server to check on
+     * @param world The world to check on
+     * @param temporary if the permission is temporary
+     * @return true if the user has the permission
+     */
+    boolean hasPermission(String node, boolean b, String server, String world, boolean temporary);
+
     /**
      * Checks to see if the object inherits a certain permission
      * @param node The permission node
@@ -61,6 +92,16 @@ public interface PermissionObject {
      */
     boolean inheritsPermission(String node, boolean b, String server);
 
+    /**
+     * Checks to see the the object inherits a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @param world The world
+     * @return true if the user inherits the permission
+     */
+    boolean inheritsPermission(String node, boolean b, String server, String world);
+
     /**
      * Checks to see if the object inherits a certain permission
      * @param node The permission node
@@ -70,6 +111,27 @@ public interface PermissionObject {
      */
     boolean inheritsPermission(String node, boolean b, boolean temporary);
 
+    /**
+     * Checks to see if the object inherits a certain permission
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @param temporary if the permission is temporary
+     * @return true if the user inherits the permission
+     */
+    boolean inheritsPermission(String node, boolean b, String server, boolean temporary);
+
+    /**
+     * Checks to see if the object inherits a certain permission
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @param world The world
+     * @param temporary if the permission is temporary
+     * @return true if the user inherits the permission
+     */
+    boolean inheritsPermission(String node, boolean b, String server, String world, boolean temporary);
+
     /**
      * Sets a permission for the object
      * @param node The node to be set
@@ -87,6 +149,16 @@ public interface PermissionObject {
      */
     void setPermission(String node, boolean value, String server) throws ObjectAlreadyHasException;
 
+    /**
+     * Sets a permission for the object
+     * @param node The node to set
+     * @param value What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @param world The world to set the permission on
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    void setPermission(String node, boolean value, String server, String world) throws ObjectAlreadyHasException;
+
     /**
      * Sets a permission for the object
      * @param node The node to set
@@ -106,6 +178,17 @@ public interface PermissionObject {
      */
     void setPermission(String node, boolean value, String server, long expireAt) throws ObjectAlreadyHasException;
 
+    /**
+     * Sets a permission for the object
+     * @param node The node to set
+     * @param value What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @param world The world to set the permission on
+     * @param expireAt The time in unixtime when the permission will expire
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    void setPermission(String node, boolean value, String server, String world, long expireAt) throws ObjectAlreadyHasException;
+
     /**
      * Unsets a permission for the object
      * @param node The node to be unset
@@ -129,6 +212,15 @@ public interface PermissionObject {
      */
     void unsetPermission(String node, String server) throws ObjectLacksException;
 
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @param server The server to unset the node on
+     * @param world The world to unset the node on
+     * @throws ObjectLacksException if the node wasn't already set
+     */
+    void unsetPermission(String node, String server, String world) throws ObjectLacksException;
+
     /**
      * Unsets a permission for the object
      * @param node The node to be unset
@@ -138,6 +230,25 @@ public interface PermissionObject {
      */
     void unsetPermission(String node, String server, boolean temporary) throws ObjectLacksException;
 
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @param server The server to unset the node on
+     * @param world The world to unset the node on
+     * @param temporary if the permission being unset is temporary
+     * @throws ObjectLacksException if the node wasn't already set
+     */
+    void unsetPermission(String node, String server, String world, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Gets the permissions and inherited permissions that apply to a specific server
+     * @param server The server to get nodes for
+     * @param world The world to get nodes for
+     * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
+     * @return a {@link Map} of the permissions
+     */
+    Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups);
+
     /**
      * Gets the permissions and inherited permissions that apply to a specific server
      * @param server The server to get nodes for (can be null)

api/src/main/java/me/lucko/luckperms/api/User.java

@@ -14,10 +14,32 @@ import java.util.UUID;
 @SuppressWarnings("unused")
 public interface User extends PermissionObject {
 
+    /**
+     * @return the users Mojang assigned unique id
+     */
     UUID getUuid();
+
+    /**
+     * @return the Users Username
+     */
     String getName();
+
+    /**
+     * Gets the users primary group
+     * @return the users primary group
+     */
     String getPrimaryGroup();
+
+    /**
+     * Sets a users primary group
+     * @param s the new primary group
+     * @throws ObjectAlreadyHasException if the user already has this set as their primary group
+     */
     void setPrimaryGroup(String s) throws ObjectAlreadyHasException;
+
+    /**
+     * Refresh and re-assign the users permissions
+     */
     void refreshPermissions();
 
     /**
@@ -35,6 +57,15 @@ public interface User extends PermissionObject {
      */
     boolean isInGroup(Group group, String server);
 
+    /**
+     * Check to see if a user is a member of a group on a specific server
+     * @param group The group to check membership of
+     * @param server The server to check on
+     * @param world The world to check on
+     * @return true if the user is a member of the group
+     */
+    boolean isInGroup(Group group, String server, String world);
+
     /**
      * Add a user to a group
      * @param group The group to add the user to
@@ -50,6 +81,15 @@ public interface User extends PermissionObject {
      */
     void addGroup(Group group, String server) throws ObjectAlreadyHasException;
 
+    /**
+     * Add a user to a group on a specific server
+     * @param group The group to add the user to
+     * @param server The server to add the group on
+     * @param world The world to add the group on
+     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
+     */
+    void addGroup(Group group, String server, String world) throws ObjectAlreadyHasException;
+
     /**
      * Add a user to a group on a specific server
      * @param group The group to add the user to
@@ -67,6 +107,16 @@ public interface User extends PermissionObject {
      */
     void addGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
 
+    /**
+     * Add a user to a group on a specific server
+     * @param group The group to add the user to
+     * @param server The server to add the group on
+     * @param world The world to add the group on
+     * @param expireAt when the group should expire
+     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
+     */
+    void addGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException;
+
     /**
      * Remove the user from a group
      * @param group the group to remove the user from
@@ -90,6 +140,15 @@ public interface User extends PermissionObject {
      */
     void removeGroup(Group group, String server) throws ObjectLacksException;
 
+    /**
+     * Remove the user from a group
+     * @param group The group to remove the user from
+     * @param server The server to remove the group on
+     * @param world The world to remove the group on
+     * @throws ObjectLacksException if the user isn't a member of the group
+     */
+    void removeGroup(Group group, String server, String world) throws ObjectLacksException;
+
     /**
      * Remove the user from a group
      * @param group The group to remove the user from
@@ -99,6 +158,16 @@ public interface User extends PermissionObject {
      */
     void removeGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
 
+    /**
+     * Remove the user from a group
+     * @param group The group to remove the user from
+     * @param server The server to remove the group on
+     * @param world The world to remove the group on
+     * @param temporary if the group being removed is temporary
+     * @throws ObjectLacksException if the user isn't a member of the group
+     */
+    void removeGroup(Group group, String server, String world, boolean temporary) throws ObjectLacksException;
+
     /**
      * Clear all of the users permission nodes
      */
@@ -110,6 +179,14 @@ public interface User extends PermissionObject {
      */
     List<String> getGroupNames();
 
+    /**
+     * Get a {@link List} of the groups the user is a member of on a specific server
+     * @param server the server to check
+     * @param world the world to check
+     * @return a {@link List} of group names
+     */
+    List<String> getLocalGroups(String server, String world);
+
     /**
      * Get a {@link List} of the groups the user is a member of on a specific server
      * @param server the server to check

api/src/main/java/me/lucko/luckperms/api/data/Callback.java

@@ -1,11 +1,7 @@
 package me.lucko.luckperms.api.data;
 
-import java.util.UUID;
+public interface Callback<T> {
 
-public interface Callback {
-    void onComplete(boolean success);
+    void onComplete(T t);
 
-    interface GetUUID {
-        void onComplete(UUID uuid);
-    }
 }

bukkit/pom.xml

@@ -4,13 +4,13 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
-        <groupId>me.lucko</groupId>
-        <version>1.3</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bukkit</artifactId>
-    <version>$(project.parent.version)</version>
+    <version>1.5</version>
     <packaging>jar</packaging>
     <name>LuckPerms</name>
 
@@ -65,22 +65,22 @@
         <dependency>
             <groupId>net.milkbowl.vault</groupId>
             <artifactId>VaultAPI</artifactId>
-            <version>1.5</version>
+            <version>1.6</version>
             <scope>provided</scope>
         </dependency>
         <!-- LuckPerms Common -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
         <!-- LuckPerms API -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
-</project>
+</project>

bukkit/src/main/java/me/lucko/luckperms/BukkitCommand.java

@@ -11,8 +11,8 @@ import java.lang.ref.WeakReference;
 import java.util.Arrays;
 import java.util.List;
 
-class CommandManagerBukkit extends CommandManager implements CommandExecutor, TabExecutor {
-    CommandManagerBukkit(LuckPermsPlugin plugin) {
+class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
+    BukkitCommand(LuckPermsPlugin plugin) {
         super(plugin);
     }
 

bukkit/src/main/java/me/lucko/luckperms/LPBukkitPlugin.java

@@ -1,10 +1,11 @@
 package me.lucko.luckperms;
 
 import lombok.Getter;
+import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.LuckPermsApi;
 import me.lucko.luckperms.api.implementation.ApiProvider;
+import me.lucko.luckperms.api.vault.VaultHook;
 import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
 import me.lucko.luckperms.data.methods.FlatfileDatastore;
 import me.lucko.luckperms.data.methods.MySQLDatastore;
 import me.lucko.luckperms.data.methods.SQLiteDatastore;
@@ -15,7 +16,8 @@ import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BukkitUserManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
-import me.lucko.luckperms.vaulthooks.VaultHook;
+import me.lucko.luckperms.utils.LogUtil;
+import me.lucko.luckperms.utils.UuidCache;
 import org.bukkit.Bukkit;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
@@ -31,17 +33,16 @@ import java.util.stream.Collectors;
 
 @Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.3";
-
     private LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
     private TrackManager trackManager;
     private Datastore datastore;
+    private UuidCache uuidCache;
 
     @Override
     public void onEnable() {
-        getLogger().info("Loading configuration...");
+        getLog().info("Loading configuration...");
         configuration = new BukkitConfig(this);
 
         // register events
@@ -49,44 +50,40 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         pm.registerEvents(new PlayerListener(this), this);
 
         // register commands
-        getLogger().info("Registering commands...");
-        CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
+        getLog().info("Registering commands...");
+        BukkitCommand commandManager = new BukkitCommand(this);
         PluginCommand main = getServer().getPluginCommand("luckperms");
         main.setExecutor(commandManager);
         main.setTabCompleter(commandManager);
         main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
 
-        getLogger().info("Detecting storage method...");
+        getLog().info("Detecting storage method...");
         final String storageMethod = configuration.getStorageMethod();
         if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
+            getLog().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
         } else if (storageMethod.equalsIgnoreCase("sqlite")) {
-            getLogger().info("Using SQLite as storage method.");
+            getLog().info("Using SQLite as storage method.");
             datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
         } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
+            getLog().info("Using Flatfile (JSON) as storage method.");
             datastore = new FlatfileDatastore(this, getDataFolder());
         } else {
-            getLogger().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
+            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
             datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
         }
 
-        getLogger().info("Initialising datastore...");
+        getLog().info("Initialising datastore...");
         datastore.init();
 
-        getLogger().info("Loading internal permission managers...");
+        getLog().info("Loading internal permission managers...");
+        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BukkitUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
 
         // Run update task to refresh any online users
-        getLogger().info("Scheduling Update Task to refresh any online users.");
+        getLog().info("Scheduling Update Task to refresh any online users.");
         try {
             new UpdateTask(this).run();
         } catch (Exception e) {
@@ -100,33 +97,33 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         }
 
         // Provide vault support
-        getLogger().info("Attempting to hook into Vault...");
+        getLog().info("Attempting to hook into Vault...");
         try {
             if (getServer().getPluginManager().isPluginEnabled("Vault")) {
                 VaultHook.hook(this);
-                getLogger().info("Registered Vault permission & chat hook.");
+                getLog().info("Registered Vault permission & chat hook.");
             } else {
-                getLogger().info("Vault not found.");
+                getLog().info("Vault not found.");
             }
         } catch (Exception e) {
-            getLogger().severe("Error occurred whilst hooking into Vault.");
+            getLog().severe("Error occurred whilst hooking into Vault.");
             e.printStackTrace();
         }
 
-        getLogger().info("Registering API...");
+        getLog().info("Registering API...");
         final ApiProvider provider = new ApiProvider(this);
         LuckPerms.registerProvider(provider);
         getServer().getServicesManager().register(LuckPermsApi.class, provider, this, ServicePriority.Normal);
 
-        getLogger().info("Successfully loaded.");
+        getLog().info("Successfully loaded.");
     }
 
     @Override
     public void onDisable() {
-        getLogger().info("Closing datastore...");
+        getLog().info("Closing datastore...");
         datastore.shutdown();
 
-        getLogger().info("Unregistering API...");
+        getLog().info("Unregistering API...");
         LuckPerms.unregisterProvider();
         getServer().getServicesManager().unregisterAll(this);
     }
@@ -141,14 +138,19 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         Bukkit.getScheduler().runTask(this, r);
     }
 
+    @Override
+    public Logger getLog() {
+        return LogUtil.wrap(getLogger());
+    }
+
     @Override
     public String getVersion() {
-        return VERSION;
+        return getDescription().getVersion();
     }
 
     @Override
     public String getPlayerStatus(UUID uuid) {
-        return getServer().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
+        return getServer().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? "&aOnline" : "&cOffline";
     }
 
     @Override

bukkit/src/main/java/me/lucko/luckperms/api/vault/VaultChatHook.java

@@ -1,4 +1,4 @@
-package me.lucko.luckperms.vaulthooks;
+package me.lucko.luckperms.api.vault;
 
 import net.milkbowl.vault.chat.Chat;
 import net.milkbowl.vault.permission.Permission;

bukkit/src/main/java/me/lucko/luckperms/api/vault/VaultHook.java

@@ -1,4 +1,4 @@
-package me.lucko.luckperms.vaulthooks;
+package me.lucko.luckperms.api.vault;
 
 import me.lucko.luckperms.LPBukkitPlugin;
 import net.milkbowl.vault.chat.Chat;

bukkit/src/main/java/me/lucko/luckperms/api/vault/VaultPermissionHook.java

@@ -0,0 +1,197 @@
+package me.lucko.luckperms.api.vault;
+
+import lombok.NonNull;
+import lombok.Setter;
+import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.PermissionObject;
+import net.milkbowl.vault.permission.Permission;
+
+/**
+ *
+ */
+class VaultPermissionHook extends Permission {
+
+    @Setter
+    private LPBukkitPlugin plugin;
+
+    @Override
+    public String getName() {
+        return "LuckPerms";
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return plugin.getDatastore().isAcceptingLogins();
+    }
+
+    @Override
+    public boolean hasSuperPermsCompat() {
+        return true;
+    }
+
+    private boolean objectHas(String world, PermissionObject object, String permission) {
+        if (object == null) return false;
+
+        if (world != null && !world.equals("")) {
+            return object.hasPermission(permission, true, "global", world);
+        } else {
+            return object.hasPermission(permission, true);
+        }
+    }
+
+    private boolean objectAdd(String world, PermissionObject object, String permission) {
+        if (object == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                object.setPermission(permission, true, "global", world);
+            } else {
+                object.setPermission(permission, true);
+            }
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        objectSave(object);
+        return true;
+    }
+
+    private boolean objectRemove(String world, PermissionObject object, String permission) {
+        if (object == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                object.unsetPermission(permission, "global", world);
+            } else {
+                object.unsetPermission(permission);
+            }
+        } catch (ObjectLacksException ignored) {}
+
+        objectSave(object);
+        return true;
+    }
+
+    private void objectSave(PermissionObject t) {
+        if (t instanceof User) {
+            ((User) t).refreshPermissions();
+            plugin.getDatastore().saveUser(((User) t), aBoolean -> {});
+        }
+        if (t instanceof Group) {
+            plugin.getDatastore().saveGroup(((Group) t), aBoolean -> plugin.runUpdateTask());
+        }
+    }
+
+    @Override
+    public boolean playerHas(String world, @NonNull String player, @NonNull String permission) {
+        return objectHas(world, plugin.getUserManager().getUser(player), permission);
+    }
+
+    @Override
+    public boolean playerAdd(String world, @NonNull String player, @NonNull String permission) {
+        final User user = plugin.getUserManager().getUser(player);
+        return objectAdd(world, user, permission);
+    }
+
+    @Override
+    public boolean playerRemove(String world, @NonNull String player, @NonNull String permission) {
+        final User user = plugin.getUserManager().getUser(player);
+        return objectRemove(world, user, permission);
+    }
+
+    @Override
+    public boolean groupHas(String world, @NonNull String groupName, @NonNull String permission) {
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        return objectHas(world, group, permission);
+    }
+
+    @Override
+    public boolean groupAdd(String world, @NonNull String groupName, @NonNull String permission) {
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        return objectAdd(world, group, permission);
+    }
+
+    @Override
+    public boolean groupRemove(String world, @NonNull String groupName, @NonNull String permission) {
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        return objectRemove(world, group, permission);
+    }
+
+    @Override
+    public boolean playerInGroup(String world, @NonNull String player, @NonNull String group) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        final Group group1 = plugin.getGroupManager().getGroup(group);
+        if (group1 == null) return false;
+
+        if (world != null && !world.equals("")) {
+            return user.isInGroup(group1, "global", world);
+        } else {
+            return user.isInGroup(group1);
+        }
+    }
+
+    @Override
+    public boolean playerAddGroup(String world, @NonNull String player, @NonNull String groupName) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        if (group == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                user.addGroup(group, "global", world);
+            } else {
+                user.addGroup(group);
+            }
+        } catch (ObjectAlreadyHasException ignored) {}
+        objectSave(user);
+        return true;
+    }
+
+    @Override
+    public boolean playerRemoveGroup(String world, @NonNull String player, @NonNull String groupName) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        if (group == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                user.removeGroup(group, "global", world);
+            } else {
+                user.removeGroup(group);
+            }
+        } catch (ObjectLacksException ignored) {}
+        objectSave(user);
+        return true;
+    }
+
+    @Override
+    public String[] getPlayerGroups(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().getUser(player);
+        return (user == null) ? new String[0] :
+                world != null && !world.equals("") ? user.getLocalGroups("global", world).toArray(new String[0]) :
+                        user.getGroupNames().toArray(new String[0]);
+    }
+
+    @Override
+    public String getPrimaryGroup(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().getUser(player);
+        return (user == null) ? null : user.getPrimaryGroup();
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroupManager().getGroups().keySet().toArray(new String[0]);
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -6,13 +6,13 @@ import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.users.BukkitUser;
 import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.UuidCache;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.*;
+
+import java.util.UUID;
 
 @AllArgsConstructor
 public class PlayerListener implements Listener {
@@ -21,18 +21,39 @@ public class PlayerListener implements Listener {
 
     @EventHandler
     public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
+        final long startTime = System.currentTimeMillis();
         if (!plugin.getDatastore().isAcceptingLogins()) {
             // Datastore is disabled, prevent players from joining the server
             e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, KICK_MESSAGE);
             return;
         }
-        plugin.getDatastore().loadOrCreateUser(e.getUniqueId(), e.getName());
+        
+        final UuidCache cache = plugin.getUuidCache();
+        if (!cache.isOnlineMode()) {
+            UUID uuid = plugin.getDatastore().getUUID(e.getName());
+            if (uuid != null) {
+                cache.addToCache(e.getUniqueId(), uuid);
+            } else {
+                // No previous data for this player
+                cache.addToCache(e.getUniqueId(), e.getUniqueId());
+                plugin.getDatastore().saveUUIDData(e.getName(), e.getUniqueId(), b -> {});
+            }
+        } else {
+            // Online mode, no cache needed. This is just for name -> uuid lookup.
+            plugin.getDatastore().saveUUIDData(e.getName(), e.getUniqueId(), b -> {});
+        }
+
+        plugin.getDatastore().loadOrCreateUser(cache.getUUID(e.getUniqueId()), e.getName());
+        final long time = System.currentTimeMillis() - startTime;
+        if (time >= 1000) {
+            plugin.getLog().warn("Processing login for " + e.getName() + " took " + time + "ms.");
+        }
     }
 
     @EventHandler
     public void onPlayerLogin(PlayerLoginEvent e) {
         final Player player = e.getPlayer();
-        final User user = plugin.getUserManager().getUser(player.getUniqueId());
+        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(player.getUniqueId()));
 
         if (user == null) {
             e.disallow(PlayerLoginEvent.Result.KICK_OTHER, KICK_MESSAGE);
@@ -49,24 +70,32 @@ public class PlayerListener implements Listener {
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent e) {
-        // Save UUID data for the player
-        plugin.getDatastore().saveUUIDData(e.getPlayer().getName(), e.getPlayer().getUniqueId(), success -> {});
-
-        final User user = plugin.getUserManager().getUser(e.getPlayer().getUniqueId());
-        if (user != null) {
-            // Refresh permissions again
-            user.refreshPermissions();
-        }
+        // Refresh permissions again
+        refreshPlayer(e.getPlayer());
+    }
 
+    @EventHandler
+    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
+        refreshPlayer(e.getPlayer());
     }
 
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent e) {
         final Player player = e.getPlayer();
+        final UuidCache cache = plugin.getUuidCache();
 
-        // Unload the user from memory when they disconnect
-        final User user = plugin.getUserManager().getUser(player.getUniqueId());
+        // Unload the user from memory when they disconnect;
+        cache.clearCache(player.getUniqueId());
+
+        final User user = plugin.getUserManager().getUser(cache.getUUID(player.getUniqueId()));
         plugin.getUserManager().unloadUser(user);
     }
 
+    private void refreshPlayer(Player p) {
+        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(p.getUniqueId()));
+        if (user != null) {
+            user.refreshPermissions();
+        }
+    }
+
 }

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUser.java

@@ -30,11 +30,11 @@ public class BukkitUser extends User {
     @Override
     public void refreshPermissions() {
         plugin.doSync(() -> {
-            final Player player = plugin.getServer().getPlayer(getUuid());
+            final Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(getUuid()));
             if (player == null) return;
 
             if (attachment == null) {
-                getPlugin().getLogger().warning("User " + getName() + " does not have a permissions attachment defined.");
+                getPlugin().getLog().warn("User " + getName() + " does not have a permissions attachment defined.");
                 setAttachment(player.addAttachment(plugin));
             }
 
@@ -42,7 +42,7 @@ public class BukkitUser extends User {
             attachment.getPermissions().keySet().forEach(p -> attachment.setPermission(p, false));
 
             // Re-add all defined permissions for the user
-            Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
+            Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), player.getWorld().getName(), null);
             local.entrySet().forEach(e -> attachment.setPermission(e.getKey(), e.getValue()));
         });
     }

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUserManager.java

@@ -3,7 +3,9 @@ package me.lucko.luckperms.users;
 import me.lucko.luckperms.LPBukkitPlugin;
 import org.bukkit.entity.Player;
 
+import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 public class BukkitUserManager extends UserManager {
     private final LPBukkitPlugin plugin;
@@ -21,7 +23,7 @@ public class BukkitUserManager extends UserManager {
                 BukkitUser u = (BukkitUser) user;
 
                 if (u.getAttachment() != null) {
-                    Player player = plugin.getServer().getPlayer(u.getUuid());
+                    Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(u.getUuid()));
 
                     if (player != null) {
                         player.removeAttachment(u.getAttachment());
@@ -36,7 +38,7 @@ public class BukkitUserManager extends UserManager {
 
     @Override
     public void cleanupUser(User user) {
-        if (plugin.getServer().getPlayer(user.getUuid()) == null) {
+        if (plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
             unloadUser(user);
         }
     }
@@ -53,6 +55,12 @@ public class BukkitUserManager extends UserManager {
 
     @Override
     public void updateAllUsers() {
-        plugin.getServer().getOnlinePlayers().stream().map(Player::getUniqueId).forEach(u -> plugin.getDatastore().loadUser(u));
+        // Sometimes called async, so we need to get the players on the Bukkit thread.
+        plugin.doSync(() -> {
+            Set<UUID> players = plugin.getServer().getOnlinePlayers().stream()
+                    .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
+                    .collect(Collectors.toSet());
+            plugin.doAsync(() -> players.forEach(u -> plugin.getDatastore().loadUser(u)));
+        });
     }
 }

bukkit/src/main/java/me/lucko/luckperms/vaulthooks/VaultPermissionHook.java

@@ -1,152 +0,0 @@
-package me.lucko.luckperms.vaulthooks;
-
-import lombok.Setter;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.users.User;
-import net.milkbowl.vault.permission.Permission;
-
-class VaultPermissionHook extends Permission {
-
-    @Setter
-    private LPBukkitPlugin plugin;
-
-    @Override
-    public String getName() {
-        return "LuckPerms";
-    }
-
-    @Override
-    public boolean isEnabled() {
-        return plugin.getDatastore().isAcceptingLogins();
-    }
-
-    @Override
-    public boolean hasSuperPermsCompat() {
-        // Idk???
-        return true;
-    }
-
-    @Override
-    public boolean playerHas(String world, String player, String permission) {
-        final User user = plugin.getUserManager().getUser(player);
-        return user != null && user.hasPermission(permission, true);
-    }
-
-    @Override
-    public boolean playerAdd(String world, String player, String permission) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        try {
-            user.setPermission(permission, true);
-        } catch (ObjectAlreadyHasException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public boolean playerRemove(String world, String player, String permission) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        try {
-            user.unsetPermission(permission);
-        } catch (ObjectLacksException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public boolean groupHas(String world, String groupName, String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        return group != null && group.hasPermission(permission, true);
-    }
-
-    @Override
-    public boolean groupAdd(String world, String groupName, String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            group.setPermission(permission, true);
-        } catch (ObjectAlreadyHasException ignored) {}
-        plugin.runUpdateTask();
-        return true;
-    }
-
-    @Override
-    public boolean groupRemove(String world, String groupName, String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            group.unsetPermission(permission);
-        } catch (ObjectLacksException ignored) {}
-        plugin.runUpdateTask();
-        return true;
-    }
-
-    @Override
-    public boolean playerInGroup(String world, String player, String group) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        final Group group1 = plugin.getGroupManager().getGroup(group);
-        return group1 != null && user.isInGroup(group1);
-    }
-
-    @Override
-    public boolean playerAddGroup(String world, String player, String groupName) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            user.addGroup(group);
-        } catch (ObjectAlreadyHasException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public boolean playerRemoveGroup(String world, String player, String groupName) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            user.removeGroup(group);
-        } catch (ObjectLacksException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public String[] getPlayerGroups(String world, String player) {
-        final User user = plugin.getUserManager().getUser(player);
-        return (user == null) ? new String[0] : user.getGroupNames().toArray(new String[0]);
-    }
-
-    @Override
-    public String getPrimaryGroup(String world, String player) {
-        final User user = plugin.getUserManager().getUser(player);
-        return (user == null) ? null : user.getPrimaryGroup();
-    }
-
-    @Override
-    public String[] getGroups() {
-        return plugin.getGroupManager().getGroups().keySet().toArray(new String[0]);
-    }
-
-    @Override
-    public boolean hasGroupSupport() {
-        return true;
-    }
-}

bukkit/src/main/resources/config.yml

@@ -9,6 +9,19 @@ default-group: default
 # If users on this server should have their global permissions/groups applied.
 include-global: true
 
+# If this server is in offline or online mode.
+# This setting allows a player to have the same UUID across a network of offline mode/mixed servers.
+
+# You should generally reflect the setting in server.properties here. Except when...
+
+# 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
+#    AND 'ip-forward' set to true in the BungeeCord config.yml
+#    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
+
+# 2. You are only running one server instance using LuckPerms, (not a network)
+#    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
+online-mode: true
+
 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, flatfile
 # Fill out connection info below if you're using MySQL

bukkit/src/main/resources/plugin.yml

@@ -1,6 +1,6 @@
 name: LuckPerms
 author: Luck
-version: 1.2
+version: ${project.version}
 main: me.lucko.luckperms.LPBukkitPlugin
 softdepend: [Vault]
 description: A permissions plugin

bungee/pom.xml

@@ -4,19 +4,19 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
-        <groupId>me.lucko</groupId>
-        <version>1.3</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bungee</artifactId>
-    <version>$(project.parent.version)</version>
+    <version>1.5</version>
     <packaging>jar</packaging>
     <name>LuckPerms</name>
 
     <build>
         <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms</finalName>
+        <finalName>LuckPermsBungee</finalName>
         <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
         <resources>
             <resource>
@@ -63,18 +63,18 @@
         </dependency>
         <!-- LuckPerms Common -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
         <!-- LuckPerms API -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
 
-</project>
+</project>

bungee/src/main/java/me/lucko/luckperms/BungeeCommand.java

@@ -10,10 +10,10 @@ import net.md_5.bungee.api.plugin.TabExecutor;
 import java.lang.ref.WeakReference;
 import java.util.Arrays;
 
-class MainCommand extends Command implements TabExecutor {
+class BungeeCommand extends Command implements TabExecutor {
     private final CommandManager manager;
 
-    public MainCommand(CommandManager manager) {
+    public BungeeCommand(CommandManager manager) {
         super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
         this.manager = manager;
     }

bungee/src/main/java/me/lucko/luckperms/LPBungeePlugin.java

@@ -1,10 +1,10 @@
 package me.lucko.luckperms;
 
 import lombok.Getter;
+import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.commands.CommandManager;
 import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
 import me.lucko.luckperms.data.methods.FlatfileDatastore;
 import me.lucko.luckperms.data.methods.MySQLDatastore;
 import me.lucko.luckperms.groups.GroupManager;
@@ -14,6 +14,8 @@ import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.utils.LogUtil;
+import me.lucko.luckperms.utils.UuidCache;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
 
@@ -24,57 +26,52 @@ import java.util.stream.Collectors;
 
 @Getter
 public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.3";
-
     private LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
     private TrackManager trackManager;
     private Datastore datastore;
+    private UuidCache uuidCache;
 
     @Override
     public void onEnable() {
-        getLogger().info("Loading configuration...");
+        getLog().info("Loading configuration...");
         configuration = new BungeeConfig(this);
 
         // register events
         getProxy().getPluginManager().registerListener(this, new PlayerListener(this));
 
         // register commands
-        getLogger().info("Registering commands...");
-        getProxy().getPluginManager().registerCommand(this, new MainCommand(new CommandManager(this)));
+        getLog().info("Registering commands...");
+        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(new CommandManager(this)));
 
         // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
         getProxy().getDisabledCommands().add("perms");
 
-        getLogger().info("Detecting storage method...");
+        getLog().info("Detecting storage method...");
         final String storageMethod = configuration.getStorageMethod();
         if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
+            getLog().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
         } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
+            getLog().info("Using Flatfile (JSON) as storage method.");
             datastore = new FlatfileDatastore(this, getDataFolder());
         } else {
-            getLogger().severe("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
+            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
             datastore = new FlatfileDatastore(this, getDataFolder());
         }
 
-        getLogger().info("Initialising datastore...");
+        getLog().info("Initialising datastore...");
         datastore.init();
 
-        getLogger().info("Loading internal permission managers...");
+        getLog().info("Loading internal permission managers...");
+        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BungeeUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
 
         // Run update task to refresh any online users
-        getLogger().info("Scheduling Update Task to refresh any online users.");
+        getLog().info("Scheduling Update Task to refresh any online users.");
         try {
             new UpdateTask(this).run();
         } catch (Exception e) {
@@ -86,29 +83,34 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
             getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
         }
 
-        getLogger().info("Registering API...");
+        getLog().info("Registering API...");
         LuckPerms.registerProvider(new ApiProvider(this));
 
-        getLogger().info("Successfully loaded.");
+        getLog().info("Successfully loaded.");
     }
 
     @Override
     public void onDisable() {
-        getLogger().info("Closing datastore...");
+        getLog().info("Closing datastore...");
         datastore.shutdown();
 
-        getLogger().info("Unregistering API...");
+        getLog().info("Unregistering API...");
         LuckPerms.unregisterProvider();
     }
 
+    @Override
+    public Logger getLog() {
+        return LogUtil.wrap(getLogger());
+    }
+
     @Override
     public String getVersion() {
-        return VERSION;
+        return getDescription().getVersion();
     }
 
     @Override
     public String getPlayerStatus(UUID uuid) {
-        return getProxy().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
+        return getProxy().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? "&aOnline" : "&cOffline";
     }
 
     @Override

bungee/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -5,14 +5,19 @@ import me.lucko.luckperms.LPBungeePlugin;
 import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.UuidCache;
 import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.event.LoginEvent;
 import net.md_5.bungee.api.event.PlayerDisconnectEvent;
 import net.md_5.bungee.api.event.PostLoginEvent;
+import net.md_5.bungee.api.event.ServerSwitchEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
 
 import java.lang.ref.WeakReference;
+import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 @AllArgsConstructor
@@ -22,39 +27,77 @@ public class PlayerListener implements Listener {
     );
     private final LPBungeePlugin plugin;
 
+    @EventHandler
+    public void onPlayerLogin(LoginEvent e) {
+        /* Delay the login here, as we want to cache UUID data before the player is connected to a backend bukkit server.
+           This means that a player will have the same UUID across the network, even if parts of the network are running in
+           Offline mode. */
+        e.registerIntent(plugin);
+        plugin.doAsync(() -> {
+            final long startTime = System.currentTimeMillis();
+            final UuidCache cache = plugin.getUuidCache();
+            final PendingConnection c = e.getConnection();
+
+            if (!cache.isOnlineMode()) {
+                UUID uuid = plugin.getDatastore().getUUID(c.getName());
+                if (uuid != null) {
+                    cache.addToCache(c.getUniqueId(), uuid);
+                } else {
+                    // No previous data for this player
+                    cache.addToCache(c.getUniqueId(), c.getUniqueId());
+                    plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
+                }
+            } else {
+                // Online mode, no cache needed. This is just for name -> uuid lookup.
+                plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
+            }
+
+            // We have to make a new user on this thread whilst the connection is being held, or we get concurrency issues as the Bukkit server
+            // and the BungeeCord server try to make a new user at the same time.
+            plugin.getDatastore().loadOrCreateUser(cache.getUUID(c.getUniqueId()), c.getName());
+            final long time = System.currentTimeMillis() - startTime;
+            if (time >= 1000) {
+                plugin.getLog().warn("Processing login for " + c.getName() + " took " + time + "ms.");
+            }
+            e.completeIntent(plugin);
+        });
+    }
+
     @EventHandler
     public void onPlayerPostLogin(PostLoginEvent e) {
         final ProxiedPlayer player = e.getPlayer();
         final WeakReference<ProxiedPlayer> p = new WeakReference<>(player);
 
-        // Create user async and at post login. We're not concerned if data couldn't be loaded, the player won't be kicked.
-        plugin.getDatastore().loadOrCreateUser(player.getUniqueId(), player.getName(), success -> {
-            if (!success) {
-                plugin.getProxy().getScheduler().schedule(plugin, () -> {
-                    final ProxiedPlayer pl = p.get();
-                    if (pl != null) {
-                        pl.sendMessage(WARN_MESSAGE);
-                    }
-                }, 3, TimeUnit.SECONDS);
-
-            } else {
+        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        if (user == null) {
+            plugin.getProxy().getScheduler().schedule(plugin, () -> {
                 final ProxiedPlayer pl = p.get();
                 if (pl != null) {
-                    final User user = plugin.getUserManager().getUser(pl.getUniqueId());
-                    user.refreshPermissions();
+                    pl.sendMessage(WARN_MESSAGE);
                 }
-            }
-        });
-
-        plugin.getDatastore().saveUUIDData(player.getName(), player.getUniqueId(), success -> {});
+            }, 3, TimeUnit.SECONDS);
+        } else {
+            user.refreshPermissions();
+        }
     }
 
     @EventHandler
     public void onPlayerQuit(PlayerDisconnectEvent e) {
         final ProxiedPlayer player = e.getPlayer();
+        final UuidCache cache = plugin.getUuidCache();
 
-        // Unload the user from memory when they disconnect
-        final User user = plugin.getUserManager().getUser(player.getUniqueId());
+        // Unload the user from memory when they disconnect;
+        cache.clearCache(player.getUniqueId());
+
+        final User user = plugin.getUserManager().getUser(cache.getUUID(player.getUniqueId()));
         plugin.getUserManager().unloadUser(user);
     }
+
+    @EventHandler
+    public void onPlayerServerSwitch(ServerSwitchEvent e) {
+        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        if (user != null) {
+            user.refreshPermissions();
+        }
+    }
 }

bungee/src/main/java/me/lucko/luckperms/users/BungeeUser.java

@@ -9,7 +9,6 @@ import java.util.Map;
 import java.util.UUID;
 
 public class BungeeUser extends User {
-
     private final LPBungeePlugin plugin;
 
     BungeeUser(UUID uuid, LPBungeePlugin plugin) {
@@ -24,7 +23,7 @@ public class BungeeUser extends User {
 
     @Override
     public void refreshPermissions() {
-        ProxiedPlayer player = plugin.getProxy().getPlayer(getUuid());
+        ProxiedPlayer player = plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(getUuid()));
         if (player == null) return;
 
         // Clear existing permissions
@@ -32,7 +31,8 @@ public class BungeeUser extends User {
         perms.forEach(p -> player.setPermission(p, false));
 
         // Re-add all defined permissions for the user
-        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
+        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
+        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), server, null);
         local.entrySet().forEach(e -> player.setPermission(e.getKey(), e.getValue()));
     }
 }

bungee/src/main/java/me/lucko/luckperms/users/BungeeUserManager.java

@@ -1,7 +1,6 @@
 package me.lucko.luckperms.users;
 
 import me.lucko.luckperms.LPBungeePlugin;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 import java.util.UUID;
 
@@ -24,7 +23,7 @@ public class BungeeUserManager extends UserManager {
 
     @Override
     public void cleanupUser(User user) {
-        if (plugin.getProxy().getPlayer(user.getUuid()) == null) {
+        if (plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
             unloadUser(user);
         }
     }
@@ -41,6 +40,8 @@ public class BungeeUserManager extends UserManager {
 
     @Override
     public void updateAllUsers() {
-        plugin.getProxy().getPlayers().stream().map(ProxiedPlayer::getUniqueId).forEach(u -> plugin.getDatastore().loadUser(u));
+        plugin.getProxy().getPlayers().stream()
+                .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
+                .forEach(u -> plugin.getDatastore().loadUser(u));
     }
 }

bungee/src/main/resources/config.yml

@@ -9,6 +9,19 @@ default-group: default
 # If users on this server should have their global permissions/groups applied.
 include-global: false
 
+# If this server is in offline or online mode.
+# This setting allows a player to have the same UUID across a network of offline mode/mixed servers.
+
+# You should generally reflect the setting in server.properties here. Except when...
+
+# 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
+#    AND 'ip-forward' set to true in the BungeeCord config.yml
+#    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
+
+# 2. You are only running one server instance using LuckPerms, (not a network)
+#    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
+online-mode: true
+
 # Which storage method the plugin should use.
 # Currently supported: mysql & flatfile
 # Fill out connection info below if you're using MySQL

bungee/src/main/resources/plugin.yml

@@ -1,5 +1,5 @@
 name: LuckPerms
 author: Luck
-version: 1.2
+version: ${project.version}
 main: me.lucko.luckperms.LPBungeePlugin
 description: A permissions plugin

common/pom.xml

@@ -4,11 +4,12 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
-        <groupId>me.lucko</groupId>
-        <version>1.3</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>1.5</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
+    <version>1.5</version>
     <artifactId>luckperms-common</artifactId>
     <build>
         <plugins>
@@ -27,11 +28,11 @@
     <dependencies>
         <!-- LuckPerms API -->
         <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>${project.parent.version}</version>
+            <version>1.5</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
 
-</project>
+</project>

common/src/main/java/me/lucko/luckperms/LuckPermsPlugin.java

@@ -1,14 +1,15 @@
 package me.lucko.luckperms;
 
+import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.data.Datastore;
 import me.lucko.luckperms.groups.GroupManager;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.utils.UuidCache;
 
 import java.util.List;
 import java.util.UUID;
-import java.util.logging.Logger;
 
 public interface LuckPermsPlugin {
 
@@ -46,7 +47,13 @@ public interface LuckPermsPlugin {
      * Retrieves the {@link Logger} for the plugin
      * @return the plugin's {@link Logger}
      */
-    Logger getLogger();
+    Logger getLog();
+
+    /**
+     * Retrieves the {@link UuidCache} for the plugin
+     * @return the plugin's {@link UuidCache}
+     */
+    UuidCache getUuidCache();
 
     /**
      * @return the version of the plugin

common/src/main/java/me/lucko/luckperms/api/implementation/ApiProvider.java

@@ -33,6 +33,11 @@ public class ApiProvider implements LuckPermsApi {
         return new DatastoreLink(plugin.getDatastore());
     }
 
+    @Override
+    public Logger getLogger() {
+        return plugin.getLog();
+    }
+
     @Override
     public User getUser(@NonNull UUID uuid) {
         final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(uuid);

common/src/main/java/me/lucko/luckperms/api/implementation/internal/DatastoreLink.java

@@ -43,18 +43,10 @@ public class DatastoreLink implements Datastore {
         return s.toLowerCase();
     }
 
-    private static Callback checkCallback(Callback c) {
+    private static <T> Callback<T> checkCallback(Callback<T> c) {
         // If no callback was given, just send an empty one
         if (c == null) {
-            c = success -> {};
-        }
-        return c;
-    }
-
-    private static Callback.GetUUID checkCallback(Callback.GetUUID c) {
-        // If no callback was given, just send an empty one
-        if (c == null) {
-            c = success -> {};
+            c = t -> {};
         }
         return c;
     }
@@ -84,82 +76,82 @@ public class DatastoreLink implements Datastore {
         private final me.lucko.luckperms.data.Datastore master;
 
         @Override
-        public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback callback) {
+        public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
             master.loadOrCreateUser(uuid, checkUsername(username), checkCallback(callback));
         }
 
         @Override
-        public void loadUser(@NonNull UUID uuid, Callback callback) {
+        public void loadUser(@NonNull UUID uuid, Callback<Boolean> callback) {
             master.loadUser(uuid, checkCallback(callback));
         }
 
         @Override
-        public void saveUser(@NonNull User user, Callback callback) {
+        public void saveUser(@NonNull User user, Callback<Boolean> callback) {
             Utils.checkUser(user);
             master.saveUser(((UserLink) user).getMaster(), checkCallback(callback));
         }
 
         @Override
-        public void createAndLoadGroup(@NonNull String name, Callback callback) {
+        public void createAndLoadGroup(@NonNull String name, Callback<Boolean> callback) {
             master.createAndLoadGroup(checkName(name), checkCallback(callback));
         }
 
         @Override
-        public void loadGroup(@NonNull String name, Callback callback) {
+        public void loadGroup(@NonNull String name, Callback<Boolean> callback) {
             master.loadGroup(checkName(name), checkCallback(callback));
         }
 
         @Override
-        public void loadAllGroups(Callback callback) {
+        public void loadAllGroups(Callback<Boolean> callback) {
             master.loadAllGroups(checkCallback(callback));
         }
 
         @Override
-        public void saveGroup(@NonNull Group group, Callback callback) {
+        public void saveGroup(@NonNull Group group, Callback<Boolean> callback) {
             Utils.checkGroup(group);
             master.saveGroup(((GroupLink) group).getMaster(), checkCallback(callback));
         }
 
         @Override
-        public void deleteGroup(@NonNull Group group, Callback callback) {
+        public void deleteGroup(@NonNull Group group, Callback<Boolean> callback) {
             Utils.checkGroup(group);
             master.deleteGroup(((GroupLink) group).getMaster(), checkCallback(callback));
         }
 
         @Override
-        public void createAndLoadTrack(@NonNull String name, Callback callback) {
+        public void createAndLoadTrack(@NonNull String name, Callback<Boolean> callback) {
             master.createAndLoadTrack(checkName(name), checkCallback(callback));
         }
 
         @Override
-        public void loadTrack(@NonNull String name, Callback callback) {
+        public void loadTrack(@NonNull String name, Callback<Boolean> callback) {
             master.loadTrack(checkName(name), checkCallback(callback));
         }
 
         @Override
-        public void loadAllTracks(Callback callback) {
+        public void loadAllTracks(Callback<Boolean> callback) {
             master.loadAllTracks(checkCallback(callback));
         }
 
         @Override
-        public void saveTrack(@NonNull Track track, Callback callback) {
+        public void saveTrack(@NonNull Track track, Callback<Boolean> callback) {
             Utils.checkTrack(track);
             master.saveTrack(((TrackLink) track).getMaster(), checkCallback(callback));
         }
 
         @Override
-        public void deleteTrack(@NonNull Track track, Callback callback) {
+        public void deleteTrack(@NonNull Track track, Callback<Boolean> callback) {
             Utils.checkTrack(track);
             master.deleteTrack(((TrackLink) track).getMaster(), checkCallback(callback));
         }
 
         @Override
-        public void saveUUIDData(@NonNull String username, @NonNull UUID uuid, Callback callback) {
+        public void saveUUIDData(@NonNull String username, @NonNull UUID uuid, Callback<Boolean> callback) {
             master.saveUUIDData(checkUsername(username), uuid, checkCallback(callback));
         }
 
         @Override
-        public void getUUID(@NonNull String username, Callback.GetUUID callback) {
+        public void getUUID(@NonNull String username, Callback<UUID> callback) {
             master.getUUID(checkUsername(username), checkCallback(callback));
         }
     }

common/src/main/java/me/lucko/luckperms/api/implementation/internal/GroupLink.java

@@ -4,6 +4,10 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
 
 /**
  * Provides a link between {@link Group} and {@link me.lucko.luckperms.groups.Group}
@@ -24,8 +28,113 @@ public class GroupLink extends PermissionObjectLink implements Group {
         return master.getName();
     }
 
+    @Override
+    public boolean inheritsGroup(@NonNull Group group) {
+        Utils.checkGroup(group);
+        return master.inheritsGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public boolean inheritsGroup(@NonNull Group group, @NonNull String server) {
+        Utils.checkGroup(group);
+        return master.inheritsGroup(((GroupLink) group).getMaster(), server);
+    }
+
+    @Override
+    public boolean inheritsGroup(@NonNull Group group, @NonNull String server, @NonNull String world) {
+        Utils.checkGroup(group);
+        return master.inheritsGroup(((GroupLink) group).getMaster(), server, world);
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world, checkTime(expireAt));
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull boolean temporary) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), temporary);
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world, temporary);
+    }
+
     @Override
     public void clearNodes() {
         master.clearNodes();
     }
+
+    @Override
+    public List<String> getGroupNames() {
+        return master.getGroupNames();
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server, @NonNull String world) {
+        return master.getLocalGroups(checkServer(server), world);
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server) {
+        return master.getLocalGroups(checkServer(server));
+    }
 }

common/src/main/java/me/lucko/luckperms/api/implementation/internal/PermissionObjectLink.java

@@ -64,11 +64,26 @@ class PermissionObjectLink implements PermissionObject {
         return master.hasPermission(node, b, checkServer(server));
     }
 
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world) {
+        return master.hasPermission(node, b, checkServer(server), world);
+    }
+
     @Override
     public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
         return master.hasPermission(node, b, temporary);
     }
 
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull boolean temporary) {
+        return master.hasPermission(node, b, checkServer(server), temporary);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world, @NonNull boolean temporary) {
+        return master.hasPermission(node, b, checkServer(server), world, temporary);
+    }
+
     @Override
     public boolean inheritsPermission(@NonNull String node, @NonNull boolean b) {
         return master.inheritsPermission(node, b);
@@ -79,11 +94,26 @@ class PermissionObjectLink implements PermissionObject {
         return master.inheritsPermission(node, b, checkServer(server));
     }
 
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world) {
+        return master.inheritsPermission(node, b, checkServer(server), world);
+    }
+
     @Override
     public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
         return master.inheritsPermission(node, b, temporary);
     }
 
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull boolean temporary) {
+        return master.inheritsPermission(node, b, checkServer(server), temporary);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world, @NonNull boolean temporary) {
+        return master.inheritsPermission(node, b, checkServer(server), world, temporary);
+    }
+
     @Override
     public void setPermission(@NonNull String node, @NonNull boolean value) throws ObjectAlreadyHasException {
         master.setPermission(checkNode(node), value);
@@ -94,6 +124,11 @@ class PermissionObjectLink implements PermissionObject {
         master.setPermission(checkNode(node), value, checkServer(server));
     }
 
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server), world);
+    }
+
     @Override
     public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull long expireAt) throws ObjectAlreadyHasException {
         master.setPermission(checkNode(node), value, checkTime(expireAt));
@@ -104,6 +139,11 @@ class PermissionObjectLink implements PermissionObject {
         master.setPermission(checkNode(node), value, checkServer(server), checkTime(expireAt));
     }
 
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server), world, checkTime(expireAt));
+    }
+
     @Override
     public void unsetPermission(@NonNull String node, @NonNull boolean temporary) throws ObjectLacksException {
         master.unsetPermission(checkNode(node), temporary);
@@ -119,11 +159,26 @@ class PermissionObjectLink implements PermissionObject {
         master.unsetPermission(checkNode(node), checkServer(server));
     }
 
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull String world) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server), world);
+    }
+
     @Override
     public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
         master.unsetPermission(checkNode(node), checkServer(server), temporary);
     }
 
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server), world, temporary);
+    }
+
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups) {
+        return master.getLocalPermissions(server, world, excludedGroups);
+    }
+
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
         return master.getLocalPermissions(server, excludedGroups);

common/src/main/java/me/lucko/luckperms/api/implementation/internal/UserLink.java

@@ -70,6 +70,12 @@ public class UserLink extends PermissionObjectLink implements User {
         return master.isInGroup(((GroupLink) group).getMaster(), server);
     }
 
+    @Override
+    public boolean isInGroup(@NonNull Group group, @NonNull String server, @NonNull String world) {
+        Utils.checkGroup(group);
+        return master.isInGroup(((GroupLink) group).getMaster(), server, world);
+    }
+
     @Override
     public void addGroup(@NonNull Group group) throws ObjectAlreadyHasException {
         Utils.checkGroup(group);
@@ -82,6 +88,12 @@ public class UserLink extends PermissionObjectLink implements User {
         master.addGroup(((GroupLink) group).getMaster(), checkServer(server));
     }
 
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
     @Override
     public void addGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
         Utils.checkGroup(group);
@@ -94,6 +106,12 @@ public class UserLink extends PermissionObjectLink implements User {
         master.addGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
     }
 
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), world, checkTime(expireAt));
+    }
+
     @Override
     public void removeGroup(@NonNull Group group) throws ObjectLacksException {
         Utils.checkGroup(group);
@@ -112,12 +130,24 @@ public class UserLink extends PermissionObjectLink implements User {
         master.removeGroup(((GroupLink) group).getMaster(), checkServer(server));
     }
 
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
     @Override
     public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
         Utils.checkGroup(group);
         master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
     }
 
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), world, temporary);
+    }
+
     @Override
     public void clearNodes() {
         master.clearNodes();
@@ -128,6 +158,11 @@ public class UserLink extends PermissionObjectLink implements User {
         return master.getGroupNames();
     }
 
+    @Override
+    public List<String> getLocalGroups(@NonNull String server, @NonNull String world) {
+        return master.getLocalGroups(checkServer(server), world);
+    }
+
     @Override
     public List<String> getLocalGroups(@NonNull String server) {
         return master.getLocalGroups(checkServer(server));

common/src/main/java/me/lucko/luckperms/commands/CommandManager.java

@@ -23,7 +23,6 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import java.util.logging.Level;
 import java.util.stream.Collectors;
 
 public class CommandManager {
@@ -96,8 +95,9 @@ public class CommandManager {
     /**
      * Generic on command method to be called from the command executor object of the platform
      * @param sender who sent the command
+     * @param label the command label used
      * @param args the arguments provided
-     * @return if the command was successful (hint: it always is :> )
+     * @return if the command was successful
      */
     public boolean onCommand(Sender sender, String label, List<String> args) {
         if (args.size() == 0) {
@@ -113,7 +113,7 @@ public class CommandManager {
         }
 
         final MainCommand main = o.get();
-        if (!main.canUse(sender)) {
+        if (!main.isAuthorized(sender)) {
             sendCommandUsage(sender, label);
             return true;
         }
@@ -139,8 +139,9 @@ public class CommandManager {
      * @param args the arguments provided so far
      * @return a list of suggestions
      */
+    @SuppressWarnings("unchecked")
     public List<String> onTabComplete(Sender sender, List<String> args) {
-        final List<MainCommand> mains = mainCommands.stream().filter(m -> m.canUse(sender)).collect(Collectors.toList());
+        final List<MainCommand> mains = mainCommands.stream().filter(m -> m.isAuthorized(sender)).collect(Collectors.toList());
 
         if (args.size() <= 1) {
             if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
@@ -160,7 +161,7 @@ public class CommandManager {
     }
 
     private void registerMainCommand(MainCommand command) {
-        plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
+        plugin.getLog().info("[CommandManager] Registered main command '" + command.getName() + "'");
         mainCommands.add(command);
     }
 
@@ -168,7 +169,7 @@ public class CommandManager {
         Message.INFO_BRIEF.send(sender, plugin.getVersion());
 
         mainCommands.stream()
-                .filter(c -> c.canUse(sender))
+                .filter(c -> c.isAuthorized(sender))
                 .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
     }
 }

common/src/main/java/me/lucko/luckperms/commands/MainCommand.java

@@ -1,27 +1,103 @@
 package me.lucko.luckperms.commands;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.constants.Message;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Getter
-@AllArgsConstructor
-public abstract class MainCommand {
+@RequiredArgsConstructor
+public abstract class MainCommand<T> {
 
+    /**
+     * The name of the main command
+     */
     private final String name;
+
+    /**
+     * The command usage
+     */
     private final String usage;
+
+    /**
+     * How many arguments are required for the command to run
+     */
     private final int requiredArgsLength;
 
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label);
-    protected abstract List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin);
-    public abstract List<? extends SubCommand> getSubCommands();
+    /**
+     * A list of the sub commands under this main command
+     */
+    @Getter
+    private final List<SubCommand<T>> subCommands = new ArrayList<>();
 
+    /**
+     * Called when this main command is ran
+     * @param plugin a link to the main plugin instance
+     * @param sender the sender to executed the command
+     * @param args the stripped arguments given
+     * @param label the command label used
+     */
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < 2) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        Optional<SubCommand<T>> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+
+        if (!o.isPresent()) {
+            Message.COMMAND_NOT_RECOGNISED.send(sender);
+            return;
+        }
+
+        final SubCommand<T> sub = o.get();
+        if (!sub.isAuthorized(sender)) {
+            Message.COMMAND_NO_PERMISSION.send(sender);
+            return;
+        }
+
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        if (sub.getIsArgumentInvalid().test(strippedArgs.size())) {
+            sub.sendUsage(sender, label);
+            return;
+        }
+
+        final String name = args.get(0).toLowerCase();
+        getTarget(name, plugin, sender, t -> sub.execute(plugin, sender, t, strippedArgs, label));
+    }
+
+    /**
+     * Gets the object the command is acting upon, and runs the callback if successful
+     * @param target the name of the object to be looked up
+     * @param plugin a link to the main plugin instance
+     * @param sender the user who send the command (used to send error messages if the lookup was unsuccessful)
+     * @param onSuccess the callback to run when the lookup is completed
+     */
+    protected abstract void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<T> onSuccess);
+
+    /**
+     * Get a list of objects for tab completion
+     * @param plugin a link to the main plugin instance
+     * @return a list of strings
+     */
+    protected abstract List<String> getObjects(LuckPermsPlugin plugin);
+
+    /**
+     * Send the command usage to a sender
+     * @param sender the sender to send the usage to
+     * @param label the command label used
+     */
     protected void sendUsage(Sender sender, String label) {
         if (getSubCommands().isEmpty()) {
             Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
@@ -41,12 +117,27 @@ public abstract class MainCommand {
         }
     }
 
-    protected boolean canUse(Sender sender) {
+    /**
+     * If a sender has permission to use this command
+     * @param sender the sender trying to use the command
+     * @return true if the sender can use the command
+     */
+    protected boolean isAuthorized(Sender sender) {
         return getSubCommands().stream().filter(sc -> sc.isAuthorized(sender)).count() != 0;
     }
 
-    protected List<String> onAbstractTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> objects = getObjects(plugin);
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return objects;
+            }
+
+            return objects.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        final List<SubCommand<T>> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
         if (args.size() == 2) {
             if (args.get(1).equalsIgnoreCase("")) {
                 return subs.stream().map(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
@@ -56,11 +147,15 @@ public abstract class MainCommand {
                     .filter(s -> s.toLowerCase().startsWith(args.get(1).toLowerCase())).collect(Collectors.toList());
         }
 
-        Optional<SubCommand> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+        Optional<SubCommand<T>> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
         if (!o.isPresent()) {
             return Collections.emptyList();
         }
 
         return o.get().onTabComplete(sender, args.subList(2, args.size()), plugin);
     }
+
+    public void registerSubCommand(SubCommand<T> subCommand) {
+        subCommands.add(subCommand);
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/Predicate.java

@@ -0,0 +1,53 @@
+package me.lucko.luckperms.commands;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+@UtilityClass
+public class Predicate {
+    public static <T> java.util.function.Predicate<T> alwaysFalse() {
+        return t -> false;
+    }
+
+    public static <T> java.util.function.Predicate<T> alwaysTrue() {
+        return t -> true;
+    }
+
+    public static java.util.function.Predicate<Integer> notInRange(Integer start, Integer end) {
+        return inverse(inRange(start, end));
+    }
+
+    public static java.util.function.Predicate<Integer> inRange(Integer start, Integer end) {
+        return isOneOf(IntStream.rangeClosed(start, end).boxed().collect(Collectors.toSet()));
+    }
+
+    public static <T> java.util.function.Predicate<T> notOneOf(Set<T> ts) {
+        return inverse(isOneOf(ts));
+    }
+
+    public static <T> java.util.function.Predicate<T> isOneOf(Set<T> ta) {
+        return t -> {
+            for (T i : ta) {
+                if (i == t) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+
+    public static <T> java.util.function.Predicate<T> not(T t) {
+        return inverse(is(t));
+    }
+
+    public static <T> java.util.function.Predicate<T> is(T t) {
+        return t2 -> t == t2;
+    }
+
+    public static <T> java.util.function.Predicate<T> inverse(java.util.function.Predicate<T> t) {
+        return t2 -> !t.test(t2);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/SingleMainCommand.java

@@ -0,0 +1,50 @@
+package me.lucko.luckperms.commands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.constants.Permission;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * An extension of {@link MainCommand} for implementations without any subcommands
+ */
+public class SingleMainCommand extends MainCommand<Object> {
+    private final Permission permission;
+
+    public SingleMainCommand(String name, String usage, int requiredArgsLength, Permission permission) {
+        super(name, usage, requiredArgsLength);
+        this.permission = permission;
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        // Do nothing, allow the implementation to override this
+    }
+
+    @Override
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) {
+        // Do nothing, don't run callback
+    }
+
+    @Override
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand<Object>> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean isAuthorized(Sender sender) {
+        return permission.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/SubCommand.java

@@ -3,49 +3,97 @@ package me.lucko.luckperms.commands;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.users.User;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 /**
  * Abstract SubCommand class
- * Doesn't declare any abstract onCommand methods, as sub classes declare their own with parameters unique to the sub command type.
- * For example, see: {@link me.lucko.luckperms.commands.user.UserSubCommand#execute(LuckPermsPlugin, Sender, User, List, String)}
- *
- * SubCommand #execute methods are always called from the {@link MainCommand} class related to them, so abstraction is not needed.
  */
 @Getter
 @AllArgsConstructor
-public abstract class SubCommand {
+public abstract class SubCommand<T> {
+
+    /**
+     * The name of the sub command
+     */
     private final String name;
+
+    /**
+     * A brief description of what the sub command does
+     */
     private final String description;
+
+    /**
+     * The command usage
+     */
     private final String usage;
+
+    /**
+     * The permission needed to use this command
+     */
     private final Permission permission;
 
-    public abstract boolean isArgLengthInvalid(int argLength);
+    /**
+     * Predicate to test if the argument length given is invalid
+     */
+    private final Predicate<? super Integer> isArgumentInvalid;
 
-    public boolean isAuthorized(Sender sender) {
-        return permission.isAuthorized(sender);
-    }
+    /**
+     * Called when this sub command is ran
+     * @param plugin a link to the main plugin instance
+     * @param sender the sender to executed the command
+     * @param t the object the command is operating on
+     * @param args the stripped arguments given
+     * @param label the command label used
+     */
+    public abstract void execute(LuckPermsPlugin plugin, Sender sender, T t, List<String> args, String label);
 
+    /**
+     * Send the command usage to a sender
+     * @param sender the sender to send the usage to
+     * @param label the command label used
+     */
     public void sendUsage(Sender sender, String label) {
         Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
     }
 
+    /**
+     * If a sender has permission to use this command
+     * @param sender the sender trying to use the command
+     * @return true if the sender can use the command
+     */
+    public boolean isAuthorized(Sender sender) {
+        return permission.isAuthorized(sender);
+    }
+
     /**
      * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override
      * this method to give their own list.
+     * @param sender who is tab completing
+     * @param args the arguments so far
+     * @param plugin the plugin instance
+     * @return a list of suggestions
      */
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return Collections.emptyList();
     }
 
-    /* Utility methods used by #onTabComplete implementations in sub classes  */
+    /*
+        ----------------------------------------------------------------------------------
+        Utility methods used by #onTabComplete and #execute implementations in sub classes
+        ----------------------------------------------------------------------------------
+     */
+
     protected static List<String> getGroupTabComplete(List<String> args, LuckPermsPlugin plugin) {
         return getTabComplete(new ArrayList<>(plugin.getGroupManager().getGroups().keySet()), args);
     }
@@ -73,4 +121,40 @@ public abstract class SubCommand {
 
         return Collections.emptyList();
     }
+
+    protected static void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
+        user.refreshPermissions();
+
+        plugin.getDatastore().saveUser(user, success -> {
+            if (success) {
+                Message.USER_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.USER_SAVE_ERROR.send(sender);
+            }
+        });
+    }
+
+    protected static void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveGroup(group, success -> {
+            if (success) {
+                Message.GROUP_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.GROUP_SAVE_ERROR.send(sender);
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
+
+    protected static void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveTrack(track, success -> {
+            if (success) {
+                Message.TRACK_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.TRACK_SAVE_ERROR.send(sender);
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java

@@ -1,19 +1,17 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.utils.Patterns;
 
-import java.util.Collections;
 import java.util.List;
 
-public class CreateGroup extends MainCommand {
+public class CreateGroup extends SingleMainCommand {
     public CreateGroup() {
-        super("CreateGroup", "/%s creategroup <group>", 1);
+        super("CreateGroup", "/%s creategroup <group>", 1, Permission.CREATE_GROUP);
     }
 
     @Override
@@ -50,19 +48,4 @@ public class CreateGroup extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.CREATE_GROUP.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java

@@ -1,9 +1,8 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -14,9 +13,9 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class DeleteGroup extends MainCommand {
+public class DeleteGroup extends SingleMainCommand {
     public DeleteGroup() {
-        super("DeleteGroup", "/%s deletegroup <group>", 1);
+        super("DeleteGroup", "/%s deletegroup <group>", 1, Permission.DELETE_GROUP);
     }
 
     @Override
@@ -74,14 +73,4 @@ public class DeleteGroup extends MainCommand {
 
         return Collections.emptyList();
     }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.DELETE_GROUP.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java

@@ -1,101 +1,46 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.Patterns;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-public class GroupMainCommand extends MainCommand {
-
-    private final List<GroupSubCommand> subCommands = new ArrayList<>();
 
+public class GroupMainCommand extends MainCommand<Group> {
     public GroupMainCommand() {
         super("Group", "/%s group <group>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
-            sendUsage(sender, label);
-            return;
-        }
-
-        Optional<GroupSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
-
-        if (!o.isPresent()) {
-            Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
-        }
-
-        final GroupSubCommand sub = o.get();
-        if (!sub.isAuthorized(sender)) {
-            Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
-        }
-
-        List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
-        }
-
-        if (sub.isArgLengthInvalid(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
-            return;
-        }
-
-        final String groupName = args.get(0).toLowerCase();
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<Group> onSuccess) {
+        if (Patterns.NON_ALPHA_NUMERIC.matcher(target).find()) {
             Message.GROUP_INVALID_ENTRY.send(sender);
             return;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
+        plugin.getDatastore().loadGroup(target, success -> {
             if (!success) {
                 Message.GROUP_NOT_FOUND.send(sender);
                 return;
             }
 
-            Group group = plugin.getGroupManager().getGroup(groupName);
+            Group group = plugin.getGroupManager().getGroup(target);
             if (group == null) {
                 Message.GROUP_NOT_FOUND.send(sender);
                 return;
             }
 
-            sub.execute(plugin, sender, group, strippedArgs, label);
+            onSuccess.onComplete(group);
         });
     }
 
     @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> groups = new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return groups;
-            }
-
-            return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return onAbstractTabComplete(sender, args, plugin);
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
     }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return subCommands;
-    }
-
-    public void registerSubCommand(GroupSubCommand subCommand) {
-        subCommands.add(subCommand);
-    }
-
 }

common/src/main/java/me/lucko/luckperms/commands/group/GroupSubCommand.java

@@ -1,30 +0,0 @@
-package me.lucko.luckperms.commands.group;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.groups.Group;
-
-import java.util.List;
-
-public abstract class GroupSubCommand extends SubCommand {
-    protected GroupSubCommand(String name, String description, String usage, Permission permission) {
-        super(name, description, usage, permission);
-    }
-
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label);
-
-    protected void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
-        plugin.getDatastore().saveGroup(group, success -> {
-            if (success) {
-                Message.GROUP_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.GROUP_SAVE_ERROR.send(sender);
-            }
-
-            plugin.runUpdateTask();
-        });
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java

@@ -1,20 +1,18 @@
 package me.lucko.luckperms.commands.group;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
-public class ListGroups extends MainCommand {
+public class ListGroups extends SingleMainCommand {
     public ListGroups() {
-        super("ListGroups", "/%s listgroups", 0);
+        super("ListGroups", "/%s listgroups", 0, Permission.LIST_GROUPS);
     }
 
     @Override
@@ -27,19 +25,4 @@ public class ListGroups extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.LIST_GROUPS.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java

@@ -1,29 +1,26 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupClear extends GroupSubCommand {
+public class GroupClear extends SubCommand<Group> {
     public GroupClear() {
-        super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR);
+        super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         group.clearNodes();
         Message.CLEAR_SUCCESS.send(sender, group.getName());
 
         saveGroup(group, sender, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -11,28 +12,29 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupHasPerm extends GroupSubCommand {
+public class GroupHasPerm extends SubCommand<Group> {
     public GroupHasPerm() {
         super("haspermission", "Checks to see if a group has a certain permission node",
-                "/%s group <group> haspermission <node> [server]", Permission.GROUP_HASPERMISSION);
+                "/%s group <group> haspermission <node> [server] [world]", Permission.GROUP_HASPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        if (args.size() == 2) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
                 return;
             }
 
-            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1).toLowerCase()));
+            if (args.size() == 2) {
+                Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1)));
+            } else {
+                Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1), args.get(2)));
+            }
+
         } else {
             Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java

@@ -1,27 +1,24 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupInfo extends GroupSubCommand {
+public class GroupInfo extends SubCommand<Group> {
     public GroupInfo() {
-        super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO);
+        super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         Message.GROUP_INFO.send(sender, group.getName(), group.getPermanentNodes().keySet().size(),
                 group.getTemporaryNodes().keySet().size(), label, group.getName());
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -11,28 +12,29 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupInheritsPerm extends GroupSubCommand {
+public class GroupInheritsPerm extends SubCommand<Group> {
     public GroupInheritsPerm() {
         super("inheritspermission", "Checks to see if a group inherits a certain permission node",
-                "/%s group <group> inheritspermission <node> [server]", Permission.GROUP_INHERITSPERMISSION);
+                "/%s group <group> inheritspermission <node> [server] [world]", Permission.GROUP_INHERITSPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        if (args.size() == 2) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
                 return;
             }
 
-            Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1).toLowerCase()));
+            if (args.size() == 2) {
+                Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1)));
+            } else {
+                Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1), args.get(2)));
+            }
+
         } else {
             Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java

@@ -1,29 +1,25 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupListNodes extends GroupSubCommand {
+public class GroupListNodes extends SubCommand<Group> {
     public GroupListNodes() {
         super("listnodes", "Lists the permission nodes the group has", "/%s group <group> listnodes",
-                Permission.GROUP_LISTNODES);
+                Permission.GROUP_LISTNODES, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermanentNodes()));
         Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodes()));
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetInherit extends GroupSubCommand {
+public class GroupSetInherit extends SubCommand<Group> {
     public GroupSetInherit() {
         super("setinherit", "Sets another group for this group to inherit permissions from",
-                "/%s group <group> setinherit <group> [server]", Permission.GROUP_SETINHERIT);
+                "/%s group <group> setinherit <group> [server] [world]", Permission.GROUP_SETINHERIT,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -31,15 +33,22 @@ public class GroupSetInherit extends GroupSubCommand {
                 Message.GROUP_LOAD_ERROR.send(sender);
             } else {
                 try {
-                    if (args.size() == 2) {
+                    if (args.size() >= 2) {
                         final String server = args.get(1).toLowerCase();
                         if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                             Message.SERVER_INVALID_ENTRY.send(sender);
                             return;
                         }
 
-                        group.setPermission("group." + groupName, true, server);
-                        Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                        if (args.size() == 2) {
+                            group.setPermission("group." + groupName, true, server);
+                            Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                        } else {
+                            final String world = args.get(2).toLowerCase();
+                            group.setPermission("group." + groupName, true, server, world);
+                            Message.GROUP_SETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
+                        }
+
                     } else {
                         group.setPermission("group." + groupName, true);
                         Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
@@ -57,9 +66,4 @@ public class GroupSetInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetPermission extends GroupSubCommand {
+public class GroupSetPermission extends SubCommand<Group> {
     public GroupSetPermission() {
-        super("set", "Sets a permission for a group", "/%s group <group> set <node> <true|false> [server]",
-                Permission.GROUP_SETPERMISSION);
+        super("set", "Sets a permission for a group", "/%s group <group> set <node> <true|false> [server] [world]",
+                Permission.GROUP_SETPERMISSION, Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -40,15 +41,22 @@ public class GroupSetPermission extends GroupSubCommand {
         boolean b = Boolean.parseBoolean(bool);
 
         try {
-            if (args.size() == 3) {
+            if (args.size() >= 3) {
                 final String server = args.get(2).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                group.setPermission(node, b, server);
-                Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
+                if (args.size() == 3) {
+                    group.setPermission(node, b, server);
+                    Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
+                } else {
+                    final String world = args.get(3).toLowerCase();
+                    group.setPermission(node, b, server, world);
+                    Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server, world);
+                }
+
             } else {
                 group.setPermission(node, b);
                 Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
@@ -64,9 +72,4 @@ public class GroupSetPermission extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2 && argLength != 3;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetTempInherit extends GroupSubCommand {
+public class GroupSetTempInherit extends SubCommand<Group> {
     public GroupSetTempInherit() {
         super("settempinherit", "Sets another group for this group to inherit permissions from temporarily",
-                "/%s group <group> settempinherit <group> <duration> [server]", Permission.GROUP_SET_TEMP_INHERIT);
+                "/%s group <group> settempinherit <group> <duration> [server] [world]",
+                Permission.GROUP_SET_TEMP_INHERIT, Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -45,16 +47,24 @@ public class GroupSetTempInherit extends GroupSubCommand {
                 Message.GROUP_LOAD_ERROR.send(sender);
             } else {
                 try {
-                    if (args.size() == 3) {
+                    if (args.size() >= 3) {
                         final String server = args.get(2).toLowerCase();
                         if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                             Message.SERVER_INVALID_ENTRY.send(sender);
                             return;
                         }
 
-                        group.setPermission("group." + groupName, true, server, duration);
-                        Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server,
-                                DateUtil.formatDateDiff(duration));
+                        if (args.size() == 3) {
+                            group.setPermission("group." + groupName, true, server, duration);
+                            Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server,
+                                    DateUtil.formatDateDiff(duration));
+                        } else {
+                            final String world = args.get(3).toLowerCase();
+                            group.setPermission("group." + groupName, true, server, world, duration);
+                            Message.GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server,
+                                    world, DateUtil.formatDateDiff(duration));
+                        }
+
                     } else {
                         group.setPermission("group." + groupName, true, duration);
                         Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName, DateUtil.formatDateDiff(duration));
@@ -72,9 +82,4 @@ public class GroupSetTempInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2 && argLength != 3;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupSetTempPermission extends GroupSubCommand {
+public class GroupSetTempPermission extends SubCommand<Group> {
     public GroupSetTempPermission() {
-        super("settemp", "Sets a temporary permission for a group", "/%s group <group> settemp <node> <true|false> <duration> [server]",
-                Permission.GROUP_SET_TEMP_PERMISSION);
+        super("settemp", "Sets a temporary permission for a group",
+                "/%s group <group> settemp <node> <true|false> <duration> [server] [world]",
+                Permission.GROUP_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -54,15 +56,24 @@ public class GroupSetTempPermission extends GroupSubCommand {
         }
 
         try {
-            if (args.size() == 4) {
+            if (args.size() >= 4) {
                 final String server = args.get(3).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                group.setPermission(node, b, server, duration);
-                Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server, DateUtil.formatDateDiff(duration));
+                if (args.size() == 4) {
+                    group.setPermission(node, b, server, duration);
+                    Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server,
+                            DateUtil.formatDateDiff(duration));
+                } else {
+                    final String world = args.get(4).toLowerCase();
+                    group.setPermission(node, b, server, world, duration);
+                    Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server,
+                            world, DateUtil.formatDateDiff(duration));
+                }
+
             } else {
                 group.setPermission(node, b, duration);
                 Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
@@ -78,9 +89,4 @@ public class GroupSetTempPermission extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 3 && argLength != 4;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -12,13 +13,14 @@ import me.lucko.luckperms.tracks.Track;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class GroupShowTracks extends GroupSubCommand {
+public class GroupShowTracks extends SubCommand<Group> {
     public GroupShowTracks() {
-        super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks", Permission.GROUP_SHOWTRACKS);
+        super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks",
+                Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         plugin.getDatastore().loadAllTracks(success -> {
             if (!success) {
                 Message.TRACKS_LOAD_ERROR.send(sender);
@@ -29,9 +31,4 @@ public class GroupShowTracks extends GroupSubCommand {
                     plugin.getTrackManager().getApplicableTracks(group.getName()).stream().map(Track::getName).collect(Collectors.toList())));
         });
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnSetPermission extends GroupSubCommand {
+public class GroupUnSetPermission extends SubCommand<Group> {
     public GroupUnSetPermission() {
-        super("unset", "Unsets a permission for a group",
-                "/%s group <group> unset <node> [server]", Permission.GROUP_UNSETPERMISSION);
+        super("unset", "Unsets a permission for a group", "/%s group <group> unset <node> [server] [world]",
+                Permission.GROUP_UNSETPERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -32,15 +33,22 @@ public class GroupUnSetPermission extends GroupSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                group.unsetPermission(node, server);
-                Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                if (args.size() == 2) {
+                    group.unsetPermission(node, server);
+                    Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    group.unsetPermission(node, server, world);
+                    Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
+                }
+
             } else {
                 group.unsetPermission(node);
                 Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
@@ -51,9 +59,4 @@ public class GroupUnSetPermission extends GroupSubCommand {
             Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnsetInherit extends GroupSubCommand {
+public class GroupUnsetInherit extends SubCommand<Group> {
     public GroupUnsetInherit() {
         super("unsetinherit", "Unsets another group for this group to inherit permissions from",
-                "/%s group <group> unsetinherit <group> [server]", Permission.GROUP_UNSETINHERIT);
+                "/%s group <group> unsetinherit <group> [server] [world]", Permission.GROUP_UNSETINHERIT,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -27,15 +29,22 @@ public class GroupUnsetInherit extends GroupSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                group.unsetPermission("group." + groupName, server);
-                Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                if (args.size() == 2) {
+                    group.unsetPermission("group." + groupName, server);
+                    Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    group.unsetPermission("group." + groupName, server, world);
+                    Message.GROUP_UNSETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
+                }
+
             } else {
                 group.unsetPermission("group." + groupName);
                 Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
@@ -51,9 +60,4 @@ public class GroupUnsetInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnsetTempInherit extends GroupSubCommand {
+public class GroupUnsetTempInherit extends SubCommand<Group> {
     public GroupUnsetTempInherit() {
         super("unsettempinherit", "Unsets another group for this group to inherit permissions from",
-                "/%s group <group> unsettempinherit <group> [server]", Permission.GROUP_UNSET_TEMP_INHERIT);
+                "/%s group <group> unsettempinherit <group> [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -27,15 +29,22 @@ public class GroupUnsetTempInherit extends GroupSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                group.unsetPermission("group." + groupName, server, true);
-                Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                if (args.size() == 2) {
+                    group.unsetPermission("group." + groupName, server, true);
+                    Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    group.unsetPermission("group." + groupName, server, world, true);
+                    Message.GROUP_UNSET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
+                }
+
             } else {
                 group.unsetPermission("group." + groupName, true);
                 Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
@@ -51,9 +60,4 @@ public class GroupUnsetTempInherit extends GroupSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class GroupUnsetTempPermission extends GroupSubCommand {
+public class GroupUnsetTempPermission extends SubCommand<Group> {
     public GroupUnsetTempPermission() {
         super("unsettemp", "Unsets a temporary permission for a group",
-                "/%s group <group> unsettemp <node> [server]", Permission.GROUP_UNSET_TEMP_PERMISSION);
+                "/%s group <group> unsettemp <node> [server] [world]", Permission.GROUP_UNSET_TEMP_PERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -32,15 +34,22 @@ public class GroupUnsetTempPermission extends GroupSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                group.unsetPermission(node, server);
-                Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server, true);
+                if (args.size() == 2) {
+                    group.unsetPermission(node, server);
+                    Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    group.unsetPermission(node, server, world);
+                    Message.UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
+                }
+
             } else {
                 group.unsetPermission(node, true);
                 Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
@@ -51,9 +60,4 @@ public class GroupUnsetTempPermission extends GroupSubCommand {
             Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/misc/DebugCommand.java

@@ -1,18 +1,16 @@
 package me.lucko.luckperms.commands.misc;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 
-import java.util.Collections;
 import java.util.List;
 
-public class DebugCommand extends MainCommand {
+public class DebugCommand extends SingleMainCommand {
     public DebugCommand() {
-        super("Debug", "/%s debug", 0);
+        super("Debug", "/%s debug", 0, Permission.DEBUG);
     }
 
     @Override
@@ -21,19 +19,4 @@ public class DebugCommand extends MainCommand {
                 plugin.getGroupManager().getGroups().size(), plugin.getTrackManager().getTracks().size()
         );
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.DEBUG.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java

@@ -1,40 +1,23 @@
 package me.lucko.luckperms.commands.misc;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.utils.LPConfiguration;
 
-import java.util.Collections;
 import java.util.List;
 
-public class InfoCommand extends MainCommand {
+public class InfoCommand extends SingleMainCommand {
     public InfoCommand() {
-        super("Info", "/%s info", 0);
+        super("Info", "/%s info", 0, Permission.INFO);
     }
 
     @Override
     protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         final LPConfiguration c = plugin.getConfiguration();
         Message.INFO.send(sender, plugin.getVersion(), plugin.getDatastore().getName(), c.getServer(),
-                c.getDefaultGroupName(), c.getSyncTime(), c.getIncludeGlobalPerms());
-    }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.INFO.isAuthorized(sender);
+                c.getDefaultGroupName(), c.getSyncTime(), c.getIncludeGlobalPerms(), c.getOnlineMode());
     }
 }

common/src/main/java/me/lucko/luckperms/commands/misc/SyncCommand.java

@@ -1,18 +1,16 @@
 package me.lucko.luckperms.commands.misc;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 
-import java.util.Collections;
 import java.util.List;
 
-public class SyncCommand extends MainCommand {
+public class SyncCommand extends SingleMainCommand {
     public SyncCommand() {
-        super("Sync", "/%s sync", 0);
+        super("Sync", "/%s sync", 0, Permission.SYNC);
     }
 
     @Override
@@ -20,19 +18,4 @@ public class SyncCommand extends MainCommand {
         Message.UPDATE_TASK_RUN.send(sender);
         plugin.runUpdateTask();
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.SYNC.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java

@@ -1,19 +1,17 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.utils.Patterns;
 
-import java.util.Collections;
 import java.util.List;
 
-public class CreateTrack extends MainCommand {
+public class CreateTrack extends SingleMainCommand {
     public CreateTrack() {
-        super("CreateTrack", "/%s createtrack <track>", 1);
+        super("CreateTrack", "/%s createtrack <track>", 1, Permission.CREATE_TRACK);
     }
 
     @Override
@@ -50,19 +48,4 @@ public class CreateTrack extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.CREATE_TRACK.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java

@@ -1,9 +1,8 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -14,9 +13,9 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class DeleteTrack extends MainCommand {
+public class DeleteTrack extends SingleMainCommand {
     public DeleteTrack() {
-        super("DeleteTrack", "/%s deletetrack <track>", 1);
+        super("DeleteTrack", "/%s deletetrack <track>", 1, Permission.DELETE_TRACK);
     }
 
     @Override
@@ -69,14 +68,4 @@ public class DeleteTrack extends MainCommand {
 
         return Collections.emptyList();
     }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.DELETE_TRACK.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java

@@ -1,20 +1,18 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
-public class ListTracks extends MainCommand {
+public class ListTracks extends SingleMainCommand {
     public ListTracks() {
-        super("ListTracks", "/%s listtracks", 0);
+        super("ListTracks", "/%s listtracks", 0, Permission.LIST_TRACKS);
     }
 
     @Override
@@ -27,19 +25,4 @@ public class ListTracks extends MainCommand {
             }
         });
     }
-
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<SubCommand> getSubCommands() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected boolean canUse(Sender sender) {
-        return Permission.LIST_TRACKS.isAuthorized(sender);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java

@@ -1,101 +1,40 @@
 package me.lucko.luckperms.commands.track;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.tracks.Track;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-public class TrackMainCommand extends MainCommand {
-
-    private final List<TrackSubCommand> subCommands = new ArrayList<>();
 
+public class TrackMainCommand extends MainCommand<Track> {
     public TrackMainCommand() {
         super("Track", "/%s track <track>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
-            sendUsage(sender, label);
-            return;
-        }
-
-        Optional<TrackSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
-
-        if (!o.isPresent()) {
-            Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
-        }
-
-        final TrackSubCommand sub = o.get();
-        if (!sub.isAuthorized(sender)) {
-            Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
-        }
-
-        List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
-        }
-
-        if (sub.isArgLengthInvalid(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
-            return;
-        }
-
-        final String trackName = args.get(0).toLowerCase();
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
-            Message.TRACK_INVALID_ENTRY.send(sender);
-            return;
-        }
-
-        plugin.getDatastore().loadTrack(trackName, success -> {
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<Track> onSuccess) {
+        plugin.getDatastore().loadTrack(target, success -> {
             if (!success) {
                 Message.TRACK_NOT_FOUND.send(sender);
                 return;
             }
 
-            Track track = plugin.getTrackManager().getTrack(trackName);
+            Track track = plugin.getTrackManager().getTrack(target);
             if (track == null) {
                 Message.TRACK_NOT_FOUND.send(sender);
                 return;
             }
 
-            sub.execute(plugin, sender, track, strippedArgs, label);
+            onSuccess.onComplete(track);
         });
     }
 
     @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> tracks = new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return tracks;
-            }
-
-            return tracks.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return onAbstractTabComplete(sender, args, plugin);
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
     }
-
-    @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return subCommands;
-    }
-
-    public void registerSubCommand(TrackSubCommand subCommand) {
-        subCommands.add(subCommand);
-    }
-
 }

common/src/main/java/me/lucko/luckperms/commands/track/TrackSubCommand.java

@@ -1,30 +0,0 @@
-package me.lucko.luckperms.commands.track;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.tracks.Track;
-
-import java.util.List;
-
-public abstract class TrackSubCommand extends SubCommand {
-    public TrackSubCommand(String name, String description, String usage, Permission permission) {
-        super(name, description, usage, permission);
-    }
-
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label);
-
-    protected void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) {
-        plugin.getDatastore().saveTrack(track, success -> {
-            if (success) {
-                Message.TRACK_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.TRACK_SAVE_ERROR.send(sender);
-            }
-
-            plugin.runUpdateTask();
-        });
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,13 +13,14 @@ import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackAppend extends TrackSubCommand {
+public class TrackAppend extends SubCommand<Track> {
     public TrackAppend() {
-        super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>", Permission.TRACK_APPEND);
+        super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>",
+                Permission.TRACK_APPEND, Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadGroup(groupName, success -> {
@@ -47,9 +49,4 @@ public class TrackAppend extends TrackSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java

@@ -1,28 +1,25 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackClear extends TrackSubCommand {
+public class TrackClear extends SubCommand<Track> {
     public TrackClear() {
-        super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR);
+        super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         track.clearGroups();
         Message.TRACK_CLEAR.send(sender, track.getName());
         saveTrack(track, sender, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java

@@ -1,27 +1,24 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackInfo extends TrackSubCommand {
+public class TrackInfo extends SubCommand<Track> {
     public TrackInfo() {
-        super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO);
+        super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         Message.TRACK_INFO.send(sender, track.getName(), Util.listToArrowSep(track.getGroups()));
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,14 @@ import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackInsert extends TrackSubCommand {
+public class TrackInsert extends SubCommand<Track> {
     public TrackInsert() {
         super("insert", "Inserts a group at a given position along the track",
-                "/%s track <track> insert <group> <position>", Permission.TRACK_INSERT);
+                "/%s track <track> insert <group> <position>", Permission.TRACK_INSERT, Predicate.not(2));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
         int pos;
         try {
@@ -57,9 +58,4 @@ public class TrackInsert extends TrackSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -10,13 +11,14 @@ import me.lucko.luckperms.tracks.Track;
 
 import java.util.List;
 
-public class TrackRemove extends TrackSubCommand {
+public class TrackRemove extends SubCommand<Track> {
     public TrackRemove() {
-        super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE);
+        super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
         try {
             track.removeGroup(groupName);
@@ -31,9 +33,4 @@ public class TrackRemove extends TrackSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java

@@ -1,104 +1,53 @@
 package me.lucko.luckperms.commands.user;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.Patterns;
 
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
-import java.util.stream.Collectors;
-
-public class UserMainCommand extends MainCommand {
-
-    private final List<UserSubCommand> subCommands = new ArrayList<>();
 
+public class UserMainCommand extends MainCommand<User> {
     public UserMainCommand() {
         super("User", "/%s user <user>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
-            sendUsage(sender, label);
-            return;
-        }
-
-        Optional<UserSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
-
-        if (!o.isPresent()) {
-            Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
-        }
-
-        final UserSubCommand sub = o.get();
-        if (!sub.isAuthorized(sender)) {
-            Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
-        }
-
-        // The arguments to be passed onto the sub command
-        List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
-        }
-
-        if (sub.isArgLengthInvalid(strippedArgs.size())) {
-            sub.sendUsage(sender, label);
-            return;
-        }
-
-        final String user = args.get(0);
-
-        if (Patterns.NON_USERNAME.matcher(user).find()) {
-            Message.USER_INVALID_ENTRY.send(sender, user);
-            return;
-        }
-
-        UUID u = Util.parseUuid(user);
+    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<User> onSuccess) {
+        UUID u = Util.parseUuid(target);
         if (u != null) {
-            runSub(plugin, sender, u, sub, strippedArgs, label);
+            runSub(plugin, sender, u, onSuccess);
             return;
         }
 
-        if (user.length() <= 16) {
+        if (target.length() <= 16) {
+            if (Patterns.NON_USERNAME.matcher(target).find()) {
+                Message.USER_INVALID_ENTRY.send(sender, target);
+                return;
+            }
+
             Message.USER_ATTEMPTING_LOOKUP.send(sender);
 
-            plugin.getDatastore().getUUID(user, uuid -> {
+            plugin.getDatastore().getUUID(target, uuid -> {
                 if (uuid == null) {
                     Message.USER_NOT_FOUND.send(sender);
                     return;
                 }
-                runSub(plugin, sender, uuid, sub, strippedArgs, label);
+
+                runSub(plugin, sender, uuid, onSuccess);
             });
             return;
         }
 
-        Message.USER_INVALID_ENTRY.send(sender, user);
+        Message.USER_INVALID_ENTRY.send(sender, target);
     }
 
-    @Override
-    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> onlinePlayers = plugin.getPlayerList();
-
-        if (args.size() <= 1) {
-            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return onlinePlayers;
-            }
-
-            return onlinePlayers.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
-        }
-
-        return onAbstractTabComplete(sender, args, plugin);
-    }
-
-    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List<String> strippedArgs, String label) {
+    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, Callback<User> onSuccess) {
         plugin.getDatastore().loadUser(uuid, success -> {
             if (!success) {
                 Message.USER_NOT_FOUND.send(sender);
@@ -108,19 +57,16 @@ public class UserMainCommand extends MainCommand {
             User user = plugin.getUserManager().getUser(uuid);
             if (user == null) {
                 Message.USER_NOT_FOUND.send(sender);
+                return;
             }
 
-            command.execute(plugin, sender, user, strippedArgs, label);
+            onSuccess.onComplete(user);
             plugin.getUserManager().cleanupUser(user);
         });
     }
 
     @Override
-    public List<? extends SubCommand> getSubCommands() {
-        return subCommands;
-    }
-
-    public void registerSubCommand(UserSubCommand subCommand) {
-        subCommands.add(subCommand);
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return plugin.getPlayerList();
     }
 }

common/src/main/java/me/lucko/luckperms/commands/user/UserSubCommand.java

@@ -1,30 +0,0 @@
-package me.lucko.luckperms.commands.user;
-
-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.users.User;
-
-import java.util.List;
-
-public abstract class UserSubCommand extends SubCommand {
-    protected UserSubCommand(String name, String description, String usage, Permission permission) {
-        super(name, description, usage, permission);
-    }
-
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label);
-
-    protected void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
-        user.refreshPermissions();
-
-        plugin.getDatastore().saveUser(user, success -> {
-            if (success) {
-                Message.USER_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.USER_SAVE_ERROR.send(sender);
-            }
-        });
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,13 +13,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserAddGroup extends UserSubCommand {
+public class UserAddGroup extends SubCommand<User> {
     public UserAddGroup() {
-        super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server]", Permission.USER_ADDGROUP);
+        super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server] [world]",
+                Permission.USER_ADDGROUP, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -37,15 +39,22 @@ public class UserAddGroup extends UserSubCommand {
                 }
 
                 try {
-                    if (args.size() == 2) {
+                    if (args.size() >= 2) {
                         final String server = args.get(1).toLowerCase();
                         if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                             Message.SERVER_INVALID_ENTRY.send(sender);
                             return;
                         }
 
-                        user.addGroup(group, server);
-                        Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                        if (args.size() == 2) {
+                            user.addGroup(group, server);
+                            Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                        } else {
+                            final String world = args.get(2).toLowerCase();
+                            user.addGroup(group, server, world);
+                            Message.USER_ADDGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                        }
+
                     } else {
                         user.addGroup(group);
                         Message.USER_ADDGROUP_SUCCESS.send(sender, user.getName(), groupName);
@@ -63,9 +72,4 @@ public class UserAddGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 1 && argLength != 2);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -13,14 +14,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserAddTempGroup extends UserSubCommand {
+public class UserAddTempGroup extends SubCommand<User> {
     public UserAddTempGroup() {
-        super("addtempgroup", "Adds the user to a group temporarily", "/%s user <user> addtempgroup <group> <duration> [server]",
-                Permission.USER_ADDTEMPGROUP);
+        super("addtempgroup", "Adds the user to a group temporarily",
+                "/%s user <user> addtempgroup <group> <duration> [server] [world]", Permission.USER_ADDTEMPGROUP,
+                Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -52,16 +54,24 @@ public class UserAddTempGroup extends UserSubCommand {
                 }
 
                 try {
-                    if (args.size() == 3) {
+                    if (args.size() >= 3) {
                         final String server = args.get(2).toLowerCase();
                         if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                             Message.SERVER_INVALID_ENTRY.send(sender);
                             return;
                         }
 
-                        user.addGroup(group, server, duration);
-                        Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
-                                DateUtil.formatDateDiff(duration));
+                        if (args.size() == 3) {
+                            user.addGroup(group, server, duration);
+                            Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
+                                    DateUtil.formatDateDiff(duration));
+                        } else {
+                            final String world = args.get(3).toLowerCase();
+                            user.addGroup(group, server, world, duration);
+                            Message.USER_ADDTEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server,
+                                    world, DateUtil.formatDateDiff(duration));
+                        }
+
                     } else {
                         user.addGroup(group, duration);
                         Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), groupName, DateUtil.formatDateDiff(duration));
@@ -79,9 +89,4 @@ public class UserAddTempGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 2 && argLength != 3);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserClear.java

@@ -1,30 +1,27 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserClear extends UserSubCommand {
+public class UserClear extends SubCommand<User> {
     public UserClear() {
-        super("clear", "Clears a users permissions and groups", "/%s user <user> clear", Permission.USER_CLEAR);
+        super("clear", "Clears a users permissions and groups", "/%s user <user> clear", Permission.USER_CLEAR,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         user.clearNodes();
         plugin.getUserManager().giveDefaults(user);
         Message.CLEAR_SUCCESS.send(sender, user.getName());
 
         saveUser(user, sender, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserDemote.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -14,13 +15,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserDemote extends UserSubCommand {
+public class UserDemote extends SubCommand<User> {
     public UserDemote() {
-        super("demote", "Demotes a user along a track", "/%s user <user> demote <track>", Permission.USER_DEMOTE);
+        super("demote", "Demotes a user along a track", "/%s user <user> demote <track>", Permission.USER_DEMOTE,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         final String trackName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadTrack(trackName, success -> {
@@ -85,9 +87,4 @@ public class UserDemote extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getTrackTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserGetUUID.java

@@ -1,26 +1,23 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserGetUUID extends UserSubCommand {
+public class UserGetUUID extends SubCommand<User> {
     public UserGetUUID() {
-        super("getuuid", "Get the UUID of a user", "/%s user <user> getuuid", Permission.USER_GETUUID);
+        super("getuuid", "Get the UUID of a user", "/%s user <user> getuuid", Permission.USER_GETUUID,
+                Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Message.USER_GETUUID.send(sender, user.getName(), user.getUuid().toString());
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserHasPerm.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
@@ -11,28 +12,29 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserHasPerm extends UserSubCommand {
+public class UserHasPerm extends SubCommand<User> {
     public UserHasPerm() {
         super("haspermission", "Checks to see if a user has a certain permission node",
-                "/%s user <user> haspermission <node> [server]", Permission.USER_HASPERMISSION);
+                "/%s user <user> haspermission <node> [server] [world]", Permission.USER_HASPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
                 return;
             }
 
-            Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1)));
+            if (args.size() == 2) {
+                Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1)));
+            } else {
+                Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1), args.get(2)));
+            }
+
         } else {
             Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global"));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfo.java

@@ -1,30 +1,26 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserInfo extends UserSubCommand {
+public class UserInfo extends SubCommand<User> {
     public UserInfo() {
-        super("info", "Gives info about the user", "/%s user <user> info", Permission.USER_INFO);
+        super("info", "Gives info about the user", "/%s user <user> info", Permission.USER_INFO, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Message.USER_INFO.send(sender, user.getName(), user.getUuid(), plugin.getPlayerStatus(user.getUuid()),
                 Util.listToCommaSep(user.getGroupNames()), user.getPrimaryGroup(),
                 user.getPermanentNodes().keySet().size(), user.getTemporaryNodes().keySet().size(), label, user.getName()
         );
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInheritsPerm.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
@@ -11,28 +12,29 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserInheritsPerm extends UserSubCommand {
+public class UserInheritsPerm extends SubCommand<User> {
     public UserInheritsPerm() {
         super("inheritspermission", "Checks to see if a user inherits a certain permission node",
-                "/%s user <user> inheritspermission <node> [server]", Permission.USER_INHERITSPERMISSION);
+                "/%s user <user> inheritspermission <node> [server] [world]", Permission.USER_INHERITSPERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         if (args.size() >= 2) {
             if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
                 return;
             }
 
-            Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1)));
+            if (args.size() == 2) {
+                Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1)));
+            } else {
+                Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1), args.get(2)));
+            }
+
         } else {
             Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true));
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserListNodes.java

@@ -1,28 +1,25 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserListNodes extends UserSubCommand {
+public class UserListNodes extends SubCommand<User> {
     public UserListNodes() {
-        super("listnodes", "Lists the permission nodes the user has", "/%s user <user> listnodes", Permission.USER_LISTNODES);
+        super("listnodes", "Lists the permission nodes the user has", "/%s user <user> listnodes",
+                Permission.USER_LISTNODES, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Message.LISTNODES.send(sender, user.getName(), Util.permNodesToString(user.getPermanentNodes()));
         Message.LISTNODES_TEMP.send(sender, user.getName(), Util.tempNodesToString(user.getTemporaryNodes()));
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserPromote.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -14,13 +15,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserPromote extends UserSubCommand {
+public class UserPromote extends SubCommand<User> {
     public UserPromote() {
-        super("promote", "Promotes the user along a track", "/%s user <user> promote <track>", Permission.USER_PROMOTE);
+        super("promote", "Promotes the user along a track", "/%s user <user> promote <track>", Permission.USER_PROMOTE,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         final String trackName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadTrack(trackName, success -> {
@@ -85,9 +87,4 @@ public class UserPromote extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getTrackTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroup.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,13 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserRemoveGroup extends UserSubCommand {
+public class UserRemoveGroup extends SubCommand<User> {
     public UserRemoveGroup() {
-        super("removegroup", "Removes a user from a group", "/%s user <user> removegroup <group> [server]", Permission.USER_REMOVEGROUP);
+        super("removegroup", "Removes a user from a group", "/%s user <user> removegroup <group> [server] [world]",
+                Permission.USER_REMOVEGROUP, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -32,15 +34,22 @@ public class UserRemoveGroup extends UserSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                user.unsetPermission("group." + groupName, server);
-                Message.USER_REMOVEGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                if (args.size() == 2) {
+                    user.unsetPermission("group." + groupName, server);
+                    Message.USER_REMOVEGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    user.unsetPermission("group." + groupName, server, world);
+                    Message.USER_REMOVEGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                }
+
             } else {
                 user.unsetPermission("group." + groupName);
                 Message.USER_REMOVEGROUP_SUCCESS.send(sender, user.getName(), groupName);
@@ -56,9 +65,4 @@ public class UserRemoveGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 1 && argLength != 2);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempGroup.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,13 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserRemoveTempGroup extends UserSubCommand {
+public class UserRemoveTempGroup extends SubCommand<User> {
     public UserRemoveTempGroup() {
-        super("removetempgroup", "Removes a user from a temporary group", "/%s user <user> removetempgroup <group> [server]", Permission.USER_REMOVETEMPGROUP);
+        super("removetempgroup", "Removes a user from a temporary group",
+                "/%s user <user> removetempgroup <group> [server] [world]", Permission.USER_REMOVETEMPGROUP,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.contains("/") || groupName.contains("$")) {
@@ -26,15 +29,22 @@ public class UserRemoveTempGroup extends UserSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                user.unsetPermission("group." + groupName, server, true);
-                Message.USER_REMOVETEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                if (args.size() == 2) {
+                    user.unsetPermission("group." + groupName, server, true);
+                    Message.USER_REMOVETEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    user.unsetPermission("group." + groupName, server, world, true);
+                    Message.USER_REMOVETEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                }
+
             } else {
                 user.unsetPermission("group." + groupName, true);
                 Message.USER_REMOVETEMPGROUP_SUCCESS.send(sender, user.getName(), groupName);
@@ -50,9 +60,4 @@ public class UserRemoveTempGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return (argLength != 1 && argLength != 2);
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserSetPermission extends UserSubCommand {
+public class UserSetPermission extends SubCommand<User> {
     public UserSetPermission() {
         super("set", "Sets a permission for a user",
-                "/%s user <user> set <node> <true|false> [server]", Permission.USER_SETPERMISSION);
+                "/%s user <user> set <node> <true|false> [server] [world]", Permission.USER_SETPERMISSION,
+                Predicate.notInRange(2, 4));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -40,15 +42,22 @@ public class UserSetPermission extends UserSubCommand {
         boolean b = Boolean.parseBoolean(bool);
 
         try {
-            if (args.size() == 3) {
+            if (args.size() >= 3) {
                 final String server = args.get(2).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                user.setPermission(node, b, server);
-                Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server);
+                if (args.size() == 3) {
+                    user.setPermission(node, b, server);
+                    Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server);
+                } else {
+                    final String world = args.get(3).toLowerCase();
+                    user.setPermission(node, b, server, world);
+                    Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, user.getName(), server, world);
+                }
+
             } else {
                 user.setPermission(node, b);
                 Message.SETPERMISSION_SUCCESS.send(sender, node, bool, user.getName());
@@ -64,9 +73,4 @@ public class UserSetPermission extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 2 && argLength != 3;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPrimaryGroup.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -10,14 +11,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserSetPrimaryGroup extends UserSubCommand {
+public class UserSetPrimaryGroup extends SubCommand<User> {
     public UserSetPrimaryGroup() {
         super("setprimarygroup", "Sets a users primary group",
-                "/%s user <user> setprimarygroup <group>", Permission.USER_SETPRIMARYGROUP);
+                "/%s user <user> setprimarygroup <group>", Permission.USER_SETPRIMARYGROUP, Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         Group group = plugin.getGroupManager().getGroup(args.get(0).toLowerCase());
         if (group == null) {
             Message.GROUP_DOES_NOT_EXIST.send(sender);
@@ -44,9 +45,4 @@ public class UserSetPrimaryGroup extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getGroupTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetTempPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserSetTempPermission extends UserSubCommand {
+public class UserSetTempPermission extends SubCommand<User> {
     public UserSetTempPermission() {
         super("settemp", "Sets a temporary permission for a user",
-                "/%s user <user> settemp <node> <true|false> <duration> [server]", Permission.USER_SET_TEMP_PERMISSION);
+                "/%s user <user> settemp <node> <true|false> <duration> [server] [world]",
+                Permission.USER_SET_TEMP_PERMISSION, Predicate.notInRange(3, 5));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
@@ -54,15 +56,22 @@ public class UserSetTempPermission extends UserSubCommand {
         }
 
         try {
-            if (args.size() == 4) {
+            if (args.size() >= 4) {
                 final String server = args.get(3).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                user.setPermission(node, b, server, duration);
-                Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server, DateUtil.formatDateDiff(duration));
+                if (args.size() == 4) {
+                    user.setPermission(node, b, server, duration);
+                    Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server, DateUtil.formatDateDiff(duration));
+                } else {
+                    final String world = args.get(4).toLowerCase();
+                    user.setPermission(node, b, server, world, duration);
+                    Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, user.getName(), server, world, DateUtil.formatDateDiff(duration));
+                }
+
             } else {
                 user.setPermission(node, b, duration);
                 Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, user.getName(), DateUtil.formatDateDiff(duration));
@@ -78,9 +87,4 @@ public class UserSetTempPermission extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getBoolTabComplete(args);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 3 && argLength != 4;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowPos.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -11,13 +12,14 @@ import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserShowPos extends UserSubCommand {
+public class UserShowPos extends SubCommand<User> {
     public UserShowPos() {
-        super("showpos", "Shows a users position on a track", "/%s user <user> showpos <track>", Permission.USER_SHOWPOS);
+        super("showpos", "Shows a users position on a track", "/%s user <user> showpos <track>", Permission.USER_SHOWPOS,
+                Predicate.not(1));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         final String trackName = args.get(0).toLowerCase();
 
         plugin.getDatastore().loadTrack(trackName, success -> {
@@ -49,9 +51,4 @@ public class UserShowPos extends UserSubCommand {
     public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
         return getTrackTabComplete(args, plugin);
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowTracks.java

@@ -1,9 +1,10 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.commands.user.UserSubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -12,14 +13,14 @@ import me.lucko.luckperms.users.User;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class UserShowTracks extends UserSubCommand {
+public class UserShowTracks extends SubCommand<User> {
     public UserShowTracks() {
         super("showtracks", "Lists the tracks that this user's primary group features on", "/%s user <user> showtracks",
-                Permission.USER_SHOWTRACKS);
+                Permission.USER_SHOWTRACKS, Predicate.alwaysFalse());
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         plugin.getDatastore().loadAllTracks(success -> {
             if (!success) {
                 Message.TRACKS_LOAD_ERROR.send(sender);
@@ -31,9 +32,4 @@ public class UserShowTracks extends UserSubCommand {
                     plugin.getTrackManager().getApplicableTracks(user.getPrimaryGroup()).stream().map(Track::getName).collect(Collectors.toList())));
         });
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return false;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserUnSetPermission extends UserSubCommand {
+public class UserUnSetPermission extends SubCommand<User> {
     public UserUnSetPermission() {
         super("unset", "Unsets a permission for a user",
-                "/%s user <user> unset <node> [server]", Permission.USER_UNSETPERMISSION);
+                "/%s user <user> unset <node> [server] [world]", Permission.USER_UNSETPERMISSION, Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -32,15 +33,22 @@ public class UserUnSetPermission extends UserSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                user.unsetPermission(node, server);
-                Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+                if (args.size() == 2) {
+                    user.unsetPermission(node, server);
+                    Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    user.unsetPermission(node, server, world);
+                    Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, user.getName(), server, world);
+                }
+
             } else {
                 user.unsetPermission(node);
                 Message.UNSETPERMISSION_SUCCESS.send(sender, node, user.getName());
@@ -51,9 +59,4 @@ public class UserUnSetPermission extends UserSubCommand {
             Message.DOES_NOT_HAVEPERMISSION.send(sender, user.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnsetTempPermission.java

@@ -1,8 +1,9 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
@@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
-public class UserUnsetTempPermission extends UserSubCommand {
+public class UserUnsetTempPermission extends SubCommand<User> {
     public UserUnsetTempPermission() {
         super("unsettemp", "Unsets a temporary permission for a user",
-                "/%s user <user> unsettemp <node> [server]", Permission.USER_UNSET_TEMP_PERMISSION);
+                "/%s user <user> unsettemp <node> [server] [world]", Permission.USER_UNSET_TEMP_PERMISSION,
+                Predicate.notInRange(1, 3));
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String node = args.get(0);
 
         if (node.contains("/") || node.contains("$")) {
@@ -32,15 +34,22 @@ public class UserUnsetTempPermission extends UserSubCommand {
         }
 
         try {
-            if (args.size() == 2) {
+            if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
                 if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
                     return;
                 }
 
-                user.unsetPermission(node, server, true);
-                Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+                if (args.size() == 2) {
+                    user.unsetPermission(node, server, true);
+                    Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    user.unsetPermission(node, server, world, true);
+                    Message.UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, user.getName(), server, world);
+                }
+
             } else {
                 user.unsetPermission(node, true);
                 Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, user.getName());
@@ -51,9 +60,4 @@ public class UserUnsetTempPermission extends UserSubCommand {
             Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, user.getName());
         }
     }
-
-    @Override
-    public boolean isArgLengthInvalid(int argLength) {
-        return argLength != 1 && argLength != 2;
-    }
 }

common/src/main/java/me/lucko/luckperms/constants/Message.java

@@ -8,7 +8,7 @@ import me.lucko.luckperms.commands.Util;
 @AllArgsConstructor
 public enum Message {
 
-    /**
+    /*
      * General & Commands
      */
     PREFIX("&7&l[&b&lL&a&lP&7&l] &c", false),
@@ -25,7 +25,7 @@ public enum Message {
 
 
 
-    /**
+    /*
      * Loading / Saving
      */
     USER_NOT_FOUND("&eUser could not be found.", true),
@@ -43,7 +43,7 @@ public enum Message {
 
 
 
-    /**
+    /*
      * Command Syntax
      */
     USER_USE_ADDGROUP("Use the addgroup command instead of specifying the node.", true),
@@ -59,7 +59,7 @@ public enum Message {
     SERVER_INVALID_ENTRY("Server names can only contain alphanumeric characters.", true),
 
 
-    /**
+    /*
      * Commands
      */
     CREATE_SUCCESS("&b%s&a was successfully created.", true),
@@ -99,7 +99,8 @@ public enum Message {
             PREFIX + "&eServer Name: &6%s" + "\n" +
             PREFIX + "&eDefault Group: &6%s" + "\n" +
             PREFIX + "&eSync Interval: &6%s minutes" + "\n" +
-            PREFIX + "&eInclude Global Perms: &6%s",
+            PREFIX + "&eInclude Global Perms: &6%s" + "\n" +
+            PREFIX + "&eOnline Mode: &6%s",
             false
     ),
     DEBUG(
@@ -124,12 +125,16 @@ public enum Message {
     LISTNODES_TEMP("&e%s's Temporary Nodes:" + "\n" + "%s", true),
     SETPERMISSION_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a.", true),
     SETPERMISSION_SERVER_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a.", true),
+    SETPERMISSION_SERVER_WORLD_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a, world &b%s&a.", true),
     SETPERMISSION_TEMP_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a for a duration of &b%s&a.", true),
     SETPERMISSION_TEMP_SERVER_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
+    SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a, world &b%s&a, for a duration of &b%s&a.", true),
     UNSETPERMISSION_SUCCESS("&aUnset &b%s&a for &b%s&a.", true),
     UNSETPERMISSION_SERVER_SUCCESS("&aUnset &b%s&a for &b%s&a on server &b%$s&a.", true),
+    UNSETPERMISSION_SERVER_WORLD_SUCCESS("&aUnset &b%s&a for &b%s&a on server &b%$s&a, world &b%$s&a.", true),
     UNSET_TEMP_PERMISSION_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a.", true),
     UNSET_TEMP_PERMISSION_SERVER_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a on server &b%$s&a.", true),
+    UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a on server &b%$s&a, world &b%$s&a.", true),
     CLEAR_SUCCESS("&b%s&a's permissions were cleared.", true),
     ILLEGAL_DATE_ERROR("Could not parse date '%s'.", true),
     PAST_DATE_ERROR("You cannot set a date in the past!", true),
@@ -148,12 +153,16 @@ public enum Message {
     USER_GETUUID("&bThe UUID of &e%s&b is &e%s&b.", true),
     USER_ADDGROUP_SUCCESS("&b%s&a successfully added to group &b%s&a.", true),
     USER_ADDGROUP_SERVER_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a.", true),
+    USER_ADDGROUP_SERVER_WORLD_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a, world &b%s&a.", true),
     USER_ADDTEMPGROUP_SUCCESS("&b%s&a successfully added to group &b%s&a for a duration of &b%s&a.", true),
     USER_ADDTEMPGROUP_SERVER_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
+    USER_ADDTEMPGROUP_SERVER_WORLD_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a, world &b%s&a, for a duration of &b%s&a.", true),
     USER_REMOVEGROUP_SUCCESS("&b%s&a was removed from group &b%s&a.", true),
     USER_REMOVEGROUP_SERVER_SUCCESS("&b%s&a was removed from group &b%s&a on server &b%s&a.", true),
+    USER_REMOVEGROUP_SERVER_WORLD_SUCCESS("&b%s&a was removed from group &b%s&a on server &b%s&a, world &b%s&a.", true),
     USER_REMOVETEMPGROUP_SUCCESS("&b%s&a was removed from temproary group &b%s&a.", true),
     USER_REMOVETEMPGROUP_SERVER_SUCCESS("&b%s&a was removed from temporary group &b%s&a on server &b%s&a.", true),
+    USER_REMOVETEMPGROUP_SERVER_WORLD_SUCCESS("&b%s&a was removed from temporary group &b%s&a on server &b%s&a, world &b%s&a.", true),
     USER_REMOVEGROUP_ERROR_PRIMARY("You cannot remove a user from their primary group.", true),
     USER_PRIMARYGROUP_SUCCESS("&b%s&a's primary group was set to &b%s&a.", true),
     USER_PRIMARYGROUP_ERROR_ALREADYHAS("The user already has this group set as their primary group.", true),
@@ -188,12 +197,16 @@ public enum Message {
     ),
     GROUP_SETINHERIT_SUCCESS("&b%s&a now inherits permissions from &b%s&a.", true),
     GROUP_SETINHERIT_SERVER_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a.", true),
+    GROUP_SETINHERIT_SERVER_WORLD_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a, world &b%s&a.", true),
     GROUP_SET_TEMP_INHERIT_SUCCESS("&b%s&a now inherits permissions from &b%s&a for a duration of &b%s&a.", true),
     GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
+    GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a, world &b%s&a, for a duration of &b%s&a.", true),
     GROUP_UNSETINHERIT_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a.", true),
     GROUP_UNSETINHERIT_SERVER_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a on server &b%s&a.", true),
+    GROUP_UNSETINHERIT_SERVER_WORLD_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a on server &b%s&a, world &b%s&a.", true),
     GROUP_UNSET_TEMP_INHERIT_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a.", true),
     GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a on server &b%s&a.", true),
+    GROUP_UNSET_TEMP_INHERIT_SERVER_WORLD_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a on server &b%s&a, world &b%s&a.", true),
 
     TRACK_INFO(
             PREFIX + "&d-> &eTrack: &6%s" + "\n" +

common/src/main/java/me/lucko/luckperms/data/Datastore.java

@@ -39,12 +39,8 @@ public abstract class Datastore {
         plugin.doSync(r);
     }
 
-    private void runCallback(boolean result, Callback callback) {
-        doSync(() -> callback.onComplete(result));
-    }
-
-    private void runCallback(UUID result, Callback.GetUUID callback) {
-        doSync(() -> callback.onComplete(result));
+    private <T> void runCallback(T t, Callback<T> callback) {
+        doSync(() -> callback.onComplete(t));
     }
 
     /*
@@ -74,63 +70,63 @@ public abstract class Datastore {
         These methods will schedule the operation to run async. The callback will be ran when the task is complete.
         Callbacks are ran on the main Bukkit server thread (if applicable)
      */
-    public void loadOrCreateUser(UUID uuid, String username, Callback callback) {
+    public void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback) {
         doAsync(() -> runCallback(loadOrCreateUser(uuid, username), callback));
     }
 
-    public void loadUser(UUID uuid, Callback callback) {
+    public void loadUser(UUID uuid, Callback<Boolean> callback) {
         doAsync(() -> runCallback(loadUser(uuid), callback));
     }
 
-    public void saveUser(User user, Callback callback) {
+    public void saveUser(User user, Callback<Boolean> callback) {
         doAsync(() -> runCallback(saveUser(user), callback));
     }
 
-    public void createAndLoadGroup(String name, Callback callback) {
+    public void createAndLoadGroup(String name, Callback<Boolean> callback) {
         doAsync(() -> runCallback(createAndLoadGroup(name), callback));
     }
 
-    public void loadGroup(String name, Callback callback) {
+    public void loadGroup(String name, Callback<Boolean> callback) {
         doAsync(() -> runCallback(loadGroup(name), callback));
     }
 
-    public void loadAllGroups(Callback callback) {
+    public void loadAllGroups(Callback<Boolean> callback) {
         doAsync(() -> runCallback(loadAllGroups(), callback));
     }
 
-    public void saveGroup(Group group, Callback callback) {
+    public void saveGroup(Group group, Callback<Boolean> callback) {
         doAsync(() -> runCallback(saveGroup(group), callback));
     }
 
-    public void deleteGroup(Group group, Callback callback) {
+    public void deleteGroup(Group group, Callback<Boolean> callback) {
         doAsync(() -> runCallback(deleteGroup(group), callback));
     }
 
-    public void createAndLoadTrack(String name, Callback callback) {
+    public void createAndLoadTrack(String name, Callback<Boolean> callback) {
         doAsync(() -> runCallback(createAndLoadTrack(name), callback));
     }
 
-    public void loadTrack(String name, Callback callback) {
+    public void loadTrack(String name, Callback<Boolean> callback) {
         doAsync(() -> runCallback(loadTrack(name), callback));
     }
 
-    public void loadAllTracks(Callback callback) {
+    public void loadAllTracks(Callback<Boolean> callback) {
         doAsync(() -> runCallback(loadAllTracks(), callback));
     }
 
-    public void saveTrack(Track track, Callback callback) {
+    public void saveTrack(Track track, Callback<Boolean> callback) {
         doAsync(() -> runCallback(saveTrack(track), callback));
     }
 
-    public void deleteTrack(Track track, Callback callback) {
+    public void deleteTrack(Track track, Callback<Boolean> callback) {
         doAsync(() -> runCallback(deleteTrack(track), callback));
     }
 
-    public void saveUUIDData(String username, UUID uuid, Callback callback) {
+    public void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback) {
         doAsync(() -> runCallback(saveUUIDData(username, uuid), callback));
     }
 
-    public void getUUID(String username, Callback.GetUUID callback) {
+    public void getUUID(String username, Callback<UUID> callback) {
         doAsync(() -> runCallback(getUUID(username), callback));
     }
 }

common/src/main/java/me/lucko/luckperms/data/methods/FlatfileDatastore.java

@@ -503,12 +503,14 @@ public class FlatfileDatastore extends Datastore {
 
     @Override
     public boolean saveUUIDData(String username, UUID uuid) {
+        username = username.toLowerCase();
         uuidCache.put(username, uuid.toString());
         return true;
     }
 
     @Override
     public UUID getUUID(String username) {
+        username = username.toLowerCase();
         if (uuidCache.get(username) == null) return null;
         return UUID.fromString(uuidCache.get(username));
     }

common/src/main/java/me/lucko/luckperms/data/methods/MySQLDatastore.java

@@ -1,12 +1,14 @@
 package me.lucko.luckperms.data.methods;
 
 import com.zaxxer.hikari.HikariDataSource;
+import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.data.MySQLConfiguration;
 
 import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.logging.Level;
 
 public class MySQLDatastore extends SQLDatastore {
 
@@ -41,13 +43,53 @@ public class MySQLDatastore extends SQLDatastore {
         hikari.addDataSourceProperty("password", password);
 
         if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS)) {
-            plugin.getLogger().log(Level.SEVERE, "Error occurred whilst initialising the database. All connections are disallowed.");
+            plugin.getLog().severe("Error occurred whilst initialising the database. All connections are disallowed.");
             shutdown();
         } else {
             setAcceptingLogins(true);
         }
     }
 
+    @Override
+    boolean runQuery(QueryPS queryPS) {
+        boolean success = false;
+        try {
+            @Cleanup Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
+            queryPS.onRun(preparedStatement);
+            preparedStatement.execute();
+            success = true;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
+    @Override
+    boolean runQuery(QueryRS queryRS) {
+        boolean success = false;
+        try {
+            @Cleanup Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
+            queryRS.onRun(preparedStatement);
+            preparedStatement.execute();
+
+            @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
+            success = queryRS.onResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
     @Override
     public void shutdown() {
         if (hikari != null) {

common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java

@@ -3,7 +3,6 @@ package me.lucko.luckperms.data.methods;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import lombok.AllArgsConstructor;
-import lombok.Cleanup;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.data.Datastore;
@@ -58,43 +57,8 @@ abstract class SQLDatastore extends Datastore {
 
     abstract Connection getConnection() throws SQLException;
 
-    private boolean runQuery(QueryPS queryPS) {
-        boolean success = false;
-        try {
-            @Cleanup Connection connection = getConnection();
-            if (connection == null) {
-                throw new IllegalStateException("SQL connection is null");
-            }
-
-            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
-            queryPS.onRun(preparedStatement);
-            preparedStatement.execute();
-            success = true;
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-        return success;
-    }
-
-    private boolean runQuery(QueryRS queryRS) {
-        boolean success = false;
-        try {
-            @Cleanup Connection connection = getConnection();
-            if (connection == null) {
-                throw new IllegalStateException("SQL connection is null");
-            }
-
-            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
-            queryRS.onRun(preparedStatement);
-            preparedStatement.execute();
-
-            @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
-            success = queryRS.onResult(resultSet);
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-        return success;
-    }
+    abstract boolean runQuery(QueryPS queryPS);
+    abstract boolean runQuery(QueryRS queryRS);
 
     boolean setupTables(String... tableQueries) {
         boolean success = true;
@@ -396,10 +360,11 @@ abstract class SQLDatastore extends Datastore {
 
     @Override
     public boolean saveUUIDData(String username, UUID uuid) {
+        final String u = username.toLowerCase();
         boolean success = runQuery(new QueryRS(UUIDCACHE_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
-                preparedStatement.setString(1, username);
+                preparedStatement.setString(1, u);
             }
 
             @Override
@@ -410,14 +375,14 @@ abstract class SQLDatastore extends Datastore {
                         @Override
                         void onRun(PreparedStatement preparedStatement) throws SQLException {
                             preparedStatement.setString(1, uuid.toString());
-                            preparedStatement.setString(2, username);
+                            preparedStatement.setString(2, u);
                         }
                     });
                 } else {
                     success = runQuery(new QueryPS(UUIDCACHE_INSERT) {
                         @Override
                         void onRun(PreparedStatement preparedStatement) throws SQLException {
-                            preparedStatement.setString(1, username);
+                            preparedStatement.setString(1, u);
                             preparedStatement.setString(2, uuid.toString());
                         }
                     });
@@ -431,12 +396,13 @@ abstract class SQLDatastore extends Datastore {
 
     @Override
     public UUID getUUID(String username) {
+        final String u = username.toLowerCase();
         final UUID[] uuid = {null};
 
         boolean success = runQuery(new QueryRS(UUIDCACHE_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
-                preparedStatement.setString(1, username);
+                preparedStatement.setString(1, u);
             }
 
             @Override
@@ -465,14 +431,14 @@ abstract class SQLDatastore extends Datastore {
 
     @Getter
     @AllArgsConstructor
-    private abstract class QueryPS {
+    abstract class QueryPS {
         private final String query;
         abstract void onRun(PreparedStatement preparedStatement) throws SQLException;
     }
 
     @Getter
     @AllArgsConstructor
-    private abstract class QueryRS {
+    abstract class QueryRS {
         private final String query;
         abstract void onRun(PreparedStatement preparedStatement) throws SQLException;
         abstract boolean onResult(ResultSet resultSet) throws SQLException;

common/src/main/java/me/lucko/luckperms/data/methods/SQLiteDatastore.java

@@ -1,12 +1,10 @@
 package me.lucko.luckperms.data.methods;
 
+import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
 
 import java.io.File;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.util.logging.Level;
+import java.sql.*;
 
 public class SQLiteDatastore extends SQLDatastore {
 
@@ -26,13 +24,53 @@ public class SQLiteDatastore extends SQLDatastore {
     @Override
     public void init() {
         if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS)) {
-            plugin.getLogger().log(Level.SEVERE, "Error occurred whilst initialising the database. All connections are disallowed.");
+            plugin.getLog().severe("Error occurred whilst initialising the database. All connections are disallowed.");
             shutdown();
         } else {
             setAcceptingLogins(true);
         }
     }
 
+    @Override
+    boolean runQuery(QueryPS queryPS) {
+        boolean success = false;
+        try {
+            Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
+            queryPS.onRun(preparedStatement);
+            preparedStatement.execute();
+            success = true;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
+    @Override
+    boolean runQuery(QueryRS queryRS) {
+        boolean success = false;
+        try {
+            Connection connection = getConnection();
+            if (connection == null || connection.isClosed()) {
+                throw new IllegalStateException("SQL connection is null");
+            }
+
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
+            queryRS.onRun(preparedStatement);
+            preparedStatement.execute();
+
+            @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
+            success = queryRS.onResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return success;
+    }
+
     @Override
     public void shutdown() {
         try {