New network system

2024-01-02 15:16:13 +02:00
parent 1dad912ec1
commit 0813bc416c
30 changed files with 517 additions and 107 deletions
--- a/NeoForge/src/main/java/com/hypherionmc/craterlib/CraterLib.java
+++ b/NeoForge/src/main/java/com/hypherionmc/craterlib/CraterLib.java
@@ -3,23 +3,32 @@ package com.hypherionmc.craterlib;
 import com.hypherionmc.craterlib.api.event.client.LateInitEvent;
 import com.hypherionmc.craterlib.common.NeoForgeServerEvents;
 import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.core.networking.CraterPacketNetwork;
+import com.hypherionmc.craterlib.core.networking.PacketRegistry;
+import com.hypherionmc.craterlib.core.networking.data.PacketSide;
+import com.hypherionmc.craterlib.network.CraterNeoForgeNetworkHandler;
 import net.minecraft.client.Minecraft;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.fml.common.Mod;
 import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
 import net.neoforged.fml.javafmlmod.FMLJavaModLoadingContext;
 import net.neoforged.fml.loading.FMLEnvironment;
+import net.neoforged.fml.loading.FMLLoader;
 import net.neoforged.neoforge.common.NeoForge;

@Mod(CraterConstants.MOD_ID)
 public class CraterLib {

+    private final PacketRegistry handler;
+
    public CraterLib(IEventBus eventBus) {
        NeoForge.EVENT_BUS.register(new NeoForgeServerEvents());
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::commonSetup);
+        handler = new CraterNeoForgeNetworkHandler(FMLLoader.getDist().isClient() ? PacketSide.CLIENT : PacketSide.SERVER);
    }

    public void commonSetup(FMLCommonSetupEvent evt) {
+        new CraterPacketNetwork(handler);
        if (FMLEnvironment.dist.isClient()) {
            LateInitEvent event = new LateInitEvent(Minecraft.getInstance(), Minecraft.getInstance().options);
            CraterEventBus.INSTANCE.postEvent(event);
--- a/NeoForge/src/main/java/com/hypherionmc/craterlib/common/NeoForgeCommonHelper.java
+++ b/NeoForge/src/main/java/com/hypherionmc/craterlib/common/NeoForgeCommonHelper.java
@@ -23,7 +23,8 @@ public class NeoForgeCommonHelper implements CommonPlatform {

    @Override
    public CraterNetworkHandler createPacketHandler(String modid, boolean requiredClient, boolean requiredServer) {
-        return NeoForgeNetworkHandler.of(modid, requiredClient, requiredServer);
+        return new NeoForgeNetworkHandler(modid, requiredClient, requiredServer);
+        //return NeoForgeNetworkHandler.of(modid, requiredClient, requiredServer);
    }

    @Override
--- a/NeoForge/src/main/java/com/hypherionmc/craterlib/network/CraterNeoForgeNetworkHandler.java
+++ b/NeoForge/src/main/java/com/hypherionmc/craterlib/network/CraterNeoForgeNetworkHandler.java
@@ -0,0 +1,103 @@
+package com.hypherionmc.craterlib.network;
+
+import com.hypherionmc.craterlib.CraterConstants;
+import com.hypherionmc.craterlib.core.networking.PacketRegistry;
+import com.hypherionmc.craterlib.core.networking.data.PacketContext;
+import com.hypherionmc.craterlib.core.networking.data.PacketHolder;
+import com.hypherionmc.craterlib.core.networking.data.PacketSide;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.LogicalSide;
+import net.neoforged.neoforge.network.PacketDistributor;
+import net.neoforged.neoforge.network.event.RegisterPayloadHandlerEvent;
+import net.neoforged.neoforge.network.handling.IPayloadHandler;
+import net.neoforged.neoforge.network.registration.IPayloadRegistrar;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Based on https://github.com/mysticdrew/common-networking/tree/1.20.4
+ */
+public class CraterNeoForgeNetworkHandler extends PacketRegistry {
+
+    private final Map<Class<?>, NeoForgePacketContainer> PACKETS = new HashMap<>();
+
+    public CraterNeoForgeNetworkHandler(PacketSide side) {
+        super(side);
+    }
+
+    @SubscribeEvent
+    public void register(final RegisterPayloadHandlerEvent event) {
+        if (!PACKETS.isEmpty()) {
+            PACKETS.forEach((type, container) -> {
+                final IPayloadRegistrar registrar = event.registrar(container.packetId().getNamespace());
+                registrar.common(
+                        container.packetId(),
+                        container.decoder(),
+                        container.handler());
+            });
+        }
+    }
+
+    protected <T> void registerPacket(PacketHolder<T> container) {
+        if (PACKETS.get(container.messageType()) == null) {
+            var packetContainer = new NeoForgePacketContainer<>(
+                    container.messageType(),
+                    container.packetId(),
+                    container.encoder(),
+                    decoder(container.decoder()),
+                    buildHandler(container.handler())
+            );
+
+            PACKETS.put(container.messageType(), packetContainer);
+        }
+    }
+
+    private <T> FriendlyByteBuf.Reader<NeoForgePacket<T>> decoder(Function<FriendlyByteBuf, T> decoder) {
+        return (buf -> {
+            T packet = decoder.apply(buf);
+            return new NeoForgePacket<T>(PACKETS.get(packet.getClass()), packet);
+        });
+    }
+
+    public <T> void sendToServer(T packet) {
+        this.sendToServer(packet, false);
+    }
+
+    public <T> void sendToServer(T packet, boolean ignoreCheck) {
+        NeoForgePacketContainer<T> container = PACKETS.get(packet.getClass());
+        try {
+            PacketDistributor.SERVER.noArg().send(new NeoForgePacket<>(container, packet));
+        } catch (Throwable t) {
+            CraterConstants.LOG.error("{} packet not registered on the client, this is needed.", packet.getClass(), t);
+        }
+    }
+
+    public <T> void sendToClient(T packet, ServerPlayer player) {
+        NeoForgePacketContainer<T> container = PACKETS.get(packet.getClass());
+        try {
+            if (player.connection.isConnected(container.packetId())) {
+                PacketDistributor.PLAYER.with(player).send(new NeoForgePacket<>(container, packet));
+            }
+        } catch (Throwable t) {
+            CraterConstants.LOG.error("{} packet not registered on the server, this is needed.", packet.getClass(), t);
+        }
+    }
+
+    private <T, K extends NeoForgePacket<T>> IPayloadHandler<K> buildHandler(Consumer<PacketContext<T>> handler) {
+        return (payload, ctx) -> {
+            try {
+                PacketSide side = ctx.flow().getReceptionSide().equals(LogicalSide.SERVER) ? PacketSide.SERVER : PacketSide.CLIENT;
+                Player player = ctx.player().orElse(null);
+                handler.accept(new PacketContext<>(player, payload.packet(), side));
+            } catch (Throwable t) {
+                CraterConstants.LOG.error("Error handling packet: {} -> ", payload.packet().getClass(), t);
+            }
+        };
+    }
+}
--- a/NeoForge/src/main/java/com/hypherionmc/craterlib/network/NeoForgeNetworkHandler.java
+++ b/NeoForge/src/main/java/com/hypherionmc/craterlib/network/NeoForgeNetworkHandler.java
@@ -1,129 +1,35 @@
 package com.hypherionmc.craterlib.network;

-import com.google.common.collect.Maps;
 import com.hypherionmc.craterlib.core.network.CraterNetworkHandler;
 import com.hypherionmc.craterlib.core.network.CraterPacket;
 import com.hypherionmc.craterlib.core.network.PacketDirection;
-import com.hypherionmc.craterlib.core.platform.ClientPlatform;
-import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.protocol.Packet;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Player;
-import net.neoforged.fml.LogicalSide;
-import net.neoforged.neoforge.common.util.LogicalSidedProvider;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.NetworkRegistry;
-import net.neoforged.neoforge.network.PlayNetworkDirection;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
-import net.neoforged.neoforge.network.simple.SimpleChannel;

-import java.util.Map;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.BiConsumer;
-import java.util.function.Function;
 import java.util.function.Supplier;

 /**
 * @author HypherionSA
 * Partly inspired by and based on <a href="https://github.com/Fuzss/puzzleslib/blob/1.19/Forge/src/main/java/fuzs/puzzleslib/network/ForgeNetworkHandler.java">...</a>
 */
+@Deprecated(forRemoval = true)
 public class NeoForgeNetworkHandler implements CraterNetworkHandler {

-    private static final Map<String, NeoForgeNetworkHandler> NETWORK_HANDLERS = Maps.newConcurrentMap();
-    private static final String PROTOCOL = Integer.toString(1);

-    private final SimpleChannel channel;
-
-    private final boolean clientRequired;
-
-    private final boolean serverRequired;
-
-    private final AtomicInteger packetID = new AtomicInteger();
-
-    private NeoForgeNetworkHandler(SimpleChannel channel, boolean clientRequired, boolean serverRequired) {
-        this.channel = channel;
-        this.clientRequired = clientRequired;
-        this.serverRequired = serverRequired;
-    }
-
-    public synchronized static CraterNetworkHandler of(String modId, boolean clientRequired, boolean serverRequired) {
-        NeoForgeNetworkHandler handler = NETWORK_HANDLERS.computeIfAbsent(modId, modId1 -> new NeoForgeNetworkHandler(buildSimpleChannel(modId1, clientRequired, serverRequired), clientRequired, serverRequired));
-        if (handler.clientRequired != clientRequired)
-            throw new IllegalArgumentException("client channel settings mismatch, expected %s, but was %s".formatted(handler.clientRequired, clientRequired));
-        if (handler.serverRequired != serverRequired)
-            throw new IllegalArgumentException("server channel settings mismatch, expected %s, but was %s".formatted(handler.serverRequired, serverRequired));
-        return handler;
-    }
-
-    private static SimpleChannel buildSimpleChannel(String modId, boolean clientAcceptsVanillaOrMissing, boolean serverAcceptsVanillaOrMissing) {
-        return NetworkRegistry.ChannelBuilder
-                .named(new ResourceLocation(modId, "crater_network"))
-                .networkProtocolVersion(() -> PROTOCOL)
-                .clientAcceptedVersions(clientAcceptsVanillaOrMissing ? NetworkRegistry.acceptMissingOr(PROTOCOL) : PROTOCOL::equals)
-                .serverAcceptedVersions(serverAcceptsVanillaOrMissing ? NetworkRegistry.acceptMissingOr(PROTOCOL) : PROTOCOL::equals)
-                .simpleChannel();
+    public NeoForgeNetworkHandler(String modid, boolean requiredClient, boolean requiredServer) {
    }

    @Override
    public <T extends CraterPacket<T>> void registerPacket(Class<T> clazz, Supplier<T> supplier, PacketDirection packetDirection) {
-        BiConsumer<T, FriendlyByteBuf> encoder = CraterPacket::write;
-        Function<FriendlyByteBuf, T> decoder = buf -> {
-            T packet = supplier.get();
-            packet.read(buf);
-            return packet;
-        };

-        BiConsumer<T, NetworkEvent.Context> handler = (packet, ctx) -> {
-            LogicalSide expectedSide = getSideFromDirection(packetDirection);
-            LogicalSide currentSide = ctx.getDirection().getReceptionSide();
-
-            if (expectedSide != currentSide) {
-                throw new IllegalStateException(String.format("Received message on wrong side, expected %s, was %s", expectedSide, currentSide));
-            }
-
-            ctx.enqueueWork(() -> {
-                Player player;
-                if (packetDirection == PacketDirection.TO_CLIENT) {
-                    player = ClientPlatform.INSTANCE.getClientPlayer();
-                } else {
-                    player = ctx.getSender();
-                }
-                packet.handle(player, LogicalSidedProvider.WORKQUEUE.get(expectedSide));
-            });
-            ctx.setPacketHandled(true);
-        };
-
-        this.channel.registerMessage(this.packetID.getAndIncrement(), clazz, encoder(encoder), decoder(decoder), buildHandler(handler));
    }

    @Override
    public Packet<?> toServerBound(CraterPacket<?> packet) {
-        return this.channel.toVanillaPacket(packet, PlayNetworkDirection.PLAY_TO_SERVER);
+        return null;
    }

    @Override
    public Packet<?> toClientBound(CraterPacket<?> packet) {
-        return this.channel.toVanillaPacket(packet, PlayNetworkDirection.PLAY_TO_CLIENT);
-    }
-
-    @Override
-    public void sendToServer(CraterPacket<?> packet) {
-        CraterNetworkHandler.super.sendToServer(packet);
-    }
-
-    private LogicalSide getSideFromDirection(PacketDirection direction) {
-        return direction == PacketDirection.TO_CLIENT ? LogicalSide.CLIENT : LogicalSide.SERVER;
-    }
-
-    private <T> MessageFunctions.MessageEncoder<T> encoder(BiConsumer<T, FriendlyByteBuf> encoder) {
-        return encoder::accept;
-    }
-
-    private <T> MessageFunctions.MessageDecoder<T> decoder(Function<FriendlyByteBuf, T> decoder) {
-        return decoder::apply;
-    }
-
-    private <T> MessageFunctions.MessageConsumer<T> buildHandler(BiConsumer<T, NetworkEvent.Context> handler) {
-        return (message, ctx) -> handler.accept(message, ctx);
+        return null;
    }
 }
--- a/NeoForge/src/main/java/com/hypherionmc/craterlib/network/NeoForgePacket.java
+++ b/NeoForge/src/main/java/com/hypherionmc/craterlib/network/NeoForgePacket.java
@@ -0,0 +1,23 @@
+package com.hypherionmc.craterlib.network;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+
+/**
+ * Based on https://github.com/mysticdrew/common-networking/tree/1.20.4
+ */
+public record NeoForgePacket<T>(NeoForgePacketContainer<T> container, T packet) implements CustomPacketPayload {
+
+    @Override
+    public void write(FriendlyByteBuf buff)
+    {
+        container().encoder().accept(packet(), buff);
+    }
+
+    @Override
+    public ResourceLocation id()
+    {
+        return container().packetId();
+    }
+}
--- a/NeoForge/src/main/java/com/hypherionmc/craterlib/network/NeoForgePacketContainer.java
+++ b/NeoForge/src/main/java/com/hypherionmc/craterlib/network/NeoForgePacketContainer.java
@@ -0,0 +1,16 @@
+package com.hypherionmc.craterlib.network;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.network.handling.IPayloadHandler;
+
+import java.util.function.BiConsumer;
+
+/**
+ * Based on https://github.com/mysticdrew/common-networking/tree/1.20.4
+ */
+public record NeoForgePacketContainer<T>(Class<T> messageType,
+                                         ResourceLocation packetId,
+                                         BiConsumer<T, FriendlyByteBuf> encoder,
+                                         FriendlyByteBuf.Reader<NeoForgePacket<T>> decoder,
+                                         IPayloadHandler<NeoForgePacket<T>> handler) { }
--- a/NeoForge/src/main/resources/META-INF/mods.toml
+++ b/NeoForge/src/main/resources/META-INF/mods.toml
@@ -19,13 +19,13 @@ displayTest = "MATCH_VERSION"
 [[dependencies.${ mod_id }]]
 modId = "neoforge"
 mandatory = true
-versionRange = "[20.3,)"
+versionRange = "[20.4,)"
 ordering = "NONE"
 side = "BOTH"

 [[dependencies.${ mod_id }]]
 modId = "minecraft"
 mandatory = true
-versionRange = "[1.20.3,1.21)"
+versionRange = "[1.20.4,1.21)"
 ordering = "NONE"
 side = "BOTH"