initial work backporting release 2.4

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

···
 public class InfinityMod {
 	public static final String MOD_ID = "infinity";
 	public static final Logger LOGGER = LoggerFactory.getLogger("Infinite Dimensions");
-	public static Path configPath = PlatformMethods.getConfigPath()
+	public static Path configPath = PlatformMethods.getConfigPath();
 	public static Path utilPath = configPath.resolve(".util");
 	public static Path invocationLock = configPath.resolve("modular/invocation.lock");
 
···
 		rootConfigPathInJar = PlatformMethods.getRootConfigPath();
 		ConfigManager.updateInvocationLock();
 		ConfigManager.unpackDefaultConfigs();
-		ModComponentTypes.registerComponentTypes();
 		ModStatusEffects.registerModEffects();
 		ModItemFunctions.registerItemFunctions();
 		ModEntities.registerEntities();

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

···
 import net.lerariemann.infinity.block.entity.BiomeBottleBlockEntity;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.var.ModCriteria;
+import net.lerariemann.infinity.util.BackportMethods;
 import net.lerariemann.infinity.util.var.BishopBattle;
 import net.minecraft.block.*;
-import net.minecraft.component.ComponentChanges;
-import net.minecraft.component.DataComponentTypes;
-import net.minecraft.component.type.BlockStateComponent;
-import net.minecraft.component.type.CustomModelDataComponent;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.DyeItem;
 import net.minecraft.item.ItemStack;
···
         world.setBlockState(pos, state.with(COLOR, i));
     }
 
-    public static ComponentChanges toComponentChanges(BlockState state) {
-        int color = state.get(AltarBlock.COLOR);
-        boolean flower = state.get(AltarBlock.FLOWER);
-        if (color > 0 || flower) return ComponentChanges.builder().add(DataComponentTypes.BLOCK_STATE,
-                        new BlockStateComponent(Map.of())
-                                .with(AltarBlock.COLOR, color)
-                                .with(AltarBlock.FLOWER, flower))
-                .add(DataComponentTypes.CUSTOM_MODEL_DATA, new CustomModelDataComponent(color +
-                        (flower ? AltarBlock.numColors : 0)))
-                .build();
-        return ComponentChanges.EMPTY;
-    }
-
     @Override
-    public ItemStack getPickStack(WorldView world, BlockPos pos, BlockState state) {
+    public ItemStack getPickStack(BlockView world, BlockPos pos, BlockState state) {
         ItemStack res = super.getPickStack(world, pos, state);
-        res.applyChanges(toComponentChanges(state));
         return res;
     }
 

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

···
     }
 
     @Override
