chroma matter in iridescence

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

···
             MinecraftServer server = world.getServer();
             if (entity instanceof ItemEntity e) {
                 ModItemFunctions.checkCollisionRecipes(world, e, ModItemFunctions.PORTAL_CRAFTING_TYPE.get(),
-                        item -> PortalDataHolder.addPortalComponents(item, e.getStack(), ipbe));
+                        item -> PortalDataHolder.addPortalComponents(item, ipbe));
                 InfinityMod.provider.getPortalKeyAsItem().ifPresent(item -> { //opening a portal by tossing a key in
                     if (e.getStack().isOf(item)) {
                         InfinityPortal.tryUpdateOpenStatus(ipbe, world, pos, server);

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

···
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.lerariemann.infinity.util.loading.ShaderLoader;
 import net.lerariemann.infinity.util.teleport.WarpLogic;
+import net.lerariemann.infinity.util.var.ColorLogic;
 import net.minecraft.block.Block;
 import net.minecraft.entity.EntityType;
 import net.minecraft.entity.LivingEntity;
···
 import net.minecraft.world.biome.Biome;
 import org.jetbrains.annotations.Nullable;
 
-import java.awt.Color;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.LocalTime;
···
     }
 
     static int getPosBasedColor(BlockPos pos) {
-        return Color.HSBtoRGB((float)InfinityMethods.sample(pos), 1.0F, 1.0F) & 0xFFFFFF;
+        return ColorLogic.getPureHue(InfinityMethods.sample(pos));
     }
+
     //todo: figure out how minecraft offsets animations to sync this with irid items' textures' animation loops
     static int getTimeBasedColor() {
         long timeMS = LocalTime.now().toNanoOfDay() / 1000000;
         int hue = (int)(timeMS % 24000);
-        return Color.HSBtoRGB((float)(hue / 24000.0), 1.0f, 1.0f) & 0xFFFFFF;
+        return ColorLogic.getPureHue(hue / 24000.0);
     }
 
     java.util.List<DyeColor> dyeColors = List.of(

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

···
                 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(),
-                            PortalDataHolder::addIridComponents);
+                            i -> PortalDataHolder.getIridComponents(i, item));
             }
             default -> {}
         }

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

···
 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.InfinityMethods;
 import net.lerariemann.infinity.util.var.ColorLogic;
 import net.minecraft.block.BlockState;
 import net.minecraft.component.ComponentChanges;
+import net.minecraft.entity.ItemEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
···
 import net.minecraft.util.DyeColor;
 import net.minecraft.util.Hand;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 
-import java.awt.*;
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class ChromaticItem extends Item implements PortalDataHolder {
···
         super(settings);
     }
     @Override
-    public ComponentChanges.Builder getPortalComponents(InfinityPortalBlockEntity ipbe) {
-        return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), ipbe.getPortalColor())
-                .remove(ModComponentTypes.DYE_COLOR.get())
-                .remove(ModComponentTypes.HUE.get());
+    public ComponentChanges getPortalComponents(InfinityPortalBlockEntity ipbe) {
+        return ofColor(ipbe.getPortalColor());
     }
     @Override
+    public Optional<ComponentChanges> getIridComponents(ItemEntity entity) {
+        Vec3d pos = entity.getPos();
+        int hue = (int)(360*InfinityMethods.sampler.sample(pos.x, pos.y, pos.z));
+        return Optional.of(ofHue(hue));
+    }
+
+    @Override
     public ItemStack getStack() {
         return getDefaultStack();
     }
···
     }
     static ComponentChanges ofHue(int hue) {
         return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), Color.HSBtoRGB(hue/360f, 1.0f, 1.0f) & 0xFFFFFF)
+                .add(ModComponentTypes.COLOR.get(), ColorLogic.getPureHue(hue/360f))
                 .remove(ModComponentTypes.DYE_COLOR.get())
                 .add(ModComponentTypes.HUE.get(), hue)
                 .build();
···
                 else return false;
             }
             if (i > 0) {
-                if (i != currColor) newStack.applyChanges(ofColor(i));
+                int currHue = currStack.getOrDefault(ModComponentTypes.HUE.get(), -1);
+                if (currHue > 0) {
+                    if (ColorLogic.matchesPureHue(i, currHue)) return false;
+                    newStack.applyChanges(ofColor(i));
+                }
+                else if (i != currColor) newStack.applyChanges(ofColor(i));
                 else return false;
             }
             player.setStackInHand(hand, newStack);

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

