程序包 net.neoforged.neoforge.network.registration

类 NetworkRegistry

java.lang.Object
net.neoforged.neoforge.network.registration.NetworkRegistry
@Internal public class NetworkRegistry extends Object
Core registry for all modded networking.

This registry is responsible for storing all known modded payloads, and for handling the negotiation of modded network channels between the client and the server.

Additionally, this registry is responsible for handling all packets that are not natively known once they arrive at the receiving end.

To prevent payloads from being send to a client that has no idea what to do with them, the registry provides endpoints for the vanilla code base to check if a packet can be send to a client.

  • 字段详细资料

  • 构造器详细资料

    • NetworkRegistry

      protected NetworkRegistry()

  • 方法详细资料

    • setup

      public static void setup()
      Sets up the network registry by firing RegisterPayloadHandlersEvent, storing the resulting payload registrations in PAYLOAD_REGISTRATIONS.

    • register

      public static <T extends CustomPacketPayload, B extends FriendlyByteBuf> void register(CustomPacketPayload.Type<T> type, StreamCodec<? super B,T> codec, @Nullable @Nullable IPayloadHandler<T> serverHandler, @Nullable @Nullable IPayloadHandler<T> clientHandler, List<ConnectionProtocol> protocols, Optional<PacketFlow> flow, String version, boolean optional)
      Registers a new payload.
      类型参数:
      T - The class of the payload.
      B - The class of the ByteBuf. Only play payloads may use RegistryFriendlyByteBuf.
      参数:
      type - The type of the payload.
      codec - The codec for the payload.
      serverHandler - The server-side handler for the payload. This handler will be executed on the network thread.
      clientHandler - The client-side handler for the payload. This handler will be executed on the network thread.
      protocols - The protocols this payload supports being sent over. Only configuration and play are supported.
      flow - The flow of this payload. Specify Optional.empty() to support sending in both directions.
      version - The version of the payload. Increase the payload version if the codec logic or handler logic changes. Neo-Neo connections with mismatched versions are denied.
      optional - If the payload is optional. Any connection with missing non-optional payloads is denied.

    • registerHandler

      protected static <T extends CustomPacketPayload> void registerHandler(Map<ConnectionProtocol,Map<ResourceLocation,IPayloadHandler<?>>> handlers, ConnectionProtocol protocol, PacketFlow flow, CustomPacketPayload.Type<T> type, IPayloadHandler<T> handler)

    • getCodec

      @Nullable public static @Nullable StreamCodec<? super FriendlyByteBuf,? extends CustomPacketPayload> getCodec(ResourceLocation id, ConnectionProtocol protocol, PacketFlow flow)
      Attempts to retrieve the StreamCodec for a non-vanilla payload.

      This method hardcodes NeoForge custom packets, stored in BUILTIN_PAYLOADS, which may be sent before negotiation.

      If none of the hardcoded matches succeed, we instead query the registered handlers.

      The only validation this method performs is that the PacketFlow is correct. Other checks should be done externally.

      参数:
      id - The id of the payload.
      protocol - The protocol of the connection.
      flow - The flow of the connection.
      返回:
      A codec for the payload, or null if the payload should be discarded on receipt.
      API Note:
      This method must not throw exceptions, as it is called within another codec on the network thread.

    • isModdedPayload

      public static boolean isModdedPayload(CustomPacketPayload payload)
      Checks if a payload is a modded payload. A modded payload is any payload that does not have `minecraft` as the domain, and is not a discarded payload.

      The special handling for DiscardedPayload is because it falsely reports its type as the type that failed to decode.

      返回:
      True if the payload is modded, and modded payload handling should be invoked for it.

    • handleModdedPayload

      public static void handleModdedPayload(ServerCommonPacketListener listener, ServerboundCustomPayloadPacket packet)
      Handles modded payloads on the server. Invoked after built-in handling.

      Called on the network thread.

      参数:
      listener - The listener which received the packet.
      packet - The packet that was received.

    • initializeNeoForgeConnection

      public static void initializeNeoForgeConnection(ServerConfigurationPacketListener listener, Map<ConnectionProtocol,Set<ModdedNetworkQueryComponent>> clientChannels)
      Invoked by the server when it completes the negotiation with the client during the configuration phase.

      This method determines what the versions of each of the channels are, and checks if the client and server have a compatible set of network channels.

      If the negotiation fails, a custom packet is sent to the client to inform it of the failure, and which will allow the client to disconnect gracefully with an indicative error screen.

      This method should only be invoked for modded connections. Use initializeOtherConnection(ServerConfigurationPacketListener) to indicate that during the configuration phase of the network handshake between a client and the server, a vanilla connection was detected.

      Invoked on the network thread.

      参数:
      listener - The listener which completed the negotiation.
      clientChannels - The network channels that the client has available.

    • initializeOtherConnection

      public static boolean initializeOtherConnection(ServerConfigurationPacketListener listener)
      Invoked by the ServerConfigurationPacketListenerImpl when a vanilla or other connection is detected.
      参数:
      listener - The listener which detected the vanilla connection during the configuration phase.
      返回:
      True if the vanilla connection should be handled by the server, false otherwise.

    • checkPacket

      public static void checkPacket(Packet<?> packet, ServerCommonPacketListener listener)
      Validates that a ClientboundCustomPayloadPacket may be sent to the client.
      参数:
      packet - The packet that is about to be sent.
      listener - The listener that wants to send the packet.
      抛出:
      UnsupportedOperationException - if the packet may not be sent.

    • checkPacket

      public static void checkPacket(Packet<?> packet, ClientCommonPacketListener listener)
      Validates that a ServerboundCustomPayloadPacket may be sent to the server.
      参数:
      packet - The packet that is about to be sent.
      listener - The listener that wants to send the packet.
      抛出:
      UnsupportedOperationException - if the packet may not be sent.

    • hasAdhocChannel

      protected static boolean hasAdhocChannel(ConnectionProtocol protocol, ResourceLocation id, PacketFlow flow)
      Checks if a given payload is ad-hoc readable, that is, may be read without a negotiated channel being present.

      This is possible when an optional registration exists for the payload.

      参数:
      id - The id of the packet.
      flow - The flow of the packet.
      返回:
      True if the packet is ad-hoc readable, false otherwise.

    • hasChannel

      public static boolean hasChannel(ICommonPacketListener listener, ResourceLocation payloadId)
      Checks if the packet listener's connection can send/receive the given payload.
      参数:
      listener - The listener to check.
      payloadId - The payload id to check.
      返回:
      True if the listener has a connection setup that can transmit the given payload id, false otherwise.

    • hasChannel

      public static boolean hasChannel(Connection connection, @Nullable @Nullable ConnectionProtocol protocol, ResourceLocation payloadId)
      Indicates whether the given connection has a connection setup that can transmit the given payload id.
      参数:
      connection - The connection to check.
      protocol - The protocol to check. Pass null to check against all protocols.
      payloadId - The payload id to check.
      返回:
      True if the connection has a connection setup that can transmit the given payload id, false otherwise.

    • filterGameBundlePackets

      public static <T extends PacketListener> List<Packet<?>> filterGameBundlePackets(io.netty.channel.ChannelHandlerContext context, Iterable<Packet<? super T>> packets)
      Filters the given packets for a bundle packet in the game phase of the connection.
      类型参数:
      T - The type of the listener.
      参数:
      context - The context of the connection.
      packets - The packets to filter.
      返回:
      The filtered packets.

    • configureMockConnection

      @VisibleForTesting public static void configureMockConnection(Connection connection)
      Configures a mock connection for use in game tests. The mock connection will act as if the server and client are fully compatible and both NeoForge.
      参数:
      connection - The connection to configure.

    • onMinecraftRegister

      public static void onMinecraftRegister(Connection connection, Set<ResourceLocation> resourceLocations)
      Invoked to add to the known ad-hoc channels on a connection.

      Invoked on the network thread.

      参数:
      connection - The connection to add the channels to.
      resourceLocations - The resource locations to add.

    • onMinecraftUnregister

      public static void onMinecraftUnregister(Connection connection, Set<ResourceLocation> resourceLocations)
      Invoked to remove from the known ad-hoc channels on a connection.

      Invoked on the network thread.

      参数:
      connection - The connection to remove the channels from.
      resourceLocations - The resource locations to remove.

    • getInitialListeningChannels

      public static Set<ResourceLocation> getInitialListeningChannels(PacketFlow flow)
      返回 the initial channels for the configuration phase.。
      返回:
      the initial channels for the configuration phase.

    • getInitialServerUnregisterChannels

      public static Set<ResourceLocation> getInitialServerUnregisterChannels()

    • checkCommonVersion

      public static void checkCommonVersion(ICommonPacketListener listener, CommonVersionPayload payload)
      Called when a CommonVersionPayload is received. Triggers a disconnect if none of the supplied version match our supported ones. Since we only support one version, we don't need to do further handling or record the "active" version just yet.

      Invoked on the network thread.

      参数:
      listener - The receiving listener.
      payload - The incoming version payload.

    • onCommonRegister

      public static void onCommonRegister(ICommonPacketListener listener, CommonRegisterPayload payload)
      Replaces any existing common channels with the incoming ones from a CommonRegisterPayload.

      Invoked on the network thread.

      参数:
      listener - The receiving listener.
      payload - The incoming register payload.

    • getCommonPlayChannels

      public static Set<ResourceLocation> getCommonPlayChannels(PacketFlow flow)

    • onConfigurationFinished

      public static void onConfigurationFinished(ICommonPacketListener listener)
      Invoked when the configuration phase of a connection is completed.

      Updates the ad-hoc channels to prepare for the game phase by removing the initial channels and building a new list based on the connection type.

      参数:
      listener - The packet listener finishing the configuration phase

    • getConnectionType

      public static ConnectionType getConnectionType(Connection connection)

    • guard

      public static <T> CompletableFuture<T> guard(CompletableFuture<T> future, ResourceLocation payloadId)
      Helper to guard futures generated by IPayloadContext against exceptions.

    • handlePacketUnchecked

      public static <T extends PacketListener> void handlePacketUnchecked(Packet<T> packet, PacketListener listener)

    • dumpStackToLog

      private static void dumpStackToLog()
      Used in place of Thread.dumpStack() as that logs to System.err.