block tag amendment

common/src/main/java/net/lerariemann/infinity/InfinityMod.java

···
 	public static Path configPath = Path.of("config", InfinityMod.MOD_ID);
 	public static Path utilPath = configPath.resolve(".util");
 	public static Path invocationLock = configPath.resolve("modular/invocation.lock");
+	public static Path amendmentPath = configPath.resolve("amendments.json");
 
 	public static Path rootConfigPathInJar;
 	public static RandomProvider provider;
···
 
 	public static void init() {
 		rootConfigPathInJar = PlatformMethods.getRootConfigPath();
-		ConfigManager.updateInvocationLock();
+		ConfigManager.updateInvocationUnlock();
 		ConfigManager.unpackDefaultConfigs();
 		ModComponentTypes.registerComponentTypes();
 		ModStatusEffects.registerModEffects();

common/src/main/java/net/lerariemann/infinity/mixin/core/MinecraftServerMixin.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.PlatformMethods;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
+import net.lerariemann.infinity.util.config.ConfigManager;
 import net.minecraft.network.QueryableServer;
 import net.minecraft.registry.DynamicRegistryManager;
 import net.minecraft.registry.RegistryKey;
···
 
 import java.io.IOException;
 import java.nio.file.Files;
-import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Executor;
-
-import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
 
 @Mixin(MinecraftServer.class)
 public abstract class MinecraftServerMixin extends ReentrantThreadExecutor<ServerTask> implements QueryableServer, ChunkErrorHandler, CommandOutput, AutoCloseable, MinecraftServerAccess {
···
     public void infinity$onInvocation() {
         infinity$needsInvocation = false;
         try {
-            Path p = InfinityMod.invocationLock;
-            if (!Files.exists(p)) {
-                Files.createDirectories(p.getParent());
-                Files.copy(InfinityMod.rootConfigPathInJar.resolve(".util/invocation.lock"), p, REPLACE_EXISTING);
-            }
+            ConfigManager.updateInvocationLock();
             infinity$setDimensionProvider();
             InfinityMod.LOGGER.info("Invocation complete");
         } catch (IOException e) {

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

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.minecraft.block.Block;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtString;
+import net.minecraft.registry.Registries;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.RegistryKeys;
+import net.minecraft.registry.tag.TagKey;
+import net.minecraft.util.Identifier;
 
 import java.util.ArrayList;
 import java.util.HashMap;
···
         else modSelector = new MatchingModSelector(mod);
 
         ConfigType area = ConfigType.byName(data.getString("area"));
-        Selector selector = switch(data.getString("selector")) {
+        String selectorType = data.getString("selector");
+        Selector selector = switch(selectorType) {
             case "all" -> new UniversalSelector();
             case "containing" -> new ContainingSelector(data.getString("containing"));
             case "matching" -> new MatchingSelector(data.getString("matching"));
+            case "matching_block_tag" -> new MatchingBlockTagSelector(data.getString("matching"));
             case "matching_any" -> new MatchingAnySelector(data.getList("matching", NbtElement.STRING_TYPE)
                     .stream().map(e->(NbtString)e).map(NbtString::asString).toList());
-            default -> null;
+            default -> {
+                InfinityMod.LOGGER.warn("Unknown amendment selector type: {}", selectorType);
+                yield null;
+            }
         };
-        Results results = switch (data.getString("results")) {
+        String resultType = data.getString("results");
+        Results results = switch (resultType) {
             case "set_value" -> new SetValue(data.getInt("value"));
             case "erase" -> new SetValue(0);
             case "set_field" -> new SetField(data.getString("field_name"), data.get("field"));
-            default -> null;
+            default -> {
+                InfinityMod.LOGGER.warn("Unknown amendment result type: {}", resultType);
+                yield null;
+            }
         };
 
         if (area == null || selector == null || results == null) return null;
···
 
     public static Map<ConfigType, List<Amendment>> getAmendmentList() {
         Map<ConfigType, List<Amendment>> data = new HashMap<>();
-        NbtCompound rawData = CommonIO.read(InfinityMod.configPath.resolve("modular").resolve("amendments.json"));
+        NbtCompound rawData = CommonIO.read(InfinityMod.amendmentPath);
         AtomicInteger i = new AtomicInteger();
         for (NbtElement e : rawData.getList("elements", NbtElement.COMPOUND_TYPE)) {
             Amendment amd = Amendment.of((NbtCompound)e);
···
     public record MatchingSelector(String key) implements Selector {
         public boolean applies(String key) {
             return key.equals(this.key);
+        }
+    }
+    public record MatchingBlockTagSelector(String key) implements Selector {
+        public boolean applies(String key) {
+            Block b = Registries.BLOCK.get(RegistryKey.of(RegistryKeys.BLOCK, Identifier.of(key)));
+            if (b != null) {
+                return b.getDefaultState().isIn(TagKey.of(RegistryKeys.BLOCK, Identifier.of(this.key)));
+            }
+            return false;
         }
     }
     public record MatchingAnySelector(List<String> lst) implements Selector {

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
+import org.apache.commons.io.FileUtils;
 import org.apache.logging.log4j.LogManager;
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
···
     /** If the game was last started in a version of the mod that uses a different modular config format,
      * this deletes the old configs ensuring they will be regenerated in the correct format
      * by {@link ConfigFactory} on next world load. */
-    static void updateInvocationLock() {
+    static void updateInvocationUnlock() {
         File invlock = InfinityMod.invocationLock.toFile();
         if (!invlock.exists()) return;
         try {
-            if (!compareVersions(InfinityMod.invocationLock, InfinityMod.rootConfigPathInJar.resolve( ".util/invocation.lock"))) return;
+            int a = compareVersionsAndAmendments(InfinityMod.invocationLock, InfinityMod.rootConfigPathInJar.resolve( ".util/invocation.lock"));
+            if (a == 0) return;
             try (Stream<Path> files = Files.walk(configPath.resolve("modular"))) {
-                InfinityMod.LOGGER.info("Deleting outdated modular configs");
+                InfinityMod.LOGGER.info("Deleting {} modular configs", a == 1 ? "outdated" : "amended");
                 files.map(Path::toFile).filter(File::isFile).forEach(f -> {
                     if (!f.delete()) InfinityMod.LOGGER.info("Cannot delete file {}", f);
                 });
···
             throw new RuntimeException(e);
         }
     }
+    
+    static void updateInvocationLock() throws IOException {
+        Path inv = InfinityMod.invocationLock;
+        if (!Files.exists(inv)) {
+            Files.createDirectories(inv.getParent());
+            Files.copy(InfinityMod.rootConfigPathInJar.resolve(".util/invocation.lock"), tempFile, REPLACE_EXISTING);
+            String s = FileUtils.readFileToString(tempFile.toFile(), StandardCharsets.UTF_8);
+            s = s.replace("&0", String.valueOf(CommonIO.getAmendmentVersion(InfinityMod.amendmentPath.toFile())));
+            Files.writeString(inv, s, StandardCharsets.UTF_8);
+        }
+    }
 
     static void unpackDefaultConfigs() {
         try(Stream<Path> files = Files.walk(InfinityMod.rootConfigPathInJar)) {
···
         Files.copy(newFile, tempFile, REPLACE_EXISTING);
         int version_new = CommonIO.getVersion(tempFile.toFile());
         return version_new > version_old;
+    }
+
+    static int compareVersionsAndAmendments(Path oldFile, Path newFile) throws IOException {
+        int version_old = CommonIO.getVersion(oldFile.toFile());
+        int amendment_version_old = CommonIO.getAmendmentVersion(oldFile.toFile());
+        Files.copy(newFile, tempFile, REPLACE_EXISTING);
+        int version_new = CommonIO.getVersion(tempFile.toFile());
+        int amendment_version_new = CommonIO.getAmendmentVersion(InfinityMod.amendmentPath.toFile());
+        if (version_new > version_old) return 1;
+        if (amendment_version_new > amendment_version_old) return 2;
+        return 0;
     }
 
     @Deprecated

common/src/main/java/net/lerariemann/infinity/util/core/CommonIO.java

···
 import java.nio.file.Paths;
 import java.util.*;
 
+import static net.lerariemann.infinity.InfinityMod.LOGGER;
 import static net.lerariemann.infinity.InfinityMod.configPath;
 
 public interface CommonIO {
···
     }
 
     static int getVersion(File file) {
+        return getStaistic(file, "infinity_version");
+    }
+    static int getAmendmentVersion(File file) {
+        return getStaistic(file, "amendment_version");
+    }
+
+    static int getStaistic(File file, String statname) {
         String content;
         try {
             content = FileUtils.readFileToString(file, StandardCharsets.UTF_8);
-            if (!content.contains("infinity_version")) return 0;
-            int i = content.indexOf("infinity_version");
+            if (!content.contains(statname)) return 0;
+            int i = content.indexOf(statname);
             int end = content.indexOf(",", i);
             if (end == -1) {
                 end = content.indexOf("\n", i);
             }
             return Integer.parseInt(content.substring(content.indexOf(" ", i)+1, end).trim());
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            LOGGER.warn("No file found: {}", file);
+            return 0;
         }
     }
 

common/src/main/resources/config/.util/invocation.lock

···
-infinity_version: 2004001
+infinity_version: 2004002
+amendment_version: &0
 Delete this file to regenerate modular configs automatically
 (e.g. you may want to do this when adding new mods to the instance)

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

···
 {
+  "amendment_version": 0,
   "elements": [
     {
       "area": "fluids",
···
       "results": "erase"
     },
     {
-      "area": "structures",
+      "area": "blocks",
       "mod": "oritech",
       "selector": "containing",
       "containing": "pipe",

docs/Invocation.mdx

···
 * status effects,
 * block tags,
 * structures plus some of their additional data,
-* biomes and surface rules for them.
+* biomes,
+* (in limited capacity) surface rules for biomes.
 
 Blocks are auto-assigned tags needed for the generator to know which parts of worldgen are they usable for ("full", "laggy" etc.,
 see the page on [configuring the mod](Configuring-the-mod)), plus checked for different traits (being a flower, rotatable, dyeable etc.).
···
 ## Known issues with invocation
 * Invocation only happens once per game folder. As such, if you add new mods to the instance after you already loaded worlds on it once,
 invocation will not happen again. This especially stands for the default Minecraft launcher by Mojang, which by design only uses one.
-To force the invocation to happen again, you can either construct and activate the Transfinite Altar, or delete the file
-`config/infinity/modular/invocation.lock` and relaunch the game.
-    * Note that such reinvocation will not touch any of the existing files, only add new ones. As such, it is useful by itself only when
-    adding new mods to the instance. If you update one of the mods (including Infinite Dimensions!) to a newer version that brings
-    more content, or *especially* if you remove mods, you have to purge the `/config/modular` folder entirely to do a successful reinvocation.
+To force the invocation to happen again, you need to delete the file `config/infinity/modular/invocation.lock` and relaunch the game.
+* Repeated invocation will not touch any of the existing files, only add new ones. As such, it is useful by itself only when
+adding new mods to the instance. If you update one of the mods to a newer version that brings more content, or *especially* if you remove mods,
+you have to purge the `/config/modular` folder entirely to do a successful reinvocation.
 * Starting at version 2.1.0 of the mod, Infinite Dimensions will automatically delete all modular configs and issue reinvocation
 if it detects that the version of those configs (set in the invocation lock) is outdated. If you make changes to your modular configs,
-do a backup of them before updating the mod!
+do a backup of them before updating the mod!
+
+## Amendments
+Amendments are a system of automatically changing values in config files without changing them one-by-one. A more proper integration (for editing them
+in GUI) will be explored later, but so far it is possible to do them by editing files.
+
+Amendments are stored in `config/infinity/amendments.json` and only can affect modular configs. To change the list of active amendments,
+one must edit the amendments.json file _making sure to increase up the amendment_version statistic at the top_, then fully close and restart the game.
+
+Amendments consist of four distinct parts governing when and how the amendment will be passed:
+* Area. This is the scope of the amendment in terms of type of game content it affects: `"blocks"`, `"fluids"`, `"items"`, `"structures"` and `"mobs"`
+are the ones that would probably be most useful to a user, but there are other options too.
+* Mod. This cam be set to a mod ID (including `"minecraft"`) to only select content from this mod, or to `"all"` to skip the mod check.
+* Selector. This governs what content within the selected mod and area is affected by the amendment, and there are several types available:
+ * `"all"` - amend everything (useful if you want to skip some mod entirely);
+ * `"matching"` - amend a single entry, with it's key set as a value under a key `matching` (i.e., `"selector": "matching", "matching": "minecraft:lava"`);
+ * `"matching_any"` - amend every entry in a list, provided under a key `matching`;
+ * `"matching_block_tag"` - only works when `area` is set to `"blocks"` and amends all blocks under a tag. The tag ID is provided under `matching` without
+ the leading `#` symbol.
+ * `"containing"` - amends all entries the names of which contain a certain string of characters set under the `containing` field.
+* Results - what will the amendment do, the following options are available:
+ * `"set_value"` - sets the weight of an element to a number provided under `value` (the default weight is 1);
+ * `"set_field"` - useful e.g. for blocks if you want to mark them as laggy overriding the default algorithm that checks it;
+ additional fields are `field_name` and `field` allowing you to add any field to the data amended content has;
+ * `"erase"` - skip the entry entirely, effectively the same as setting its weight to 0.
+
+Let's break down the default list of ten amendments the mod comes with. Most of them are fixes for various mod compatibility issues:
+```
+    {
+      "area": "fluids",
+      "mod": "minecraft",
+      "selector": "matching",
+      "matching": "minecraft:lava",
+      "results": "set_value",
+      "value": 2.0
+    },
+    {
+      "area": "fluids",
+      "mod": "minecraft",
+      "selector": "matching",
+      "matching": "minecraft:water",
+      "results": "set_value",
+      "value": 5.0
+    }
+```
+The first and second amendments modify the weights the two vanilla fluids have in the distribution of all fluids, making them
+a bit more common in modded scenarios.
+
+```
+    {
+      "area": "blocks",
+      "mod": "minecraft",
+      "selector": "matching_any",
+      "matching": [
+        "minecraft:slime_block",
+        "minecraft:honey_block",
+        "minecraft:mangrove_roots"
+      ],
+      "results": "set_field",
+      "field_name": "laggy",
+      "field": true
+    }
+```
+The third amendment marks some vanilla blocks as laggy. These are the blocks which can overwhelm the rendering algorithm when present in large blobs
+due to having unculled inner faces on their model.
+
+```
+    {
+      "area": "trees",
+      "mod": "all",
+      "selector": "containing",
+      "containing": "bees",
+      "results": "erase"
+    }
+```
+The fourth amendment forbids generation of any trees that have beehives on them (conveniently, their IDs all have the word bees in them),
+as large amounts of those leads to large amounts of bees present which can lag the game.
+
+```
+    {
+      "area": "fluids",
+      "mod": "modern_industrialization",
+      "selector": "all",
+      "results": "erase"
+    }
+```
+The fifth amendment forbids all fluids from the Modern Industrialization mod from appearing, as they lack fluid physics and rendering due to not having
+been supposed to ever be placed in-world.
+
+```
+    {
+      "area": "mobs",
+      "mod": "minecolonies",
+      "selector": "all",
+      "results": "erase"
+    }
+```
+The sixth amendment prevents all mobs from Minecolonies from spawning in this mod's biomes as part of the natural spawning algorithm,
+as these error out the game if they do due to incomplete entity data.
+
+```
+    {
+      "area": "structures",
+      "mod": "alexscaves",
+      "selector": "all",
+      "results": "erase"
+    },
+    {
+      "area": "structures",
+      "mod": "aether",
+      "selector": "containing",
+      "containing": "dungeon",
+      "results": "erase"
+    }
+```
+The seventh and eighth amendments bans all structures from Alex's Caves (aka, the caves themselves) and Aether dungeons from generating in this mod's
+custom dimensions, as they sometimes throw errors when they do due to failing their inner checks when called to generate outside of their natural
+environment.
+
+```
+    {
+      "area": "structures",
+      "mod": "oritech",
+      "selector": "containing",
+      "containing": "pipe",
+      "results": "erase"
+    }
+```
+The ninth amendment bans all pipe blocks from Oritech, because when these are placed during world generation, they try to update their shape
+and in the process poll the world for metrics which on this stage aren't yet present, resulting in a crash.
+
+```
+    {
+      "area": "blocks",
+      "mod": "chipped",
+      "selector": "all",
+      "results": "set_value",
+      "value": 0.1
+    }
+```
+The tenth amendment reduces weights of all blocks from the Chipped mod down to 0.1, as there are thousands of them :D