···
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.component.ComponentChanges;
+import net.minecraft.entity.ItemEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Identifier;
···
         return (isDestinationRandom(id)) ? InfinityMethods.getRandomId(world.random) : id;
     }
 
-    static Optional<ComponentChanges> addPortalComponents(Item item, ItemStack oldStack, InfinityPortalBlockEntity ipbe) {
+    static Optional<ComponentChanges> addPortalComponents(Item item, InfinityPortalBlockEntity ipbe) {
         if (item instanceof PortalDataHolder pdh)
-            return Optional.of(pdh.addPortalComponents(oldStack, ipbe));
+            return Optional.of(pdh.getPortalComponents(ipbe));
         return Optional.empty();
     }
-
-    default ComponentChanges addPortalComponents(ItemStack oldStack, InfinityPortalBlockEntity ipbe) {
-        return getPortalComponents(ipbe).build();
-    }
-
-    default ComponentChanges.Builder getPortalComponents(InfinityPortalBlockEntity ipbe) {
+    default ComponentChanges getPortalComponents(InfinityPortalBlockEntity ipbe) {
         return ComponentChanges.builder()
-                .add(ModComponentTypes.COLOR.get(), ipbe.getPortalColor());
+                .add(ModComponentTypes.COLOR.get(), ipbe.getPortalColor())
+                .build();
     }
 
-    static Optional<ComponentChanges> addIridComponents(Item item) {
+    static Optional<ComponentChanges> getIridComponents(Item item, ItemEntity entity) {
         if (item instanceof PortalDataHolder pdh)
-            return pdh.addIridComponents();
+            return pdh.getIridComponents(entity);
         return Optional.empty();
     }
-    default Optional<ComponentChanges> addIridComponents() {
+    default Optional<ComponentChanges> getIridComponents(ItemEntity entity) {
         return Optional.empty();
     }
 
     default ItemStack withPortalData(InfinityPortalBlockEntity ipbe) {
         ItemStack stack = getStack();
-        stack.applyChanges(addPortalComponents(stack, ipbe));
+        stack.applyChanges(getPortalComponents(ipbe));
         return stack;
     }
 
···
 
     interface Destinable extends PortalDataHolder {
         @Override
-        default ComponentChanges.Builder getPortalComponents(InfinityPortalBlockEntity ipbe) {
+        default ComponentChanges getPortalComponents(InfinityPortalBlockEntity ipbe) {
             return ComponentChanges.builder()
                     .add(ModComponentTypes.DESTINATION.get(), ipbe.getDimension())
-                    .add(ModComponentTypes.COLOR.get(), ipbe.getPortalColor());
+                    .add(ModComponentTypes.COLOR.get(), ipbe.getPortalColor())
+                    .build();
         }
     }
 }

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

···
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.component.ComponentChanges;
+import net.minecraft.entity.ItemEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.tooltip.TooltipType;
···
     }
 
     @Override
-    public ComponentChanges.Builder getPortalComponents(InfinityPortalBlockEntity ipbe) {
+    public ComponentChanges 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);
+                .add(ModComponentTypes.COLOR.get(), color & 0xFFFFFF)
+                .build();
     }
 
     @Override
-    public Optional<ComponentChanges> addIridComponents() {
+    public Optional<ComponentChanges> getIridComponents(ItemEntity entity) {
         return Optional.of(ComponentChanges.builder()
                 .remove(ModComponentTypes.DESTINATION.get())
                 .remove(ModComponentTypes.COLOR.get())

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

···
     public static final DeferredRegister<RecipeType<?>> RECIPE_TYPES =
             DeferredRegister.create(MOD_ID, RegistryKeys.RECIPE_TYPE);
 
-
     public static RegistrySupplier<LootFunctionType<SetLevelLootFunction>> SET_BIOME_BOTTLE_LEVEL =
             LOOT_FUNCTION_TYPES.register("set_biome_bottle_level", () -> new LootFunctionType<>(SetLevelLootFunction.CODEC));
     public static RegistrySupplier<LootFunctionType<SetAltarStateLootFunction>> SET_ALTAR_STATE =
             LOOT_FUNCTION_TYPES.register("set_altar_state", () -> new LootFunctionType<>(SetAltarStateLootFunction.CODEC));
 
+    //special recipe serializers
     public static RegistrySupplier<RecipeSerializer<BiomeBottleCombiningRecipe>> BIOME_BOTTLE_COMBINING =
             RECIPE_SERIALIZERS.register("biome_bottle_combining", () ->
                     new SpecialRecipeSerializer<>(BiomeBottleCombiningRecipe::new));
···
     public static RegistrySupplier<RecipeSerializer<ChromaCarpetRecipe>> CARPET =
             RECIPE_SERIALIZERS.register("chroma_carpet", () ->
                     new SpecialRecipeSerializer<>(ChromaCarpetRecipe::new));
-
+    //regular recipe serializers
     public static RegistrySupplier<RecipeSerializer<ChromaticColoringRecipe>> CHROMATIC_COLORING =
             RECIPE_SERIALIZERS.register("chromatic_coloring", () ->
                     new ChromaticColoringRecipe.Serializer(ChromaticColoringRecipe::new));
···
     public static RegistrySupplier<RecipeSerializer<CollisionCraftingRecipe>> IRIDESCENCE_CRAFTING =
             RECIPE_SERIALIZERS.register("collision_iridescence", () ->
                     new CollisionCraftingRecipe.Serializer(CollisionCraftingRecipe.OfIridescence::new));
-
+    //recipe types
     public static RegistrySupplier<RecipeType<CollisionCraftingRecipe>> PORTAL_CRAFTING_TYPE =
             RECIPE_TYPES.register("collision_portal", () -> CollisionCraftingRecipe.Type.PORTAL);
     public static RegistrySupplier<RecipeType<CollisionCraftingRecipe>> IRIDESCENCE_CRAFTING_TYPE =
···
                     int charge = BiomeBottleBlock.getCharge(stack);
                     return Math.clamp(charge / 1000.0f, 0f, 1f);
                 });
-        ItemPropertiesRegistry.register(ModItems.IRIDESCENT_CARPET.get(), InfinityMethods.getId("iridescent"),
-                ModItemFunctions::iridPredicate);
-        ItemPropertiesRegistry.register(ModItems.IRIDESCENT_WOOL.get(), InfinityMethods.getId("iridescent"),
-                ModItemFunctions::iridPredicate);
         ItemPropertiesRegistry.register(ModItems.F4.get(), InfinityMethods.getId("f4"),
                 (stack, world, entity, seed) -> {
                     Identifier id = ModItems.F4.get().getDestination(stack);

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

···
         return chromaticColors.getOrDefault(dye.getName(), 0xFFFFFF);
     }
 
+    static int getPureHue(double hue) {
+        return getPureHue((float)hue);
+    }
+    static int getPureHue(float hue) {
+        return Color.HSBtoRGB(hue, 1.0F, 1.0F) & 0xFFFFFF;
+    }
     static boolean matchesPureHue(int rgb, int pureHue) {
         Color c = new Color(rgb);
         float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), null);

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

···
   "recipe_info.portal.infinity.color": "The item inherits its color from the portal",
   "recipe_info.portal.infinity.attuned": "The item is attuned to the portal used",
   "recipe_info.iridescence.infinity.key": "No matter the key provided, a random one is born",
+  "recipe_info.iridescence.infinity.chromatic_matter": "Gets drenched with the liquid's hue",
   "stat.infinity.portals_opened_stat": "Infinity portals opened",
   "stat.infinity.dimensions_opened_stat": "Unique dimensions discovered",
   "stat.infinity.worlds_destroyed_stat": "Unique dimensions destroyed",

common/src/main/resources/data/infinity/recipe/chromatic_matter_from_iridescence.json

···
+{
+  "type": "infinity:collision_iridescence",
+  "input": {
+    "item": "infinity:chromatic_matter"
+  },
+  "output": {
+    "id": "infinity:chromatic_matter"
+  },
+  "lore": "recipe_info.iridescence.infinity.chromatic_matter"
+}