-    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
+    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) {
         if (player.getStackInHand(Hand.MAIN_HAND).isOf(ModItems.STAR_OF_LANG.get())) {
             BlockState state1 = toStatic(state);
             if (state1 != null) {

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

···
         color = Color.HSBtoRGB(hue / 360f, saturation / 255f, brightness / 255f) & 0xFFFFFF;
     }
 
-    @Override
-    protected void addComponents(ComponentMap.Builder componentMapBuilder) {
-        super.addComponents(componentMapBuilder);
-        componentMapBuilder.add(ModComponentTypes.COLOR.get(), color);
-    }
-    @Override
-    protected void readComponents(BlockEntity.ComponentsAccess components) {
-        super.readComponents(components);
-        setColor(components.getOrDefault(ModComponentTypes.COLOR.get(), 0xFFFFFF));
-    }
-
-    public static ComponentMap asMap(int i) {
-        return ComponentMap.builder()
-                .add(ModComponentTypes.COLOR.get(), i)
-                .build();
-    }
-    public ComponentMap asMap() {
-        return asMap(getTint());
-    }
     public short offset(short orig, short amount, AtomicBoolean cancel) {
         if (amount < 0 ? orig == 0 : orig == 255) {
             cancel.set(true);
···
 
     @Override
     public void readNbt(NbtCompound nbt) {
-        super.readNbt(nbt, registryLookup);
+        super.readNbt(nbt);
         if (nbt.contains("color", NbtElement.INT_TYPE))
             setColor(nbt.getInt("color"));
         else if (nbt.contains("color", NbtElement.COMPOUND_TYPE)) {
···
     }
     @Override
     protected void writeNbt(NbtCompound nbt) {
-        super.writeNbt(nbt, registryLookup);
+        super.writeNbt(nbt);
         NbtCompound color = new NbtCompound();
         color.putShort("h", hue);
         color.putShort("s", saturation);

common/src/main/java/net/lerariemann/infinity/compat/emi/ChromaticEmiRecipe.java

···
 
     @Override
     public void addWidgets(WidgetHolder widgets) {
-        widgets.addSlot(inputs.getFirst(), 0, 0);
+        widgets.addSlot(inputs.get(0), 0, 0);
         MutableText text = Text.translatable(Util.createTranslationKey("chromatic", this.id));
         Map<Integer, MutableText> chars = new HashMap<>();
         text.asOrderedText().accept((index, style, codepoint) -> {
···
         for (int i = 0; i < len; i++) {
             MutableText ch = chars.get(i);
             if (ch == null) continue;
-            finalText.append(ch.withColor(getCharColor(i, len)));
+            var chStyle = ch.setStyle(Style.EMPTY.withColor(getCharColor(i, len)));
+            finalText.append(chStyle);
         }
         if (infoId != null)
             widgets.add(new TextWidgetWithTooltip(Text.literal("ℹ").formatted(Formatting.GRAY)

common/src/main/java/net/lerariemann/infinity/compat/emi/EmiCompat.java

···
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.PlatformMethods;
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.component.DataComponentTypes;
-import net.minecraft.component.type.PotionContentsComponent;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
 import net.minecraft.potion.Potions;
 import net.minecraft.recipe.Ingredient;
-import net.minecraft.recipe.RecipeEntry;
 import net.minecraft.recipe.RecipeManager;
 import net.minecraft.registry.DynamicRegistryManager;
 import net.minecraft.util.Identifier;

common/src/main/java/net/lerariemann/infinity/compat/emi/IridesenceCraftingEmiRecipe.java

···
 import net.minecraft.registry.DynamicRegistryManager;
 
 public class IridesenceCraftingEmiRecipe extends BasicEmiRecipe {
-    public IridesenceCraftingEmiRecipe(RecipeEntry<CollisionCraftingRecipe> recipeEntry, DynamicRegistryManager registryManager) {
-        super(EmiCompat.IRIDESCENCE_CRAFTING, recipeEntry.id(), 118, 18);
-        CollisionCraftingRecipe recipe = recipeEntry.value();
-        this.inputs.add(EmiIngredient.of(recipe.getInput()));
-        this.outputs.add(EmiStack.of(recipe.getOutput(registryManager)));
+    public IridesenceCraftingEmiRecipe(CollisionCraftingRecipe recipeEntry, DynamicRegistryManager registryManager) {
+        super(EmiCompat.IRIDESCENCE_CRAFTING, recipeEntry.getId(), 118, 18);
+        this.inputs.add(EmiIngredient.of(recipeEntry.getInput()));
+        this.outputs.add(EmiStack.of(recipeEntry.getOutput(registryManager)));
     }
 
     @Override

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

···
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.predicate.entity.EntityPredicates;
 import net.minecraft.registry.tag.FluidTags;
+import net.minecraft.scoreboard.AbstractTeam;
 import net.minecraft.scoreboard.Team;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundEvent;

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

···
     }
 
     @Override
-    public boolean canBeLeashed() {
+    public boolean canBeLeashedBy(PlayerEntity player) {
         return !isInBattle();
     }
+    
     @Override
     public boolean canWalkOnFluid(FluidState state) {
         return state.isIn(FluidTags.WATER);
···
     @Override
     public ActionResult interactMob(PlayerEntity player, Hand hand) {
         if (!this.hasPassengers()
-                && this.getAttributeValue(EntityAttributes.GENERIC_SCALE) > 2
                 && player.getStackInHand(hand).isEmpty()) {
             this.putPlayerOnBack(player);
             return ActionResult.success(this.getWorld().isClient);

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

···
 
     @Nullable
     @Override
-    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
-        entityData = super.initialize(world, difficulty, spawnReason, entityData);
+    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData, @Nullable NbtCompound entityNbt) {
+        entityData = super.initialize(world, difficulty, spawnReason, entityData, entityNbt);
         updateAttackType();
         return entityData;
     }
···
     }
 
     @Override
-    public void shootAt(LivingEntity target, float pullProgress) {
+    public void attack(LivingEntity target, float pullProgress) {
         ItemStack bow = Items.BOW.getDefaultStack();
         PersistentProjectileEntity persistentProjectileEntity =
                 ProjectileUtil.createArrowProjectile(this, getProjectileType(), pullProgress, bow);
···
                 || effect.getBoolean("Instant")) return Items.ARROW.getDefaultStack();
         return ChaosSkeleton.setPotion(Items.TIPPED_ARROW.getDefaultStack(),
                 effect.getInt("Color"),
-                effect.getString("Name"),
                 200);
     }
 }

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

···
     public int getSuccessors(PathNode[] successors, PathNode node) {
         int i = 0;
         int j = 0;
-        PathNodeType pathNodeType = this.getNodeType(node.x, node.y + 1, node.z);
-        PathNodeType pathNodeType2 = this.getNodeType(node.x, node.y, node.z);
+        PathNodeType pathNodeType = this.getNodeType(this.entity, node.x, node.y + 1, node.z);
+        PathNodeType pathNodeType2 = this.getNodeType(this.entity, node.x, node.y, node.z);
         if (this.entity.getPathfindingPenalty(pathNodeType) >= 0.0F && pathNodeType2 != PathNodeType.STICKY_HONEY) {
             j = MathHelper.floor(Math.max(1.0F, this.entity.getStepHeight()));
         }

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

···
 
     @Override
     @Nullable
-    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData) {
-        initFromBlock(world.getBlockState(this.getBlockPos().down()));
+    public EntityData initialize(ServerWorldAccess world, LocalDifficulty difficulty, SpawnReason spawnReason, @Nullable EntityData entityData, @Nullable NbtCompound entityNbt) {        initFromBlock(world.getBlockState(this.getBlockPos().down()));
         double i = random.nextDouble() * 40;
         Objects.requireNonNull(this.getAttributeInstance(EntityAttributes.GENERIC_MAX_HEALTH)).setBaseValue(i);
         this.setHealth((float)i);
···
         if ((a = (int)(0.1*i)) > 0) {
             this.equipLootStack(
                     EquipmentSlot.HEAD,
-                    Registries.ITEM.get(new Identifier(InfinityMod.provider.randomName(r, "items"))).getDefaultStack().copyWithCount(a));
+                    Registries.ITEM.get(new Identifier(InfinityMod.provider.randomName(i, "items"))).getDefaultStack().copyWithCount(a));
             ((MobEntityAccess)this).infinity$setPersistent(false);
         }
         return super.initialize(world, difficulty, spawnReason, entityData, entityNbt);

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

···
 import net.minecraft.potion.PotionUtil;
 import net.minecraft.potion.Potions;
 import net.minecraft.registry.Registries;
-import net.minecraft.registry.RegistryKeys;
-import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.text.Style;
···
 import net.minecraft.world.ServerWorldAccess;
 import net.minecraft.world.World;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
 
 import java.util.*;
 
···
             }
         }
         if (itemStack.isOf(Items.GLASS_BOTTLE)) {
-            ItemStack itemStack2 = setPotion(Items.POTION.getDefaultStack(), this.getColorForRender(), this.getEffect(), this.getDuration() * 20);
+            ItemStack itemStack2 = setPotion(Items.POTION.getDefaultStack(), this.getEffectRawId(), this.getDuration() * 20);
             ItemStack itemStack3 = ItemUsage.exchangeStack(itemStack, player, itemStack2, false);
             player.setStackInHand(hand, itemStack3);
             this.playSound(SoundEvents.ITEM_BOTTLE_FILL, 1.0f, 1.0f);
···
     public String getEffect() {
         return this.dataTracker.get(effect);
     }
+
+    public int getEffectRawId() {
+        return reg.getRawId(getEffect());
+    }
+
     @Override
-    public int getColor() {
+    public int getColorRaw() {
         return this.dataTracker.get(color);
     }
 

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

···
         this.dataTracker.set(color, c);
     }
     @Override
-    public int getColor() {
+    public Vector3f getColor() {
         return this.dataTracker.get(color);
     }
 
···
 
     @Override
     protected ParticleEffect getParticles() {
-        return new DustParticleEffect(particleColorFromInt(this.getColorForRender()), 1.0f);
+        return new DustParticleEffect(particleColorFromInt(this.getColorRaw()), 1.0f);
     }
     @Override
     protected SoundEvent getHurtSound(DamageSource source) {
···
     @Override
     public void writeCustomDataToNbt(NbtCompound nbt) {
         super.writeCustomDataToNbt(nbt);
-        nbt.putInt("color", getColor());
+        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.putString("core", Registries.BLOCK.getId(this.getCore().getBlock()).toString());
     }
 

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

···
 import java.awt.*;
 
 public interface TintableEntity {
+    boolean hasCustomName();
+    Text getName();
+    int getId();
+    int getAge();
+
     default Vector3f particleColorFromInt(int i) {
         float f = (float)(i >> 16 & 0xFF) / 255.0f;
         float g = (float)(i >> 8 & 0xFF) / 255.0f;
         float h = (float)(i & 0xFF) / 255.0f;
         return new Vector3f(f, g, h);
     }
+
+
     default Vector3f getColorNamed() {
         if (hasCustomName()) {
             String s = getName().getString();
···
                 int n = getAge() + getId();
                 float hue = n / 400.f;
                 hue = hue - (int) hue;
-                return colorFromInt(Color.getHSBColor(hue, 1.0f, 1.0f).getRGB());
+                return particleColorFromInt(Color.getHSBColor(hue, 1.0f, 1.0f).getRGB());
             }
         }
         return null;
     }
 
-    default int getColorForRender() {
-        int v = getColorNamed();
-        if (v!=-1) return v;
-        return ColorHelper.Argb.fullAlpha(this.getColor());
+    default Vector3f getColor() {
+        Vector3f v = getColorNamed();
+        if (v!=null) return v;
+        return particleColorFromInt(this.getColorRaw());
     }
-
-    default int getColor() {
+    default int getColorRaw() {
         return 0;
     }
     default float getAlpha() {

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

···
             DyeColor.PINK);
 
     static Block getRandomColorBlock(WorldAccess world, String str) {
-        return Registries.BLOCK.get(Identifier.of(dyeColors.get(world.getRandom().nextInt(dyeColors.size())).getName() + "_" + str));
+        return Registries.BLOCK.get(new Identifier(dyeColors.get(world.getRandom().nextInt(dyeColors.size())).getName() + "_" + str));
     }
     static Block getRandomColorBlock(double d, String str) {
-        return Registries.BLOCK.get(Identifier.of(dyeColors.get((int)(d* dyeColors.size())).getName() + "_" + str));
+        return Registries.BLOCK.get(new Identifier(dyeColors.get((int)(d* dyeColors.size())).getName() + "_" + str));
     }
 
     int ticksInHour = 1200;
···
         }
         return -1;
     }
-
-    int ticksInHour = 1200;
 
     static int getFullEffectLength(int amplifier) {
         return getOnsetLength() + getEffectLength(amplifier);
···
     static void tryBeginJourney(LivingEntity entity, int amplifier, boolean willingly) {
         amplifier = Iridescence.getAmplifierOnApply(entity, amplifier);
         if (amplifier >= 0) {
-            entity.addStatusEffect(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT,
+            entity.addStatusEffect(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT.value(),
                     Iridescence.getFullEffectLength(amplifier),
                     amplifier, true, true));
             entity.removeStatusEffect(ModStatusEffects.IRIDESCENT_COOLDOWN.value());
···
                 entity.addStatusEffect(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_COOLDOWN.value(),
                         cooldownDuration, amplifier > 0 ? 1 : 0, true, false));
             if (entity instanceof ServerPlayerEntity player) {
-                ModCriteria.IRIDESCENT.get().trigger(player, willingly, amplifier);
+                ModCriteria.IRIDESCENT.trigger(player, willingly, amplifier);
             }
         }
     }

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

···
     @Override
     public void onEntityCollision(BlockState state, World world, BlockPos pos, Entity entity) {
         super.onEntityCollision(state, world, pos, entity);
-        if (world.getFluidState(pos).getLevel() > 3 && world instanceof ServerWorld w) switch (entity) {
-            case PlayerEntity player -> Iridescence.tryBeginJourney(player, 4, false);
-            case MobEntity ent -> Iridescence.tryApplyEffect(ent);
-            case ItemEntity item -> {
+        if (world.getFluidState(pos).getLevel() > 3 && world instanceof ServerWorld w) {
+            if (Objects.requireNonNull(entity) instanceof PlayerEntity player) {
+                Iridescence.tryBeginJourney(player, 4, false);
+            } else if (entity instanceof MobEntity ent) {
+                Iridescence.tryApplyEffect(ent);
+            } else if (entity instanceof ItemEntity item) {
                 if (!Iridescence.isIridescentItem(item.getStack()) && item.getOwner() instanceof LivingEntity le &&
                         !Iridescence.getPhase(le).equals(Iridescence.Phase.INITIAL))
                     ModItemFunctions.checkCollisionRecipes(w, item, ModItemFunctions.IRIDESCENCE_CRAFTING_TYPE.get(),
                             new NbtCompound());
             }
+        }
     }
-}
+}

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.particle.ParticleEffect;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.util.Identifier;
···
     }
 
     public void onRemoved(LivingEntity entity) {
-        switch (entity) {
-            case ServerPlayerEntity player -> {
-                unloadShader(player);
-                if (player.isInvulnerable()) endJourney(player, true, 0);
-            }
-            case ChaosPawn pawn -> {
-                if (pawn.getRandom().nextBoolean()) {
-                    pawn.unchess();
-                    pawn.playSound(SoundEvents.ENTITY_ZOMBIE_VILLAGER_CONVERTED, 1.0f, 1.0f);
-                    convTriggers(pawn);
-                }
-            }
-            case MobEntity currEntity -> endConversion(currEntity);
-            default -> {
+        if (Objects.requireNonNull(entity) instanceof ServerPlayerEntity player) {
+            unloadShader(player);
+            if (player.isInvulnerable()) endJourney(player, true, 0);
+        } else if (entity instanceof ChaosPawn pawn) {
+            if (pawn.getRandom().nextBoolean()) {
+                pawn.unchess();
+                pawn.playSound(SoundEvents.ENTITY_ZOMBIE_VILLAGER_CONVERTED, 1.0f, 1.0f);
+                convTriggers(pawn);
             }
+        } else if (entity instanceof MobEntity currEntity) {
+            endConversion(currEntity);
         } else if (entity instanceof MobEntity currEntity) {
             endConversion(currEntity);
         } else if (entity instanceof MobEntity currEntity) {
···
         }
     }
 
-    @Override
-    public ParticleEffect createParticle(StatusEffectInstance effect) {
-        float hue = effect.getDuration() / 13.0f;
-        return EntityEffectParticleEffect.create(
-                ParticleTypes.ENTITY_EFFECT, ColorHelper.Argb.fullAlpha(Color.HSBtoRGB(hue - (int)hue, 1.0f, 1.0f)));
-    }
-
     public static class Setup extends InstantStatusEffect {
         public Setup(StatusEffectCategory category, int color) {
             super(category, color);
         }
 
         @Override
-        public void onApplied(LivingEntity entity, int amplifier) {
-            super.onApplied(entity, amplifier);
+        public void onApplied(LivingEntity entity, AttributeContainer attributes, int amplifier) {
+            super.onApplied(entity, attributes, amplifier);
             tryBeginJourney(entity, amplifier, true);
         }
     }

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

···
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.util.BackportMethods;
+import net.lerariemann.infinity.util.var.ColorLogic;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.BlockItem;
 import net.minecraft.item.ItemStack;
+import net.minecraft.text.Style;
+import net.minecraft.text.Text;
 import net.minecraft.util.Hand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
···
         super(block, settings);
     }
 
-    @Override
-    public ComponentChanges.Builder getPortalComponents(InfinityPortalBlockEntity ipbe) {
-        return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), ipbe.getPortalColor());
-    }
-
     //todo: implement this properly
     @Override
     protected boolean postPlacement(BlockPos pos, World world, @Nullable PlayerEntity player, ItemStack stack, BlockState state) {
···
         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.COLOR, 0xFFFFFF));
+            cbe.setColor(BackportMethods.getOrDefaultInt(stack, ModComponentTypes.KEY_COLOR, 0xFFFFFF));
         }
         return bl;
+    }
+
+    @Override
+    public Text getName() {
+        return Text.translatable(this.getTranslationKey()).setStyle(Style.EMPTY.withColor(ColorLogic.defaultChromatic));
     }
 }

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.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
+import net.lerariemann.infinity.registry.var.ModTags;
 import net.lerariemann.infinity.util.BackportMethods;
 import net.lerariemann.infinity.util.var.ColorLogic;
 import net.minecraft.block.BlockState;
···
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUsageContext;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.text.Style;
+import net.minecraft.text.Text;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.DyeColor;
 import net.minecraft.util.Hand;
 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 ComponentChanges ofColor(int color) {
-        return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), color)
-                .remove(ModComponentTypes.DYE_COLOR.get())
-                .remove(ModComponentTypes.HUE.get())
-                .build();
-    }
-    static ComponentChanges ofHue(int hue) {
-        return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), Color.HSBtoRGB(hue/360f, 1.0f, 1.0f) & 0xFFFFFF)
-                .remove(ModComponentTypes.DYE_COLOR.get())
-                .add(ModComponentTypes.HUE.get(), hue)
-                .build();
-    }
-    static ComponentChanges ofDye(DyeColor dyeColor) {
-        return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), ColorLogic.getChromaticColor(dyeColor))
-                .add(ModComponentTypes.DYE_COLOR.get(), dyeColor.getName())
-                .remove(ModComponentTypes.HUE.get())
-                .build();
-    }
-
     @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 = currStack.getOrDefault(ModComponentTypes.COLOR.get(), 0xFFFFFF);
+        int currColor = BackportMethods.getOrDefaultInt(currStack, ModComponentTypes.KEY_COLOR, 0xFFFFFF);
         if (player.isSneaking()) { //copy color
             ItemStack newStack = currStack.copy();
             int i = -1;
···
                 else {
                     int hue = (altarState - 1) * (360 / (AltarBlock.numColors - 1));
                     if (!ColorLogic.matchesPureHue(currColor, hue))
-                        newStack.applyChanges(ofHue(hue));
+                        BackportMethods.apply(newStack, ModComponentTypes.HUE, hue);
                     else return false;
                 }
             }
             else { //copy color from vanilla blocks
                 DyeColor dyeColor = ColorLogic.getColorByState(oldState);
                 if (dyeColor != null &&
-                        !dyeColor.getName().equals(newStack.getOrDefault(ModComponentTypes.DYE_COLOR.get(), "null"))) {
-                    newStack.applyChanges(ofDye(dyeColor));
+                        !(dyeColor.getId() == (BackportMethods.getOrDefaultInt(newStack, ModComponentTypes.DYE_COLOR, -1)))) {
+                    BackportMethods.apply(newStack, ModComponentTypes.DYE_COLOR, dyeColor.getId());
                 }
                 else return false;
             }
             if (i > 0) {
-                if (i != currColor) newStack.applyChanges(ofColor(i));
+                if (i != currColor) BackportMethods.apply(newStack, ModComponentTypes.DYE_COLOR, i);
                 else return false;
             }
             player.setStackInHand(hand, newStack);
···
         }
         else { //paste color to blocks
             if (oldState.isIn(ModTags.IRIDESCENT_BLOCKS)) return false;
-            boolean bl = currStack.contains(ModComponentTypes.DYE_COLOR.get());
-            BlockState state = ColorLogic.recolor(bl ? currStack.get(ModComponentTypes.DYE_COLOR.get()) : "infinity:chromatic", oldState);
+            boolean bl = BackportMethods.contains(currStack, ModComponentTypes.DYE_COLOR);
+            BlockState state;
+            if (bl) state = ColorLogic.recolor(BackportMethods.getOrDefaultString(currStack, ModComponentTypes.DYE_COLOR, "infinity:chromatic"), oldState);
+            else state = ColorLogic.recolor("infinity:chromatic", oldState);
             if (state == null) return false;
             world.setBlockState(pos, state);
             AtomicBoolean cancel = new AtomicBoolean(false);
             if (!bl && world.getBlockEntity(pos) instanceof ChromaticBlockEntity cbe) {
-                int hue = currStack.getOrDefault(ModComponentTypes.HUE.get(), -1);
+                int hue = BackportMethods.getOrDefaultInt(currStack, ModComponentTypes.HUE, -1);
                 if (hue > 0) cbe.setColor(hue, 255, 255, cancel);
                 else cbe.setColor(currColor, cancel);
             }
···
             }
         }
         return false;
+    }
+
+    @Override
+    public Text getName() {
+        return Text.translatable(this.getTranslationKey()).setStyle(Style.EMPTY.withColor(ColorLogic.defaultChromatic));
     }
 }

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

