1.21.5 port

common/src/main/java/net/lerariemann/infinity/block/custom/InfinityPortalBlock.java

···
 import net.minecraft.block.*;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityCollisionHandler;
 import net.minecraft.entity.ItemEntity;
 import net.minecraft.entity.SpawnReason;
 import net.minecraft.entity.player.PlayerEntity;
···
     @Environment(EnvType.CLIENT) @Override
     public void randomDisplayTick(BlockState state, World world, BlockPos pos, net.minecraft.util.math.random.Random random) {
         if (random.nextInt(100) == 0) {
-            world.playSound((double)pos.getX() + 0.5, (double)pos.getY() + 0.5, (double)pos.getZ() + 0.5, SoundEvents.BLOCK_BEACON_AMBIENT, SoundCategory.BLOCKS, 1.0F, random.nextFloat() * 0.4F + 0.8F, false);
+            world.playSound(null, (double)pos.getX() + 0.5, (double)pos.getY() + 0.5, (double)pos.getZ() + 0.5, SoundEvents.BLOCK_BEACON_AMBIENT, SoundCategory.BLOCKS, 1.0F, random.nextFloat() * 0.4F + 0.8F);
         }
 
         for(int i = 0; i < 4; ++i) {
···
                 eff = new DustParticleEffect(colorInt, 1.0f);
             }
 
-            world.addParticle(eff, d, e, f, g, h, j);
+            world.addParticleClient(eff, d, e, f, g, h, j);
         }
     }
 
···
      * Adds logic for portal-based recipes.
      */
     @Override
-    public void onEntityCollision(BlockState state, World w, BlockPos pos, Entity entity) {
+    public void onEntityCollision(BlockState state, World w, BlockPos pos, Entity entity, EntityCollisionHandler handler) {
         AtomicBoolean bl = new AtomicBoolean(false);
         if (w instanceof ServerWorld world
                 && world.getBlockEntity(pos) instanceof InfinityPortalBlockEntity ipbe) {
···
                 }
             }
         }
-        if (!bl.get()) super.onEntityCollision(state, w, pos, entity);
+        if (!bl.get()) super.onEntityCollision(state, w, pos, entity, handler);
     }
     /**
      * Spawns chaos pawns in the portal.

common/src/main/java/net/lerariemann/infinity/block/custom/NotesBlock.java

···
             if (noteBlockInstrument.canBePitched()) {
                 int i = world.random.nextInt(24);
                 f = NoteBlock.getNotePitch(i);
-                world.addParticle(ParticleTypes.NOTE, pos.getX() + 0.5, pos.getY() + 1.2, pos.getZ() + 0.5, i / 24.0, 0.0F, 0.0F);
+                world.addParticleClient(ParticleTypes.NOTE, pos.getX() + 0.5, pos.getY() + 1.2, pos.getZ() + 0.5, i / 24.0, 0.0F, 0.0F);
             } else {
                 f = 1.0F;
             }

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

···
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.component.ComponentMap;
+import net.minecraft.component.ComponentsAccess;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket;
···
     }
 
     @Override
-    protected void readComponents(BlockEntity.ComponentsAccess components) {
+    protected void readComponents(ComponentsAccess components) {
         super.readComponents(components);
         this.biome = components.getOrDefault(ModComponentTypes.BIOME_CONTENTS.get(), BiomeBottleBlock.defaultBiome());
         this.color = components.getOrDefault(ModComponentTypes.COLOR.get(), 0xFFFFFF);

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

···
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.component.ComponentMap;
+import net.minecraft.component.ComponentsAccess;
 import net.minecraft.item.DyeItem;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
···
         componentMapBuilder.add(ModComponentTypes.COLOR.get(), color);
     }
     @Override
-    protected void readComponents(BlockEntity.ComponentsAccess components) {
+    protected void readComponents(ComponentsAccess components) {
         super.readComponents(components);
         setColor(components.getOrDefault(ModComponentTypes.COLOR.get(), 0xFFFFFF));
     }
···
     @Override
     public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
         super.readNbt(nbt, registryLookup);
-        if (nbt.getType("color") == NbtElement.INT_TYPE)
-            setColor(nbt.getInt("color"));
-        else if (nbt.getType("color") == NbtElement.COMPOUND_TYPE) {
+        if (nbt.get("color").getType() == NbtElement.INT_TYPE)
+            setColor(nbt.getInt("color").get());
+        else if (nbt.get("color").getType() == NbtElement.COMPOUND_TYPE) {
             NbtCompound color = NbtUtils.getCompound(nbt, "color");
             hue = NbtUtils.getShort(color, "h");
             saturation = NbtUtils.getShort(color, "s");

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.getType("Dimension") == NbtElement.NUMBER_TYPE) { //conversion from legacy formats
+        if (tag.get("Dimension").getType() == NbtElement.INT_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.getType("Dimension") == NbtElement.STRING_TYPE) { //new better format
+        else if (tag.get("Dimension").getType() == NbtElement.STRING_TYPE) { //new better format
             this.dimension = Identifier.of(NbtUtils.getString(tag, "Dimension"));
             this.portalColor = NbtUtils.getInt(tag, "Color", (world instanceof ServerWorld serverWorld ? PortalColorApplier.of(dimension, serverWorld.getServer()) :
                     PortalColorApplier.of(dimension, new NbtCompound())).apply(pos) & 0xFFFFFF);

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

···
 
     static void amendmentSetter(String name, String newValue, int amendmentIndex) {
         NbtCompound elements = readNbt(configPath()+("/amendments.json"));
-        NbtCompound amendment = elements.getList("elements", 10).getCompound(amendmentIndex);
+        NbtCompound amendment = elements.getList("elements").get().getCompound(amendmentIndex).get();
         // Check if an amendment should be changed before writing
         if (!Objects.equals(NbtUtils.getString(amendment, name), newValue)) {
             amendment.putString(name, newValue);
···
 
     static void amendmentSetter(String name, Double newValue, int amendmentIndex) {
         NbtCompound elements = readNbt(configPath()+("/amendments.json"));
-        NbtCompound amendment = elements.getList("elements", 10).getCompound(amendmentIndex);
+        NbtCompound amendment = elements.getList("elements").get().getCompound(amendmentIndex).get();
         // Check if an amendment should be changed before writing
         if (NbtUtils.getDouble(amendment, name) != newValue) {
             amendment.putDouble(name, newValue);
···
         if (Objects.equals(newValue.getLast(), ""))
             newValue.removeLast();
         NbtCompound elements = readNbt(configPath()+("/amendments.json"));
-        NbtCompound amendment = elements.getList("elements", NbtElement.COMPOUND_TYPE).getCompound(amendmentIndex);
+        NbtCompound amendment = elements.getList("elements").get().getCompound(amendmentIndex).get();
         // TODO Check if an amendment should be changed before writing
         amendment.put(name, convertNbtList(newValue));
         CommonIO.write(elements, configPath(), "amendments.json");

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

···
      */
     public static NbtCompound readNbt(String file) {
         try {
-            return StringNbtReader.parse(readConfig(file));
+            return StringNbtReader.readCompound(readConfig(file));
         } catch (CommandSyntaxException e) {
             throw new RuntimeException(e);
         }

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

···
         }
         // If a dimension should be disabled...
         else {
-            if (!rootConfig.getList("disabledDimensions", 8).contains(NbtString.of(name))) {
+            if (!rootConfig.getList("disabledDimensions").get().contains(NbtString.of(name))) {
                 // remove it from the list of disabled dimensions.
-                rootConfig.getList("disabledDimensions", 8).add(NbtString.of(name));
+                rootConfig.getList("disabledDimensions").get().add(NbtString.of(name));
 
                 CommonIO.write(rootConfig, configPath(), "infinity.json");
             }

common/src/main/java/net/lerariemann/infinity/compat/eiv/iridescence_crafting/IridescenceCraftingServerRecipe.java

···
 import de.crafty.eiv.common.api.recipe.IEivServerRecipe;
 import de.crafty.eiv.common.recipe.util.EivTagUtil;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtString;
···
 
     @Override
     public void loadFromTag(NbtCompound tag) {
-        this.input = EivTagUtil.readIngredient(tag.getCompound("ingredient"));
-        this.output = EivTagUtil.decodeItemStack(tag.getCompound("result"));
-        this.lore = tag.getString("lore");
+        this.input = EivTagUtil.readIngredient(NbtUtils.getCompound(tag, "ingredient"));
+        this.output = EivTagUtil.decodeItemStack(NbtUtils.getCompound(tag, "result"));
+        this.lore = NbtUtils.getString(tag,"lore");
     }
 
     @Override

common/src/main/java/net/lerariemann/infinity/compat/eiv/portal_crafting/PortalCraftingServerRecipe.java

···
 import de.crafty.eiv.common.api.recipe.IEivServerRecipe;
 import de.crafty.eiv.common.recipe.util.EivTagUtil;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtString;
···
 
     @Override
     public void loadFromTag(NbtCompound tag) {
-        this.input = EivTagUtil.readIngredient(tag.getCompound("ingredient"));
-        this.output = EivTagUtil.decodeItemStack(tag.getCompound("result"));
-        this.lore = tag.getString("lore");
+        this.input = EivTagUtil.readIngredient(NbtUtils.getCompound(tag, "ingredient"));
+        this.output = EivTagUtil.decodeItemStack(NbtUtils.getCompound(tag, "result"));
+        this.lore = NbtUtils.getString(tag, "lore");
     }
 
     @Override

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

···
 
     void rollAndPutSafe(NbtCompound res, String key, NbtElement randomSound) {
         if (roll(key)) {
-            if (randomSound != null && !randomSound.asString().isBlank())
+            if (randomSound != null && !randomSound.asString().orElse("").isBlank())
                 res.put(key, randomSound);
         }
     }

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 = e.asString().get();
                 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/features/vegetation/RandomSurfacePatch.java

···
         int tries_max = (xz_spread+1)*(xz_spread+1);
         NbtCompound config = CommonIO.readAndFormat(InfinityMod.utilPath + "/preplacements/surfacepatch.json",
                 CommonIO.compoundToString(PROVIDER.randomElement(random, ConfigType.BLOCKS_FEATURES)),
-                parent.surface_block.getString("Name"), Math.min(256, random.nextInt(tries_max)), xz_spread, y_spread);
+                parent.surface_block.getString("Name").get(), Math.min(256, random.nextInt(tries_max)), xz_spread, y_spread);
         return feature(config);
     }
 }

