com.comphenix.protocol.ProtocolLibrary Java Examples

public static void reload(CommandSender sender) {
    ChatItem obj = getInstance();
    obj.pm = ProtocolLibrary.getProtocolManager();
    obj.saveDefaultConfig();
    obj.reloadConfig();
    obj.storage = new Storage(obj.getConfig());
    obj.packetListener.setStorage(obj.storage);
    obj.packetValidator.setStorage(obj.storage);
    obj.chatEventListener.setStorage(obj.storage);
    obj.filter.setStorage(obj.storage);
    APIImplementation api = (APIImplementation) Bukkit.getServicesManager().getRegistration(ChatItemAPI.class).getProvider();
    api.setStorage(obj.storage);
    api.updateLogger();
    if (!obj.storage.RELOAD_MESSAGE.isEmpty())
        sender.sendMessage(obj.storage.RELOAD_MESSAGE);
}
 

@Override
public void kick(String message) throws InvocationTargetException {
    ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();

    PacketContainer kickPacket = new PacketContainer(DISCONNECT);
    kickPacket.getChatComponents().write(0, WrappedChatComponent.fromText(message));

    try {
        //send kick packet at login state
        //the normal event.getPlayer.kickPlayer(String) method does only work at play state
        protocolManager.sendServerPacket(player, kickPacket);
    } finally {
        //tell the server that we want to close the connection
        player.kickPlayer("Disconnect");
    }
}
 

@Override
public void setOnlineMode() throws Exception {
    verifyToken = EncryptionUtil.generateVerifyToken(random);

    /*
     * Packet Information: https://wiki.vg/Protocol#Encryption_Request
     *
     * ServerID="" (String) key=public server key verifyToken=random 4 byte array
     */
    PacketContainer newPacket = new PacketContainer(ENCRYPTION_BEGIN);

    newPacket.getStrings().write(0, serverId);
    newPacket.getSpecificModifier(PublicKey.class).write(0, publicKey);

    newPacket.getByteArrays().write(0, verifyToken);

    //serverId is a empty string
    ProtocolLibrary.getProtocolManager().sendServerPacket(player, newPacket);
}
 

@Override
public void sendNamedEntitySpawnPacket(Player playerToSpawn, Player seer) {
    PacketContainer packet = ProtocolLibrary.getProtocolManager().createPacket(PacketType.Play.Server.NAMED_ENTITY_SPAWN);
    packet.getIntegers().write(0, playerToSpawn.getEntityId());
    packet.getUUIDs().write(0, playerToSpawn.getUniqueId());
    if (ReflectUtil.isVersionHigherThan(1, 8, 8)) {
        packet.getDoubles().write(0, playerToSpawn.getLocation().getX());
        packet.getDoubles().write(1, playerToSpawn.getLocation().getY());
        packet.getDoubles().write(2, playerToSpawn.getLocation().getZ());
    } else {
        packet.getIntegers().write(0, (int) Math.floor(playerToSpawn.getLocation().getX() * 32D));
        packet.getIntegers().write(1, (int) Math.floor(playerToSpawn.getLocation().getY() * 32D));
        packet.getIntegers().write(2, (int) Math.floor(playerToSpawn.getLocation().getZ() * 32D));
    }
    packet.getBytes().write(0, (byte) (playerToSpawn.getLocation().getYaw() * 256F / 360F));
    packet.getBytes().write(1, (byte) (playerToSpawn.getLocation().getPitch() * 256F / 360F));
    packet.getDataWatcherModifier().write(0, WrappedDataWatcher.getEntityWatcher(playerToSpawn));
    try {
        ProtocolLibrary.getProtocolManager().sendServerPacket(seer, packet);
    } catch (InvocationTargetException e) {
        logMessage(Level.SEVERE, "Failed to send named entity spawn packet!", e);
    }
}
 

@Override
public void onDisable()
{
    // Plugin is already disabled -> VerboseSender is not allowed to register a task
    VerboseSender.getInstance().setAllowedToRegisterTasks(false);

    // Remove all the Listeners, PacketListeners
    ProtocolLibrary.getProtocolManager().removePacketListeners(this);
    HandlerList.unregisterAll(AACAdditionPro.getInstance());

    DataUpdaterEvents.INSTANCE.unregister();

    VerboseSender.getInstance().sendVerboseMessage("AACAdditionPro disabled.", true, false);
    VerboseSender.getInstance().sendVerboseMessage(" ", true, false);

    // Task scheduling
    loaded = false;
}
 

