end gateway

common/src/main/java/net/lerariemann/infinity/dimensions/features/surface_structures/RandomEndGateway.java

···
 import net.lerariemann.infinity.dimensions.RandomFeaturesList;
 import net.lerariemann.infinity.dimensions.features.Placement;
 import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
+import net.lerariemann.infinity.util.core.ConfigType;
 import net.minecraft.nbt.NbtCompound;
-import net.minecraft.nbt.NbtInt;
 import net.minecraft.nbt.NbtList;
 
 public class RandomEndGateway extends RandomisedFeature {
     public RandomEndGateway(RandomFeaturesList parent) {
         super(parent, "gateway");
-        id = "end_gateway";
+        id = "infinity:end_gateway";
         savePlacement();
     }
 
···
 
     public NbtCompound feature() {
         NbtCompound config = new NbtCompound();
-        config.putBoolean("exact", PROVIDER.roll(random, "exact_gateways"));
-        NbtList exit = new NbtList();
-        exit.add(NbtInt.of(random.nextInt(-2048, 2048)));
-        exit.add(NbtInt.of(random.nextInt(daddy.min_y, daddy.min_y + daddy.height)));
-        exit.add(NbtInt.of(random.nextInt(-2048, 2048)));
-        config.put("exit", exit);
+        config.putInt("spread", (int)(1000 * Math.pow(2, 2 * random.nextDouble() - 1)));
+        if (PROVIDER.roll(random, "gateways_random_block")) addRandomBlock(config, "block", ConfigType.FULL_BLOCKS);
         return feature(config);
     }
 }

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

···
+package net.lerariemann.infinity.features;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.entity.EndGatewayBlockEntity;
+import net.minecraft.util.dynamic.Codecs;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.StructureWorldAccess;
+import net.minecraft.world.gen.feature.*;
+import net.minecraft.world.gen.feature.util.FeatureContext;
+
+import java.util.Optional;
+
+public class RandomEndGatewayFeature extends Feature<RandomEndGatewayFeature.Config> {
+    public RandomEndGatewayFeature(Codec<RandomEndGatewayFeature.Config> codec) {
+        super(codec);
+    }
+
+    @Override
+    public boolean generate(FeatureContext<RandomEndGatewayFeature.Config> context) {
+        BlockPos origin = context.getOrigin();
+        StructureWorldAccess structureWorldAccess = context.getWorld();
+        RandomEndGatewayFeature.Config config = context.getConfig();
+        BlockState bedrock = config.block.orElse(Blocks.BEDROCK.getDefaultState());
+        for (BlockPos bp : BlockPos.iterate(origin.add(-1, -2, -1), origin.add(1, 2, 1))) {
+            boolean bl = bp.getX() == origin.getX();
+            boolean bl2 = bp.getY() == origin.getY();
+            boolean bl3 = bp.getZ() == origin.getZ();
+            boolean bl4 = Math.abs(bp.getY() - origin.getY()) == 2;
+            BlockState localFluid = structureWorldAccess.getFluidState(bp).getBlockState().getBlock().getDefaultState();
+            if (bl && bl2 && bl3) {
+                BlockPos destination = new BlockPos(bp.getX() + context.getRandom().nextBetween(-config.spread, config.spread),
+                        bp.getY(), bp.getZ() + context.getRandom().nextBetween(-config.spread, config.spread));
+                destination = structureWorldAccess.getWorldBorder().clamp(destination);
+                this.setBlockState(structureWorldAccess, bp, Blocks.END_GATEWAY.getDefaultState());
+                if (structureWorldAccess.getBlockEntity(bp) instanceof EndGatewayBlockEntity egbe) {
+                    egbe.setExitPortalPos(destination, false);
+                }
+            } else if (bl2) {
+                this.setBlockState(structureWorldAccess, bp, localFluid);
+            } else if (bl4 && bl && bl3) {
+                this.setBlockState(structureWorldAccess, bp, bedrock);
+            } else if ((bl || bl3) && !bl4) {
+                this.setBlockState(structureWorldAccess, bp, bedrock);
+            } else {
+                this.setBlockState(structureWorldAccess, bp, localFluid);
+            }
+        }
+
+        return true;
+    }
+
+    public record Config(int spread, Optional<BlockState> block) implements FeatureConfig {
+        public static final Codec<RandomEndGatewayFeature.Config> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                (Codecs.rangedInt(1, 30000000).fieldOf("spread")).forGetter(a -> a.spread),
+                (BlockState.CODEC.optionalFieldOf("block")).forGetter(a -> a.block)).apply(
+                instance, RandomEndGatewayFeature.Config::new));
+    }
+}
+

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

