com.comphenix.protocol.events.ListenerPriority Java Examples

public SpigotProtocolHackPacketListener(EchoPetPlugin echoPetPlugin) {
    super(echoPetPlugin,
            ListenerPriority.HIGHEST,
            PacketType.Play.Server.SPAWN_ENTITY_LIVING,
            PacketType.Play.Server.ENTITY_METADATA);
    this.echoPetPlugin = echoPetPlugin;
    ProtocolLibrary.getProtocolManager().addPacketListener(this);
}
 

public PacketInterceptor(Conversation conv, String playerID) {
    this.conv = conv;
    this.player = PlayerConverter.getPlayer(playerID);

    // Intercept Packets
    packetAdapter = new PacketAdapter(BetonQuest.getInstance(), ListenerPriority.HIGHEST,
            PacketType.Play.Server.CHAT

    ) {
        @Override
        public void onPacketSending(PacketEvent event) {
            if (event.getPlayer() != player) {
                return;
            }

            if (event.getPacketType().equals(PacketType.Play.Server.CHAT)) {
                PacketContainer packet = event.getPacket();
                BaseComponent[] bc = (BaseComponent[]) packet.getModifier().read(1);
                if (bc != null && bc.length > 0 && ((TextComponent) bc[0]).getText().contains("_bq_")) {
                    packet.getModifier().write(1, Arrays.copyOfRange(bc, 1, bc.length));
                    event.setPacket(packet);
                    return;
                }

                // Else save message to replay later
                WrapperPlayServerChat chat = new WrapperPlayServerChat(event.getPacket());
                event.setCancelled(true);
                messages.add(chat);
            }
        }
    };

    ProtocolLibrary.getProtocolManager().addPacketListener(packetAdapter);
}
 

public KeepAlive()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.LOW,
          // --------------- Server --------------- //
          // KeepAlive analysis
          PacketType.Play.Server.KEEP_ALIVE,
          // --------------- Client --------------- //
          // KeepAlive analysis
          PacketType.Play.Client.KEEP_ALIVE);
}
 

public Inventory()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.LOWEST,
          // Look
          PacketType.Play.Client.LOOK,
          // Move
          PacketType.Play.Client.POSITION,
          PacketType.Play.Client.POSITION_LOOK);
}
 

public PacketAnalysis()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.LOW,
          // --------------- Server --------------- //
          // Compare
          PacketType.Play.Server.POSITION,
          // --------------- Client --------------- //
          // CombatOrder
          PacketType.Play.Client.USE_ENTITY,
          PacketType.Play.Client.ARM_ANIMATION,
          // EqualRotation
          PacketType.Play.Client.LOOK,
          // EqualRotation + Compare
          PacketType.Play.Client.POSITION_LOOK);
}
 

public ChatPacketListener(Plugin plugin, ListenerPriority listenerPriority, Storage s, PacketType... types) {
    super(plugin, listenerPriority, types);
    if(ChatItem.supportsShulkerBoxes()){
        SHULKER_BOXES.addAll(Arrays.asList(Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX,
                Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX, Material.GREEN_SHULKER_BOX,
                Material.LIGHT_BLUE_SHULKER_BOX, Material.LIME_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.ORANGE_SHULKER_BOX,
                Material.PINK_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.LIGHT_GRAY_SHULKER_BOX,
                Material.WHITE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX));
    }
    c = s;
}
 

public LookPacketDataUpdater()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.MONITOR, PacketType.Play.Client.LOOK, PacketType.Play.Client.POSITION_LOOK);
}
 

TabCompletePacketAdapter(AuthMe plugin, PlayerCache playerCache) {
    super(plugin, ListenerPriority.NORMAL, PacketType.Play.Client.TAB_COMPLETE);
    this.playerCache = playerCache;
}
 

HardcoreHeartsListener() {
    super(HardcoreHeartsModule.this.plugin, ListenerPriority.NORMAL, PacketType.Play.Server.LOGIN);
}
 