···
         BlockPos lowerCenter = player.getBlockPos().offset(dir, 4);
         ItemStack stack = player.getStackInHand(hand);
 
-        int size_x = BackportMethods.getOrDefaultInt(stack, ModItemFunctions.SIZE_X, 3);
-        int size_y =  BackportMethods.getOrDefaultInt(stack, ModItemFunctions.SIZE_Y, 3);
+        int size_x = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.SIZE_X, 3);
+        int size_y =  BackportMethods.getOrDefaultInt(stack, ModComponentTypes.SIZE_Y, 3);
 
         if (size_y % 2 == 0) {
             double d = dir2.equals(Direction.Axis.X) ? player.getPos().x : player.getPos().z;
···
         Direction.Axis dir2 =
                 player.getHorizontalFacing().getAxis().equals(Direction.Axis.X) ? Direction.Axis.Z : Direction.Axis.X;
 
-        int size_x = BackportMethods.getOrDefaultInt(stack, ModItemFunctions.SIZE_X, 3);
-        int size_y = BackportMethods.getOrDefaultInt(stack, ModItemFunctions.SIZE_Y, 3);
+        int size_x = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.SIZE_X, 3);
+        int size_y = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.SIZE_Y, 3);
 
         //validating the place position
         for (int j = -1; j <= size_y; j++) for (int k = -1; k <= size_x; k++) {

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

···
 import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModStatusEffects;
+import net.lerariemann.infinity.util.BackportMethods;
+import net.lerariemann.infinity.util.var.ColorLogic;
 import net.minecraft.advancement.criterion.Criteria;
-import net.minecraft.component.type.PotionContentsComponent;
+import net.minecraft.client.item.TooltipContext;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.player.PlayerEntity;
···
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUsage;
 import net.minecraft.item.Items;
-import net.minecraft.item.tooltip.TooltipType;
+import net.minecraft.potion.PotionUtil;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.stat.Stats;
+import net.minecraft.text.Style;
 import net.minecraft.text.Text;
 import net.minecraft.util.Hand;
 import net.minecraft.util.TypedActionResult;
···
     }
 
     @Override