···
     public static RegistrySupplier<RandomRoundMushroomFeature> RANDOM_ROUND_MUSHROOM;
     public static RegistrySupplier<RandomCeilingBlobFeature> RANDOM_CEILING_BLOB;
     public static RegistrySupplier<RandomBonusChestFeature> RANDOM_BONUS_CHEST;
+    public static RegistrySupplier<RandomEndGatewayFeature> RANDOM_END_GATEWAY;
     public static RegistrySupplier<RandomCubeFeature> RANDOM_CUBE;
     public static RegistrySupplier<RandomShapeFeature> RANDOM_STAR;
     public static RegistrySupplier<TextFeature> RANDOM_TEXT;
···
         RANDOM_TEXT = register("random_text", new TextFeature(TextFeature.Config.CODEC));
         PORTAL_SETUPPER = register("portal_setupper", new RandomPortalSetupper((RandomPortalSetupper.Config.CODEC)));
         RANDOM_BONUS_CHEST = register("bonus_chest", new RandomBonusChestFeature(RandomBonusChestFeature.Config.CODEC));
+        RANDOM_END_GATEWAY = register("end_gateway", new RandomEndGatewayFeature(RandomEndGatewayFeature.Config.CODEC));
         WONKY_TRUNK = TRUNKS.register("wonky", () -> new TrunkPlacerType<>(WonkyTrunkPlacer.CODEC));
         FEATURES.register();
         TRUNKS.register();

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

···
   "config.infinity.rootChances.features_rules.scatter_ores.description": "This setting changes how often to toggle between \"ore\" and \"scattered_ore\" types of ore deposit generation.",
   "config.infinity.rootChances.features_rules.scatter_end_spikes.description": "When you have end spikes in a random dimension, this is a chance they will be all over the place like in pre-1.9 and not in a perfect circle.",
   "config.infinity.rootChances.features_rules.cage_crystals.description": "This setting controls the percentage of spikes that have their end crystal in a cage.",
-  "config.infinity.rootChances.features_rules.exact_gateways.description": "This setting controls the chance that an End Gateway will teleport you to exact coordinates without regards to if you'll get stuck in a wall there. Otherwise, it will at least try to find a safe spot nearby.",
+  "config.infinity.rootChances.features_rules.gateways_bedrock.description": "This setting controls the chance that End Gateways will use a random block instead of bedrock.",
   "config.infinity.rootChances.features_rules.colourful_shapes.description": "This setting controls whether the large balls that spawn being of one random block or of a bunch of colored blocks.",
   "config.infinity.rootChances.features_rules.banded_shapes.description": "This setting controls whether large balls made of coloured blocks are arranged in a perlin noise map or in diagonal bands.",
   "config.infinity.rootChances.dimension_type.piglin_safe.description": "This setting controls the percentage of dimensions where Piglins are not converted into Zombie Piglins.",

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

···
       "scatter_ores": 0.2,
       "scatter_end_spikes": 0.67,
       "cage_crystals": 0.2,
-      "exact_gateways": 0.2,
+      "gateways_random_block": 0.8,
       "colourful_shapes": 0.5,
       "banded_shapes": 0.5
     },