moving more methods to InfinityMethods

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

···
         type = new RandomDimensionType(this);
         data.putString("type", type.fullname);
         data.put("generator", randomDimensionGenerator());
-        for (Long l: random_biome_ids) if (does_not_contain(RegistryKeys.BIOME, "biome_"+l)) {
+        for (Long l: random_biome_ids) if (doesNotContain(RegistryKeys.BIOME, "biome_"+l)) {
             RandomBiome b = new RandomBiome(l, this);
             random_biomes.add(b);
             addStructures(b);
···
         }
     }
 
-    public <T> boolean does_not_contain(RegistryKey<? extends Registry<T>> key, String name) {
+    public <T> boolean doesNotContain(RegistryKey<? extends Registry<T>> key, String name) {
         return !(server.getRegistryManager().get(key).contains(RegistryKey.of(key, InfinityMethods.getId(name))));
     }
 
···
             vanilla_biomes.add(biome);
         }
         else {
-            long id = WarpLogic.getRandomSeed(random);
+            long id = InfinityMethods.getRandomSeed(random);
             random_biome_ids.add(id);
             biome = "infinity:biome_" + id;
         }

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

···
 import net.lerariemann.infinity.dimensions.RandomDimension;
 import net.lerariemann.infinity.util.CommonIO;
 import net.lerariemann.infinity.dimensions.RandomFeaturesList;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.RandomProvider;
-import net.lerariemann.infinity.util.WarpLogic;
 import net.minecraft.nbt.*;
-import net.minecraft.registry.Registry;
-import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
 
 import java.util.List;
···
     NbtList placement_data;
 
     public RandomisedFeature(RandomFeaturesList lst, String namecore) {
-        this(WarpLogic.getRandomSeed(lst.random), lst, namecore);
+        this(InfinityMethods.getRandomSeed(lst.random), lst, namecore);
     }
 
     public RandomisedFeature(long i, RandomFeaturesList lst, String namecore) {
···
         return InfinityMod.MOD_ID + ":configured_" + name;
     }
 