common/src/main/java/net/lerariemann/infinity/entity/client/AntModel.java

···
 		ModelData modelData = new ModelData();
 		ModelPartData root = modelData.getRoot();
 		ModelPartData body = root.addChild("body", ModelPartBuilder.create().uv(0, 11).cuboid(-2.0F, -5.75F, 3.0F, 4.0F, 4.0F, 4.0F, new Dilation(0.0F))
-				.uv(0, 0).cuboid(-1.0F, -4.0F, -5.0F, 2.0F, 2.0F, 9.0F, new Dilation(0.0F)), ModelTransform.pivot(0.0F, 24.0F, 0.0F));
+				.uv(0, 0).cuboid(-1.0F, -4.0F, -5.0F, 2.0F, 2.0F, 9.0F, new Dilation(0.0F)), ModelTransform.rotation(0.0F, 24.0F, 0.0F));
 
 		body.addChild("head", ModelPartBuilder.create().uv(16, 11).cuboid(-1.5F, -1.75F, -3.0F, 3.0F, 3.0F, 3.0F, new Dilation(0.0F))
 				.uv(0, 0)
 				.cuboid(2.0F, -3.75F, -1.0F, -1.0F, 3.0F, 1.0F, new Dilation(0.0F))
 				.uv(0, 0)
 				.cuboid(-1.0F, -3.75F, -1.0F, -1.0F, 3.0F, 1.0F, new Dilation(0.0F)),
-				ModelTransform.pivot(0.0F, -3.0F, -4.0F));
+				ModelTransform.rotation(0.0F, -3.0F, -4.0F));
 
 		body.addChild("front_left_leg", ModelPartBuilder.create()
 				.uv(16, 17)

common/src/main/java/net/lerariemann/infinity/entity/client/BishopModel.java

···
         root.addChild("body",
                 ModelPartBuilder.create().uv(16, 16)
                         .cuboid(-4.0F, 0.0F, -2.0F, 8.0F, 12.0F, 4.0F, Dilation.NONE),
-                ModelTransform.pivot(0.0F, 0.0F, 0.0F));
+                ModelTransform.rotation(0.0F, 0.0F, 0.0F));
 
         root.addChild("head",
                 ModelPartBuilder.create()
···
                         .cuboid(-1.0F, -17.0F, -1.0F, 2.0F, 4.0F, 2.0F, Dilation.NONE)
                         .uv(54, 59)
                         .cuboid(-1.0F, -19.0F, -1.0F, 2.0F, 2.0F, 2.0F, new Dilation(0.5F)),
-                ModelTransform.pivot(0.0F, 0.0F, 0.0F));
+                ModelTransform.rotation(0.0F, 0.0F, 0.0F));
         root.addChild("hat", ModelPartBuilder.create()
                         .uv(32, 35)
                         .cuboid(-4.0F, -8.0F, -4.0F, 8.0F, 8.0F, 8.0F, new Dilation(0.5F)),
-                ModelTransform.pivot(0.0F, 0.0F, 0.0F));
+                ModelTransform.rotation(0.0F, 0.0F, 0.0F));
 
         root.addChild("right_arm", ModelPartBuilder.create()
                         .uv(0, 16)
                         .cuboid(-3.0F, -2.0F, -2.0F, 4.0F, 12.0F, 4.0F, Dilation.NONE),
-                ModelTransform.pivot(-5.0F, 2.0F, 0.0F));
+                ModelTransform.rotation(-5.0F, 2.0F, 0.0F));
         root.addChild("left_arm", ModelPartBuilder.create()
                         .uv(16, 48)
                         .cuboid(-1.0F, -2.0F, -2.0F, 4.0F, 12.0F, 4.0F, Dilation.NONE),
-                ModelTransform.pivot(5.0F, 2.0F, 0.0F));
+                ModelTransform.rotation(5.0F, 2.0F, 0.0F));
         root.addChild("right_leg", ModelPartBuilder.create()
                         .uv(0, 16)
                         .cuboid(-2.0F, 0.0F, -2.0F, 4.0F, 12.0F, 4.0F, Dilation.NONE),
-                ModelTransform.pivot(-1.9F, 12.0F, 0.0F));
+                ModelTransform.rotation(-1.9F, 12.0F, 0.0F));
         root.addChild("left_leg", ModelPartBuilder.create()
                         .uv(16, 48)
                         .cuboid(-2.0F, 0.0F, -2.0F, 4.0F, 12.0F, 4.0F, Dilation.NONE),
-                ModelTransform.pivot(1.9F, 12.0F, 0.0F));
+                ModelTransform.rotation(1.9F, 12.0F, 0.0F));
 
         return TexturedModelData.of(modelData, 64, 64);
     }

