1.21 update

build.gradle

···
 plugins {
-	id 'fabric-loom' version '1.6-SNAPSHOT'
+	id 'fabric-loom' version '1.7-SNAPSHOT'
 	id 'maven-publish'
 }
 
···
 
 tasks.withType(JavaCompile).configureEach {
 	// Minecraft 1.18 (1.18-pre2) upwards uses Java 17.
-	it.options.release = 17
+	it.options.release = 21
 }
 
 java {

gradle.properties

···
 
 # Fabric Properties
 	# check these on https://fabricmc.net/develop
-	minecraft_version=1.20.1
-	yarn_mappings=1.20.1+build.9
-	loader_version=0.15.7
+	minecraft_version=1.21.1
+	yarn_mappings=1.21.1+build.3
+	loader_version=0.16.2
 
 # Mod Properties
-	mod_version = 1.11.2-1.20.1
+	mod_version = 1.12.0-1.21.1
 	maven_group = net.lerariemann
 	archives_base_name = infinity
 
 # Dependencies
-	fabric_version=0.85.0+1.20.1
+	fabric_version=0.102.1+1.21.1

gradle/wrapper/gradle-wrapper.properties

···
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/me/basiqueevangelist/dynreg/DynReg.java

···
     public static MinecraftServer SERVER;
 
     public static Identifier id(String path) {
-        return new Identifier(MODID, path);
+        return Identifier.of(MODID, path);
     }
 
     @Override

src/main/java/me/basiqueevangelist/dynreg/mixin/SimpleRegistryMixin.java

···
 import com.mojang.serialization.Lifecycle;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
-import it.unimi.dsi.fastutil.objects.Object2IntMap;
-import it.unimi.dsi.fastutil.objects.ObjectList;
 import me.basiqueevangelist.dynreg.access.ExtendedRegistry;
 import me.basiqueevangelist.dynreg.event.RegistryEntryDeletedCallback;
 import me.basiqueevangelist.dynreg.event.RegistryFrozenCallback;
 import me.basiqueevangelist.dynreg.util.StackTracingMap;
 import net.fabricmc.fabric.api.event.Event;
 import net.fabricmc.fabric.api.event.EventFactory;
-import net.fabricmc.fabric.api.event.registry.RegistryEntryRemovedCallback;
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.SimpleRegistry;
···
 import org.spongepowered.asm.mixin.*;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
···
     @Shadow
     public abstract Optional<RegistryEntry.Reference<T>> getEntry(RegistryKey<T> key);
 
-    @Shadow
-    @Final
-    private Object2IntMap<T> entryToRawId;
-    @Shadow
-    @Final
-    private ObjectList<RegistryEntry.Reference<T>> rawIdToEntry;
     @Mutable
     @Shadow
     @Final
     private Map<Identifier, RegistryEntry.Reference<T>> idToEntry;
-    @Shadow
-    @Final
-    private Map<RegistryKey<T>, RegistryEntry.Reference<T>> keyToEntry;
-    @Shadow
-    @Final
-    private Map<T, RegistryEntry.Reference<T>> valueToEntry;
-    @Shadow
-    @Final
-    private Map<T, Lifecycle> entryToLifecycle;
-    @Shadow
-    @Nullable
-    private List<RegistryEntry.Reference<T>> cachedEntries;
-    @Shadow private int nextId;
 
     @Unique
     @SuppressWarnings("unchecked") private final Event<RegistryEntryDeletedCallback<T>> dynreg$entryDeletedEvent = EventFactory.createArrayBacked(RegistryEntryDeletedCallback.class, callbacks -> (rawId, entry) -> {
···
     }
 
     @Override
-    public void dynreg$remove(RegistryKey<T> key) {
-        if (frozen) {
-            throw new IllegalStateException("Registry is frozen (trying to remove key " + key + ")");
-        }
-
-        RegistryEntry.Reference<T> entry = getEntry(key).orElseThrow();
-
-        int rawId = entryToRawId.getInt(entry.value());
-        dynreg$entryDeletedEvent.invoker().onEntryDeleted(rawId, entry);
-        RegistryEntryRemovedCallback.event(this).invoker().onEntryRemoved(rawId, entry.registryKey().getValue(), entry.value());
-
-        rawIdToEntry.set(rawId, null);
-        entryToRawId.removeInt(entry.value());
-        idToEntry.remove(key.getValue());
-        keyToEntry.remove(key);
-        valueToEntry.remove(entry.value());
-        entryToLifecycle.remove(entry.value());
-        dynreg$freeIds.add(rawId);
-
-        cachedEntries = null;
-    }
-
-    @Redirect(method = "add", at = @At(value = "FIELD", target = "Lnet/minecraft/registry/SimpleRegistry;nextId:I"))
-    private int getNextId(SimpleRegistry<T> instance) {
-        if (!dynreg$freeIds.isEmpty())
-            return dynreg$freeIds.removeInt(0);
-
-        return nextId;
-    }
-
-    @Override
     public void dynreg$unfreeze() {
         frozen = false;
         if (dynreg$intrusive)
             this.intrusiveValueToEntry = new IdentityHashMap<>();
-
-        cachedEntries = null;
     }
 
     @Inject(method = "freeze", at = @At("HEAD"))

src/main/java/net/lerariemann/infinity/InfinityMod.java

···
 
 public class InfinityMod implements ModInitializer {
 	public static final String MOD_ID = "infinity";
-	public static final Identifier WORLD_ADD = getId("reload_worlds");
-	public static final Identifier SHADER_RELOAD = getId("reload_shader");
-	public static final Identifier STARS_RELOAD = getId("reload_stars");
 	public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
 
     public static Identifier getId(String value){
-		return new Identifier(MOD_ID, value);
+		return Identifier.of(MOD_ID, value);
 	}
 
 	@Override
···
 		ModFeatures.registerFeatures();
 		ModStats.registerStats();
 		ModCriteria.registerCriteria();
+		ModPayloads.registerPayloadsServer();
 	}
 }

src/main/java/net/lerariemann/infinity/InfinityModClient.java

···
 
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.blockrenderlayer.v1.BlockRenderLayerMap;
-import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
 import net.fabricmc.fabric.api.client.rendering.v1.ColorProviderRegistry;
 import net.lerariemann.infinity.block.ModBlocks;
 import net.lerariemann.infinity.block.entity.NeitherPortalBlockEntity;
-import net.lerariemann.infinity.options.PacketTransiever;
 import net.lerariemann.infinity.entity.ModEntities;
-import net.lerariemann.infinity.loading.DimensionGrabber;
+import net.lerariemann.infinity.var.ModPayloads;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.client.render.RenderLayer;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.noise.DoublePerlinNoiseSampler;
 import net.minecraft.util.math.random.CheckedRandom;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class InfinityModClient implements ClientModInitializer {
     final static DoublePerlinNoiseSampler sampler = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -3, 1.0, 1.0, 1.0, 0.0);
 
···
             if (world != null && pos != null) {
                 BlockEntity blockEntity = world.getBlockEntity(pos);
                 if (blockEntity instanceof NeitherPortalBlockEntity) {
-                    Object j = ((NeitherPortalBlockEntity)blockEntity).getRenderAttachmentData();
+                    Object j = blockEntity.getRenderData();
                     if (j == null) return 0;
                     return (int)j & 0xFFFFFF;
                 }
···
             }
             return 16777215;
         }, ModBlocks.BOOK_BOX);
-        ClientPlayNetworking.registerGlobalReceiver(InfinityMod.WORLD_ADD, (client, handler, buf, responseSender) -> {
-            Identifier id = buf.readIdentifier();
-            NbtCompound optiondata = buf.readNbt();
-            int i = buf.readInt();
-            List<Identifier> biomeids = new ArrayList<>();
-            List<NbtCompound> biomes = new ArrayList<>();
-            for (int j = 0; j < i; j++) {
-                biomeids.add(buf.readIdentifier());
-                biomes.add(buf.readNbt());
-            }
-            client.execute(() -> (new DimensionGrabber(client.getNetworkHandler().getRegistryManager())).grab_for_client(id, optiondata, biomeids, biomes));
-        });
-        ClientPlayNetworking.registerGlobalReceiver(InfinityMod.SHADER_RELOAD, PacketTransiever::receive);
-        ClientPlayNetworking.registerGlobalReceiver(InfinityMod.STARS_RELOAD, PacketTransiever::receiveStars);
+        ModPayloads.registerPayloadsClient();
         ModEntities.registerEntityRenderers();
     }
 }

src/main/java/net/lerariemann/infinity/access/InfinityOptionsAccess.java

···
 import net.lerariemann.infinity.options.InfinityOptions;
 
 public interface InfinityOptionsAccess {
-    InfinityOptions getInfinityOptions();
-    void setInfinityOptions(InfinityOptions options);
+    InfinityOptions projectInfinity$getInfinityOptions();
+    void projectInfinity$setInfinityOptions(InfinityOptions options);
 }

src/main/java/net/lerariemann/infinity/access/MavityInterface.java