private void sendNbt(Vector pos, NbtCompound compound) {
    Player player = this.<Player>getPlayer().parent;
    ProtocolManager manager = ProtocolLibrary.getProtocolManager();

    PacketContainer blockNbt = new PacketContainer(PacketType.Play.Server.TILE_ENTITY_DATA);
    blockNbt.getBlockPositionModifier().write(0, new BlockPosition(pos.getBlockX(), pos.getBlockY(), pos.getBlockZ()));
    blockNbt.getIntegers().write(0, 7);
    blockNbt.getNbtModifier().write(0, compound);


    try {
        manager.sendServerPacket(player, blockNbt);
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}
 

private void sendPlayerInfoChangeGameModePacket(Player p, Player change, boolean spectator) {
    PacketContainer packet = new PacketContainer(PLAYER_INFO);
    packet.getPlayerInfoAction().write(0, EnumWrappers.PlayerInfoAction.UPDATE_GAME_MODE);
    List<PlayerInfoData> data = new ArrayList<>();
    int ping = ThreadLocalRandom.current().nextInt(20) + 15;
    data.add(new PlayerInfoData(WrappedGameProfile.fromPlayer(change), ping,
            spectator ? EnumWrappers.NativeGameMode.SPECTATOR
                    : EnumWrappers.NativeGameMode.fromBukkit(change.getGameMode()),
            WrappedChatComponent.fromText(change.getPlayerListName())));
    packet.getPlayerInfoDataLists().write(0, data);
    try {
        ProtocolLibrary.getProtocolManager().sendServerPacket(p, packet);
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Cannot send packet", e);
    }
}
 

@Override
public void modifyInformation(final Player observer, final Entity entity)
{
    validate(observer, entity);

    if (setModifyInformation(observer, entity.getEntityId(), false)) {
        //Create new packet which destroys the entity
        final PacketContainer destroyEntity = new PacketContainer(PacketType.Play.Server.ENTITY_DESTROY);
        destroyEntity.getIntegerArrays().write(0, new int[]{entity.getEntityId()});

        // Make the entity disappear
        try {
            ProtocolLibrary.getProtocolManager().sendServerPacket(observer, destroyEntity);
        } catch (final InvocationTargetException e) {
            throw new RuntimeException("Cannot send server packet.", e);
        }
    }
}
 

private void sendAddPotionEffect(Player p, PotionEffect effect) {
    PacketContainer packet = new PacketContainer(ENTITY_EFFECT);
    //noinspection deprecation
    int effectID = effect.getType().getId();
    int amplifier = effect.getAmplifier();
    int duration = effect.getDuration();
    int entityID = p.getEntityId();
    packet.getIntegers().write(0, entityID);
    packet.getBytes().write(0, (byte) effectID);
    packet.getBytes().write(1, (byte) amplifier);
    packet.getIntegers().write(1, duration);
    // hide particles in 1.9
    packet.getBytes().write(2, (byte) 0);
    try {
        ProtocolLibrary.getProtocolManager().sendServerPacket(p, packet);
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Cannot send packet", e);
    }
}
 

private void sendRemovePotionEffect(Player p, PotionEffectType type) {
    PacketContainer packet = new PacketContainer(REMOVE_ENTITY_EFFECT);
    //noinspection deprecation
    final int effectID = type.getId();
    final int entityID = p.getEntityId();
    // 1.7 and below
    if (!plugin.getVersionUtil().isOneDotXOrHigher(8)) {
        packet.getIntegers().write(0, entityID);
        packet.getBytes().write(0, (byte) effectID);
    } else if (plugin.getVersionUtil().isOneDotX(8)) {
        // 1.8
        packet.getIntegers().write(0, entityID);
        packet.getIntegers().write(1, effectID);
    } else {
        // 1.9 and higher
        packet.getEffectTypes().write(0, type);
        packet.getIntegers().write(0, entityID);
    }
    try {
        ProtocolLibrary.getProtocolManager().sendServerPacket(p, packet);
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Cannot send packet", e);
    }
}
 

/**
 * Sends a blanked out packet to the given player in order to hide the inventory.
 *
 * @param player the player to send the blank inventory packet to
 */
public void sendBlankInventoryPacket(Player player) {
    ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
    PacketContainer inventoryPacket = protocolManager.createPacket(PacketType.Play.Server.WINDOW_ITEMS);
    inventoryPacket.getIntegers().write(0, PLAYER_INVENTORY);
    int inventorySize = CRAFTING_SIZE + ARMOR_SIZE + MAIN_SIZE + HOTBAR_SIZE;

    ItemStack[] blankInventory = new ItemStack[inventorySize];
    Arrays.fill(blankInventory, new ItemStack(Material.AIR));

    //old minecraft versions
    StructureModifier<ItemStack[]> itemArrayModifier = inventoryPacket.getItemArrayModifier();
    if (itemArrayModifier.size() > 0) {
        itemArrayModifier.write(0, blankInventory);
    } else {
        //minecraft versions above 1.11
        StructureModifier<List<ItemStack>> itemListModifier = inventoryPacket.getItemListModifier();
        itemListModifier.write(0, Arrays.asList(blankInventory));
    }

    try {
        protocolManager.sendServerPacket(player, inventoryPacket, false);
    } catch (InvocationTargetException invocationExc) {
        logger.logException("Error during sending blank inventory", invocationExc);
    }
}
 

@Override
public void run() {
    try {
        super.onLogin(username, new ProtocolLibLoginSource(packetEvent, player, random, publicKey));
    } finally {
        ProtocolLibrary.getProtocolManager().getAsynchronousManager().signalPacketTransmission(packetEvent);
    }
}
 

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);
}
 