common/src/main/java/net/lerariemann/infinity/entity/client/ChaosPawnTint.java

···
 import net.lerariemann.infinity.entity.custom.ChaosPawn;
 import net.lerariemann.infinity.entity.custom.TintableEntity;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.model.ModelPart;
 import net.minecraft.client.render.RenderLayer;
···
 
     public void renderOneLayer(MatrixStack matrixStack, VertexConsumer vertexConsumer, int light, int overlay, ChaosPawnRenderState livingEntity, ModelPart part, String name) {
         int color;
-        color = livingEntity.colors.getInt(name);
+        color = NbtUtils.getInt(livingEntity.colors, name);
         if (livingEntity.customName != null) {
             String s = livingEntity.customName.toString();
              if ("jeb_".equals(s)) {

common/src/main/java/net/lerariemann/infinity/entity/client/DimensionalSlimeCoreRenderer.java

···
 package net.lerariemann.infinity.entity.client;
 
+import net.fabricmc.fabric.api.renderer.v1.render.FabricBlockModelRenderer;
 import net.lerariemann.infinity.entity.client.state.ChaosSlimeRenderState;
 import net.lerariemann.infinity.entity.custom.ChaosSlime;
 import net.minecraft.block.BlockState;
···
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
 import net.minecraft.client.render.entity.model.SlimeEntityModel;
-import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.BlockStateModel;
 import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.util.math.BlockPos;
 
 public class DimensionalSlimeCoreRenderer extends FeatureRenderer<ChaosSlimeRenderState, SlimeEntityModel> {
     private final BlockRenderManager blockRenderManager;
···
     }
 
     private void renderCore(MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, BlockState coreState, int overlay) {
-        BakedModel coreModel = this.blockRenderManager.getModel(coreState);
-        this.blockRenderManager.getModelRenderer().render(matrices.peek(), vertexConsumers.getBuffer(RenderLayers.getBlockLayer(coreState)), coreState, coreModel, 1.0f, 1.0f, 1.0f, light, overlay);
+        BlockStateModel coreModel = this.blockRenderManager.getModel(coreState);
+        FabricBlockModelRenderer.render(matrices.peek(), vertexConsumers, coreModel, 1.0f, 1.0f, 1.0f, light, overlay, null, BlockPos.ORIGIN, coreState);
     }
 }

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

···
     protected void tickControlled(PlayerEntity controllingPlayer, Vec3d movementInput) {
         super.tickControlled(controllingPlayer, movementInput);
         this.setRotation(controllingPlayer.getYaw(),controllingPlayer.getPitch() * 0.5F);
-        this.prevYaw = this.bodyYaw = this.headYaw = this.getYaw();
+        this.lastYaw = this.bodyYaw = this.headYaw = this.getYaw();
     }
 
     public static class AntBattleGoal<T extends LivingEntity> extends ActiveTargetGoal<T> {

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
-import net.minecraft.registry.RegistryPair;
+import net.minecraft.registry.entry.LazyRegistryEntryReference;
 import net.minecraft.registry.tag.EntityTypeTags;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.world.ServerWorld;
···
             Identifier song = Identifier.of(InfinityMod.provider.randomName(world.random, ConfigType.JUKEBOXES));
             var color = (int)InfinityMethods.getNumericFromId(song);
             stack.applyComponentsFrom(ComponentMap.builder()
-                    .add(DataComponentTypes.JUKEBOX_PLAYABLE, new JukeboxPlayableComponent(new RegistryPair<>(
-                            RegistryKey.of(RegistryKeys.JUKEBOX_SONG, song)), true))
+                    .add(DataComponentTypes.JUKEBOX_PLAYABLE, new JukeboxPlayableComponent(new LazyRegistryEntryReference<>(
+                            RegistryKey.of(RegistryKeys.JUKEBOX_SONG, song))))
                     .add(ModComponentTypes.COLOR.get(), color).add(DataComponentTypes.CUSTOM_MODEL_DATA, new CustomModelDataComponent(List.of(), List.of(), List.of(), List.of(color, InfinityMethods.invertColor(color)))).build());
             this.dropStack(world, stack);
         }

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

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.util.core.ConfigType;
+import net.lerariemann.infinity.util.core.NbtUtils;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
···
     @Override
     public void readCustomDataFromNbt(NbtCompound nbt) {
         super.readCustomDataFromNbt(nbt);
-        this.setColors(nbt.getCompound("colors"));
-        this.dataTracker.set(special_case, nbt.getInt("case"));
+        this.setColors(NbtUtils.getCompound(nbt, "colors"));
+        this.dataTracker.set(special_case, NbtUtils.getInt(nbt, "case"));
     }
 
     // TODO mojang plz

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

···
         potionEffect.putString("id", effect);
         potionEffect.putInt("duration", duration);
         List<StatusEffectInstance> customEffects = new ArrayList<>();
-        customEffects.add(StatusEffectInstance.fromNbt(potionEffect));
+        // TODO 1.21.5 PUT THIS BACK
+//        customEffects.add(StatusEffectInstance.fromNbt(potionEffect));
         stack.set(DataComponentTypes.POTION_CONTENTS, new PotionContentsComponent(Optional.empty(), Optional.of(color), customEffects, Optional.of(I18n.translate("potion.infinity.skeleton"))));        stack.set(DataComponentTypes.ITEM_NAME, Text.translatable("potion.infinity.skeleton"));
         return stack;
     }

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

···
         int p = n % o;
         int q = (n + 1) % o;
         float r = (float)(age % 25) / 25.0F;
-        int s = SheepEntity.getRgbColor(DyeColor.byId(p));
-        int t = SheepEntity.getRgbColor(DyeColor.byId(q));
+        int s = SheepEntity.getRgbColor(DyeColor.byIndex(p));
+        int t = SheepEntity.getRgbColor(DyeColor.byIndex(q));
         return ColorHelper.lerp(r, s, t);
     }
 

