Start futureproofing NbtUtils

common/src/main/java/net/lerariemann/infinity/options/InfinityOptions.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.InfinityOptionsAccess;
 import net.lerariemann.infinity.util.core.CommonIO;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
···
 
     public InfinityOptions(NbtCompound data) {
         this.data = data;
-        this.shifter = PitchShifter.decode(test(data, "pitch_shift", new NbtCompound()));
-        this.effect = EffectGiver.of(test(data, "effect", new NbtCompound()));
-        this.iridMap = IridescentMap.decode(test(data, "iridescent_map", new NbtCompound()));
+        this.shifter = PitchShifter.decode(NbtUtils.getCompound(data, "pitch_shift", new NbtCompound()));
+        this.effect = EffectGiver.of(NbtUtils.getCompound(data, "effect", new NbtCompound()));
+        this.iridMap = IridescentMap.decode(NbtUtils.getCompound(data, "iridescent_map", new NbtCompound()));
         this.mavity = test(data, "mavity", 1.0);
         this.timeScale = test(data, "time_scale", 1.0);
         this.haunted = test(data, "haunted", false);
···
     }
 
     public NbtCompound getShader() {
-        return test(data, "shader", new NbtCompound());
+        return NbtUtils.getCompound(data, "shader", new NbtCompound());
     }
 
     public double getTimeScale() {

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

···
     static String test(NbtCompound data, String key, String def) {
         return data.contains(key, NbtElement.STRING_TYPE) ? data.getString(key) : def;
     }
-    static NbtCompound test(NbtCompound data, String key, NbtCompound def) {
+    static NbtCompound getCompound(NbtCompound data, String key, NbtCompound def) {
         return data.contains(key, NbtElement.COMPOUND_TYPE) ? data.getCompound(key) : def;
     }
     static float test(NbtCompound data, String key, float def) {
···
     }
     static boolean test(NbtCompound data, String key, boolean def) {
         return data.contains(key) ? data.getBoolean(key) : def;
+    }
+
+    static String getString(NbtCompound data, String key) {
+        return data.getString(key);
+    }
+    static NbtCompound getCompound(NbtCompound data, String key) {
+        return data.getCompound(key);
+    }
+    static float getFloat(NbtCompound data, String key) {
+        return data.getFloat(key);
+    }
+    static int getInt(NbtCompound data, String key) {
+        return data.getInt(key);
+    }
+    static double getDouble(NbtCompound data, String key) {
+        return data.getDouble(key);
+    }
+    static boolean getBoolean(NbtCompound data, String key) {
+        return data.getBoolean(key);
     }
 
     static String elementToName(NbtElement e) {

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

···
 
     void readRootConfig() {
         NbtCompound rootConfig = CommonIO.read(configPath.resolve("infinity.json"));
-        portalKey = rootConfig.getString("portalKey");
-        salt = rootConfig.getString("salt");
-        NbtCompound gameRules = rootConfig.getCompound("gameRules");
+        portalKey = NbtUtils.getString(rootConfig, "portalKey");
+        salt = NbtUtils.getString(rootConfig, "salt");
+        NbtCompound gameRules = NbtUtils.getCompound(rootConfig, "gameRules");
         for (String s: gameRules.getKeys()) {
             NbtElement elem = gameRules.get(s);
             if (elem!=null) {
-                if (elem.getType() == NbtElement.INT_TYPE) gameRulesInt.put(s, gameRules.getInt(s));
-                if (elem.getType() == NbtElement.DOUBLE_TYPE) gameRulesDouble.put(s, gameRules.getDouble(s));
+                if (elem.getType() == NbtElement.INT_TYPE) gameRulesInt.put(s, NbtUtils.getInt(gameRules, s));
+                if (elem.getType() == NbtElement.DOUBLE_TYPE) gameRulesDouble.put(s, NbtUtils.getDouble(gameRules, s));
                 else this.gameRules.put(s, gameRules.getBoolean(s));
             }
         }
-        NbtCompound rootChances = rootConfig.getCompound("rootChances");
+        NbtCompound rootChances = NbtUtils.getCompound(rootConfig, "rootChances");
         for (String c: rootChances.getKeys()) {
-            for (String s: rootChances.getCompound(c).getKeys()) {
-                this.rootChances.put(s, rootChances.getCompound(c).getDouble(s));
+            var compound = NbtUtils.getCompound(rootChances, c);
+            for (String s: compound.getKeys()) {
+                this.rootChances.put(s, NbtUtils.getDouble(compound, s));
             }
         }
 
-        NbtList disabledDimensions = rootConfig.getList("disabledDimensions", 8);
+        NbtList disabledDimensions = rootConfig.getList("disabledDimensions", NbtElement.STRING_TYPE);
         for (NbtElement jsonElement : disabledDimensions) {
             this.disabledDimensions.add(jsonElement.asString());
         }
···
         List<NbtCompound> blocksFeatures = new ArrayList<>();
         List<NbtCompound> fullBlocksWG = new ArrayList<>();
         for (NbtCompound block : blocksSettings) {
-            NbtCompound data = NbtUtils.test(block, "data", new NbtCompound());
+            NbtCompound data = NbtUtils.getCompound(block, "data", new NbtCompound());
             boolean isfull, istop, isfloat, islaggy;
             isfull = popBlockData(data, "full", false);
             islaggy = popBlockData(data, "laggy", false);
···
         List<NbtCompound> cleanMobs = new ArrayList<>();
         for (ConfigType type : ConfigType.mobCategories) byCategory.put(type, new ArrayList<>());
         for (NbtCompound mob : allmobs) {
-            String group = mob.getCompound("data").getString("Category");
+            String group = NbtUtils.getString(NbtUtils.getCompound(mob, "data"), "Category");
             mob.remove("data");
             ConfigType type = ConfigType.byName(group);
             if (type != null) {
···
 
     public NbtCompound blockToProvider(NbtCompound block, Random random) {
         NbtCompound res = new NbtCompound();
-        boolean isRotatable = Registries.BLOCK.get(Identifier.of(block.getString("Name"))).getDefaultState().getProperties().contains(Properties.AXIS);
+        boolean isRotatable = Registries.BLOCK.get(Identifier.of(NbtUtils.getString(block, "Name"))).getDefaultState().getProperties().contains(Properties.AXIS);
         res.putString("type", isRotatable && roll(random, "rotate_blocks") ?
                 "minecraft:rotated_block_provider" : "minecraft:simple_state_provider");
         res.put("state", block);
···
         registry.remove(ConfigType.BIOMES);
         List<NbtCompound> biomes = CommonIO.readCategory(ConfigType.BIOMES);
         Registry<Biome> reg = s.get(RegistryKeys.BIOME);
-        registerCategory(ConfigType.BIOMES, biomes.stream().filter(comp -> reg.containsId(Identifier.of(comp.getString("Name")))).toList());
+        registerCategory(ConfigType.BIOMES, biomes.stream().filter(comp -> reg.containsId(Identifier.of(NbtUtils.getString(comp,"Name")))).toList());
     }
 }