-    <T> boolean does_not_contain(RegistryKey<? extends Registry<T>> key) {
-        return daddy.does_not_contain(key, name);
-    }
-
     void save_with_placement() {
-        if (does_not_contain(RegistryKeys.CONFIGURED_FEATURE)) CommonIO.write(feature(),
+        if (daddy.doesNotContain(RegistryKeys.CONFIGURED_FEATURE, name)) CommonIO.write(feature(),
                 parent.storagePath + "/worldgen/configured_feature", "configured_" + name + ".json");
         NbtCompound moredata = new NbtCompound();
         moredata.putString("feature", fullNameConfigured());

common/src/main/java/net/lerariemann/infinity/features/RandomPortalSetupper.java

···
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import net.lerariemann.infinity.block.ModBlocks;
 import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
-import net.lerariemann.infinity.util.WarpLogic;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.block.NetherPortalBlock;
···
 
     public static Set<Integer> tileChunkPositions(int start, int offset) {
         Set<Integer> ls = new HashSet<>();
-        int mod = WarpLogic.properMod(start, offset);
+        int mod = InfinityMethods.properMod(start, offset);
         int d_start = mod == 0 ? 0 : offset - mod;
         for (int d_curr = d_start; d_curr < 16; d_curr += offset) ls.add(start + d_curr);
         return ls;
···
 
     public boolean generateOnePortal(StructureWorldAccess structureWorldAccess, BlockPos blockPos, Random random,
                                      boolean axis_x, int width, int height, int sol, int soy) {
-        long dim = WarpLogic.getRandomSeed(random);
+        long dim = InfinityMethods.getRandomSeed(random);
         for (int y = 0; y < height+2; y++) {
             if (y == 0 || y == height+1) for (int l = 0; l < width+2; l++) {
                 setBlockState(structureWorldAccess, bpadd(blockPos, l, y, 0, axis_x), obs);

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

···
 import net.lerariemann.infinity.entity.custom.ChaosPawn;
 import net.lerariemann.infinity.item.ModItems;
 import net.lerariemann.infinity.util.InfinityMethods;
-import net.lerariemann.infinity.util.WarpLogic;
 import net.lerariemann.infinity.var.ModCriteria;
 import net.lerariemann.infinity.var.ModPayloads;
 import net.lerariemann.infinity.var.ModStats;
···
 
     public static Identifier getIdForWarp(ServerPlayerEntity player) {
         ServerWorld w = player.getServerWorld().getServer().getOverworld();
-        return WarpLogic.getRandomId(new Random(w.getSeed() + w.getTime() / ticksInHour));
+        return InfinityMethods.getRandomId(new Random(w.getSeed() + w.getTime() / ticksInHour));
     }
 
     public static final Map<EntityType<? extends MobEntity>, RegistrySupplier<? extends EntityType<? extends MobEntity>>> convertibles =

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.WarpLogic;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.util.math.BlockPos;
 
···
 
 public interface IridescentMap {
     default int getColor(BlockPos pos) {
-        return WarpLogic.properMod((int)(num_models * getHue(pos)), num_models);
+        return InfinityMethods.properMod((int)(num_models * getHue(pos)), num_models);
     }
     default double getHue(BlockPos pos) {
         return Iridescence.sample(pos);
···
         INSTANCE;
         @Override
         public int getColor(BlockPos pos) {
-            return WarpLogic.properMod(pos.getX() + pos.getY() + pos.getZ(), num_models);
+            return InfinityMethods.properMod(pos.getX() + pos.getY() + pos.getZ(), num_models);
         }
     }
     enum RandomMap implements IridescentMap {
···
     record Static(int value) implements IridescentMap {
         @Override
         public int getColor(BlockPos pos) {
-            return WarpLogic.properMod(value, num_models);
+            return InfinityMethods.properMod(value, num_models);
         }
     }
 }

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

···
 package net.lerariemann.infinity.options;
 
-import net.lerariemann.infinity.util.WarpLogic;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
···
     record Checker(NbtList values) implements PortalColorApplier {
         @Override
         public int apply(BlockPos pos) {
-            int mod = WarpLogic.properMod(pos.getX() + pos.getY() + pos.getZ(), values.size());
+            int mod = InfinityMethods.properMod(pos.getX() + pos.getY() + pos.getZ(), values.size());
             return values.getInt(mod);
         }
     }

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

···
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ColorHelper;
+import net.minecraft.util.math.random.Random;
 import net.minecraft.world.BlockRenderView;
 import net.minecraft.world.World;
 
···
         return sampler.sample(x, y, z);
     }
 
+    static int properMod(int a, int b) {
+        int res = a%b;
+        return (res >= 0) ? res : b + res;
+    }
+
     static int posToColor(BlockPos pos) {
         double r = sample(pos.getX(), pos.getY() - 10000, pos.getZ());
         double g = sample(pos.getX(), pos.getY(), pos.getZ());
···
             }
         }
         return 0xFFFFFF;
+    }
+
+    static long getRandomSeed(java.util.Random random) {
+        return InfinityMod.longArithmeticEnabled ? random.nextLong() : random.nextInt();
+    }
+    static long getRandomSeed(Random random) {
+        return InfinityMod.longArithmeticEnabled ? random.nextLong() : random.nextInt();
+    }
+    static Identifier getRandomId(java.util.Random random) {
+        return getDimId(getRandomSeed(random));
+    }
+    static Identifier getRandomId(Random random) {
+        return getDimId(getRandomSeed(random));
     }
 }

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

···
     static boolean modifyOnInitialCollision(Identifier dimName, ServerWorld world, BlockPos pos) {
         MinecraftServer server = world.getServer();
         if (dimName.toString().equals("minecraft:random")) {
-            dimName = WarpLogic.getRandomId(world.getRandom());
+            dimName = InfinityMethods.getRandomId(world.getRandom());
         }
         PlayerEntity nearestPlayer = world.getClosestPlayer(pos.getX(), pos.getY(), pos.getZ(), 5, false);
 

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

···
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ColorHelper;
-import net.minecraft.util.math.random.Random;
 import net.minecraft.world.BlockView;
 import net.minecraft.world.TeleportTarget;
 import net.minecraft.world.World;
···
 
     static void onInvocationNeedDetected(PlayerEntity player) {
         if (player != null) player.sendMessage(Text.translatable("error.infinity.invocation_needed"));
-    }
-
-    static int properMod(int a, int b) {
-        int res = a%b;
-        return (res >= 0) ? res : b + res;
     }
 
     static PortalColorApplier getPortalColorApplier(Identifier id, MinecraftServer server) {
···
     static long getDimensionSeed(String text, RandomProvider prov) {
         HashCode f = Hashing.sha256().hashString(text + prov.salt, StandardCharsets.UTF_8);
         return InfinityMod.longArithmeticEnabled ? f.asLong() & Long.MAX_VALUE : f.asInt() & Integer.MAX_VALUE;
-    }
-
-    static long getRandomSeed(java.util.Random random) {
-        return InfinityMod.longArithmeticEnabled ? random.nextLong() : random.nextInt();
-    }
-    static long getRandomSeed(Random random) {
-        return InfinityMod.longArithmeticEnabled ? random.nextLong() : random.nextInt();
-    }
-
-    static Identifier getRandomId(java.util.Random random) {
-        return InfinityMethods.getDimId(getRandomSeed(random));
-    }
-    static Identifier getRandomId(Random random) {
-        return InfinityMethods.getDimId(getRandomSeed(random));
     }
 }