messy 1.21.8 work

common/src/main/java/net/lerariemann/infinity/access/Timebombable.java

···
         }
         else if (i > 200) {
             if (i%4 == 0) {
-                Registry<DamageType> r = player.getServerWorld().getServer().getRegistryManager().getOrThrow(RegistryKeys.DAMAGE_TYPE);
+                Registry<DamageType> r = player.getServer().getRegistryManager().getOrThrow(RegistryKeys.DAMAGE_TYPE);
                 RegistryEntry<DamageType> entry = r.getEntry(r.get(InfinityMethods.getId("world_ceased")));
-                player.damage(player.getServerWorld(), new DamageSource(entry), i > 400 ? 2.0f : 1.0f);
+                player.damage(player.getWorld(), new DamageSource(entry), i > 400 ? 2.0f : 1.0f);
             }
         }
     }

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

···
 import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.screen.PropertyDelegate;
 import net.minecraft.server.world.ServerWorld;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
···
         this.biome = i;
     }
 
-    public void writeNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
-        super.writeNbt(tag, registryLookup);
-        tag.putString("Biome", biome.toString());
-        tag.putInt("Color", color);
-        tag.putInt("Charge", charge);
-        if (from_charge > 0) tag.putInt("from_charge", from_charge);
+    @Override
+    protected void writeData(WriteView view) {
+        super.writeData(view);
+        view.putString("Biome", biome.toString());
+        view.putInt("Color", color);
+        view.putInt("Charge", charge);
+        if (from_charge > 0) view.putInt("from_charge", from_charge);
     }
 
-    public void readNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
-        super.readNbt(tag, registryLookup);
-        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
+    public void readData(ReadView view) {
+        super.readData(view);
+        this.charge = NbtUtils.getInt(view, "Charge");
+        this.biome = Identifier.of(NbtUtils.getString(view, "Biome"));
+        this.color = NbtUtils.getInt(view, "Color");
+        this.from_charge = NbtUtils.getInt(view, "from_charge", 0);
     }
 
     @Override

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

···
 import net.minecraft.sound.SoundCategory;
 import net.minecraft.sound.SoundEvent;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 import org.jetbrains.annotations.Nullable;
···
     }
 
     @Override
-    public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
-        super.readNbt(nbt, registryLookup);
-        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");
-            brightness = NbtUtils.getShort(color, "b");
+    public void readData(ReadView nbt) {
+        super.readData(nbt);
+        if (nbt.contains("color") && nbt.getInt("color", 0) != 0) {
+            var color = nbt.getOptionalInt("color");
+            setColor(color.get());
+        }
+        else if (nbt.getOptionalReadView("color").isPresent()) {
+            ReadView color = nbt.getOptionalReadView("color").get();
+            hue = (short) color.getShort("h", (short)0);
+            saturation = (short) color.getShort("s", (short)0);
+            brightness = (short) color.getShort("b", (short)0);
             updateColor();
         }
     }
     @Override
-    protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
-        super.writeNbt(nbt, registryLookup);
-        NbtCompound color = new NbtCompound();
-        color.putShort("h", hue);
-        color.putShort("s", saturation);
-        color.putShort("b", brightness);
-        nbt.put("color", color);
+    protected void writeData(WriteView nbt) {
+        super.writeData(nbt);
+        nbt.putShort("h", hue);
+        nbt.putShort("s", saturation);
+        nbt.putShort("b", brightness);
     }
 
     public int getTint() {

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket;
 import net.minecraft.registry.RegistryWrapper;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 import org.jetbrains.annotations.Nullable;
···
     }
 
     @Override
-    public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
-        super.readNbt(nbt, registryLookup);
+    protected void readData(ReadView view) {
+        super.readData(view);
     }
 
     @Override
-    protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
-        super.writeNbt(nbt, registryLookup);
+    protected void writeData(WriteView view) {
+        super.writeData(view);
     }
 
     @Nullable

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

···
 import net.minecraft.screen.PropertyDelegate;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.world.ServerWorld;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import org.jetbrains.annotations.Nullable;
···
     }
 
 
-    public void writeNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
-        super.writeNbt(tag, registryLookup);
+    @Override
+    protected void writeData(WriteView tag) {
+        super.writeData(tag);
         tag.putInt("Color", this.portalColor);
         tag.putString("Dimension", this.dimension.toString());
         tag.putBoolean("Open", this.isOpen);
         if (otherSidePos != null) {
-            NbtCompound pos = new NbtCompound();
-            pos.putInt("x", otherSidePos.getX());
-            pos.putInt("y", otherSidePos.getY());
-            pos.putInt("z", otherSidePos.getZ());
-            tag.put("other_side", pos);
+            tag.put("other_side", BlockPos.CODEC, otherSidePos);
         }
     }
 
