Merge branch 'master' into architectury/1.21.3

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

···
 import net.lerariemann.infinity.registry.core.ModBlockEntities;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItems;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.var.ColorLogic;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
···
     @Override
     public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
         super.readNbt(nbt, registryLookup);
-        if (nbt.contains("color", NbtElement.INT_TYPE))
+        if (nbt.getType("color") == NbtElement.INT_TYPE)
             setColor(nbt.getInt("color"));
-        else if (nbt.contains("color", NbtElement.COMPOUND_TYPE)) {
-            NbtCompound color = nbt.getCompound("color");
-            hue = color.getShort("h");
-            saturation = color.getShort("s");
-            brightness = color.getShort("b");
+        else if (nbt.getType("color") == NbtElement.COMPOUND_TYPE) {
+            NbtCompound color = NbtUtils.getCompound(nbt, "color");
+            hue = NbtUtils.getShort(color, "h");
+            saturation = NbtUtils.getShort(color, "s");
+            brightness = NbtUtils.getShort(color, "b");
             updateColor();
         }
     }

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

···
             biomestoadd.add(NbtString.of(biome));
             sequence.add(ruleWrap(biomestoadd, rule));
         }
-        sequence.add(CommonIO.readAndFormat(
+        sequence.add(NbtUtils.getCompound(CommonIO.readAndFormat(
                 InfinityMod.utilPath + "/surface_rule/default.json",
                 defaultBlock("minecraft:grass_block"),
                 defaultBlock("minecraft:dirt"),
                 defaultBlock("minecraft:dirt"),
                 defaultBlock("minecraft:stone"),
-                defaultBlock("minecraft:gravel")).getCompound("rule"));
+                defaultBlock("minecraft:gravel")), "rule"));
         return sequence;
     }
 

common/src/main/java/net/lerariemann/infinity/dimensions/features/fluid_springs/RandomSpring.java

···
         }
         config.putBoolean("requires_block_below", random.nextBoolean());
         config.put("state", NbtUtils.nameToElement(PROVIDER.randomName(random, ConfigType.FLUIDS)));
-        config.putString("valid_blocks", daddy.default_block.getString("Name"));
+        config.putString("valid_blocks", NbtUtils.getString(daddy.default_block, "Name"));
         return feature(config);
     }
 

common/src/main/java/net/lerariemann/infinity/dimensions/features/raw_generation/RandomShape.java