+    public boolean hasGlint(ItemStack stack) {
+        return true;
+    }
+
+    @Override
     public ItemStack finishUsing(ItemStack stack, World world, LivingEntity user) {
-        int level = stack.getOrDefault(ModComponentTypes.CHARGE.get(), 0);
+        int level = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.F4_CHARGE, 0);
         if (!world.isClient) Iridescence.tryBeginJourney(user, level, true);
         if (user instanceof PlayerEntity player) {
             if (user instanceof ServerPlayerEntity spe) {
                 Criteria.CONSUME_ITEM.trigger(spe, stack);
             }
             player.incrementStat(Stats.USED.getOrCreateStat(this));
-            stack.decrementUnlessCreative(1, player);
 
-            if (!player.isInCreativeMode())
+            if (!player.isCreative()) {
+                stack.decrement(1);
                 player.getInventory().insertStack(new ItemStack(Items.GLASS_BOTTLE));
+            }
+
         }
         else if (stack.isEmpty()) {
             return new ItemStack(Items.GLASS_BOTTLE);
···
     }
 
     @Override
-    public int getMaxUseTime(ItemStack stack, LivingEntity user) {
+    public int getMaxUseTime(ItemStack stack) {
         return 32;
     }
 
···
     }
 
     @Override
-    public void appendTooltip(ItemStack stack, Item.TooltipContext context, List<Text> tooltip, TooltipType type) {
-        int level = stack.getOrDefault(ModComponentTypes.CHARGE.get(), 0);
-        List<StatusEffectInstance> effects = List.of(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT,
+    public void appendTooltip(ItemStack stack, World world, List<Text> tooltip, TooltipContext type) {
+        int level = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.F4_CHARGE, 0);
+        List<StatusEffectInstance> effects = List.of(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT.value(),
                 Iridescence.getFullEffectLength(level), level));
-        PotionContentsComponent.buildTooltip(effects, tooltip::add, 1.0F, context.getUpdateTickRate());
+        PotionUtil.buildTooltip(effects, tooltip::add, 1.0F, level);
+    }
+
+    @Override
+    public Text getName() {
+        return Text.translatable(this.getTranslationKey()).setStyle(Style.EMPTY.withColor(ColorLogic.defaultChromatic));
     }
 }

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