-    public void readNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
-        super.readNbt(tag, registryLookup);
-        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.get("Dimension").getType() == NbtElement.STRING_TYPE) { //new better format
-            this.dimension = Identifier.of(NbtUtils.getString(tag, "Dimension"));
+    @Override
+    protected void readData(ReadView view) {
+        super.readData(view);
+//        if (view.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 (view.contains("Dimension")) { //new better format
+            this.dimension = Identifier.of(NbtUtils.getString(view, "Dimension"));
             if (world != null && world.getServer() != null)
-                this.portalColor = NbtUtils.getInt(tag, "Color", PortalColorApplier.of(dimension, world.getServer()).apply(pos) & 0xFFFFFF);
+                this.portalColor = NbtUtils.getInt(view, "Color", PortalColorApplier.of(dimension, world.getServer()).apply(pos) & 0xFFFFFF);
             else
-                this.portalColor = NbtUtils.getInt(tag, "Color", PortalColorApplier.of(dimension, new NbtCompound()).apply(pos) & 0xFFFFFF);
+                this.portalColor = NbtUtils.getInt(view, "Color", PortalColorApplier.of(dimension, new NbtCompound()).apply(pos) & 0xFFFFFF);
         }
         else {
             setDimension(InfinityMethods.getRandomSeed(new Random())); //random by default
         }
-        this.isOpen = NbtUtils.getBoolean(tag, "Open", false);
-        if (tag.contains("other_side")) {
-            NbtCompound pos = NbtUtils.getCompound(tag,"other_side");
-            otherSidePos = new BlockPos(NbtUtils.getInt(pos, "x"), NbtUtils.getInt(pos, "y"), NbtUtils.getInt(pos, "z"));
+        this.isOpen = NbtUtils.getBoolean(view, "Open", false);
+        if (view.contains("other_side")) {
+            otherSidePos = view.read("other_side", BlockPos.CODEC).get();
         }
     }
 

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

···
     @Override
     public void writeToTag(NbtCompound tag) {
         tag.put("ingredient", EivTagUtil.writeIngredient(this.input));
-        tag.put("result", EivTagUtil.encodeItemStack(this.output));
+        tag.put("result", EivTagUtil.encodeItemStackOnServer(this.output));
         tag.put("lore", NbtString.of(this.lore));
     }
 
     @Override
     public void loadFromTag(NbtCompound tag) {
         this.input = EivTagUtil.readIngredient(NbtUtils.getCompound(tag, "ingredient"));
-        this.output = EivTagUtil.decodeItemStack(NbtUtils.getCompound(tag, "result"));
+        this.output = EivTagUtil.decodeItemStackOnClient(NbtUtils.getCompound(tag, "result"));
         this.lore = NbtUtils.getString(tag,"lore");
     }
 

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

···
     @Override
     public void writeToTag(NbtCompound tag) {
         tag.put("ingredient", EivTagUtil.writeIngredient(this.input));
-        tag.put("result", EivTagUtil.encodeItemStack(this.output));
+        tag.put("result", EivTagUtil.encodeItemStackOnServer(this.output));
         tag.put("lore", NbtString.of(this.lore));
     }
 
     @Override
     public void loadFromTag(NbtCompound tag) {
         this.input = EivTagUtil.readIngredient(NbtUtils.getCompound(tag, "ingredient"));
-        this.output = EivTagUtil.decodeItemStack(NbtUtils.getCompound(tag, "result"));
+        this.output = EivTagUtil.decodeItemStackOnClient(NbtUtils.getCompound(tag, "result"));
         this.lore = NbtUtils.getString(tag, "lore");
     }
 

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

···
 
 
 
-	@Override
+//	@Override
 	public Optional<ModelPart> getPart(String part) {
 		return Optional.of(body);
 	}

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

···
 
 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.MinecraftClient;
-import net.minecraft.client.render.RenderLayers;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
 import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.block.BlockRenderManager;
 import net.minecraft.client.render.entity.LivingEntityRenderer;
···
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
 import net.minecraft.client.render.entity.model.SlimeEntityModel;
 import net.minecraft.client.render.model.BlockStateModel;
+import net.minecraft.client.texture.SpriteAtlasTexture;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.math.BlockPos;
 
···
         matrixStack.push();
         matrixStack.scale(0.25f, 0.25f, 0.25f);
         matrixStack.translate(-0.5f, 4.5f, -0.5f);
-        this.renderCore(matrixStack, vertexConsumerProvider, light, blockState, m);
+        this.renderCore(matrixStack, vertexConsumerProvider.getBuffer(RenderLayer.getEntityTranslucent(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE)), light, blockState, m);
         matrixStack.pop();
     }
 
