下面列出了怎么用org.bukkit.permissions.PermissibleBase的API类实例代码及写法,或者点击链接到github查看源代码。
private PermissibleBase transform(PermissibleBase permBase, String name) {
Objects.requireNonNull(permBase, "permBase");
// don't bother injecting if already setup.
if (this.mode == Mode.INJECT && permBase instanceof MonitoredPermissibleBase && ((MonitoredPermissibleBase) permBase).plugin == this.plugin) {
return null;
}
// unwrap any previous injection
if (permBase instanceof MonitoredPermissibleBase) {
permBase = ((MonitoredPermissibleBase) permBase).getDelegate();
}
// if the mode is uninject, just return the unwrapped PermissibleBase
if (this.mode == Mode.UNINJECT) {
return permBase;
}
// create a monitored instance which delegates to the previous PermissibleBase
return new MonitoredPermissibleBase(this.plugin, permBase, name);
}
private void injectConsole() throws Exception {
ConsoleCommandSender consoleSender = this.plugin.getBootstrap().getServer().getConsoleSender();
// get the ServerCommandSender class
Class<?> serverCommandSenderClass = CraftBukkitImplementation.obcClass("command.ServerCommandSender");
// get the perm field
Field permField = serverCommandSenderClass.getDeclaredField("perm");
permField.setAccessible(true);
// get the PermissibleBase instance
PermissibleBase permBase = (PermissibleBase) permField.get(consoleSender);
// create a new instance which delegates to the previous PermissibleBase
PermissibleBase newPermBase = transform(permBase, "internal/console");
if (newPermBase == null) {
return;
}
// inject the new instance
permField.set(consoleSender, newPermBase);
}
private void injectEntity() throws Exception {
// get the CraftEntity class
Class<?> entityClass = CraftBukkitImplementation.obcClass("entity.CraftEntity");
// get the method used to obtain a PermissibleBase
// this method will initialise a new PB instance if one doesn't yet exist
Method getPermissibleBaseMethod = entityClass.getDeclaredMethod("getPermissibleBase");
getPermissibleBaseMethod.setAccessible(true);
// get the PermissibleBase instance
PermissibleBase permBase = (PermissibleBase) getPermissibleBaseMethod.invoke(null);
// get the perm field on CraftEntity
Field permField = entityClass.getDeclaredField("perm");
permField.setAccessible(true);
// create a new instance which delegates to the previous PermissibleBase
PermissibleBase newPermBase = transform(permBase, "internal/entity");
if (newPermBase == null) {
return;
}
// inject the new instance
permField.set(null, newPermBase);
}
/**
* Injects a {@link LuckPermsPermissible} into a {@link Player}.
*
* @param player the player to inject into
* @param newPermissible the permissible to inject
* @throws Exception propagates any exceptions which were thrown during injection
*/
public static void inject(Player player, LuckPermsPermissible newPermissible) throws Exception {
// get the existing PermissibleBase held by the player
PermissibleBase oldPermissible = (PermissibleBase) HUMAN_ENTITY_PERMISSIBLE_FIELD.get(player);
// seems we have already injected into this player.
if (oldPermissible instanceof LuckPermsPermissible) {
throw new IllegalStateException("LPPermissible already injected into player " + player.toString());
}
// Move attachments over from the old permissible
//noinspection unchecked
List<PermissionAttachment> attachments = (List<PermissionAttachment>) PERMISSIBLE_BASE_ATTACHMENTS_FIELD.get(oldPermissible);
newPermissible.convertAndAddAttachments(attachments);
attachments.clear();
oldPermissible.clearPermissions();
// Setup the new permissible
newPermissible.getActive().set(true);
newPermissible.setOldPermissible(oldPermissible);
// inject the new instance
HUMAN_ENTITY_PERMISSIBLE_FIELD.set(player, newPermissible);
}
public static void copyFields(PermissibleBase from, PermissibleBase to) {
try {
ATTACHMENTS_FIELD.set(to, ATTACHMENTS_FIELD.get(from));
PERMISSIONS_FIELD.set(to, PERMISSIONS_FIELD.get(from));
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public MonitoredPermissibleBase(LuckPermsPlugin plugin, PermissibleBase delegate, String name) {
super(null);
DummyPermissibleBase.copyFields(delegate, this);
this.plugin = plugin;
this.delegate = delegate;
this.name = name;
this.initialised = true;
}
@Override
public synchronized void clearPermissions()
{
if (oldPermissible instanceof PermissibleBase)
{
PermissibleBase base = (PermissibleBase) oldPermissible;
base.clearPermissions();
}
}
public void inject()
{
if (Injector.getPermissible(sender) == this)
{
return;
}
Statics.setField(PermissibleBase.class, oldPermissible, superperms, "permissions");
Statics.setField(PermissibleBase.class, this, permissions, "permissions");
Statics.setField(PermissibleBase.class, oldPermissible, opable, "opable");
Injector.inject(sender, this);
recalculatePermissions();
}
public void uninject()
{
if (Injector.getPermissible(sender) != this)
{
return;
}
Statics.setField(PermissibleBase.class, oldPermissible, new HashMap(), "permissions");
Statics.setField(PermissibleBase.class, oldPermissible, oldOpable, "opable");
Injector.inject(sender, oldPermissible);
recalculatePermissions();
}
PermissibleBase getOldPermissible() {
return this.oldPermissible;
}
void setOldPermissible(PermissibleBase oldPermissible) {
this.oldPermissible = oldPermissible;
}
PermissibleBase getDelegate() {
return this.delegate;
}
public BPPermissible(CommandSender sender, User u, Permissible oldPermissible)
{
super(sender);
this.sender = sender;
this.oldPermissible = oldPermissible;
permissions = new LinkedHashMap<String, PermissionAttachmentInfo>()
{
@Override
public PermissionAttachmentInfo put(String k, PermissionAttachmentInfo v)
{
PermissionAttachmentInfo existing = this.get(k);
if (existing != null)
{
return existing;
}
return super.put(k, v);
}
};
superperms = new LinkedHashMap<String, PermissionAttachmentInfo>()
{
@Override
public PermissionAttachmentInfo put(String k, PermissionAttachmentInfo v)
{
PermissionAttachmentInfo existing = this.get(k);
if (existing != null)
{
return existing;
}
return super.put(k, v);
}
};
//inject an opable
oldOpable = Statics.getField(PermissibleBase.class, oldPermissible, ServerOperator.class, "opable");
opable = new ServerOperator()
{
@Override
public boolean isOp()
{
BukkitConfig config = (BukkitConfig) BungeePerms.getInstance().getConfig();
if (opdisabled)
{
if (!config.isAllowops())
{
return false;
}
}
if (config.isDebug())
{
BungeePerms.getLogger().info("op check: " + BPPermissible.this.sender.getName() + " has OP: " + oldOpable.isOp());
}
return oldOpable.isOp();
}
@Override
public void setOp(boolean value)
{
oldOpable.setOp(value);
}
};
init = true;
recalculatePermissions();
}