@Override public Integer apply(PacketType type) { return type.getLegacyId(); }; });
@Override public InputStream openStream() throws IOException { byte[] data = new byte[] { (byte) type.getLegacyId() }; return new ByteArrayInputStream(data); } };
/** * Retrieve the id of the packets this constructor creates. * <p> * Deprecated: Use {@link #getType()} instead. * @return The ID of the packets this constructor will create. */ @Deprecated public int getPacketID() { return type.getLegacyId(); }
/** * Retrieves the ID of this packet. * <p> * Deprecated: Use {@link #getType()} instead. * @return Packet ID. */ @Deprecated public int getID() { return type.getLegacyId(); }
/** * Convert a set of packet types to a set of integers based on the legacy packet ID. * @param types - packet type. * @return Set of integers. */ public static Set<Integer> toLegacy(Set<PacketType> types) { Set<Integer> result = Sets.newHashSet(); for (PacketType type : types) result.add(type.getLegacyId()); return Collections.unmodifiableSet(result); }
@SuppressWarnings("deprecation") @Override public boolean hasPacketHandler(PacketType type) { return PacketRegistry.getPreviousPackets().containsKey(type.getLegacyId()); }
@Override public boolean hasMainThreadListener(PacketType type) { return sendingFilters.contains(type.getLegacyId()); }
@Override protected ByteBuffer addHeader(ByteBuffer buffer, PacketType type) { return ByteBuffer.wrap(Bytes.concat(new byte[] { (byte) type.getLegacyId() }, buffer.array())); }
@Override public void addPacketHandler(PacketType type, Set<ListenerOptions> options) { sendingFilters.add(type.getLegacyId()); }
@Override public void removePacketHandler(PacketType type) { sendingFilters.remove(type.getLegacyId()); }
@Override public PacketContainer createPacket(PacketType type) { return createPacket(type.getLegacyId()); }
@Override public PacketContainer createPacket(PacketType type, boolean forceDefaults) { return createPacket(type.getLegacyId(), forceDefaults); }
/** * Retrieve the packet ID of a given packet. * <p> * Deprecated: Use {@link #getPacketType(Class)}. * @param packet - the type of packet to check. * @return The legacy ID of the given packet. * @throws IllegalArgumentException If this is not a valid packet. */ @Deprecated public static int getPacketID(Class<?> packet) { initialize(); return NETTY.getPacketClassLookup().get(packet).getLegacyId(); }
/** * Retrieve the vanilla classes handling each packet ID. * @return Vanilla classes. */ @Deprecated public static Map<Integer, Class> getPreviousPackets() { initialize(); // Construct it first if (LEGACY_PREVIOUS_PACKETS == null) { Map<Integer, Class> map = Maps.newHashMap(); for (Entry<PacketType, Class<?>> entry : NETTY.getPacketTypeLookup().entrySet()) { map.put(entry.getKey().getLegacyId(), entry.getValue()); } LEGACY_PREVIOUS_PACKETS = Collections.unmodifiableMap(map); } return LEGACY_PREVIOUS_PACKETS; }
private String getPacketId(PacketType type) { return Strings.padStart(Integer.toString(type.getCurrentId()), 2, '0') + " (Legacy: " + type.getLegacyId() + ")"; }
@Override @SuppressWarnings({"rawtypes", "deprecation"}) public boolean removePacketHandler(PacketType type) { final int packetID = type.getLegacyId(); if (!hasPacketHandler(type)) return false; Map<Class, Integer> registry = PacketRegistry.getPacketToID(); Map<Integer, Class> previous = PacketRegistry.getPreviousPackets(); Map<Integer, Class> overwritten = PacketRegistry.getOverwrittenPackets(); Class old = previous.get(packetID); Class proxy = PacketRegistry.getPacketClassFromType(type); lookup.setLookup(packetID, old); previous.remove(packetID); registry.remove(proxy); overwritten.remove(packetID); return true; }
/** * Add a collection of packet types to the lookup. * @param types - the types to add. */ public PacketTypeLookup addPacketTypes(Iterable<? extends PacketType> types) { Preconditions.checkNotNull(types, "types cannot be NULL"); for (PacketType type : types) { int legacy = type.getLegacyId(); // Skip unknown legacy packets if (legacy != PacketType.UNKNOWN_PACKET) { if (type.isServer()) serverLookup.put(type.getLegacyId(), type); if (type.isClient()) clientLookup.put(type.getLegacyId(), type); legacyLookup.put(type.getLegacyId(), type); } // Skip unknown current packets if (type.getCurrentId() != PacketType.UNKNOWN_PACKET) { idLookup.getMap(type.getProtocol(), type.getSender()).put(type.getCurrentId(), type); classLookup.getMap(type.getProtocol(), type.getSender()).put(type.getClassNames()[0], type); } nameLookup.put(type.name(), type); } return this; }
@Override @SuppressWarnings({"rawtypes", "deprecation"}) public boolean addPacketHandler(PacketType type, Set<ListenerOptions> options) { final int packetID = type.getLegacyId();
invoker.registerPacketClass(proxyClass, type.getLegacyId()); Object proxy = proxyClass.newInstance();
/** * Determine if a given packet may be sent during login. * @param type - the packet type. * @return TRUE if it may, FALSE otherwise. */ public boolean isLoginPacket(PacketType type) { if (!MinecraftReflection.isUsingNetty()) return isLoginPacket(type.getLegacyId(), type.getSender().toSide()); return PacketType.Login.Client.getInstance().hasMember(type) || PacketType.Login.Server.getInstance().hasMember(type) || PacketType.Status.Client.getInstance().hasMember(type) || PacketType.Status.Server.getInstance().hasMember(type); } }