···
     public NbtCompound feature() {
         NbtCompound config = new NbtCompound();
         NbtList replaceable = new NbtList();
-        replaceable.add(NbtUtils.nameToElement(parent.parent.parent.default_fluid.getString("Name")));
+        replaceable.add(NbtUtils.nameToElement(NbtUtils.getString(parent.parent.parent.default_fluid, "Name")));
         config.put("replaceable", replaceable);
         if (!usePreset) addRandomBlockProvider(config, "block_provider", ConfigType.FULL_BLOCKS_WG);
         else config.put("block_provider", PROVIDER.randomPreset(random, useBands ? "weighted_state_provider" : "noise_provider"));

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

···
 package net.lerariemann.infinity.options;
 
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 
···
     }
 
     static PitchShifter decode(NbtCompound comp) {
-        return switch(comp.getString("type")) {
+        return switch(NbtUtils.getString(comp, "type")) {
             case "constant" -> new Constant(getFloat(comp, "value", 1));
             case "add" -> new Add(getFloat(comp, "value", 1));
             default -> Empty.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(NbtUtils.getInt(data, "portal_color"));
+        if (data.getType("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 "checker" -> new PortalColorApplier.Checker(NbtUtils.getList(applierData, "values", NbtElement.INT_TYPE));
             case "random_hue" -> new PortalColorApplier.RandomHue(applierData);
             case "random" -> PortalColorApplier.RandomColor.INSTANCE;
             default -> new PortalColorApplier.Simple(defaultColor);

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

···
 import net.lerariemann.infinity.util.InfinityMethods;
 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.RandomProvider;
 import net.lerariemann.infinity.util.loading.DimensionGrabber;
 import net.minecraft.block.jukebox.JukeboxSong;
···
     public static void unpackDownloadedPack(NbtCompound songIds, MinecraftClient cl) {
         //the client unpacks a non-empty payload only when needed, meaning only if it doesn't have necessary files yet
         if (!songIds.isEmpty() && !Files.exists(cl.getResourcePackDir().resolve("infinity/assets/infinity/sounds.json"))) {
-            cl.execute(() -> saveResourcePack(cl, songIds.getList("entries", NbtElement.STRING_TYPE).stream()
+            cl.execute(() -> saveResourcePack(cl, NbtUtils.getList(songIds, "entries", NbtElement.STRING_TYPE).stream()
                     .map(NbtElement::asString).map(Identifier::of), false));
         }
         else if (isPreloaded()) {
···
         if (!data.contains("jukeboxes") || !data.contains("entries")) return;
         if (Files.exists(server.getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json"))) return;
 
-        NbtCompound allJukeboxes = data.getCompound("jukeboxes");
+        NbtCompound allJukeboxes = NbtUtils.getCompound(data, "jukeboxes");
         Path pathJukeboxes = server.getSavePath(WorldSavePath.DATAPACKS).resolve("infinity/data/infinity/jukebox_song");
         for (String key: allJukeboxes.getKeys()) {
             if (allJukeboxes.get(key) instanceof NbtCompound jukebox) {

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

···
                 o.ifPresent(settings -> {
                     Optional<NbtElement> c = ChunkGeneratorSettings.CODEC.encodeStart(NbtOps.INSTANCE, settings).result();
                     c.ifPresent(e -> {
-                        Tree t = new Tree(((NbtCompound) e).getCompound("surface_rule"));
+                        Tree t = new Tree(NbtUtils.getCompound(((NbtCompound) e), "surface_rule"));
                         t.biomeLocations.keySet().forEach(biome -> {
                             if (!map.containsKey(biome)) map.put(biome, t.wrappedRule(biome));
                         });
···
                     else {
                         TreeLeaf l = addOfRule(next, where, true);
                         if(Objects.requireNonNull(c.get("biome_is")).getNbtType().equals(NbtList.TYPE)) {
-                            c.getList("biome_is", NbtElement.STRING_TYPE).forEach(e -> addBiomeLoc(e.asString(), l.i));
+                            NbtUtils.getList(c, "biome_is", NbtElement.STRING_TYPE).forEach(e -> addBiomeLoc(e.asString(), l.i));
                         }
                     }
                 }
                 case "sequence", "minecraft:sequence" -> {
-                    NbtList sq = rule.getList("sequence", NbtElement.COMPOUND_TYPE);
+                    NbtList sq = NbtUtils.getList(rule, "sequence", NbtElement.COMPOUND_TYPE);
                     sq.forEach(e -> add((NbtCompound)e, where));
                 }
                 default -> {

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

···
     static boolean getBoolean(NbtCompound data, String key) {
         return data.getBoolean(key);
     }
+    static short getShort(NbtCompound data, String key) {
+        return data.getShort(key);
+    }
     static NbtList getList(NbtCompound data, String key, byte nbttype) {
         return data.getList(key, nbttype);
     }

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

···
         }
         Path root = configPath.resolve("infinity.json");
         if (!root.toFile().exists()) return def;
-        NbtCompound rules = CommonIO.read(configPath.resolve("infinity.json")).getCompound("gameRules");
+        NbtCompound rules = NbtUtils.getCompound(CommonIO.read(configPath.resolve("infinity.json")), "gameRules");
         if (!rules.contains(key)) return def;
         return applier2.apply(rules, key);
     }
···
             if (elem!=null) {
                 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));
+                else this.gameRules.put(s, NbtUtils.getBoolean(gameRules, s));
             }
         }
         NbtCompound rootChances = NbtUtils.getCompound(rootConfig, "rootChances");
···
             }
         }
 
-        NbtList disabledDimensions = rootConfig.getList("disabledDimensions", NbtElement.STRING_TYPE);
+        NbtList disabledDimensions = NbtUtils.getList(rootConfig, "disabledDimensions", NbtElement.STRING_TYPE);
         for (NbtElement jsonElement : disabledDimensions) {
-            this.disabledDimensions.add(jsonElement.asString());
+            this.disabledDimensions.add(String.valueOf(jsonElement));
         }
     }
 
···
             Path file = dir.resolve(type.getKey() + ".json");
             if (file.toFile().exists()) {
                 NbtCompound base = CommonIO.read(file);
-                List<NbtCompound> list = base.getList("elements", NbtElement.COMPOUND_TYPE).stream().map(e -> (NbtCompound)e).toList();
+                List<NbtCompound> list = NbtUtils.getList(base, "elements", NbtElement.COMPOUND_TYPE).stream().map(e -> (NbtCompound)e).toList();
                 registry.put(type, new WeighedStructure.Simple(list, type.getDef()));
             }
         }

common/src/main/java/net/lerariemann/infinity/util/teleport/PortalCreator.java

···
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.core.CommonIO;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.lerariemann.infinity.util.loading.DimensionGrabber;
 import net.lerariemann.infinity.options.PortalColorApplier;
···
         String key = id.getPath();
         if (comp.contains(key)) {
             NbtList l;
-            if (comp.contains(key, NbtElement.STRING_TYPE)) {
+            if (comp.getType(key) == NbtElement.STRING_TYPE) {
                 l = new NbtList();
                 l.add(comp.get(key));
             }
-            else l = comp.getList(key, NbtElement.STRING_TYPE);
+            else l = NbtUtils.getList(comp, key, NbtElement.STRING_TYPE);
             NbtString nbts = NbtString.of(value);
             if (l.contains(nbts)) return; //no need to record a value twice
             comp.remove(key);