-    private void renderCore(MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, BlockState coreState, int overlay) {
+    private void renderCore(MatrixStack matrices, VertexConsumer vertexConsumers, int light, BlockState coreState, int 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);
+        FabricBlockModelRenderer.render(matrices.peek(), layer-> vertexConsumers, coreModel, 1.0f, 1.0f, 1.0f, light, overlay, null, BlockPos.ORIGIN, coreState);
     }
 }

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

···
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundEvent;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.TimeHelper;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Box;
···
     }
 
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
-        this.writeAngerToNbt(nbt);
+    public void writeCustomData(WriteView nbt) {
+        super.writeCustomData(nbt);
+        this.writeAngerToData(nbt);
     }
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
-        this.readAngerFromNbt(this.getWorld(), nbt);
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
+        this.readAngerFromData(this.getWorld(), nbt);
     }
 
     @Override

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

···
 import net.minecraft.registry.tag.FluidTags;
 import net.minecraft.sound.SoundEvent;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.math.BlockPos;
···
     }
 
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
         this.dropsLoot = NbtUtils.getBoolean(nbt, "dropsLoot", true);
         this.direction = switch(NbtUtils.getString(nbt, "direction")) {
             case "N" -> Direction.NORTH;
···
             default -> Direction.EAST;
         };
         if (nbt.contains("last_changed_pos")) {
-            NbtCompound pos = NbtUtils.getCompound(nbt, "last_changed_pos");
-            this.lastChangedPos = new BlockPos(NbtUtils.getInt(pos, "x"), NbtUtils.getInt(nbt,"y"), NbtUtils.getInt(nbt, "z"));
+            this.lastChangedPos = nbt.read("last_changed_pos", BlockPos.CODEC).get();
         }
     }
 
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
+    public void writeData(WriteView nbt) {
+        super.writeCustomData(nbt);
         nbt.putBoolean("dropsLoot", dropsLoot);
         nbt.putString("direction", switch(this.direction) {
                     case Direction.NORTH -> "N";
···
                     default -> "E";
                 });
         if (lastChangedPos != null) {
-            NbtCompound pos = new NbtCompound();
-            pos.putInt("x", lastChangedPos.getX());
-            pos.putInt("y", lastChangedPos.getY());
-            pos.putInt("z", lastChangedPos.getZ());
-            nbt.put("last_changed_pos", pos);
+            nbt.put("last_changed_pos", BlockPos.CODEC, lastChangedPos);
         }
     }
 

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.world.LocalDifficulty;
 import net.minecraft.world.ServerWorldAccess;
 import net.minecraft.world.World;
···
     }
 
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
+    public void writeCustomData(WriteView nbt) {
+        super.writeCustomData(nbt);
         if (battle != null) nbt.putString("battle", battle.teamName);
     }
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
         if (nbt.contains("battle") && getWorld() instanceof ServerWorld w)
             battle = new BishopBattle(w, NbtUtils.getString(nbt, "battle"));
         updateAttackType();

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

···
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.Identifier;
···
     }
 
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
+    public void writeCustomData(WriteView nbt) {
+        super.writeCustomData(nbt);
         nbt.putFloat("range", this.getRange());
         nbt.putInt("color", this.getColor());
         nbt.putString("biome", this.getBiome());
     }
 
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
         this.setRange(NbtUtils.getFloat(nbt, "range"));
         this.setColor(NbtUtils.getInt(nbt, "color"));
         this.setBiome(NbtUtils.getString(nbt, "biome"));

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

···
 package net.lerariemann.infinity.entity.custom;
 
+import com.mojang.serialization.Codec;
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.util.core.ConfigType;
···
 import net.minecraft.entity.data.TrackedDataHandlerRegistry;
 import net.minecraft.entity.mob.*;
 import net.minecraft.item.ItemStack;
-import net.minecraft.loot.LootTable;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.registry.Registries;
-import net.minecraft.registry.RegistryKey;
-import net.minecraft.registry.RegistryKeys;
 import net.minecraft.server.world.ServerWorld;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.dynamic.Codecs;
 import net.minecraft.world.*;
 import org.jetbrains.annotations.Nullable;
 
