adding new amendments; amendment version updating

common/src/main/java/net/lerariemann/infinity/compat/cloth/AmendmentConfigFactory.java

···
 import me.shedaniel.clothconfig2.api.Requirement;
 import me.shedaniel.clothconfig2.api.ValueHolder;
 import me.shedaniel.clothconfig2.gui.entries.DropdownBoxEntry;
+import me.shedaniel.clothconfig2.gui.entries.SubCategoryListEntry;
 import me.shedaniel.clothconfig2.impl.builders.DropdownMenuBuilder;
 import me.shedaniel.clothconfig2.impl.builders.SubCategoryBuilder;
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
 import net.minecraft.nbt.NbtString;
-import net.minecraft.text.Style;
 import net.minecraft.text.Text;
 
 import java.util.*;
···
         var elements = amendmentList.getAsJsonArray("elements");
         int numAmendments = 0;
         for (JsonElement amendmentElement : elements) {
-            numAmendments = AmendmentBuilder.addNew(builder, amendmentElement, numAmendments, amendmentCategory);
+            amendmentCategory.addEntry(AmendmentBuilder.getNew(builder, amendmentElement, numAmendments));
+            numAmendments++;
         }
-        // todo new amendments
-//        addAmendment(builder, null, i, amendmentCategory);
-        amendmentCategory.addEntry(builder.entryBuilder().startTextDescription(Text.literal("To add new entries, edit amendments.json.").setStyle(Style.EMPTY)).build());
+
+        var moreAmendments = builder.entryBuilder().startIntField(Text.literal("Add more amendments:"), 0).setMax(10).build();
+        amendmentCategory.addEntry(moreAmendments);
+        for (int i = 0; i < 10; i++) {
+            amendmentCategory.addEntry(AmendmentBuilder.getShadow(builder, numAmendments, moreAmendments, i));
+            numAmendments++;
+        }
     }
 
     interface AmendmentUpdater<T> {
···
         AmendmentUpdater<List<String>> ofStringList = new AmendmentUpdater<>() {
             @Override
             public boolean check(NbtCompound amendment, String key, List<String> value) {
-                // TODO Check if an amendment should be changed before writing
-                return true;
+                var list = NbtUtils.getList(amendment, key, NbtElement.STRING_TYPE);
+                StringBuilder a = new StringBuilder();
+                StringBuilder b = new StringBuilder();
+                for (NbtElement s: list) a.append(s.asString());
+                for (String s: value) b.append(s);
+                return !Objects.equals(a.toString(), b.toString());
             }
             @Override
             public void update(NbtCompound amendment, String key, List<String> value) {
···
         };
     }
 
-    record StaticStringValueHolder(String s) implements ValueHolder<String> {
-        @Override
-        public String getValue() {
-            return s;
-        }
-    }
-    static ValueHolder<String> hold(String s) {
-        return new StaticStringValueHolder(s);
+    static Requirement always = () -> true;
+    static Requirement matches(ValueHolder<String> holder, String m) {
+        return () -> Objects.equals(holder.getValue(), m);
     }
 
     static class AmendmentBuilder {
···
             this.amendment = amendment;
         }
 
-        static Requirement always = () -> true;
-
         void build() {
             var area = addStringDropdownOption("area", always,
                     Lists.newArrayList("blocks", "fluids", "items", "structures", "trees", "mobs"));
···
 
             var selector = addStringDropdownOption("selector", always,
                     Lists.newArrayList("all", "matching", "matching_any", "matching_block_tag", "containing"));
-            addListOption("matching",
-                    Requirement.matches(selector, hold("matching_any")));
-            addStringOption("matching",
-                    Requirement.matches(selector, hold("matching")));
-            addStringOption("matching",
-                    Requirement.matches(selector, hold("matching_block_tag")));
+            addListOption("matching_any", matches(selector, "matching_any"));
+            addStringOption("matching", matches(selector, "matching"));
+            addStringOption("containing", matches(selector, "containing"));
+            addStringOption("matching_block_tag", matches(selector, "matching_block_tag"));
 
             var results = addStringDropdownOption("results", always,
                     Lists.newArrayList("set_value", "set_field", "erase"));
-            addDoubleOption("value",
-                    Requirement.matches(results, hold("set_value")));
+            addDoubleOption("value", matches(results, "set_value"));
             addStringDropdownOption("field_name",
-                    Requirement.all(Requirement.matches(area, hold("blocks")), Requirement.matches(results, hold("set_field"))),
+                    Requirement.all(matches(area, "blocks"), matches(results, "set_field")),
                     Lists.newArrayList("full", "float", "top", "laggy"));
         }
 
···
         }
 
         <T> void amendmentSetter(String name, T newValue, int amendmentIndex, AmendmentUpdater<T> updater) {
-            NbtCompound elements = readNbt(configPath()+("/amendments.json"));
-            NbtCompound amendmentNbt = elements.getList("elements", 10).getCompound(amendmentIndex);
+            NbtCompound elements = readNbt(configPath()+"/amendments.json");
+            NbtList list = elements.getList("elements", 10);
+            NbtCompound amendmentNbt = list.getCompound(amendmentIndex);
+
             // Check if an amendment should be changed before writing
             if (updater.check(amendmentNbt, name, newValue)) {
                 updater.update(amendmentNbt, name, newValue);
+                updateAmendmentVersion(elements);
                 CommonIO.write(elements, configPath(), "amendments.json");
-                amendment = readJson(configPath()+("/amendments.json"))
-                        .getAsJsonObject()
-                        .getAsJsonArray("elements")
-                        .get(amendmentIndex)
-                        .getAsJsonObject();
             }
         }
 
-        static int addNew(ConfigBuilder builder, JsonElement amendmentElement, int i, ConfigCategory amendmentCategory) {
-            JsonObject amendment;
-            SubCategoryBuilder subCategory;
-            if (amendmentElement != null) {
-                subCategory = builder.entryBuilder().startSubCategory(Text.translatable("config.infinity.amendment", String.valueOf(i)));
-                amendment = amendmentElement.getAsJsonObject();
-            } else {
-                subCategory = builder.entryBuilder().startSubCategory(Text.translatable("config.infinity.amendment.new"));
-                amendment = new JsonObject();
+        static SubCategoryListEntry getNew(ConfigBuilder builder, JsonElement amendmentElement, int i) {
+            JsonObject amendment = amendmentElement.getAsJsonObject();;
+            SubCategoryBuilder subCategory = builder.entryBuilder().startSubCategory(Text.translatable("config.infinity.amendment", String.valueOf(i)));
+
+            (new AmendmentBuilder(builder, subCategory, i, amendment)).build();
+            return subCategory.build();
+        }
+
+        static SubCategoryListEntry getShadow(ConfigBuilder builder, int i, ValueHolder<Integer> shadowAmount, int shadowI) {
+            SubCategoryBuilder subCategory = builder.entryBuilder()
+                    .startSubCategory(Text.translatable("config.infinity.amendment.new"))
+                    .setDisplayRequirement(() -> shadowAmount.getValue() > shadowI);
+
+            (new NewAmendmentBuilder(builder, subCategory, i)).build();
+            return subCategory.build();
+        }
+
+        static void updateAmendmentVersion(NbtCompound elements) {
+            elements.putInt("amendment_version", (int)((System.currentTimeMillis() - 1754769333185L)/1000));
+        }
+    }
+
+    static class NewAmendmentBuilder extends AmendmentBuilder {
+        NewAmendmentBuilder(ConfigBuilder builder, SubCategoryBuilder subCategory, int i) {
+            super(builder, subCategory, i, new JsonObject());
+        }
+
+        @Override
+        <T> void amendmentSetter(String name, T newValue, int amendmentIndex, AmendmentUpdater<T> updater) {
+            NbtCompound elements = readNbt(configPath()+"/amendments.json");
+            NbtList list = elements.getList("elements", 10);
+            if (amendmentIndex < list.size()) {
+                super.amendmentSetter(name, newValue, amendmentIndex, updater);
+                return;
             }
+            NbtCompound amendmentNbt = new NbtCompound();
 
-            (new AmendmentBuilder(builder, subCategory, i, amendment)).build();
-            amendmentCategory.addEntry(subCategory.build());
-            i++;
-            return i;
+            // Check if an amendment should be changed before writing
+            if (updater.check(amendmentNbt, name, newValue)) {
+                updater.update(amendmentNbt, name, newValue);
+                list.add(amendmentNbt);
+                updateAmendmentVersion(elements);
+                CommonIO.write(elements, configPath(), "amendments.json");
+            }
         }
     }
 

common/src/main/java/net/lerariemann/infinity/util/config/Amendment.java

···
             return null;
         }
 
-        String mod = NbtUtils.getString(data, "mod");
+        String mod = NbtUtils.getString(data, "mod", "");
         ModSelector modSelector;
         if (mod.equals("all")) {
             modSelector = new UniversalModSelector();
···
             case "all" -> new UniversalSelector();
             case "containing" -> new ContainingSelector(NbtUtils.getString(data, "containing"));
             case "matching" -> new MatchingSelector(NbtUtils.getString(data, "matching"));
-            case "matching_block_tag" -> new MatchingBlockTagSelector(NbtUtils.getString(data, "matching"));
-            case "matching_any" -> new MatchingAnySelector(NbtUtils.getList(data, "matching", NbtElement.STRING_TYPE)
+            case "matching_block_tag" -> new MatchingBlockTagSelector(NbtUtils.getString(data, "matching_block_tag"));
+            case "matching_any" -> new MatchingAnySelector(NbtUtils.getList(data, "matching_any", NbtElement.STRING_TYPE)
                     .stream().map(e->(NbtString)e).map(NbtString::asString).toList());
             default -> {
                 InfinityMod.LOGGER.warn("Unknown amendment selector type: {}", selectorType);
···
             }
         };
 
-        String resultType = NbtUtils.getString(data, "results");
+        String resultType = NbtUtils.getString(data, "results", "");
         Results results = switch (resultType) {
             case "set_value" -> new SetValue(NbtUtils.getInt(data, "value"));
             case "erase" -> new SetValue(0);

common/src/main/resources/config/amendments.json

···
 {
-  "amendment_version": 0,
+  "amendment_version": 1,
   "elements": [
     {
       "area": "fluids",
···
       "area": "blocks",
       "mod": "minecraft",
       "selector": "matching_any",
-      "matching": [
+      "matching_any": [
         "minecraft:slime_block",
         "minecraft:honey_block",
         "minecraft:mangrove_roots"