Fix NetworkChannel client-server desync

common/src/main/java/me/shedaniel/architectury/networking/NetworkChannel.java

@@ -19,11 +19,9 @@
 
 package me.shedaniel.architectury.networking;
 
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Table;
+import com.google.common.collect.Maps;
+import com.mojang.datafixers.util.Pair;
 import io.netty.buffer.Unpooled;
-import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
-import it.unimi.dsi.fastutil.ints.IntSet;
 import me.shedaniel.architectury.networking.NetworkManager.PacketContext;
 import me.shedaniel.architectury.platform.Platform;
 import me.shedaniel.architectury.utils.Env;
@@ -34,8 +32,9 @@ import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.protocol.Packet;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.lang3.StringUtils;
 
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.BiConsumer;
@@ -47,8 +46,7 @@ import java.util.function.Supplier;
  */
 public final class NetworkChannel {
     private final ResourceLocation id;
-    private final IntSet takenIds = new IntOpenHashSet();
-    private final Table<NetworkManager.Side, Class<?>, Pair<ResourceLocation, BiConsumer<?, FriendlyByteBuf>>> encoders = HashBasedTable.create();
+    private final Map<Class<?>, MessageInfo<?>> encoders = Maps.newHashMap();
     
     private NetworkChannel(ResourceLocation id) {
         this.id = id;
@@ -60,70 +58,66 @@ public final class NetworkChannel {
     
     @Deprecated
     public <T> void register(NetworkManager.Side side, Class<T> type, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
-        register(Optional.empty(), type, encoder, decoder, messageConsumer);
+        register(type, encoder, decoder, messageConsumer);
     }
     
     @Deprecated
     public <T> void register(Optional<NetworkManager.Side> side, Class<T> type, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
-        for (int i = 0; true; i++) {
-            if (!takenIds.contains(i)) {
-                register(side, i, type, encoder, decoder, messageConsumer);
-                break;
-            }
-        }
+        register(type, encoder, decoder, messageConsumer);
     }
     
     public <T> void register(Class<T> type, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
-        for (int i = 0; true; i++) {
-            if (!takenIds.contains(i)) {
-                register(i, type, encoder, decoder, messageConsumer);
-                break;
-            }
+        String s = StringUtils.leftPad(String.valueOf(hashCodeString(type.toString())), 10, '0');
+        if (s.length() > 10) s = s.substring(0, 10);
+        MessageInfo<T> info = new MessageInfo<>(new ResourceLocation(id + "_" + s), encoder, decoder, messageConsumer);
+        encoders.put(type, info);
+        NetworkManager.NetworkReceiver receiver = (buf, context) -> {
+            info.messageConsumer.accept(info.decoder.apply(buf), () -> context);
+        };
+        NetworkManager.registerReceiver(NetworkManager.clientToServer(), info.packetId, receiver);
+        if (Platform.getEnvironment() == Env.CLIENT) {
+            NetworkManager.registerReceiver(NetworkManager.serverToClient(), info.packetId, receiver);
         }
     }
     
+    public static long hashCodeString(String str) {
+        long h = 0;
+        int length = str.length();
+        for (int i = 0; i < length; i++) {
+            h = 31 * h + str.charAt(i);
+        }
+        return h;
+    }
+    
+    @Deprecated
     public <T> void register(int id, Class<T> type, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
-        register(Optional.empty(), id, type, encoder, decoder, messageConsumer);
+        register(type, encoder, decoder, messageConsumer);
     }
     
     @Deprecated
     public <T> void register(NetworkManager.Side side, int id, Class<T> type, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
-        register(Optional.ofNullable(side), id, type, encoder, decoder, messageConsumer);
+        register(type, encoder, decoder, messageConsumer);
     }
     
     @Deprecated
     public <T> void register(Optional<NetworkManager.Side> side, int id, Class<T> type, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
-        takenIds.add(id);
-        ResourceLocation messageId = new ResourceLocation(this.id.getNamespace(), this.id.getPath() + "_" + id);
-        
-        if (Platform.getEnvironment() == Env.CLIENT) {
-            NetworkManager.registerReceiver(NetworkManager.s2c(), messageId, (buf, context) -> {
-                messageConsumer.accept(decoder.apply(buf), () -> context);
-            });
-        }
-        encoders.put(NetworkManager.s2c(), type, Pair.of(messageId, encoder));
-        
-        NetworkManager.registerReceiver(NetworkManager.c2s(), messageId, (buf, context) -> {
-            messageConsumer.accept(decoder.apply(buf), () -> context);
-        });
-        encoders.put(NetworkManager.c2s(), type, Pair.of(messageId, encoder));
+        register(type, encoder, decoder, messageConsumer);
     }
     
-    private <T> Pair<ResourceLocation, FriendlyByteBuf> encode(NetworkManager.Side side, T message) {
-        Pair<ResourceLocation, BiConsumer<?, FriendlyByteBuf>> pair = Objects.requireNonNull(encoders.get(side, message.getClass()));
+    private <T> Pair<MessageInfo<T>, FriendlyByteBuf> encode(T message) {
+        MessageInfo<T> messageInfo = (MessageInfo<T>) Objects.requireNonNull(encoders.get(message.getClass()));
         FriendlyByteBuf buf = new FriendlyByteBuf(Unpooled.buffer());
-        ((BiConsumer<T, FriendlyByteBuf>) pair.getRight()).accept(message, buf);
-        return Pair.of(pair.getLeft(), buf);
+        messageInfo.encoder.accept(message, buf);
+        return new Pair<>(messageInfo, buf);
     }
     
     public <T> Packet<?> toPacket(NetworkManager.Side side, T message) {
-        Pair<ResourceLocation, FriendlyByteBuf> encoded = encode(side, message);
-        return NetworkManager.toPacket(side, encoded.getLeft(), encoded.getRight());
+        Pair<MessageInfo<T>, FriendlyByteBuf> encoded = encode(message);
+        return NetworkManager.toPacket(side, encoded.getFirst().packetId, encoded.getSecond());
     }
     
     public <T> void sendToPlayer(ServerPlayer player, T message) {
-        Pair<ResourceLocation, FriendlyByteBuf> encoded = encode(NetworkManager.s2c(), message);
-        NetworkManager.sendToPlayer(player, encoded.getLeft(), encoded.getRight());
+        player.connection.send(toPacket(NetworkManager.s2c(), message));
     }
     
     public <T> void sendToPlayers(Iterable<ServerPlayer> players, T message) {
@@ -140,10 +134,24 @@ public final class NetworkChannel {
     
     @Environment(EnvType.CLIENT)
     public <T> boolean canServerReceive(Class<T> type) {
-        return NetworkManager.canServerReceive(encoders.get(NetworkManager.c2s(), type).getLeft());
+        return NetworkManager.canServerReceive(encoders.get(type).packetId);
     }
     
     public <T> boolean canPlayerReceive(ServerPlayer player, Class<T> type) {
-        return NetworkManager.canPlayerReceive(player, encoders.get(NetworkManager.s2c(), type).getLeft());
+        return NetworkManager.canPlayerReceive(player, encoders.get(type).packetId);
+    }
+    
+    private static final class MessageInfo<T> {
+        private final ResourceLocation packetId;
+        private final BiConsumer<T, FriendlyByteBuf> encoder;
+        private final Function<FriendlyByteBuf, T> decoder;
+        private final BiConsumer<T, Supplier<PacketContext>> messageConsumer;
+        
+        public MessageInfo(ResourceLocation packetId, BiConsumer<T, FriendlyByteBuf> encoder, Function<FriendlyByteBuf, T> decoder, BiConsumer<T, Supplier<PacketContext>> messageConsumer) {
+            this.packetId = packetId;
+            this.encoder = encoder;
+            this.decoder = decoder;
+            this.messageConsumer = messageConsumer;
+        }
     }
 }