import me.lucko.luckperms.api.User; //导入依赖的package包/类
static String getPrefix(ProxiedPlayer p) {
    if (ProxyServer.getInstance().getPluginManager().getPlugin("LuckPerms") == null) {
        return "";
    }
    final LuckPermsApi lpAPI = LuckPerms.getApi();
    User user = lpAPI.getUser(p.getUniqueId());
    Contexts userCtx = lpAPI.getContextForUser(user).orElseThrow(() -> new IllegalStateException("Could not get LuckPerms context for player " + p));
    return user.getCachedData().getMetaData(userCtx).getPrefix();
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public boolean addToGroup(OfflinePlayer player, String group) {
    Group newGroup = luckPermsApi.getGroup(group);
    if (newGroup == null) {
        return false;
    }

    User user = luckPermsApi.getUser(player.getName());
    if (user == null) {
        return false;
    }

    DataMutateResult result = user.setPermissionUnchecked(luckPermsApi.getNodeFactory().makeGroupNode(newGroup).build());
    if (result == DataMutateResult.FAIL) {
        return false;
    }

    saveUser(user);
    luckPermsApi.cleanupUser(user);

    return true;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public boolean removeFromGroup(OfflinePlayer player, String group) {
    User user = luckPermsApi.getUser(player.getName());
    if (user == null) {
        return false;
    }

    Group permissionGroup = luckPermsApi.getGroup(group);
    if (permissionGroup == null) {
        return false;
    }

    Node groupNode = luckPermsApi.getNodeFactory().makeGroupNode(permissionGroup).build();
    boolean result = user.unsetPermissionUnchecked(groupNode) != DataMutateResult.FAIL;

    luckPermsApi.cleanupUser(user);
    return result;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public boolean setGroup(OfflinePlayer player, String group) {
    User user = luckPermsApi.getUser(player.getName());
    if (user == null) {
        return false;
    }
    Group permissionGroup = luckPermsApi.getGroup(group);
    if (permissionGroup == null) {
        return false;
    }
    Node groupNode = luckPermsApi.getNodeFactory().makeGroupNode(permissionGroup).build();
    DataMutateResult result = user.setPermissionUnchecked(groupNode);
    if (result == DataMutateResult.FAIL) {
        return false;
    }
    user.clearMatching(node -> node.isGroupNode() && !node.getGroupName().equals(permissionGroup.getName()));

    saveUser(user);
    luckPermsApi.cleanupUser(user);
    return true;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
private void onUserDataRecalculateEvent(UserDataRecalculateEvent event) {
    User user = event.getUser();
    Player player = Bukkit.getPlayer(user.getUuid());
    if (player != null) {
        handler.applyTagToPlayer(player);
    }
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
@Nullable
protected String[] get(Event e) {

	ArrayList<String> groups = new ArrayList<>();
	Optional<LuckPermsApi> api = LuckPerms.getApiSafe();
	if (pl.getSingle(e) == null) {
		return new String[groups.size()];
	}
	Consumer<User> action = new Consumer<User>() {
		@Override
		public void accept(User t) {

			for (Group g : api.get().getGroups()) {
				if (t.isInGroup(g)) {
					groups.add(g.getName());
				}
			}
		}

	};

	User user = api.get().getUser(pl.getSingle(e).getUniqueId());
	if (user != null) {
		action.accept(user);

	}
	return groups.toArray(new String[groups.size()]);
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
private void saveUser(User user) {
    luckPermsApi.getStorage().saveUser(user)
        .thenAcceptAsync(wasSuccessful -> {
            if (!wasSuccessful) {
                return;
            }
            user.refreshPermissions();
        }, luckPermsApi.getStorage().getAsyncExecutor());
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public boolean hasPermissionOffline(String name, PermissionNode node) {
    User user = luckPermsApi.getUser(name);
    if (user == null) {
        return false;
    }

    UserData userData = user.getCachedData();
    PermissionData permissionData = userData.getPermissionData(Contexts.allowAll());
    boolean result = permissionData.getPermissionValue(node.getNode()).asBoolean();

    luckPermsApi.cleanupUser(user);
    return result;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public boolean isInGroup(OfflinePlayer player, String group) {
    User user = luckPermsApi.getUser(player.getName());
    if (user == null) {
        return false;
    }

    Group permissionGroup = luckPermsApi.getGroup(group);
    boolean result = permissionGroup != null && user.inheritsGroup(permissionGroup);

    luckPermsApi.cleanupUser(user);
    return result;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public List<String> getGroups(OfflinePlayer player) {
    User user = luckPermsApi.getUser(player.getName());
    if (user == null) {
        return Collections.emptyList();
    }

    List<String> result = user.getOwnNodes().stream()
        .filter(Node::isGroupNode)
        .map(n -> luckPermsApi.getGroupSafe(n.getGroupName()))
        .filter(Optional::isPresent)
        .map(Optional::get)
        .distinct()
        .sorted((o1, o2) -> {
            if (o1.getName().equals(user.getPrimaryGroup()) || o2.getName().equals(user.getPrimaryGroup())) {
                return o1.getName().equals(user.getPrimaryGroup()) ? 1 : -1;
            }

            int i = Integer.compare(o2.getWeight().orElse(0), o1.getWeight().orElse(0));
            return i != 0 ? i : o1.getName().compareToIgnoreCase(o2.getName());
        })
        .map(Group::getName)
        .collect(Collectors.toList());

    luckPermsApi.cleanupUser(user);
    return result;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public User getUser(@Nonnull UUID uuid) {
    Objects.requireNonNull(uuid, "uuid");
    me.lucko.luckperms.common.model.User user = this.handle.getIfLoaded(uuid);
    return user == null ? null : user.getDelegate();
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Nonnull
@Override
public Set<User> getLoadedUsers() {
    return this.handle.getAll().values().stream().map(me.lucko.luckperms.common.model.User::getDelegate).collect(Collectors.toSet());
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public void cleanupUser(@Nonnull User user) {
    Objects.requireNonNull(user, "user");
    this.handle.getHouseKeeper().clearApiUsage(ApiUser.cast(user).getUuid());
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Nonnull
@Override
public Optional<ImmutableContextSet> lookupApplicableContext(@Nonnull User user) {
    Objects.requireNonNull(user, "user");
    return Optional.ofNullable(this.plugin.getContextForUser(ApiUser.cast(user))).map(c -> c.getContexts().makeImmutable());
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Nonnull
@Override
public Optional<Contexts> lookupApplicableContexts(@Nonnull User user) {
    Objects.requireNonNull(user, "user");
    return Optional.ofNullable(this.plugin.getContextForUser(ApiUser.cast(user)));
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
public static me.lucko.luckperms.common.model.User cast(User u) {
    Preconditions.checkState(u instanceof ApiUser, "Illegal instance " + u.getClass() + " cannot be handled by this implementation.");
    return ((ApiUser) u).getHandle();
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
me.lucko.luckperms.common.model.User getHandle() {
    return this.handle;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
public ApiUser(me.lucko.luckperms.common.model.User handle) {
    super(handle);
    this.handle = handle;
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Nonnull
@Override
public CompletableFuture<Boolean> saveUser(@Nonnull User user) {
    Objects.requireNonNull(user, "user");
    return this.handle.noBuffer().saveUser(ApiUser.cast(user)).thenApply(x -> true);
}
 

import me.lucko.luckperms.api.User; //导入依赖的package包/类
@Override
public boolean isUser() {
    return this.target instanceof User;
}