Java Priority.CRITICAL属性代码示例

@HookHandler(priority = Priority.CRITICAL)
public void onBlockDestroy(final BlockDestroyHook hook) {
    final Player player = hook.getPlayer();
    final Block block = hook.getBlock();

    if (!player.isOperator()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(block.getLocation());
        if (!zownTree.getData().isOwnerOrMember(player)) {
            final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.build.name());
            if (flag != null) {
                final boolean excluded = zownTree.getData().getConfiguration()
                        .hasBlockBuildExclusion(block.getType());
                if (flag) {
                    if (excluded) {
                        hook.setCanceled();
                    }
                } else {
                    if (!excluded) {
                        hook.setCanceled();
                    }
                }
            }
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onServerListPing(final ServerListPingHook hook) {
    server.getPluginManager().callEvent(
            new ServerListPingEvent(hook.getRequesterAddress(), hook.getMotd().getFullText(), hook
                    .getCurrentPlayers(), hook.getMaxPlayers()) {
                @Override
                public void setMotd(String motd) {
                    super.setMotd(motd);
                    hook.setMotd(motd);
                }

                @Override
                public void setMaxPlayers(int maxPlayers) {
                    super.setMaxPlayers(maxPlayers);
                    hook.setMaxPlayers(maxPlayers);
                }

                @Override
                public void setServerIcon(CachedServerIcon icon) throws IllegalArgumentException,
                        UnsupportedOperationException {
                    super.setServerIcon(icon);
                }
            });
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onItemUse(final ItemUseHook hook) {
    final Player player = hook.getPlayer();
    final Block block = hook.getBlockClicked();

    if (!player.isOperator()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(block.getLocation());
        if (!zownTree.getData().isOwnerOrMember(player)) {
            final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.build.name());
            if (flag != null && !flag) {
                final ItemType type = hook.getItem().getType();
                if (type == ItemType.FlintAndSteel || type == ItemType.WaterBucket
                        || type == ItemType.LavaBucket || type == ItemType.Bonemeal) {
                    hook.setCanceled();
                }
            }
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL, ignoreCanceled = true)
public void onTeleportation(final TeleportHook hook) {
    PlayerTeleportEvent event =
            new PlayerTeleportEvent(new CanaryPlayer(hook.getPlayer()), new CanaryLocation(hook.getPlayer()
                    .getLocation(), new CanaryWorld(hook.getDestination().getWorld())), new CanaryLocation(hook
                    .getDestination(), new CanaryWorld(hook.getDestination().getWorld())),
                    TeleportCauseConverter.of(hook.getTeleportReason())) {
                @Override
                public void setFrom(Location from) {
                    super.setFrom(from);
                    // How can you do this in Canary?
                }

                @Override
                public void setTo(Location to) {
                    super.setTo(to);
                    // How can you do this in Canary?
                }
            };
    event.setCancelled(hook.isCanceled());
    server.getPluginManager().callEvent(event);
    if (event.isCancelled()) {
        hook.setCanceled();
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onItemFrameRotate(final ItemFrameRotateHook hook) {
    final Player player = hook.getPlayer();
    final Entity entity = hook.getItemFrame();

    if (!player.isOperator()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(entity.getLocation());
        if (!zownTree.getData().isOwnerOrMember(player)) {
            final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.interact.name());
            if (flag != null) {
                final boolean excluded = zownTree.getData().getConfiguration()
                        .hasEntityInteractExclusion(entity.getClass());
                if (flag) {
                    if (excluded) {
                        hook.setCanceled();
                    }
                } else {
                    if (!excluded) {
                        hook.setCanceled();
                    }
                }
            }
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onHangingEntityDestroy(final HangingEntityDestroyHook hook) {
    final Player player = hook.getPlayer();
    final HangingEntity entity = hook.getPainting();

    if (player == null || !player.isOperator()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(entity.getLocation());
        if (player == null || !zownTree.getData().isOwnerOrMember(player)) {
            final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.build.name());
            if (flag != null) {
                final boolean excluded = zownTree.getData().getConfiguration()
                        .hasEntityCreateExclusion(entity.getClass());
                if (flag) {
                    if (excluded) {
                        hook.setCanceled();
                    }
                } else {
                    if (!excluded) {
                        hook.setCanceled();
                    }
                }
            }
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onEntityLightningStruck(final EntityLightningStruckHook hook) {
    final Entity target = hook.getStruckEntity();

    if (target.isPlayer()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(target.getLocation());
        final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.playerimmune.name());
        if (flag != null && flag) {
            hook.setCanceled();
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onPlayerCommand(final PlayerCommandHook hook) {
    final Player player = hook.getPlayer();
    final String[] command = hook.getCommand();

    if (!player.isOperator()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(player.getLocation());
        if (zownTree.getData().getConfiguration().hasCommandRestriction(command[0])) {
            hook.setCanceled();
            player.message(ChatFormat.GOLD + "That command has been restricted.");
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL, ignoreCanceled = true)
public void onPlayerChat(final ChatHook hook) {
    Set<org.bukkit.entity.Player> recievers = new HashSet<org.bukkit.entity.Player>();
    for (Player p : hook.getReceiverList()) {
        recievers.add(new CanaryPlayer(p));
    }
    AsyncPlayerChatEvent event =
            new AsyncPlayerChatEvent(false, new CanaryPlayer(hook.getPlayer()), hook.getMessage(), recievers) {
                @Override
                public void setMessage(String message) {
                    super.setMessage(message);
                    hook.setMessage(message);
                }

                @Override
                public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
                    super.setFormat(format);
                    hook.setFormat(format);
                }
            };
    event.setCancelled(hook.isCanceled());
    server.getPluginManager().callEvent(event);
    if (event.isCancelled()) {
        hook.setCanceled();
    }
    // TODO: Fill in
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onPlayerJoin(final ConnectionHook hook) {
    server.getPluginManager().callEvent(new PlayerJoinEvent(new CanaryPlayer(hook.getPlayer()), hook.getMessage()) {
        @Override
        public void setJoinMessage(String joinMessage) {
            super.setJoinMessage(joinMessage);
            hook.setMessage(joinMessage);
        }
    });
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onEnderDropBlock(final EndermanDropBlockHook hook) {
    final Location location = hook.getEnderman().getLocation();

    final Tree<? extends IZown> zownTree = zownManager.getZown(location);
    final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.mobgrief.name());
    if (flag != null && !flag) {
        hook.setCanceled();
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onLiquidDestroy(final LiquidDestroyHook hook) {
    final Block block = hook.getBlock();

    final Tree<? extends IZown> zownTree = zownManager.getZown(block.getLocation());
    final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.flow.name());
    if (flag != null && !flag) {
        hook.setCanceled();
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onArmorStandModify(final ArmorStandModifyHook hook) {
    final Player player = hook.getPlayer();
    // TODO need access to the armor stand being modified
    // final Entity entity = hook.getArmorStand();
    final Entity armorStand = player;

    if (!player.isOperator()) {
        final Tree<? extends IZown> zownTree = zownManager.getZown(armorStand.getLocation());
        if (!zownTree.getData().isOwnerOrMember(player)) {
            final Boolean flag = zownTree.getData().getConfiguration().getFlag(Flag.interact.name());
            if (flag != null) {
                final boolean excluded = zownTree.getData().getConfiguration()
                        .hasEntityInteractExclusion(ArmorStand.class);
                if (flag) {
                    if (excluded) {
                        hook.setCanceled();
                    }
                } else {
                    if (!excluded) {
                        hook.setCanceled();
                    }
                }
            }
        }
    }
}
 

@HookHandler(priority = Priority.CRITICAL)
public void onWorldUnload(final UnloadWorldHook hook) {
    server.getPluginManager().callEvent(new WorldUnloadEvent(new CanaryWorld(hook.getWorld())) {
        @Override
        public void setCancelled(boolean cancelled) {
            super.setCancelled(cancelled);
            //UnloadWorldHook isn't a CancelableHook :(
        }
    });
}
 

@HookHandler(priority = Priority.CRITICAL, ignoreCanceled = true)
public void onBlockDestroy(final BlockDestroyHook hook) {
    BlockBreakEvent event =
            new BlockBreakEvent(new CanaryBlock(hook.getBlock()), new CanaryPlayer(hook.getPlayer()));
    event.setCancelled(hook.isCanceled());
    server.getPluginManager().callEvent(event);
    if (event.isCancelled()) {
        hook.setCanceled();
    }
}