Further futureproofing

common/src/main/java/net/lerariemann/infinity/block/entity/BiomeBottleBlockEntity.java

···
 
     public void readNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
         super.readNbt(tag, registryLookup);
-        this.charge = tag.getInt("Charge");
-        this.biome = Identifier.of(tag.getString("Biome"));
-        this.color = tag.getInt("Color");
-        this.from_charge = NbtUtils.test(tag, "from_charge", 0);
+        this.charge = NbtUtils.getInt(tag, "Charge");
+        this.biome = Identifier.of(NbtUtils.getString(tag, "Biome"));
+        this.color = NbtUtils.getInt(tag, "Color");
+        this.from_charge = NbtUtils.getInt(tag, "from_charge", 0);
     }
 
     @Override

common/src/main/java/net/lerariemann/infinity/block/entity/InfinityPortalBlockEntity.java

···
 import net.lerariemann.infinity.options.PortalColorApplier;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.registry.core.ModBlockEntities;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.teleport.InfinityPortal;
 import net.minecraft.block.BlockState;
 import net.minecraft.nbt.NbtCompound;
···
     public void readNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
         super.readNbt(tag, registryLookup);
         if (tag.contains("Dimension", NbtElement.NUMBER_TYPE)) { //conversion from legacy formats
-            this.portalColor = tag.getInt("Dimension") & 0xFFFFFF;
+            this.portalColor = NbtUtils.getInt(tag, "Dimension") & 0xFFFFFF;
             if (tag.contains("DimensionName")) {
-                this.dimension = Identifier.of(tag.getString("DimensionName"));
+                this.dimension = Identifier.of(NbtUtils.getString(tag, "DimensionName"));
             }
             else this.dimension = InfinityMethods.getDimId(this.portalColor);
         }
         else if (tag.contains("Dimension", NbtElement.STRING_TYPE)) { //new better format
-            this.dimension = Identifier.of(tag.getString("Dimension"));
-            this.portalColor = tag.contains("Color", NbtElement.INT_TYPE) ?
-                    tag.getInt("Color") :
-                    (world != null ? PortalColorApplier.of(dimension, world.getServer()) :
-                            PortalColorApplier.of(dimension, new NbtCompound())).apply(pos) & 0xFFFFFF;
+            this.dimension = Identifier.of(NbtUtils.getString(tag, "Dimension"));
+            this.portalColor = NbtUtils.getInt(tag, "Color", (world != null ? PortalColorApplier.of(dimension, world.getServer()) :
+                    PortalColorApplier.of(dimension, new NbtCompound())).apply(pos) & 0xFFFFFF);
         }
         else {
             setDimension(InfinityMethods.getRandomSeed(new Random())); //random by default
         }
-        this.isOpen = tag.getBoolean("Open");
+        this.isOpen = NbtUtils.getBoolean(tag, "Open", false);
         if (tag.contains("other_side")) {
-            NbtCompound pos = tag.getCompound("other_side");
-            otherSidePos = new BlockPos(pos.getInt("x"), pos.getInt("y"), pos.getInt("z"));
+            NbtCompound pos = NbtUtils.getCompound(tag,"other_side");
+            otherSidePos = new BlockPos(NbtUtils.getInt(pos, "x"), NbtUtils.getInt(pos, "y"), NbtUtils.getInt(pos, "z"));
         }
     }
 

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

···
 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;
···
         NbtCompound elements = readNbt(configPath()+("/amendments.json"));
         NbtCompound amendment = elements.getList("elements", 10).getCompound(amendmentIndex);
         // Check if an amendment should be changed before writing
