shouldn't edit one file ten times in a row anymore

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

···
 package net.lerariemann.infinity.compat.cloth;
 
 import com.google.common.collect.Lists;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
 import me.shedaniel.clothconfig2.api.ConfigBuilder;
 import me.shedaniel.clothconfig2.api.ConfigCategory;
 import me.shedaniel.clothconfig2.api.Requirement;
···
 
 public class AmendmentConfigFactory {
     public static void build(ConfigBuilder builder) {
-        ConfigCategory amendmentCategory = builder.getOrCreateCategory(Text.translatable("config.infinity.title.amendments"));
-        JsonObject amendmentList = readJson(configPath()+("/amendments.json")).getAsJsonObject();
-        var elements = amendmentList.getAsJsonArray("elements");
-        int numAmendments = 0;
-        for (JsonElement amendmentElement : elements) {
-            amendmentCategory.addEntry(AmendmentBuilder.getNew(builder, amendmentElement, numAmendments));
-            numAmendments++;
+        AmendmentConfigFactory factory = new AmendmentConfigFactory(builder);
+        builder.setSavingRunnable(factory::save);
+    }
+
+    Map<Integer, NbtCompound> amendments = new HashMap<>();
+    boolean edited = false;
+    ConfigCategory amendmentCategory;
+    ConfigBuilder builder;
+
+    AmendmentConfigFactory(ConfigBuilder builder) {
+        this.builder = builder;
+
+        NbtList list = readNbt(configPath()+"/amendments.json").getList("elements", 10);
+        int N = list.size();
+        for (int i = 0; i < N; i++) if (list.get(i) instanceof NbtCompound e) {
+            amendments.put(i, e);
         }
 
-        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++;
+        //adding amendments from the disk
+        this.amendmentCategory = builder.getOrCreateCategory(Text.translatable("config.infinity.title.amendments"));
+        for (int i = 0; i < N; i++) {
+            amendmentCategory.addEntry(AmendmentBuilder.getNew(this, i));
+        }
+
+        //"button" to show new amendments
+        var moreAmendmentsField = builder.entryBuilder()
+                .startIntField(Text.translatable("config.infinity.amendments.addmore"), 0)
+                .setTooltip(amendmentTooltip("addmore"))
+                .setMax(10)
+                .build();
+        amendmentCategory.addEntry(moreAmendmentsField);
+
+        //empty fields to add new amendments
+        for (int i = N; i < N + 10; i++) {
+            amendments.put(i, new NbtCompound());
+            amendmentCategory.addEntry(AmendmentBuilder.getShadow(this, i, moreAmendmentsField, i - N));
+        }
+    }
+
+    void save() {
+        if (!edited) return;
+        NbtList elements = new NbtList();
+        var keys = amendments.keySet().stream().sorted().toList();
+        for (int k: keys) {
+            NbtCompound value = amendments.get(k);
+            if (!value.isEmpty()) elements.add(value);
         }
+        NbtCompound res = new NbtCompound();
+        res.putInt("amendment_version", (int)((System.currentTimeMillis() - 1754769333185L)/1000));
+        res.put("elements", elements);
+        CommonIO.write(res, configPath(), "amendments.json");
     }
 
     interface AmendmentUpdater<T> {
         boolean check(NbtCompound amendment, String key, T value);
-        void update(NbtCompound amendment, String key, T value);
+        NbtCompound update(NbtCompound amendment, String key, T value);
 
         AmendmentUpdater<String> ofString = new AmendmentUpdater<>() {
             @Override
···
             }
 
             @Override
-            public void update(NbtCompound amendment, String key, String value) {
+            public NbtCompound update(NbtCompound amendment, String key, String value) {
                 amendment.putString(key, value);
+                return amendment;
             }
         };
         AmendmentUpdater<Double> ofDouble = new AmendmentUpdater<>() {
···
             }
 
             @Override
-            public void update(NbtCompound amendment, String key, Double value) {
+            public NbtCompound update(NbtCompound amendment, String key, Double value) {
                 amendment.putDouble(key, value);
+                return amendment;
             }
         };
         AmendmentUpdater<List<String>> ofStringList = new AmendmentUpdater<>() {
···
                 return !Objects.equals(a.toString(), b.toString());
             }
             @Override
-            public void update(NbtCompound amendment, String key, List<String> value) {
+            public NbtCompound update(NbtCompound amendment, String key, List<String> value) {
                 amendment.put(key, convertNbtList(value));
+                return amendment;
             }
         };
     }
···
         return () -> Objects.equals(holder.getValue(), m);
     }
 
-    static class AmendmentBuilder {
-        ConfigBuilder builder;
-        SubCategoryBuilder subCategory;
-        int i;
-        JsonObject amendment;
-
-        AmendmentBuilder(ConfigBuilder builder, SubCategoryBuilder subCategory, int i, JsonObject amendment) {
-            this.builder = builder;
-            this.subCategory = subCategory;
-            this.i = i;
-            this.amendment = amendment;
+    record AmendmentBuilder(AmendmentConfigFactory parent, SubCategoryBuilder subCategory, int index) {
+        NbtCompound getData() {
+            return parent.amendments.get(index);
         }
 
         void build() {
···
             addStringDropdownOption("field_name",
                     Requirement.all(matches(area, "blocks"), matches(results, "set_field")),
                     Lists.newArrayList("full", "float", "top", "laggy"));
+            addDeleteButton();
+        }
+
+        private void addDeleteButton() {
+            subCategory.add(parent.builder.entryBuilder().startBooleanToggle(Text.translatable("config.infinity.amendments.delete"), false)
+                    .requireRestart()
+                    .setTooltip(amendmentTooltip("delete"))
+                    .setSaveConsumer((value) -> {
+                        if (value) deleteAmendment();
+                    })
+                    .build());
         }
 
         private void addStringOption(String name, Requirement req) {
-            String current = getSafeString(amendment, name);
-            subCategory.add(builder.entryBuilder().startStrField(
+            String current = NbtUtils.getString(getData(), name, "");
+            subCategory.add(parent.builder.entryBuilder().startStrField(
                             Text.translatable("config.infinity.amendments."+name),
                             current)
+                    .requireRestart()
                     .setTooltip(amendmentTooltip(name))
                     .setDisplayRequirement(req)
-                    .setSaveConsumer((value)-> amendmentSetter(name, value, i, AmendmentUpdater.ofString)).build());
+                    .setSaveConsumer((value)-> amendmentSetter(name, value, AmendmentUpdater.ofString)).build());
         }
 
         private DropdownBoxEntry<String> addStringDropdownOption(String name, Requirement req, List<String> options) {
-            String current = getSafeString(amendment, name);
-            DropdownBoxEntry<String> res = builder.entryBuilder().startDropdownMenu(Text.translatable("config.infinity.amendments."+name), DropdownMenuBuilder.TopCellElementBuilder.of(current, (s) -> s))
+            String current = NbtUtils.getString(getData(), name, "");
+            DropdownBoxEntry<String> res = parent.builder.entryBuilder().startDropdownMenu(
+                            Text.translatable("config.infinity.amendments."+name),
+                            DropdownMenuBuilder.TopCellElementBuilder.of(current, (s) -> s))
+                    .requireRestart()
                     .setTooltip(amendmentTooltip(name))
                     .setDisplayRequirement(req)
-                    .setSaveConsumer((value) -> amendmentSetter(name, String.valueOf(value), i, AmendmentUpdater.ofString))
+                    .setSaveConsumer((value) -> amendmentSetter(name, String.valueOf(value), AmendmentUpdater.ofString))
                     .setSelections(options).build();
             subCategory.add(res);
             return res;
         }
 
         private void addDoubleOption(String name, Requirement req) {
-            Double current = getSafeDouble(amendment, name);
-            subCategory.add(builder.entryBuilder().startDoubleField(
+            double current = NbtUtils.getDouble(getData(), name, 0d);
+            subCategory.add(parent.builder.entryBuilder().startDoubleField(
                             Text.translatable("config.infinity.amendments."+name),
                             current)
+                    .requireRestart()
                     .setTooltip(amendmentTooltip(name))
                     .setDisplayRequirement(req)
-                    .setSaveConsumer((value) -> amendmentSetter(name, value, i, AmendmentUpdater.ofDouble)).build());
+                    .setSaveConsumer((value) -> amendmentSetter(name, value, AmendmentUpdater.ofDouble)).build());
+        }
+
+        List<String> getSafeList(String name) {
+            NbtCompound data = getData();
+            if (data.contains(name, NbtElement.LIST_TYPE)) return convertNbtList(data.getList(name, NbtElement.STRING_TYPE));
+            return List.of("");
         }
 
         private void addListOption(String name, Requirement req) {
-            JsonElement list = amendment.get(name);
-            List<String> current = (list == null || !list.isJsonArray()) ? List.of("") : convertNbtList(list.getAsJsonArray());
-            if (!Objects.equals(current.getLast(), ""))
-                current.add("");
-            subCategory.add(builder.entryBuilder().startStrList(
+            List<String> current = getSafeList(name);
+            if (!Objects.equals(current.getLast(), "")) current.add("");
+            subCategory.add(parent.builder.entryBuilder().startStrList(
                             Text.translatable("config.infinity.amendments."+name),
                             current)
+                    .requireRestart()
                     .setTooltip(amendmentTooltip(name))
                     .setDisplayRequirement(req)
-                    .setSaveConsumer((value) -> amendmentSetter(name, value, i, AmendmentUpdater.ofStringList)).build());
+                    .setSaveConsumer((value) -> amendmentSetter(name, value, AmendmentUpdater.ofStringList)).build());
         }
 
-        <T> void amendmentSetter(String name, T newValue, int amendmentIndex, AmendmentUpdater<T> updater) {
-            NbtCompound elements = readNbt(configPath()+"/amendments.json");
-            NbtList list = elements.getList("elements", 10);
-            NbtCompound amendmentNbt = list.getCompound(amendmentIndex);
-
+        <T> void amendmentSetter(String key, T newValue, AmendmentUpdater<T> updater) {
+            NbtCompound amendmentNbt = getData();
             // 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");
+            if (updater.check(amendmentNbt, key, newValue)) {
+                amendmentNbt = updater.update(amendmentNbt, key, newValue);
+                parent.edited = true;
+                parent.amendments.put(index, amendmentNbt);
             }
         }
 
-        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)));
+        void deleteAmendment() {
+            parent.amendments.put(index, new NbtCompound());
+            parent.edited = true;
+        }
 
-            (new AmendmentBuilder(builder, subCategory, i, amendment)).build();
+        static SubCategoryListEntry getNew(AmendmentConfigFactory parent, int i) {
+            SubCategoryBuilder subCategory = parent.builder.entryBuilder().startSubCategory(
+                    Text.translatable("config.infinity.amendment", String.valueOf(i)));
+            (new AmendmentBuilder(parent, subCategory, i)).build();
             return subCategory.build();
         }
 
-        static SubCategoryListEntry getShadow(ConfigBuilder builder, int i, ValueHolder<Integer> shadowAmount, int shadowI) {
-            SubCategoryBuilder subCategory = builder.entryBuilder()
+        static SubCategoryListEntry getShadow(AmendmentConfigFactory parent, int i, ValueHolder<Integer> shadowAmount, int shadowI) {
+            SubCategoryBuilder subCategory = parent.builder.entryBuilder()
                     .startSubCategory(Text.translatable("config.infinity.amendment.new"))
                     .setDisplayRequirement(() -> shadowAmount.getValue() > shadowI);
-
-            (new NewAmendmentBuilder(builder, subCategory, i)).build();
+            (new AmendmentBuilder(parent, 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();
-
-            // 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");
-            }
-        }
-    }
-
-    private static String getSafeString(JsonObject amendment, String key) {
-        var amend = amendment.get(key);
-        if (amend != null && !amend.isJsonArray())
-            return amend.getAsString();
-        else return "";
-    }
-    private static Double getSafeDouble(JsonObject amendment, String key) {
-        var amend = amendment.get(key);
-        if (amend != null && !amend.isJsonArray())
-            return amend.getAsDouble();
-        else return 0d;
     }
 
     static NbtList convertNbtList(List<String> list) {
···
         return nbtList;
     }
 
-    static List<String> convertNbtList(JsonArray nbtList) {
+    static List<String> convertNbtList(NbtList nbtList) {
         ArrayList<String> list = new ArrayList<>();
-        for (JsonElement s : nbtList) {
-            list.add(s.getAsString());
+        for (NbtElement s : nbtList) {
+            list.add(s.asString());
         }
         return list;
     }

common/src/main/resources/assets/infinity/lang/en_us.json

···
   "config.infinity.title.rootChances": "Root Chances",
   "config.infinity.amendment": "Amendment #%s",
   "config.infinity.amendment.new": "New Amendment",
+  "config.infinity.amendments.addmore": "Add more amendments:",
+  "config.infinity.amendments.addmore.description": "Change this number to start creating additional amendments, up to 10 at at time.",
   "config.infinity.amendments.area": "Area",
   "config.infinity.amendments.area.description": "What part of Infinite Dimensions generation to affect. Options include blocks, fluids, trees, mobs, structures.",
   "config.infinity.amendments.mod": "Mod Name",
···
   "config.infinity.amendments.selector.description": "This governs what content within the selected mod and area is affected by the amendment, \"all\" to amend an entire mod, \"matching\" to amend a single entry, \"matching_any\" to amend a list of entries, \"matching_block_tag\" amends a block tag, \"containing\" amends any entry with certain characters in its name. ",
   "config.infinity.amendments.matching": "Matching",
   "config.infinity.amendments.matching.description": "Amends a single entry with the following ID.",
+  "config.infinity.amendments.matching_any": "Matching any",
+  "config.infinity.amendments.matching_any.description": "Amends all entries from a following list.",
+  "config.infinity.amendments.matching_block_tag": "Matching block tag",
+  "config.infinity.amendments.matching_block_tag.description": "Amends all entries from a following block tag.",
+  "config.infinity.amendments.containing": "Containing",
+  "config.infinity.amendments.containing.description": "Amends all entries which contain the following substring in their ID.",
   "config.infinity.amendments.results": "Results",
   "config.infinity.amendments.results.description": "Sets how to affect the matched item. Values include \"set_value\" which sets the weight of an element, \"set_field\" which can amend the internal type of a block, and \"erase\" which prevents an element from generating.",
   "config.infinity.amendments.field_name": "Field Name",
   "config.infinity.amendments.field_name.description": "Set the value of the field to be amended. Options include \"full\" representing standard blocks, \"float\" which represents full blocks not affected by gravity, \"top\" representing blocks that require a block below like Sand, and \"laggy\" representing block entities like Chests.",
   "config.infinity.amendments.value": "Value",
   "config.infinity.amendments.value.description": "How often an element occurs in generation. The default weight is 1.",
+  "config.infinity.amendments.delete": "Delete this amendment?",
+  "config.infinity.amendments.delete.description": "Toggle for this amendment to be removed upon saving and exiting.",
   "config.infinity.salt": "Salt",
   "config.infinity.salt.description": "This string will be added to the book text in the process of its conversion to the dimension ID. This can be used to ensure your dimensions are differing from dimensions with the same book text that other users generate. You can do this if you don't want to go into the mod already knowing \"oh, the dimension 90 has diamonds\" etc. Does not affect \"easter egg\"-type dimensions.",
   "config.infinity.portalKey": "Portal Key",