/**
 * Construct a new entity hider.
 *
 * @param plugin - the plugin that controls this entity hider.
 * @param policy - the default visibility policy.
 */
public EntityHider(Plugin plugin, Policy policy) {
    Preconditions.checkNotNull(plugin, "plugin cannot be NULL.");

    // Save policy
    this.policy = policy;
    this.manager = ProtocolLibrary.getProtocolManager();

    // Register events and packet listener
    plugin.getServer().getPluginManager().registerEvents(
            bukkitListener = constructBukkit(), plugin);
    manager.addPacketListener(
            protocolListener = constructProtocol(plugin));
}
 

private void sendPackets(PacketContainer... packets) {
    try {
        ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
        for (PacketContainer packet : packets) {
            protocolManager.sendServerPacket(receiver, packet);
        }
    } catch (InvocationTargetException ex) {
        plugin.getLog().error("Exception sending instant skin change packet for: {}", receiver, ex);
    }
}
 

public List<Entity> getPassengers(World world) {
    int[] ids = getPassengerIds();
    List<Entity> passengers = new ArrayList<>();
    ProtocolManager manager = ProtocolLibrary.getProtocolManager();

    for (int id : ids) {
        Entity entity = manager.getEntityFromID(world, id);
        if (entity != null) {
            passengers.add(entity);
        }
    }

    return passengers;
}
 

void sendPacket(PacketContainer packet) {
    //add metadata that we ignore our packets on the listener
    packet.addMetadata("ScoreboardStats", true);

    try {
        //false so we don't listen to our own packets
        ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
    } catch (InvocationTargetException ex) {
        //just log it for now.
        plugin.getLog().info("Failed to send packet", ex);
    }
}
 

@Override
public void end() {
    // Stop Listening for Packets
    ProtocolLibrary.getProtocolManager().removePacketListener(packetAdapter);

    // Send all messages to player
    for (WrapperPlayServerChat message : messages) {
        message.sendPacket(player);
    }
}
 

