Merge branch 'architectury/1.20' into create-6.0

README.md

···
 
 ## Dependencies
 
-Architectury API is required, as well as [Fabric API](https://modrinth.com/mod/fabric-api) on Fabric and [Forgified Fabric API](https://modrinth.com/mod/forgified-fabric-api) on Forge and NeoForge. Older versions of the mod (v1.13.0 and below) only require Fabric API.
+[Architectury API](https://modrinth.com/mod/architectury-api) is required, as well as [Fabric API](https://modrinth.com/mod/fabric-api) on Fabric. The Forge backport also requires [Forgified Fabric API](https://modrinth.com/mod/forgified-fabric-api).
+
+If you want to configure the mod in-game, you will need [Cloth Config](https://modrinth.com/mod/cloth-config) and [Mod Menu](https://modrinth.com/mod/modmenu) (on Fabric).
+
+Older versions may have different dependencies. See their specific version pages for more details.
 
 ## FAQ
 

build.gradle

···
         // See https://docs.gradle.org/current/userguide/declaring_repositories.html
         // for more information about repositories.
         maven { // Flywheel
-            url = "https://maven.tterrag.com/"
+            url = "https://modmaven.dev"
             content {
                 // need to be specific here due to version overlaps
                 includeGroup("com.jozufozu.flywheel")

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

···
             InputUtil.Type.KEYSYM,
             GLFW.GLFW_KEY_F4,
             "key.categories.misc");
+    public static KeyBinding postProcessorConfigKey = new KeyBinding("key.infinity.postprocessor",
+            InputUtil.Type.KEYSYM,
+            GLFW.GLFW_KEY_F12,
+            "key.categories.misc");
 
     public static void initializeClient() {
         ModEntities.registerEntityRenderers();
···
                 TypedActionResult<ItemStack> result = F4Item.deploy(client.world, client.player, Hand.MAIN_HAND);
                 client.player.setStackInHand(Hand.MAIN_HAND, result.getValue());
             }
+            while (postProcessorConfigKey.wasPressed()) client.gameRenderer.togglePostProcessorEnabled();
         });
     }
 }

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

···
 package net.lerariemann.infinity.block.custom;
 
-import com.mojang.serialization.MapCodec;
 import net.lerariemann.infinity.block.entity.ChromaticBlockEntity;
+import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.minecraft.block.*;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NbtCompound;
 import net.minecraft.state.StateManager;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
···
     @Override
     public ItemStack getPickStack(BlockView world, BlockPos pos, BlockState state) {
         ItemStack res = super.getPickStack(world, pos, state);
-//        if (!res.isEmpty() && world.getBlockEntity(pos) instanceof ChromaticBlockEntity cbe)
-//            res.applyComponentsFrom(cbe.asMap());
+        if (!res.isEmpty() && world.getBlockEntity(pos) instanceof ChromaticBlockEntity cbe) {
+            var c = new NbtCompound();
+            c.putInt(ModComponentTypes.COLOR, cbe.color);
+            res.setNbt(c);
+        }
         return res;
     }
 

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

···
 import net.lerariemann.infinity.access.Timebombable;
 import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
 import net.lerariemann.infinity.dimensions.RandomDimension;
-import net.lerariemann.infinity.item.PortalDataHolder;
+import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItemFunctions;
 import net.lerariemann.infinity.registry.var.ModPoi;
 import net.lerariemann.infinity.util.InfinityMethods;
···
 import net.minecraft.particle.ParticleTypes;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
+import net.minecraft.registry.tag.ItemTags;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ChunkTicketType;
···
 
     public static NbtCompound putKeyComponents(Item item, Identifier dim) {
         NbtCompound nbtCompound = new NbtCompound();
-        if (!item.equals(Items.AMETHYST_SHARD)) return nbtCompound;
+        if (!(item.equals(Items.AMETHYST_SHARD) || item.getDefaultStack().isIn(ItemTags.WOOL) || item.getDefaultStack().isIn(ItemTags.WOOL_CARPETS)))
+            return nbtCompound;
         int keycolor = WarpLogic.getKeyColorFromId(dim);
-        nbtCompound.putInt("key_color", keycolor);
-        nbtCompound.putString("key_destination", dim.toString());
+        nbtCompound.putInt(ModComponentTypes.COLOR, keycolor);
+        if (!item.equals(Items.AMETHYST_SHARD))
+            return nbtCompound;
+        nbtCompound.putString(ModComponentTypes.DESTINATION, dim.toString());
         return nbtCompound;
     }
 

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

···
 
     @Override
     public boolean onSyncedBlockEvent(BlockState state, World world, BlockPos pos, int type, int data) {
-        Instrument[] instruments = (Instrument[]) INSTRUMENT.stream().toArray();
+        Instrument[] instruments = INSTRUMENT.getValues().toArray(Instrument[]::new);
         Instrument noteBlockInstrument = instruments[world.random.nextInt(instruments.length-7)];
         float f;
         if (world.getBlockEntity(pos.down()) instanceof ChromaticBlockEntity e) {

common/src/main/java/net/lerariemann/infinity/compat/ComputerCraftCompat.java

···
             }
             return string;
         }
-        return null;
+        return "";
     }
 }

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

···
             case "minecraft:noise" -> {
                 res.put("biome_source", randomBiomeSource());
                 res.putString("settings", randomNoiseSettings());
-                res.putLong("seed", numericId);
+                res.putLong("seed", numericId ^ server.getOverworld().getSeed());
                 return res;
             }
             default -> {

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

···
         lightLevel.putString("type", "uniform");
             lightLevel.put("value", RandomProvider.genBounds(0, random.nextInt(15)));
         data.put("monster_spawn_light_level", lightLevel);
-        data.putString("infiniburn", dim.PROVIDER.randomName(random, "tags"));
+        data.putString("infiniburn", "#" + dim.PROVIDER.randomName(random, "tags"));
         String s = dim.PROVIDER.randomName(random, "dimension_effects");
         foggy = s.equals("minecraft:the_nether");
         data.putString("effects", s);

common/src/main/java/net/lerariemann/infinity/dimensions/features/RandomFungus.java

···
         addRandomBlock(config, "stem_state", "full_blocks_worldgen");
         NbtCompound replaceableBlocks = new NbtCompound();
         replaceableBlocks.putString("type", "minecraft:matching_block_tag");
-        replaceableBlocks.putString("tag", PROVIDER.randomName(random, "tags").replace("#", ""));
+        replaceableBlocks.putString("tag", PROVIDER.randomName(random, "tags"));
         config.put("replaceable_blocks", replaceableBlocks);
         config.put("valid_base_block", mainsurfaceblock);
         return feature(config);

common/src/main/java/net/lerariemann/infinity/dimensions/features/RandomGeode.java

···
         NbtList inner_placements = new NbtList();
         inner_placements.add(PROVIDER.randomElement(random, "all_blocks"));
         blocks.put("inner_placements", inner_placements);
-        blocks.putString("cannot_replace", PROVIDER.randomName(random, "tags"));
-        blocks.putString("invalid_blocks", PROVIDER.randomName(random, "tags"));
+        blocks.putString("cannot_replace", "#" + PROVIDER.randomName(random, "tags"));
+        blocks.putString("invalid_blocks", "#" + PROVIDER.randomName(random, "tags"));
         config.put("blocks", blocks);
         NbtCompound layers = new NbtCompound();
         double r = 1.0;

common/src/main/java/net/lerariemann/infinity/dimensions/features/RandomTree.java

···
         mangrove.putInt("max_root_width", 1 + random.nextInt(ishuge ? 12 : 4));
         mangrove.putInt("max_root_length", 1 + random.nextInt(ishuge ? 64 : 8));
         mangrove.putFloat("random_skew_chance", random.nextFloat());
-        mangrove.putString("can_grow_through", PROVIDER.randomName(random, "tags"));
-        mangrove.putString("muddy_roots_in", PROVIDER.randomName(random, "tags"));
+        mangrove.putString("can_grow_through", "#" + PROVIDER.randomName(random, "tags"));
+        mangrove.putString("muddy_roots_in", "#" + PROVIDER.randomName(random, "tags"));
         addRandomBlockProvider(mangrove, "muddy_roots_provider", "full_blocks");
         res.put("mangrove_root_placement", mangrove);
         return res;
···
                 res.putInt("extra_branch_steps", 1 + (int) Math.floor(random.nextExponential()));
                 res.putInt("extra_branch_length", (int) Math.floor(random.nextExponential()*3));
                 res.putFloat("place_branch_per_log_probability", random.nextFloat());
-                res.putString("can_grow_through", PROVIDER.randomName(random, "tags"));
+                res.putString("can_grow_through", "#" + PROVIDER.randomName(random, "tags"));
             }
             case "cherry_trunk_placer" -> {
                 addRandomIntProvider(res, "branch_count", 1, 2);
···
                 res.put("branch_start_offset_from_top", branch_start_offset_from_top);
                 addRandomIntProvider(res, "branch_end_offset_from_top", -16, 15);
             }