···
         super(settings);
     }
 
-    @Override
-    public ComponentChanges.Builder getPortalComponents(InfinityPortalBlockEntity ipbe) {
-        Identifier id = ipbe.getDimension();
-        int color = (ipbe.getWorld() instanceof ServerWorld w) ?
-                PortalColorApplier.of(id, w.getServer()).apply(BlockPos.ORIGIN) :
-                (int)InfinityMethods.getNumericFromId(id);
-        return ComponentChanges.builder()
-                .add(ModComponentTypes.DESTINATION.get(), id)
-                .add(ModComponentTypes.COLOR.get(), color & 0xFFFFFF);
-    }
-
     @NotNull
     @Override
     public Identifier getDestination(ItemStack stack) {

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

···
             if (charge > 0) return Items.OBSIDIAN.getDefaultStack().copyWithCount(Math.min(charge, 64)); //"removing obsidian" recipe
         }
         ItemStack result = f4.copy();
-        BackportMethods.apply(result, ModItemFunctions.F4_CHARGE, charge+i);
+        BackportMethods.apply(result, ModComponentTypes.F4_CHARGE, charge+i);
         return result;
     }
 
···
         if (charge == 0) return defaultedList; //"clearing data" recipe
         charge = Math.max(charge - 64, 0);
         ItemStack result = f4.copy();
-        BackportMethods.apply(result, ModItemFunctions.F4_CHARGE, charge);
+        BackportMethods.apply(result, ModComponentTypes.F4_CHARGE, charge);
         defaultedList.set(f4pos, result);
         return defaultedList;
     }

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

···
 package net.lerariemann.infinity.mixin.iridescence;
 
 import net.lerariemann.infinity.registry.core.ModItems;
-import net.minecraft.component.DataComponentTypes;
-import net.minecraft.component.type.PotionContentsComponent;
 import net.minecraft.item.ItemStack;
 import net.minecraft.potion.Potion;
 import net.minecraft.recipe.BrewingRecipeRegistry;