public void sendChunkUpdatePLIB(FaweChunk chunk, FawePlayer... players) {
    ProtocolManager manager = ProtocolLibrary.getProtocolManager();
    WirePacket packet = null;
    int viewDistance = Bukkit.getViewDistance();
    try {
        for (int i = 0; i < players.length; i++) {
            int cx = chunk.getX();
            int cz = chunk.getZ();

            Player player = ((BukkitPlayer) players[i]).parent;
            Location loc = player.getLocation();

            if (Math.abs((loc.getBlockX() >> 4) - cx) <= viewDistance && Math.abs((loc.getBlockZ() >> 4) - cz) <= viewDistance) {
                if (packet == null) {
                    byte[] data;
                    byte[] buffer = new byte[8192];
                    if (chunk instanceof LazyFaweChunk) {
                        chunk = (FaweChunk) chunk.getChunk();
                    }
                    if (chunk instanceof MCAChunk) {
                        data = new MCAChunkPacket((MCAChunk) chunk, true, true, hasSky()).apply(buffer);
                    } else {
                        data = new FaweChunkPacket(chunk, true, true, hasSky()).apply(buffer);
                    }
                    packet = new WirePacket(PacketType.Play.Server.MAP_CHUNK, data);
                }
                manager.sendWirePacket(player, packet);
            }
        }
    } catch (InvocationTargetException e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public void initialize() throws InvalidConfigurationException {
    // make sure to enable the respawn module
    respawnModule.enable();

    if (!respawnModule.isEnabled()) {
        throw new InvalidConfigurationException(
                "Error enabling the respawn module. The respawn module is required to run hardcore hearts"
        );
    }

    ProtocolLibrary.getProtocolManager().addPacketListener(new HardcoreHeartsListener());

    this.icon.setLore(messages.getRawStrings("lore"));
}
 

public void sendPacket(Player observer, Object packet) {
	try {
		ProtocolLibrary.getProtocolManager().sendServerPacket(observer, PacketContainer.fromPacket(packet));
	} catch(InvocationTargetException e) {
		if(VersionHelper.debug()) {
			iDisguise.getInstance().getLogger().log(Level.INFO, "Cannot send packet: " + packet.getClass().getSimpleName() + " to " + observer.getName(), e);
		}
	}
}
 

private void kickPlayer(String reason) {
    PacketContainer kickPacket = new PacketContainer(DISCONNECT);
    kickPacket.getChatComponents().write(0, WrappedChatComponent.fromText(reason));
    try {
        //send kick packet at login state
        //the normal event.getPlayer.kickPlayer(String) method does only work at play state
        ProtocolLibrary.getProtocolManager().sendServerPacket(player, kickPacket);
        //tell the server that we want to close the connection
        player.kickPlayer("Disconnect");
    } catch (InvocationTargetException ex) {
        plugin.getLog().error("Error sending kick packet for: {}", player, ex);
    }
}
 

@Override
public boolean unregister() {
    if (listener != null) {
        ProtocolLibrary.getProtocolManager().removePacketListener(listener);
        this.listener = null;
        return true;
    } else
        return false;
}
 

/**
 * Sends a list of ProtocolLib packets to a player.
 * @param player
 * @param packets
 * @return
 */
public static void send(Player player, List<PacketContainer> packets) {
    try {
        for (PacketContainer packet : packets)
            ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet, false);
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}
 

public static int getProtocolVersion(Player p) {
    if(Hawk.USING_PLIB)
        return ProtocolLibrary.getProtocolManager().getProtocolVersion(p);
    if(Hawk.getServerVersion() == 7) {
        net.minecraft.server.v1_7_R4.PlayerConnection pConnection = ((org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer) p).getHandle().playerConnection;
        if(pConnection == null)
            return 5;
        return pConnection.networkManager.getVersion();
    }
    return 47;
}
 

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);
}
 

/**
 * Send the current packet to the given receiver.
 *
 * @param receiver - the receiver.
 * @throws RuntimeException If the packet cannot be sent.
 */
public void sendPacket(Player receiver) {
    try {
        ProtocolLibrary.getProtocolManager().sendServerPacket(receiver,
                getHandle());
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Cannot send packet.", e);
    }
}
 

public void sendPacket(Player player) {
    try {
        ProtocolManager manager = ProtocolLibrary.getProtocolManager();
        manager.sendServerPacket(player, getHandle());
    } catch(InvocationTargetException ex) {
        throw new RuntimeException("Cannot send packet", ex);
    }
}
 

public void unregisterProtocol() {
    PluginManager pluginManager = Bukkit.getPluginManager();
    if(!pluginManager.isPluginEnabled("ProtocolLib")) return;

    ProtocolManager manager = ProtocolLibrary.getProtocolManager();
    manager.removePacketListeners(this.plugin.getPlugin());
}
 

private void updateHeaderFooter() {
    PacketContainer packet = new PacketContainer(Server.PLAYER_LIST_HEADER_FOOTER);
    packet.getChatComponents().write(0, WrappedChatComponent.fromText(this.header == null ? "" : this.header));
    packet.getChatComponents().write(1, WrappedChatComponent.fromText(this.footer == null ? "" : this.footer));
    try {
        ProtocolLibrary.getProtocolManager().sendServerPacket(this.player, packet);
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}