/** * Creates a packet container for an existing packet. * @param id - ID of the given packet. * @param handle - contained packet. * @deprecated Use {@link #PacketContainer(PacketType, Object)} instead */ @Deprecated public PacketContainer(int id, Object handle) { this(PacketType.findLegacy(id), handle); }
/** * Creates a packet container for an existing packet. * @param id - ID of the given packet. * @param handle - contained packet. * @param structure - structure modifier. * @deprecated Use {@link #PacketContainer(PacketType, Object, StructureModifier)} instead */ @Deprecated public PacketContainer(int id, Object handle, StructureModifier<Object> structure) { this(PacketType.findLegacy(id), handle, structure); }
@Override public boolean requireInputBuffer(int packetId) { return inputBufferedPackets.contains(PacketType.findLegacy(packetId, Sender.CLIENT)); }
/** * Creates a packet container for a new packet. * <p> * Deprecated: Use {@link #PacketContainer(PacketType)} instead. * @param id - ID of the packet to create. */ @Deprecated public PacketContainer(int id) { this(PacketType.findLegacy(id), StructureCache.newPacket(PacketType.findLegacy(id))); }
/** * Creates an empty Minecraft packet of the given id. * <p> * Decreated: Use {@link #newPacket(PacketType)} instead. * @param legacyId - legacy (1.6.4) packet id. * @return Created packet. */ @Deprecated public static Object newPacket(int legacyId) { return newPacket(PacketType.findLegacy(legacyId)); }
/** * Retrieve a cached structure modifier for the given packet ID. * <p> * Deprecated: Use {@link #getStructure(PacketType, boolean)} instead. * @param legacyId - the legacy (1.6.4) packet ID. * @param compile - whether or not to asynchronously compile the structure modifier. * @return A structure modifier. */ @Deprecated public static StructureModifier<Object> getStructure(final int legacyId, boolean compile) { return getStructure(PacketType.findLegacy(legacyId), compile); }
/** * Set the packet IDs of the packets the listener is looking for. * <p> * This parameter is required. * <p> * Deprecated: Use {@link #types(PacketType...)} instead. * @param packets - the packet IDs to look for. * @return This builder, for chaining. */ @Deprecated public AdapterParameteters packets(@Nonnull Integer... packets) { Preconditions.checkNotNull(packets, "packets cannot be NULL"); PacketType[] types = new PacketType[packets.length]; for (int i = 0; i < types.length; i++) { types[i] = PacketType.findLegacy(packets[i]); } this.packets = types; return this; }
/** * Retrieve a cached structure modifier for the given packet id. * <p> * Deprecated: Use {@link #getStructure(PacketType)} instead. * @param legacyId - the legacy (1.6.4) packet ID. * @return A structure modifier. */ @Deprecated public static StructureModifier<Object> getStructure(int legacyId) { return getStructure(PacketType.findLegacy(legacyId)); }
@Override @Deprecated public PacketContainer createPacket(int id, boolean forceDefaults) { return createPacket(PacketType.findLegacy(id), forceDefaults); }
@Override @Deprecated public PacketContainer createPacket(int id) { return createPacket(PacketType.findLegacy(id), true); }
/** * Create a packet constructor that creates packets using the given ID. * <p> * Note that if you pass a Class as a value, it will use its type directly. * <p> * Deprecated: Use {@link #withPacket(PacketType, Object[])} instead. * @param id - legacy (1.6.4) packet ID. * @param values - the values that will match each parameter in the desired constructor. * @return A packet constructor with these types. * @throws IllegalArgumentException If no packet constructor could be created with these types. */ @Deprecated public PacketConstructor withPacket(int id, Object[] values) { return withPacket(PacketType.findLegacy(id), values); }
/** * Retrieves the correct packet class from a given packet ID. * <p> * Deprecated: Use {@link #getPacketClassFromType(PacketType)} instead. * @param packetID - the packet ID. * @return The associated class. */ @Deprecated public static Class getPacketClassFromID(int packetID) { initialize(); return NETTY.getPacketTypeLookup().get(PacketType.findLegacy(packetID)); }
@Override @SuppressWarnings({"rawtypes", "deprecation"}) public synchronized void cleanupAll() { Map<Integer, Class> overwritten = PacketRegistry.getOverwrittenPackets(); Map<Integer, Class> previous = PacketRegistry.getPreviousPackets(); // Remove every packet handler for (Integer id : previous.keySet().toArray(new Integer[0])) { removePacketHandler(PacketType.findLegacy(id, Sender.CLIENT)); removePacketHandler(PacketType.findLegacy(id, Sender.SERVER)); } overwritten.clear(); previous.clear(); } }
/** * Retrieve a packet type from a legacy (1.6.4 and below) packet ID. * @param packetId - the legacy packet ID. * @param preference - the preferred sender, or NULL for any arbitrary sender. * @return The corresponding packet type. * @throws IllegalArgumentException If the legacy packet could not be found. * @deprecated Legacy IDs haven't functioned properly for some time */ @Deprecated public static PacketType findLegacy(int packetId, Sender preference) { if (preference == null) return findLegacy(packetId); PacketType type = getLookup().getFromLegacy(packetId, preference); if (type != null) return type; throw new IllegalArgumentException("Cannot find legacy packet " + packetId); }
result.add(PacketType.findLegacy(id, side));
@Override public Object packetReceived(Object networkManager, Object connection, Object packet) { if (reveivedFilters.contains(packet.getClass())) { @SuppressWarnings("deprecation") Integer id = invoker.getPacketID(packet); // Check for ignored packets if (ignoredPackets.remove(packet)) { return packet; } Player sender = getInjector(networkManager, connection).getUpdatedPlayer(); PacketType type = PacketType.findLegacy(id, Sender.CLIENT); PacketContainer container = new PacketContainer(type, packet); PacketEvent event = packetReceived(container, sender, readBufferedPackets.get(packet)); if (!event.isCancelled()) return event.getPacket().getHandle(); else return null; // Cancel } // Don't change anything return packet; }
/** * Determine if a listener is valid or not. * <p> * If not, a warning will be printed to the console. * @param listener - listener to check. */ @Override public void checkListener(PacketListener listener) { PlayerInjector last = getLastSuccessfulHook(); if (last != null) { UnsupportedListener result = last.checkListener(version, listener); // We won't prevent the listener, as it may still have valid packets if (result != null) { reporter.reportWarning(this, Report.newBuilder(REPORT_UNSUPPPORTED_LISTENER).messageParam(PacketAdapter.getPluginName(listener), result) ); // These are illegal for (int packetID : result.getPackets()) { removePacketHandler(PacketType.findLegacy(packetID, Sender.CLIENT)); removePacketHandler(PacketType.findLegacy(packetID, Sender.SERVER)); } } } }
@Override public Object packetQueued(Object networkManager, Object connection, Object packet) { if (queuedFilters.contains(packet.getClass())) { @SuppressWarnings("deprecation") Integer id = invoker.getPacketID(packet); // Check for ignored packets if (ignoredPackets.remove(packet)) { return packet; } Player reciever = getInjector(networkManager, connection).getUpdatedPlayer(); PacketType type = PacketType.findLegacy(id, Sender.SERVER); PacketContainer container = new PacketContainer(type, packet); PacketEvent event = packetQueued(container, reciever); if (!event.isCancelled()) return event.getPacket().getHandle(); else return null; // Cancel } // Don't change anything return packet; }
PacketType type = PacketType.findLegacy(packetID, Sender.CLIENT); PacketContainer container = new PacketContainer(type, thisObj); PacketEvent event = packetInjector.packetRecieved(container, input, buffer);
PacketType type = PacketType.findLegacy(id, Sender.SERVER); PacketContainer container = new PacketContainer(type, packet); PacketEvent event = PacketEvent.fromServer(invoker, container, marker, currentPlayer);