···
 @Mixin(BrewingRecipeRegistry.class)
 public class BrewingRecipeRegistryMixin {
     @Inject(method = "isValidIngredient", at = @At("RETURN"), cancellable = true)
-    void inj(ItemStack stack, CallbackInfoReturnable<Boolean> cir) {
+    private static void inj(ItemStack stack, CallbackInfoReturnable<Boolean> cir) {
         cir.setReturnValue(cir.getReturnValue() || stack.isOf(ModItems.CHROMATIC_MATTER.get()));
     }
 
     @Inject(method="hasPotionRecipe", at = @At("RETURN"), cancellable = true)
-    void inj(ItemStack input, ItemStack ingredient, CallbackInfoReturnable<Boolean> cir) {
+    private static void inj(ItemStack input, ItemStack ingredient, CallbackInfoReturnable<Boolean> cir) {
         if (ingredient.isOf(ModItems.CHROMATIC_MATTER.get())) {
             Optional<RegistryEntry<Potion>> optional = input.getOrDefault(DataComponentTypes.POTION_CONTENTS, PotionContentsComponent.DEFAULT).potion();
-            if (optional.isPresent() && optional.get().matchesId(Identifier.ofVanilla("awkward"))) cir.setReturnValue(true);
+            if (optional.isPresent() && optional.get().matchesId(new Identifier("awkward"))) cir.setReturnValue(true);
         }
     }
 
     @Inject(method = "craft", at = @At("HEAD"), cancellable = true)
-    void inj2(ItemStack ingredient, ItemStack input, CallbackInfoReturnable<ItemStack> cir) {
+    private static void inj2(ItemStack ingredient, ItemStack input, CallbackInfoReturnable<ItemStack> cir) {
         if (!input.isEmpty() && ingredient.isOf(ModItems.CHROMATIC_MATTER.get())) {
             Optional<RegistryEntry<Potion>> optional = input.getOrDefault(DataComponentTypes.POTION_CONTENTS, PotionContentsComponent.DEFAULT).potion();
-            if (optional.isPresent() && optional.get().matchesId(Identifier.ofVanilla("awkward")))
+            if (optional.isPresent() && optional.get().matchesId(new Identifier("awkward")))
                 cir.setReturnValue(ModItems.CHROMATIC_POTION.get().getDefaultStack());
         }
     }

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

···
 import com.llamalad7.mixinextras.sugar.ref.LocalRef;
 import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.registry.var.ModTags;
+import net.minecraft.client.item.TooltipContext;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.item.tooltip.TooltipType;
 import net.minecraft.registry.tag.TagKey;
 import net.minecraft.text.MutableText;
+import net.minecraft.text.Style;
 import net.minecraft.text.Text;
+import net.minecraft.util.DyeColor;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
···
 
     @Inject(method="getTooltip", at = @At(value = "INVOKE",
             target = "Ljava/util/List;add(Ljava/lang/Object;)Z", ordinal = 0))
-    void inj(Item.TooltipContext context, PlayerEntity player, TooltipType type, CallbackInfoReturnable<List<Text>> cir,
-             @Local LocalRef<MutableText> mutableText) {
+    void inj(PlayerEntity player, TooltipContext context, CallbackInfoReturnable<List<Text>> cir, @Local LocalRef<MutableText> mutableText) {
         if (isIn(ModTags.IRIDESCENT_ITEMS)) {
-            mutableText.set(mutableText.get().withColor(Iridescence.getTimeBasedColor()));
+            mutableText.set(mutableText.get().setStyle(Style.EMPTY.withColor(Iridescence.getTimeBasedColor())));
         }
     }
 }

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

···
             });
         }
         InfinityMod.LOGGER.info("Sending sound pack to client");
-        if (InfinityMod.provider.rule("useSoundSyncPackets")) InfinityMethods.sendS2CPayload(player, new ModPayloads.DownloadSoundPack(
-                CommonIO.read(player.server.getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json"))));
+        // TODO soundpacks
+//        if (InfinityMod.provider.rule("useSoundSyncPackets")) InfinityMethods.sendS2CPayload(player, new ModPayloads.DownloadSoundPack(
+//                CommonIO.read(player.server.getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json"))));
     }
 
     @Inject(method="sendWorldInfo", at = @At("TAIL"))

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 COLOR = "color";
+    public static String KEY_COLOR = "key_color";
+    public static String HUE = "hue";
     public static String DYE_COLOR = "dye_color";
     public static String F4_CHARGE = "f4_charge";
     public static String SIZE_X = "f4_size_x";

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

···
 import net.minecraft.block.DispenserBlock;
 import net.minecraft.block.dispenser.ItemDispenserBehavior;
 import net.minecraft.client.world.ClientWorld;
-import net.minecraft.component.ComponentChanges;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.ItemEntity;
 import net.minecraft.entity.LivingEntity;
···
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Optional;
-import java.util.function.Function;
 
 import static net.lerariemann.infinity.InfinityMod.MOD_ID;
 import static net.lerariemann.infinity.registry.core.ModItems.TRANSFINITE_KEY;
 
 public class ModItemFunctions {
-
-    public static String SIZE_X = "f4_size_x";
-    public static String SIZE_Y = "f4_size_y";
-    public static String F4_CHARGE = "f4_charge";
-    public static String DESTINATION = "key_destination";
-    public static String COLOR = "key_color";
 
     public static final DeferredRegister<LootFunctionType> LOOT_FUNCTION_TYPES =
             DeferredRegister.create(MOD_ID, RegistryKeys.LOOT_FUNCTION_TYPE);
···
                 }, w);
         if (match.isEmpty()) return;
 
-        ItemStack resStack = match.get().value().getResult(w.getRegistryManager());
-        componentFunction.apply(resStack.getItem()).ifPresent(resStack::applyChanges);
+        ItemStack resStack = match.get().getOutput(w.getRegistryManager());
+//        componentFunction.apply(resStack.getItem()).ifPresent(resStack::applyChanges);
 
         Vec3d v = itemEntity.getVelocity();
         ItemEntity result = new ItemEntity(w, itemEntity.getX(), itemEntity.getY(), itemEntity.getZ(),

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

···
             registerBlockItemAfter(ModBlocks.IRIDESCENT_CARPET, ItemGroups.COLORED_BLOCKS, Items.PINK_CARPET, BlockItem::new);
     public static final RegistrySupplier<ChromaticBlockItem> CHROMATIC_WOOL  =
             registerBlockItemAfter(ModBlocks.CHROMATIC_WOOL, ItemGroups.COLORED_BLOCKS, Items.PINK_WOOL,
-                    new Item.Settings().component(ModComponentTypes.COLOR.get(), ColorLogic.defaultChromatic),
+                    new Item.Settings(),
                     ChromaticBlockItem::new);
     public static final RegistrySupplier<ChromaticBlockItem> CHROMATIC_CARPET  =
             registerBlockItemAfter(ModBlocks.CHROMATIC_CARPET, ItemGroups.COLORED_BLOCKS, Items.PINK_CARPET,
-                    new Item.Settings().component(ModComponentTypes.COLOR.get(), ColorLogic.defaultChromatic),
+                    new Item.Settings(),
                     ChromaticBlockItem::new);
     public static final RegistrySupplier<Item> BIOME_BOTTLE_ITEM =
             registerBlockItemAfter(ModBlocks.BIOME_BOTTLE, ItemGroups.INGREDIENTS, Items.EXPERIENCE_BOTTLE, BiomeBottleItem::new);
···
                             new FoodComponent.Builder().alwaysEdible().build()));
     public static final RegistrySupplier<ChromaticItem> CHROMATIC_MATTER =
             registerItemAfter("chromatic_matter", ItemGroups.INGREDIENTS, Items.DISC_FRAGMENT_5, ChromaticItem::new,
-                    new Item.Settings().component(ModComponentTypes.COLOR.get(), ColorLogic.defaultChromatic));
+                    new Item.Settings());
     public static final RegistrySupplier<Item> WHITE_MATTER =
             registerItemAfter("white_matter", ItemGroups.INGREDIENTS, Items.DISC_FRAGMENT_5, Item::new);
     public static final RegistrySupplier<Item> BLACK_MATTER =
···
                     new Item.Settings().rarity(Rarity.RARE));
     public static final RegistrySupplier<Item> IRIDESCENT_POTION =
             registerItemAfter("iridescent_potion", ItemGroups.FOOD_AND_DRINK, Items.HONEY_BOTTLE, IridescentPotionItem::new,
-                    new Item.Settings().component(ModComponentTypes.CHARGE.get(), 4)
-                            .rarity(Rarity.UNCOMMON)
-                            .component(DataComponentTypes.ENCHANTMENT_GLINT_OVERRIDE, true));
+                    new Item.Settings());
     public static final RegistrySupplier<Item> CHROMATIC_POTION =
             registerItemAfter("chromatic_potion", ItemGroups.FOOD_AND_DRINK, Items.HONEY_BOTTLE, IridescentPotionItem::new,
-                    new Item.Settings().component(ModComponentTypes.CHARGE.get(), 0));
+                    new Item.Settings());
 
     public static <T extends Item> RegistrySupplier<T> register(String item, Item.Settings settings, Function<Item.Settings, T> constructor) {
         return ITEMS.register(item, () -> constructor.apply(settings));

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

···
         }
     }
 
