public static void setHearDisguisesListener(boolean enabled) { if (soundsListenerEnabled != enabled) { soundsListenerEnabled = enabled; if (soundsListenerEnabled) { ProtocolLibrary.getProtocolManager().addPacketListener(soundsListener); } else { ProtocolLibrary.getProtocolManager().removePacketListener(soundsListener); } } }
/** * Sends a packet to the given player. * * @param player the player * @param packet the packet */ public static void sendPacket(@Nonnull Player player, @Nonnull PacketContainer packet) { try { manager().sendServerPacket(player, packet); } catch (InvocationTargetException e) { throw new RuntimeException(e); } }
private static PacketContainer fromEntity(Entity entity, int type, int objectData) { if (entityConstructor == null) entityConstructor = ProtocolLibrary.getProtocolManager().createPacketConstructor(TYPE, entity, type, objectData); return entityConstructor.createPacket(entity, type, objectData); }
public static void sendKeepAlive(List<Player> player) { for (Player p : player) { try { PacketContainer packet = get().createPacket(PacketType.Play.Client.KEEP_ALIVE); packet.getIntegers().write(0, random.nextInt()); get().sendServerPacket(p, packet); } catch (InvocationTargetException ex) { ex.printStackTrace(); } } }
private void printListeners(final CommandSender sender) { ProtocolManager manager = ProtocolLibrary.getProtocolManager(); sender.sendMessage(ChatColor.GOLD + "Packet listeners:"); for (PacketListener listener : manager.getPacketListeners()) { sender.sendMessage(ChatColor.GOLD + " - " + listener); } // Along with every asynchronous listener sender.sendMessage(ChatColor.GOLD + "Asynchronous listeners:"); for (PacketListener listener : manager.getAsynchronousManager().getAsyncHandlers()) { sender.sendMessage(ChatColor.GOLD + " - " + listener); } }
@SuppressWarnings("unchecked") HelperProtocolListener(ProtocolSubscriptionBuilderImpl builder, List<BiConsumer<ProtocolSubscription, ? super PacketEvent>> handlers) { super(LoaderUtils.getPlugin(), builder.priority, builder.types); this.types = builder.types; this.exceptionConsumer = builder.exceptionConsumer; this.filters = builder.filters.toArray(new Predicate[builder.filters.size()]); this.preExpiryTests = builder.preExpiryTests.toArray(new BiPredicate[builder.preExpiryTests.size()]); this.midExpiryTests = builder.midExpiryTests.toArray(new BiPredicate[builder.midExpiryTests.size()]); this.postExpiryTests = builder.postExpiryTests.toArray(new BiPredicate[builder.postExpiryTests.size()]); this.handlers = handlers.toArray(new BiConsumer[handlers.size()]); Protocol.manager().addPacketListener(this); }
@Override public void removePacketListener(PacketListener listener) { Iterator<CommonPacketListener> iter = listeners.iterator(); while (iter.hasNext()) { CommonPacketListener cpl = iter.next(); if (cpl.listener == listener) { ProtocolLibrary.getProtocolManager().removePacketListener(cpl); iter.remove(); } } }
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet); ProtocolLibrary.getProtocolManager().sendServerPacket(player, ProtocolLibrary.getProtocolManager() .createPacketConstructor(Server.ENTITY_METADATA, player.getEntityId(), WrappedDataWatcher.getEntityWatcher(player), true) .createPacket(player.getEntityId(), WrappedDataWatcher.getEntityWatcher(player), true));
manager.verifyWhitelist(listener, sendingWhitelist); serverProcessingQueue.addListener(handler, sendingWhitelist); manager.verifyWhitelist(listener, receivingWhitelist); clientProcessingQueue.addListener(handler, receivingWhitelist); manager.addPacketListener(handler.getNullPacketListener());
private Map<String, Integer> getPluginUsers() { Map<String, Integer> users = new HashMap<>(); for (PacketListener listener : ProtocolLibrary.getProtocolManager().getPacketListeners()) { String name = PacketAdapter.getPluginName(listener); // Increment occurence if (!users.containsKey(name)) { users.put(name, 1); } else { users.put(name, users.get(name) + 1); } } return users; } }
/** * Simulate receiving the current packet from the given sender. * @param sender - the sender. * @throws RuntimeException If the packet cannot be received. */ public void recievePacket(Player sender) { try { ProtocolLibrary.getProtocolManager().recieveClientPacket(sender, getHandle()); } catch (Exception e) { throw new RuntimeException("Cannot recieve packet.", e); } } }
@SuppressWarnings("unchecked") HelperProtocolListener(ProtocolSubscriptionBuilderImpl builder, List<BiConsumer<ProtocolSubscription, ? super PacketEvent>> handlers) { super(LoaderUtils.getPlugin(), builder.priority, builder.types); this.types = builder.types; this.exceptionConsumer = builder.exceptionConsumer; this.filters = builder.filters.toArray(new Predicate[builder.filters.size()]); this.preExpiryTests = builder.preExpiryTests.toArray(new BiPredicate[builder.preExpiryTests.size()]); this.midExpiryTests = builder.midExpiryTests.toArray(new BiPredicate[builder.midExpiryTests.size()]); this.postExpiryTests = builder.postExpiryTests.toArray(new BiPredicate[builder.postExpiryTests.size()]); this.handlers = handlers.toArray(new BiConsumer[handlers.size()]); Protocol.manager().addPacketListener(this); }
@Override public boolean unregister() { // already unregistered if (!this.active.getAndSet(false)) { return false; } Protocol.manager().removePacketListener(this); return true; } }
manager.sendServerPacket(player, manager.createPacketConstructor(Server.NAMED_ENTITY_SPAWN, player).createPacket(player)); manager.createPacketConstructor(Server.ENTITY_METADATA, player.getEntityId(), dataWatcher, true) .createPacket(player.getEntityId(), dataWatcher, true)); Vector velocity = player.getVelocity(); sendSelfPacket(player, manager .createPacketConstructor(Server.ENTITY_VELOCITY, player.getEntityId(), velocity.getX(), velocity.getY(), velocity.getZ()) .createPacket(player.getEntityId(), velocity.getX(), velocity.getY(), velocity.getZ())); manager.createPacketConstructor(Server.ATTACH_ENTITY, 0, player, player.getVehicle()) .createPacket(0, player, player.getVehicle())); } else if (player.getPassenger() != null && player.getEntityId() > player.getPassenger().getEntityId()) { sendSelfPacket(player, manager.createPacketConstructor(Server.ATTACH_ENTITY, 0, player.getPassenger(), player) .createPacket(0, player.getPassenger(), player)); sendSelfPacket(player, manager.createPacketConstructor(Server.ENTITY_EQUIPMENT, 0, ReflectionManager.createEnumItemSlot(EquipmentSlot.HEAD), ReflectionManager.getNmsItem(new ItemStack(Material.STONE))) .createPacket(player.getEntityId(), ReflectionManager.createEnumItemSlot(EquipmentSlot.HEAD), ReflectionManager.getNmsItem(player.getInventory().getHelmet()))); sendSelfPacket(player, manager.createPacketConstructor(Server.ENTITY_EQUIPMENT, 0, ReflectionManager.createEnumItemSlot(EquipmentSlot.HEAD), ReflectionManager.getNmsItem(new ItemStack(Material.STONE))) .createPacket(player.getEntityId(), ReflectionManager.createEnumItemSlot(EquipmentSlot.CHEST), ReflectionManager.getNmsItem(player.getInventory().getChestplate())));
pw.println(); Set<PacketListener> listeners = manager.getPacketListeners(); Set<Plugin> plugins = new HashSet<>();
@Override public void receivePacket(Player player, Object packet) { if (isNPCPlayer(player) || PlayerUtil.isDisconnected(player)) { return; } PacketContainer toReceive = new PacketContainer(getPacketType(packet.getClass()), packet); try{ ProtocolLibrary.getProtocolManager().recieveClientPacket(player, toReceive); } catch (PlayerLoggedOutException ex) { // Ignore } catch (Exception e) { throw new RuntimeException("Error while receiving packet:", e); } }
/** * Sends a packet to the given player. * * @param player the player * @param packet the packet */ public static void sendPacket(@Nonnull Player player, @Nonnull PacketContainer packet) { try { manager().sendServerPacket(player, packet); } catch (InvocationTargetException e) { throw new RuntimeException(e); } }
public PacketListener updatePacketListener() { if (listener != null) { manager.removePacketListener(listener); } if (compareListener != null) { manager.removePacketListener(compareListener); } // Register the new listeners listener = createPacketListener(packetTypes.values()); compareListener = createCompareListener(compareTypes.values()); manager.addPacketListener(listener); manager.addPacketListener(compareListener); return listener; }
@Override public void addPacketListener(Plugin plugin, PacketListener listener, PacketType[] types) { CommonPacketListener commonListener = new CommonPacketListener(plugin, listener, types); ProtocolLibrary.getProtocolManager().addPacketListener(commonListener); this.listeners.add(commonListener); }
@Override public boolean unregister() { // already unregistered if (!this.active.getAndSet(false)) { return false; } Protocol.manager().removePacketListener(this); return true; } }