-        if (!Objects.equals(amendment.getString(newValue), newValue)) {
+        if (!Objects.equals(NbtUtils.getString(amendment, name), newValue)) {
             amendment.putString(name, newValue);
             CommonIO.write(elements, configPath(), "amendments.json");
         }
···
         NbtCompound elements = readNbt(configPath()+("/amendments.json"));
         NbtCompound amendment = elements.getList("elements", 10).getCompound(amendmentIndex);
         // Check if an amendment should be changed before writing
-        if (amendment.getDouble(name) != newValue) {
+        if (NbtUtils.getDouble(amendment, name) != newValue) {
             amendment.putDouble(name, newValue);
             CommonIO.write(elements, configPath(), "amendments.json");
         }

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

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.resource.language.I18n;
 import net.minecraft.nbt.NbtCompound;
···
         NbtCompound rootConfig = readDefaultConfig();
         NbtCompound configPath = rootConfig;
         if (prevField != null) {
-            configPath = rootConfig.getCompound(prevField);
+            configPath = NbtUtils.getCompound(rootConfig, prevField);
         }
         if (prevPrevField != null) {
-            configPath = rootConfig.getCompound(prevPrevField).getCompound(prevField);
+            configPath = NbtUtils.getCompound(NbtUtils.getCompound(rootConfig, prevPrevField), prevField);
         }
 
         return switch (type) {
-            case "string" -> configPath.getString(field.getKey());
-            case "boolean" -> configPath.getBoolean(field.getKey());
-            case "double" -> configPath.getDouble(field.getKey());
-            case "int" -> configPath.getInt(field.getKey());
+            case "string" -> NbtUtils.getString(configPath, field.getKey());
+            case "boolean" -> NbtUtils.getBoolean(configPath, field.getKey());
+            case "double" -> NbtUtils.getDouble(configPath, field.getKey());
+            case "int" -> NbtUtils.getInt(configPath, field.getKey());
             default -> false;
         };
     }

common/src/main/java/net/lerariemann/infinity/dimensions/RandomFeaturesList.java

···
 import net.lerariemann.infinity.dimensions.features.underground_structures.RandomFossil;
 import net.lerariemann.infinity.dimensions.features.vegetation.*;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtList;
···
         res.addAll(getAllElements(ConfigType.VEG2));
         addRandomFeature("surface_patch", res, RandomSurfacePatch::new);
         addRandomFeature("floating_patch", res, RandomFloatingPatch::new);
-        if (parent.parent.default_fluid.getString("Name").contains("water")) {
+        if (NbtUtils.getString(parent.parent.default_fluid, "Name").contains("water")) {
             addRandomFeature("water_plants", res, RandomSeagrass::new);
             addRandomFeature("water_plants", res, RandomPickle::new);
             addRandomFeature("water_plants", res, RandomKelp::new);

common/src/main/java/net/lerariemann/infinity/dimensions/RandomStructure.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtList;
 import net.minecraft.util.Identifier;
···
     void addData() {
         data = parent.PROVIDER.randomElement(random, ConfigType.STRUCTURES);
         assert data.contains("id");
-        type = data.getString("id");
+        type = NbtUtils.getString(data,"id");
         name = Identifier.of(type).getPath().replace("/", "_").replace("\\", "_") + "_" + id;
 
         data.putString("type", "infinity:setupper");

common/src/main/java/net/lerariemann/infinity/dimensions/features/underground_ores/RandomDisk.java

···
 import net.lerariemann.infinity.dimensions.features.Placement;
 import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtList;
 import net.minecraft.nbt.NbtString;
···
     String target;
     public RandomDisk(RandomFeaturesList parent) {
         super(parent, "disk");
-        target = daddy.underwater.get(parent.parent.fullname).getString("Name");
+        target = NbtUtils.getString(daddy.underwater.get(parent.parent.fullname), "Name");
         id = "disk";
         savePlacement();
     }
···
         Placement res = new Placement();
         res.addInSquare();
         res.addHeightmap("OCEAN_FLOOR_WG");
-        String s = daddy.default_fluid.getString("fluidName");
+        String s = NbtUtils.getString(daddy.default_fluid, "fluidName");
         if (!s.equals("minecraft:air")) res.addBlockPredicateFilter(matchingFluids(s));
         res.addBiome();
         return res.data;
···
         if (!awt) {
             NbtList blocks = new NbtList();
             blocks.add(NbtString.of(target));
-            blocks.add(NbtString.of(blockProvider.getCompound("state").getString("Name")));
+            blocks.add(NbtString.of(NbtUtils.getString(NbtUtils.getCompound(blockProvider, "state"), "Name")));
             targets.put("blocks", blocks);
         }
         config.put("target", targets);

common/src/main/java/net/lerariemann/infinity/dimensions/features/underground_ores/RandomOre.java

···
 import net.lerariemann.infinity.dimensions.features.Placement;
 import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtList;
 
···
     static NbtCompound target(NbtCompound block, boolean awt) {
         NbtCompound res = new NbtCompound();
         res.putString("predicate_type", awt ? "always_true" : "block_match");
-        if (!awt) res.putString("block", block.getString("Name"));
+        if (!awt) res.putString("block", NbtUtils.getString(block, "Name"));
         return res;
     }
 }

common/src/main/java/net/lerariemann/infinity/dimensions/features/vegetation/RandomTree.java

···
 
     public NbtList placement() {
         Placement res = new Placement();
-        NbtCompound predicate = matchingBlocks(parent.surface_block.getString("Name"));
+        NbtCompound predicate = matchingBlocks(NbtUtils.getString(parent.surface_block, "Name"));
         predicate.put("offset", offsetToNbt(Arrays.asList(0, -1, 0)));
         res.addCountEveryLayer(1);
         res.addWaterDepthFilter((int) Math.floor(random.nextExponential()*4));

common/src/main/java/net/lerariemann/infinity/dimensions/features/vegetation/RandomVegetation.java

···
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.ConfigType;
 import net.lerariemann.infinity.util.core.CorePack;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.*;
 
 public class RandomVegetation extends RandomisedFeature {
···
         String tree = ConfigType.TREES.getDef();
         if (parent.roll("use_vanilla_trees")) {
             tree = PROVIDER.randomName(random, ConfigType.TREES);
-            NbtCompound c = CorePack.treePlacement(tree, parent.surface_block.getString("Name"));
+            NbtCompound c = CorePack.treePlacement(tree, NbtUtils.getString(parent.surface_block, "Name"));
             String s = tree.substring(tree.lastIndexOf(':') + 1).replace("/", "_") + "_" + parent.parent.id;
             s = s.replace("/", "_");
             CommonIO.write(c, parent.storagePath + "/worldgen/placed_feature", s + ".json");

common/src/main/java/net/lerariemann/infinity/entity/custom/AntEntity.java

···
 import net.lerariemann.infinity.util.var.BishopBattle;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
-import net.minecraft.block.FluidBlock;
 import net.minecraft.block.ShapeContext;
 import net.minecraft.entity.*;
 import net.minecraft.entity.ai.goal.*;
···
     @Override
     public void readCustomDataFromNbt(NbtCompound nbt) {
         super.readCustomDataFromNbt(nbt);
-        this.dropsLoot = NbtUtils.test(nbt, "dropsLoot", true);
-        this.direction = switch(nbt.getString("direction")) {
+        this.dropsLoot = NbtUtils.getBoolean(nbt, "dropsLoot", true);
+        this.direction = switch(NbtUtils.getString(nbt, "direction")) {
             case "N" -> Direction.NORTH;
             case "W" -> Direction.WEST;
             case "S" -> Direction.SOUTH;
             default -> Direction.EAST;
         };
         if (nbt.contains("last_changed_pos")) {
-            NbtCompound pos = nbt.getCompound("last_changed_pos");
-            this.lastChangedPos = new BlockPos(pos.getInt("x"), pos.getInt("y"), pos.getInt("z"));
+            NbtCompound pos = NbtUtils.getCompound(nbt, "last_changed_pos");
+            this.lastChangedPos = new BlockPos(NbtUtils.getInt(pos, "x"), NbtUtils.getInt(nbt,"y"), NbtUtils.getInt(nbt, "z"));
         }
     }
 

common/src/main/java/net/lerariemann/infinity/entity/custom/BishopEntity.java

···
 
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.var.BishopBattle;
 import net.minecraft.entity.*;
 import net.minecraft.entity.ai.RangedAttackMob;
···
 
     public ItemStack getProjectileType() {
         NbtCompound effect = InfinityMod.provider.randomElement(random, ConfigType.EFFECTS);
-        if (!effect.getString("Category").equals("harmful")
-                || effect.getBoolean("Instant")) return Items.ARROW.getDefaultStack();
+        if (!NbtUtils.getString(effect, "Category").equals("harmful")
+                || NbtUtils.getBoolean(effect, "Instant")) return Items.ARROW.getDefaultStack();
         return ChaosSkeleton.setPotion(Items.TIPPED_ARROW.getDefaultStack(),
-                effect.getInt("Color"),
-                effect.getString("Name"),
+                NbtUtils.getInt(effect, "Color"),
+                NbtUtils.getString(effect, "Name"),
                 200);
     }
 }

common/src/main/java/net/lerariemann/infinity/entity/custom/ChaosCreeper.java

···
     @Nullable
     public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
         NbtCompound biome = InfinityMod.provider.randomElement(world.getRandom(), ConfigType.BIOMES);
-        this.setColor(NbtUtils.test(biome, "Color", 7842607));
+        this.setColor(NbtUtils.getInt(biome, "Color", 7842607));
         this.setRandomCharge();
-        this.setBiome(biome.getString("Name"));
+        this.setBiome(NbtUtils.getString(biome, "Name"));
         return super.initialize(world, difficulty, spawnReason, entityData);
     }
 
···
     @Override
     public void readCustomDataFromNbt(NbtCompound nbt) {
         super.readCustomDataFromNbt(nbt);
-        this.setRange(nbt.getFloat("range"));
-        this.setColor(nbt.getInt("color"));
-        this.setBiome(nbt.getString("biome"));
+        this.setRange(NbtUtils.getFloat(nbt, "range"));
+        this.setColor(NbtUtils.getInt(nbt, "color"));
+        this.setBiome(NbtUtils.getString(nbt, "biome"));
     }
 
     public void blow_up() {

common/src/main/java/net/lerariemann/infinity/entity/custom/ChaosSkeleton.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.registry.core.ModEntities;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.component.DataComponentTypes;
 import net.minecraft.component.type.PotionContentsComponent;
 import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentHelper;
 import net.minecraft.enchantment.Enchantments;
 import net.minecraft.entity.EntityData;
 import net.minecraft.entity.EntityType;
···
     }
 
     public void setEffect(NbtCompound eff) {
-        setEffect(eff.getString("Name"), eff.getInt("Color"));
+        setEffect(NbtUtils.getString(eff, "Name"), NbtUtils.getInt(eff, "Color"));
     }
     public void setEffect(String eff, int c) {
         if (eff.isBlank()) {
             NbtCompound newEffect = InfinityMod.provider.randomElement(random, ConfigType.EFFECTS);
-            eff = newEffect.getString("Name");
-            c = newEffect.getInt("Color");
+            eff = NbtUtils.getString(newEffect, "Name");
+            c = NbtUtils.getInt(newEffect, "Color");
         }
         this.dataTracker.set(effect, eff);
         this.dataTracker.set(color, c);
···
     @Override
     public void readCustomDataFromNbt(NbtCompound nbt) {
         super.readCustomDataFromNbt(nbt);
-        this.setEffect(nbt.getString("effect"), nbt.getInt("color"));
-        this.setDuration(nbt.getInt("duration"));
+        this.setEffect(NbtUtils.getString(nbt, "effect"), NbtUtils.getInt(nbt, "color"));
+        this.setDuration(NbtUtils.getInt(nbt,"duration"));
     }
 
     public static ItemStack setPotion(ItemStack stack, int color, String effect, int duration) {

common/src/main/java/net/lerariemann/infinity/entity/custom/ChaosSlime.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
···
     @Override
     public void readCustomDataFromNbt(NbtCompound nbt) {
         super.readCustomDataFromNbt(nbt);
-        this.setColor(nbt.getInt("color"));
-        Block b = Registries.BLOCK.get(Identifier.of(nbt.getString("core")));
+        this.setColor(NbtUtils.getInt(nbt, "color"));
+        Block b = Registries.BLOCK.get(Identifier.of(NbtUtils.getString(nbt,"core")));
         this.setCore(b.getDefaultState());
     }
 

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

···
     }
 
     public static EffectGiver of(NbtCompound data) {
-        if (data.contains("id")) return new EffectGiver(effectOf(data.getString("id")),
-                NbtUtils.test(data, "duration", 300),
-                NbtUtils.test(data, "amplifier", 0),
-                Math.min(NbtUtils.test(data, "cooldown", 100), 100));
+        if (data.contains("id")) return new EffectGiver(effectOf(NbtUtils.getString(data, "id")),
+                NbtUtils.getInt(data, "duration", 300),
+                NbtUtils.getInt(data, "amplifier", 0),
+                Math.min(NbtUtils.getInt(data, "cooldown", 100), 100));
         return new EffectGiver(null, 0,0,200);
     }
 

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

···
 
 import java.io.File;
 import java.util.function.Function;
-import static net.lerariemann.infinity.util.core.NbtUtils.*;
 
 public class InfinityOptions {
     public NbtCompound data;
···
         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);
+        this.mavity = NbtUtils.getDouble(data, "mavity", 1.0);
+        this.timeScale = NbtUtils.getDouble(data, "time_scale", 1.0);
+        this.haunted = NbtUtils.getBoolean(data, "haunted", false);
     }
 
     public NbtCompound data() {
···
     public int getHauntingTicks(Random random) {
         if (!isHaunted()) return -2;
         if (data.contains("haunting_ticks")) return data.getInt("haunting_ticks");
-        return random.nextBetween(test(data, "min_haunting_ticks", 20), test(data, "max_haunting_ticks", 200));
+        return random.nextBetween(NbtUtils.getInt(data, "min_haunting_ticks", 20), NbtUtils.getInt(data, "max_haunting_ticks", 200));
     }
 
     //sky - common
     public String getSkyType() {
-        return test(data, "sky_type", "empty");
+        return NbtUtils.getString(data, "sky_type", "empty");
     }
     public float getHorizonShadingRatio() {
-        return test(data, "horizon_shading_ratio", 1.0f);
+        return NbtUtils.getFloat(data, "horizon_shading_ratio", 1.0f);
     }
     public boolean endSkyLike() {
-        return test(data, "end_sky_like", false);
+        return NbtUtils.getBoolean(data, "end_sky_like", false);
     }
     public boolean hasDawn() {
-        return test(data, "dawn", !getSkyType().equals("rainbow"));
+        return NbtUtils.getBoolean(data, "dawn", !getSkyType().equals("rainbow"));
     }
 
     //sun
     public float getSolarSize() {
-        return test(data, "solar_size", 30.0f);
+        return NbtUtils.getFloat(data, "solar_size", 30.0f);
     }
     public float getSolarTilt() {
-        return test(data, "solar_tilt", -90.0f);
+        return NbtUtils.getFloat(data, "solar_tilt", -90.0f);
     }
     public Vector3f getSolarTint() {
-        int color = test(data, "solar_tint",16777215);
+        int color = NbtUtils.getInt(data, "solar_tint",16777215);
         return new Vector3f((float)(color >> 16 & 0xFF) / 255.0f, (float)(color >> 8 & 0xFF) / 255.0f, (float)(color & 0xFF) / 255.0f);
     }
     public Identifier getSolarTexture() {
-        return Identifier.of(test(data, "solar_texture", "textures/environment/sun.png"));
+        return Identifier.of(NbtUtils.getString(data, "solar_texture", "textures/environment/sun.png"));
     }
 
     //stars
     public int getNumStars() {
-        return test(data, "num_stars", 1500);
+        return NbtUtils.getInt(data, "num_stars", 1500);
     }
     public float getStarSizeBase() {
-        return test(data, "star_size_base", 0.15f);
+        return NbtUtils.getFloat(data, "star_size_base", 0.15f);
     }
     public float getStarSizeModifier() {
-        return test(data, "star_size_modifier", 0.1f);
+        return NbtUtils.getFloat(data, "star_size_modifier", 0.1f);
     }
     public float getStellarTiltY() {
-        return test(data, "stellar_tilt_y", -90.0f);
+        return NbtUtils.getFloat(data, "stellar_tilt_y", -90.0f);
     }
     public float getStellarTiltZ() {
-        return test(data, "stellar_tilt_z", 0.0f);
+        return NbtUtils.getFloat(data, "stellar_tilt_z", 0.0f);
     }
     public float getStellarVelocity() {
-        return test(data, "stellar_velocity", 1.0f);
+        return NbtUtils.getFloat(data, "stellar_velocity", 1.0f);
     }
     public float getDayStarBrightness() {
-        return test(data, "star_brightness_day", 0.0f);
+        return NbtUtils.getFloat(data, "star_brightness_day", 0.0f);
     }
     public float getNightStarBrightness() {
-        return test(data, "star_brightness_night", 0.5f);
+        return NbtUtils.getFloat(data, "star_brightness_night", 0.5f);
     }
     public Vector3f getStellarColor() {
-        int color = test(data, "stellar_color",16777215);
+        int color = NbtUtils.getInt(data, "stellar_color",16777215);
         return new Vector3f((float)(color >> 16 & 0xFF) / 255.0f, (float)(color >> 8 & 0xFF) / 255.0f, (float)(color & 0xFF) / 255.0f);
     }
 

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

···
 
     static IridescentMap decode(NbtCompound data) {
         if (!data.contains("type")) return Perliny.INSTANCE;
-        return switch (data.getString("type")) {
+        return switch (NbtUtils.getString(data,"type", "")) {
             case "linear" -> Linear.INSTANCE;
-            case "circles" -> new PrettyCircles(NbtUtils.test(data, "scale", num_models / 2.0f));
-            case "static" -> new Static(NbtUtils.test(data, "value", 0));
+            case "circles" -> new PrettyCircles(NbtUtils.getFloat(data, "scale", num_models / 2.0f));
+            case "static" -> new Static(NbtUtils.getInt(data, "value", 0));
             case "random" -> RandomMap.INSTANCE;
             default -> Perliny.INSTANCE;
         };

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

···
     }
     static PortalColorApplier of(NbtCompound data, int defaultColor) {
         if (!data.contains("portal_color")) return new PortalColorApplier.Simple(defaultColor);
-        if (data.contains("portal_color", NbtElement.INT_TYPE)) return new PortalColorApplier.Simple(data.getInt("portal_color"));
-        NbtCompound applierData = data.getCompound("portal_color");
-        return switch (applierData.getString("type")) {
-            case "simple" -> new PortalColorApplier.Simple(applierData.getInt("value"));
+        if (data.contains("portal_color", NbtElement.INT_TYPE)) return new PortalColorApplier.Simple(NbtUtils.getInt(data, "portal_color"));
+        NbtCompound applierData = NbtUtils.getCompound(data, "portal_color");
+        return switch (NbtUtils.getString(applierData, "type", "")) {
+            case "simple" -> new PortalColorApplier.Simple(NbtUtils.getInt(applierData, "value"));
             case "checker" -> new PortalColorApplier.Checker(applierData.getList("values", NbtElement.INT_TYPE));
             case "random_hue" -> new PortalColorApplier.RandomHue(applierData);
             case "random" -> PortalColorApplier.RandomColor.INSTANCE;
···
 
     record RandomHue(float saturation, float brightness, float detail) implements PortalColorApplier {
         public RandomHue(NbtCompound applierData) {
-            this(NbtUtils.test(applierData, "saturation", 1.0f),
-                    NbtUtils.test(applierData, "brightness", 1.0f),
-                    NbtUtils.test(applierData, "detail", 12.0f));
+            this(NbtUtils.getFloat(applierData, "saturation", 1.0f),
+                    NbtUtils.getFloat(applierData, "brightness", 1.0f),
+                    NbtUtils.getFloat(applierData, "detail", 12.0f));
         }
 
         @Override

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

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.dimensions.RandomDimension;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.minecraft.nbt.NbtCompound;
···
         NbtCompound effect = provider.randomElement(r, ConfigType.EFFECTS);
         if (effect.getBoolean("Instant")) return new NbtCompound();
         int amplifier = Math.min(5, (int)(0.5*r.nextExponential()));
-        res.putString("id", effect.getString("Name"));
+        res.putString("id", NbtUtils.getString(effect, "Name"));
         res.putInt("amplifier", amplifier);
         return res;
     }

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.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.block.Block;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
···
 
 public record Amendment(ConfigType area, ModSelector modSelector, Selector selector, Results results) {
     public static Amendment of(NbtCompound data) {
-        String areaName = data.getString("area");
+        String areaName = NbtUtils.getString(data, "area", "");
         ConfigType area = ConfigType.byName(areaName);
         if (area == null) {
             InfinityMod.LOGGER.warn("Unknown amendment area: {}", areaName);
             return null;
         }
 
-        String mod = data.getString("mod");
+        String mod = NbtUtils.getString(data, "mod");
         ModSelector modSelector;
         if (mod.equals("all")) {
             modSelector = new UniversalModSelector();
···
         else if (!Platform.isModLoaded(mod)) return null;
         else modSelector = new MatchingModSelector(mod);
 
-        String selectorType = data.getString("selector");
+        String selectorType = NbtUtils.getString(data,"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 "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(data.getList("matching", NbtElement.STRING_TYPE)
                     .stream().map(e->(NbtString)e).map(NbtString::asString).toList());
             default -> {
···
             }
         };
 
-        String resultType = data.getString("results");
+        String resultType = NbtUtils.getString(data, "results");
         Results results = switch (resultType) {
-            case "set_value" -> new SetValue(data.getInt("value"));
+            case "set_value" -> new SetValue(NbtUtils.getInt(data, "value"));
             case "erase" -> new SetValue(0);
-            case "set_field" -> new SetField(data.getString("field_name"), data.get("field"));
+            case "set_field" -> new SetField(NbtUtils.getString(data, "field_name"), data.get("field"));
             default -> {
                 InfinityMod.LOGGER.warn("Unknown amendment result type: {}", resultType);
                 yield null;

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

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.core.WeighedStructure;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtList;
···
         range.sort(new Comparator<Integer>() {
             public String extract(int i) {
                 NbtCompound compound = w.get(i);
-                return compound.getString("key");
+                return NbtUtils.getString(compound, "key");
             }
             @Override
             public int compare(Integer i, Integer j) {

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

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.dimensions.RandomNoisePreset;
 import net.lerariemann.infinity.util.core.CommonIO;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.*;
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKeys;
···
         }
 
         void add(NbtCompound rule, TreeLeaf where) {
-            switch(rule.getString("type")) {
+            switch(NbtUtils.getString(rule,"type", "")) {
                 case "condition", "minecraft:condition" -> {
-                    NbtCompound next = rule.getCompound("then_run");
-                    NbtCompound c = rule.getCompound("if_true");
+                    NbtCompound next = NbtUtils.getCompound(rule,"then_run");
+                    NbtCompound c = NbtUtils.getCompound(rule, "if_true");
                     if (c.getString("type").contains("above_preliminary_surface")) {
                         add(next, where);
                     }
···
         }
 
         static boolean checkUnneededParts(NbtCompound rule) {
-            return rule.getString("type").contains("block")
+            return NbtUtils.getString(rule, "type", "").contains("block")
                     && (rule.toString().contains("minecraft:bedrock")
                     || rule.toString().contains("minecraft:deepslate"));
         }

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

···
                 String name = p.getFileName().toString().replace(".json", "");
                 NbtCompound compound = CommonIO.read(p.toFile());
                 if (compound.contains("name"))
-                    name = compound.getString("name");
+                    name = NbtUtils.getString(compound, "name");
                 if (compound.contains("type"))
-                    typeMap.put(name, compound.getString("type"));
+                    typeMap.put(name, NbtUtils.getString(compound, "type"));
                 if (compound.contains("aliases", NbtElement.LIST_TYPE)) {
                     String finalName = name;
                     compound.getList("aliases", NbtElement.STRING_TYPE)
···
                             .forEach(alias -> aliasMap.put(alias, finalName));
                 }
                 else if (compound.contains("aliases", NbtElement.STRING_TYPE))
-                    aliasMap.put(compound.getString("aliases"), name);
+                    aliasMap.put(NbtUtils.getString(compound, "aliases"), name);
                 if (compound.contains("options")) {
-                    optionmap.put(name, compound.getCompound("options"));
+                    optionmap.put(name, NbtUtils.getCompound(compound, "options"));
                 }
 
-                map.put(name, compound.getCompound("generator"));
+                map.put(name, NbtUtils.getCompound(compound, "generator"));
             });
         } catch (IOException e) {
             throw new RuntimeException(e);

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

···
 
 /** Contains various common use methods for working with {@link NbtCompound} objects. */
 public interface NbtUtils {
-    static String test(NbtCompound data, String key, String def) {
+    static String getString(NbtCompound data, String key, String def) {
         return data.contains(key, NbtElement.STRING_TYPE) ? data.getString(key) : 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 float getFloat(NbtCompound data, String key, float def) {
         return data.contains(key, NbtElement.DOUBLE_TYPE) ? data.getFloat(key) : def;
     }
-    static int test(NbtCompound data, String key, int def) {
+    static int getInt(NbtCompound data, String key, int def) {
         return data.contains(key, NbtElement.INT_TYPE) ? data.getInt(key) : def;
     }
-    static double test(NbtCompound data, String key, double def) {
+    static double getDouble(NbtCompound data, String key, double def) {
         return data.contains(key, NbtElement.DOUBLE_TYPE) ? data.getDouble(key) : def;
     }
-    static boolean test(NbtCompound data, String key, boolean def) {
+    static boolean getBoolean(NbtCompound data, String key, boolean def) {
         return data.contains(key) ? data.getBoolean(key) : def;
     }
 
···
     }
 
     static String elementToName(NbtElement e) {
-        if (e instanceof NbtCompound) return ((NbtCompound)e).getString("Name");
+        if (e instanceof NbtCompound compound) return NbtUtils.getString(compound, "Name");
         else return e.asString();
     }
     static NbtCompound nameToElement(String block) {

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

···
         registerCategory(ConfigType.TOP_BLOCKS, topBlocks);
     }
     static boolean popBlockData(NbtCompound e, String key, boolean def) {
-        boolean res = NbtUtils.test(e, key, def);
+        boolean res = NbtUtils.getBoolean(e, key, def);
         e.remove(key);
         return res;
     }

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

···
         double weight;
 
         public Leaf(NbtCompound comp) {
-            name = comp.getString("key");
-            weight = comp.getDouble("weight");
+            name = NbtUtils.getString(comp, "key");
+            weight = NbtUtils.getDouble(comp,"weight");
         }
 
         @Override
···
             weights = new ArrayList<>();
             statsum = 0;
             if (data.isEmpty()) add(def, 1);
-            else for (NbtCompound d : data) add(d.getString("key"), d.getDouble("weight"));
+            else for (NbtCompound d : data) add(NbtUtils.getString(d, "key"), NbtUtils.getDouble(d, "weight"));
         }
         public void add(String key, double weight) {
             statsum += weight;
···
 
         Leaf getLeaf(NbtCompound comp) {
             Leaf str = new Leaf(comp);
-            if (comp.contains("data")) dataMap.put(str.name, comp.getCompound("data"));
+            if (comp.contains("data")) dataMap.put(str.name, NbtUtils.getCompound(comp, "data"));
             return str;
         }