+//            case "infinity:wonky" -> {
+//                float a = random.nextFloat();
+//                float b = random.nextFloat();
+//                res.putFloat("weight_up", Math.max(a, b));
+//                res.putFloat("weight_down", Math.min(a, b));
+//                res.putFloat("weight_side", random.nextFloat());
+//            }
         }
         return res;
     }

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

···
 import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.mob.Angerable;
 import net.minecraft.entity.mob.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.particle.ParticleEffect;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.sound.SoundEvents;
···
     }
 
     public void onRemoved(LivingEntity entity) {
-        if (Objects.requireNonNull(entity) instanceof ServerPlayerEntity player) {
-            unloadShader(player);
-            if (player.isInvulnerable()) endJourney(player, true, 0);
+        if (Objects.requireNonNull(entity) instanceof PlayerEntity player) {
+            if (player instanceof ServerPlayerEntity serverPlayer) {
+                unloadShader(serverPlayer);
+                if (player.isInvulnerable()) endJourney(serverPlayer, true, 0);
+            }
         } else if (entity instanceof ChaosPawn pawn) {
             if (pawn.getRandom().nextBoolean()) {
                 pawn.unchess();
···
             }
         } else if (entity instanceof MobEntity currEntity) {
             endConversion(currEntity);
-        } else if (entity instanceof MobEntity currEntity) {
-            endConversion(currEntity);
-        } else if (entity instanceof MobEntity currEntity) {
-            Iridescence.endConversion(currEntity);
         }
     }
 
     @Override
     public void tryApplySpecial(LivingEntity entity, int duration, int amplifier) {
-        if (entity instanceof ServerPlayerEntity player) {
-            if (shouldWarp(duration, amplifier)) {
-                if (!player.isInvulnerable()) {
-                    player.setInvulnerable(true);
-                    saveCookie(player);
+        if (entity instanceof PlayerEntity player) {
+            if (player instanceof ServerPlayerEntity serverPlayer) {
+                if (shouldWarp(duration, amplifier)) {
+                    if (!player.isInvulnerable()) {
+                        player.setInvulnerable(true);
+                        saveCookie(serverPlayer);
+                    }
+                    Identifier id = getIdForWarp(serverPlayer);
+                    WarpLogic.requestWarp(serverPlayer, id, false);
+                }
+                if (shouldReturn(duration, amplifier)) {
+                    endJourney(serverPlayer, false, amplifier);
                 }
-                Identifier id = getIdForWarp(player);
-                WarpLogic.requestWarp(player, id, false);
+                if (shouldRequestShaderLoad(duration, amplifier))
+                    loadShader(serverPlayer);
             }
-            if (shouldReturn(duration, amplifier)) {
-                endJourney(player, false, amplifier);
-            }
-            if (shouldRequestShaderLoad(duration, amplifier))
-                loadShader(player);
             if (amplifier == 0 && duration == 2) {
                 player.addStatusEffect(new StatusEffectInstance(ModStatusEffects.AFTERGLOW.value(),
                         getAfterglowDuration() / 2, 0, true, true));

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

···
         if (player != null && player.getStackInHand(Hand.OFF_HAND)
                 .isOf(ModItems.CHROMATIC_MATTER.get())
                 && world.getBlockEntity(pos) instanceof ChromaticBlockEntity cbe) {
-            cbe.setColor(BackportMethods.getOrDefaultInt(stack, ModComponentTypes.KEY_COLOR, 0xFFFFFF));
+            cbe.setColor(BackportMethods.getOrDefaultInt(stack, ModComponentTypes.COLOR, 0xFFFFFF));
         }
         return bl;
     }

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

···
 
 import net.lerariemann.infinity.block.custom.AltarBlock;
 import net.lerariemann.infinity.block.entity.ChromaticBlockEntity;
+import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.var.ModTags;
···
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUsageContext;
+import net.minecraft.nbt.NbtCompound;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.text.Style;
 import net.minecraft.text.Text;
···
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
+import java.awt.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class ChromaticItem extends Item implements PortalDataHolder {
···
         player.playSound(SoundEvents.ENTITY_EXPERIENCE_ORB_PICKUP, 0.5f, pitch);
     }
 
+    static NbtCompound ofColor(int color) {
+        NbtCompound compound = new NbtCompound();
+        compound.putInt(ModComponentTypes.COLOR, color);
+        return compound;
+    }
+
+    static NbtCompound ofHue(int hue) {
+        NbtCompound compound = new NbtCompound();
+        compound.putInt(ModComponentTypes.COLOR, Color.HSBtoRGB(hue/360f, 1.0f, 1.0f) & 0xFFFFFF);
+        return compound;
+    }
+
+    static NbtCompound ofDye(DyeColor dyeColor) {
+        NbtCompound compound = new NbtCompound();
+        compound.putInt(ModComponentTypes.COLOR, ColorLogic.getChromaticColor(dyeColor));
+        compound.putString(ModComponentTypes.DYE_COLOR, dyeColor.getName());
+        return compound;
+    }
+
     @Override
     public ActionResult useOnBlock(ItemUsageContext context) {
         PlayerEntity player = context.getPlayer();
···
 
     public boolean useOnBlock(PlayerEntity player, Hand hand, World world, BlockPos pos, ItemStack currStack) {
         BlockState oldState = world.getBlockState(pos);
-        int currColor = BackportMethods.getOrDefaultInt(currStack, ModComponentTypes.KEY_COLOR, 0xFFFFFF);
+        int currColor = BackportMethods.getOrDefaultInt(currStack, ModComponentTypes.COLOR, 0xFFFFFF);
         if (player.isSneaking()) { //copy color
             ItemStack newStack = currStack.copy();
             int i = -1;
             if (world.getBlockEntity(pos) instanceof ChromaticBlockEntity cbe) i = cbe.getTint();
+            else if (world.getBlockEntity(pos) instanceof InfinityPortalBlockEntity cbe) i = cbe.getTint();
             else if (oldState.isOf(ModBlocks.ALTAR.get())) {
                 int altarState = oldState.get(AltarBlock.COLOR);
                 if (altarState == 0) i = ColorLogic.getChromaticColor(DyeColor.LIGHT_GRAY);
                 else {
                     int hue = (altarState - 1) * (360 / (AltarBlock.numColors - 1));
                     if (!ColorLogic.matchesPureHue(currColor, hue))
-                        BackportMethods.apply(newStack, ModComponentTypes.HUE, hue);
+                        newStack.setNbt(ofHue(hue));
                     else return false;
                 }
             }
             else { //copy color from vanilla blocks
                 DyeColor dyeColor = ColorLogic.getColorByState(oldState);
                 if (dyeColor != null &&
-                        !(dyeColor.getId() == (BackportMethods.getOrDefaultInt(newStack, ModComponentTypes.DYE_COLOR, -1)))) {
-                    BackportMethods.apply(newStack, ModComponentTypes.DYE_COLOR, dyeColor.getId());
+                        !dyeColor.getName().equals(BackportMethods.getOrDefaultString(newStack, ModComponentTypes.DYE_COLOR, "null"))) {
+                    newStack.setNbt(ofDye(dyeColor));
                 }
                 else return false;
             }
             if (i > 0) {
-                if (i != currColor) BackportMethods.apply(newStack, ModComponentTypes.DYE_COLOR, i);
+                if (i != currColor) newStack.setNbt(ofColor(i));
                 else return false;
             }
             player.setStackInHand(hand, newStack);
···
             if (oldState.isIn(ModTags.IRIDESCENT_BLOCKS)) return false;
             boolean bl = BackportMethods.contains(currStack, ModComponentTypes.DYE_COLOR);
             BlockState state;
-            if (bl) state = ColorLogic.recolor(BackportMethods.getOrDefaultString(currStack, ModComponentTypes.DYE_COLOR, "infinity:chromatic"), oldState);
+            if (bl) state = ColorLogic.recolor(BackportMethods.getOrDefaultString(currStack, ModComponentTypes.DYE_COLOR, null), oldState);
             else state = ColorLogic.recolor("infinity:chromatic", oldState);
             if (state == null) return false;
             world.setBlockState(pos, state);

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

···
 package net.lerariemann.infinity.item;
 
+import dev.architectury.platform.Platform;
 import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
···
 
 
     public static int getCharge(ItemStack f4) {
-        if (f4.hasNbt()) {
-            assert f4.getNbt() != null;
-            return f4.getNbt().getInt("f4_charge");
-        }
-        return 0;
+        return BackportMethods.getOrDefaultInt(f4, ModComponentTypes.F4_CHARGE, 0);
     }
 
     @Override
···
                                     int size_x, int size_y) {
         Direction.Axis dir2 = player.getHorizontalFacing().rotateClockwise(Direction.Axis.Y).getAxis();
 
-        int charges = getCharge(stack);
+        int charges = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.F4_CHARGE, 0);
         int useCharges = player.isCreative() ? 0 : 2*(2 + size_x + size_y);
         if (charges < useCharges) {
             if (!world.isClient())
···
         useCharges -= obsNotReplaced;
 
         world.playSound(player, player.getBlockPos(), SoundEvents.BLOCK_BELL_USE, SoundCategory.BLOCKS, 1, 0.75f);
-        BackportMethods.apply(stack, ModComponentTypes.F4_CHARGE, charges-useCharges);
-        return stack;
+        return BackportMethods.apply(stack, ModComponentTypes.F4_CHARGE, charges-useCharges);
     }
 
     @Override
···
         World world = context.getWorld();
         BlockPos pos = context.getBlockPos();
         BlockState bs = world.getBlockState(pos);
+        if (bs.isReplaceable()) {
+            pos = pos.down();
+            bs = world.getBlockState(pos);
+        }
         Hand hand = context.getHand();
 
         if (isPortal(bs)) {
···
         }
         for (int i = 0; i < portal.width; i++) for (int j = 0; j < portal.height; j++)
             world.setBlockState(portal.lowerLeft.offset(axis, i).up(j), Blocks.AIR.getDefaultState(), 3, 0);
-        BackportMethods.apply(stack, ModComponentTypes.F4_CHARGE, getCharge(stack) + obsidian);
         world.playSound(null, origin, SoundEvents.BLOCK_GLASS_BREAK, SoundCategory.BLOCKS, 1, 0.75f);
-        return stack;
+        return BackportMethods.apply(stack, ModComponentTypes.F4_CHARGE, getCharge(stack) + obsidian);
     }
 }

common/src/main/java/net/lerariemann/infinity/item/function/F4RechargingRecipe.java

···
 
     public ItemStack craft(RecipeInputInventory inventory, DynamicRegistryManager registryManager) {
         ItemStack f4 = null;
-        int i = 0;
-        for (int k = 0; k < inventory.getInputStacks().size(); k++) {
-            ItemStack itemStack = inventory.getStack(k);
+        int obsidian = 0;
+        for (int slot = 0; slot < inventory.getInputStacks().size(); slot++) {
+            ItemStack itemStack = inventory.getStack(slot);
             if (itemStack.isOf(ModItems.F4.get())) f4 = itemStack;
-            else if (!itemStack.isEmpty()) i++;
+            else if (!itemStack.isEmpty()) obsidian++;
         }
         assert f4 != null;
         int charge = F4Item.getCharge(f4);
-        if (i == 0) {
+        if (obsidian == 0) {
             if (charge > 0) return Items.OBSIDIAN.getDefaultStack().copyWithCount(Math.min(charge, 64)); //"removing obsidian" recipe
         }
         ItemStack result = f4.copy();
-        BackportMethods.apply(result, ModComponentTypes.F4_CHARGE, charge+i);
-        return result;
+        return BackportMethods.apply(result, ModComponentTypes.F4_CHARGE, charge+obsidian);
     }
 
     @Override

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

···
 			if (!bl && !InfinityMethods.isInfinity(world)) return;
 			world.setBlockState(pos, ModBlocks.PORTAL.get().getDefaultState().
 					with(AXIS, state.get(AXIS)));
-			if (bl && world.getBlockEntity(pos) instanceof InfinityPortalBlockEntity ipbe) {
-				long l = InfinityMethods.getRandomSeed(new java.util.Random(world.getTime()));
-				ipbe.setDimension(l);
+			if (world.getBlockEntity(pos) instanceof InfinityPortalBlockEntity ipbe) {
+				if (bl) {
+					long l = InfinityMethods.getRandomSeed(new java.util.Random(world.getTime()));
+					ipbe.setDimension(l);
+				}
+				else {
+					ipbe.setOpen(true);
+				}
 			}
 		}
 	}

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

···
     @Inject(method = "getNodeType(Lnet/minecraft/world/BlockView;IIILnet/minecraft/entity/mob/MobEntity;)Lnet/minecraft/entity/ai/pathing/PathNodeType;",
             at = @At("HEAD"), cancellable = true)
     private void inj(BlockView world, int x, int y, int z, MobEntity mob, CallbackInfoReturnable<PathNodeType> cir) {
-        if (Iridescence.isIridescence(entity.getWorld(), new BlockPos(x, y, z))) {
+        if (mob != null && Iridescence.isIridescence(entity.getWorld(), new BlockPos(x, y, z))) {
             if (entity instanceof AbstractChessFigure figure && figure.isBlackOrWhite())
                 cir.setReturnValue(PathNodeType.BLOCKED);
         }

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

···
+package net.lerariemann.infinity.mixin.iridescence;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.LilyPadBlock;
+import net.minecraft.fluid.Fluids;
+import net.minecraft.registry.tag.FluidTags;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.BlockView;
+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;
+
+@Mixin(LilyPadBlock.class)
+public class LilyPadBlockMixin {
+    /* make lilypads plantable on iridescence */
+    @Inject(method = "canPlantOnTop", at = @At(value = "RETURN"), cancellable = true)
+    void inj(BlockState floor, BlockView world, BlockPos pos, CallbackInfoReturnable<Boolean> cir) {
+        if (world.getFluidState(pos).isIn(FluidTags.WATER) && world.getFluidState(pos.up()).getFluid() == Fluids.EMPTY) {
+            cir.setReturnValue(true);
+        }
+    }
+}

common/src/main/java/net/lerariemann/infinity/mixin/qol/KeyboardMixin.java

···
+package net.lerariemann.infinity.mixin.qol;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.client.Keyboard;
+import net.minecraft.client.render.GameRenderer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(Keyboard.class)
+public class KeyboardMixin {
+    /* disable f4 being a hardcoded toggle postprocessing shaders key, as the mod makes it rebindable */
+    @WrapOperation(method="onKey", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/GameRenderer;togglePostProcessorEnabled()V"))
+    void inj(GameRenderer instance, Operation<Void> original) {
+    }
+}

common/src/main/java/net/lerariemann/infinity/registry/core/ModBlocks.java

···
     public static void registerFlammableBlocks() {
         PlatformMethods.registerFlammableBlock(ModBlocks.IRIDESCENT_WOOL, 60, 30);
         PlatformMethods.registerFlammableBlock(ModBlocks.IRIDESCENT_CARPET, 20, 60);
+        PlatformMethods.registerFlammableBlock(ModBlocks.CHROMATIC_WOOL, 60, 30);
+        PlatformMethods.registerFlammableBlock(ModBlocks.CHROMATIC_CARPET, 20, 60);
     }
 }

common/src/main/java/net/lerariemann/infinity/registry/core/ModComponentTypes.java

···
 
     public static String DESTINATION = "key_destination";
     public static String BIOME_CONTENTS = "biome_contents";
-    public static String KEY_COLOR = "key_color";
+    public static String COLOR = "key_color";
     public static String HUE = "hue";
     public static String DYE_COLOR = "dye_color";
     public static String F4_CHARGE = "f4_charge";

common/src/main/java/net/lerariemann/infinity/registry/core/ModItemFunctions.java

···
         if (match.isEmpty()) return;
 
         ItemStack resStack = match.get().getOutput(w.getRegistryManager());
-//        componentFunction.apply(resStack.getItem()).ifPresent(resStack::applyChanges);
+        resStack.setNbt(compound);
 
         Vec3d v = itemEntity.getVelocity();
         ItemEntity result = new ItemEntity(w, itemEntity.getX(), itemEntity.getY(), itemEntity.getZ(),

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

···
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
 import dev.architectury.event.events.common.CommandRegistrationEvent;
+import dev.architectury.platform.Platform;
 import net.lerariemann.infinity.util.teleport.WarpLogic;
 import net.minecraft.command.argument.DimensionArgumentType;
 import net.minecraft.server.command.CommandManager;
···
     );
 
     public static void registerCommands() {
-        CommandRegistrationEvent.EVENT.register((dispatcher, registryAccess, environment) -> dispatcher.register(literal("warp")
+        String warp;
+        if (Platform.isModLoaded("ftbessentials") || Platform.isModLoaded("fabric-essentials")) // FTB/Fabric Essentials add their own warp command that plays havoc with ours.
+            warp = "dimwarp";
+        else {
+            warp = "warp";
+        }
+        CommandRegistrationEvent.EVENT.register((dispatcher, registryAccess, environment) -> dispatcher.register(literal(warp)
                 .requires(source -> source.hasPermissionLevel(2))
                 .then(
                         CommandManager.literal("existing").then(

common/src/main/java/net/lerariemann/infinity/util/BackportMethods.java

···
 
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NbtCompound;
 import net.minecraft.util.Identifier;
 import org.jetbrains.annotations.Nullable;
 
···
     public static int getOrDefaultInt(ItemStack stack, String key, int i) {
         if (stack.hasNbt()) {
             assert stack.getNbt() != null;
-            return stack.getNbt().getInt(key);
+            if (stack.getNbt().contains(key))
+                return stack.getNbt().getInt(key);
         }
         return i;
     }
···
     public static String getOrDefaultString(ItemStack stack, String key, String i) {
         if (stack.hasNbt()) {
             assert stack.getNbt() != null;
-            return stack.getNbt().getString(key);
+            if (stack.getNbt().contains(key))
+                return stack.getNbt().getString(key);
         }
         return i;
     }
 
     public static boolean contains(ItemStack stack, String key) {
         if (stack.hasNbt()) {
-            return !Objects.requireNonNull(stack.getSubNbt(key)).isEmpty();
+            assert stack.getNbt() != null;
+            return stack.getNbt().contains(key);
         }
         return false;
     }
···
             assert stack.getNbt() != null;
             stack.getNbt().putInt(key, i);
             return stack;
+        } else {
+            NbtCompound nbtCompound = new NbtCompound();
+            nbtCompound.putInt(key, i);
+            stack.setNbt(nbtCompound);
         }
         return stack;
     }
···
             assert stack.getNbt() != null;
             stack.getNbt().putString(key, i);
             return stack;
+        } else {
+            NbtCompound nbtCompound = new NbtCompound();
+            nbtCompound.putString(key, i);
+            stack.setNbt(nbtCompound);
         }
         return stack;
     }

common/src/main/java/net/lerariemann/infinity/util/InfinityMethods.java

···
 import net.lerariemann.infinity.access.Timebombable;
 import net.lerariemann.infinity.block.entity.BiomeBottleBlockEntity;
 import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
+import net.lerariemann.infinity.block.entity.TintableBlockEntity;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.util.core.RandomProvider;
···
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.text.MutableText;
 import net.minecraft.text.Text;
+import net.minecraft.util.DyeColor;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.Util;
 import net.minecraft.util.math.BlockPos;
···
     }
 
     static int getOverlayColorFromComponents(ItemStack stack, int layer) {
-        if (stack.getNbt() != null && layer == 1) {
-            if (stack.getItem().equals(ModItems.TRANSFINITE_KEY.get()))
-                return stack.getNbt().getInt("key_color");
-            else if (stack.getItem().equals(ModItems.BIOME_BOTTLE_ITEM.get())) {
-                return stack.getNbt().getCompound("BlockEntityTag").getInt("Color");
-            }
-            else if (stack.getItem().equals(ModItems.F4.get())) {
-                return stack.getNbt().getInt(ModComponentTypes.KEY_COLOR);
+        if (stack.getNbt() != null) {
+            if (layer == 1) {
+                if (stack.isOf(ModItems.TRANSFINITE_KEY.get()))
+                    return stack.getNbt().getInt(ModComponentTypes.COLOR);
+                else if (stack.isOf(ModItems.BIOME_BOTTLE_ITEM.get())) {
+                    return stack.getNbt().getCompound("BlockEntityTag").getInt("Color");
+                }
+                else if (stack.isOf(ModItems.F4.get())) {
+                    return BackportMethods.getOrDefaultInt(stack, ModComponentTypes.COLOR, 10879231);
+                }
             }
+            else if (stack.isOf(ModItems.CHROMATIC_MATTER.get()) || stack.isOf(ModItems.CHROMATIC_WOOL.get()) || stack.isOf(ModItems.CHROMATIC_CARPET.get()))
+                return stack.getNbt().getInt(ModComponentTypes.COLOR);
         }
         return 0xFFFFFF;
     }
···
     static int getBlockEntityColor(BlockState state, BlockRenderView world, BlockPos pos, int tintIndex) {
         if (world != null && pos != null) {
             BlockEntity blockEntity = world.getBlockEntity(pos);
-            if (blockEntity instanceof InfinityPortalBlockEntity be) {
+            if (blockEntity instanceof TintableBlockEntity be) {
                 Object j = be.getTint();
                 return (int)j & 0xFFFFFF;
-            }
-        }
-        return 0xFFFFFF;
-    }
-
-    /**
-     * Gets a Biome Bottle's color from its block entity - for use in color providers.
-     */
-    static int getBiomeBottleColor(BlockState state, BlockRenderView world, BlockPos pos, int tintIndex) {
-        if (world != null && pos != null) {
-            BlockEntity blockEntity = world.getBlockEntity(pos);
-            if (blockEntity instanceof BiomeBottleBlockEntity be) {
-                int j = be.color;
-                return j & 0xFFFFFF;
             }
         }
         return 0xFFFFFF;

common/src/main/java/net/lerariemann/infinity/util/PlatformMethods.java

···
         return (int)(256 * ((r + 1)/2)) + 256*((int)(256 * ((g + 1)/2)) + 256*(int)(256 * ((b + 1)/2)));
     }
 
-    public static int getBookBoxColour(BlockState state, BlockRenderView world, BlockPos pos, int tintIndex) {
-        if (pos != null) {
-            return posToColor(pos);
-        }
-        return 16777215;
-    }
-
-    public static int getOverlayColorFromComponents(ItemStack stack, int layer) {
-        if (stack.getNbt() != null) {
-            int color = stack.getNbt().getInt("key_color");
-            if (layer == 1) {
-                return color;
-            }
-        }
-        return 0xFFFFFF;
-    }
-
-    public static int getNeitherPortalColour(BlockState state, BlockRenderView world, BlockPos pos, int tintIndex) {
-        if (world != null && pos != null) {
-            BlockEntity blockEntity = world.getBlockEntity(pos);
-            if (blockEntity instanceof InfinityPortalBlockEntity be) {
-                Object j = be.getTint();
-                return (int)j & 0xFFFFFF;
-            }
-        }
-        return 0xFFFFFF;
-    }
-
-    public static int getBiomeBottleColor(BlockState state, BlockRenderView world, BlockPos pos, int tintIndex) {
-        if (world != null && pos != null) {
-            BlockEntity blockEntity = world.getBlockEntity(pos);
-            if (blockEntity instanceof BiomeBottleBlockEntity be) {
-                Object j = be.getTint();
-                return (int)j & 0xFFFFFF;
-            }
-        }
-        return 0xFFFFFF;
-    }
-
     @ExpectPlatform
     public static <T extends Item> void addAfter(RegistrySupplier<T> blockItem, RegistryKey<ItemGroup> group, Item item) {
         throw new AssertionError();
···
     }
 
     /**
-     * Neoforge-exclusive method of testing if a mob is located in iridescence as far as fluid types are concerned.
+     * Forge-exclusive method of testing if a mob is located in iridescence as far as fluid types are concerned.
      * Used only in mixins, to fix the neoforge loader stripping mobs of ability to swim in non-water fluids.
      * On Fabric, returns false.
      */
···
     public static boolean acidTest(Entity entity, boolean eyes) {
         throw new AssertionError();
     }
+
     @ExpectPlatform
     public static double acidHeightTest(Entity entity) {
         throw new AssertionError();

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

···
 import net.lerariemann.infinity.util.BackportMethods;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.PlatformMethods;
+import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.lerariemann.infinity.util.loading.DimensionGrabber;
 import net.lerariemann.infinity.options.PortalColorApplier;
···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
+import net.minecraft.nbt.NbtString;
 import net.minecraft.network.PacketByteBuf;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
···
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.WorldSavePath;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import net.minecraft.world.BlockLocating;
 import net.minecraft.world.TeleportTarget;
 import net.minecraft.world.World;
 
+import java.nio.file.Path;
 import java.util.*;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
···
                 if (world instanceof ServerWorld serverWorld) {
                     boolean bl = modifyOnInitialCollision(id, serverWorld, pos);
                     if (bl) entity.remove(Entity.RemovalReason.CHANGED_DIMENSION);
+                    recordIdTranslation(world.getServer(), id, content);
                 }
             }
         }
         else if (Platform.isModLoaded("computercraft")) {
-            String content;
-            content = checkPrintedPage(itemStack);
-            MinecraftServer server = world.getServer();
-            if (server != null) {
-                Identifier id = InfinityMethods.dimTextToId(content);
-                if (world instanceof ServerWorld serverWorld) {
-                    boolean bl = modifyOnInitialCollision(id, serverWorld, pos);
-                    if (bl) entity.remove(Entity.RemovalReason.CHANGED_DIMENSION);
+            try {
+                String content;
+                content = checkPrintedPage(itemStack);
+                MinecraftServer server = world.getServer();
+                if (server != null) {
+                    Identifier id = InfinityMethods.dimTextToId(content);
+                    if (world instanceof ServerWorld serverWorld) {
+                        boolean bl = modifyOnInitialCollision(id, serverWorld, pos);
+                        if (bl) entity.remove(Entity.RemovalReason.CHANGED_DIMENSION);
+                        recordIdTranslation(world.getServer(), id, content);
+                    }
                 }
+            } catch (Exception e) {
+                InfinityMod.LOGGER.warn("An incompatible version of ComputerCraft is present. Please update it to the latest version");
             }
         }
-
     }
 
     /**
···
             }
         }
         return bl;
+    }
+
+    static void recordIdTranslation(MinecraftServer server, Identifier id, String value) {
+        value = value.replaceAll("\n", "/n");
+        Path dir = server.getSavePath(WorldSavePath.DATAPACKS).resolve("infinity");
+        String filename = "translation_tables.json";
+        NbtCompound comp = CommonIO.read(dir.resolve(filename));
+        String key = id.getPath();
+        if (comp.contains(key)) {
+            NbtList l;
+            if (comp.contains(key, NbtElement.STRING_TYPE)) {
+                l = new NbtList();
+                l.add(comp.get(key));
+            }
+            else l = comp.getList(key, NbtElement.STRING_TYPE);
+            l.add(NbtString.of(value));
+            comp.remove(key);
+            comp.put(key, l);
+        }
+        else comp.putString(key, value);
+        CommonIO.write(comp, dir, filename);
     }
 }

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

···
      * Handles the /warp text command, warping the player to a specified dimension. This is the same as writing the input into a book.
      */
     static void requestWarpByText(CommandContext<ServerCommandSource> context, String value) {
-        requestWarp(context.getSource().getPlayer(), InfinityMethods.dimTextToId(value), true);
+        Identifier id = InfinityMethods.dimTextToId(value);
+        requestWarp(context.getSource().getPlayer(), id, true);
+        PortalCreator.recordIdTranslation(context.getSource().getServer(), id, value);
     }
 
     /**

common/src/main/resources/assets/infinity/lang/en_us.json

···
   "item.infinity.chromatic_potion": "Chromatic Potion",
   "item.infinity.iridescent_potion": "Iridescent Potion",
   "key.infinity.f4": "Place a Nether Portal",
+  "key.infinity.postprocessor": "Toggle dimension postprocessing shaders",
   "lore.infinity.altar": "This block can be crafted by throwing a Lectern into an Infinity Portal.",
   "lore.infinity.ant": "This strange block rapidly moves, changing White Concrete to Black Concrete and back again.",
   "lore.infinity.book_box": "This block can be found in the Infinite Library. Using it will give you a randomly generated book based on the block's position.",

common/src/main/resources/config/.util/invocation.lock

···
-infinity_version: 2003009
+infinity_version: 2004005
 Delete this file to regenerate modular configs automatically
 (e.g. you may want to do this when adding new mods to the instance)

common/src/main/resources/config/easter/credits.json

···
 {
-  "infinity_version": 2004002,
+  "infinity_version": 2004005,
   "options": {
     "portal_color": 11894492
   },
···
             "then_run": {
               "type": "minecraft:condition",
               "if_true": {
-                "text": "Acknowledgements$n----------------------$nMod by LeraRiemann, cassiancc$n$nMusic by ivory rosewood$n$nAdditional code by:$n* BasiqueEvangelist$n* unilock$n$nAlpha testers:$n* MamonaTheGreed$n* Mirakuzura$n* sweetbriar$n$nGolden bug catcher:$n* JustImagineIT$n$nBug catchers:$n* ezioishere$n* MommysDebitCard$n* 0tvechau$n* purplenathaniel$n* bravely-beep$n* tylerb153$n* Lord_Drakostar$n* slomas04$n* Strike_GR$n* TVFLabs$n* krispyking24$n* wknowleskellett$n* CrownScorpion$n* CraftyZombie$n* Pookette$n* anhonestheart$n----------------------$nMay contain elephants",
+                "text": "Acknowledgements$n----------------------$nMod by LeraRiemann, cassiancc$n$nMusic by ivory rosewood$n$nAdditional code by:$n* BasiqueEvangelist$n* unilock$n$nAlpha testers:$n* MamonaTheGreed$n* Mirakuzura$n* sweetbriar$n$nGolden bug catcher:$n* JustImagineIT$n$nBug catchers:$n* ezioishere$n* MommysDebitCard$n* 0tvechau$n* purplenathaniel$n* bravely-beep$n* tylerb153$n* Lord_Drakostar$n* slomas04$n* Strike_GR$n* TVFLabs$n* krispyking24$n* wknowleskellett$n* CrownScorpion$n* CraftyZombie$n* Pookette$n* anhonestheart$n* hollow_egg$n* zontreck$n* erasemint$n* EssGeeEich$n* CryptidArtha----------------------$nMay contain elephants",
                 "type": "infinity:text"
               },
               "then_run": {

common/src/main/resources/data/infinity/advancements/bishop_taken.json

···
       "translate": "advancements.infinity.bishop_taken.description"
     },
     "icon": {
-      "count": 1,
-      "id": "infinity:star_of_lang"
+      "item": "infinity:star_of_lang"
     },
     "frame": "goal",
     "show_toast": true,

common/src/main/resources/data/infinity/advancements/iridescence_root.json

···
   "parent": "infinity:multiverse_root",
   "display": {
     "icon": {
-      "id": "infinity:iridescence_bucket"
+      "item": "infinity:iridescence_bucket"
     },
     "title": {
       "translate": "advancements.infinity.iridescence_root.title"

common/src/main/resources/data/infinity/worldgen/biome/custom.json

···
     "temperature": 0.5,
     "downfall": 0.5,
     "effects": {
-      "fog_color": 16645990,
-      "sky_color": 16758886,
+      "fog_color": 12638463,
+      "sky_color": 65493,
       "water_color": 6141935,
       "water_fog_color": 6141935,
       "foliage_color": 16087296,

common/src/main/resources/data/infinity/worldgen/biome/isolation.json

···
     "temperature": 0.5,
     "downfall": 0.5,
     "effects": {
-      "fog_color": 12638463,
-      "sky_color": 65493,
+      "fog_color": 16645990,
+      "sky_color": 16758886,
       "water_color": 4159204,
       "water_fog_color": 329011,
       "foliage_color": 16087296,

common/src/main/resources/infinity.mixins.json

···
     "options.PlayerManagerMixin",
     "options.ServerWorldMixin",
     "qol.FireBlockMixin",
-    "qol.LavaFluidMixin"
+    "qol.LavaFluidMixin",
+    "iridescence.LilyPadBlockMixin"
   ],
   "client": [
     "SoundListMixin",
···
     "options.GameRendererMixin",
     "options.MinecraftClientMixin",
     "options.SoundSystemMixin",
-    "options.WorldRendererMixin"
+    "options.WorldRendererMixin",
+    "qol.KeyboardMixin"
   ],
   "injectors": {
     "defaultRequire": 1

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

···
         ColorProviderRegistry.ITEM.register(InfinityMethods::getOverlayColorFromComponents,
                 ModItems.TRANSFINITE_KEY.get(),
                 ModItems.BIOME_BOTTLE_ITEM.get(),
-                ModItems.F4.get());
-        ColorProviderRegistry.ITEM.register(InfinityMethods::getOverlayColorFromComponents,
+                ModItems.F4.get(),
                 ModItems.CHROMATIC_WOOL.get(),
                 ModItems.CHROMATIC_CARPET.get(),
                 ModItems.CHROMATIC_MATTER.get());

forge/build.gradle

···
             includeGroup "curse.maven"
         }
     }
-    maven { url = "https://maven.tterrag.com/" } // Flywheel on both, Create and Registrate on forge
+    maven { url = "https://modmaven.dev/" } // Flywheel on both, Create and Registrate on forge
 }
 
 processResources {

forge/src/main/java/net/lerariemann/infinity/fluids/forge/FluidTypes.java

···
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ColorHelper;
 import net.minecraft.world.BlockRenderView;
 import net.minecraft.world.BlockView;
 import net.minecraft.world.World;
···
 import java.util.function.Consumer;
 
 public class FluidTypes {
-    private static final DeferredRegister<FluidType> FLUID_TYPES = DeferredRegister.create(ForgeRegistries.Keys.FLUID_TYPES, InfinityMod.MOD_ID);
-
-    public static final RegistryObject<FluidType> IRIDESCENCE_TYPE = FLUID_TYPES.register("iridescence",
-            () -> new IridescentFluidType(FluidType.Properties.create()
-            .descriptionId("fluid.infinity.iridescence")
-            .fallDistanceModifier(0F)
-            .canExtinguish(true)
-            .canConvertToSource(true)
-            .supportsBoating(true)
-            .canSwim(true)
-            .canHydrate(true)
-            .sound(SoundActions.BUCKET_FILL, SoundEvents.ITEM_BUCKET_FILL)
-            .sound(SoundActions.BUCKET_EMPTY, SoundEvents.ITEM_BUCKET_EMPTY)
-            .sound(SoundActions.FLUID_VAPORIZE, SoundEvents.BLOCK_FIRE_EXTINGUISH)
-            .pathType(PathNodeType.WATER)
-            .adjacentPathType(PathNodeType.WATER)) {
-
-        @Override
-        public void initializeClient(Consumer<IClientFluidTypeExtensions> consumer) {
-            consumer.accept(new IClientFluidTypeExtensions() {
-                private static final Identifier IRIDESCENCE = InfinityMethods.getId("block/iridescence");
-
-                @Override
-                public @NotNull Identifier getStillTexture() {
-                    return IRIDESCENCE;
-                }
-
-                @Override
-                public @NotNull Identifier getFlowingTexture() {
-                    return IRIDESCENCE;
-                }
-
-                @Override
-                public int getTintColor(@NotNull FluidState state, @NotNull BlockRenderView getter, @NotNull BlockPos pos) {
-                    return Iridescence.getPosBasedColor(pos);
-                }
-            });
-        }
-    });
 
-    public static FluidInteractionRegistry.InteractionInformation getIridescentInteraction(FluidType type) {
-        return new FluidInteractionRegistry.InteractionInformation(
-                (level, currentPos, relativePos, currentState) -> level.getFluidState(relativePos).getFluidType() == type,
-                (level, currentPos, relativePos, currentState) -> {
-            level.setBlockState(currentPos, ForgeEventFactory.fireFluidPlaceBlockEvent(level, currentPos, currentPos,
-                    currentState.isStill() ? Blocks.OBSIDIAN.getDefaultState() :
-                            Iridescence.getRandomColorBlock(level,"glazed_terracotta").getDefaultState()));
-            level.syncWorldEvent(1501, currentPos, 0);
-        });
-    }
-
-    public static void registerFluidTypes(IEventBus bus) {
-        FLUID_TYPES.register(bus);
-    }
-    public static void registerFluidInteractions(FMLCommonSetupEvent event) {
-        FluidInteractionRegistry.addInteraction(ForgeMod.LAVA_TYPE.get(), getIridescentInteraction(IRIDESCENCE_TYPE.get()));
-    }
-
-    public static class IridescentFluidType extends FluidType {
-        public IridescentFluidType(Properties properties) {
-            super(properties);
-        }
-        @Override
-        public PathNodeType getBlockPathType(@NotNull FluidState state, @NotNull BlockView level, @NotNull BlockPos pos,
-                                             @Nullable MobEntity mob, boolean canFluidLog) {
-            return canFluidLog ? super.getBlockPathType(state, level, pos, mob, true) : null;
-        }
-        @Override
-        public boolean canConvertToSource(@NotNull FluidState state, @NotNull WorldView reader, @NotNull BlockPos pos) {
-            if (reader instanceof World level) {
-                return Iridescence.isInfinite(level);
-            }
-            //Best guess fallback to default (true)
-            return super.canConvertToSource(state, reader, pos);
-        }
-        @Override
-        public boolean isVaporizedOnPlacement(@NotNull World w, @NotNull BlockPos pos, @NotNull FluidStack stack) {
-            return false;
-        }
-    }
 }

forge/src/main/java/net/lerariemann/infinity/fluids/forge/ModFluidsForge.java

···
 
 import dev.architectury.registry.registries.DeferredRegister;
 import dev.architectury.registry.registries.RegistrySupplier;
+import net.lerariemann.infinity.InfinityMod;
+import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.core.ModItems;
+import net.lerariemann.infinity.util.InfinityMethods;
+import net.minecraft.block.Blocks;
+import net.minecraft.entity.ai.pathing.PathNodeType;
+import net.minecraft.entity.mob.MobEntity;
 import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.FluidState;
 import net.minecraft.registry.RegistryKeys;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ColorHelper;
+import net.minecraft.world.BlockRenderView;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldView;
+import net.minecraftforge.client.extensions.common.IClientFluidTypeExtensions;
+import net.minecraftforge.common.ForgeMod;
+import net.minecraftforge.common.SoundActions;
+import net.minecraftforge.event.ForgeEventFactory;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fluids.FluidInteractionRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidType;
 import net.minecraftforge.fluids.ForgeFlowingFluid;
+import net.minecraftforge.registries.ForgeRegistries;
+import net.minecraftforge.registries.RegistryObject;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
 
 import static net.lerariemann.infinity.InfinityMod.MOD_ID;
 
 public class ModFluidsForge {
     public static final DeferredRegister<Fluid> FLUIDS = DeferredRegister.create(MOD_ID, RegistryKeys.FLUID);
+    private static final net.minecraftforge.registries.DeferredRegister<FluidType> FLUID_TYPES = net.minecraftforge.registries.DeferredRegister.create(ForgeRegistries.Keys.FLUID_TYPES, InfinityMod.MOD_ID);
 
     public static final RegistrySupplier<ForgeFlowingFluid.Flowing> IRIDESCENCE_FLOWING =
             FLUIDS.register("flowing_iridescence", () -> new ForgeFlowingFluid.Flowing(iridProp()));
+
     public static final RegistrySupplier<ForgeFlowingFluid.Source> IRIDESCENCE_STILL =
             FLUIDS.register("iridescence", () -> new ForgeFlowingFluid.Source(iridProp()));
 
     public static ForgeFlowingFluid.Properties iridProp() {
-        return (new ForgeFlowingFluid.Properties(FluidTypes.IRIDESCENCE_TYPE,
+        return (new ForgeFlowingFluid.Properties(IRIDESCENCE_TYPE,
                 IRIDESCENCE_STILL, IRIDESCENCE_FLOWING))
                 .bucket(ModItems.IRIDESCENCE_BUCKET)
                 .block(ModBlocks.IRIDESCENCE);
     }
 
-    public static void registerModFluids() {
+    public static final RegistryObject<FluidType> IRIDESCENCE_TYPE = FLUID_TYPES.register("iridescence",
+            () -> new IridescentFluidType(FluidType.Properties.create()
+                    .descriptionId("fluid.infinity.iridescence")
+                    .fallDistanceModifier(0F)
+                    .canExtinguish(true)
+                    .canConvertToSource(true)
+                    .supportsBoating(true)
+                    .canSwim(true)
+                    .canHydrate(true)
+                    .sound(SoundActions.BUCKET_FILL, SoundEvents.ITEM_BUCKET_FILL)
+                    .sound(SoundActions.BUCKET_EMPTY, SoundEvents.ITEM_BUCKET_EMPTY)
+                    .sound(SoundActions.FLUID_VAPORIZE, SoundEvents.BLOCK_FIRE_EXTINGUISH)
+                    .pathType(PathNodeType.WATER)
+                    .adjacentPathType(PathNodeType.WATER)) {
+
+                @Override
+                public void initializeClient(Consumer<IClientFluidTypeExtensions> consumer) {
+                    consumer.accept(new IClientFluidTypeExtensions() {
+                        private static final Identifier IRIDESCENCE = InfinityMethods.getId("block/iridescence");
+
+                        @Override
+                        public @NotNull Identifier getStillTexture() {
+                            return IRIDESCENCE;
+                        }
+
+                        @Override
+                        public @NotNull Identifier getFlowingTexture() {
+                            return IRIDESCENCE;
+                        }
+
+                        @Override
+                        public int getTintColor(@NotNull FluidState state, @NotNull BlockRenderView getter, @NotNull BlockPos pos) {
+                            return ColorHelper.Abgr.toOpaque(Iridescence.getPosBasedColor(pos));
+                        }
+                    });
+                }
+            });
+
+    public static class IridescentFluidType extends FluidType {
+        public IridescentFluidType(Properties properties) {
+            super(properties);
+        }
+        @Override
+        public PathNodeType getBlockPathType(@NotNull FluidState state, @NotNull BlockView level, @NotNull BlockPos pos,
+                                             @Nullable MobEntity mob, boolean canFluidLog) {
+            return canFluidLog ? super.getBlockPathType(state, level, pos, mob, true) : null;
+        }
+        @Override
+        public boolean canConvertToSource(@NotNull FluidState state, @NotNull WorldView reader, @NotNull BlockPos pos) {
+            if (reader instanceof World level) {
+                return Iridescence.isInfinite(level);
+            }
+            //Best guess fallback to default (true)
+            return super.canConvertToSource(state, reader, pos);
+        }
+        @Override
+        public boolean isVaporizedOnPlacement(@NotNull World w, @NotNull BlockPos pos, @NotNull FluidStack stack) {
+            return false;
+        }
+    }
+
+    public static FluidInteractionRegistry.InteractionInformation getIridescentInteraction(FluidType type) {
+        return new FluidInteractionRegistry.InteractionInformation(
+                (level, currentPos, relativePos, currentState) -> level.getFluidState(relativePos).getFluidType() == type,
+                (level, currentPos, relativePos, currentState) -> {
+                    level.setBlockState(currentPos, ForgeEventFactory.fireFluidPlaceBlockEvent(level, currentPos, currentPos,
+                            currentState.isStill() ? Blocks.OBSIDIAN.getDefaultState() :
+                                    Iridescence.getRandomColorBlock(level,"glazed_terracotta").getDefaultState()));
+                    level.syncWorldEvent(1501, currentPos, 0);
+                });
+    }
+
+    public static void registerModFluids(IEventBus bus) {
         FLUIDS.register();
+        FLUID_TYPES.register(bus);
+    }
+
+    public static void registerFluidInteractions() {
+        FluidInteractionRegistry.addInteraction(ForgeMod.LAVA_TYPE.get(), getIridescentInteraction(IRIDESCENCE_TYPE.get()));
     }
 }

forge/src/main/java/net/lerariemann/infinity/forge/InfinityModForge.java

···
 @Mod(InfinityMod.MOD_ID)
 public final class InfinityModForge {
     public InfinityModForge() {
+        FMLJavaModLoadingContext context = FMLJavaModLoadingContext.get();
         // Register compat file ASAP to prevent a Canary crash.
         if (Platform.isModLoaded("canary"))
             CanaryCompat.writeCompatFile();
···
         if (Platform.isModLoaded("radium"))
             RadiumCompat.writeCompatFile();
         // Submit our event bus to let Architectury API register our content on the right time.
-        EventBuses.registerModEventBus(InfinityMod.MOD_ID, FMLJavaModLoadingContext.get().getModEventBus());
-        IEventBus eventBus = FMLJavaModLoadingContext.get().getModEventBus();
+        EventBuses.registerModEventBus(InfinityMod.MOD_ID, context.getModEventBus());
+        IEventBus eventBus = context.getModEventBus();
         // Run our common setup.
         InfinityMod.init();
         // Run our client setup.
         if (FMLEnvironment.dist == Dist.CLIENT)
-            InfinityModForgeClient.initializeClient(eventBus);
+            InfinityModForgeClient.initializeClient(context, eventBus);
         // Run any remaining Forge specific tasks.
         eventBus.addListener(InfinityModForge::registerSpawns);
         eventBus.addListener(InfinityModForge::commonSetup);
-        eventBus.addListener(FluidTypes::registerFluidInteractions);
         MinecraftForge.EVENT_BUS.addListener(InfinityModForge::sliderSpamFix);
-        
-        FluidTypes.registerFluidTypes(eventBus);
-        ModFluidsForge.registerModFluids();
+
+        ModFluidsForge.registerModFluids(eventBus);
         ModEffectsForge.register(eventBus);
         ModTags.IRIDESCENT_ITEMS = ItemTags.create(InfinityMethods.getId("iridescent"));
     }
···
         ModItemFunctions.registerDispenserBehaviour();
         if (isCreateLoaded())
             CreateCompat.register();
+        ModFluidsForge.registerFluidInteractions();
     }
 }

forge/src/main/java/net/lerariemann/infinity/forge/client/InfinityModForgeClient.java

···
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.core.ModItemFunctions;
 import net.lerariemann.infinity.registry.core.ModItems;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.PlatformMethods;
 import net.lerariemann.infinity.compat.forge.ModConfigFactory;
 import net.minecraft.client.render.RenderLayer;
···
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.ModLoadingContext;
 import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
 
 public class InfinityModForgeClient {
 
-    public static void initializeClient(IEventBus eventBus) {
+    public static void initializeClient(FMLJavaModLoadingContext context, IEventBus eventBus) {
         InfinityModClient.initializeClient();
-        InfinityModForgeClient.registerModsPage();
+        InfinityModForgeClient.registerModsPage(ModLoadingContext.get());
         eventBus.addListener(InfinityModForgeClient::registerBlockColorHandlers);
         eventBus.addListener(InfinityModForgeClient::registerItemColorHandlers);
         eventBus.addListener(InfinityModForgeClient::registerFluidRenderLayers);
···
     }
 
     //Integrate Cloth Config screen (if mod present) with Forge mod menu.
-    public static void registerModsPage() {
-        if (clothConfigInstalled()) ModLoadingContext.get().registerExtensionPoint(ConfigScreenHandler.ConfigScreenFactory.class, () -> new ConfigScreenHandler.ConfigScreenFactory(ModConfigFactory::createScreen));
+    public static void registerModsPage(ModLoadingContext context) {
+        if (clothConfigInstalled()) context.registerExtensionPoint(ConfigScreenHandler.ConfigScreenFactory.class, () -> new ConfigScreenHandler.ConfigScreenFactory(ModConfigFactory::createScreen));
     }
 
     // Apply colour handlers to tint Neither Portals and Book Boxes.
     @SubscribeEvent
     public static void registerBlockColorHandlers(RegisterColorHandlersEvent.Block event) {
-        event.register(PlatformMethods::getNeitherPortalColour, ModBlocks.PORTAL.get());
-        event.register(PlatformMethods::getBookBoxColour, ModBlocks.BOOK_BOX.get(), ModBlocks.IRIDESCENCE.get());
+        event.register(InfinityMethods::getBlockEntityColor,
+                ModBlocks.PORTAL.get(),
+                ModBlocks.BIOME_BOTTLE.get(),
+                ModBlocks.CHROMATIC_WOOL.get(),
+                ModBlocks.CHROMATIC_CARPET.get());
+        event.register(InfinityMethods::getBookBoxColor,
+                ModBlocks.BOOK_BOX.get());
     }
     @SubscribeEvent
     public static void registerItemColorHandlers(RegisterColorHandlersEvent.Item event) {
-        event.register(PlatformMethods::getOverlayColorFromComponents, ModItems.TRANSFINITE_KEY.get(), ModItems.BIOME_BOTTLE_ITEM.get());
+        event.register(InfinityMethods::getOverlayColorFromComponents,
+                ModItems.TRANSFINITE_KEY.get(),
+                ModItems.BIOME_BOTTLE_ITEM.get(),
+                ModItems.F4.get(),
+                ModItems.CHROMATIC_WOOL.get(),
+                ModItems.CHROMATIC_CARPET.get(),
+                ModItems.CHROMATIC_MATTER.get());
+        event.register(InfinityMethods::getPortalItemColor,
+                ModItems.PORTAL_ITEM.get());
     }
     @SubscribeEvent
     public static void registerModelPredicates(FMLClientSetupEvent event) {

forge/src/main/java/net/lerariemann/infinity/util/forge/PlatformMethodsImpl.java

···
 
     public static boolean acidTest(Entity entity, boolean eyes) {
         if (entity instanceof PlayerEntity) return false;
-        if (eyes) return entity.isEyeInFluidType(FluidTypes.IRIDESCENCE_TYPE.get());
-        return entity.isInFluidType(FluidTypes.IRIDESCENCE_TYPE.get());
+        if (eyes) return entity.isEyeInFluidType(ModFluidsForge.IRIDESCENCE_TYPE.get());
+        return entity.isInFluidType(ModFluidsForge.IRIDESCENCE_TYPE.get());
     }
 
     public static double acidHeightTest(Entity entity) {
         if (entity instanceof PlayerEntity) return -1;
-        return entity.getFluidTypeHeight(FluidTypes.IRIDESCENCE_TYPE.get());
+        return entity.getFluidTypeHeight(ModFluidsForge.IRIDESCENCE_TYPE.get());
     }
 
     public static Function<Item.Settings, ? extends StarOfLangItem> getStarOfLangConstructor() {

gradle.properties

···
 org.gradle.parallel=true
 
 # Mod properties
-mod_version = 2.4.3
+mod_version = 2.4.5
 maven_group = net.lerariemann
 archives_name = infinity
 enabled_platforms = fabric,forge
-tbversion = 4
+tbversion = 0
 
 # Minecraft properties
 minecraft_version = 1.20.1
···
 architectury_api_version = 9.2.14
 
 # Fabric Dependencies
-fabric_loader_version = 0.16.8
+fabric_loader_version = 0.16.10
 fabric_api_version = 0.92.2+1.20.1
 
 # Forge Dependencies
-forge_version = 1.20.1-47.3.33
+forge_version = 1.20.1-47.1.3
 forgified_fabric_api_version = 0.92.2+1.11.8+1.20.1
 
 # Optional Dependencies
···
 cct_version = 1.115.0
 gravity_changer_version = 1.0.2
 cca_version = 5.2.2
-emi_version = 1.1.3
+emi_version = 1.1.20
 
 # Create - Fabric
 # https://modrinth.com/mod/create-fabric/versions