Skip to content

Commit

Permalink
Use tracks with LuckPerms
Browse files Browse the repository at this point in the history
  • Loading branch information
@bermudalocket
bermudalocket committed Jan 7, 2019
1 parent c2e18e6 commit 0ed027c
Show file tree
Hide file tree
Showing 4 changed files with 58 additions and 111 deletions.
2 changes: 2 additions & 0 deletions config.yml
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,5 @@
server: pve-dev

allow:
flight: true
collisions: true
Expand Down
2 changes: 1 addition & 1 deletion pom.xml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
<modelVersion>4.0.0</modelVersion>
<groupId>nu.nerd</groupId>
<artifactId>ModMode</artifactId>
<version>4.0.1</version>
<version>4.0.3</version>
<packaging>jar</packaging>
<name>ModMode</name>
<properties>
Expand Down
46 changes: 15 additions & 31 deletions src/nu/nerd/modmode/ModMode.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,6 @@
import org.kitteh.vanish.VanishPlugin;

import java.io.File;
import java.util.HashSet;
import java.util.List;

// ------------------------------------------------------------------------
Expand Down Expand Up @@ -402,18 +401,14 @@ private void toggleModMode(final Player player, boolean enabled) {
}

if (!enabled) {
// remove ModMode node
PERMISSIONS.removeGroup(player, CONFIG.MODMODE_GROUP);

// re-add the player's serialized groups
List<String> serializedGroups = Configuration.getSerializedGroups(player);
serializedGroups.forEach(group -> PERMISSIONS.addGroup(player, group));

// When leaving ModMode, Admins return to their persistent vanish
// state; Moderators become visible
if (PERMISSIONS.isAdmin(player)) {
// When leaving ModMode, Admins return to their persistent vanish
// state
setVanish(player, Configuration.loggedOutVanished(player));
} else {
// luckperms: demote from modmode back to moderator group
PERMISSIONS.demote(player);
// always reappear
setVanish(player, false);
if (CONFIG.joinedVanished.containsKey(player.getUniqueId().toString())) {
getServer().broadcastMessage(CONFIG.joinedVanished.get(player.getUniqueId().toString()));
Expand All @@ -422,33 +417,22 @@ private void toggleModMode(final Player player, boolean enabled) {

// remove from ModMode cache
MODMODE_CACHE.remove(player);

player.sendMessage(ChatColor.RED + "You are no longer in ModMode!");
} else {
// clean up old mappings
Configuration.sanitizeSerializedGroups(player);

// get & serialize player's current groups
HashSet<String> nodes = PERMISSIONS.getGroups(player);
Configuration.serializeGroups(player, nodes);

// remove all groups that are not configured to be persistent
nodes.stream()
.filter(group -> !Configuration.isPersistentGroup(group))
.forEach(group -> PERMISSIONS.removeGroup(player, group));

// apply the ModMode node
PERMISSIONS.addGroup(player, CONFIG.MODMODE_GROUP);
if (!player.hasPermission(Permissions.ADMIN)) {
// promote moderators along modmode track to give modmod perms;
// admin perms stay as-is
PERMISSIONS.promote(player);
} else {
// Always vanish when entering ModMode. Record the old vanish state for admins only.
setPersistentVanishState(player);
}

// add to ModMode cache
MODMODE_CACHE.add(player);

// Always vanish when entering ModMode. Record the old vanish state for admins only.
if (PERMISSIONS.isAdmin(player)) {
setPersistentVanishState(player);
}

setVanish(player, true);
// brief half-second delay to allow luckperms to catch up
Bukkit.getScheduler().runTaskLater(this, () -> setVanish(player, true), 10);
player.sendMessage(ChatColor.RED + "You are now in ModMode!");
}

Expand Down
119 changes: 40 additions & 79 deletions src/nu/nerd/modmode/Permissions.java
View file
Original file line number Diff line number Diff line change
@@ -1,67 +1,34 @@
package nu.nerd.modmode;

import me.lucko.luckperms.api.Contexts;
import me.lucko.luckperms.api.LuckPermsApi;
import me.lucko.luckperms.api.Node;
import me.lucko.luckperms.api.User;
import me.lucko.luckperms.api.Track;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.plugin.RegisteredServiceProvider;

import java.util.HashMap;
import java.util.HashSet;
import java.util.UUID;
import java.util.stream.Collectors;

public class Permissions {

private final LuckPermsApi API;

private static Track MODMODE_TRACK;
private static Track FOREIGN_SERVER_ADMINS_TRACK;

Permissions() {
RegisteredServiceProvider<LuckPermsApi> svcProvider = Bukkit.getServer().getServicesManager().getRegistration(LuckPermsApi.class);
if (svcProvider != null) {
API = svcProvider.getProvider();
MODMODE_TRACK = getTrack("modmode-track");
FOREIGN_SERVER_ADMINS_TRACK = getTrack("foreign-server-admins-modmode-track");
} else {
API = null;
ModMode.log("LuckPerms could not be found. Is it disabled or missing?");
Bukkit.getPluginManager().disablePlugin(ModMode.PLUGIN);
}
}

// ------------------------------------------------------------------------
/**
* Returns a User instance corresponding to the given player.
*
* @param player the player.
* @return the User instance.
*/
private User getUser(Player player) {
UUID uuid = player.getUniqueId();
if (API.isUserLoaded(uuid)) {
return API.getUser(uuid);
} else {
return API.getUserManager().loadUser(uuid).join();
if (MODMODE_TRACK == null) {
ModMode.log("Track modmode-track could not be found.");
}
}

// ------------------------------------------------------------------------
/**
* Returns a Node instance for the given group. Consults cache before
* doing a lookup.
*
* @param group the group.
* @return the node.
*/
private Node getGroupNode(String group) {
if (_nodeCache.containsKey(group)) {
return _nodeCache.get(group);
} else {
Node node = API.getNodeFactory()
.makeGroupNode(group)
.setExtraContext(Contexts.global().getContexts())
.build();
_nodeCache.put(group, node);
return node;
if (FOREIGN_SERVER_ADMINS_TRACK == null) {
ModMode.log("Track modmode-track could not be found.");
}
}

Expand All @@ -81,64 +48,58 @@ boolean isAdmin(Player player) {

// ------------------------------------------------------------------------
/**
* Adds the player to the given group.
* Gets the Track with the given name, or null if it does not exist.
*
* @param player the player.
* @param group the group to add.
* @param name the name of the Track.
* @return the Track, or null if it does not exist.
*/
void addGroup(Player player, String group) {
changeGroup(player, group, true);
Track getTrack(String name) {
if (API.isTrackLoaded(name)) {
return API.getTrack(name);
} else {
return API.getTrackManager().loadTrack(name).join().orElse(null);
}
}

// ------------------------------------------------------------------------
/**
* Removes the player from the given group.
* Returns the modmode track if the player is a moderator, or the foreign
* server admins modmode track if the player is a foreign server admin.
*
* @param player the player.
* @param group the group to remove.
* @param player the player.
* @return the modmode track if the player is a moderator, or the foreign
* server admins modmode track if the player is a foreign server admin.
*/
void removeGroup(Player player, String group) {
changeGroup(player, group, false);
private Track getAppropriateTrack(Player player) {
if (player.hasPermission("group.foreignserveradmins")) {
return FOREIGN_SERVER_ADMINS_TRACK;
} else {
return MODMODE_TRACK;
}
}

// ------------------------------------------------------------------------
/**
* If add is true, the group will be added to the user; likewise removed
* if false.
* Promotes the player along the track corresponding to their primary group.
*
* @param player the player.
* @param group the group.
* @param add true to add, false to remove.
* @param player the player to promote.
*/
private void changeGroup(Player player, String group, boolean add) {
User user = getUser(player);
Node node = getGroupNode(group);
if (add) user.setPermission(node); else user.unsetPermission(node);
API.getUserManager().saveUser(user);
void promote(Player player) {
Track track = getAppropriateTrack(player);
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + player.getName() + " promote " + track.getName());
}

// ------------------------------------------------------------------------
/**
* Returns all of a player's groups as a set.
* Demotes the player along the track corresponding to their primary group.
*
* @param player the player.
* @return a set of groups.
* @param player the player to demote.
*/
HashSet<String> getGroups(Player player) {
User user = getUser(player);
return user.getAllNodes()
.stream()
.filter(Node::isGroupNode)
.map(Node::getGroupName)
.collect(Collectors.toCollection(HashSet::new));
void demote(Player player) {
Track track = getAppropriateTrack(player);
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + player.getName() + " demote " + track.getName());
}

// ------------------------------------------------------------------------
/**
* A cache of previously built Nodes.
*/
private final HashMap<String, Node> _nodeCache = new HashMap<>();

private static final String MODMODE = "modmode.";
public static final String VANISH = MODMODE + "vanish";
public static final String TOGGLE = MODMODE + "toggle";
Expand Down

0 comments on commit 0ed027c

Please sign in to comment.