···
     default double getMavity() {
         double mavity;
         try {
-            mavity = ((InfinityOptionsAccess) getWorld()).getInfinityOptions().getMavity();
+            mavity = ((InfinityOptionsAccess) getWorld()).projectInfinity$getInfinityOptions().getMavity();
         } catch (Exception e) {
             mavity = 1.0;
         }

src/main/java/net/lerariemann/infinity/access/MinecraftServerAccess.java

···
 
 public interface MinecraftServerAccess {
 
-    void addWorld(RegistryKey<World> key, DimensionOptions options);
+    void projectInfinity$addWorld(RegistryKey<World> key, DimensionOptions options);
 
-    boolean hasToAdd(RegistryKey<World> key);
+    boolean projectInfinity$hasToAdd(RegistryKey<World> key);
 
-    boolean needsInvocation();
-    void onInvocation();
+    boolean projectInfinity$needsInvocation();
+    void projectInfinity$onInvocation();
 
-    RandomProvider getDimensionProvider();
-    void setDimensionProvider();
+    RandomProvider projectInfinity$getDimensionProvider();
+    void projectInfinity$setDimensionProvider();
 }

src/main/java/net/lerariemann/infinity/access/MobEntityAccess.java

···
 package net.lerariemann.infinity.access;
 
 public interface MobEntityAccess {
-    void setPersistent(boolean bl);
+    void projectInfinity$setPersistent(boolean bl);
 }

src/main/java/net/lerariemann/infinity/access/ServerPlayerEntityAccess.java

···
 package net.lerariemann.infinity.access;
 
 public interface ServerPlayerEntityAccess {
-    void setWarpTimer(long ticks, long dim);
+    void projectInfinity$setWarpTimer(long ticks, long dim);
 }

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

···
 package net.lerariemann.infinity.access;
 
 public interface Timebombable {
-    void timebomb(int i);
+    void projectInfinity$timebomb(int i);
 
-    int isTimebobmed();
+    int projectInfinity$isTimebobmed();
 }

src/main/java/net/lerariemann/infinity/access/WorldRendererAccess.java

···
 package net.lerariemann.infinity.access;
 
 public interface WorldRendererAccess {
-    void setNeedsStars(boolean b);
+    void projectInfinity$setNeedsStars(boolean b);
 }

src/main/java/net/lerariemann/infinity/block/ModBlocks.java

···
 package net.lerariemann.infinity.block;
 
-import net.fabricmc.fabric.api.item.v1.FabricItemSettings;
 import net.fabricmc.fabric.api.itemgroup.v1.ItemGroupEvents;
-import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings;
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.block.custom.*;
+import net.minecraft.block.AbstractBlock;
 import net.minecraft.block.Block;
 import net.minecraft.block.Blocks;
 import net.minecraft.item.*;
···
 import net.minecraft.registry.Registry;
 
 public class ModBlocks {
-    public static final Block NEITHER_PORTAL = new NeitherPortalBlock(FabricBlockSettings.copy(Blocks.NETHER_PORTAL));
-    public static final Block BOOK_BOX = new BookBoxBlock(FabricBlockSettings.copy(Blocks.BOOKSHELF));
-    public static final Item BOOK_BOX_ITEM = new BlockItem(BOOK_BOX, new FabricItemSettings());
-    public static final Block ALTAR_COSMIC = new CosmicAltar(FabricBlockSettings.copy(Blocks.BEDROCK).nonOpaque());
-    public static final Block ALTAR_LIT = new TransfiniteAltar(FabricBlockSettings.copy(Blocks.BEDROCK).nonOpaque().
+    public static final Block NEITHER_PORTAL = new NeitherPortalBlock(AbstractBlock.Settings.copy(Blocks.NETHER_PORTAL));
+    public static final Block BOOK_BOX = new BookBoxBlock(AbstractBlock.Settings.copy(Blocks.BOOKSHELF));
+    public static final Item BOOK_BOX_ITEM = new BlockItem(BOOK_BOX, new Item.Settings());
+    public static final Block ALTAR_COSMIC = new CosmicAltar(AbstractBlock.Settings.copy(Blocks.BEDROCK).nonOpaque());
+    public static final Block ALTAR_LIT = new TransfiniteAltar(AbstractBlock.Settings.copy(Blocks.BEDROCK).nonOpaque().
             luminance(state -> state.get(TransfiniteAltar.FLOWER) ? 15 : 0));
-    public static final Block ALTAR = new TransfiniteAltarBase(FabricBlockSettings.copy(Blocks.STONE).nonOpaque().
+    public static final Block ALTAR = new TransfiniteAltarBase(AbstractBlock.Settings.copy(Blocks.STONE).nonOpaque().
             luminance(state -> state.get(TransfiniteAltarBase.FLOWER) ? 15 : 0));
-    public static final Item ALTAR_ITEM = new BlockItem(ALTAR, new FabricItemSettings());
-    public static final Block TIME_BOMB = new TimeBombBlock(FabricBlockSettings.copy(Blocks.BEDROCK).nonOpaque().
+    public static final Item ALTAR_ITEM = new BlockItem(ALTAR, new Item.Settings());
+    public static final Block TIME_BOMB = new TimeBombBlock(AbstractBlock.Settings.copy(Blocks.BEDROCK).nonOpaque().
             luminance(state -> 15));
-    public static final Item TIME_BOMB_ITEM = new BlockItem(TIME_BOMB, new FabricItemSettings());
+    public static final Item TIME_BOMB_ITEM = new BlockItem(TIME_BOMB, new Item.Settings());
     private static void registerBlock(String name, Block block) {
         Registry.register(Registries.BLOCK, InfinityMod.getId(name), block);
     }

src/main/java/net/lerariemann/infinity/block/custom/BookBoxBlock.java

···
 import net.minecraft.block.AbstractBlock;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.WrittenBookContentComponent;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.nbt.NbtList;
-import net.minecraft.nbt.NbtString;
+import net.minecraft.text.RawFilteredPair;
+import net.minecraft.text.Text;
 import net.minecraft.util.ActionResult;
-import net.minecraft.util.Hand;
 import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 
 public class BookBoxBlock extends Block {
···
     }
 
     @Override
-    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) {
+    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
         if (!world.isClient) {
             ItemStack itemStack1 = Items.WRITTEN_BOOK.getDefaultStack();
-            NbtCompound compound = itemStack1.getOrCreateNbt();
-            compound.putString("author", "§kLeraRiemann");
-            NbtList lst = new NbtList();
-            lst.add(NbtString.of(text(pos)));
-            compound.put("pages", lst);
-            compound.putString("title", title(pos));
+            List<RawFilteredPair<Text>> pages = new ArrayList<>();
+            pages.add(RawFilteredPair.of(Text.of(text(pos))));
+            WrittenBookContentComponent component = new WrittenBookContentComponent(RawFilteredPair.of(title(pos)), "§kLeraRiemann", 3, pages, false);
+            itemStack1.set(DataComponentTypes.WRITTEN_BOOK_CONTENT, component);
             player.getInventory().insertStack(itemStack1);
         }
         return ActionResult.SUCCESS;

src/main/java/net/lerariemann/infinity/block/custom/CosmicAltar.java

···
 package net.lerariemann.infinity.block.custom;
 
+import com.mojang.serialization.MapCodec;
 import net.lerariemann.infinity.block.entity.CosmicAltarEntity;
 import net.lerariemann.infinity.block.entity.ModBlockEntities;
 import net.minecraft.block.BlockRenderType;
···
 import org.jetbrains.annotations.Nullable;
 
 public class CosmicAltar extends BlockWithEntity {
+    public static final MapCodec<CosmicAltar> CODEC = createCodec(CosmicAltar::new);
     public CosmicAltar(Settings settings) {
         super(settings);
     }
+
+    @Override
+    protected MapCodec<? extends BlockWithEntity> getCodec() {
+        return CODEC;
+    }
+
     @Override
     public BlockRenderType getRenderType(BlockState state) {
         return BlockRenderType.MODEL;
···
     }
     @Override
     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(World world, BlockState state, BlockEntityType<T> type) {
-        if (!world.isClient) return checkType(type, ModBlockEntities.ALTAR_COSMIC, CosmicAltarEntity::serverTick);
-        return null;
+        return validateTicker(type, ModBlockEntities.ALTAR_COSMIC, world.isClient ? null : CosmicAltarEntity::serverTick);
     }
 }

src/main/java/net/lerariemann/infinity/block/custom/NeitherPortalBlock.java

···
 import net.fabricmc.api.Environment;
 import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
-import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.block.ModBlocks;
 import net.lerariemann.infinity.block.entity.NeitherPortalBlockEntity;
···
 import net.lerariemann.infinity.loading.DimensionGrabber;
 import net.lerariemann.infinity.var.ModCommands;
 import net.lerariemann.infinity.var.ModCriteria;
+import net.lerariemann.infinity.var.ModPayloads;
 import net.lerariemann.infinity.var.ModStats;
 import net.minecraft.block.BlockEntityProvider;
 import net.minecraft.block.BlockState;
···
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
 import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtList;
 import net.minecraft.network.PacketByteBuf;
 import net.minecraft.particle.DustParticleEffect;
 import net.minecraft.particle.ParticleEffect;
···
     }
 
     public static boolean open(MinecraftServer s, World world, BlockPos pos, boolean countRepeats) {
-        RandomProvider prov = ((MinecraftServerAccess)(s)).getDimensionProvider();
+        RandomProvider prov = ((MinecraftServerAccess)(s)).projectInfinity$getDimensionProvider();
         BlockEntity blockEntity = world.getBlockEntity(pos);
         boolean bl = false;
         if (blockEntity instanceof NeitherPortalBlockEntity) {
···
 
     @Override
     public ActionResult onUse(BlockState state, World world, BlockPos pos,
-                              PlayerEntity player, Hand hand, BlockHitResult hit) {
+                              PlayerEntity player, BlockHitResult hit) {
         if (!world.isClient) {
             MinecraftServer s = world.getServer();
             BlockEntity blockEntity = world.getBlockEntity(pos);
             if (s!=null && blockEntity instanceof NeitherPortalBlockEntity) {
                 if (((NeitherPortalBlockEntity)blockEntity).getOpen() && world_exists(s, ((NeitherPortalBlockEntity)blockEntity).getDimension()))
                     return ActionResult.SUCCESS;
-                RandomProvider prov = ((MinecraftServerAccess)(s)).getDimensionProvider();
+                RandomProvider prov = ((MinecraftServerAccess)(s)).projectInfinity$getDimensionProvider();
                 boolean bl = prov.portalKey.isBlank();
                 boolean bl2 = false;
                 if (bl) {
                     bl2 = open(s, world, pos, false);
                 }
                 else {
-                    ItemStack itemStack = player.getStackInHand(hand);
-                    Item item = Registries.ITEM.get(new Identifier(prov.portalKey));
+                    ItemStack itemStack = player.getStackInHand(Hand.MAIN_HAND);
+                    Item item = Registries.ITEM.get(Identifier.of(prov.portalKey));
                     if (itemStack.isOf(item)) {
                         if (!player.getAbilities().creativeMode) {
                             itemStack.decrement(1);
···
         return ActionResult.SUCCESS;
     }
 
-
     public static boolean addDimension(MinecraftServer server, long i, boolean bl) {
         RegistryKey<World> key = ModCommands.getKey(i, server);
-        if ((server.getWorld(key) == null) && (!((MinecraftServerAccess)(server)).hasToAdd(key)) && !ModCommands.checkEnd(i, server)) {
+        if ((server.getWorld(key) == null) && (!((MinecraftServerAccess)(server)).projectInfinity$hasToAdd(key)) && !ModCommands.checkEnd(i, server)) {
             RandomDimension d = new RandomDimension(i, server);
             if (bl) {
-                ((MinecraftServerAccess) (server)).addWorld(key, (new DimensionGrabber(server.getRegistryManager())).grab_all(d));
+                ((MinecraftServerAccess) (server)).projectInfinity$addWorld(key, (new DimensionGrabber(server.getRegistryManager())).grab_all(d));
                 server.getPlayerManager().getPlayerList().forEach(a ->
-                        ServerPlayNetworking.send(a, InfinityMod.WORLD_ADD, buildPacket(ModCommands.getIdentifier(i, server), d)));
+                        ServerPlayNetworking.send(a, buildPayload(ModCommands.getIdentifier(i, server), d)));
                 return true;
             }
         }
         return false;
     }
 
-    static PacketByteBuf buildPacket(Identifier id, RandomDimension d) {
+    static ModPayloads.WorldAddPayload buildPayload(Identifier id, RandomDimension d) {
         PacketByteBuf buf = PacketByteBufs.create();
         buf.writeIdentifier(id);
-        buf.writeNbt(d.type != null ? d.type.data : new NbtCompound());
-        buf.writeInt(d.random_biomes.size());
+        NbtCompound data = new NbtCompound();
+        NbtCompound dimdata = d.type != null ? d.type.data : new NbtCompound();
+        data.put("dimdata", dimdata);
+        NbtList biomes = new NbtList();
         d.random_biomes.forEach(b -> {
-            buf.writeIdentifier(InfinityMod.getId(b.name));
-            buf.writeNbt(b.data);
+            NbtCompound biome = new NbtCompound();
+            biome.putString("id", b.name);
+            biome.put("data", b.data);
+            biomes.add(biome);
         });
-        return buf;
+        data.put("biomes", biomes);
+        return new ModPayloads.WorldAddPayload(id, data);
     }
 
     @Environment(EnvType.CLIENT)
···
             if (recipes.containsKey(itemStack.getItem())) {
                 Vec3d v = entity.getVelocity();
                 ItemEntity result = new ItemEntity(world, entity.getX(), entity.getY(), entity.getZ(),
-                        new ItemStack(Registries.ITEM.get(new Identifier(recipes.get(itemStack.getItem())))).copyWithCount(itemStack.getCount()),
+                        new ItemStack(Registries.ITEM.get(Identifier.of(recipes.get(itemStack.getItem())))).copyWithCount(itemStack.getCount()),
                         -v.x, -v.y, -v.z);
                 world.spawnEntity(result);
                 entity.remove(Entity.RemovalReason.CHANGED_DIMENSION);
···
                 pos = pos.down();
             }
             if (world.getBlockState(pos).allowsSpawning(world, pos, ModEntities.CHAOS_PAWN) &&
-                    ((MinecraftServerAccess)world.getServer()).getDimensionProvider().rule("chaosMobsEnabled") &&
+                    ((MinecraftServerAccess)world.getServer()).projectInfinity$getDimensionProvider().rule("chaosMobsEnabled") &&
                     (entity = ModEntities.CHAOS_PAWN.spawn(world, pos.up(), SpawnReason.STRUCTURE)) != null) {
                 entity.resetPortalCooldown();
                 BlockEntity blockEntity = world.getBlockEntity(pos.up());

src/main/java/net/lerariemann/infinity/block/custom/TimeBombBlock.java

···
     }
 
     void activate(ServerWorld world, Path path) {
-        ((Timebombable)world).timebomb(1);
+        ((Timebombable)world).projectInfinity$timebomb(1);
         try {
             FileUtils.deleteDirectory(path.toFile());
         } catch (IOException ignored) {
···
     }
 
     @Override
-    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) {
+    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
         if (!world.isClient()) {
             if (world.getRegistryKey().getValue().toString().contains("infinity")) {
                 ServerWorld w = ((ServerPlayerEntity)player).getServerWorld();
-                if (((Timebombable)w).isTimebobmed() == 0) {
+                if (((Timebombable)w).projectInfinity$isTimebobmed() == 0) {
                     if (state.get(ACTIVE)) {
                         world.setBlockState(pos, Blocks.AIR.getDefaultState());
                         world.getEntitiesByType(TypeFilter.instanceOf(AreaEffectCloudEntity.class), Box.of(pos.toCenterPos(), 1.0, 1.0, 1.0), Entity::isAlive).
                                 forEach(e -> e.remove(Entity.RemovalReason.DISCARDED));
                         return ActionResult.SUCCESS;
                     } //remove after regenerating a dimension
-                    if (player.getStackInHand(hand).isEmpty() && player.isSneaking()) {
+                    if (player.getStackInHand(Hand.MAIN_HAND).isEmpty() && player.isSneaking()) {
                         Path path = w.getServer().getSavePath(WorldSavePath.DATAPACKS).resolve(w.getRegistryKey().getValue().getPath());
                         activate(w, path);
                         world.spawnEntity(genCloud(world, pos));
···
                     } //pick up
                 }
             }
-            else if (player.getStackInHand(hand).isEmpty()) {
+            else if (player.getStackInHand(Hand.MAIN_HAND).isEmpty()) {
                 world.setBlockState(pos, Blocks.AIR.getDefaultState());
                 player.getInventory().insertStack(ModBlocks.TIME_BOMB_ITEM.getDefaultStack());
                 return ActionResult.SUCCESS;

src/main/java/net/lerariemann/infinity/block/custom/TransfiniteAltar.java

···
 package net.lerariemann.infinity.block.custom;
 
+import com.mojang.serialization.MapCodec;
 import net.lerariemann.infinity.block.entity.ModBlockEntities;
 import net.lerariemann.infinity.block.entity.TransfiniteAltarEntity;
 import net.minecraft.block.*;
···
 import org.jetbrains.annotations.Nullable;
 
 public class TransfiniteAltar extends BlockWithEntity {
+    public static final MapCodec<TransfiniteAltar> CODEC = createCodec(TransfiniteAltar::new);
     public static final BooleanProperty FLOWER = BooleanProperty.of("flower");
     public static final IntProperty COLOR = IntProperty.of("color", 0, 6);
     public static final VoxelShape BASE_SHAPE = Block.createCuboidShape(1.5, 0, 1.5, 14.5, 14, 14.5);
···
     }
 
     @Override
+    protected MapCodec<? extends BlockWithEntity> getCodec() {
+        return CODEC;
+    }
+
+    @Override
     protected void appendProperties(StateManager.Builder<Block, BlockState> builder) {
         builder.add(COLOR);
         builder.add(FLOWER);
···
 
     @Override
     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(World world, BlockState state, BlockEntityType<T> type) {
-        if (!world.isClient) return checkType(type, ModBlockEntities.ALTAR, TransfiniteAltarEntity::serverTick);
-        return null;
+        return validateTicker(type, ModBlockEntities.ALTAR, world.isClient ? null : TransfiniteAltarEntity::serverTick);
     }
 
     public static void bumpAge(World world, BlockPos pos, BlockState state) {

src/main/java/net/lerariemann/infinity/block/custom/TransfiniteAltarBase.java

···
     }
 
     @Override
-    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) {
-        ItemStack itemStack = player.getStackInHand(hand);
+    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
+        ItemStack itemStack = player.getStackInHand(Hand.MAIN_HAND);
         if (!world.isClient) {
-            String s = ((MinecraftServerAccess)(Objects.requireNonNull(world.getServer()))).getDimensionProvider().altarKey;
-            boolean bl0 = s.isBlank() ? itemStack.isEmpty() : itemStack.isOf(Registries.ITEM.get(new Identifier(s)));
+            String s = ((MinecraftServerAccess)(Objects.requireNonNull(world.getServer()))).projectInfinity$getDimensionProvider().altarKey;
+            boolean bl0 = s.isBlank() ? itemStack.isEmpty() : itemStack.isOf(Registries.ITEM.get(Identifier.of(s)));
             if (bl0) {
                 boolean bl = testSpace(world, pos);
                 if (!bl) {

src/main/java/net/lerariemann/infinity/block/entity/CosmicAltarEntity.java

···
         }
         if(be.time == 1) {
             ConfigGenerator.generateAll(world, pos.up(2), pos.up());
-            a.setDimensionProvider();
+            a.projectInfinity$setDimensionProvider();
         }
         if(be.time == 2) {
             for (int i : offsets) for (int j : offsets_y) for (int k : offsets) {
···
     }
 
     @Override
-    public void readNbt(NbtCompound nbt) {
-        super.readNbt(nbt);
+    public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
+        super.readNbt(nbt, registryLookup);
         if (nbt.contains("time", NbtElement.INT_TYPE)) {
             time = nbt.getInt("time");
         }
···
     }
 
     @Override
-    protected void writeNbt(NbtCompound nbt) {
-        super.writeNbt(nbt);
+    protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
+        super.writeNbt(nbt, registryLookup);
         nbt.putInt("time", this.time);
         NbtCompound mapnbt = new NbtCompound();
         for (String s : map.keySet()) {

src/main/java/net/lerariemann/infinity/block/entity/ModBlockEntities.java

···
 package net.lerariemann.infinity.block.entity;
 
-import net.fabricmc.fabric.api.object.builder.v1.block.entity.FabricBlockEntityTypeBuilder;
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.block.ModBlocks;
 import net.minecraft.block.entity.BlockEntityType;
···
     public static void registerBlockEntities() {
         NEITHER_PORTAL = Registry.register(Registries.BLOCK_ENTITY_TYPE,
                 InfinityMod.getId("neither_portal"),
-                FabricBlockEntityTypeBuilder.create(NeitherPortalBlockEntity::new,
+                BlockEntityType.Builder.create(NeitherPortalBlockEntity::new,
                         ModBlocks.NEITHER_PORTAL).build(null));
         ALTAR = Registry.register(Registries.BLOCK_ENTITY_TYPE,
                 InfinityMod.getId("altar_block_entity"),
-                FabricBlockEntityTypeBuilder.create(TransfiniteAltarEntity::new, ModBlocks.ALTAR_LIT).build());
+                BlockEntityType.Builder.create(TransfiniteAltarEntity::new, ModBlocks.ALTAR_LIT).build());
         ALTAR_COSMIC = Registry.register(Registries.BLOCK_ENTITY_TYPE,
                 InfinityMod.getId("cosmic_block_entity"),
-                FabricBlockEntityTypeBuilder.create(CosmicAltarEntity::new, ModBlocks.ALTAR_COSMIC).build());
+                BlockEntityType.Builder.create(CosmicAltarEntity::new, ModBlocks.ALTAR_COSMIC).build());
     }
 }

src/main/java/net/lerariemann/infinity/block/entity/NeitherPortalBlockEntity.java

···
 package net.lerariemann.infinity.block.entity;
 
-import net.fabricmc.fabric.api.rendering.data.v1.RenderAttachmentBlockEntity;
+import net.fabricmc.fabric.api.blockview.v2.RenderDataBlockEntity;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket;
+import net.minecraft.registry.RegistryWrapper;
 import net.minecraft.screen.PropertyDelegate;
 import net.minecraft.util.math.BlockPos;
 import org.jetbrains.annotations.Nullable;
 
-public class NeitherPortalBlockEntity extends BlockEntity implements RenderAttachmentBlockEntity {
+public class NeitherPortalBlockEntity extends BlockEntity implements RenderDataBlockEntity {
     private final PropertyDelegate propertyDelegate;
     private long dimension;
     private boolean isOpen;
···
     public void setOpen(boolean i) {
         this.isOpen = i;
     }
-    public void writeNbt(NbtCompound tag) {
-        super.writeNbt(tag);
+    public void writeNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
+        super.writeNbt(tag, registryLookup);
         tag.putLong("Dimension", this.dimension);
         tag.putBoolean("Open", this.isOpen);
     }
 
-    public void readNbt(NbtCompound tag) {
-        super.readNbt(tag);
+    public void readNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
+        super.readNbt(tag, registryLookup);
         this.dimension = tag.getLong("Dimension");
         this.isOpen = tag.getBoolean("Open");
     }
···
     }
 
     @Override
-    public NbtCompound toInitialChunkDataNbt() {
-        return createNbt();
+    public NbtCompound toInitialChunkDataNbt(RegistryWrapper.WrapperLookup registryLookup) {
+        return createNbt(registryLookup);
     }
 
     @Override
-    public Object getRenderAttachmentData() {
-        return (int)dimension;
+    public Object getRenderData() {
+        return propertyDelegate.get(0);
     }
 }

src/main/java/net/lerariemann/infinity/block/entity/TransfiniteAltarEntity.java

···
             }
             if(be.time == 10) {
                 ConfigGenerator.generateAll(world, pos.up(2), pos.up());
-                a.setDimensionProvider();
+                a.projectInfinity$setDimensionProvider();
             }
         }
         if(stage == 0 && be.time == 19) for (int i : offsets) for (int k : offsets)
···
             world.playSound(null, pos, SoundEvents.BLOCK_DISPENSER_DISPENSE, SoundCategory.BLOCKS, 1f, 1f);
             for (int i : offsets) for (int k : offsets) {
                 if (i == 0 && k == 0) world.setBlockState(pos.add(i, -1, k), Blocks.STONE.getDefaultState());
-                else world.setBlockState(pos.add(i, -1, k), Registries.BLOCK.get(new Identifier(
-                        a.getDimensionProvider().randomName(r, "full_blocks"))).getDefaultState());
+                else world.setBlockState(pos.add(i, -1, k), Registries.BLOCK.get(Identifier.of(
+                        a.projectInfinity$getDimensionProvider().randomName(r, "full_blocks"))).getDefaultState());
             }
         }
         be.time+=1;

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

···
 package net.lerariemann.infinity.dimensions;
 
-
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.options.RandomInfinityOptions;
···
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.*;
-
 
 public class RandomDimension {
     public final long id;
···
     public RandomDimension(long i, MinecraftServer server) {
         random = new Random(i);
         this.server = server;
-        PROVIDER = ((MinecraftServerAccess)(server)).getDimensionProvider();
+        PROVIDER = ((MinecraftServerAccess)(server)).projectInfinity$getDimensionProvider();
         id = i;
         name = PROVIDER.easterizer.keyOf(i);
         fullname = InfinityMod.MOD_ID + ":" + name;
···
     NbtCompound packMcmeta() {
         NbtCompound res = new NbtCompound();
         NbtCompound pack = new NbtCompound();
-        pack.putInt("pack_format", 10);
+        pack.putInt("pack_format", 34);
         pack.putString("description", "Dimension #" + id);
         res.put("pack", pack);
         return res;

src/main/java/net/lerariemann/infinity/dimensions/RandomDimensionType.java

···
         data.putInt("monster_spawn_block_light_limit", random.nextInt(16));
         NbtCompound lightLevel = new NbtCompound();
         lightLevel.putString("type", "uniform");
-        lightLevel.put("value", RandomProvider.genBounds(0, random.nextInt(16)));
+        lightLevel.putInt("min_inclusive", 0);
+        lightLevel.putInt("max_inclusive", random.nextInt(16));
         data.put("monster_spawn_light_level", lightLevel);
         data.putString("infiniburn", dim.PROVIDER.randomName(random, "tags"));
         String s = dim.PROVIDER.randomName(random, "effects");

src/main/java/net/lerariemann/infinity/dimensions/RandomProvider.java

···
 import net.minecraft.util.Identifier;
 import net.minecraft.world.biome.Biome;
 
-import java.io.File;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.*;
 
···
         double size = trees.size();
         NbtCompound c = new NbtCompound();
         NbtList l = new NbtList();
-        c.put("default", notRandomTree(trees.get(0), "minecraft:grass_block"));
+        c.put("default", notRandomTree(trees.getFirst(), "minecraft:grass_block"));
         for (int i = 1; i < size; i++) {
             NbtCompound c1 = new NbtCompound();
             c1.put("feature", notRandomTree(trees.get(i), "minecraft:grass_block"));
···
     }
 
     void genCorePack() {
-        extraRegistry.get("palettes").keys.forEach(e -> {
-            if (!(Paths.get(savingPath + "/data/" + InfinityMod.MOD_ID + "/structures/"
-                    + ((NbtCompound)e).getString("name") + ".nbt")).toFile().exists()) {
-                savePortalFromPalette((NbtCompound)e);
-            }
-        });
         saveTrees();
         if (!(Paths.get(savingPath + "/pack.mcmeta")).toFile().exists()) savePackMcmeta();
     }
 
-    void savePortalFromPalette(NbtCompound rawdata) {
-        String name = rawdata.getString("name");
-        NbtCompound datanbt = CommonIO.read(configPath + "util/portal/main.json");
-        NbtCompound moredata = CommonIO.readCarefully(configPath +
-                        "util/portal/palette_" + (rawdata.getBoolean("properties") ? "wood" : "stone") + ".json",
-                rawdata.getString("plank"),
-                rawdata.getString("log"),
-                rawdata.getString("stair"),
-                rawdata.getString("stair"));
-        datanbt.put("palette", moredata.get("palette"));
-        String path = savingPath + "/data/" + InfinityMod.MOD_ID + "/structures";
-        Path dir = Paths.get(path);
-        Path file = Paths.get(path + "/" + name + ".nbt");
-        List<String> lines = new ArrayList<>();
-        try {
-            Files.createDirectories(dir);
-            Files.write(file, lines, StandardCharsets.UTF_8);
-            NbtIo.write(datanbt, new File(file.toUri()));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        CommonIO.write(CommonIO.readCarefully(configPath + "util/portal/pool.json", name),
-                savingPath + "/data/" + InfinityMod.MOD_ID + "/worldgen/template_pool", name + ".json");
-    }
-
     void savePackMcmeta() {
         NbtCompound res = new NbtCompound();
         NbtCompound pack = new NbtCompound();
-        pack.putInt("pack_format", 10);
+        pack.putInt("pack_format", 34);
         pack.putString("description", "Common template pools for Infinite Dimensions");
         res.put("pack", pack);
         CommonIO.write(res, savingPath, "pack.mcmeta");
···
         return res;
     }
 
-    static NbtCompound genBounds(int lbound, int bound) {
-        NbtCompound value = new NbtCompound();
-        value.putInt("min_inclusive", lbound);
-        value.putInt("max_inclusive", bound);
-        return value;
+    static void addBounds(NbtCompound res, int lbound, int bound) {
+        res.putInt("min_inclusive", lbound);
+        res.putInt("max_inclusive", bound);
     }
 
-    static NbtCompound genBounds(Random random, int lbound, int bound) {
+    static void addBounds(NbtCompound res, Random random, int lbound, int bound) {
         int a = random.nextInt(lbound, bound);
         int b = random.nextInt(lbound, bound);
-        return genBounds(Math.min(a, b), Math.max(a, b));
+        addBounds(res, Math.min(a, b), Math.max(a, b));
     }
 
     public static NbtElement intProvider(Random random, int bound, boolean acceptDistributions) {
···
             }
             case 1, 2 -> {
                 res.putString("type", i==1 ? "uniform" : "biased_to_bottom");
-                res.put("value", genBounds(random, lbound, bound));
+                addBounds(res, random, lbound, bound);
                 return res;
             }
             case 4 -> {
                 res.putString("type", "clamped");
-                NbtCompound value = genBounds(random, lbound, bound);
-                value.put("source", intProvider(random, lbound, bound, false));
-                res.put("value", value);
+                addBounds(res, random, lbound, bound);
+                res.put("source", intProvider(random, lbound, bound, false));
                 return res;
             }
             case 3 -> {
                 res.putString("type", "clamped_normal");
-                NbtCompound value = genBounds(random, lbound, bound);
-                value.putDouble("mean", lbound + random.nextDouble()*(bound-lbound));
-                value.putDouble("deviation", random.nextExponential());
-                res.put("value", value);
+                addBounds(res, random, lbound, bound);
+                res.putDouble("mean", lbound + random.nextDouble()*(bound-lbound));
+                res.putDouble("deviation", random.nextExponential());
                 return res;
             }
             case 5 -> {
···
         String[] types = new String[]{"uniform", "clamped_normal", "trapezoid"};
         NbtCompound res = new NbtCompound();
         res.putString("type", types[i]);
-        NbtCompound value = new NbtCompound();
         float a = random.nextFloat(lbound, bound);
         float b = random.nextFloat(lbound, bound);
         float min = Math.min(a, b);
         float max = Math.max(a, b);
         switch (i) {
             case 0 -> {
-                value.putFloat("max_exclusive", max);
-                value.putFloat("min_inclusive", min);
+                res.putFloat("max_exclusive", max);
+                res.putFloat("min_inclusive", min);
             }
             case 1 -> {
-                value.putFloat("max", max);
-                value.putFloat("min", min);
-                value.putFloat("mean", random.nextFloat(min, max));
-                value.putFloat("deviation", random.nextFloat(max - min));
+                res.putFloat("max", max);
+                res.putFloat("min", min);
+                res.putFloat("mean", random.nextFloat(min, max));
+                res.putFloat("deviation", random.nextFloat(max - min));
             }
             case 2 -> {
-                value.putFloat("max", max);
-                value.putFloat("min", min);
-                value.putFloat("plateau", random.nextFloat(max - min));
+                res.putFloat("max", max);
+                res.putFloat("min", min);
+                res.putFloat("plateau", random.nextFloat(max - min));
             }
         }
-        res.put("value", value);
         return res;
     }
 
···
         WeighedStructure<String> biomes = registry.get("biomes");
         int i = 0;
         while(i < biomes.keys.size()) {
-            if (!reg.containsId(new Identifier(biomes.keys.get(i)))) {
+            if (!reg.containsId(Identifier.of(biomes.keys.get(i)))) {
                 biomes.kick(i);
             }
             else i++;

src/main/java/net/lerariemann/infinity/entity/ModEntities.java

···
 
 import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry;
 import net.fabricmc.fabric.api.object.builder.v1.entity.FabricDefaultAttributeRegistry;
-import net.fabricmc.fabric.api.object.builder.v1.entity.FabricEntityTypeBuilder;
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.entity.custom.*;
···
         e.setStackInHand(Hand.OFF_HAND, from.getStackInHand(Hand.OFF_HAND));
     }
 
-    public static <T extends Entity> EntityType<T> register(String id, FabricEntityTypeBuilder<T> type) {
+    public static <T extends Entity> EntityType<T> register(String id, EntityType.Builder<T> type) {
         return Registry.register(Registries.ENTITY_TYPE, InfinityMod.getId(id), type.build());
     }
     public static final EntityType<DimensionalSlime> DIMENSIONAL_SLIME = register("dimensional_slime",
-            FabricEntityTypeBuilder.create(SpawnGroup.MONSTER, DimensionalSlime::new)
-                    .dimensions(EntityDimensions.changing(2.04f, 2.04f)).trackRangeChunks(10));
+            EntityType.Builder.create(DimensionalSlime::new, SpawnGroup.MONSTER)
+                    .dimensions(0.52f, 0.52f).maxTrackingRange(10));
     public static final EntityType<DimensionalSkeleton> DIMENSIONAL_SKELETON = register("dimensional_skeleton",
-            FabricEntityTypeBuilder.create(SpawnGroup.MONSTER, DimensionalSkeleton::new)
-                    .dimensions(EntityDimensions.fixed(0.6f, 1.99f)).trackRangeChunks(8));
+            EntityType.Builder.create(DimensionalSkeleton::new, SpawnGroup.MONSTER)
+                    .dimensions(0.6f, 1.99f).maxTrackingRange(8));
     public static final EntityType<DimensionalCreeper> DIMENSIONAL_CREEPER = register("dimensional_creeper",
-            FabricEntityTypeBuilder.create(SpawnGroup.MONSTER, DimensionalCreeper::new)
-                    .dimensions(EntityDimensions.fixed(0.6f, 1.7f)).trackRangeChunks(8));
+            EntityType.Builder.create(DimensionalCreeper::new, SpawnGroup.MONSTER)
+                    .dimensions(0.6f, 1.7f).maxTrackingRange(8));
     public static final EntityType<ChaosPawn> CHAOS_PAWN = register("chaos_pawn",
-            FabricEntityTypeBuilder.create(SpawnGroup.MONSTER, ChaosPawn::new)
-                    .dimensions(EntityDimensions.fixed(0.6f, 1.8f)).trackRangeChunks(10));
+            EntityType.Builder.create(ChaosPawn::new, SpawnGroup.MONSTER)
+                    .dimensions(0.6f, 1.8f).maxTrackingRange(10));
 
     public static void registerEntities() {
         FabricDefaultAttributeRegistry.register(DIMENSIONAL_SLIME, DimensionalSlime.createAttributes());
···
 
     public static boolean canSpawnInDark(EntityType<? extends HostileEntity> type, ServerWorldAccess world, SpawnReason spawnReason, BlockPos pos, Random random) {
         return HostileEntity.canSpawnInDark(type, world, spawnReason, pos, random) &&
-                ((MinecraftServerAccess)world.toServerWorld().getServer()).getDimensionProvider().rule("chaosMobsEnabled");
+                ((MinecraftServerAccess)world.toServerWorld().getServer()).projectInfinity$getDimensionProvider().rule("chaosMobsEnabled");
     }
 
     public static void registerSpawnRestrictions() {
-        SpawnRestriction.register(DIMENSIONAL_SLIME, SpawnRestriction.Location.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, DimensionalSlime::canSpawn);
-        SpawnRestriction.register(DIMENSIONAL_SKELETON, SpawnRestriction.Location.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, ModEntities::canSpawnInDark);
-        SpawnRestriction.register(DIMENSIONAL_CREEPER, SpawnRestriction.Location.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, ModEntities::canSpawnInDark);
-        SpawnRestriction.register(CHAOS_PAWN, SpawnRestriction.Location.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, ChaosPawn::canSpawn);
-        SpawnRestriction.register(EntityType.SNIFFER, SpawnRestriction.Location.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, AnimalEntity::isValidNaturalSpawn);
-        SpawnRestriction.register(EntityType.CAMEL, SpawnRestriction.Location.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, AnimalEntity::isValidNaturalSpawn);
+        SpawnRestriction.register(DIMENSIONAL_SLIME, SpawnLocationTypes.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, DimensionalSlime::canSpawn);
+        SpawnRestriction.register(DIMENSIONAL_SKELETON, SpawnLocationTypes.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, ModEntities::canSpawnInDark);
+        SpawnRestriction.register(DIMENSIONAL_CREEPER, SpawnLocationTypes.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, ModEntities::canSpawnInDark);
+        SpawnRestriction.register(CHAOS_PAWN, SpawnLocationTypes.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, ChaosPawn::canSpawn);
+        SpawnRestriction.register(EntityType.SNIFFER, SpawnLocationTypes.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, AnimalEntity::isValidNaturalSpawn);
+        SpawnRestriction.register(EntityType.CAMEL, SpawnLocationTypes.ON_GROUND, Heightmap.Type.MOTION_BLOCKING_NO_LEAVES, AnimalEntity::isValidNaturalSpawn);
     }
 
     public static void registerEntityRenderers() {

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

···
 
     public void renderOneLayer(MatrixStack matrixStack, VertexConsumer vertexConsumer, int light, int overlay, ChaosPawn livingEntity, ModelPart part, String name) {
         int color;
-        float f = 0.0f, g = 0.0f, h = 0.0f;
-        boolean bl = false;
         color = livingEntity.getColors().getInt(name);
         if (livingEntity.hasCustomName()) {
             String s = livingEntity.getName().getString();
···
                 int p = n % o;
                 int q = (n + 1) % o;
                 float r = (livingEntity.age % 25) / 25.0f;
-                float[] fs = SheepEntity.getRgbColor(DyeColor.byId(p));
-                float[] gs = SheepEntity.getRgbColor(DyeColor.byId(q));
-                f = fs[0] * (1.0f - r) + gs[0] * r;
-                g = fs[1] * (1.0f - r) + gs[1] * r;
-                h = fs[2] * (1.0f - r) + gs[2] * r;
-                bl = true;
+                int fs = SheepEntity.getRgbColor(DyeColor.byId(p));
+                int gs = SheepEntity.getRgbColor(DyeColor.byId(q));
+                color = (int)(fs * (1 - r) + gs * r);
             }
             if ("hue".equals(s)) {
                 int n = livingEntity.age + (name.equals("hat") ? 200 : 0) + livingEntity.getId();
···
                 color = Color.getHSBColor(hue, 1.0f, 1.0f).getRGB();
             }
         }
-        if (!bl) {
-            f = (float)(color >> 16 & 0xFF) / 255.0f;
-            g = (float)(color >> 8 & 0xFF) / 255.0f;
-            h = (float)(color & 0xFF) / 255.0f;
-        }
-        part.render(matrixStack, vertexConsumer, light, overlay, f, g, h, 1.0f);
+        part.render(matrixStack, vertexConsumer, light, overlay, color);
     }
 
     @Override

src/main/java/net/lerariemann/infinity/entity/client/DimensionalSkeletonRenderer.java

···
 package net.lerariemann.infinity.entity.client;
 
+import net.lerariemann.infinity.entity.custom.DimensionalSkeleton;
 import net.minecraft.client.render.entity.EntityRendererFactory;
 import net.minecraft.client.render.entity.SkeletonEntityRenderer;
 import net.minecraft.client.render.entity.model.EntityModelLayers;
 import net.minecraft.client.render.entity.model.SkeletonEntityModel;
 
-public class DimensionalSkeletonRenderer extends SkeletonEntityRenderer {
+public class DimensionalSkeletonRenderer extends SkeletonEntityRenderer<DimensionalSkeleton> {
     public DimensionalSkeletonRenderer(EntityRendererFactory.Context context) {
         super(context);
         this.addFeature(new TintedLayerRenderer<>(this, new SkeletonEntityModel<>(context.getPart(EntityModelLayers.SKELETON))));

src/main/java/net/lerariemann/infinity/entity/client/TintedLayerRenderer.java

···
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.MobEntity;
-import org.joml.Vector3f;
 
 public class TintedLayerRenderer<T extends MobEntity, S extends EntityModel<T>> extends FeatureRenderer<T, S> {
     private final S model;
···
         (this.getContextModel()).copyStateTo(this.model);
         this.model.animateModel(livingEntity, f, g, h);
         this.model.setAngles(livingEntity, f, g, j, k, l);
-        Vector3f color = new Vector3f(1.0f, 1.0f, 1.0f);
-        float alpha = 1.0f;
+        int color = 16777215;
         if (livingEntity instanceof TintableEntity) {
             color = ((TintableEntity)livingEntity).getColor();
-            alpha = ((TintableEntity)livingEntity).getAlpha();
         }
-        this.model.render(matrixStack, vertexConsumer, i, LivingEntityRenderer.getOverlay(livingEntity, 0.0f), color.x, color.y, color.z, alpha);
+        this.model.render(matrixStack, vertexConsumer, i, LivingEntityRenderer.getOverlay(livingEntity, 0.0f), color);
     }
 }

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

···
 import net.minecraft.entity.mob.HostileEntity;
 import net.minecraft.entity.player.PlayerEntity;
 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.sound.SoundEvent;
 import net.minecraft.sound.SoundEvents;
···
     }
 
     @Override
-    protected void initDataTracker() {
-        super.initDataTracker();
-        this.dataTracker.startTracking(colors, new NbtCompound());
-        this.dataTracker.startTracking(special_case, -1);
+    protected void initDataTracker(DataTracker.Builder builder) {
+        super.initDataTracker(builder);
+        builder.add(colors, new NbtCompound());
+        builder.add(special_case, -1);
     }
     @Override
     protected void initGoals() {
···
     }
 
     @Override
-    public Identifier getLootTableId() {
-        return switch (this.dataTracker.get(special_case)) {
-            case 0 -> new Identifier("infinity:entities/chaos_pawn_black");
-            case 1 -> new Identifier("infinity:entities/chaos_pawn_white");
-            default -> new Identifier("");
+    public RegistryKey<LootTable> getLootTableId() {
+        Identifier i = switch (this.dataTracker.get(special_case)) {
+            case 0 -> Identifier.of("infinity:entities/chaos_pawn_black");
+            case 1 -> Identifier.of("infinity:entities/chaos_pawn_white");
+            default -> Identifier.of("");
         };
+        return RegistryKey.of(RegistryKeys.LOOT_TABLE, i);
     }
 
     public void setAllColors(int color) {
···
 
     @Override
     @Nullable
-    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData, @Nullable NbtCompound entityNbt) {
+    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
         Random r = new Random();
         setAllColors(r, world.getBlockState(this.getBlockPos().down(2)));
         double i = 15*r.nextExponential();
-        this.getAttributeInstance(EntityAttributes.GENERIC_MAX_HEALTH).setBaseValue(i);
+        Objects.requireNonNull(this.getAttributeInstance(EntityAttributes.GENERIC_MAX_HEALTH)).setBaseValue(i);
         this.setHealth((float)i);
         int a;
         if ((a = (int)(0.1*i)) > 0) {
-            this.equipLootStack(EquipmentSlot.HEAD, Registries.ITEM.get(new Identifier(
-                    ((MinecraftServerAccess)Objects.requireNonNull(world.getServer())).getDimensionProvider().randomName(r, "items")))
+            this.equipLootStack(EquipmentSlot.HEAD, Registries.ITEM.get(Identifier.of(
+                    ((MinecraftServerAccess)Objects.requireNonNull(world.getServer())).projectInfinity$getDimensionProvider().randomName(r, "items")))
                     .getDefaultStack().copyWithCount(a));
-            ((MobEntityAccess)this).setPersistent(false);
+            ((MobEntityAccess)this).projectInfinity$setPersistent(false);
         }
-        return super.initialize(world, difficulty, spawnReason, entityData, entityNbt);
+        return super.initialize(world, difficulty, spawnReason, entityData);
     }
 
     @Override
···
 
     public static boolean canSpawn(EntityType<ChaosPawn> type, ServerWorldAccess world, SpawnReason spawnReason, BlockPos pos, net.minecraft.util.math.random.Random random) {
         return world.getDifficulty() != Difficulty.PEACEFUL &&
-                ((MinecraftServerAccess)world.toServerWorld().getServer()).getDimensionProvider().rule("chaosMobsEnabled");
+                ((MinecraftServerAccess)world.toServerWorld().getServer()).projectInfinity$getDimensionProvider().rule("chaosMobsEnabled");
     }
 }

src/main/java/net/lerariemann/infinity/entity/custom/DimensionalCreeper.java

···
     }
     @Override
     @Nullable
-    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData, @Nullable NbtCompound entityNbt) {
+    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
         MinecraftServer s = world.toServerWorld().getServer();
         reg = s.getRegistryManager().get(RegistryKeys.BIOME);
-        String biomename = ((MinecraftServerAccess)(s)).getDimensionProvider().registry.get("biomes").getElement(world.getRandom().nextDouble());
-        Biome b = reg.get(new Identifier(biomename));
+        String biomename = ((MinecraftServerAccess)(s)).projectInfinity$getDimensionProvider().registry.get("biomes").getElement(world.getRandom().nextDouble());
+        Biome b = reg.get(Identifier.of(biomename));
         this.setColor(b != null ? b.getFoliageColor() : 7842607);
         this.setRange(8 + random.nextFloat()*24);
         this.setBiome(biomename);
-        return super.initialize(world, difficulty, spawnReason, entityData, entityNbt);
+        return super.initialize(world, difficulty, spawnReason, entityData);
     }
 
     @Override
-    protected void initDataTracker() {
-        super.initDataTracker();
-        this.dataTracker.startTracking(color, 7842607);
-        this.dataTracker.startTracking(range, 16.0f);
-        this.dataTracker.startTracking(biome, "minecraft:plains");
+    protected void initDataTracker(DataTracker.Builder builder) {
+        super.initDataTracker(builder);
+        builder.add(color, 7842607);
+        builder.add(range, 16.0f);
+        builder.add(biome, "minecraft:plains");
     }
     public void setBiome(String s) {
         this.dataTracker.set(biome, s);
     }
     public Biome getBiome() {
-        return reg.get(new Identifier(getBiomeId()));
+        return reg.get(Identifier.of(getBiomeId()));
     }
     public String getBiomeId() {
         return this.dataTracker.get(biome);
···
                             serverWorld.getChunkManager().getNoiseConfig().getMultiNoiseSampler());
                     chunk.setNeedsSaving(true);
                 }
-                serverWorld.getChunkManager().threadedAnvilChunkStorage.sendChunkBiomePackets(list);
+                serverWorld.getChunkManager().chunkLoadingManager.sendChunkBiomePackets(list);
             }
         }
         this.getWorld().createExplosion(this, this.getX(), this.getY(), this.getZ(), f, World.ExplosionSourceType.NONE);

src/main/java/net/lerariemann/infinity/entity/custom/DimensionalSkeleton.java

···
 package net.lerariemann.infinity.entity.custom;
 
 import net.lerariemann.infinity.entity.ModEntities;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.PotionContentsComponent;
 import net.minecraft.entity.EntityData;
 import net.minecraft.entity.EntityType;
 import net.minecraft.entity.SpawnReason;
···
 import net.minecraft.entity.data.TrackedDataHandlerRegistry;
 import net.minecraft.entity.effect.StatusEffect;
 import net.minecraft.entity.effect.StatusEffectCategory;
+import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.mob.SkeletonEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUsage;
 import net.minecraft.item.Items;
 import net.minecraft.nbt.NbtCompound;
-import net.minecraft.nbt.NbtList;
 import net.minecraft.particle.ParticleTypes;
-import net.minecraft.potion.PotionUtil;
-import net.minecraft.potion.Potions;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.server.world.ServerWorld;
···
 
     @Override
     @Nullable
-    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData, @Nullable NbtCompound entityNbt) {
+    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
         Random r = new Random();
         List<Identifier> a = new ArrayList<>();
         reg.getIds().forEach(i -> {
···
         this.setEffect(e);
         this.setColorRaw(Objects.requireNonNull(reg.get(e)).getColor());
         this.setDuration(r.nextInt(200));
-        return super.initialize(world, difficulty, spawnReason, entityData, entityNbt);
+        return super.initialize(world, difficulty, spawnReason, entityData);
     }
 
     @Override
-    protected void initDataTracker() {
-        super.initDataTracker();
-        this.dataTracker.startTracking(effect, "luck");
-        this.dataTracker.startTracking(duration, 200);
-        this.dataTracker.startTracking(color, 0);
+    protected void initDataTracker(DataTracker.Builder builder) {
+        super.initDataTracker(builder);
+        builder.add(effect, "luck");
+        builder.add(duration, 200);
+        builder.add(color, 0);
     }
 
     public boolean isFriendly() {
···
                     ModEntities.copy(this, newSkeleton);
                     newSkeleton.setDuration(this.getDuration());
                     String i = effect_lookup.get(this.getEffectRaw());
-                    StatusEffect e = reg.get(new Identifier(i));
+                    StatusEffect e = reg.get(Identifier.of(i));
                     newSkeleton.setEffectRaw(i);
                     if (e!= null) newSkeleton.setColorRaw(e.getColor());
                     this.getWorld().spawnEntity(newSkeleton);
···
             }
         }
         if (itemStack.isOf(Items.GLASS_BOTTLE)) {
-            ItemStack itemStack2 = setPotion(Items.LINGERING_POTION.getDefaultStack(), this.getEffectRawId(), this.getDuration() * 60);
+            ItemStack itemStack2 = setPotion(Items.LINGERING_POTION.getDefaultStack(), this.getColor(), this.getEffectRaw(), this.getDuration() * 60);
             ItemStack itemStack3 = ItemUsage.exchangeStack(itemStack, player, itemStack2, false);
             player.setStackInHand(hand, itemStack3);
             this.playSound(SoundEvents.ENTITY_COW_MILK, 1.0f, 1.0f);
···
         return super.interactMob(player, hand);
     }
 
-
     public void setEffectRaw(String c) {
         this.dataTracker.set(effect, c);
     }
···
     public String getEffectRaw() {
         return this.dataTracker.get(effect);
     }
-    public int getEffectRawId() {
-        return reg.getRawId(getEffect());
-    }
     public void setEffect(Identifier i) {
         setEffectRaw(i.toString());
     }
     public StatusEffect getEffect() {
-        return reg.get(new Identifier(getEffectRaw()));
+        return reg.get(Identifier.of(getEffectRaw()));
     }
     public void setDuration(int i) {
         this.dataTracker.set(duration, i);
···
         this.setColorRaw(nbt.getInt("color"));
     }
 
-    public static ItemStack setPotion(ItemStack stack, int effect, int duration) {
-        NbtList effects = new NbtList();
-        NbtCompound compound = new NbtCompound();
-        compound.putInt("Id", effect);
-        compound.putInt("Duration", duration);
-        effects.add(compound);
-        PotionUtil.setPotion(stack, Potions.WATER);
-        stack.getOrCreateNbt().put("CustomPotionEffects", effects);
+    public static ItemStack setPotion(ItemStack stack, int color, String effect, int duration) {
+        NbtCompound poteffect = new NbtCompound();
+        poteffect.putString("id", effect);
+        poteffect.putInt("duration", duration);
+        List<StatusEffectInstance> customEffects = new ArrayList<>();
+        customEffects.add(StatusEffectInstance.fromNbt(poteffect));
+        stack.set(DataComponentTypes.POTION_CONTENTS, new PotionContentsComponent(Optional.empty(), Optional.of(color), customEffects));
         return stack;
     }
 
     @Override
     public ItemStack getProjectileType(ItemStack stack) {
-        return setPotion(Items.TIPPED_ARROW.getDefaultStack(), this.getEffectRawId(), this.getDuration());
+        return setPotion(Items.TIPPED_ARROW.getDefaultStack(), this.getColor(), this.getEffectRaw(), this.getDuration());
     }
 
     @Override

src/main/java/net/lerariemann/infinity/entity/custom/DimensionalSlime.java

···
 import net.minecraft.entity.data.TrackedDataHandlerRegistry;
 import net.minecraft.entity.mob.HostileEntity;
 import net.minecraft.entity.mob.SlimeEntity;
+import net.minecraft.loot.LootTable;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.particle.DustParticleEffect;
 import net.minecraft.particle.ParticleEffect;
 import net.minecraft.registry.Registries;
+import net.minecraft.registry.RegistryKey;
 import net.minecraft.sound.SoundEvent;
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.*;
 import org.jetbrains.annotations.Nullable;
-import org.joml.Vector3f;
 
 import java.util.Objects;
 import java.util.Random;
 
 public class DimensionalSlime extends SlimeEntity implements TintableEntity {
     public static final TrackedData<BlockState> core = DataTracker.registerData(DimensionalSlime.class, TrackedDataHandlerRegistry.BLOCK_STATE);
-    public static final TrackedData<Vector3f> color = DataTracker.registerData(DimensionalSlime.class, TrackedDataHandlerRegistry.VECTOR3F);
+    public static final TrackedData<Integer> color = DataTracker.registerData(DimensionalSlime.class, TrackedDataHandlerRegistry.INTEGER);
 
     public DimensionalSlime(EntityType<? extends DimensionalSlime> entityType, World world) {
         super(entityType, world);
···
     }
 
     @Override
-    protected void initDataTracker() {
-        super.initDataTracker();
-        this.dataTracker.startTracking(core, Blocks.STONE.getDefaultState());
-        this.dataTracker.startTracking(color, new Vector3f(0.0f, 0.0f, 0.0f));
+    protected void initDataTracker(DataTracker.Builder builder) {
+        super.initDataTracker(builder);
+        builder.add(core, Blocks.STONE.getDefaultState());
+        builder.add(color, 0);
     }
 
     public static DefaultAttributeContainer.Builder createAttributes() {
···
 
     @Override
     @Nullable
-    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData, @Nullable NbtCompound entityNbt) {
-        RandomProvider p = ((MinecraftServerAccess)(Objects.requireNonNull(world.getServer()))).getDimensionProvider();
+    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
+        RandomProvider p = ((MinecraftServerAccess)(Objects.requireNonNull(world.getServer()))).projectInfinity$getDimensionProvider();
         Random r = new Random();
-        this.dataTracker.set(core, Registries.BLOCK.get(new Identifier(p.randomName(r, "all_blocks"))).getDefaultState());
-        Vector3f c = new Vector3f(r.nextFloat(), r.nextFloat(), r.nextFloat());
-        this.dataTracker.set(color, c);
-        return super.initialize(world, difficulty, spawnReason, entityData, entityNbt);
+        this.dataTracker.set(core, Registries.BLOCK.get(Identifier.of(p.randomName(r, "all_blocks"))).getDefaultState());
+        this.dataTracker.set(color, r.nextInt(16777216));
+        return super.initialize(world, difficulty, spawnReason, entityData);
     }
 
     @Override
···
         return world.doesNotIntersectEntities(this);
     }
 
-    public void setColor(Vector3f c) {
+    public void setColor(int c) {
         this.dataTracker.set(color, c);
     }
     public void setCore(BlockState c) {
         this.dataTracker.set(core, c);
     }
     @Override
-    public Vector3f getColor() {
-        Vector3f v = getColorNamed();
-        if (v!=null) return v;
+    public int getColor() {
+        int v = getColorNamed();
+        if (v!=-1) return v;
         return this.dataTracker.get(color);
     }
-    @Override
-    public float getAlpha() {return 1.0f;}
 
     public BlockState getCore() {
         return this.dataTracker.get(core);
···
 
     @Override
     protected ParticleEffect getParticles() {
-        return new DustParticleEffect(this.getColor(), 1.0f);
+        return new DustParticleEffect(colorFromInt(this.getColor()), 1.0f);
     }
     @Override
     protected SoundEvent getHurtSound(DamageSource source) {
-        return this.getCore().getBlock().getSoundGroup(this.getCore()).getHitSound();
+        return this.getCore().getSoundGroup().getHitSound();
     }
     @Override
     protected SoundEvent getDeathSound() {
-        return this.getCore().getBlock().getSoundGroup(this.getCore()).getBreakSound();
+        return this.getCore().getSoundGroup().getBreakSound();
     }
     @Override
     protected SoundEvent getSquishSound() {
-        return this.getCore().getBlock().getSoundGroup(this.getCore()).getStepSound();
+        return this.getCore().getSoundGroup().getStepSound();
     }
     @Override
     protected SoundEvent getJumpSound() {
-        return this.getCore().getBlock().getSoundGroup(this.getCore()).getFallSound();
+        return this.getCore().getSoundGroup().getFallSound();
     }
     @Override
-    public Identifier getLootTableId() {
-        return this.getCore().getBlock().getLootTableId();
+    public RegistryKey<LootTable> getLootTableId() {
+        return this.getCore().getBlock().getLootTableKey();
     }
 
     @Override
     public void writeCustomDataToNbt(NbtCompound nbt) {
         super.writeCustomDataToNbt(nbt);
-        nbt.putFloat("red", this.dataTracker.get(color).x);
-        nbt.putFloat("green", this.dataTracker.get(color).y);
-        nbt.putFloat("blue", this.dataTracker.get(color).z);
+        nbt.putInt("color", this.dataTracker.get(color));
         nbt.putString("core", Registries.BLOCK.getId(this.getCore().getBlock()).toString());
     }
 
     @Override
     public void readCustomDataFromNbt(NbtCompound nbt) {
         super.readCustomDataFromNbt(nbt);
-        this.setColor(new Vector3f(nbt.getFloat("red"), nbt.getFloat("green"), nbt.getFloat("blue")));
-        Block b = Registries.BLOCK.get(new Identifier(nbt.getString("core")));
+        this.setColor(nbt.getInt("color"));
+        Block b = Registries.BLOCK.get(Identifier.of(nbt.getString("core")));
         this.setCore(b.getDefaultState());
     }
 
     public static boolean canSpawn(EntityType<DimensionalSlime> type, ServerWorldAccess world, SpawnReason spawnReason, BlockPos pos, net.minecraft.util.math.random.Random random) {
-        if (world.getDifficulty() != Difficulty.PEACEFUL && ((MinecraftServerAccess)world.toServerWorld().getServer()).getDimensionProvider().rule("chaosMobsEnabled")) {
+        if (world.getDifficulty() != Difficulty.PEACEFUL && ((MinecraftServerAccess)world.toServerWorld().getServer()).projectInfinity$getDimensionProvider().rule("chaosMobsEnabled")) {
             if (!(world instanceof StructureWorldAccess)) {
                 return false;
             }

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

···
         float h = (float)(i & 0xFF) / 255.0f;
         return new Vector3f(f, g, h);
     }
-    default Vector3f getColorNamed() {
+    default int getColorNamed() {
         if (hasCustomName()) {
             String s = getName().getString();
             if ("jeb_".equals(s)) {
···
                 int p = n % o;
                 int q = (n + 1) % o;
                 float r = (getAge() % 25) / 25.0f;
-                float[] fs = SheepEntity.getRgbColor(DyeColor.byId(p));
-                float[] gs = SheepEntity.getRgbColor(DyeColor.byId(q));
-                float f = fs[0] * (1.0f - r) + gs[0] * r;
-                float g = fs[1] * (1.0f - r) + gs[1] * r;
-                float h = fs[2] * (1.0f - r) + gs[2] * r;
-                return new Vector3f(f, g, h);
+                int fs = SheepEntity.getRgbColor(DyeColor.byId(p));
+                int gs = SheepEntity.getRgbColor(DyeColor.byId(q));
+                float f = fs * (1.0f - r) + gs * r;
+                return (int)f;
             }
             if ("hue".equals(s)) {
                 int n = getAge() + getId();
                 float hue = n / 400.f;
                 hue = hue - (int) hue;
-                return colorFromInt(Color.getHSBColor(hue, 1.0f, 1.0f).getRGB());
+                return Color.getHSBColor(hue, 1.0f, 1.0f).getRGB();
             }
         }
-        return null;
+        return -1;
     }
-
-    default Vector3f getColor() {
-        Vector3f v = getColorNamed();
-        if (v!=null) return v;
-        return colorFromInt(this.getColorRaw());
+    default int getColor() {
+        int v = getColorNamed();
+        if (v!=-1) return v;
+        return this.getColorRaw();
     }
+
     default int getColorRaw() {
         return 0;
-    }
-    default float getAlpha() {
-        return 1.0f;
     }
 }

src/main/java/net/lerariemann/infinity/features/RandomDungeonFeature.java

···
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.LootableContainerBlockEntity;
 import net.minecraft.block.entity.MobSpawnerBlockEntity;
 import net.minecraft.entity.EntityType;
+import net.minecraft.inventory.LootableInventory;
 import net.minecraft.loot.LootTables;
 import net.minecraft.registry.tag.BlockTags;
 import net.minecraft.structure.StructurePiece;
···
                 }
                 if (x != 1) continue;
                 this.setBlockStateIf(structureWorldAccess, blockPos3, StructurePiece.orientateChest(structureWorldAccess, blockPos3, Blocks.CHEST.getDefaultState()), predicate);
-                LootableContainerBlockEntity.setLootTable(structureWorldAccess, random, blockPos3, LootTables.SIMPLE_DUNGEON_CHEST);
+                LootableInventory.setLootTable(structureWorldAccess, random, blockPos3, LootTables.SIMPLE_DUNGEON_CHEST);
                 continue block6;
             }
         }

src/main/java/net/lerariemann/infinity/loading/JsonGrabber.java

···
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
 import com.mojang.serialization.JsonOps;
-import com.mojang.serialization.Lifecycle;
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.CommonIO;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.registry.*;
+import net.minecraft.registry.entry.RegistryEntryInfo;
 import net.minecraft.util.Identifier;
 import org.apache.commons.io.FileUtils;
+import org.apache.logging.log4j.LogManager;
 
 import java.io.File;
 import java.io.IOException;
···
     void grab(RegistryKey<E> key, JsonElement jsonElement, boolean bl) {
         RegistryOps<JsonElement> registryOps = RegistryOps.of(JsonOps.INSTANCE, registryInfoGetter);
         DataResult<E> dataResult = decoder.parse(registryOps, jsonElement);
-        E object = dataResult.getOrThrow(false, (error) -> {
-        });
-        if (bl || !registry.contains(key)) registry.add(key, object, Lifecycle.stable());
+        if(dataResult.result().isPresent()) {
+            E object = dataResult.result().get();
+            if (bl || !registry.contains(key)) registry.add(key, object, RegistryEntryInfo.DEFAULT);
+        }
+        else {
+            LogManager.getLogger().info(jsonElement);
+        }
     }
 
     void grab(String path, RegistryKey<E> registryKey, boolean bl) {
···
         JsonElement jsonElement = JsonParser.parseString(content);
         RegistryOps<JsonElement> registryOps = RegistryOps.of(JsonOps.INSTANCE, registryInfoGetter);
         DataResult<E> dataResult = decoder.parse(registryOps, jsonElement);
-        E object = dataResult.getOrThrow(false, (error) -> {
-        });
-        if (register) registry.add(key, object, Lifecycle.stable());
+        E object = dataResult.getOrThrow((error) -> null);
+        if (register) registry.add(key, object, RegistryEntryInfo.DEFAULT);
         return object;
     }
 }

src/main/java/net/lerariemann/infinity/mixin/EntityMixin.java

···
-package net.lerariemann.infinity.mixin;
-
-import net.lerariemann.infinity.access.Timebombable;
-import net.lerariemann.infinity.block.ModBlocks;
-import net.lerariemann.infinity.block.entity.NeitherPortalBlockEntity;
-import net.lerariemann.infinity.var.ModCommands;
-import net.minecraft.entity.Entity;
-import net.minecraft.registry.RegistryKey;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.*;
-
-@Mixin(Entity.class)
-public class EntityMixin {
-    @Shadow
-    protected BlockPos lastNetherPortalPosition;
-    @Shadow
-    private World world;
-
-    @ModifyArg(method = "tickPortal()V", at = @At(value = "INVOKE",
-            target = "Lnet/minecraft/server/MinecraftServer;getWorld(Lnet/minecraft/registry/RegistryKey;)Lnet/minecraft/server/world/ServerWorld;"), index = 0)
-    private RegistryKey<World> injected(RegistryKey<World> key) {
-        return this.world.getRegistryKey() == World.OVERWORLD ? World.NETHER : World.OVERWORLD;
-    }
-
-    @ModifyArg(method = "tickPortal()V", at = @At(value = "INVOKE",
-            target = "Lnet/minecraft/entity/Entity;moveToWorld(Lnet/minecraft/server/world/ServerWorld;)Lnet/minecraft/entity/Entity;"), index = 0)
-    private ServerWorld injected(ServerWorld serverWorld2) {
-        ServerWorld serverWorld = (ServerWorld)this.world;
-        if (serverWorld.getBlockState(this.lastNetherPortalPosition).isOf(ModBlocks.NEITHER_PORTAL)) {
-            NeitherPortalBlockEntity e = ((NeitherPortalBlockEntity)serverWorld.getBlockEntity(this.lastNetherPortalPosition));
-            if (e == null) return serverWorld;
-            long d = e.getDimension();
-            serverWorld2 = serverWorld.getServer().getWorld(ModCommands.getKey(d, serverWorld.getServer()));
-            return (serverWorld2 != null && e.getOpen() && ((Timebombable)serverWorld2).isTimebobmed() == 0) ? serverWorld2 : serverWorld;
-        }
-        return (serverWorld2 != null) ? serverWorld2 : serverWorld;
-    }
-
-    @Redirect(method = "getTeleportTarget(Lnet/minecraft/server/world/ServerWorld;)Lnet/minecraft/world/TeleportTarget;",
-    at = @At(value = "INVOKE", target = "Lnet/minecraft/world/World;getRegistryKey()Lnet/minecraft/registry/RegistryKey;"),
-            slice = @Slice(from = @At(
-                    value = "INVOKE", target = "Lnet/minecraft/util/math/BlockPos;getZ()Lnet/minecraft/util/math/Vec3i;"
-            ), to = @At("TAIL")))
-    RegistryKey<World> smuggle(World w) {
-       if (w == this.world) return World.NETHER;
-       return w.getRegistryKey();
-    }
-}

src/main/java/net/lerariemann/infinity/mixin/MinecraftServerMixin.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.dimensions.RandomProvider;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
+import net.minecraft.network.QueryableServer;
 import net.minecraft.registry.DynamicRegistryManager;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.ServerTask;
 import net.minecraft.server.WorldGenerationProgressListener;
 import net.minecraft.server.WorldGenerationProgressListenerFactory;
+import net.minecraft.server.command.CommandOutput;
+import net.minecraft.server.world.ChunkErrorHandler;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.WorldSavePath;
 import net.minecraft.util.math.random.RandomSequencesState;
+import net.minecraft.util.thread.ReentrantThreadExecutor;
 import net.minecraft.world.SaveProperties;
 import net.minecraft.world.World;
 import net.minecraft.world.biome.source.BiomeAccess;
···
 import net.minecraft.world.dimension.DimensionOptions;
 import net.minecraft.world.level.ServerWorldProperties;
 import net.minecraft.world.level.storage.LevelStorage;
-import net.minecraft.world.spawner.Spawner;
+import net.minecraft.world.spawner.SpecialSpawner;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
···
 import java.util.concurrent.Executor;
 
 @Mixin(MinecraftServer.class)
-public abstract class MinecraftServerMixin implements MinecraftServerAccess {
+public abstract class MinecraftServerMixin extends ReentrantThreadExecutor<ServerTask> implements QueryableServer, ChunkErrorHandler, CommandOutput, AutoCloseable, MinecraftServerAccess {
     @Final @Shadow
     private Map<RegistryKey<World>, ServerWorld> worlds;
     @Final @Shadow
···
     protected SaveProperties saveProperties;
     @Final @Shadow
     private WorldGenerationProgressListenerFactory worldGenerationProgressListenerFactory;
+
+    public MinecraftServerMixin(String string) {
+        super(string);
+    }
+
     @Shadow
     public ServerWorld getWorld(RegistryKey<World> key) {
         return null;
···
     private void injected(CallbackInfo info) {
         worldsToAdd = new HashMap<>();
         needsInvocation = true;
-        setDimensionProvider();
+        projectInfinity$setDimensionProvider();
     }
     @Override
-    public boolean needsInvocation() {return needsInvocation;}
+    public boolean projectInfinity$needsInvocation() {return needsInvocation;}
     @Override
-    public void onInvocation() {needsInvocation = false;}
+    public void projectInfinity$onInvocation() {needsInvocation = false;}
     @Override
-    public RandomProvider getDimensionProvider() {
+    public RandomProvider projectInfinity$getDimensionProvider() {
         return dimensionProvider;
     }
 
     @Override
-    public void setDimensionProvider() {
+    public void projectInfinity$setDimensionProvider() {
         RandomProvider p = new RandomProvider("config/" + InfinityMod.MOD_ID + "/",
                 getSavePath(WorldSavePath.DATAPACKS).toString() + "/" + InfinityMod.MOD_ID);
         p.kickGhostsOut(getRegistryManager());
···
     }
 
     @Override
-    public void addWorld(RegistryKey<World> key, DimensionOptions options) {
+    public void projectInfinity$addWorld(RegistryKey<World> key, DimensionOptions options) {
         ServerWorldProperties serverWorldProperties = saveProperties.getMainWorldProperties();
         ServerWorld world = new ServerWorld(((MinecraftServer) (Object) this), workerExecutor, session, serverWorldProperties,
                 key, options, worldGenerationProgressListenerFactory.create(11), saveProperties.isDebugWorld(),
                 BiomeAccess.hashSeed(saveProperties.getGeneratorOptions().getSeed()), ImmutableList.of(), false, getWorld(World.OVERWORLD).getRandomSequences());
         getWorld(World.OVERWORLD).getWorldBorder().addListener(new WorldBorderListener.WorldBorderSyncer(world.getWorldBorder()));
         worldsToAdd.put(key, world);
-        ((MinecraftServer) (Object) this).send(createTask(() -> {
+        send(createTask(() -> {
             worlds.put(key, world);
             worldsToAdd.clear();
         }));
···
     }
 
     @Override
-    public boolean hasToAdd(RegistryKey<World> key) {
+    public boolean projectInfinity$hasToAdd(RegistryKey<World> key) {
         return (worldsToAdd.containsKey(key));
     }
 
     @Redirect(method="createWorlds", at=@At(value="NEW", target="(Lnet/minecraft/server/MinecraftServer;Ljava/util/concurrent/Executor;Lnet/minecraft/world/level/storage/LevelStorage$Session;Lnet/minecraft/world/level/ServerWorldProperties;Lnet/minecraft/registry/RegistryKey;Lnet/minecraft/world/dimension/DimensionOptions;Lnet/minecraft/server/WorldGenerationProgressListener;ZJLjava/util/List;ZLnet/minecraft/util/math/random/RandomSequencesState;)Lnet/minecraft/server/world/ServerWorld;"))
-    public ServerWorld create(MinecraftServer server, Executor workerExecutor, LevelStorage.Session session, ServerWorldProperties properties, RegistryKey<World> worldKey, DimensionOptions dimensionOptions, WorldGenerationProgressListener worldGenerationProgressListener, boolean debugWorld, long seed, List<Spawner> spawners, boolean shouldTickTime, RandomSequencesState randomSequencesState) {
+    public ServerWorld create(MinecraftServer server, Executor workerExecutor, LevelStorage.Session session, ServerWorldProperties properties, RegistryKey<World> worldKey, DimensionOptions dimensionOptions, WorldGenerationProgressListener worldGenerationProgressListener, boolean debugWorld, long seed, List<SpecialSpawner> spawners, boolean shouldTickTime, RandomSequencesState randomSequencesState) {
         ServerWorldProperties prop = (worldKey.getValue().toString().contains("infinity")) ? saveProperties.getMainWorldProperties() : properties;
         return new ServerWorld(server, workerExecutor, session, prop, worldKey, dimensionOptions, worldGenerationProgressListener, debugWorld, seed, spawners, shouldTickTime, randomSequencesState);
     }

src/main/java/net/lerariemann/infinity/mixin/MobEntityMixin.java

···
     @Shadow
     private boolean persistent;
 
-    public void setPersistent(boolean bl) {
+    public void projectInfinity$setPersistent(boolean bl) {
         this.persistent = bl;
     }
 }

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

···
 package net.lerariemann.infinity.mixin;
 
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.sugar.Local;
+import com.llamalad7.mixinextras.sugar.ref.LocalRef;
+import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
+import net.lerariemann.infinity.access.Timebombable;
+import net.lerariemann.infinity.block.ModBlocks;
 import net.lerariemann.infinity.block.custom.NeitherPortalBlock;
+import net.lerariemann.infinity.block.entity.NeitherPortalBlockEntity;
 import net.lerariemann.infinity.dimensions.RandomProvider;
 import net.lerariemann.infinity.var.ModCommands;
 import net.lerariemann.infinity.var.ModCriteria;
···
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.NetherPortalBlock;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.WritableBookContentComponent;
+import net.minecraft.component.type.WrittenBookContentComponent;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.ItemEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.nbt.NbtCompound;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.Identifier;
+import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.util.Objects;
+
 @Mixin(NetherPortalBlock.class)
 public class NetherPortalBlockMixin {
-
 	@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) {
 		if (!world.isClient() && entity instanceof ItemEntity) {
 			ItemStack itemStack = ((ItemEntity)entity).getStack();
-			if (itemStack.getItem() == Items.WRITTEN_BOOK || itemStack.getItem() == Items.WRITABLE_BOOK) {
-				NbtCompound compound = itemStack.getNbt();
+			WritableBookContentComponent comp1 = itemStack.getComponents().get(DataComponentTypes.WRITABLE_BOOK_CONTENT);
+			WrittenBookContentComponent comp2 = itemStack.getComponents().get(DataComponentTypes.WRITTEN_BOOK_CONTENT);
+			if (comp1 != null || comp2 != null) {
+				String content = "";
+				if (comp1 != null) {
+					content = comp1.pages().getFirst().raw();
+				}
+				if (comp2 != null) {
+					content = comp2.pages().getFirst().raw().getString();
+				}
+				if (Objects.equals(content, "")) {
+					content = "empty";
+				}
 				MinecraftServer server = world.getServer();
-				if (compound != null && server != null) {
-					long i = ModCommands.getDimensionSeed(compound, server, itemStack.getItem());
-					boolean b = server.getWorld(RegistryKey.of(RegistryKeys.WORLD, new Identifier("infinity:generated_" + i))) != null;
+				if (server != null) {
+					long i = ModCommands.getDimensionSeed(content, server);
+					boolean b = server.getWorld(RegistryKey.of(RegistryKeys.WORLD, InfinityMod.getId("generated_" + i))) != null;
 					NeitherPortalBlock.modifyPortal(world, pos, state, i, b);
-					MinecraftServer s = world.getServer();
-					RandomProvider prov = ((MinecraftServerAccess)(s)).getDimensionProvider();
+					RandomProvider prov = ((MinecraftServerAccess)(server)).projectInfinity$getDimensionProvider();
 					boolean bl = prov.portalKey.isBlank();
 					if (bl) {
-						NeitherPortalBlock.open(s, world, pos, false);
+						NeitherPortalBlock.open(server, world, pos, false);
 						PlayerEntity player = world.getClosestPlayer(pos.getX(), pos.getY(), pos.getZ(), 5, false);
                         if (player != null) {
 							player.increaseStat(ModStats.DIMS_OPENED_STAT, 1);
···
 		}
 	}
 
-	@Redirect(method="getStateForNeighborUpdate(Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/Direction;Lnet/minecraft/block/BlockState;Lnet/minecraft/world/WorldAccess;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/BlockState;isOf(Lnet/minecraft/block/Block;)Z"))
+	@ModifyExpressionValue(method = "createTeleportTarget", at = @At(value = "INVOKE",
+			target = "Lnet/minecraft/server/MinecraftServer;getWorld(Lnet/minecraft/registry/RegistryKey;)Lnet/minecraft/server/world/ServerWorld;"))
+	private @Nullable ServerWorld injected(@Nullable ServerWorld original,
+										   @Local(argsOnly = true) ServerWorld world, @Local(argsOnly = true) BlockPos pos) {
+		if (!world.getBlockState(pos).isOf(ModBlocks.NEITHER_PORTAL)) {
+			if (!world.getRegistryKey().getValue().getNamespace().contains("infinity")) {
+				return original; //when teleportation should not be redirected
+			}
+			return world.getServer().getWorld(World.OVERWORLD); //when we return from another dimension
+		}
+
+		NeitherPortalBlockEntity e = ((NeitherPortalBlockEntity)world.getBlockEntity(pos));
+		if (e==null) return world;
+		long d = e.getDimension();
+
+		RegistryKey<World> key2 = ModCommands.getKey(d, world.getServer());
+		ServerWorld serverWorld2 = world.getServer().getWorld(key2);
+
+		if (serverWorld2 != null && e.getOpen() && ((Timebombable)serverWorld2).projectInfinity$isTimebobmed() == 0) {
+			return serverWorld2;
+		}
+		return world;
+	}
+
+	@Redirect(method="getStateForNeighborUpdate(Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/Direction;Lnet/minecraft/block/BlockState;Lnet/minecraft/world/WorldAccess;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;",
+			at = @At(value = "INVOKE", target = "Lnet/minecraft/block/BlockState;isOf(Lnet/minecraft/block/Block;)Z"))
 	private boolean injected(BlockState neighborState, Block block) {
 		return (neighborState.getBlock() instanceof NetherPortalBlock);
 	}

src/main/java/net/lerariemann/infinity/mixin/PlayerEntityMixin.java

···
-package net.lerariemann.infinity.mixin;
-
-import net.lerariemann.infinity.access.Timebombable;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Optional;
-
-@Mixin(PlayerEntity.class)
-public class PlayerEntityMixin {
-    @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) {
-        if (((Timebombable)world).isTimebobmed() > 0) cir.setReturnValue(Optional.empty());
-    }
-}

src/main/java/net/lerariemann/infinity/mixin/PointOfInterestTypesMixin.java

···
 
 import com.google.common.collect.ImmutableSet;
 import net.lerariemann.infinity.block.ModBlocks;
-import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.registry.Registry;
···
 
 import java.util.HashSet;
 import java.util.Set;
-import java.util.stream.Stream;
 
 @Mixin(PointOfInterestTypes.class)
 public class PointOfInterestTypesMixin {
-    private static Set<BlockState> getAllStatesOf(Block... blocks) {
-        return (Set<BlockState>) Stream.<Block>of(blocks).flatMap(block -> block.getStateManager().getStates().stream()).collect(ImmutableSet.toImmutableSet());
-    }
 
     @Shadow private static PointOfInterestType register(Registry<PointOfInterestType> registry, RegistryKey<PointOfInterestType> key, Set<BlockState> states, int ticketCount, int searchDistance) {
         return null;

src/main/java/net/lerariemann/infinity/mixin/PortalForcerMixin.java

···
 
 import net.lerariemann.infinity.var.ModPoi;
 import net.minecraft.registry.entry.RegistryEntry;
-import net.minecraft.world.PortalForcer;
+import net.minecraft.world.dimension.PortalForcer;
 import net.minecraft.world.poi.PointOfInterestType;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
···
 
 @Mixin(PortalForcer.class)
 public class PortalForcerMixin {
-    @ModifyArg(method = "getPortalRect(Lnet/minecraft/util/math/BlockPos;ZLnet/minecraft/world/border/WorldBorder;)Ljava/util/Optional;",
-    at = @At(value = "INVOKE",
-            target = "Lnet/minecraft/world/poi/PointOfInterestStorage;getInSquare(Ljava/util/function/Predicate;Lnet/minecraft/util/math/BlockPos;ILnet/minecraft/world/poi/PointOfInterestStorage$OccupationStatus;)Ljava/util/stream/Stream;"),
-    index = 0)
-    Predicate<RegistryEntry<PointOfInterestType>> injected(Predicate<RegistryEntry<PointOfInterestType>> typePredicate)
-    {
-        return typePredicate.or(poiType -> (poiType.matchesKey(ModPoi.NEITHER_PORTAL_KEY)));
+    @ModifyArg(method = "getPortalPos", at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/world/poi/PointOfInterestStorage;getInSquare(Ljava/util/function/Predicate;Lnet/minecraft/util/math/BlockPos;ILnet/minecraft/world/poi/PointOfInterestStorage$OccupationStatus;)Ljava/util/stream/Stream;"))
+    Predicate<RegistryEntry<PointOfInterestType>> injected(Predicate<RegistryEntry<PointOfInterestType>> typePredicate) {
+        return typePredicate.or(poiType -> poiType.matchesKey(ModPoi.NEITHER_PORTAL_KEY));
     }
 }

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

···
 package net.lerariemann.infinity.mixin;
 
+import com.llamalad7.mixinextras.sugar.Local;
 import com.mojang.authlib.GameProfile;
-import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.Timebombable;
 import net.lerariemann.infinity.block.custom.NeitherPortalBlock;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.access.ServerPlayerEntityAccess;
-import net.lerariemann.infinity.options.PacketTransiever;
 import net.lerariemann.infinity.var.ModCommands;
 import net.lerariemann.infinity.var.ModCriteria;
+import net.lerariemann.infinity.var.ModPayloads;
 import net.lerariemann.infinity.var.ModStats;
 import net.minecraft.block.Blocks;
 import net.minecraft.entity.Entity;
···
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.PlayerManager;
 import net.minecraft.server.network.ServerPlayNetworkHandler;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.GameMode;
 import net.minecraft.world.TeleportTarget;
 import net.minecraft.world.World;
-import net.minecraft.world.WorldProperties;
 import net.minecraft.world.dimension.DimensionType;
+import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
···
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
 import java.util.HashSet;
+import java.util.Optional;
 import java.util.Set;
 
 @Mixin(ServerPlayerEntity.class)
···
     @Shadow public abstract boolean damage(DamageSource source, float amount);
     @Shadow public boolean notInAnyWorld;
     @Shadow public ServerPlayNetworkHandler networkHandler;
+
+    @Shadow public abstract @Nullable Entity teleportTo(TeleportTarget teleportTarget);
+
     @Unique private long ticksUntilWarp;
     @Unique private long idForWarp;
 
 
-    @Inject(method = "moveToWorld(Lnet/minecraft/server/world/ServerWorld;)Lnet/minecraft/entity/Entity;",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/server/network/ServerPlayerEntity;setServerWorld(Lnet/minecraft/server/world/ServerWorld;)V"),
-            locals = LocalCapture.CAPTURE_FAILHARD)
-    private void injected2(ServerWorld destination, CallbackInfoReturnable<Entity> ci, ServerWorld serverWorld, RegistryKey<World> registryKey,
-                           WorldProperties worldProperties, PlayerManager playerManager, TeleportTarget teleportTarget) {
-        if (((MinecraftServerAccess)(serverWorld.getServer())).getDimensionProvider().rule("returnPortalsEnabled") &&
+    @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) {
+        if (((Timebombable)world).projectInfinity$isTimebobmed() > 0) cir.setReturnValue(Optional.empty());
+    }
+
+    @Inject(method = "teleportTo",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/server/network/ServerPlayerEntity;setServerWorld(Lnet/minecraft/server/world/ServerWorld;)V")
+    )
+    private void injected2(TeleportTarget teleportTarget, CallbackInfoReturnable<Entity> cir, @Local(ordinal = 0) ServerWorld serverWorld, @Local RegistryKey<World> registryKey) {
+        if (((MinecraftServerAccess)(serverWorld.getServer())).projectInfinity$getDimensionProvider().rule("returnPortalsEnabled") &&
                 (registryKey.getValue().getNamespace().equals(InfinityMod.MOD_ID))) {
-            BlockPos pos = BlockPos.ofFloored(teleportTarget.position);
+            BlockPos pos = BlockPos.ofFloored(teleportTarget.pos());
+            ServerWorld destination = teleportTarget.world();
             boolean bl = false;
             for (BlockPos pos2: new BlockPos[] {pos, pos.add(1, 0, 0), pos.add(0, 0, 1),
                     pos.add(-1, 0, 0), pos.add(0, 0, -1)}) if (destination.getBlockState(pos2).isOf(Blocks.NETHER_PORTAL)) {
···
         }
     }
 
-    @Inject(method = "moveToWorld(Lnet/minecraft/server/world/ServerWorld;)Lnet/minecraft/entity/Entity;",
+    @Inject(method = "teleportTo",
             at = @At(value = "INVOKE", target = "Lnet/minecraft/server/MinecraftServer;getPlayerManager()Lnet/minecraft/server/PlayerManager;"))
-    private void injected3(ServerWorld destination, CallbackInfoReturnable<Entity> cir) {
-        ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), InfinityMod.SHADER_RELOAD,
-                PacketTransiever.buildPacket(destination));
-        ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), InfinityMod.STARS_RELOAD, PacketByteBufs.create());
+    private void injected3(TeleportTarget teleportTarget, CallbackInfoReturnable<Entity> cir) {
+        ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), ModPayloads.setShaderFromWorld(teleportTarget.world()));
+        ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), ModPayloads.StarsRePayLoad.INSTANCE);
     }
 
     @Inject(method = "tick", at = @At("TAIL"))
···
             BlockPos blockPos2 = w.getWorldBorder().clamp(self.getX() * d, self.getY(), self.getZ() * d);
             this.teleport(w, blockPos2.getX(), blockPos2.getY(), blockPos2.getZ(), new HashSet<>(), self.getYaw(), self.getPitch());
         }
-        int i = ((Timebombable)(getServerWorld())).isTimebobmed();
+        int i = ((Timebombable)(getServerWorld())).projectInfinity$isTimebobmed();
         if (i > 200) {
             if (i%4 == 0) {
                 Registry<DamageType> r = getServerWorld().getServer().getRegistryManager().get(RegistryKeys.DAMAGE_TYPE);
                 RegistryEntry<DamageType> entry = r.getEntry(r.get(InfinityMod.getId("world_ceased")));
                 damage(new DamageSource(entry), i > 400 ? 2.0f : 1.0f);
             }
-            if (i > 3500) ModCriteria.HE_WHO_REMAINS.trigger((ServerPlayerEntity)(Object)this);
+            if (i > 3500) {
+                ModCriteria.WHO_REMAINS.trigger((ServerPlayerEntity)(Object)this);
+            }
             if (i > 3540) {
                 this.detach();
                 this.getServerWorld().removePlayer((ServerPlayerEntity)(Object)this, Entity.RemovalReason.CHANGED_DIMENSION);
···
 
     @Inject(method = "changeGameMode", at = @At("RETURN"))
     private void injected4(GameMode gameMode, CallbackInfoReturnable<Boolean> cir) {
-        if (cir.getReturnValue()) ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), InfinityMod.SHADER_RELOAD, PacketTransiever.buildPacket(this.getServerWorld()));
+        if (cir.getReturnValue()) ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), ModPayloads.setShaderFromWorld(this.getServerWorld()));
     }
 
-    @Inject(method= "teleport(Lnet/minecraft/server/world/ServerWorld;DDDFF)V", at = @At(value="INVOKE", target ="Lnet/minecraft/server/PlayerManager;sendCommandTree(Lnet/minecraft/server/network/ServerPlayerEntity;)V"))
-    private void injected5(ServerWorld targetWorld, double x, double y, double z, float yaw, float pitch, CallbackInfo ci) {
-        ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), InfinityMod.SHADER_RELOAD, PacketTransiever.buildPacket(targetWorld));
-        ServerPlayNetworking.send(((ServerPlayerEntity)(Object)this), InfinityMod.STARS_RELOAD, PacketByteBufs.create());
-    }
-
-
     @Override
-    public void setWarpTimer(long ticks, long dim) {
+    public void projectInfinity$setWarpTimer(long ticks, long dim) {
         this.ticksUntilWarp = ticks;
         this.idForWarp = dim;
     }

src/main/java/net/lerariemann/infinity/mixin/SlimeEntityMixin.java

···
 package net.lerariemann.infinity.mixin;
 
-import com.llamalad7.mixinextras.sugar.Local;
 import net.lerariemann.infinity.entity.custom.DimensionalSlime;
-import net.minecraft.entity.Entity;
 import net.minecraft.entity.mob.SlimeEntity;
 import org.spongepowered.asm.mixin.Mixin;
 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.Redirect;
 
 import static net.lerariemann.infinity.entity.custom.DimensionalSlime.color;
 
 @Mixin(SlimeEntity.class)
 public class SlimeEntityMixin {
-    @Inject(method = "remove(Lnet/minecraft/entity/Entity$RemovalReason;)V", at = @At(value = "INVOKE",
+    @Redirect(method = "remove(Lnet/minecraft/entity/Entity$RemovalReason;)V", at = @At(value = "INVOKE",
             target = "Lnet/minecraft/entity/mob/SlimeEntity;setAiDisabled(Z)V"))
-    private void injected(Entity.RemovalReason reason, CallbackInfo ci, @Local SlimeEntity slimeEntity) {
+    private void injected(SlimeEntity instance, boolean b) {
+        instance.setAiDisabled(b);
         SlimeEntity e = ((SlimeEntity)(Object)(this));
-        if (((SlimeEntity)(Object)(this)) instanceof DimensionalSlime) {
-            DimensionalSlime slime_mom = (DimensionalSlime)e;
-            DimensionalSlime slime_son = (DimensionalSlime)slimeEntity;
+        if (e instanceof DimensionalSlime slime_mom) {
+            DimensionalSlime slime_son = (DimensionalSlime)instance;
             slime_son.setCore(slime_mom.getCore());
             slime_son.setColor(slime_mom.getDataTracker().get(color));
         }

src/main/java/net/lerariemann/infinity/mixin/mavity/BoatEntityMixin.java

···
-package net.lerariemann.infinity.mixin.mavity;
-
-import net.lerariemann.infinity.access.MavityInterface;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityType;
-import net.minecraft.entity.vehicle.BoatEntity;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
-
-@Mixin(BoatEntity.class)
-public abstract class BoatEntityMixin extends Entity implements MavityInterface {
-    public BoatEntityMixin(EntityType<?> type, World world) {
-        super(type, world);
-    }
-
-    @ModifyVariable(method="updateVelocity", at=@At("STORE"), ordinal=1)
-    double inj(double constant) {
-        return constant * (this.hasNoGravity() ? 0.0 : getMavity());
-    }
-}

src/main/java/net/lerariemann/infinity/mixin/mavity/LivingEntityMixin.java

···
-package net.lerariemann.infinity.mixin.mavity;
-
-import net.lerariemann.infinity.access.MavityInterface;
-import net.minecraft.entity.Attackable;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityType;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Constant;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.ModifyConstant;
-
-@Mixin(LivingEntity.class)
-public abstract class LivingEntityMixin extends Entity implements Attackable, MavityInterface {
-    public LivingEntityMixin(EntityType<?> type, World world) {
-        super(type, world);
-    }
-
-    @ModifyArg(method = "computeFallDamage", at = @At(value="INVOKE", target="Lnet/minecraft/util/math/MathHelper;ceil(F)I"))
-    float injected(float value) {
-        return (float)getMavity() * value;
-    }
-
-    @ModifyConstant(method = "travel", constant = @Constant(doubleValue = 0.08))
-    double inj2(double value) {
-        return value*getMavity();
-    }
-
-    @ModifyConstant(method = "travel", constant = @Constant(doubleValue = 0.01))
-    double inj3(double value) {
-        return value*getMavity();
-    }
-}

src/main/java/net/lerariemann/infinity/mixin/mavity/PersistentProjectileEntityMixin.java

···
-package net.lerariemann.infinity.mixin.mavity;
-
-import net.lerariemann.infinity.access.MavityInterface;
-import net.minecraft.entity.EntityType;
-import net.minecraft.entity.projectile.PersistentProjectileEntity;
-import net.minecraft.entity.projectile.ProjectileEntity;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-
-@Mixin(PersistentProjectileEntity.class)
-public abstract class PersistentProjectileEntityMixin extends ProjectileEntity implements MavityInterface {
-    public PersistentProjectileEntityMixin(EntityType<? extends ProjectileEntity> entityType, World world) {
-        super(entityType, world);
-    }
-
-    @ModifyArg(method = "tick", at = @At(value="INVOKE", target="Lnet/minecraft/entity/projectile/PersistentProjectileEntity;setVelocity(DDD)V"), index = 1)
-    double injected(double x) {
-        return x - 0.05 * (getMavity() - 1);
-    }
-}

src/main/java/net/lerariemann/infinity/mixin/mavity/SeveralEntitiesMixin.java

···
-package net.lerariemann.infinity.mixin.mavity;
-
-import net.lerariemann.infinity.access.MavityInterface;
-import net.minecraft.entity.*;
-import net.minecraft.entity.projectile.LlamaSpitEntity;
-import net.minecraft.entity.vehicle.AbstractMinecartEntity;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-
-@Mixin({FallingBlockEntity.class, TntEntity.class, ItemEntity.class, ExperienceOrbEntity.class, AbstractMinecartEntity.class, LlamaSpitEntity.class})
-public abstract class SeveralEntitiesMixin extends Entity implements MavityInterface {
-    public SeveralEntitiesMixin(EntityType<?> type, World world) {
-        super(type, world);
-    }
-
-    @ModifyArg(method = "tick", at = @At(value="INVOKE", target="Lnet/minecraft/util/math/Vec3d;add(DDD)Lnet/minecraft/util/math/Vec3d;"), index = 1)
-    double injected(double x) {
-        return getMavity() * x;
-    }
-}

src/main/java/net/lerariemann/infinity/mixin/mavity/ThrownEntityMixin.java

···
-package net.lerariemann.infinity.mixin.mavity;
-
-import net.lerariemann.infinity.access.MavityInterface;
-import net.minecraft.entity.EntityType;
-import net.minecraft.entity.projectile.ProjectileEntity;
-import net.minecraft.entity.projectile.thrown.ThrownEntity;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(ThrownEntity.class)
-public abstract class ThrownEntityMixin extends ProjectileEntity implements MavityInterface {
-    @Shadow protected abstract float getGravity();
-
-    public ThrownEntityMixin(EntityType<? extends ProjectileEntity> entityType, World world) {
-        super(entityType, world);
-    }
-
-    @Redirect(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/projectile/thrown/ThrownEntity;getGravity()F"))
-    protected float getGravity(ThrownEntity instance) {
-        return (float)getMavity() * getGravity();
-    }
-}

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

···
 import net.minecraft.entity.EntityData;
 import net.minecraft.entity.SpawnReason;
 import net.minecraft.entity.passive.SheepEntity;
-import net.minecraft.nbt.NbtCompound;
 import net.minecraft.util.DyeColor;
 import net.minecraft.world.LocalDifficulty;
 import net.minecraft.world.ServerWorldAccess;
···
     @Shadow public abstract void setColor(DyeColor color);
 
     @Inject(method = "initialize", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/passive/SheepEntity;setColor(Lnet/minecraft/util/DyeColor;)V", shift = At.Shift.AFTER))
-    private void injected(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, EntityData entityData, NbtCompound entityNbt, CallbackInfoReturnable<EntityData> cir) {
+    private void injected(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, EntityData entityData, CallbackInfoReturnable<EntityData> cir) {
         if (world.toServerWorld().getRegistryKey().getValue().toString().contains("infinity:classic")) {
             setColor(DyeColor.WHITE);
         }

src/main/java/net/lerariemann/infinity/mixin/options/ClientWorldMixin.java

···
     @Inject(method = "<init>", at = @At("TAIL"))
     private void injected(ClientPlayNetworkHandler networkHandler, ClientWorld.Properties properties, RegistryKey<World> registryRef, RegistryEntry<DimensionType> dimensionTypeEntry, int loadDistance, int simulationDistance, Supplier<Profiler> profiler, WorldRenderer worldRenderer, boolean debugWorld, long seed, CallbackInfo ci) {
         DimensionType t = getDimension();
-        infinityoptions = ((InfinityOptionsAccess)MinecraftClient.getInstance()).getInfinityOptions();
-        ((InfinityOptionsAccess)(Object)t).setInfinityOptions(infinityoptions);
+        infinityoptions = ((InfinityOptionsAccess)MinecraftClient.getInstance()).projectInfinity$getInfinityOptions();
+        ((InfinityOptionsAccess)(Object)t).projectInfinity$setInfinityOptions(infinityoptions);
     }
 
     @Override
-    public InfinityOptions getInfinityOptions() {
+    public InfinityOptions projectInfinity$getInfinityOptions() {
         return infinityoptions;
     }
     @Override
-    public void setInfinityOptions(InfinityOptions options) {
+    public void projectInfinity$setInfinityOptions(InfinityOptions options) {
         infinityoptions = options;
     }
 }

src/main/java/net/lerariemann/infinity/mixin/options/DimensionTypeMixin.java

···
     @ModifyArg(method = "getSkyAngle", at = @At(value="INVOKE", target="Lnet/minecraft/util/math/MathHelper;fractionalPart(D)D"), index = 0)
     private double injected(double value) {
         try {
-            double timescale = getInfinityOptions().getTimeScale();
+            double timescale = projectInfinity$getInfinityOptions().getTimeScale();
             return timescale*(value + 0.25) - 0.25;
         } catch (Exception e) {
             return value;
         }
     }
-    public InfinityOptions getInfinityOptions() {
+    public InfinityOptions projectInfinity$getInfinityOptions() {
         return infinityoptions;
     }
     @Override
-    public void setInfinityOptions(InfinityOptions options) {
+    public void projectInfinity$setInfinityOptions(InfinityOptions options) {
         infinityoptions = options;
     }
 }

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

···
 
 @Mixin(GameRenderer.class)
 public class GameRendererMixin implements GameRendererAccess {
-    @Shadow void loadPostProcessor(Identifier id) {
+    @Shadow
+    private void loadPostProcessor(Identifier id) {
     }
 
     @Override
-    public void loadPP(Identifier id) {
+    public void projectInfinity$loadPP(Identifier id) {
         loadPostProcessor(id);
     }
 
     @Inject(method = "onCameraEntitySet", at = @At("TAIL"), cancellable = true)
     private void preserveShaderThirdPerson(CallbackInfo ci) {
-        InfinityOptions options = ((InfinityOptionsAccess)MinecraftClient.getInstance()).getInfinityOptions();
+        InfinityOptions options = ((InfinityOptionsAccess)MinecraftClient.getInstance()).projectInfinity$getInfinityOptions();
         if (options.getShader().isEmpty()) {
             ci.cancel();
         }

src/main/java/net/lerariemann/infinity/mixin/options/MinecraftClientMixin.java

···
     }
 
     @Unique
-    public InfinityOptions getInfinityOptions() {
+    public InfinityOptions projectInfinity$getInfinityOptions() {
         return infinityoptions;
     }
 
     @Unique
-    public void setInfinityOptions(InfinityOptions options) {
+    public void projectInfinity$setInfinityOptions(InfinityOptions options) {
         infinityoptions = options;
     }
 }

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

···
 package net.lerariemann.infinity.mixin.options;
 
 import com.llamalad7.mixinextras.sugar.Local;
-import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
-import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.block.ModBlocks;
 import net.lerariemann.infinity.block.entity.ModBlockEntities;
-import net.lerariemann.infinity.options.PacketTransiever;
+import net.lerariemann.infinity.var.ModPayloads;
 import net.minecraft.block.BlockState;
 import net.minecraft.network.ClientConnection;
 import net.minecraft.server.PlayerManager;
+import net.minecraft.server.network.ConnectedClientData;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
···
 public class PlayerManagerMixin {
     @Inject(method = "onPlayerConnect", at = @At(value="INVOKE",
             target = "Lnet/minecraft/server/PlayerManager;sendCommandTree(Lnet/minecraft/server/network/ServerPlayerEntity;)V"))
-    private void injected(ClientConnection connection, ServerPlayerEntity player, CallbackInfo ci, @Local(ordinal=0) ServerWorld serverWorld2) {
-        ServerPlayNetworking.send(player, InfinityMod.SHADER_RELOAD, PacketTransiever.buildPacket(serverWorld2));
-        ServerPlayNetworking.send(player, InfinityMod.STARS_RELOAD, PacketByteBufs.create());
+    private void injected(ClientConnection connection, ServerPlayerEntity player, ConnectedClientData clientData, CallbackInfo ci, @Local(ordinal=0) ServerWorld serverWorld2) {
+        ServerPlayNetworking.send(player, ModPayloads.setShaderFromWorld(serverWorld2));
+        ServerPlayNetworking.send(player, ModPayloads.StarsRePayLoad.INSTANCE);
         MinecraftServerAccess acc = ((MinecraftServerAccess)(serverWorld2.getServer()));
-        if (acc.needsInvocation()) {
+        if (acc.projectInfinity$needsInvocation()) {
             int y = serverWorld2.getTopY() - 10;
             BlockPos pos = new BlockPos(player.getBlockX(), y, player.getBlockY());
             BlockState st = serverWorld2.getBlockState(pos);
             serverWorld2.setBlockState(pos, ModBlocks.ALTAR_COSMIC.getDefaultState());
             serverWorld2.getBlockEntity(pos, ModBlockEntities.ALTAR_COSMIC).ifPresent(e -> e.addNull(st));
-            acc.onInvocation();
+            acc.projectInfinity$onInvocation();
         }
     }
 
     @Inject(method="sendWorldInfo", at = @At("TAIL"))
     private void injected2(ServerPlayerEntity player, ServerWorld world, CallbackInfo ci) {
-        ServerPlayNetworking.send(player, InfinityMod.SHADER_RELOAD, PacketTransiever.buildPacket(world));
-        ServerPlayNetworking.send(player, InfinityMod.STARS_RELOAD, PacketByteBufs.create());
+        ServerPlayNetworking.send(player, ModPayloads.setShaderFromWorld(world));
+        ServerPlayNetworking.send(player, ModPayloads.StarsRePayLoad.INSTANCE);
     }
 }

src/main/java/net/lerariemann/infinity/mixin/options/ServerWorldMixin.java

···
 import net.minecraft.world.dimension.DimensionType;
 import net.minecraft.world.level.ServerWorldProperties;
 import net.minecraft.world.level.storage.LevelStorage;
-import net.minecraft.world.spawner.Spawner;
+import net.minecraft.world.spawner.SpecialSpawner;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
···
     }
 
     @Inject(method = "<init>", at = @At("TAIL"))
-    private void injected(MinecraftServer server, Executor workerExecutor, LevelStorage.Session session, ServerWorldProperties properties, RegistryKey<World> worldKey, DimensionOptions dimensionOptions, WorldGenerationProgressListener worldGenerationProgressListener, boolean debugWorld, long seed, List<Spawner> spawners, boolean shouldTickTime, RandomSequencesState randomSequencesState, CallbackInfo ci) {
+    private void injected(MinecraftServer server, Executor workerExecutor, LevelStorage.Session session, ServerWorldProperties properties, RegistryKey<World> worldKey, DimensionOptions dimensionOptions, WorldGenerationProgressListener worldGenerationProgressListener, boolean debugWorld, long seed, List<SpecialSpawner> spawners, boolean shouldTickTime, RandomSequencesState randomSequencesState, CallbackInfo ci) {
         infinityoptions = InfinityOptions.generate(server, worldKey);
         DimensionType t = getDimension();
-        ((InfinityOptionsAccess)(Object)t).setInfinityOptions(infinityoptions);
+        ((InfinityOptionsAccess)(Object)t).projectInfinity$setInfinityOptions(infinityoptions);
         timebombed = 0;
     }
 
···
     }
 
     @Override
-    public void timebomb(int i) {
+    public void projectInfinity$timebomb(int i) {
         if(getRegistryKey().getValue().toString().contains("infinity")) timebombed = i;
     }
 
     @Override
-    public int isTimebobmed() {
+    public int projectInfinity$isTimebobmed() {
         return timebombed;
     }
 
     @Override
-    public InfinityOptions getInfinityOptions() {
+    public InfinityOptions projectInfinity$getInfinityOptions() {
         return infinityoptions;
     }
     @Override
-    public void setInfinityOptions(InfinityOptions options) {
+    public void projectInfinity$setInfinityOptions(InfinityOptions options) {
         infinityoptions = options;
     }
 }

src/main/java/net/lerariemann/infinity/mixin/options/WorldRendererMixin.java

···
 import com.mojang.blaze3d.systems.RenderSystem;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
+import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.InfinityOptionsAccess;
 import net.lerariemann.infinity.access.WorldRendererAccess;
 import net.lerariemann.infinity.options.InfinityOptions;
+import net.minecraft.block.enums.CameraSubmersionType;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gl.VertexBuffer;
 import net.minecraft.client.render.*;
···
         }
     }
     @Override
-    public void setNeedsStars(boolean b) {
+    public void projectInfinity$setNeedsStars(boolean b) {
         needsStars = b;
     }
 
-    @Inject(method = "renderSky(Lnet/minecraft/client/util/math/MatrixStack;Lorg/joml/Matrix4f;FLnet/minecraft/client/render/Camera;ZLjava/lang/Runnable;)V",
+    @Inject(method = "renderSky(Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;FLnet/minecraft/client/render/Camera;ZLjava/lang/Runnable;)V",
             at=@At("HEAD"), cancellable=true)
-    private void injected4(MatrixStack matrices, Matrix4f projectionMatrix, float tickDelta, Camera camera, boolean thickFog, Runnable fogCallback, CallbackInfo ci) {
+    private void injected4(Matrix4f matrix4f, Matrix4f projectionMatrix, float tickDelta, Camera camera, boolean thickFog, Runnable fogCallback, CallbackInfo ci) {
         if (!options().isEmpty()) {
-            renderEntireSky(matrices, projectionMatrix, tickDelta, camera, thickFog, fogCallback);
+            renderEntireSky(matrix4f, projectionMatrix, tickDelta, camera, thickFog, fogCallback);
             ci.cancel();
         }
     }
-    @ModifyConstant(method = "renderStars(Lnet/minecraft/client/render/BufferBuilder;)Lnet/minecraft/client/render/BufferBuilder$BuiltBuffer;", constant = @Constant(intValue = 1500))
+    @ModifyConstant(method = "buildStarsBuffer(Lnet/minecraft/client/render/Tessellator;)Lnet/minecraft/client/render/BuiltBuffer;", constant = @Constant(intValue = 1500))
     private int injected(int constant) {
         return options().getNumStars();
     }
-    @ModifyConstant(method = "renderStars(Lnet/minecraft/client/render/BufferBuilder;)Lnet/minecraft/client/render/BufferBuilder$BuiltBuffer;", constant = @Constant(floatValue = 0.15f))
+    @ModifyConstant(method = "buildStarsBuffer(Lnet/minecraft/client/render/Tessellator;)Lnet/minecraft/client/render/BuiltBuffer;", constant = @Constant(floatValue = 0.15f))
     private float injected2(float constant) {
         return options().getStarSizeBase();
     }
-    @ModifyConstant(method = "renderStars(Lnet/minecraft/client/render/BufferBuilder;)Lnet/minecraft/client/render/BufferBuilder$BuiltBuffer;", constant = @Constant(floatValue = 0.1f))
+    @ModifyConstant(method = "buildStarsBuffer(Lnet/minecraft/client/render/Tessellator;)Lnet/minecraft/client/render/BuiltBuffer;", constant = @Constant(floatValue = 0.1f))
     private float injected3(float constant) {
         return options().getStarSizeModifier();
     }
 
     @Unique
-    private void renderEntireSky(MatrixStack matrices, Matrix4f projectionMatrix, float tickDelta, Camera camera, boolean thickFog, Runnable fogCallback) {
+    private void renderEntireSky(Matrix4f matrix4f, Matrix4f projectionMatrix, float tickDelta, Camera camera, boolean thickFog, Runnable fogCallback) {
         fogCallback.run();
         if (thickFog) {
             return;
···
         if (cameraSubmersionType == CameraSubmersionType.POWDER_SNOW || cameraSubmersionType == CameraSubmersionType.LAVA || hasBlindnessOrDarkness(camera)) {
             return;
         }
+        MatrixStack matrices = new MatrixStack();
+        matrices.multiplyPositionMatrix(matrix4f);
         if (client.world!=null && client.world.getDimensionEffects().getSkyType() == DimensionEffects.SkyType.END) {
-            this.renderCustomSky(matrices, new Identifier("textures/environment/end_sky.png"), 16.0f, 40, 255, tickDelta, false);
+            this.renderCustomSky(matrices, Identifier.of("textures/environment/end_sky.png"), 16.0f, 40, 255, tickDelta, false);
             return;
         }
         if (options().endSkyLike()) {
···
             return;
         }
 
-        BackgroundRenderer.setFogBlack();
-        BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
+        BackgroundRenderer.applyFogColor();
+        Tessellator tessellator = Tessellator.getInstance();
         RenderSystem.depthMask(false);
         handleSkyBackground(matrices, projectionMatrix, tickDelta);
-        handleFog(matrices, bufferBuilder, tickDelta);
+        handleFog(matrices, tessellator, tickDelta);
         matrices.push();
 
         float rain_alpha = 1.0f - this.world.getRainGradient(tickDelta);
···
         rotate_with_velocity(matrices, tickDelta, 1);
         Matrix4f matrix4f2 = matrices.peek().getPositionMatrix(); //creates the rotating layer for stellar bodies
 
-        renderSun(bufferBuilder, matrix4f2, options().getSolarTexture(), options().getSolarSize(), 100.0f, options().getSolarTint());
+        renderSun(tessellator, matrix4f2, options().getSolarTexture(), options().getSolarSize(), 100.0f, options().getSolarTint());
         for (int i = 0; i < options().getNumMoons(); i++) {
-            renderSingleMoon(matrices, bufferBuilder, tickDelta, options().getLunarSize(i), options().getLunarTiltY(i), options().getLunarTiltZ(i),
+            renderSingleMoon(matrices, tessellator, tickDelta, options().getLunarSize(i), options().getLunarTiltY(i), options().getLunarTiltZ(i),
                     options().getLunarVelocity(i), options().getLunarOffset(i), options().getLunarTint(i), options().getLunarTexture(i));
         }
         testRerenderStars();
···
             }
             boolean color = !options().endSkyLike();
             if (skyType.contains("textures")) {
-                renderCustomSky(matrices, new Identifier(skyType), tickDelta, color);
+                renderCustomSky(matrices, Identifier.of(skyType), tickDelta, color);
             }
             else if (skyType.equals("LSD_rainbow")) {
                 renderLSDSky(matrices, tickDelta, color);
···
     }
 
     @Unique
-    private void renderSun(BufferBuilder bufferBuilder, Matrix4f matrix4f2, Identifier texture, float k, float y, Vector3f tint) {
+    private void renderSun(Tessellator tessellator, Matrix4f matrix4f2, Identifier texture, float k, float y, Vector3f tint) {
         RenderSystem.setShader(GameRenderer::getPositionTexProgram);
         RenderSystem.setShaderTexture(0, texture);
         RenderSystem.setShaderColor(tint.x, tint.y, tint.z, 1.0f);
-        bufferBuilder.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE);
-        bufferBuilder.vertex(matrix4f2, -k, y, -k).texture(0.0f, 0.0f).next();
-        bufferBuilder.vertex(matrix4f2, k, y, -k).texture(1.0f, 0.0f).next();
-        bufferBuilder.vertex(matrix4f2, k, y, k).texture(1.0f, 1.0f).next();
-        bufferBuilder.vertex(matrix4f2, -k, y, k).texture(0.0f, 1.0f).next();
+        BufferBuilder bufferBuilder = tessellator.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE);
+        bufferBuilder.vertex(matrix4f2, -k, y, -k).texture(0.0f, 0.0f);
+        bufferBuilder.vertex(matrix4f2, k, y, -k).texture(1.0f, 0.0f);
+        bufferBuilder.vertex(matrix4f2, k, y, k).texture(1.0f, 1.0f);
+        bufferBuilder.vertex(matrix4f2, -k, y, k).texture(0.0f, 1.0f);
         BufferRenderer.drawWithGlobalProgram(bufferBuilder.end());
     }
 
     @Unique
-    private void renderSingleMoon(MatrixStack matrices, BufferBuilder bufferBuilder, float tickDelta, float size, float tilt_y, float tilt_z, float velocity, float offset, Vector3f tint, Identifier texture) {
+    private void renderSingleMoon(MatrixStack matrices, Tessellator tessellator, float tickDelta, float size, float tilt_y, float tilt_z, float velocity, float offset, Vector3f tint, Identifier texture) {
         float lunarv = (velocity != 1.0f) ? velocity - 1 : 0;
         matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(tilt_y));
         matrices.multiply(RotationAxis.POSITIVE_Z.rotationDegrees(tilt_z));
         rotate_with_velocity(matrices, tickDelta, lunarv, offset);
-        renderMoon(bufferBuilder, matrices.peek().getPositionMatrix(), texture, size, -100.0f, tint);
+        renderMoon(tessellator, matrices.peek().getPositionMatrix(), texture, size, -100.0f, tint);
         rotate_with_velocity(matrices, tickDelta, -1 * lunarv, offset);
         matrices.multiply(RotationAxis.POSITIVE_Z.rotationDegrees(-tilt_z));
         matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(-tilt_y));
     }
-
     @Unique
-    private void renderMoon(BufferBuilder bufferBuilder, Matrix4f matrix4f2, Identifier texture, float k, float y, Vector3f tint, float t, float q, float p, float o) {
-        RenderSystem.setShader(GameRenderer::getPositionTexProgram);
-        RenderSystem.setShaderTexture(0, texture);
-        RenderSystem.setShaderColor(tint.x, tint.y, tint.z, 1.0f);
-        bufferBuilder.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE);
-        bufferBuilder.vertex(matrix4f2, -k, y, k).texture(p, q).next();
-        bufferBuilder.vertex(matrix4f2, k, y, k).texture(t, q).next();
-        bufferBuilder.vertex(matrix4f2, k, y, -k).texture(t, o).next();
-        bufferBuilder.vertex(matrix4f2, -k, y, -k).texture(p, o).next();
-        BufferRenderer.drawWithGlobalProgram(bufferBuilder.end());
-    }
-    @Unique
-    private void renderMoon(BufferBuilder bufferBuilder, Matrix4f matrix4f2, Identifier texture, float k, float y, Vector3f tint) {
+    private void renderMoon(Tessellator tessellator, Matrix4f matrix4f2, Identifier texture, float k, float y, Vector3f tint) {
         float t, q, p, o;
         if (!options().isMoonCustom()) {
             int r = this.world.getMoonPhase();
···
             t = q = 1.0f;
             p = o = 0.0f;
         }
-        renderMoon(bufferBuilder, matrix4f2, texture, k, y, tint, t, q, p, o);
+        renderMoon(tessellator, matrix4f2, texture, k, y, tint, t, q, p, o);
+    }
+    @Unique
+    private void renderMoon(Tessellator tessellator, Matrix4f matrix4f2, Identifier texture, float k, float y, Vector3f tint, float t, float q, float p, float o) {
+        RenderSystem.setShader(GameRenderer::getPositionTexProgram);
+        RenderSystem.setShaderTexture(0, texture);
+        RenderSystem.setShaderColor(tint.x, tint.y, tint.z, 1.0f);
+        BufferBuilder bufferBuilder = tessellator.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE);
+        bufferBuilder.vertex(matrix4f2, -k, y, k).texture(p, q);
+        bufferBuilder.vertex(matrix4f2, k, y, k).texture(t, q);
+        bufferBuilder.vertex(matrix4f2, k, y, -k).texture(t, o);
+        bufferBuilder.vertex(matrix4f2, -k, y, -k).texture(p, o);
+        BufferRenderer.drawWithGlobalProgram(bufferBuilder.end());
     }
 
     @Unique
     private void renderStars(Matrix4f matrix4f2, float tickDelta, Matrix4f projectionMatrix, Runnable fogCallback, float i) {
-        float u = world.method_23787(tickDelta) * i;
+        float u = world.getStarBrightness(tickDelta) * i;
         Vector3f color = options().getStellarColor();
         if (u > 0.0f) {
             RenderSystem.setShaderColor(u*color.x, u*color.y, u*color.z, u);
···
 
     @Unique
     private InfinityOptions options() {
-        InfinityOptions options = ((InfinityOptionsAccess)client).getInfinityOptions();
+        InfinityOptions options = ((InfinityOptionsAccess)client).projectInfinity$getInfinityOptions();
         if (options == null) options = InfinityOptions.empty();
         return options;
     }
···
         renderSingleColorSky(matrices, projectionMatrix, f * (float)(color >> 16 & 0xFF) / 255.0f, f * (float)(color >> 8 & 0xFF) / 255.0f, f * (float)(color & 0xFF) / 255.0f, 1.0f);
     }
     @Unique
-    private static final Identifier[] LSD_SKY = new Identifier[]{new Identifier("infinity:textures/lsd.png"),
-            new Identifier("infinity:textures/lsd60.png"),
-            new Identifier("infinity:textures/lsd120.png"),
-            new Identifier("infinity:textures/lsd180.png"),
-            new Identifier("infinity:textures/lsd240.png"),
-            new Identifier("infinity:textures/lsd300.png")};
+    private static final Identifier[] LSD_SKY = new Identifier[]{InfinityMod.getId("textures/lsd.png"),
+            InfinityMod.getId("textures/lsd60.png"),
+            InfinityMod.getId("textures/lsd120.png"),
+            InfinityMod.getId("textures/lsd180.png"),
+            InfinityMod.getId("textures/lsd240.png"),
+            InfinityMod.getId("textures/lsd300.png")};
 
     @Unique
     private void renderLSDSky(MatrixStack matrices, float tickDelta, boolean color) {
···
         }
         RenderSystem.setShaderTexture(0, texture);
         Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
+
         for (int i = 0; i < 6; ++i) {
             matrices.push();
             if (i == 1) {
···
             if (i == 5) {
                 matrices.multiply(RotationAxis.POSITIVE_Z.rotationDegrees(-90.0f));
             }
+
             Matrix4f matrix4f = matrices.peek().getPositionMatrix();
-            bufferBuilder.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);
-            bufferBuilder.vertex(matrix4f, -100.0f, -100.0f, -100.0f).texture(0.0f, 0.0f).color(r, g, b, alpha).next();
-            bufferBuilder.vertex(matrix4f, -100.0f, -100.0f, 100.0f).texture(0.0f, copies).color(r, g, b, alpha).next();
-            bufferBuilder.vertex(matrix4f, 100.0f, -100.0f, 100.0f).texture(copies, copies).color(r, g, b, alpha).next();
-            bufferBuilder.vertex(matrix4f, 100.0f, -100.0f, -100.0f).texture(copies, 0.0f).color(r, g, b, alpha).next();
-            tessellator.draw();
+            BufferBuilder bufferBuilder = tessellator.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);
+            bufferBuilder.vertex(matrix4f, -100.0f, -100.0f, -100.0f).texture(0.0f, 0.0f).color(r, g, b, alpha);
+            bufferBuilder.vertex(matrix4f, -100.0f, -100.0f, 100.0f).texture(0.0f, copies).color(r, g, b, alpha);
+            bufferBuilder.vertex(matrix4f, 100.0f, -100.0f, 100.0f).texture(copies, copies).color(r, g, b, alpha);
+            bufferBuilder.vertex(matrix4f, 100.0f, -100.0f, -100.0f).texture(copies, 0.0f).color(r, g, b, alpha);
+            BufferRenderer.drawWithGlobalProgram(bufferBuilder.end());
             matrices.pop();
         }
         RenderSystem.depthMask(true);
···
     }
 
     @Unique
-    private void handleFog(MatrixStack matrices, BufferBuilder bufferBuilder, float tickDelta) {
+    private void handleFog(MatrixStack matrices, Tessellator tessellator, float tickDelta) {
         RenderSystem.enableBlend();
         float[] fs = this.world.getDimensionEffects().getFogColorOverride(this.world.getSkyAngle(tickDelta), tickDelta);
         if (fs != null) {
···
             float k = fs[1];
             float l = fs[2];
             Matrix4f matrix4f = matrices.peek().getPositionMatrix();
-            bufferBuilder.begin(VertexFormat.DrawMode.TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
-            bufferBuilder.vertex(matrix4f, 0.0f, 100.0f, 0.0f).color(j, k, l, fs[3]).next();
+            BufferBuilder bufferBuilder = tessellator.begin(VertexFormat.DrawMode.TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
+            bufferBuilder.vertex(matrix4f, 0.0f, 100.0f, 0.0f).color(j, k, l, fs[3]);
             for (int n = 0; n <= 16; ++n) {
                 float o = (float)n * ((float)Math.PI * 2) / 16.0f;
                 float p = MathHelper.sin(o);
                 float q = MathHelper.cos(o);
-                bufferBuilder.vertex(matrix4f, p * 120.0f, q * 120.0f, -q * 40.0f * fs[3]).color(fs[0], fs[1], fs[2], 0.0f).next();
+                bufferBuilder.vertex(matrix4f, p * 120.0f, q * 120.0f, -q * 40.0f * fs[3]).color(fs[0], fs[1], fs[2], 0.0f);
             }
             BufferRenderer.drawWithGlobalProgram(bufferBuilder.end());
             matrices.pop();

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

···
     }
 
     public Identifier getSolarTexture() {
-        return new Identifier(data.contains("solar_texture") ? data.getString("solar_texture") : "textures/environment/sun.png");
+        return Identifier.of(data.contains("solar_texture") ? data.getString("solar_texture") : "textures/environment/sun.png");
     }
 
     public Vector3f getStellarColor() {
···
     }
 
     public Identifier getLunarTexture(int i) {
-        return new Identifier(lunarTest("lunar_texture", i) ?
+        return Identifier.of(lunarTest("lunar_texture", i) ?
                 ((NbtCompound)(data.getList("moons", NbtElement.COMPOUND_TYPE).get(i))).getString("lunar_texture") : "textures/environment/moon_phases.png");
     }
 

src/main/java/net/lerariemann/infinity/options/PacketTransiever.java

···
-package net.lerariemann.infinity.options;
-
-import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
-import net.fabricmc.fabric.api.networking.v1.PacketSender;
-import net.lerariemann.infinity.access.InfinityOptionsAccess;
-import net.lerariemann.infinity.access.WorldRendererAccess;
-import net.lerariemann.infinity.util.CommonIO;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.network.ClientPlayNetworkHandler;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.network.PacketByteBuf;
-import net.minecraft.server.world.ServerWorld;
-
-public class PacketTransiever {
-    public static PacketByteBuf buildPacket(ServerWorld destination) {
-        PacketByteBuf buf = PacketByteBufs.create();
-        buf.writeNbt(((InfinityOptionsAccess)(destination)).getInfinityOptions().data());
-        return buf;
-    }
-
-    public static void receive(MinecraftClient client, ClientPlayNetworkHandler handler, PacketByteBuf buf, PacketSender responseSender) {
-        InfinityOptions options = new InfinityOptions(buf.readNbt());
-        ((InfinityOptionsAccess)client).setInfinityOptions(options);
-        NbtCompound shader = options.getShader();
-        boolean bl = shader.isEmpty();
-        if (bl) client.execute(() -> ShaderLoader.reloadShaders(client, false));
-        else {
-            client.execute(() -> {
-                CommonIO.write(shader, ShaderLoader.shaderDir(client), ShaderLoader.FILENAME);
-                ShaderLoader.reloadShaders(client, true);
-            });
-        }
-    }
-
-    public static void receiveStars(MinecraftClient client, ClientPlayNetworkHandler handler, PacketByteBuf buf, PacketSender responseSender) {
-        ((WorldRendererAccess)(client.worldRenderer)).setNeedsStars(true);
-    }
-}

src/main/java/net/lerariemann/infinity/options/ShaderLoader.java

···
 
 @Environment(EnvType.CLIENT)
 public class ShaderLoader {
-    static String FILENAME = "current.json";
-    static Path shaderDir(MinecraftClient client) {
+    public static String FILENAME = "current.json";
+    public static Path shaderDir(MinecraftClient client) {
         return client.getResourcePackDir().resolve("infinity/assets/infinity/shaders");
     }
 
···
             throw new RuntimeException(e);
         }
         if(bl && shaderDir(client).resolve(FILENAME).toFile().exists()) {
-            ((GameRendererAccess)(client.gameRenderer)).loadPP(InfinityMod.getId("shaders/" + FILENAME));
+            ((GameRendererAccess)(client.gameRenderer)).projectInfinity$loadPP(InfinityMod.getId("shaders/" + FILENAME));
             return;
         }
         client.gameRenderer.disablePostProcessor();
···
     private static NbtCompound packMcmeta() {
         NbtCompound res = new NbtCompound();
         NbtCompound pack = new NbtCompound();
-        pack.putInt("pack_format", 15);
+        pack.putInt("pack_format", 34);
         pack.putString("description", "Shader container");
         res.put("pack", pack);
         return res;

src/main/java/net/lerariemann/infinity/structure/ModStructureType.java

···
 import net.minecraft.world.gen.structure.StructureType;
 
 public class ModStructureType {
-    public static StructureType<RandomPortalStructure> PORTAL;
     public static StructurePieceType PYRAMID_PIECE;
     public static StructureType<PyramidStructure> PYRAMID;
 
···
 
     public static void registerStructures() {
         InfinityMod.LOGGER.debug("Registering processors for " + InfinityMod.MOD_ID);
-        PORTAL = Registry.register(Registries.STRUCTURE_TYPE, InfinityMod.getId("portal"), () -> RandomPortalStructure.CODEC);
         PYRAMID = Registry.register(Registries.STRUCTURE_TYPE, InfinityMod.getId("pyramid"), () -> PyramidStructure.CODEC);
         PYRAMID_PIECE = register(PyramidGenerator::new, "infinity:pypiece");
     }

src/main/java/net/lerariemann/infinity/structure/PyramidStructure.java

···
 package net.lerariemann.infinity.structure;
 
 import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import net.minecraft.structure.StructurePiecesCollector;
 import net.minecraft.world.Heightmap;
···
 import java.util.Optional;
 
 public class PyramidStructure extends Structure {
-    public static final Codec<PyramidStructure> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+    public static final MapCodec<PyramidStructure> CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
             PyramidStructure.configCodecBuilder(instance),
             (Codec.INT.fieldOf("top_y")).forGetter(a -> a.top_y),
             (Codec.INT.fieldOf("bottom_y")).forGetter(a -> a.top_y),

src/main/java/net/lerariemann/infinity/structure/RandomPortalStructure.java

···
-package net.lerariemann.infinity.structure;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.serialization.Codec;
-import com.mojang.serialization.DataResult;
-import com.mojang.serialization.codecs.RecordCodecBuilder;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.ItemEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.nbt.StringNbtReader;
-import net.minecraft.registry.entry.RegistryEntry;
-import net.minecraft.structure.StructurePiecesList;
-import net.minecraft.structure.pool.StructurePool;
-import net.minecraft.structure.pool.StructurePoolBasedGenerator;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.TypeFilter;
-import net.minecraft.util.dynamic.Codecs;
-import net.minecraft.util.math.*;
-import net.minecraft.util.math.random.Random;
-import net.minecraft.world.Heightmap;
-import net.minecraft.world.StructureWorldAccess;
-import net.minecraft.world.gen.HeightContext;
-import net.minecraft.world.gen.StructureAccessor;
-import net.minecraft.world.gen.chunk.ChunkGenerator;
-import net.minecraft.world.gen.heightprovider.HeightProvider;
-import net.minecraft.world.gen.structure.Structure;
-import net.minecraft.world.gen.structure.StructureType;
-
-import java.util.Optional;
-
-public class RandomPortalStructure extends Structure {
-    public static final Codec<RandomPortalStructure> CODEC = Codecs.validate(
-            RecordCodecBuilder.mapCodec(instance -> instance.group(RandomPortalStructure.configCodecBuilder(instance),
-                    (StructurePool.REGISTRY_CODEC.fieldOf("start_pool")).forGetter(structure -> structure.startPool),
-                    Identifier.CODEC.optionalFieldOf("start_jigsaw_name").forGetter(structure -> structure.startJigsawName),
-                    (Codec.intRange(0, 7).fieldOf("size")).forGetter(structure -> structure.size),
-                    (HeightProvider.CODEC.fieldOf("start_height")).forGetter(structure -> structure.startHeight),
-                    (Codec.BOOL.fieldOf("use_expansion_hack")).forGetter(structure -> structure.useExpansionHack),
-                    Heightmap.Type.CODEC.optionalFieldOf("project_start_to_heightmap").forGetter(structure -> structure.projectStartToHeightmap),
-                    (Codec.intRange(1, 128).fieldOf("max_distance_from_center")).forGetter(structure -> structure.maxDistanceFromCenter)).apply(
-                    instance, RandomPortalStructure::new)), RandomPortalStructure::validate).codec();
-    private final RegistryEntry<StructurePool> startPool;
-    private final Optional<Identifier> startJigsawName;
-    private final int size;
-    private final HeightProvider startHeight;
-    private final boolean useExpansionHack;
-    private final Optional<Heightmap.Type> projectStartToHeightmap;
-    private final int maxDistanceFromCenter;
-
-    private static DataResult<RandomPortalStructure> validate(RandomPortalStructure structure) {
-        int i;
-        switch (structure.getTerrainAdaptation()) {
-            default -> throw new IncompatibleClassChangeError();
-            case NONE -> i = 0;
-            case BURY, BEARD_THIN, BEARD_BOX -> i = 12;
-        }
-        if (structure.maxDistanceFromCenter + i > 128) {
-            return DataResult.error(() -> "Structure size including terrain adaptation must not exceed 128");
-        }
-        return DataResult.success(structure);
-    }
-
-    public RandomPortalStructure(Structure.Config config, RegistryEntry<StructurePool> startPool, Optional<Identifier> startJigsawName, int size, HeightProvider startHeight, boolean useExpansionHack, Optional<Heightmap.Type> projectStartToHeightmap, int maxDistanceFromCenter) {
-        super(config);
-        this.startPool = startPool;
-        this.startJigsawName = startJigsawName;
-        this.size = size;
-        this.startHeight = startHeight;
-        this.useExpansionHack = useExpansionHack;
-        this.projectStartToHeightmap = projectStartToHeightmap;
-        this.maxDistanceFromCenter = maxDistanceFromCenter;
-    }
-
-    @Override
-    public Optional<Structure.StructurePosition> getStructurePosition(Structure.Context context) {
-        ChunkPos chunkPos = context.chunkPos();
-        int i = this.startHeight.get(context.random(), new HeightContext(context.chunkGenerator(), context.world()));
-        BlockPos blockPos = new BlockPos(chunkPos.getStartX(), i, chunkPos.getStartZ());
-        Optional<Structure.StructurePosition> s = StructurePoolBasedGenerator.generate(context, this.startPool, this.startJigsawName, this.size, blockPos, this.useExpansionHack, this.projectStartToHeightmap, this.maxDistanceFromCenter);
-        return s;
-    }
-
-    @Override
-    public StructureType<?> getType() {
-        return ModStructureType.PORTAL;
-    }
-
-    @Override
-    public void postPlace(StructureWorldAccess world, StructureAccessor structureAccessor, ChunkGenerator chunkGenerator, Random random, BlockBox box, ChunkPos chunkPos, StructurePiecesList pieces) {
-        Box b = Box.from(pieces.getBoundingBox());
-        BlockPos pos = BlockPos.ofFloored(b.getCenter().x, b.getCenter().y, b.getCenter().z);
-        try {
-            if (!world.isClient() && world.toServerWorld().getEntitiesByType(TypeFilter.instanceOf(ItemEntity.class), b, RandomPortalStructure::isBook).isEmpty()) {
-                ItemStack stack = ItemStack.fromNbt(StringNbtReader.parse(
-                        "{id:\"minecraft:written_book\", Count:1b, tag:{author:\"LeraRiemann\",filtered_title:\"" + pos + "\",pages:['{\"text\":\"" + pos + "\"}'],title:\"" + pos + "\"}}"));
-                Entity e = new ItemEntity(world.toServerWorld(), b.getCenter().x, b.getCenter().y + 1.0, b.getCenter().z, stack, 0.0, 0.0, 0.0);
-                world.spawnEntityAndPassengers(e);
-            }
-        } catch (CommandSyntaxException e) {
-            throw new RuntimeException(e);
-        }
-    }
-    public static boolean isBook(ItemEntity entity) {
-        return entity.getStack().getItem() == Items.WRITTEN_BOOK || entity.getStack().getItem() == Items.WRITABLE_BOOK;
-    }
-}

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

···
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.FallingBlock;
-import net.minecraft.block.enums.WallMountLocation;
+import net.minecraft.block.enums.BlockFace;
 import net.minecraft.entity.EntityType;
 import net.minecraft.entity.SpawnGroup;
 import net.minecraft.fluid.Fluid;
···
         NbtCompound res = new NbtCompound();
         NbtList elements = new NbtList();
         int cse = 0;
-        if (w.keys.get(0) instanceof String) cse = 1;
-        if (w.keys.get(0) instanceof NbtCompound) cse = 2;
-        if (w.keys.get(0) instanceof NbtList) cse = 3;
+        if (w.keys.getFirst() instanceof String) cse = 1;
+        if (w.keys.getFirst() instanceof NbtCompound) cse = 2;
+        if (w.keys.getFirst() instanceof NbtList) cse = 3;
         int finalCse = cse;
         List<Integer> range = new ArrayList<>(IntStream.rangeClosed(0, w.keys.size() - 1).boxed().toList());
         range.sort(new Comparator<Integer>() {
             public String extract(int i) {
                 return switch (finalCse) {
-                    default -> w.keys.get(i).toString();
                     case 2 -> ((NbtCompound)(w.keys.get(i))).getString("Name");
-                    case 3 -> ((NbtList)(w.keys.get(i))).get(0).toString();
+                    case 3 -> ((NbtList)(w.keys.get(i))).getFirst().toString();
+                    default -> w.keys.get(i).toString();
                 };
             }
             @Override
···
         res.putBoolean("float", isFloat(bs, w, inAir));
         NbtCompound properties = new NbtCompound();
         if (bs.contains(Properties.PERSISTENT)) properties.putString("persistent", "true");
-        if (bs.contains(Properties.WALL_MOUNT_LOCATION)) {
+        if (bs.contains(Properties.BLOCK_FACE)) {
             properties.putString("face", "floor");
-            bs = bs.with(Properties.WALL_MOUNT_LOCATION, WallMountLocation.FLOOR);
+            bs = bs.with(Properties.BLOCK_FACE, BlockFace.FLOOR);
         }
         res.putBoolean("top", isTop(bs, w, onStone));
         if (!properties.isEmpty()) res.put("Properties", properties);
···
         Arrays.stream(colors).forEach(color -> {
             int i = block.lastIndexOf("magenta");
             String blockColored = block.substring(0, i) + color + block.substring(i+7);
-            if (Registries.BLOCK.containsId(new Identifier(blockColored))) {
+            if (Registries.BLOCK.containsId(Identifier.of(blockColored))) {
                 successCounter.addAndGet(1);
                 NbtCompound c = new NbtCompound();
                 c.putString("Name", blockColored);

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
-import org.apache.logging.log4j.LogManager;
 
 import java.io.File;
 import java.io.IOException;
···
                 Files.createDirectories(path);
             }
 
-            Files.walk(modContainer.getRootPaths().get(0).resolve("config")).forEach(p -> {
+            Files.walk(modContainer.getRootPaths().getFirst().resolve("config")).forEach(p -> {
                 boolean bl = registerConfig(p);
                 if (bl && p.toString().contains("evicted_files.json")) bl2.set(true);
             });
···
         if (bl2.get()) evictOldFiles();
     }
     public static void evictOldFiles() {
-        LogManager.getLogger().info("1");
         NbtCompound c = CommonIO.read("config/infinity/util/evicted_files.json");
         NbtList l = c.getList("content", NbtElement.STRING_TYPE);
         try {
             for (NbtElement e : l) {
                 Path path1 = Paths.get("config/infinity/" + e.asString());
-                LogManager.getLogger().info("path1");
                 if (path1.toFile().exists()) {
                     Path path2 = Paths.get("config/infinity/evicted/" + e.asString());
                     Files.createDirectories(path2);

src/main/java/net/lerariemann/infinity/util/RandomLootDrops.java

···
-package net.lerariemann.infinity.util;
-
-import com.google.gson.JsonElement;
-import net.lerariemann.infinity.InfinityMod;
-import net.minecraft.loot.LootDataType;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.WorldSavePath;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.Collections;
-import java.util.List;
-import java.util.Random;
-import java.util.stream.IntStream;
-
-public class RandomLootDrops {
-    public static void genAll(int seed, MinecraftServer s) {
-        List<Identifier> a = s.getLootManager().getIds(LootDataType.LOOT_TABLES).stream().toList();
-        List<Integer> l = new java.util.ArrayList<>(IntStream.rangeClosed(0, a.size() - 1).boxed().toList());
-        Collections.shuffle(l, new Random(seed));
-        for (int i = 0; i < a.size(); i++) {
-            try {
-                gen(s, a.get(i), a.get(l.get(i)));
-            } catch (IOException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    static void gen(MinecraftServer s, Identifier dataFrom, Identifier nameFrom) throws IOException {
-        JsonElement e = LootDataType.LOOT_TABLES.getGson().toJsonTree(s.getLootManager().getLootTable(dataFrom));
-        int i = nameFrom.getPath().lastIndexOf("/");
-        String before = i < 0 ? "" : "/" + nameFrom.getPath().substring(0, i);
-        String after = i < 0 ? nameFrom.getPath() : nameFrom.getPath().substring(i+1);
-        String directory = s.getSavePath(WorldSavePath.DATAPACKS).toString() + "/" + InfinityMod.MOD_ID +
-                "/data/" + nameFrom.getNamespace() + "/loot_tables" + before;
-        Files.createDirectories(Paths.get(directory));
-        Files.write(Paths.get(directory + "/" + after + ".json"), Collections.singletonList(e.toString()), StandardCharsets.UTF_8);
-    }
-}

src/main/java/net/lerariemann/infinity/var/ModCommands.java

···
 import net.lerariemann.infinity.block.custom.NeitherPortalBlock;
 import net.lerariemann.infinity.dimensions.RandomProvider;
 import net.lerariemann.infinity.util.ConfigGenerator;
-import net.lerariemann.infinity.util.RandomLootDrops;
-import net.minecraft.command.CommandException;
 import net.minecraft.command.argument.BlockPosArgumentType;
 import net.minecraft.item.Item;
 import net.minecraft.item.Items;
···
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
-import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
···
 public class ModCommands {
     static void warpId(CommandContext<ServerCommandSource> context, long value) {
         MinecraftServer s = context.getSource().getServer();
-        boolean bl = ((MinecraftServerAccess)(s)).getDimensionProvider().rule("runtimeGenerationEnabled");
+        boolean bl = ((MinecraftServerAccess)(s)).projectInfinity$getDimensionProvider().rule("runtimeGenerationEnabled");
         boolean bl2 = NeitherPortalBlock.addDimension(s, value, bl);
-        if (!bl) throw new CommandException(Text.translatable("commands.warp.runtime_disabled"));
         final ServerPlayerEntity self = context.getSource().getPlayer();
-        if (self == null) throw new CommandException(Text.translatable("commands.warp.not_a_player"));
         if (bl2) self.increaseStat(ModStats.DIMS_OPENED_STAT, 1);
         self.increaseStat(ModStats.PORTALS_OPENED_STAT, 1);
-        ((ServerPlayerEntityAccess)(self)).setWarpTimer(20, value);
+        ((ServerPlayerEntityAccess)(self)).projectInfinity$setWarpTimer(20, value);
     }
 
     public static boolean checkEnd(long d, MinecraftServer s) {
···
     }
 
     public static Identifier getIdentifier(long d, MinecraftServer s) {
-        String s1 = ((MinecraftServerAccess)s).getDimensionProvider().easterizer.keyOf(d);
+        String s1 = ((MinecraftServerAccess)s).projectInfinity$getDimensionProvider().easterizer.keyOf(d);
         return InfinityMod.getId(s1);
     }
 
···
     }
 
     public static long getDimensionSeed(String text, MinecraftServer s) {
-        return getDimensionSeed(text, ((MinecraftServerAccess)(s)).getDimensionProvider());
-    }
-    public static long getDimensionSeed(NbtCompound compound, MinecraftServer s, Item item) {
-        NbtList pages = compound.getList("pages", NbtElement.STRING_TYPE);
-        if (pages.isEmpty()) {
-            return getDimensionSeed("empty", ((MinecraftServerAccess)(s)).getDimensionProvider());
-        }
-        else if (item == Items.WRITTEN_BOOK) {
-            String pagesString = pages.get(0).asString();
-            String parsedString = pagesString.substring(pagesString.indexOf(':')+2, pagesString.length()-2);
-            return getDimensionSeed(parsedString, ((MinecraftServerAccess)(s)).getDimensionProvider());
-        }
-        else {
-            String pagesString = pages.get(0).asString();
-            return getDimensionSeed(pagesString, ((MinecraftServerAccess)(s)).getDimensionProvider());
-        }
+        return getDimensionSeed(text, ((MinecraftServerAccess)(s)).projectInfinity$getDimensionProvider());
     }
 
     public static long getDimensionSeed(String text, RandomProvider prov) {
···
                     ConfigGenerator.generateAll(w, bp1, bp2);
                     return 1;
                 })))));
-        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> dispatcher.register(literal("generate_loot")
-                .requires(source -> source.hasPermissionLevel(2))
-                .then(argument("seed", IntegerArgumentType.integer()).executes(context -> {
-                    final int seed = IntegerArgumentType.getInteger(context, "seed");
-                    RandomLootDrops.genAll(seed, context.getSource().getServer());
-                    return 1;
-                })))); //experimental command, will likely get separated into its own mod
     }
 }

src/main/java/net/lerariemann/infinity/var/ModCriteria.java

···
 package net.lerariemann.infinity.var;
 
-import com.google.gson.JsonObject;
-import com.google.gson.JsonPrimitive;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
 import net.lerariemann.infinity.InfinityMod;
 import net.minecraft.advancement.criterion.AbstractCriterion;
-import net.minecraft.advancement.criterion.AbstractCriterionConditions;
-import net.minecraft.advancement.criterion.Criteria;
-import net.minecraft.predicate.entity.AdvancementEntityPredicateDeserializer;
-import net.minecraft.predicate.entity.AdvancementEntityPredicateSerializer;
+import net.minecraft.predicate.entity.EntityPredicate;
 import net.minecraft.predicate.entity.LootContextPredicate;
+import net.minecraft.registry.Registries;
+import net.minecraft.registry.Registry;
 import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.Identifier;
+
+import java.util.Optional;
 
 public class ModCriteria {
     public static class DimensionOpenedCriterion extends AbstractCriterion<ScoredConditions> {
-        static final Identifier ID = InfinityMod.getId("dims_open");
-
-        public DimensionOpenedCriterion() {
-            super();
-        }
-
-        public Identifier getId() {
-            return ID;
-        }
-
         @Override
-        public ScoredConditions conditionsFromJson(JsonObject jsonObject, LootContextPredicate lootContextPredicate, AdvancementEntityPredicateDeserializer advancementEntityPredicateDeserializer) {
-            int score = jsonObject.getAsJsonPrimitive("amount").getAsInt();
-            return new ScoredConditions(lootContextPredicate, score, getId());
+        public Codec<ScoredConditions> getConditionsCodec() {
+            return ScoredConditions.CODEC;
         }
 
         public void trigger(ServerPlayerEntity player) {
···
     }
 
     public static class DimensionClosedCriterion extends AbstractCriterion<ScoredConditions> {
-        static final Identifier ID = InfinityMod.getId("dims_closed");
-
-        public DimensionClosedCriterion() {
-            super();
-        }
-
-        public Identifier getId() {
-            return ID;
-        }
-
         @Override
-        public ScoredConditions conditionsFromJson(JsonObject jsonObject, LootContextPredicate lootContextPredicate, AdvancementEntityPredicateDeserializer advancementEntityPredicateDeserializer) {
-            int score = jsonObject.getAsJsonPrimitive("amount").getAsInt();
-            return new ScoredConditions(lootContextPredicate, score, getId());
+        public Codec<ScoredConditions> getConditionsCodec() {
+            return ScoredConditions.CODEC;
         }
 
         public void trigger(ServerPlayerEntity player) {
···
         }
     }
 
-
     public static class WhoRemainsCriterion extends AbstractCriterion<EmptyConditions> {
-        static final Identifier ID = InfinityMod.getId("who_remains");
-
-        public WhoRemainsCriterion() {
-            super();
-        }
-
-        public Identifier getId() {
-            return ID;
-        }
-
-        @Override
-        public EmptyConditions conditionsFromJson(JsonObject jsonObject, LootContextPredicate lootContextPredicate, AdvancementEntityPredicateDeserializer advancementEntityPredicateDeserializer) {
-            return new EmptyConditions(lootContextPredicate, ID);
-        }
-
         public void trigger(ServerPlayerEntity player) {
             this.trigger(player, (conditions) -> true);
         }
-    }
 
-    public static class EmptyConditions extends AbstractCriterionConditions {
-
-        public EmptyConditions(LootContextPredicate player, Identifier ID) {
-            super(ID, player);
+        @Override
+        public Codec<EmptyConditions> getConditionsCodec() {
+            return EmptyConditions.CODEC;
         }
+    }
 
-        public static EmptyConditions create(Identifier ID) {
-            return new EmptyConditions(LootContextPredicate.EMPTY, ID);
-        }
-
-        public JsonObject toJson(AdvancementEntityPredicateSerializer predicateSerializer) {
-            return super.toJson(predicateSerializer);
-        }
+    public record EmptyConditions(Optional<LootContextPredicate> player) implements AbstractCriterion.Conditions {
+        public static final Codec<EmptyConditions> CODEC = RecordCodecBuilder.create(
+                instance -> instance.group(
+                                EntityPredicate.LOOT_CONTEXT_PREDICATE_CODEC.optionalFieldOf("player").forGetter(EmptyConditions::player)
+                        )
+                        .apply(instance, EmptyConditions::new)
+        );
     }
 
-    public static class ScoredConditions extends AbstractCriterionConditions {
-        private final int score;
-
-        public ScoredConditions(LootContextPredicate player, int score, Identifier ID) {
-            super(ID, player);
-            this.score = score;
-        }
+    public record ScoredConditions(Optional<LootContextPredicate> player, int score) implements AbstractCriterion.Conditions {
+        public static final Codec<ScoredConditions> CODEC = RecordCodecBuilder.create(
+                instance -> instance.group(
+                                EntityPredicate.LOOT_CONTEXT_PREDICATE_CODEC.optionalFieldOf("player").forGetter(ScoredConditions::player),
+                                Codec.INT.fieldOf("amount").forGetter(ScoredConditions::score)
+                        )
+                        .apply(instance, ScoredConditions::new)
+        );
 
         public boolean test(int stat) {
             return stat >= this.score;
         }
-
-        public static ScoredConditions create(int i, Identifier ID) {
-            return new ScoredConditions(LootContextPredicate.EMPTY, i, ID);
-        }
-
-        public JsonObject toJson(AdvancementEntityPredicateSerializer predicateSerializer) {
-            JsonObject jsonObject = super.toJson(predicateSerializer);
-            jsonObject.add("amount", new JsonPrimitive(this.score));
-            return jsonObject;
-        }
     }
 
     public static DimensionOpenedCriterion DIMS_OPENED;
     public static DimensionClosedCriterion DIMS_CLOSED;
-    public static WhoRemainsCriterion HE_WHO_REMAINS;
+    public static WhoRemainsCriterion WHO_REMAINS;
 
     public static void registerCriteria() {
-        DIMS_OPENED = Criteria.register(new DimensionOpenedCriterion());
-        DIMS_CLOSED = Criteria.register(new DimensionClosedCriterion());
-        HE_WHO_REMAINS = Criteria.register(new WhoRemainsCriterion());
+        DIMS_OPENED = Registry.register(Registries.CRITERION, InfinityMod.getId("dims_open"), new DimensionOpenedCriterion());
+        DIMS_CLOSED = Registry.register(Registries.CRITERION, InfinityMod.getId("dims_closed"), new DimensionClosedCriterion());
+        WHO_REMAINS = Registry.register(Registries.CRITERION, InfinityMod.getId("who_remains"), new WhoRemainsCriterion());
     }
 }

src/main/java/net/lerariemann/infinity/var/ModDensityFunctionTypes.java

···
 import net.minecraft.util.math.random.CheckedRandom;
 import net.minecraft.world.gen.densityfunction.DensityFunction;
 
+import java.util.Arrays;
+
 public class ModDensityFunctionTypes {
     interface Nonbinary extends DensityFunction {
         DensityFunction input();
···
     }
 
     record Coordinate(double scale, int axis) implements DensityFunction.Base {
-        public static final CodecHolder<Coordinate> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        public static final CodecHolder<Coordinate> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 Codec.DOUBLE.fieldOf("scale").orElse(1.0).forGetter(a -> a.scale),
                 Codec.INT.fieldOf("axis").forGetter(a -> a.axis)).apply(
                 instance, Coordinate::new)));
···
     }
 
     record Menger(double scale, int max_y) implements DensityFunction.Base {
-        public static final CodecHolder<Menger> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        public static final CodecHolder<Menger> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 Codec.DOUBLE.fieldOf("scale").orElse(1.0).forGetter(a -> a.scale),
                 Codec.INT.fieldOf("max_y").orElse(0).forGetter(a -> a.max_y)).apply(
                 instance, Menger::new)));
···
     }
 
     record Skygrid(double scale, int size, int separation) implements DensityFunction.Base {
-        public static final CodecHolder<Skygrid> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        public static final CodecHolder<Skygrid> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 Codec.DOUBLE.fieldOf("scale").orElse(1.0).forGetter(a -> a.scale),
                 Codec.INT.fieldOf("size").orElse(1).forGetter(a -> a.size),
                 Codec.INT.fieldOf("separation").orElse(3).forGetter(a -> a.separation)).apply(
···
 
     static double[] gen(int octaves){
         double[] a = new double[octaves];
-        for (int i = 0; i < octaves; i++) a[i] = 1;
+        Arrays.fill(a, 1);
         return a;
     }
 
     public record Classic(int sealevel) implements DensityFunction.Base {
-        public static final CodecHolder<Classic> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        public static final CodecHolder<Classic> CODEC_HOLDER = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 Codec.INT.fieldOf("sealevel").orElse(64).forGetter(a -> a.sealevel)).apply(
                 instance, Classic::new)));
 

src/main/java/net/lerariemann/infinity/var/ModMaterialConditions.java

···
 public class ModMaterialConditions {
     record LinearCondition(double k_x, double k_y, double k_z, double min, double max, int separation) implements MaterialRules.MaterialCondition
     {
-        static final CodecHolder<LinearCondition> CODEC = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        static final CodecHolder<LinearCondition> CODEC = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 (Codec.DOUBLE.fieldOf("k_x").orElse(1.0).forGetter(a -> a.k_x)),
                 (Codec.DOUBLE.fieldOf("k_y").orElse(0.0).forGetter(a -> a.k_y)),
                 (Codec.DOUBLE.fieldOf("k_z").orElse(1.0).forGetter(a -> a.k_z)),
···
 
     record CheckerboardCondition(int size) implements MaterialRules.MaterialCondition
     {
-        static final CodecHolder<CheckerboardCondition> CODEC = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        static final CodecHolder<CheckerboardCondition> CODEC = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 (Codec.INT.fieldOf("size").orElse(1).forGetter(a -> a.size))
         ).apply(instance, CheckerboardCondition::new)));
 
···
 
     public record TextCondition(int font_size, int char_spacing, int line_spacing, int max_width, String text, Pair<Integer, Pair<List<List<Integer>>, List<List<Character>>>> data) implements MaterialRules.MaterialCondition
     {
-        static final CodecHolder<TextCondition> CODEC = CodecHolder.of(RecordCodecBuilder.create(instance -> instance.group(
+        static final CodecHolder<TextCondition> CODEC = CodecHolder.of(RecordCodecBuilder.mapCodec(instance -> instance.group(
                 (Codec.INT.fieldOf("font_size").orElse(1).forGetter(a -> a.font_size)),
                 (Codec.INT.fieldOf("char_spacing").orElse(1).forGetter(a -> a.char_spacing)),
                 (Codec.INT.fieldOf("line_spacing").orElse(1).forGetter(a -> a.line_spacing)),

src/main/java/net/lerariemann/infinity/var/ModMaterialRules.java

···
             long seed = MathHelper.hashCode(i, j, k);
             double d = (seed & 0xFFFL) / (double)0xFFFL;
             d = d - Math.floor(d);
-            BlockState st = Registries.BLOCK.get(new Identifier(RandomProvider.blockElementToName(w.getElement(d)))).getDefaultState();
+            BlockState st = Registries.BLOCK.get(Identifier.of(RandomProvider.blockElementToName(w.getElement(d)))).getDefaultState();
             if(st.contains(Properties.PERSISTENT)) st = st.with(Properties.PERSISTENT, Boolean.TRUE);
             return st;
         }

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

···
+package net.lerariemann.infinity.var;
+
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
+import net.lerariemann.infinity.InfinityMod;
+import net.lerariemann.infinity.access.InfinityOptionsAccess;
+import net.lerariemann.infinity.access.WorldRendererAccess;
+import net.lerariemann.infinity.loading.DimensionGrabber;
+import net.lerariemann.infinity.options.InfinityOptions;
+import net.lerariemann.infinity.options.ShaderLoader;
+import net.lerariemann.infinity.util.CommonIO;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtElement;
+import net.minecraft.nbt.NbtList;
+import net.minecraft.network.RegistryByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.codec.PacketCodecs;
+import net.minecraft.network.packet.CustomPayload;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.util.Identifier;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ModPayloads {
+    public record WorldAddPayload(Identifier world_id, NbtCompound optiondata) implements CustomPayload {
+        public static final CustomPayload.Id<WorldAddPayload> ID = new CustomPayload.Id<>(InfinityMod.getId("reload_worlds"));
+        public static final PacketCodec<RegistryByteBuf, WorldAddPayload> CODEC = PacketCodec.tuple(
+                Identifier.PACKET_CODEC, WorldAddPayload::world_id,
+                PacketCodecs.NBT_COMPOUND, WorldAddPayload::optiondata,
+                WorldAddPayload::new);
+        @Override
+        public CustomPayload.Id<? extends CustomPayload> getId() {
+            return ID;
+        }
+    }
+    public static void addWorld(WorldAddPayload payload, ClientPlayNetworking.Context context) {
+        Identifier id = payload.world_id;
+        NbtCompound optiondata = payload.optiondata;
+        NbtCompound dimdata = optiondata.getCompound("dimdata");
+        NbtList biomeslist = optiondata.getList("biomes", NbtElement.COMPOUND_TYPE);
+        List<Identifier> biomeids = new ArrayList<>();
+        List<NbtCompound> biomes = new ArrayList<>();
+        for (NbtElement e: biomeslist) if (e instanceof NbtCompound biome) {
+            biomeids.add(InfinityMod.getId(biome.getString("id")));
+            biomes.add(biome.getCompound("data"));
+        }
+        context.client().execute(() -> (new DimensionGrabber(context.client().getNetworkHandler().getRegistryManager())).grab_for_client(id, dimdata, biomeids, biomes));
+    }
+
+    public record ShaderRePayload(NbtCompound shader_data) implements CustomPayload {
+        public static final CustomPayload.Id<ShaderRePayload> ID = new CustomPayload.Id<>(InfinityMod.getId("reload_shader"));
+        public static final PacketCodec<RegistryByteBuf, ShaderRePayload> CODEC = PacketCodec.tuple(
+                PacketCodecs.NBT_COMPOUND, ShaderRePayload::shader_data,
+                ShaderRePayload::new);
+        @Override
+        public CustomPayload.Id<? extends CustomPayload> getId() {
+            return ID;
+        }
+    }
+    public static void receiveShader(ShaderRePayload payload, ClientPlayNetworking.Context context) {
+        InfinityOptions options = new InfinityOptions(payload.shader_data);
+        MinecraftClient client = context.client();
+        ((InfinityOptionsAccess)client).projectInfinity$setInfinityOptions(options);
+        NbtCompound shader = options.getShader();
+        boolean bl = shader.isEmpty();
+        if (bl) client.execute(() -> ShaderLoader.reloadShaders(client, false));
+        else {
+            client.execute(() -> {
+                CommonIO.write(shader, ShaderLoader.shaderDir(client), ShaderLoader.FILENAME);
+                ShaderLoader.reloadShaders(client, true);
+            });
+        }
+    }
+
+    public record StarsRePayLoad() implements CustomPayload {
+        public static final StarsRePayLoad INSTANCE = new StarsRePayLoad();
+        public static final CustomPayload.Id<StarsRePayLoad> ID = new CustomPayload.Id<>(InfinityMod.getId("reload_stars"));
+        public static final PacketCodec<RegistryByteBuf, StarsRePayLoad> CODEC = PacketCodec.unit(INSTANCE);
+        @Override
+        public CustomPayload.Id<? extends CustomPayload> getId() {
+            return ID;
+        }
+    }
+    public static void receiveStars(StarsRePayLoad payload, ClientPlayNetworking.Context context) {
+        ((WorldRendererAccess)(context.client().worldRenderer)).projectInfinity$setNeedsStars(true);
+    }
+
+    public static ShaderRePayload setShaderFromWorld(ServerWorld destination) {
+        return new ShaderRePayload(((InfinityOptionsAccess)(destination)).projectInfinity$getInfinityOptions().data());
+    }
+
+    public static void registerPayloadsServer() {
+        PayloadTypeRegistry.playS2C().register(WorldAddPayload.ID, WorldAddPayload.CODEC);
+        PayloadTypeRegistry.playS2C().register(ShaderRePayload.ID, ShaderRePayload.CODEC);
+        PayloadTypeRegistry.playS2C().register(StarsRePayLoad.ID, StarsRePayLoad.CODEC);
+    }
+    public static void registerPayloadsClient() {
+        ClientPlayNetworking.registerGlobalReceiver(ModPayloads.WorldAddPayload.ID, ModPayloads::addWorld);
+        ClientPlayNetworking.registerGlobalReceiver(ModPayloads.ShaderRePayload.ID, ModPayloads::receiveShader);
+        ClientPlayNetworking.registerGlobalReceiver(ModPayloads.StarsRePayLoad.ID, ModPayloads::receiveStars);
+    }
+}

src/main/java/net/lerariemann/infinity/var/ModPlacementModifiers.java

···
 package net.lerariemann.infinity.var;
 
-import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
 import net.lerariemann.infinity.InfinityMod;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
···
 
 public class ModPlacementModifiers {
     public static class CenterProximityPlacementModifier extends AbstractConditionalPlacementModifier {
-        public static final Codec<CenterProximityPlacementModifier> MODIFIER_CODEC = (Codecs.POSITIVE_INT.fieldOf("radius")).xmap(
-                CenterProximityPlacementModifier::new, a -> a.radius).codec();
+        public static final MapCodec<CenterProximityPlacementModifier> MODIFIER_CODEC = (Codecs.POSITIVE_INT.fieldOf("radius")).xmap(
+                CenterProximityPlacementModifier::new, a -> a.radius);
         private final int radius;
 
         private CenterProximityPlacementModifier(int radius) {
···
             return PlacementModifierType.RARITY_FILTER;
         }
     }
-    static <P extends PlacementModifier> PlacementModifierType<P> register(String id, Codec<P> codec) {
+    static <P extends PlacementModifier> PlacementModifierType<P> register(String id, MapCodec<P> codec) {
         return Registry.register(Registries.PLACEMENT_MODIFIER_TYPE, InfinityMod.getId(id), () -> codec);
     }
     public static void registerModifiers() {

src/main/java/net/lerariemann/infinity/var/ModSounds.java

···
 package net.lerariemann.infinity.var;
 
+import net.lerariemann.infinity.InfinityMod;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.sound.SoundEvent;
 import net.minecraft.util.Identifier;
 
 public class ModSounds {
-    public static final Identifier IVORY_MUSIC_HOPE = new Identifier("infinity:music.ivory.hope_instilled");
-    public static final Identifier IVORY_MUSIC_CHALLENGER = new Identifier("infinity:music.ivory.challenger");
+    public static final Identifier IVORY_MUSIC_HOPE = InfinityMod.getId("music.ivory.hope_instilled");
+    public static final Identifier IVORY_MUSIC_CHALLENGER = InfinityMod.getId("music.ivory.challenger");
     public static SoundEvent IVORY_MUSIC_HOPE_EVENT = SoundEvent.of(IVORY_MUSIC_HOPE);
     public static SoundEvent IVORY_MUSIC_CHALLENGER_EVENT = SoundEvent.of(IVORY_MUSIC_CHALLENGER);
 

src/main/resources/data/infinity/dimension_type/default_type.json

···
   "logical_height": 256,
   "monster_spawn_light_level": {
     "type": "uniform",
-    "value": {
-      "min_inclusive": 0,
-      "max_inclusive": 7
-    }
+    "min_inclusive": 0,
+    "max_inclusive": 7
   },
   "monster_spawn_block_light_limit": 0,
   "infiniburn": "#infiniburn_overworld",

src/main/resources/data/infinity/dimension_type/library_type.json

···
   "logical_height": 96,
   "monster_spawn_light_level": {
     "type": "uniform",
-    "value": {
-      "min_inclusive": 0,
-      "max_inclusive": 7
-    }
+    "min_inclusive": 0,
+    "max_inclusive": 7
   },
   "fixed_time": 6000,
   "monster_spawn_block_light_limit": 0,

src/main/resources/data/infinity/dimension_type/sponge_type.json

···
   "logical_height": 256,
   "monster_spawn_light_level": {
     "type": "uniform",
-    "value": {
-      "min_inclusive": 0,
-      "max_inclusive": 7
-    }
+    "min_inclusive": 0,
+    "max_inclusive": 7
   },
   "monster_spawn_block_light_limit": 0,
   "infiniburn": "#infiniburn_overworld",

src/main/resources/fabric.mod.json

···
   "id": "infinity",
   "version": "${version}",
 
-  "name": "Infinite Dimensions 1.20.1",
+  "name": "Infinite Dimensions 1.21.1",
   "description": "Inspired by 2020's April Fools' 20w14infinite Snapshot, this mod brings endless randomly generated dimensions into Minecraft.",
   "authors": [
     "Lera Riemann"
···
   "depends": {
     "fabricloader": ">=0.14.11",
     "fabric-api": "*",
-    "minecraft": "~1.20.1",
-    "java": ">=17"
+    "minecraft": "~1.21.1",
+    "java": ">=21"
   },
   "suggests": {
     "another-mod": "*"

src/main/resources/infinity.mixins.json

···
     "AbstractFireBlockMixin",
     "ChunkRegionMixin",
     "CreeperEntityMixin",
-    "EntityMixin",
     "MaterialRuleContextAccess",
     "MinecraftServerMixin",
     "MobEntityMixin",
     "NetherPortalBlockMixin",
-    "PlayerEntityMixin",
+    "NetherPortalMixin",
+    "PointOfInterestTypesMixin",
     "PortalForcerMixin",
     "ServerPlayerEntityMixin",
     "SlimeEntityMixin",
     "WorldChunkMixin",
-    "mavity.BoatEntityMixin",
-    "mavity.LivingEntityMixin",
-    "mavity.PersistentProjectileEntityMixin",
-    "mavity.SeveralEntitiesMixin",
-    "mavity.ThrownEntityMixin",
     "mobs.EndermiteEntityMixin",
     "mobs.WaterCreaturesMixin",
     "mobs.passive.AnimalEntityMixin",