Give update module setting sync control to the config elements themselves

Author: pupnewfster

src/api/java/mekanism/api/gear/ModuleData.java

@@ -172,6 +172,18 @@ public void encode(RegistryFriendlyByteBuf buffer, List<ModuleConfig<?>> configs
         };
     }
 
+    //TODO - 1.20.5: Docs
+    @Nullable
+    public final ModuleConfig<?> getNamedConfig(int installed, String name) {
+        ConfigData data = this.configData.get(installed);
+        for (ModuleConfig<?> config : data.configs()) {
+            if (config.name().equals(name)) {
+                return config;
+            }
+        }
+        return null;
+    }
+
     //TODO - 1.20.5: Docs
     public final List<ModuleConfig<?>> defaultConfigs(int installed) {
         return this.configData.get(installed).configs();

src/api/java/mekanism/api/gear/config/ModuleBooleanConfig.java

@@ -29,6 +29,11 @@ public ModuleBooleanConfig(String name, boolean value) {
         this.value = value;
     }
 
+    @Override
+    public StreamCodec<ByteBuf, ModuleConfig<Boolean>> namedStreamCodec(String name) {
+        return ByteBufCodecs.BOOL.map(val -> new ModuleBooleanConfig(name, val), ModuleConfig::get);
+    }
+
     @Override
     public Boolean get() {
         return value;

src/api/java/mekanism/api/gear/config/ModuleColorConfig.java

@@ -88,6 +88,16 @@ public boolean supportsAlpha() {
         return supportsAlpha;
     }
 
+    @Override
+    public StreamCodec<ByteBuf, ModuleConfig<Integer>> namedStreamCodec(String name) {
+        if (supportsAlpha) {
+            //Note: We don't do varint as we include alpha data
+            return ByteBufCodecs.INT.map(val -> ModuleColorConfig.argb(name, val), ModuleConfig::get);
+        }
+        //Note: We can use var int here and just not send the alpha data over the network
+        return ByteBufCodecs.VAR_INT.map(val -> ModuleColorConfig.rgb(name, val), module -> module.get() & 0x00FFFFFF);
+    }
+
     @Override
     public Integer get() {
         return value;

src/api/java/mekanism/api/gear/config/ModuleConfig.java

@@ -6,6 +6,8 @@
 import java.util.Objects;
 import mekanism.api.NBTConstants;
 import mekanism.api.annotations.NothingNullByDefault;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.util.ExtraCodecs;
 
 //TODO - 1.20.5: Docs
@@ -35,6 +37,8 @@ public final String name() {
         return name;
     }
 
+    public abstract StreamCodec<? super RegistryFriendlyByteBuf, ModuleConfig<DATA>> namedStreamCodec(String name);
+
     public abstract DATA get();
 
     public abstract ModuleConfig<DATA> with(DATA value);

src/api/java/mekanism/api/gear/config/ModuleEnumConfig.java

@@ -9,8 +9,10 @@
 import mekanism.api.NBTConstants;
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.api.text.IHasTextComponent;
+import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.codec.ByteBufCodecs;
 import net.minecraft.network.codec.StreamCodec;
+import net.neoforged.neoforge.network.codec.NeoForgeStreamCodecs;
 
 //TODO - 1.20.5: Docs
 @NothingNullByDefault
@@ -99,6 +101,14 @@ private ModuleEnumConfig(String name, TYPE value, List<TYPE> enumConstants) {
         this.enumConstants = enumConstants;
     }
 
+    @Override
+    public StreamCodec<FriendlyByteBuf, ModuleConfig<TYPE>> namedStreamCodec(String name) {
+        return NeoForgeStreamCodecs.enumCodec(value.getDeclaringClass()).map(
+              value -> new ModuleEnumConfig<>(name, value, enumConstants),
+              ModuleConfig::get
+        );
+    }
+
     @Override
     public TYPE get() {
         return value;

src/main/java/mekanism/client/gui/GuiModuleTweaker.java

@@ -57,7 +57,7 @@ public GuiModuleTweaker(ModuleTweakerContainer container, Inventory inv, Compone
                 IModule<?> module = moduleScreen.getCurrentModule();
                 if (module != null && selected != -1) {//Shouldn't be null but validate just in case
                     int slotIndex = menu.slots.get(selected).getSlotIndex();
-                    PacketUtils.sendToServer(PacketUpdateModuleSettings.create(slotIndex, module.getData(), configItem));
+                    PacketUtils.sendToServer(PacketUpdateModuleSettings.create(slotIndex, module.getData(), module.getInstalledCount(), configItem));
                 }
             }
         };

src/main/java/mekanism/common/content/gear/mekatool/ModuleVeinMiningUnit.java

@@ -264,6 +264,11 @@ public ModuleExtendedModeConfig(String name, boolean value) {
             super(name, value);
         }
 
+        @Override
+        public StreamCodec<ByteBuf, ModuleConfig<Boolean>> namedStreamCodec(String name) {
+            return ByteBufCodecs.BOOL.map(val -> new ModuleExtendedModeConfig(name, val), ModuleConfig::get);
+        }
+
         @Override
         public ModuleBooleanConfig with(Boolean value) {
             Objects.requireNonNull(value, "Value cannot be null.");

src/main/java/mekanism/common/network/to_server/PacketUpdateModuleSettings.java

@@ -1,15 +1,10 @@
 package mekanism.common.network.to_server;
 
-import io.netty.buffer.ByteBuf;
-import java.util.function.IntFunction;
-import java.util.function.Predicate;
+import io.netty.handler.codec.DecoderException;
 import mekanism.api.MekanismAPI;
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.api.gear.ModuleData;
-import mekanism.api.gear.config.ModuleBooleanConfig;
-import mekanism.api.gear.config.ModuleColorConfig;
 import mekanism.api.gear.config.ModuleConfig;
-import mekanism.api.gear.config.ModuleEnumConfig;
 import mekanism.common.Mekanism;
 import mekanism.common.content.gear.Module;
 import mekanism.common.content.gear.ModuleContainer;
@@ -19,40 +14,24 @@
 import net.minecraft.network.codec.ByteBufCodecs;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
-import net.minecraft.util.ByIdMap;
 import net.minecraft.world.item.ItemStack;
 import net.neoforged.neoforge.network.handling.IPayloadContext;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 //TODO: Eventually it would be nice to make this more generic in terms of how it can sync module data so that we can support custom types
 // though given the module tweaker screen doesn't currently have a way to support custom types it isn't that big a deal to make this support it yet either
 @NothingNullByDefault
-public record PacketUpdateModuleSettings(int slotId, ModuleData<?> moduleType, String data, TypedValue value) implements IMekanismPacket {
+public record PacketUpdateModuleSettings(int slotId, ModuleConfigTarget<?> target) implements IMekanismPacket {
 
     public static final CustomPacketPayload.Type<PacketUpdateModuleSettings> TYPE = new CustomPacketPayload.Type<>(Mekanism.rl("update_module"));
     public static final StreamCodec<RegistryFriendlyByteBuf, PacketUpdateModuleSettings> STREAM_CODEC = StreamCodec.composite(
           ByteBufCodecs.VAR_INT, PacketUpdateModuleSettings::slotId,
-          ByteBufCodecs.registry(MekanismAPI.MODULE_REGISTRY_NAME), PacketUpdateModuleSettings::moduleType,
-          ByteBufCodecs.STRING_UTF8, PacketUpdateModuleSettings::data,
-          TypedValue.STREAM_CODEC, PacketUpdateModuleSettings::value,
+          ModuleConfigTarget.STREAM_CODEC, PacketUpdateModuleSettings::target,
           PacketUpdateModuleSettings::new
     );
 
-    private PacketUpdateModuleSettings(int slotId, ModuleData<?> moduleType, String data, ModuleDataType dataType, Object value) {
-        this(slotId, moduleType, data, new TypedValue(dataType, value));
-    }
-
-    public static PacketUpdateModuleSettings create(int slotId, ModuleData<?> moduleType, ModuleConfig<?> config) {
-        if (config instanceof ModuleEnumConfig<?> enumData) {
-            return new PacketUpdateModuleSettings(slotId, moduleType, config.name(), ModuleDataType.ENUM, enumData.get().ordinal());
-        }
-        for (ModuleDataType type : ModuleDataType.VALUES) {
-            if (type.typeMatches(config)) {
-                return new PacketUpdateModuleSettings(slotId, moduleType, config.name(), type, config.get());
-            }
-        }
-        throw new IllegalArgumentException("Unknown config data type for config with name: " + config.name());
+    public static PacketUpdateModuleSettings create(int slotId, ModuleData<?> moduleType, int installed, ModuleConfig<?> config) {
+        return new PacketUpdateModuleSettings(slotId, new ModuleConfigTarget<>(moduleType, installed, config));
     }
 
     @NotNull
@@ -63,72 +42,39 @@ public CustomPacketPayload.Type<PacketUpdateModuleSettings> type() {
 
     @Override
     public void handle(IPayloadContext context) {
-        if (!data.isBlank()) {
-            ItemStack stack = context.player().getInventory().getItem(slotId);
-            ModuleContainer container = ModuleHelper.get().getModuleContainer(stack);
-            if (container != null) {
-                Module<?> module = container.get(moduleType);
-                if (module != null) {
-                    ModuleConfig<?> config = updateConfig(module.getConfig(data));
-                    if (config != null) {
-                        container.replaceModuleConfig(stack, moduleType, config);
-                    }
-                }
-            }
-        }
-    }
-
-    @Nullable
-    private <TYPE> ModuleConfig<?> updateConfig(@Nullable ModuleConfig<TYPE> configData) {
-        if (configData != null) {
-            try {
-                if (configData instanceof ModuleEnumConfig<?> config && value.type() == ModuleDataType.ENUM) {
-                    return config.with((int) value.value());
-                } else if (value.type().typeMatches(configData)) {
-                    //noinspection unchecked
-                    return configData.with((TYPE) value.value());
-                }
-            } catch (IllegalArgumentException ignored) {
-                //Ideally we will never have this be thrown, but if for some reason we get bad data it might be, and then we want to ignore it
-                //TODO - 1.20.5: Instead of just ignoring this maybe we should disconnect the client via the IPayloadContext?
+        ItemStack stack = context.player().getInventory().getItem(slotId);
+        ModuleContainer container = ModuleHelper.get().getModuleContainer(stack);
+        if (container != null) {
+            Module<?> module = container.get(target.moduleType());
+            if (module != null) {
+                //TODO - 1.20.5: Validate the config is at a valid level/in bounds for it, such as if it is a limited range enum value
+                // maybe we want the server to do a config.with itself?
+                container.replaceModuleConfig(stack, target.moduleType(), target.config());
             }
         }
-        return null;
     }
 
-    private enum ModuleDataType {
-        //TODO - 1.20.5: Can we make use of the module config stream codecs somehow?
-        BOOLEAN(data -> data instanceof ModuleBooleanConfig, ByteBufCodecs.BOOL),
-        //Must be above integer, so it uses the color type as ModuleColorData extends ModuleIntegerData
-        COLOR(data -> data instanceof ModuleColorConfig, ByteBufCodecs.INT),
-        ENUM(data -> data instanceof ModuleEnumConfig, ByteBufCodecs.VAR_INT);
+    public record ModuleConfigTarget<C>(ModuleData<?> moduleType, int installed, ModuleConfig<C> config) {
 
-        public static final IntFunction<ModuleDataType> BY_ID = ByIdMap.continuous(ModuleDataType::ordinal, values(), ByIdMap.OutOfBoundsStrategy.WRAP);
-        public static final StreamCodec<ByteBuf, ModuleDataType> STREAM_CODEC = ByteBufCodecs.idMapper(BY_ID, ModuleDataType::ordinal);
+        private static final StreamCodec<RegistryFriendlyByteBuf, ModuleData<?>> REGISTRY_CODEC = ByteBufCodecs.registry(MekanismAPI.MODULE_REGISTRY_NAME);
+        public static final StreamCodec<RegistryFriendlyByteBuf, ModuleConfigTarget<?>> STREAM_CODEC = StreamCodec.ofMember(ModuleConfigTarget::encode, ModuleConfigTarget::decode);
 
-        //DO NOT MODIFY
-        private static final ModuleDataType[] VALUES = values();
-
-        private final Predicate<ModuleConfig<?>> configDataPredicate;
-        private final StreamCodec<ByteBuf, Object> streamCodec;
-
-        ModuleDataType(Predicate<ModuleConfig<?>> configDataPredicate, StreamCodec<ByteBuf, ?> streamCodec) {
-            this.configDataPredicate = configDataPredicate;
-            this.streamCodec = (StreamCodec<ByteBuf, Object>) streamCodec;
-        }
-
-        public boolean typeMatches(ModuleConfig<?> data) {
-            return configDataPredicate.test(data);
+        private static ModuleConfigTarget<?> decode(RegistryFriendlyByteBuf buffer) {
+            ModuleData<?> moduleType = REGISTRY_CODEC.decode(buffer);
+            int installed = buffer.readVarInt();
+            String name = buffer.readUtf();
+            ModuleConfig<?> defaultConfig = moduleType.getNamedConfig(installed, name);
+            if (defaultConfig == null) {
+                throw new DecoderException("Unknown config " + name + " for module type: " + moduleType + " with " + installed + " modules installed");
+            }
+            return new ModuleConfigTarget<>(moduleType, installed, defaultConfig.namedStreamCodec(name).decode(buffer));
         }
 
-        public StreamCodec<ByteBuf, Object> streamCodec() {
-            return streamCodec;
+        private void encode(RegistryFriendlyByteBuf buffer) {
+            REGISTRY_CODEC.encode(buffer, moduleType);
+            buffer.writeVarInt(installed);
+            buffer.writeUtf(config.name());
+            config.namedStreamCodec(config.name()).encode(buffer, config);
         }
     }
-
-    private record TypedValue(ModuleDataType type, Object value) {
-
-        private static final StreamCodec<ByteBuf, TypedValue> STREAM_CODEC = ModuleDataType.STREAM_CODEC.dispatch(TypedValue::type,
-              type -> type.streamCodec().map(value -> new TypedValue(type, value), TypedValue::value));
-    }
 }