···
     public ChaosPawn(EntityType<? extends ChaosPawn> entityType, World world) {
         super(entityType, world);
     }
-    public void setColors(NbtCompound i) {
-        this.dataTracker.set(colors, i);
+    public void setColors(Map<String, Integer> i) {
+        NbtCompound nbtCompound = new NbtCompound();
+        Arrays.stream((new String[]{"body", "left_arm", "right_arm", "left_leg", "right_leg", "head", "hat"})).forEach(
+                s -> nbtCompound.putInt(s, i.get(s)));
+        this.dataTracker.set(colors, nbtCompound);
     }
+
+    public LinkedHashMap<String, Integer> getColorMap(NbtCompound nbtCompound) {
+        LinkedHashMap<String, Integer> i = new LinkedHashMap<>();
+        Arrays.stream((new String[]{"body", "left_arm", "right_arm", "left_leg", "right_leg", "head", "hat"})).forEach(
+                s -> nbtCompound.putInt(s, nbtCompound.getInt(s, 0)));
+        return i;
+    }
+
     public NbtCompound getColors() {
         return this.dataTracker.get(colors);
     }
···
     }
 
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
-        nbt.put("colors", getColors());
+    public void writeCustomData(WriteView nbt) {
+        super.writeCustomData(nbt);
+        nbt.put("colors", Codec.unboundedMap(Codecs.NON_EMPTY_STRING, Codecs.POSITIVE_INT), getColorMap(getColors()));
         nbt.putInt("case", getCase());
     }
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
-        this.setColors(NbtUtils.getCompound(nbt, "colors"));
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
+        this.setColors(nbt.read("colors", Codec.unboundedMap(Codecs.NON_EMPTY_STRING, Codecs.POSITIVE_INT)).get());
         this.dataTracker.set(special_case, NbtUtils.getInt(nbt, "case"));
     }
 
···
 //        return RegistryKey.of(RegistryKeys.LOOT_TABLE, i);
 //    }
 
-    public static NbtCompound getColorSetup(Supplier<Integer> colorSupplier) {
-        NbtCompound c = new NbtCompound();
+    public static LinkedHashMap<String, Integer> getColorSetup(Supplier<Integer> colorSupplier) {
+        LinkedHashMap<String, Integer> c = new LinkedHashMap<>();
         Arrays.stream((new String[]{"body", "left_arm", "right_arm", "left_leg", "right_leg"})).forEach(
-                s -> c.putInt(s, colorSupplier.get()));
+                s -> c.put(s, colorSupplier.get()));
         int head = colorSupplier.get();
-        c.putInt("head", head);
-        c.putInt("hat", 0xFFFFFF ^ head);
+        c.put("head", head);
+        c.put("hat", 0xFFFFFF ^ head);
         return c;
     }
+
 
     public void setAllColors(int color) {
         this.setColors(getColorSetup(() -> color));

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

···
 import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.text.Text;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
···
         return this.dataTracker.get(duration);
     }
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
+    public void writeCustomData(WriteView nbt) {
+        super.writeCustomData(nbt);
         nbt.putString("effect", this.getEffect());
         nbt.putInt("duration", this.getDuration());
         nbt.putInt("color", this.getColor());
     }
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
         this.setEffect(NbtUtils.getString(nbt, "effect"), NbtUtils.getInt(nbt, "color"));
         this.setDuration(NbtUtils.getInt(nbt,"duration"));
     }

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

···
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.sound.SoundEvent;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.*;
···
     }
 
     @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
+    public void writeCustomData(WriteView nbt) {
+        super.writeCustomData(nbt);
         nbt.putInt("color", getColor());
         nbt.putString("core", Registries.BLOCK.getId(this.getCore().getBlock()).toString());
     }
 
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
+    public void readCustomData(ReadView nbt) {
+        super.readCustomData(nbt);
         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/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.byIndex(p));
-        int t = SheepEntity.getRgbColor(DyeColor.byIndex(q));
+        int s = DyeColor.byIndex(p).getEntityColor();
+        int t = DyeColor.byIndex(q).getEntityColor();
         return ColorHelper.lerp(r, s, t);
     }
 

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

