Merge branch 'master' into architectury/1.21.3

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

···
 
     public void readNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
         super.readNbt(tag, registryLookup);
-        if (tag.contains("Dimension", NbtElement.NUMBER_TYPE)) { //conversion from legacy formats
+        if (tag.getType("Dimension") == NbtElement.NUMBER_TYPE) { //conversion from legacy formats
             this.portalColor = NbtUtils.getInt(tag, "Dimension") & 0xFFFFFF;
             if (tag.contains("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
+        else if (tag.getType("Dimension") == NbtElement.STRING_TYPE) { //new better format
             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);

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

···
         res.add(parent.parent.default_block.get("Name"));
         for (NbtCompound a : parent.parent.additional_blocks) res.add(a.get("Name"));
         res.add(parent.parent.default_fluid.get("Name"));
-        res.add(NbtString.of(parent.parent.underwater.get(parent.fullname).getString("Name")));
+        res.add(NbtString.of(NbtUtils.getString(parent.parent.underwater.get(parent.fullname), "Name")));
         return res;
     }
 }

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

···
         Map<String, NbtList> tags = new HashMap<>();
         for (String s : structure_ids.keySet()) for (String ss : dictionary.getKeys()) if (s.contains(ss)) {
             for (NbtElement e : (NbtList) Objects.requireNonNull(dictionary.get(ss))) {
-                String t = e.asString();
+                String t = String.valueOf(e);
                 if (!tags.containsKey(t)) tags.put(t, new NbtList());
                 structure_ids.get(s).forEach(fullname -> tags.get(t).add(NbtString.of(fullname)));
             }

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

···
         data.putBoolean("disable_mob_generation", false);
         data.putBoolean("legacy_random_source", false);
         data.put("default_block", parent.default_block);
-        data.put("default_fluid", NbtUtils.nameToElement(parent.default_fluid.getString("Name")));
+        data.put("default_fluid", NbtUtils.nameToElement(NbtUtils.getString(parent.default_fluid, "Name")));
         data.putInt("sea_level", parent.sea_level);
         data.put("noise", noise(dim));
         data.put("noise_router", getRouter(noise_router));
···
             files.forEach(p -> {
                 if (p.toString().contains("surface_rule") && p.toFile().isFile()) {
                     NbtCompound compound = CommonIO.readSurfaceRule(p.toFile(), parent.sea_level);
-                    NbtList biomes = compound.getList("biomes", NbtElement.STRING_TYPE);
+                    NbtList biomes = NbtUtils.getList(compound, "biomes", NbtElement.STRING_TYPE);
                     NbtList biomestoadd = new NbtList();
                     for (NbtElement b : biomes) {
                         if (parent.vanilla_biomes.contains(b.asString())) biomestoadd.add(b);
                     }
                     if (!biomestoadd.isEmpty()) {
-                        NbtCompound rule = compound.getCompound("rule");
+                        NbtCompound rule = NbtUtils.getCompound(compound, "rule");
                         sequence.add(ruleWrap(biomestoadd, rule));
                     }
                 }

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

···
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.lerariemann.infinity.InfinityMod;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.world.level.LevelProperties;
···
         if (instance.isEmpty()) return;
         NbtCompound c = ((NbtCompound) instance.get());
         if (c.contains("dimensions")) {
-            NbtCompound d = c.getCompound("dimensions");
+            NbtCompound d = NbtUtils.getCompound(c, "dimensions");
             NbtCompound newD = new NbtCompound();
             d.getKeys().stream().filter(s -> !s.startsWith(InfinityMod.MOD_ID + ":")).forEach(key -> newD.put(key, d.get(key)));
             c.put("dimensions", newD);

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

···
     }
     public int getHauntingTicks(Random random) {
         if (!isHaunted()) return -2;
-        if (data.contains("haunting_ticks")) return data.getInt("haunting_ticks");
+        if (data.contains("haunting_ticks")) return NbtUtils.getInt(data, "haunting_ticks");
         return random.nextBetween(NbtUtils.getInt(data, "min_haunting_ticks", 20), NbtUtils.getInt(data, "max_haunting_ticks", 200));
     }
 

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

···
 
 import java.util.function.Function;
 
+import static net.lerariemann.infinity.util.core.NbtUtils.getFloat;
+
 public interface PitchShifter {
     Function<Float, Float> applier();
 
···
 
     static PitchShifter decode(NbtCompound comp) {
         return switch(comp.getString("type")) {
-            case "constant" -> new Constant(getFloat(comp, "value"));
-            case "add" -> new Add(getFloat(comp, "value"));
+            case "constant" -> new Constant(getFloat(comp, "value", 1));
+            case "add" -> new Add(getFloat(comp, "value", 1));
             default -> Empty.INSTANCE;
         };
-    }
-
-    static float getFloat(NbtCompound comp, String s) {
-        if (!comp.contains(s, NbtElement.FLOAT_TYPE)) return 1;
-        return comp.getFloat(s);
     }
 }

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

···
         @Override
         public int apply(BlockPos pos) {
             int mod = InfinityMethods.properMod(pos.getX() + pos.getY() + pos.getZ(), values.size());
-            return values.getInt(mod);
+            return NbtUtils.getInt(values, mod);
         }
     }
 

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

···
             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)
+            case "matching_any" -> new MatchingAnySelector(NbtUtils.getList(data, "matching", NbtElement.STRING_TYPE)
                     .stream().map(e->(NbtString)e).map(NbtString::asString).toList());
             default -> {
                 InfinityMod.LOGGER.warn("Unknown amendment selector type: {}", selectorType);
···
         Map<ConfigType, List<Amendment>> data = new HashMap<>();
         NbtCompound rawData = CommonIO.read(InfinityMod.amendmentPath);
         AtomicInteger i = new AtomicInteger();
-        for (NbtElement e : rawData.getList("elements", NbtElement.COMPOUND_TYPE)) {
+        for (NbtElement e : NbtUtils.getList(rawData,"elements", NbtElement.COMPOUND_TYPE)) {
             Amendment amd = Amendment.of((NbtCompound)e);
             if (amd == null) continue;
             i.getAndIncrement();

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

···
 import dev.architectury.platform.Platform;
 import net.lerariemann.infinity.InfinityMod;
 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;
···
     static void evictOldFiles() {
         InfinityMod.LOGGER.info("Evicting old files");
         NbtCompound c = CommonIO.read(InfinityMod.utilPath.resolve("evicted_files.json"));
-        NbtList l = c.getList("content", NbtElement.STRING_TYPE);
+        NbtList l = NbtUtils.getList(c,"content", NbtElement.STRING_TYPE);
         try {
             for (NbtElement e : l) {
                 Path path1 = configPath.resolve(e.asString());

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

···
                 case "condition", "minecraft:condition" -> {
                     NbtCompound next = NbtUtils.getCompound(rule,"then_run");
                     NbtCompound c = NbtUtils.getCompound(rule, "if_true");
-                    if (c.getString("type").contains("above_preliminary_surface")) {
+                    if (NbtUtils.getString(c, "type").contains("above_preliminary_surface")) {
                         add(next, where);
                     }
-                    else if (!c.getString("type").contains("biome")) {
+                    else if (!NbtUtils.getString(c, "type").contains("biome")) {
                         TreeLeaf l = addOfRule(c, where, false);
                         add(next, l);
                     }

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

···
             File file = modDir.toPath().resolve(fullname).toFile();
             if (file.exists()) {
                 NbtCompound base = read(file);
-                base.getList("elements", NbtElement.COMPOUND_TYPE).stream().map(e -> (NbtCompound)e).forEach(compounds::add);
+                NbtUtils.getList(base,"elements", NbtElement.COMPOUND_TYPE).stream().map(e -> (NbtCompound)e).forEach(compounds::add);
             }
         }
         return compounds;

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

···
                     typeMap.put(name, NbtUtils.getString(compound, "type"));
                 if (compound.contains("aliases", NbtElement.LIST_TYPE)) {
                     String finalName = name;
-                    compound.getList("aliases", NbtElement.STRING_TYPE)
+                    NbtUtils.getList(compound, "aliases", NbtElement.STRING_TYPE)
                             .stream()
                             .map(e -> (NbtString)e)
                             .map(NbtString::asString)

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

···
     static boolean getBoolean(NbtCompound data, String key) {
         return data.getBoolean(key);
     }
+    static NbtList getList(NbtCompound data, String key, byte nbttype) {
+        return data.getList(key, nbttype);
+    }
+    static int getInt(NbtList data, int key) {
+        return data.getInt(key);
+    }
 
     static String elementToName(NbtElement e) {
         if (e instanceof NbtCompound compound) return NbtUtils.getString(compound, "Name");