@Override
public void onEnable() {
    ProtocolLibrary.getProtocolManager().addPacketListener(
            new PacketAdapter(plugin, ListenerPriority.NORMAL, PacketType.Play.Server.PLAYER_INFO) {
                @Override
                public void onPacketSending(PacketEvent event) {
                    // multiple events share same packet object
                    event.setPacket(event.getPacket().shallowClone());
                    List<PlayerInfoData> infoDataList = new ArrayList<>(
                            event.getPacket().getPlayerInfoDataLists().read(0));
                    Player receiver = event.getPlayer();
                    for (PlayerInfoData infoData : ImmutableList.copyOf(infoDataList)) {
                        try {
                            if (!VanishIndication.this.plugin.getVisibilityChanger().getHider()
                                    .isHidden(infoData.getProfile().getUUID(), receiver)
                                    && VanishIndication.this.plugin.getVanishStateMgr()
                                    .isVanished(infoData.getProfile().getUUID())) {
                                if (!receiver.getUniqueId().equals(infoData.getProfile().getUUID()))
                                    if (infoData.getGameMode() != EnumWrappers.NativeGameMode.SPECTATOR) {
                                        int latency;
                                        try {
                                            latency = infoData.getLatency();
                                        } catch (NoSuchMethodError e) {
                                            latency = 21;
                                        }
                                        if (event.getPacket().getPlayerInfoAction().read(0)
                                                != EnumWrappers.PlayerInfoAction.UPDATE_GAME_MODE) {
                                            continue;
                                        }
                                        PlayerInfoData newData = new PlayerInfoData(infoData.getProfile(),
                                                latency, EnumWrappers.NativeGameMode.SPECTATOR,
                                                infoData.getDisplayName());
                                        infoDataList.remove(infoData);
                                        infoDataList.add(newData);
                                    }
                            }
                        } catch (UnsupportedOperationException ignored) {
                            // Ignore temporary players
                        }
                    }
                    event.getPacket().getPlayerInfoDataLists().write(0, infoDataList);
                }
            });
}
 

public ServerListPacketListener(SuperVanish plugin) {
    //noinspection deprecation
    super(plugin, ListenerPriority.NORMAL, PacketType.Status.Server.OUT_SERVER_INFO);
    this.plugin = plugin;
}
 

ForceFieldAdapter(ForceField forceField) {
    super(forceField.getExpansion().getPlugin().getPlugin(), ListenerPriority.NORMAL, PacketType.Play.Server.BLOCK_CHANGE);
    this.forceField = forceField;
    this.plugin = this.forceField.getExpansion().getPlugin();
}
 

public ChatPacketValidator(Plugin plugin, ListenerPriority listenerPriority, Storage s, PacketType... types) {
    super(plugin, listenerPriority, types);
    c = s;
}
 

public HandshakeListener(Plugin plugin, ListenerPriority listenerPriority, PacketType... types) {
    super(plugin, listenerPriority, types);
}
 

private KeepAliveDataUpdater()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.LOWEST, PacketType.Play.Server.KEEP_ALIVE);
}
 

private VelocityChangeDataUpdater()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.MONITOR, PacketType.Play.Client.POSITION, PacketType.Play.Client.POSITION_LOOK);
}
 

public DamageIndicator()
{
    super(AACAdditionPro.getInstance(), ListenerPriority.HIGH, PacketType.Play.Server.ENTITY_METADATA, PacketType.Play.Server.NAMED_ENTITY_SPAWN);
}
 

Adapter(Plugin plugin) {
    super(plugin, ListenerPriority.LOWEST, PacketType.Handshake.Client.SET_PROTOCOL);
}
 

ProtocolSubscriptionBuilderImpl(Set<PacketType> types, ListenerPriority priority) {
    this.types = ImmutableSet.copyOf(types);
    this.priority = priority;
}
 

/**
 * Makes a HandlerBuilder for the given packets
 *
 * @param priority   the priority to listen at
 * @param packets the packets to handle
 * @return a {@link ProtocolSubscriptionBuilder} to construct the event handler
 */
@Nonnull
static ProtocolSubscriptionBuilder newBuilder(@Nonnull ListenerPriority priority, @Nonnull PacketType... packets) {
    Objects.requireNonNull(priority, "priority");
    Objects.requireNonNull(packets, "packets");
    return new ProtocolSubscriptionBuilderImpl(ImmutableSet.copyOf(packets), priority);
}
 

/**
 * Makes a HandlerBuilder for the given packets
 *
 * @param priority   the priority to listen at
 * @param packets the packets to handle
 * @return a {@link ProtocolSubscriptionBuilder} to construct the event handler
 */
@Nonnull
public static ProtocolSubscriptionBuilder subscribe(@Nonnull ListenerPriority priority, @Nonnull PacketType... packets) {
    return ProtocolSubscriptionBuilder.newBuilder(priority, packets);
}
 

/**
 * Makes a HandlerBuilder for the given packets
 *
 * @param packets the packets to handle
 * @return a {@link ProtocolSubscriptionBuilder} to construct the event handler
 */
@Nonnull
static ProtocolSubscriptionBuilder newBuilder(@Nonnull PacketType... packets) {
    return newBuilder(ListenerPriority.NORMAL, packets);
}