···
     }
 
     static void loadShader(ServerPlayerEntity player) {
-        ModPayloads.sendShaderPayload(player, player.getServerWorld(), true);
+        ModPayloads.sendShaderPayload(player, player.getWorld(), true);
     }
     static void unloadShader(ServerPlayerEntity player) {
-        ModPayloads.sendShaderPayload(player, player.getServerWorld(), false);
+        ModPayloads.sendShaderPayload(player, player.getWorld(), false);
     }
 
     static boolean shouldApplyShader(@Nullable PlayerEntity player) {
···
         compound.putDouble("x", player.getPos().x);
         compound.putDouble("y", player.getPos().y);
         compound.putDouble("z", player.getPos().z);
-        compound.putString("dim", player.getServerWorld().getRegistryKey().getValue().toString());
+        compound.putString("dim", player.getWorld().getRegistryKey().getValue().toString());
         CommonIO.write(compound, InfinityMod.provider.savingPath, player.getUuidAsString() + ".json");
     }
 
···
         Path cookie = InfinityMod.provider.savingPath.resolve(player.getUuidAsString() + ".json");
         try {
             NbtCompound comp = CommonIO.read(cookie);
-            player.teleport(player.server.getWorld(RegistryKey.of(RegistryKeys.WORLD, Identifier.of(NbtUtils.getString(comp, "dim")))),
+            player.teleport(player.getWorld().getServer().getWorld(RegistryKey.of(RegistryKeys.WORLD, Identifier.of(NbtUtils.getString(comp, "dim")))),
                     NbtUtils.getDouble(comp, "x"), NbtUtils.getDouble(comp, "y"), NbtUtils.getDouble(comp, "z"), Set.of(), player.getYaw(), player.getPitch(), false);
         } catch (Exception e) {
             WarpLogic.respawnAlive(player);
···
     }
 
     static Identifier getIdForWarp(ServerPlayerEntity player) {
-        ServerWorld w = player.getServerWorld().getServer().getOverworld();
+        ServerWorld w = player.getWorld().getServer().getOverworld();
         return InfinityMethods.getRandomId(new Random(w.getSeed() + w.getTime() / ticksInHour));
     }
 

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

···
 import net.minecraft.entity.mob.Angerable;
 import net.minecraft.entity.mob.MobEntity;
 import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.particle.EntityEffectParticleEffect;
 import net.minecraft.particle.ParticleEffect;
 import net.minecraft.particle.ParticleTypes;
+import net.minecraft.particle.TintedParticleEffect;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.util.Identifier;
···
     @Override
     public ParticleEffect createParticle(StatusEffectInstance effect) {
         float hue = effect.getDuration() / 13.0f;
-        return EntityEffectParticleEffect.create(
+        return TintedParticleEffect.create(
                 ParticleTypes.ENTITY_EFFECT, ColorHelper.fullAlpha(Color.HSBtoRGB(hue - (int)hue, 1.0f, 1.0f)));
     }
 

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

···
 @Mixin(ServerPlayerEntity.class)
 public abstract class ServerPlayerEntityMixin extends PlayerEntity implements ServerPlayerEntityAccess {
     public ServerPlayerEntityMixin(World world, BlockPos pos, float yaw, GameProfile gameProfile) {
-        super(world, pos, yaw, gameProfile);
+        super(world, gameProfile);
     }
 
-    @Shadow public abstract ServerWorld getServerWorld();
+    @Shadow public abstract ServerWorld getWorld();
     @Shadow public abstract @Nullable Entity teleportTo(TeleportTarget teleportTarget);
     @Unique private long infinity$ticksUntilWarp;
     @Unique private Identifier infinity$idForWarp;
···
         if (--this.infinity$ticksUntilWarp == 0L)
             WarpLogic.performWarp(player, infinity$idForWarp);
         /* Handle effects from dimension deletion */
-        ((Timebombable)getServerWorld()).tickTimebombProgress(player);
+        ((Timebombable)getWorld()).tickTimebombProgress(player);
     }
 
     @Inject(method = "changeGameMode", at = @At("RETURN"))

common/src/main/java/net/lerariemann/infinity/mixin/fixes/BeeGoalMixin.java

···
  * I fixed that :D */
 @Mixin(BeeEntity.MoveToHiveGoal.class)
 public abstract class BeeGoalMixin {
-    @WrapOperation(method = "<init>", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/random/Random;nextInt(I)I"))
-    private int inj(Random instance, int i, Operation<Integer> original) {
-        return 10;
-    }
-
-    @Mixin(BeeEntity.MoveToFlowerGoal.class)
-    public abstract static class BeeGoalMixin2 {
-        @WrapOperation(method = "<init>", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/random/Random;nextInt(I)I"))
-        private int inj(Random instance, int i, Operation<Integer> original) {
-            return 10;
-        }
-    }
+//    @WrapOperation(method = "<init>", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/random/Random;nextInt(I)I"))
+//    private int inj(Random instance, int i, Operation<Integer> original) {
+//        return 10;
+//    }
+//
+//    @Mixin(BeeEntity.MoveToFlowerGoal.class)
+//    public abstract static class BeeGoalMixin2 {
+//        @WrapOperation(method = "<init>", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/random/Random;nextInt(I)I"))
+//        private int inj(Random instance, int i, Operation<Integer> original) {
+//            return 10;
+//        }
+//    }
 }

common/src/main/java/net/lerariemann/infinity/mixin/options/BackgroundRendererMixin.java

···
 import net.lerariemann.infinity.options.InfinityOptions;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.block.enums.CameraSubmersionType;
-import net.minecraft.client.render.BackgroundRenderer;
 import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.fog.FogRenderer;
 import net.minecraft.client.world.ClientWorld;
 import net.minecraft.util.math.MathHelper;
 import org.joml.Vector4f;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.awt.Color;
 
-@Mixin(BackgroundRenderer.class)
+@Mixin(FogRenderer.class)
 public class BackgroundRendererMixin {
     //TODO fix
 //    @Shadow
···
 
 
     @Inject(method = "getFogColor",
-            at= @At(value = "INVOKE", target = "Lnet/minecraft/client/render/BackgroundRenderer;getFogModifier(Lnet/minecraft/entity/Entity;F)Lnet/minecraft/client/render/BackgroundRenderer$StatusEffectFogModifier;"))
-    private static void injected(Camera camera, float tickDelta, ClientWorld world, int clampedViewDistance, float skyDarkness, CallbackInfoReturnable<Vector4f> cir) {
+            at= @At(value = "INVOKE", target = "Lnet/minecraft/client/render/fog/FogModifier;getFogColor(Lnet/minecraft/client/world/ClientWorld;Lnet/minecraft/client/render/Camera;IF)I"))
+    private static void injected(Camera camera, float tickProgress, ClientWorld world, int viewDistance, float skyDarkness, boolean thick, CallbackInfoReturnable<Vector4f> cir) {
         InfinityOptions options = InfinityOptions.access(world);
         if (options.getSkyType().equals("rainbow") && camera.getSubmersionType() == CameraSubmersionType.NONE) {
-            infinity$applyRainbowFog(world, tickDelta);
+            infinity$applyRainbowFog(world, tickProgress);
         }
     }
 
     /* Disable void fog in custom dimensions. */
-    @ModifyExpressionValue(method = "getFogColor",
-    at = @At(value = "INVOKE", target = "Lnet/minecraft/client/world/ClientWorld$Properties;getHorizonShadingRatio()F"))
-    private static float inj(float original, @Local(argsOnly = true) ClientWorld world) {
-        if (!InfinityMethods.isInfinity(world)) return original;
-        return InfinityOptions.access(world).getHorizonShadingRatio();
-    }
+    //FIXME
+//    @ModifyExpressionValue(method = "getFogColor",
+//    at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/fog/FogModifier;shouldApply(Lnet/minecraft/block/enums/CameraSubmersionType;Lnet/minecraft/entity/Entity;)Z"))
+//    private static boolean inj(boolean original, @Local(argsOnly = true) ClientWorld world) {
+//        if (!InfinityMethods.isInfinity(world)) return original;
+//        return InfinityOptions.access(world).getHorizonShadingRatio();
+//    }
 
     @Unique
     private static void infinity$applyRainbowFog(ClientWorld world, float tickDelta) {

common/src/main/java/net/lerariemann/infinity/mixin/options/GameRendererMixin.java

···
 
 @Mixin(GameRenderer.class)
 public abstract class GameRendererMixin implements GameRendererAccess {
-    @Shadow
-    @Final
-    private ResourceManager resourceManager;
+
     @Shadow
     protected abstract void setPostProcessor(Identifier id);
 
     @Override
     public void infinity$loadPP(Identifier id) {
-        if (resourceManager.getResource(id).isPresent()) {
+        if (MinecraftClient.getInstance().getResourceManager().getResource(id).isPresent()) {
             setPostProcessor(id);
         }
         else {

common/src/main/java/net/lerariemann/infinity/mixin/options/PlayerManagerMixin.java

···
         }
         InfinityMod.LOGGER.info("Sending sound pack to client");
         if (RandomProvider.rule("useSoundSyncPackets")) ModPayloads.sendSoundPackPayload(player, CommonIO.read(
-                player.server.getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json")));
+                player.getWorld().getServer().getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json")));
     }
 
     @Inject(method="sendWorldInfo", at = @At("TAIL"))

common/src/main/java/net/lerariemann/infinity/registry/var/ModPayloads.java

···
         }
     }
     public static void sendShaderPayload(ServerPlayerEntity player) {
-        sendShaderPayload(player, player.getServerWorld(), Iridescence.shouldApplyShader(player));
+        sendShaderPayload(player, player.getWorld(), Iridescence.shouldApplyShader(player));
     }
     public static void sendShaderPayload(ServerPlayerEntity player, ServerWorld world) {
         sendShaderPayload(player, world, Iridescence.shouldApplyShader(player));
···
     public static void receiveF4DeployPayload(ServerPlayerEntity player) {
         ItemStack st = player.getStackInHand(Hand.MAIN_HAND);
         if (st.isOf(ModItems.F4.get())) {
-            ActionResult result = F4Item.deploy(player.getServerWorld(), player, Hand.MAIN_HAND);
+            ActionResult result = F4Item.deploy(player.getWorld(), player, Hand.MAIN_HAND);
 //            player.setStackInHand(Hand.MAIN_HAND, result);
         }
     }

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

···
     public BlockPos pos;
 
     public static void invokeOn(ServerPlayerEntity player) {
-        ServerWorld w = player.getServerWorld();
+        ServerWorld w = player.getWorld();
         int y = w.getHeight() - 10;
         BlockPos pos = new BlockPos(player.getBlockX(), y, player.getBlockZ());
         (new ConfigGenInvocation(w, pos)).run();

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

···
     }
 
     static void generateLootTables(ReloadableRegistries.Lookup reloadableRegistries) {
-        var r = reloadableRegistries.getIds(RegistryKeys.LOOT_TABLE);
+        var r = reloadableRegistries.createRegistryLookup().getOrThrow(RegistryKeys.LOOT_TABLE);
         DataCollection lootTables = new DataCollection.Logged(ConfigType.LOOT_TABLES, "loot tables");
-        r.forEach(id -> {
-            lootTables.addIdentifier(id);
+        r.streamKeys().forEach(id -> {
+            lootTables.addIdentifier(id.getValue());
         });
         lootTables.save();
     }

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 
 import java.util.Random;
 
···
     }
     static int getInt(NbtCompound data, String key, int def) {
         return (NbtUtils.getType(data, key) == NbtElement.INT_TYPE) ? NbtUtils.getInt(data, key) : def;
+    }
+    static int getInt(ReadView data, String key, int def) {
+        return NbtUtils.getInt(data, key);
     }
     static double getDouble(NbtCompound data, String key, double 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)) ? NbtUtils.getBoolean(data, key) : def;
     }
+    static boolean getBoolean(ReadView data, String key, boolean def) {
+        return NbtUtils.getBoolean(data, key);
+    }
 
     static String getString(NbtCompound data, String key) {
         return data.getString(key).orElse("");
     }
+    static String getString(ReadView data, String key) {
+        return data.getString(key, "");
+    }
     static NbtCompound getCompound(NbtCompound data, String key) {
         return data.getCompound(key).orElse(new NbtCompound());
     }
     static float getFloat(NbtCompound data, String key) {
         return data.getFloat(key).orElse(0f);
     }
+    static float getFloat(ReadView data, String key) {
+        return data.getFloat(key, 0f);
+    }
     static int getInt(NbtCompound data, String key) {
         return data.getInt(key).orElse(0);
     }
+    static int getInt(ReadView data, String key) {
+        return data.getInt(key, 0);
+    }
     static double getDouble(NbtCompound data, String key) {
         return data.getDouble(key).orElse(0d);
     }
     static boolean getBoolean(NbtCompound data, String key) {
         return data.getBoolean(key).orElse(false);
+    }
+    static boolean getBoolean(ReadView data, String key) {
+        return data.getBoolean(key, false);
     }
     static short getShort(NbtCompound data, String key) {
         return data.getShort(key).get();

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

···
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.minecraft.client.gl.RenderPipelines;
 import net.minecraft.client.gui.DrawContext;
 import net.minecraft.client.gui.screen.ingame.*;
 import net.minecraft.client.gui.widget.TextFieldWidget;
···
 
     @Override
     protected void drawBackground(DrawContext context, float delta, int mouseX, int mouseY) {
-        context.drawGuiTexture(RenderLayer::getGuiTextured, InfinityMethods.getId("textures/gui/f4.png"),
+        context.drawGuiTexture(RenderPipelines.GUI_TEXTURED, InfinityMethods.getId("textures/gui/f4.png"),
                 x, y, this.backgroundWidth, this.backgroundHeight);
     }
 }

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

···
      * Moves the player to a specified existing dimension.
      */
     static void performWarp(ServerPlayerEntity player, Identifier idForWarp) {
-        MinecraftServer s = player.getServerWorld().getServer();
+        MinecraftServer s = player.getServer();
         RegistryKey<World> key = RegistryKey.of(RegistryKeys.WORLD, idForWarp);
         ServerWorld w = s.getWorld(key);
         if (w==null) {
···
             return;
         }
 
-        double d = DimensionType.getCoordinateScaleFactor(player.getServerWorld().getDimension(), w.getDimension());
+        double d = DimensionType.getCoordinateScaleFactor(player.getWorld().getDimension(), w.getDimension());
         double y = MathHelper.clamp(player.getY(), w.getBottomY(), w.getHeight());
 
         BlockPos blockPos2 = getPosForWarp(BlockPos.ofFloored(w.getWorldBorder().clamp(player.getX() * d, y, player.getZ() * d)), w);

fabric/src/main/java/net/lerariemann/infinity/fabric/client/InfinityModFabricClient.java

···
 package net.lerariemann.infinity.fabric.client;
 
 import net.fabricmc.api.ClientModInitializer;
-import net.fabricmc.fabric.api.blockrenderlayer.v1.BlockRenderLayerMap;
 import net.fabricmc.fabric.api.client.render.fluid.v1.FluidRenderHandlerRegistry;
+import net.fabricmc.fabric.api.client.rendering.v1.BlockRenderLayerMap;
 import net.fabricmc.fabric.api.client.rendering.v1.ColorProviderRegistry;
 import net.fabricmc.fabric.api.transfer.v1.client.fluid.FluidVariantRendering;
 import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariantAttributes;
···
 import net.lerariemann.infinity.registry.core.ModItemFunctions;
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.minecraft.client.render.BlockRenderLayer;
 import net.minecraft.client.render.RenderLayer;
 
 public class InfinityModFabricClient implements ClientModInitializer {
···
                 ModBlocks.CHROMATIC_CARPET.get());
 
         // Render layer maps
-        BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getCutoutMipped(),
+        BlockRenderLayerMap.putBlocks(BlockRenderLayer.CUTOUT_MIPPED,
                 ModBlocks.BOOK_BOX.get(),
                 ModBlocks.IRIDESCENT_KELP.get(),
                 ModBlocks.IRIDESCENT_KELP_PLANT.get());
-        BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getTranslucent(),
+        BlockRenderLayerMap.putBlocks(BlockRenderLayer.TRANSLUCENT,
                 ModBlocks.TIME_BOMB.get(),
                 ModBlocks.BIOME_BOTTLE.get(),
                 ModBlocks.CHROMATIC_WOOL.get(),
                 ModBlocks.CHROMATIC_CARPET.get());
-        BlockRenderLayerMap.INSTANCE.putFluids(RenderLayer.getTranslucent(),
+        BlockRenderLayerMap.putFluids(BlockRenderLayer.TRANSLUCENT,
                 PlatformMethods.getIridescenceStill().get(),
                 PlatformMethods.getIridescenceFlowing().get());
 

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

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

gradle.properties

···
 mod_version = 2.5.2
 maven_group = net.lerariemann
 archives_name = infinity
-enabled_platforms = fabric,neoforge
+enabled_platforms = fabric
 tbversion = 1
 
 # Minecraft properties
-minecraft_version = 1.21.5
+minecraft_version = 1.21.8
 yarn_mappings = 1
 
 # Dependencies
-architectury_api_version = 16.1.4
+architectury_api_version = 17.0.8
 
 # Fabric Dependencies
-fabric_loader_version = 0.16.13
-fabric_api_version = 0.128.1+1.21.5
+fabric_loader_version = 0.17.3
+fabric_api_version = 0.136.0+1.21.8
 
 # NeoForge Dependencies
 neoforge_version = 21.5.81
···
 
 # Optional Dependencies
 catalogue_version = 5631367
-cloth_version = 18.0.145
-modmenu_version = 14.0.0-rc.2
+cloth_version = 19.0.147
+modmenu_version = 15.0.0
 emi_version = 1.1.18
 cct_version = 1.115.0
 dimlib_version = v1.1.0-mc1.21.1
-eiv_version = 2.5.3
+eiv_version = 4.1.0

settings.gradle

···
 
 include 'common'
 include 'fabric'
-include 'neoforge'
+//include 'neoforge'