common/src/main/java/net/lerariemann/infinity/iridescence/Iridescence.java

···
             DyeColor.PINK);
 
     static Block getRandomColorBlock(WorldAccess world, String str) {
-        return Registries.BLOCK.get(Identifier.of(dyeColors.get(world.getRandom().nextInt(dyeColors.size())).getName() + "_" + str));
+        return Registries.BLOCK.get(Identifier.of(dyeColors.get(world.getRandom().nextInt(dyeColors.size())).name() + "_" + str));
     }
     static Block getRandomColorBlock(double d, String str) {
-        return Registries.BLOCK.get(Identifier.of(dyeColors.get((int)(d* dyeColors.size())).getName() + "_" + str));
+        return Registries.BLOCK.get(Identifier.of(dyeColors.get((int)(d* dyeColors.size())).name() + "_" + str));
     }
 
     static int getAmplifierOnApply(LivingEntity entity, int original, boolean willingly) {

common/src/main/java/net/lerariemann/infinity/iridescence/IridescenceLiquidBlock.java

···
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityCollisionHandler;
 import net.minecraft.entity.ItemEntity;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.mob.MobEntity;
···
     }
 
     @Override
-    public void onEntityCollision(BlockState state, World world, BlockPos pos, Entity entity) {
-        super.onEntityCollision(state, world, pos, entity);
+    public void onEntityCollision(BlockState state, World world, BlockPos pos, Entity entity, EntityCollisionHandler handler) {
+        super.onEntityCollision(state, world, pos, entity, handler);
         if (world.getFluidState(pos).getLevel() > 3 && world instanceof ServerWorld w) switch (entity) {
             case PlayerEntity player -> Iridescence.tryBeginJourney(player, RandomProvider.ruleInt("iridescenceContactLevel"), false);
             case MobEntity ent -> Iridescence.tryApplyEffect(ent);

common/src/main/java/net/lerariemann/infinity/item/BiomeBottleItem.java

···
 import net.lerariemann.infinity.block.custom.BiomeBottleBlock;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.minecraft.block.Block;
+import net.minecraft.component.type.TooltipDisplayComponent;
 import net.minecraft.item.BlockItem;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
···
 import net.minecraft.util.Util;
 
 import java.util.List;
+import java.util.function.Consumer;
 
 public class BiomeBottleItem extends BlockItem {
     public BiomeBottleItem(Block block, Settings settings) {
···
     }
 
     @Override
-    public void appendTooltip(ItemStack stack, Item.TooltipContext context, List<Text> tooltip, TooltipType type) {
-        super.appendTooltip(stack, context, tooltip, type);
+    public void appendTooltip(ItemStack stack, TooltipContext context, TooltipDisplayComponent displayComponent, Consumer<Text> tooltip, TooltipType type) {
+        super.appendTooltip(stack, context, displayComponent, tooltip, type);
         Identifier biome = stack.getComponents().get(ModComponentTypes.BIOME_CONTENTS.get());
         if (biome != null) {
-            tooltip.add(Text.translatable(Util.createTranslationKey("biome", biome)).formatted(Formatting.GRAY));
+            tooltip.accept(Text.translatable(Util.createTranslationKey("biome", biome)).formatted(Formatting.GRAY));
         }
         else {
             MutableText mutableText = Text.translatable("caption.infinity.biomebottle.empty");
-            tooltip.add(mutableText.formatted(Formatting.GRAY));
+            tooltip.accept(mutableText.formatted(Formatting.GRAY));
         }
         if (type.isAdvanced()) {
-            tooltip.add(Text.translatable("caption.infinity.biomebottle.charge", BiomeBottleBlock.getCharge(stack)).formatted(Formatting.GRAY));
+            tooltip.accept(Text.translatable("caption.infinity.biomebottle.charge", BiomeBottleBlock.getCharge(stack)).formatted(Formatting.GRAY));
         }
     }
 }

common/src/main/java/net/lerariemann/infinity/item/ChromaticItem.java

···
         return ComponentChanges.builder()
                 .add(ModComponentTypes.COLOR.get(), color)
                 .add(DataComponentTypes.CUSTOM_MODEL_DATA, InfinityMethods.getColoredModel(color))
-                .add(ModComponentTypes.DYE_COLOR.get(), dyeColor.getName())
+                .add(ModComponentTypes.DYE_COLOR.get(), dyeColor.name())
                 .remove(ModComponentTypes.HUE.get())
                 .build();
     }
···
             else { //copy color from vanilla blocks
                 DyeColor dyeColor = ColorLogic.getColorByState(oldState);
                 if (dyeColor != null &&
-                        !dyeColor.getName().equals(newStack.getOrDefault(ModComponentTypes.DYE_COLOR.get(), "null"))) {
+                        !dyeColor.name().equals(newStack.getOrDefault(ModComponentTypes.DYE_COLOR.get(), "null"))) {
                     newStack.applyChanges(ofDye(dyeColor));
                 }
                 else return false;

common/src/main/java/net/lerariemann/infinity/item/F4Item.java

···
 import net.minecraft.block.Blocks;
 import net.minecraft.block.NetherPortalBlock;
 import net.minecraft.component.ComponentMap;
+import net.minecraft.component.type.TooltipDisplayComponent;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
···
 import net.minecraft.world.World;
 
 import java.util.*;
+import java.util.function.Consumer;
 
 public class F4Item extends Item implements PortalDataHolder.Destinable {
     static final BlockState OBSIDIAN = Blocks.OBSIDIAN.getDefaultState();
···
     }
 
     @Override
-    public void appendTooltip(ItemStack stack, Item.TooltipContext context, List<Text> tooltip, TooltipType type) {
-        super.appendTooltip(stack, context, tooltip, type);
+    public void appendTooltip(ItemStack stack, TooltipContext context, TooltipDisplayComponent displayComponent, Consumer<Text> tooltip, TooltipType type) {
+        super.appendTooltip(stack, context, displayComponent, tooltip, type);
         Identifier dimension = stack.getComponents().get(ModComponentTypes.DESTINATION.get());
         MutableText mutableText = getDimensionTooltip(dimension);
-        tooltip.add(mutableText.formatted(Formatting.GRAY));
+        tooltip.accept(mutableText.formatted(Formatting.GRAY));
         MutableText mutableText2 = Text.translatable("tooltip.infinity.f4.charges", getCharge(stack));
-        tooltip.add(mutableText2.formatted(Formatting.GRAY));
+        tooltip.accept(mutableText2.formatted(Formatting.GRAY));
     }
 
     public static ItemStack placePortal(World world, PlayerEntity player, ItemStack stack, BlockPos lowerCenter,

common/src/main/java/net/lerariemann/infinity/item/IridescentPotionItem.java

···
 import net.lerariemann.infinity.registry.core.ModStatusEffects;
 import net.minecraft.advancement.criterion.Criteria;
 import net.minecraft.component.type.PotionContentsComponent;
+import net.minecraft.component.type.TooltipDisplayComponent;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.player.PlayerEntity;
···
 import net.minecraft.world.event.GameEvent;
 
 import java.util.List;
+import java.util.function.Consumer;
 
 public class IridescentPotionItem extends Item {
     public IridescentPotionItem(Settings settings) {
···
     }
 
     @Override
-    public void appendTooltip(ItemStack stack, Item.TooltipContext context, List<Text> tooltip, TooltipType type) {
+    public void appendTooltip(ItemStack stack, TooltipContext context, TooltipDisplayComponent displayComponent, Consumer<Text> tooltip, TooltipType type) {
         int level = stack.getOrDefault(ModComponentTypes.CHARGE.get(), 0);
         List<StatusEffectInstance> effects = List.of(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT,
                 Iridescence.getFullEffectLength(level), level));
-        PotionContentsComponent.buildTooltip(effects, tooltip::add, 1.0F, context.getUpdateTickRate());
+        PotionContentsComponent.buildTooltip(effects, tooltip::accept, 1.0F, context.getUpdateTickRate());
     }
 }

common/src/main/java/net/lerariemann/infinity/item/TransfiniteKeyItem.java

···
 import net.minecraft.component.ComponentChanges;
 import net.minecraft.component.DataComponentTypes;
 import net.minecraft.component.type.CustomModelDataComponent;
+import net.minecraft.component.type.TooltipDisplayComponent;
 import net.minecraft.entity.ItemEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
···
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Consumer;
 
 public class TransfiniteKeyItem extends Item implements PortalDataHolder.Destinable {
     public TransfiniteKeyItem(Settings settings) {
···
     }
 
     @Override
-    public void appendTooltip(ItemStack stack, TooltipContext context, List<Text> tooltip, TooltipType type) {
-        super.appendTooltip(stack, context, tooltip, type);
+    public void appendTooltip(ItemStack stack, TooltipContext context, TooltipDisplayComponent displayComponent, Consumer<Text> tooltip, TooltipType type) {
+        super.appendTooltip(stack, context, displayComponent, tooltip, type);
         Identifier dimension = stack.getComponents().get(ModComponentTypes.DESTINATION.get());
         MutableText mutableText = (dimension != null)
                 ? InfinityMethods.getDimensionNameAsText(dimension)
                 : Text.translatable("tooltip.infinity.key.randomise");
-        tooltip.add(mutableText.formatted(Formatting.GRAY));
+        tooltip.accept(mutableText.formatted(Formatting.GRAY));
     }
 
     public CustomModelDataComponent getDataForClientItem(ItemStack stack) {

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

···
 import net.minecraft.block.Blocks;
 import net.minecraft.block.NetherPortalBlock;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityCollisionHandler;
 import net.minecraft.entity.ItemEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.state.property.EnumProperty;
···
 	@Shadow @Final public static EnumProperty<Direction.Axis> AXIS;
 
 	/* The root hook for "throw a book in the portal" logic. */
-	@Inject(at = @At("HEAD"), method = "onEntityCollision(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/entity/Entity;)V")
-	private void injected(BlockState state, World world, BlockPos pos, Entity entity, CallbackInfo info) {
+	@Inject(at = @At("HEAD"), method = "onEntityCollision")
+	private void injected(BlockState state, World world, BlockPos pos, Entity entity, EntityCollisionHandler handler, CallbackInfo ci) {
 		if (world instanceof ServerWorld w && entity instanceof ItemEntity e) {
 			PortalCreator.tryCreatePortalFromItem(w, pos, e);
 		}

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

···
     @Unique private Identifier infinity$idForWarp;
 
     @Inject(method="findRespawnPosition", at = @At("HEAD"), cancellable = true)
-    private static void injected(ServerWorld world, BlockPos pos, float angle, boolean forced, boolean alive, CallbackInfoReturnable<Optional<Vec3d>> cir) {
+    private static void injected(ServerWorld world, ServerPlayerEntity.Respawn respawn, boolean bl, CallbackInfoReturnable<Optional<?>> cir) {
         if (InfinityMethods.isTimebombed(world)) cir.setReturnValue(Optional.empty());
     }
 

common/src/main/java/net/lerariemann/infinity/mixin/iridescence/StatusEffectInstanceMixin.java

···
 import net.minecraft.entity.effect.StatusEffect;
 import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.registry.entry.RegistryEntry;
+import net.minecraft.server.world.ServerWorld;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
···
     @Shadow private int amplifier;
 
     /* Hook for unconventional status effect ticking logic */
-    @Inject(method = "update", at = @At(target = "Lnet/minecraft/entity/effect/StatusEffectInstance;updateDuration()I", value = "INVOKE"))
-    void inj(LivingEntity entity, Runnable overwriteCallback, CallbackInfoReturnable<Boolean> cir) {
+    @Inject(method = "update", at = @At(target = "Lnet/minecraft/entity/effect/StatusEffectInstance;updateDuration()V", value = "INVOKE"))
+    void inj(ServerWorld world, LivingEntity entity, Runnable hiddenEffectCallback, CallbackInfoReturnable<Boolean> cir) {
         if (getEffectType().value() instanceof ModStatusEffects.SpecialEffect eff) {
             eff.tryApplySpecial(entity, duration, amplifier);
         }

common/src/main/java/net/lerariemann/infinity/mixin/mobs/LivingEntityMixin.java

···
 
     /* Handle fall damage in dimensions with custom mavity */
     @Inject(method = "computeFallDamage", at = @At(value = "HEAD"), cancellable = true)
-    protected void inj2(float fallDistance, float damageMultiplier, CallbackInfoReturnable<Integer> cir) {
+    protected void inj2(double fallDistance, float damagePerDistance, CallbackInfoReturnable<Integer> cir) {
         InfinityOptions options = InfinityOptions.access(getWorld());
         if (!options.isEmpty()) {
             if (this.getType().isIn(EntityTypeTags.FALL_DAMAGE_IMMUNE)) cir.setReturnValue(0);
···
                 double clampedMavity = Math.clamp(options.getMavity(), 0.01, 2);
                 double g = fallDistance * clampedMavity - f;
                 cir.setReturnValue(MathHelper.ceil(
-                        (g * damageMultiplier) * this.getAttributeValue(EntityAttributes.FALL_DAMAGE_MULTIPLIER)));
+                        (g * damagePerDistance) * this.getAttributeValue(EntityAttributes.FALL_DAMAGE_MULTIPLIER)));
             }
         }
     }

common/src/main/java/net/lerariemann/infinity/mixin/mobs/SheepEntityMixin.java

···
             setColor(DyeColor.WHITE);
         }
         else if (InfinityMethods.isBiomeInfinity(world, getBlockPos())) {
-            setColor(DyeColor.byId(world.getRandom().nextInt(16)));
+            setColor(DyeColor.byIndex(world.getRandom().nextInt(16)));
         }
     }
 }

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

···
         return data.contains("moons") && ((NbtCompound)(NbtUtils.getList(data, "moons", NbtElement.COMPOUND_TYPE).get(i))).contains(key);
     }
     public float fullLunarTest(String key, int i, float def) {
-        return lunarTest(key, i) ? ((NbtCompound)(NbtUtils.getList(data, "moons", NbtElement.COMPOUND_TYPE).get(i))).getFloat(key) : def;
+        return lunarTest(key, i) ? ((NbtCompound)(NbtUtils.getList(data, "moons", NbtElement.COMPOUND_TYPE).get(i))).getFloat(key, def) : def;
     }
     public float getLunarSize(int i) {
         return fullLunarTest("lunar_size", i, 20.0f);
···
         return fullLunarTest("lunar_tilt_z", i, 0.0f);
     }
     public Vector3f getLunarTint(int i) {
-        int color = lunarTest("lunar_tint", i) ? ((NbtCompound)(NbtUtils.getList(data, "moons", NbtElement.COMPOUND_TYPE).get(i))).getInt("lunar_tint") : 16777215;
+        int color = lunarTest("lunar_tint", i) ? ((NbtCompound)(NbtUtils.getList(data, "moons", NbtElement.COMPOUND_TYPE).get(i))).getInt("lunar_tint", 16777215) : 16777215;
         return new Vector3f((float)(color >> 16 & 0xFF) / 255.0f, (float)(color >> 8 & 0xFF) / 255.0f, (float)(color & 0xFF) / 255.0f);
     }
     public Identifier getLunarTexture(int i) {

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.getType("portal_color") == NbtElement.INT_TYPE) return new PortalColorApplier.Simple(NbtUtils.getInt(data, "portal_color"));
+        if (data.get("portal_color").getType() == 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"));

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

···
     public static NbtCompound effect(Random r, RandomProvider provider) {
         NbtCompound res = new NbtCompound();
         NbtCompound effect = provider.randomElement(r, ConfigType.EFFECTS);
-        if (effect.getBoolean("Instant")) return new NbtCompound();
+        if (NbtUtils.getBoolean(effect, "Instant")) return new NbtCompound();
         int amplifier = Math.min(5, (int)(0.5*r.nextExponential()));
         res.putString("id", NbtUtils.getString(effect, "Name"));
         res.putInt("amplifier", amplifier);

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

···
             case "matching" -> new MatchingSelector(NbtUtils.getString(data, "matching"));
             case "matching_block_tag" -> new MatchingBlockTagSelector(NbtUtils.getString(data, "matching"));
             case "matching_any" -> new MatchingAnySelector(NbtUtils.getList(data, "matching", NbtElement.STRING_TYPE)
-                    .stream().map(e->(NbtString)e).map(NbtString::asString).toList());
+                    .stream().map(e->(NbtString)e).map((string)-> string.asString().get()).toList());
             default -> {
                 InfinityMod.LOGGER.warn("Unknown amendment selector type: {}", selectorType);
                 yield null;

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

···
 import net.minecraft.state.property.Properties;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.collection.Pool;
+import net.minecraft.util.collection.Weighted;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.StructureSpawns;
 import net.minecraft.world.WorldView;
···
         return lst;
     }
 
-    static NbtCompound genEntry(SpawnSettings.SpawnEntry entry) {
+    static NbtCompound genEntry(Weighted<SpawnSettings.SpawnEntry> entry) {
         NbtCompound res = new NbtCompound();
-        res.putString("type", Registries.ENTITY_TYPE.getId(entry.type).toString());
-        res.putInt("maxCount", entry.maxGroupSize);
-        res.putInt("minCount", entry.minGroupSize);
-        res.putInt("weight", entry.getWeight().getValue());
+        res.putString("type", Registries.ENTITY_TYPE.getId(entry.value().type()).toString());
+        res.putInt("maxCount", entry.value().maxGroupSize());
+        res.putInt("minCount", entry.value().minGroupSize());
+        res.putInt("weight", entry.weight());
         return res;
     }
 

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

···
         NbtList l = NbtUtils.getList(c,"content", NbtElement.STRING_TYPE);
         try {
             for (NbtElement e : l) {
-                Path path1 = configPath.resolve(e.asString());
+                Path path1 = configPath.resolve(e.asString().get());
                 LogManager.getLogger().info(path1);
                 if (path1.toFile().exists()) {
-                    Path path2 = configPath.resolve("evicted").resolve(e.asString());
+                    Path path2 = configPath.resolve("evicted").resolve(e.asString().get());
                     Files.createDirectories(path2);
                     Files.copy(path1, path2, REPLACE_EXISTING);
                     Files.delete(path1);

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

···
         //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, NbtUtils.getList(songIds, "entries", NbtElement.STRING_TYPE).stream()
-                    .map(NbtElement::asString).map(Identifier::of), false));
+                    .map(NbtElement::asString).map((str)-> Identifier.of(str.get())), false));
         }
         else if (isPreloaded()) {
             cl.execute(() -> {

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

···
                     else {
                         TreeLeaf l = addOfRule(next, where, true);
                         if(Objects.requireNonNull(c.get("biome_is")).getNbtType().equals(NbtList.TYPE)) {
-                            NbtUtils.getList(c, "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().get(), l.i));
                         }
                     }
                 }

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

···
 package net.lerariemann.infinity.util.core;
 
+import com.mojang.brigadier.StringReader;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import dev.architectury.platform.Platform;
 import net.minecraft.nbt.*;
···
         try {
             if (file.exists()) {
                 content = FileUtils.readFileToString(file, StandardCharsets.UTF_8);
-                NbtCompound c = SaferStringReader.parse(content);
+                // TODO 1.21.5 reimplement saferstringreader
+                NbtCompound c = StringNbtReader.readCompound(content);
                 c.remove("infinity_version");
                 return c;
             }
···
         File file = new File(path);
         try {
             String content = String.valueOf((new Formatter(Locale.US)).format(FileUtils.readFileToString(file, StandardCharsets.UTF_8), args));
-            NbtCompound c = StringNbtReader.parse(content);
+            NbtCompound c = StringNbtReader.readCompound(content);
             c.remove("infinity_version");
             return c;
         } catch (IOException | CommandSyntaxException e) {
···
         int i = content.lastIndexOf("%");
         if (i == -1) {
             try {
-                return StringNbtReader.parse(content);
+                return StringNbtReader.readCompound(content);
             } catch (CommandSyntaxException e) {
                 throw new RuntimeException(e);
             }
···
             case NbtLong nbtLong -> String.valueOf(boundsCheck(nbtLong.longValue()));
             case NbtInt nbtInt -> String.valueOf(boundsCheck(nbtInt.intValue()));
             case NbtShort nbtShort -> String.valueOf(boundsCheck(nbtShort.shortValue()));
-            case NbtString nbtString -> "\"" + nbtString.asString().replace("\"", "\\\"") + "\"";
+            case NbtString nbtString -> "\"" + nbtString.asString().get().replace("\"", "\\\"") + "\"";
             default -> base.toString();
         };
     }

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

···
                     name = NbtUtils.getString(compound, "name");
                 if (compound.contains("type"))
                     typeMap.put(name, NbtUtils.getString(compound, "type"));
-                if (compound.getType("aliases") == NbtElement.LIST_TYPE) {
+                if (NbtUtils.getType(compound, "aliases") == NbtElement.LIST_TYPE) {
                     String finalName = name;
                     NbtUtils.getList(compound, "aliases", NbtElement.STRING_TYPE)
                             .stream()
                             .map(e -> (NbtString)e)
                             .map(NbtString::asString)
-                            .forEach(alias -> aliasMap.put(alias, finalName));
+                            .forEach(alias -> aliasMap.put(alias.orElse(""), finalName));
                 }
-                else if (compound.getType("aliases") == NbtElement.STRING_TYPE)
+                else if (NbtUtils.getType(compound, "aliases") == NbtElement.STRING_TYPE)
                     aliasMap.put(NbtUtils.getString(compound, "aliases"), name);
                 if (compound.contains("options")) {
                     optionmap.put(name, NbtUtils.getCompound(compound, "options"));

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 getString(NbtCompound data, String key, String def) {
-        return data.contains(key, NbtElement.STRING_TYPE) ? data.getString(key) : def;
+        return (NbtUtils.getType(data, key) == NbtElement.STRING_TYPE) ? NbtUtils.getString(data, key) : def;
     }
     static NbtCompound getCompound(NbtCompound data, String key, NbtCompound def) {
-        return data.contains(key, NbtElement.COMPOUND_TYPE) ? data.getCompound(key) : def;
+        return (NbtUtils.getType(data, key) == NbtElement.COMPOUND_TYPE) ? NbtUtils.getCompound(data, key) : def;
     }
     static float getFloat(NbtCompound data, String key, float def) {
-        return data.contains(key, NbtElement.DOUBLE_TYPE) ? data.getFloat(key) : def;
+        return (NbtUtils.getType(data, key) == NbtElement.FLOAT_TYPE) ? NbtUtils.getFloat(data, key) : def;
     }
     static int getInt(NbtCompound data, String key, int def) {
-        return data.contains(key, NbtElement.INT_TYPE) ? data.getInt(key) : def;
+        return (NbtUtils.getType(data, key) == NbtElement.INT_TYPE) ? NbtUtils.getInt(data, key) : def;
     }
     static double getDouble(NbtCompound data, String key, double def) {
-        return data.contains(key, NbtElement.DOUBLE_TYPE) ? data.getDouble(key) : def;
+        return (NbtUtils.getType(data, key) == NbtElement.DOUBLE_TYPE) ? NbtUtils.getDouble(data, key) : def;
     }
     static boolean getBoolean(NbtCompound data, String key, boolean def) {
-        return data.contains(key) ? data.getBoolean(key) : def;
+        return (data.contains(key)) ? NbtUtils.getBoolean(data, key) : def;
     }
 
     static String getString(NbtCompound data, String key) {
-        return data.getString(key);
+        return data.getString(key).orElse("");
     }
     static NbtCompound getCompound(NbtCompound data, String key) {
-        return data.getCompound(key);
+        return data.getCompound(key).orElse(new NbtCompound());
     }
     static float getFloat(NbtCompound data, String key) {
-        return data.getFloat(key);
+        return data.getFloat(key).orElse(0f);
     }
     static int getInt(NbtCompound data, String key) {
-        return data.getInt(key);
+        return data.getInt(key).orElse(0);
     }
     static double getDouble(NbtCompound data, String key) {
-        return data.getDouble(key);
+        return data.getDouble(key).orElse(0d);
     }
     static boolean getBoolean(NbtCompound data, String key) {
-        return data.getBoolean(key);
+        return data.getBoolean(key).orElse(false);
     }
     static short getShort(NbtCompound data, String key) {
-        return data.getShort(key);
+        return data.getShort(key).get();
     }
     static NbtList getList(NbtCompound data, String key, byte nbttype) {
-        return data.getList(key, nbttype);
+        return data.getList(key).orElse(new NbtList());
     }
     static int getInt(NbtList data, int key) {
-        return data.getInt(key);
+        return data.getInt(key).orElse(0);
+    }
+    static int getType(NbtCompound data, String key) {
+        var d = data.get(key);
+        if (d != null)
+            return d.getType();
+        else return -1;
     }
 
     static String elementToName(NbtElement e) {
         if (e instanceof NbtCompound compound) return NbtUtils.getString(compound, "Name");
-        else return e.asString();
+        else return e.asString().orElse("");
     }
     static NbtCompound nameToElement(String block) {
         NbtCompound res = new NbtCompound();

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

···
         return applier2.apply(rules, key);
     }
     public static boolean rule(String key) {
-        return getStaticRule((p, k) -> p.gameRules.getOrDefault(k, false), NbtCompound::getBoolean, key, false);
+        return getStaticRule((p, k) -> p.gameRules.getOrDefault(k, false), NbtUtils::getBoolean, key, false);
     }
     public static int ruleInt(String key) {
         return getStaticRule(RandomProvider::_ruleInt, (p, k) -> ((AbstractNbtNumber) Objects.requireNonNull(p.get(k))).intValue(), key, -1);
···
 
         NbtList disabledDimensions = NbtUtils.getList(rootConfig, "disabledDimensions", NbtElement.STRING_TYPE);
         for (NbtElement jsonElement : disabledDimensions) {
-            this.disabledDimensions.add(String.valueOf(jsonElement));
+            this.disabledDimensions.add((jsonElement.toString()));
         }
     }
 

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

···
 
     public static NbtCompound parse(String string) throws CommandSyntaxException {
         SaferStringReader readerInner = new SaferStringReader(string);
-        StringNbtReader reader = new StringNbtReader(readerInner);
 
-        NbtCompound nbtCompound = reader.parseCompound();
+        NbtCompound nbtCompound = StringNbtReader.readCompound(string);
         readerInner.skipWhitespace();
         if (readerInner.canRead()) {
             throw StringNbtReader.TRAILING.createWithContext(readerInner);

common/src/main/java/net/lerariemann/infinity/util/screen/F4ScreenHandler.java

···
 
         public Factory(PlayerEntity player) {
             f4 = player.getStackInHand(Hand.MAIN_HAND);
-            slot = player.getInventory().selectedSlot;
+            slot = player.getInventory().getSelectedSlot();
             Identifier id = f4.get(ModComponentTypes.DESTINATION.get());
             destination = id == null ? "" : id.toString();
         }

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

···
         String key = id.getPath();
         if (comp.contains(key)) {
             NbtList l;
-            if (comp.getType(key) == NbtElement.STRING_TYPE) {
+            if (comp.get(key).getType() == NbtElement.STRING_TYPE) {
                 l = new NbtList();
                 l.add(comp.get(key));
             }

common/src/main/java/net/lerariemann/infinity/util/var/ColorLogic.java

···
     int defaultPortal = 0x00EEFF;
 
     static int getChromaticColor(DyeColor dye) {
-        return chromaticColors.getOrDefault(dye.getName(), 0xFFFFFF);
+        return chromaticColors.getOrDefault(dye.name(), 0xFFFFFF);
     }
 
     static int getPureHue(double hue) {
···
                 .replace("$", color)));
     }
     static Block getBlockByColor(DyeColor color, TagKey<Block> type) {
-        return getBlockByColor(color.getName(), type);
+        return getBlockByColor(color.name(), type);
     }
 
     static DyeColor getColorByState(BlockState state) {
         for (TagKey<Block> key : supportedBlockTypes.keySet()) if (state.isIn(key)) {
             Identifier id = Registries.BLOCK.getId(state.getBlock());
-            return DyeColor.byName(
+            return DyeColor.byId(
                     id.getPath().replace(supportedBlockTypes.get(key).replace("$", ""), ""),
                     null);
         }

fabric/src/main/resources/fabric.mod.json

···
   "depends": {
     "fabricloader": ">=0.15.11",
     "fabric-api": "*",
-    "minecraft": "1.21.4",
+    "minecraft": "1.21.5",
     "java": ">=21",
     "architectury": "*"
   },

gradle.properties

···
 tbversion = 0
 
 # Minecraft properties
-minecraft_version = 1.21.4
-yarn_mappings = 8
+minecraft_version = 1.21.5
+yarn_mappings = 1
 
 # Dependencies
-architectury_api_version = 15.0.3
+architectury_api_version = 16.1.4
 
 # Fabric Dependencies
 fabric_loader_version = 0.16.13
-fabric_api_version = 0.119.3+1.21.4
+fabric_api_version = 0.128.1+1.21.5
 
 # NeoForge Dependencies
-neoforge_version = 21.4.141
+neoforge_version = 21.5.81
 yarn_mappings_patch_neoforge_version = 1.21+build.4
 # Forgified Fabric API module versions
 forgified_fabric_api_base_version = 0.4.42+d1308ded19
···
 # Optional Dependencies
 catalogue_version = 5631367
 cloth_version = 17.0.144
-modmenu_version = 13.0.3
+modmenu_version = 14.0.0-rc.2
 emi_version = 1.1.18
 cct_version = 1.115.0
 dimlib_version = v1.1.0-mc1.21.1