Merge branch '2.4.3' into architectury/1.20

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

···
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Hand;
 import net.minecraft.util.TypedActionResult;
-import net.minecraft.util.math.noise.DoublePerlinNoiseSampler;
-import net.minecraft.util.math.random.CheckedRandom;
 import org.lwjgl.glfw.GLFW;
 
 public class InfinityModClient {
-    public final static DoublePerlinNoiseSampler sampler = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -3, 1.0, 1.0, 1.0, 0.0);
     public static KeyBinding f4ConfigKey = new KeyBinding("key.infinity.f4",
             InputUtil.Type.KEYSYM,
             GLFW.GLFW_KEY_F4,

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

···
 public class ComputerCraftCompat {
 
     public static String checkPrintedPage(ItemStack itemStack) {
-        var print = (PrintoutContents.get(itemStack));
+        var print = PrintoutContents.get(itemStack);
         if (print != null) {
             String string = "";
             for (var l : print.getTextLines().toArray()) {

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

···
 
     public void genBasics() {
         type_alike = PROVIDER.randomName(random, "noise_presets");
-        min_y = 16*Math.min(0, (int)Math.floor(random.nextGaussian(-4.0, 4.0)));
-        if (!isOverworldLike()) min_y = Math.max(min_y, -48);
-        int max_y = 16*Math.max(1, Math.min(125, (int)Math.floor(random.nextGaussian(16.0, 4.0))));
-        if (!isOverworldLike()) max_y = Math.max(max_y, 80);
+        min_y = 16*Math.clamp((int)Math.floor(random.nextExponential() * 2), isOverworldLike() ? -125 : -3, 0);
+        int avgHeight = Math.clamp(RandomProvider.ruleInt("avgDimensionHeight"), 64, 1024);
+        int max_y = 16*Math.clamp((int)Math.floor(random.nextGaussian(avgHeight/16.0, avgHeight/64.0)), isOverworldLike() ? 1 : 5, 125);
         randomiseblocks = PROVIDER.roll(random, "randomise_blocks");
         int sea_level_default = 63;
         if (!isOverworldLike()) sea_level_default = switch(type_alike) {

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

···
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Box;
-import net.minecraft.util.math.noise.DoublePerlinNoiseSampler;
-import net.minecraft.util.math.random.CheckedRandom;
 import net.minecraft.world.*;
 import net.minecraft.world.biome.Biome;
 import org.jetbrains.annotations.Nullable;
···
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.LocalTime;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
···
     Identifier TEXTURE = InfinityMethods.getId("block/iridescence");
     Identifier FLOWING_TEXTURE = InfinityMethods.getId("block/iridescence");
     Identifier OVERLAY_TEXTURE = InfinityMethods.getId("block/iridescence_overlay");
-    DoublePerlinNoiseSampler sampler =
-            DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -5, genOctaves(2));
-
-    static double[] genOctaves(int octaves){
-        double[] a = new double[octaves];
-        Arrays.fill(a, 1);
-        return a;
-    }
-
-    static double sample(BlockPos pos) {
-        return sampler.sample(pos.getX(), pos.getY(), pos.getZ());
-    }
 
     static boolean isInfinite(World world) {
         return switch (world.getRegistryKey().getValue().toString()) {
···
     }
 
     static int getPosBasedColor(BlockPos pos) {
-        return Color.HSBtoRGB((float)sample(pos), 1.0F, 1.0F) & 0xFFFFFF;
+        return Color.HSBtoRGB((float)InfinityMethods.sample(pos), 1.0F, 1.0F) & 0xFFFFFF;
     }
     //todo: figure out how minecraft offsets animations to sync this with irid items' textures' animation loops
     static int getTimeBasedColor() {

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

···
         super.onEntityCollision(state, world, pos, entity);
         if (world.getFluidState(pos).getLevel() > 3 && world instanceof ServerWorld w) {
             if (Objects.requireNonNull(entity) instanceof PlayerEntity player) {
-                Iridescence.tryBeginJourney(player, 4, false);
+                Iridescence.tryBeginJourney(player, 0, false);
             } else if (entity instanceof MobEntity ent) {
                 Iridescence.tryApplyEffect(ent);
             } else if (entity instanceof ItemEntity item) {

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

···
 package net.lerariemann.infinity.item;
 
-import net.fabricmc.fabric.api.renderer.v1.model.ModelHelper;
 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.util.BackportMethods;
 import net.lerariemann.infinity.util.ClientMethods;
 import net.lerariemann.infinity.util.InfinityMethods;
-import net.lerariemann.infinity.util.screen.F4Screen;
 import net.lerariemann.infinity.util.teleport.InfinityPortal;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
···
             world.setBlockState(bp,  Blocks.AIR.getDefaultState(), 3, 0);
             obsidian++;
         }
-        for (int i = 0; i <= portal.width; i++) for (int j = -1; j <= portal.height; j++)
+        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);

common/src/main/java/net/lerariemann/infinity/options/IridescentMap.java

···
 package net.lerariemann.infinity.options;
 
-import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.core.NbtUtils;
 import net.minecraft.nbt.NbtCompound;
···
 
 import static net.lerariemann.infinity.block.custom.IridescentBlock.num_models;
 
+@Deprecated
 public interface IridescentMap {
     default int getColor(BlockPos pos) {
         return InfinityMethods.properMod((int)(num_models * getHue(pos)), num_models);
     }
     default double getHue(BlockPos pos) {
-        return Iridescence.sample(pos);
+        return InfinityMethods.sample(pos);
     }
 
     static IridescentMap decode(NbtCompound data) {

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

···
         itemEntity.remove(Entity.RemovalReason.CHANGED_DIMENSION);
     }
 
+    @Deprecated
     @Environment(EnvType.CLIENT)
     public static float iridPredicate(@Nullable ItemStack stack, ClientWorld world, @Nullable LivingEntity entity, int seed) {
         if (entity == null) return 0;

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

···
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import dev.architectury.registry.registries.DeferredRegister;
-import net.lerariemann.infinity.iridescence.Iridescence;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.util.dynamic.CodecHolder;
 import net.minecraft.util.math.noise.DoublePerlinNoiseSampler;
···
     }
 
     public static void registerFunctions() {
-        sampler = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -5, Iridescence.genOctaves(8));
-        sampler2 = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -6, Iridescence.genOctaves(8));
+        sampler = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -5, InfinityMethods.genOctaves(8));
+        sampler2 = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -6, InfinityMethods.genOctaves(8));
         for (NonbinaryOperation.Type enum_ : NonbinaryOperation.Type.values()) {
             register(enum_.name, enum_.codecHolder);
         }

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

···
 import dev.architectury.registry.registries.DeferredRegister;
 import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.registry.core.ModBlocks;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
···
     {
         @Override
         public BlockState tryApply(int i, int j, int k) {
-            double d = Iridescence.sampler.sample(i, j, k);
+            double d = InfinityMethods.sampler.sample(i, j, k);
             d = d - Math.floor(d);
             BlockState st = Iridescence.getRandomColorBlock(d, str).getDefaultState();
             if(st.contains(Properties.PERSISTENT)) st = st.with(Properties.PERSISTENT, Boolean.TRUE);

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

···
  * @see PlatformMethods */
 public interface InfinityMethods {
     String ofRandomDim = "infinity:random";
+    DoublePerlinNoiseSampler sampler =
+            DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -5, genOctaves(2));
+
+    static double[] genOctaves(int octaves){
+        double[] a = new double[octaves];
+        Arrays.fill(a, 1);
+        return a;
+    }
+    static double sample(BlockPos pos) {
+        return sampler.sample(pos.getX(), pos.getY(), pos.getZ());
+    }
 
     /**
      * Converts a string to an identifier in the Infinite Dimensions namespace.
···
         return i;
     }
 
-    /**
-     * Converts a coordinate value to a "random" color.
-     */
-    static int posToColor(BlockPos pos) {
-        double r = sample(pos.getX(), pos.getY() - 10000, pos.getZ());
-        double g = sample(pos.getX(), pos.getY(), pos.getZ());
-        double b = sample(pos.getX(), pos.getY() + 10000, pos.getZ());
-        return (int)(256 * ((r + 1)/2)) + 256*((int)(256 * ((g + 1)/2)) + 256*(int)(256 * ((b + 1)/2)));
+    private static float bookBoxSample(BlockPos pos, int offset) {
+        return MathHelper.clamp(0.5f * (1f + (float)sampler.sample(4*pos.getX(), 4*(pos.getY() + offset), 4*pos.getZ())), 0f, 1f);
     }
-
-
     static int getBookBoxColor(BlockState state, BlockRenderView world, BlockPos pos, int tintIndex) {
         if (pos != null) {
-            return posToColor(pos);
+            float r = bookBoxSample(pos, -1000);
+            float g = bookBoxSample(pos, 0);
+            float b = bookBoxSample(pos, 1000);
+            return MathHelper.packRgb(r, g, b);
         }
         return 16777215;
     }

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

···
 {
-  "infinity_version": 2004001,
+  "infinity_version": 2004003,
   "gameRules": {
     "runtimeGenerationEnabled": true,
     "longArithmeticEnabled": false,
···
     "enforceModLoadedChecks": true,
     "maxBiomeCount": 6,
     "maxDimensionScale": 0,
+    "avgDimensionHeight": 256,
     "iridescenceInitialDuration": 30,
     "iridescenceCooldownDuration": 168,
     "afterglowDuration": 24,

gradle.properties

···
 org.gradle.parallel=true
 
 # Mod properties
-mod_version = 2.4.2
+mod_version = 2.4.3
 maven_group = net.lerariemann
 archives_name = infinity
 enabled_platforms = fabric,forge
-tbversion = 3
+tbversion = 4
 
 # Minecraft properties
 minecraft_version = 1.20.1