-    public static class IridescentCriterion extends AbstractCriterion<IridescenceConditions> {
+    public static class IridescentCriterion extends AbstractCriterion<EmptyConditions> {
+        static final Identifier ID = InfinityMethods.getId("iridescence");
+
         public void trigger(ServerPlayerEntity player, boolean willing, int level) {
-            this.trigger(player, (conditions) -> conditions.test(willing, level));
+            this.trigger(player, (conditions) -> true);
         }
 
+
         @Override
-        public Codec<IridescenceConditions> getConditionsCodec() {
-            return IridescenceConditions.CODEC;
+        protected EmptyConditions conditionsFromJson(JsonObject obj, LootContextPredicate lootContextPredicate, AdvancementEntityPredicateDeserializer predicateDeserializer) {
+            return new EmptyConditions(lootContextPredicate, ID);
+        }
+
+        @Override
+        public Identifier getId() {
+            return ID;
         }
     }
 
···
         }
     }
 
-    public record IridescenceConditions(Optional<LootContextPredicate> player, Optional<Boolean> willing, Optional<Integer> minLevel) implements AbstractCriterion.Conditions {
-        public static final Codec<IridescenceConditions> CODEC = RecordCodecBuilder.create(
-                instance -> instance.group(
-                                EntityPredicate.LOOT_CONTEXT_PREDICATE_CODEC.optionalFieldOf("player").forGetter(IridescenceConditions::player),
-                                Codec.BOOL.optionalFieldOf("willing").forGetter(IridescenceConditions::willing),
-                                Codec.INT.optionalFieldOf("min_level").forGetter(IridescenceConditions::minLevel)
-                        )
-                        .apply(instance, IridescenceConditions::new)
-        );
-
-        public boolean test(boolean isWilling, int level) {
-            return (willing.isEmpty() || isWilling == willing.get()) && (minLevel.isEmpty() || level >= minLevel.get());
-        }
-    }
-
-    public static RegistrySupplier<DimensionOpenedCriterion> DIMS_OPENED;
-    public static RegistrySupplier<DimensionClosedCriterion> DIMS_CLOSED;
-    public static RegistrySupplier<WhoRemainsCriterion> WHO_REMAINS;
-    public static RegistrySupplier<IridescentCriterion> IRIDESCENT;
-    public static RegistrySupplier<BiomeBottleCriterion> BIOME_BOTTLE;
-    public static RegistrySupplier<ConvertMobCriterion> CONVERT_MOB;
+    public static class DataConditions extends AbstractCriterionConditions {
+        private final int score;
 
         public DataConditions(LootContextPredicate player, int score, Identifier ID) {
             super(ID, player);

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

···
             ModPlacementModifiers.CenterProximityPlacementModifier.MODIFIER_CODEC);
 
     static RegistrySupplier<PlacementModifierType<?>> register(String id, MapCodec<? extends PlacementModifier> codec) {
-            return PLACEMENT_MODIFIER_TYPES.register(id, () -> getType(codec));
+        return PLACEMENT_MODIFIER_TYPES.register(id, () -> () -> ((MapCodec<PlacementModifier>) codec).codec());
     }
     public static void registerModifiers() {
         PLACEMENT_MODIFIER_TYPES.register();

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

···
 package net.lerariemann.infinity.util;
 
+import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItemFunctions;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Identifier;
 import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
 
 public class BackportMethods {
     public static int getOrDefaultInt(ItemStack stack, String key, int i) {
···
         return i;
     }
 
+    public static boolean contains(ItemStack stack, String key) {
+        if (stack.hasNbt()) {
+            return !Objects.requireNonNull(stack.getSubNbt(key)).isEmpty();
+        }
+        return false;
+    }
+
     public static ItemStack apply(ItemStack stack, String key, int i) {
         if (stack.hasNbt()) {
             assert stack.getNbt() != null;
···
 
     public static @Nullable String getDimensionComponents(ItemStack stack) {
         if (stack.getNbt() != null) {
-            return stack.getNbt().getString(ModItemFunctions.DESTINATION);
+            return stack.getNbt().getString(ModComponentTypes.DESTINATION);
         }
         return null;
     }

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

···
 import net.lerariemann.infinity.util.core.CommonIO;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.lerariemann.infinity.util.loading.DimensionGrabber;
-import net.minecraft.block.jukebox.JukeboxSong;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
···
 /**
  * Pipeline for generating custom sound events and jukebox song definitions for every music track in the game.
  */
+// TODO soundpacks
 public record SoundScanner(Map<Identifier, Resource> soundIds) {
     /** Holds a map which allows to get the list of all sound IDs in existence and .ogg data for each.
      * Seeded by {@link SoundListMixin} on client launch. */
···
      * <p>On player connect, the server sends a {@link ModPayloads.DownloadSoundPack} payload to the client.
      * <p>If the server already contains data upon which the client should create its resource pack, it holds this data.
      * <p>Otherwise, this payload is empty, and the server relies on the client to create it and send it back to the server for future use. */
-    public static void unpackDownloadedPack(ModPayloads.DownloadSoundPack payload, Object clientContext) {
-        MinecraftClient cl = ModPayloads.client(clientContext);
-        //the client unpacks a non-empty payload only when needed, meaning only if it doesn't have necessary files yet
-        if (!payload.songIds().isEmpty() && !Files.exists(cl.getResourcePackDir().resolve("infinity/assets/infinity/sounds.json"))) {
-            cl.execute(() -> saveResourcePack(cl, payload.songIds().getList("entries", NbtElement.STRING_TYPE).stream()
-                    .map(NbtElement::asString).map(Identifier::of), false));
-        }
-        else if (isPreloaded()) {
-            cl.execute(() -> {
-                NbtCompound jukeboxes = saveResourcePack(cl, getMatchingLoadedIds(), true);
-                NbtCompound res = new NbtCompound();
-                NbtList songIds = new NbtList();
-                getMatchingLoadedIds().forEach(id -> songIds.add(NbtString.of(id.toString())));
-                res.put("entries", songIds);
-                res.put("jukeboxes", jukeboxes);
-                ClientPlayNetworking.send(new ModPayloads.UploadJukeboxes(res));
-            });
-        }
-    }
+//    public static void unpackDownloadedPack(ModPayloads.DownloadSoundPack payload, Object clientContext) {
+//        MinecraftClient cl = ModPayloads.client(clientContext);
+//        //the client unpacks a non-empty payload only when needed, meaning only if it doesn't have necessary files yet
+//        if (!payload.songIds().isEmpty() && !Files.exists(cl.getResourcePackDir().resolve("infinity/assets/infinity/sounds.json"))) {
+//            cl.execute(() -> saveResourcePack(cl, payload.songIds().getList("entries", NbtElement.STRING_TYPE).stream()
+//                    .map(NbtElement::asString).map(Identifier::of), false));
+//        }
+//        else if (isPreloaded()) {
+//            cl.execute(() -> {
+//                NbtCompound jukeboxes = saveResourcePack(cl, getMatchingLoadedIds(), true);
+//                NbtCompound res = new NbtCompound();
+//                NbtList songIds = new NbtList();
+//                getMatchingLoadedIds().forEach(id -> songIds.add(NbtString.of(id.toString())));
+//                res.put("entries", songIds);
+//                res.put("jukeboxes", jukeboxes);
+//                ClientPlayNetworking.send(new ModPayloads.UploadJukeboxes(res));
+//            });
+//        }
+//    }
     /**
      * Generating and saving a resource pack from a stream of identifiers that correspond to music tracks.
      * @param sendJukeboxes if this is true, the method also generates and returns data that needs to be sent to the server
···
         songIds.forEach(id -> {
             String str = id.toString().replace(".ogg", "").replace("sounds/", "");
             List<String> arr = Arrays.stream(str.split("[:/]")).toList(); //preloading IDs
-            String songID = "disc." + arr.getFirst() + "." + arr.getLast();
+            String songID = "disc." + arr.get(0) + "." + arr.get(arr.size()-1);
             String subtitleID = "infinity:subtitles." + songID;
-            String subtitleData = InfinityMethods.formatAsTitleCase(arr.getFirst() + " - " + arr.getLast());
+            String subtitleData = InfinityMethods.formatAsTitleCase(arr.get(0) + " - " + arr.get(arr.size()-1));
 
             NbtList soundForRPList = new NbtList();
             soundForRPList.add(NbtString.of(str));
···
                 } catch (IOException e) {
                     length = 600;
                 }
-                jukeboxes.put(arr.getLast(), getJukeboxDef(songID, subtitleID, length));
+                jukeboxes.put(arr.get(arr.size()-1), getJukeboxDef(songID, subtitleID, length));
             }
         });
         CommonIO.write(soundsForRP, client.getResourcePackDir().resolve("infinity/assets/infinity"), "sounds.json");
···
         return jukeboxes;
     }
 
-    /** Receiver for a C2S {@link ModPayloads.UploadJukeboxes} payload, which holds data to send to clients in the future for them to
+    /** Receiver for a C2S {@link ModPayloads} payload, which holds data to send to clients in the future for them to
      * generate custom sound resource packs, as well as jukebox song definitions corresponding to this data. */
-    public static void unpackUploadedJukeboxes(ModPayloads.UploadJukeboxes payload, ServerPlayNetworking.Context context) {
-        if (!InfinityMod.provider.rule("useSoundSyncPackets")) return;
-        NbtCompound data = payload.data();
-        if (!data.contains("jukeboxes") || !data.contains("entries")) return;
-        MinecraftServer server = context.player().server;
-        if (Files.exists(server.getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json"))) return;
-
-        unpackUploadedJukeboxes(server, data.getCompound("jukeboxes"));
-        data.remove("jukeboxes");
-        NbtCompound packData = new NbtCompound();
-        packData.put("entries", data.get("entries"));
-        CommonIO.write(packData, server.getSavePath(WorldSavePath.DATAPACKS), "client_sound_pack_data.json");
-    }
+//    public static void unpackUploadedJukeboxes(ModPayloads payload, ServerPlayNetworking.Context context) {
+//        if (!InfinityMod.provider.rule("useSoundSyncPackets")) return;
+//        NbtCompound data = payload.data();
+//        if (!data.contains("jukeboxes") || !data.contains("entries")) return;
+//        MinecraftServer server = context.player().server;
+//        if (Files.exists(server.getSavePath(WorldSavePath.DATAPACKS).resolve("client_sound_pack_data.json"))) return;
+//
+//        unpackUploadedJukeboxes(server, data.getCompound("jukeboxes"));
+//        data.remove("jukeboxes");
+//        NbtCompound packData = new NbtCompound();
+//        packData.put("entries", data.get("entries"));
+//        CommonIO.write(packData, server.getSavePath(WorldSavePath.DATAPACKS), "client_sound_pack_data.json");
+//    }
     public static void unpackUploadedJukeboxes(MinecraftServer server, NbtCompound allJukeboxes) {
         Path pathJukeboxes = server.getSavePath(WorldSavePath.DATAPACKS).resolve("infinity/data/infinity/jukebox_song");
         for (String key: allJukeboxes.getKeys()) {
···
                 CommonIO.write(jukebox, pathJukeboxes, key + ".json");
             }
         }
-        grabJukeboxes(server);
+//        grabJukeboxes(server);
     }
     /** Injects freshly received jukebox song definitions into the server's registries, config files and {@link RandomProvider}. */
-    public static void grabJukeboxes(MinecraftServer server) {
-        Path pathJukeboxes = server.getSavePath(WorldSavePath.DATAPACKS).resolve("infinity/data/infinity/jukebox_song");
-        InfinityMod.LOGGER.info("grabbing jukeboxes");
-        DimensionGrabber grabber = new DimensionGrabber(server.getRegistryManager());
-        grabber.buildGrabber(JukeboxSong.CODEC, RegistryKeys.JUKEBOX_SONG).grabAll(pathJukeboxes);
-        grabber.close();
-        if (!((MinecraftServerAccess)server).infinity$needsInvocation()) {
-            ConfigFactory.of(server.getRegistryManager().get(RegistryKeys.JUKEBOX_SONG)).generate("misc", "jukeboxes");
-            InfinityMod.updateProvider(server);
-        }
-    }
+//    public static void grabJukeboxes(MinecraftServer server) {
+//        Path pathJukeboxes = server.getSavePath(WorldSavePath.DATAPACKS).resolve("infinity/data/infinity/jukebox_song");
+//        InfinityMod.LOGGER.info("grabbing jukeboxes");
+//        DimensionGrabber grabber = new DimensionGrabber(server.getRegistryManager());
+//        grabber.buildGrabber(JukeboxSong.CODEC, RegistryKeys.JUKEBOX_SONG).grabAll(pathJukeboxes);
+//        grabber.close();
+//        if (!((MinecraftServerAccess)server).infinity$needsInvocation()) {
+//            ConfigFactory.of(server.getRegistryManager().get(RegistryKeys.JUKEBOX_SONG)).generate("misc", "jukeboxes");
+//            InfinityMod.updateProvider(server);
+//        }
+//    }
 
     /**
      Getting a duration of an OGG file from its byte data; <a href="https://stackoverflow.com/a/44407355">implementation from StackOverflow</a>.

gradle.properties

···
 maven_group = net.lerariemann
 archives_name = infinity
 enabled_platforms = fabric,forge
+tbversion = 0
 
 # Minecraft properties
 minecraft_version = 1.20.1