nether portals no longer overwritten

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

···
     public static void tryUpdateOpenStatus(InfinityPortalBlockEntity npbe, ServerWorld worldFrom,
                                            ServerWorld worldTo, BlockPos pos) {
         if (!npbe.isOpen() ^ worldTo == null) {
-            PortalCreationLogic.modifyPortalRecursive(worldFrom, pos,
-                    new PortalCreationLogic.PortalModifier(e -> e.setOpen(!npbe.isOpen())));
+            PortalCreationLogic.modifyPortalRecursive(worldFrom, pos, e -> e.setOpen(!npbe.isOpen()));
         }
     }
 
···
     }
 
     /**
-     * Filter for portal blocks except infinity portals of other destinations.
-     */
-    public static boolean isValidDestinationWeak(ServerWorld worldFrom, ServerWorld worldTo, BlockPos posTo) {
-        if (posTo == null || !InfinityMethods.dimExists(worldTo)) return false;
-        return (worldTo.getBlockState(posTo).isOf(Blocks.NETHER_PORTAL))
-                || (worldTo.getBlockEntity(posTo) instanceof InfinityPortalBlockEntity ipbe
-                && ipbe.getDimension().toString().equals(worldFrom.getRegistryKey().getValue().toString()));
-    }
-
-    /**
      * Filter for infinity portals of the correct destination.
      */
     public static boolean isValidDestinationStrong(ServerWorld worldFrom, ServerWorld worldTo, BlockPos posTo) {
···
         PointOfInterestStorage poiStorage = worldTo.getPointOfInterestStorage();
         poiStorage.preloadChunks(worldTo, originOfTesting, radiusOfTesting);
 
-        Set<BlockPos> allPortalsInRange = poiStorage.getInSquare(poiType ->
+        return poiStorage.getInSquare(poiType ->
                                 poiType.matchesKey(PointOfInterestTypes.NETHER_PORTAL) || poiType.matchesKey(ModPoi.NEITHER_PORTAL_KEY),
                         originOfTesting, radiusOfTesting, PointOfInterestStorage.OccupationStatus.ANY)
                 .map(PointOfInterest::getPos)
                 .filter(wbTo::contains)
-                .collect(Collectors.toSet());
-
-        Set<BlockPos> matchingPortalsInRange = allPortalsInRange
-                .stream()
                 .filter(pos -> isValidDestinationStrong(worldFrom, worldTo, pos))
-                .collect(Collectors.toSet()); //try a stronger selector first (only infinity portals of matching dimension)
-
-        if (matchingPortalsInRange.isEmpty())
-            matchingPortalsInRange = allPortalsInRange
-                    .stream()
-                    .filter(pos -> isValidDestinationWeak(worldFrom, worldTo, pos))
-                    .collect(Collectors.toSet()); //try a weaker selector (which also accepts nether portals)
-
-        return matchingPortalsInRange.stream()
                 .min(Comparator.comparingDouble(posTo -> posTo.getSquaredDistance(originOfTesting)));
     }
 
···
             if (ipbe.isConnectedBothSides()) return; //don't resync what's already synced
         }
         else {
-            otherSideModifier = PortalCreationLogic.forInitialSetupping(worldTo, posTo, idFrom, true); //make it an infinity portal while you're at it
+            otherSideModifier = PortalCreationLogic.forInitialSetupping(worldTo, posTo, idFrom, true);
+            //make it an infinity portal while you're at it
         }
 
         otherSideModifier.addModifier(ipbe1 -> ipbe1.setBlockPos(posFrom));
-        PortalCreationLogic.modifyPortalRecursive(worldFrom, posFrom,
-                new PortalCreationLogic.PortalModifier(ipbe -> ipbe.setBlockPos(posTo)));
+        PortalCreationLogic.modifyPortalRecursive(worldFrom, posFrom, ipbe -> ipbe.setBlockPos(posTo));
         PortalCreationLogic.modifyPortalRecursive(worldTo, posTo, otherSideModifier);
     }
 }

common/src/main/java/net/lerariemann/infinity/mixin/NetherPortalBlockMixin.java

···
 		return (neighborState.getBlock() instanceof NetherPortalBlock);
 	}
 
+	/* This makes sure that newly portals in infdims become infinity portals. */
 	@Override
 	protected void injected_onBlockAdded(BlockState state, World world, BlockPos pos, BlockState oldState, boolean notify, CallbackInfo ci) {
 		if (state.isOf(Blocks.NETHER_PORTAL) &&

common/src/main/java/net/lerariemann/infinity/mixin/ServerPlayerEntityMixin.java

···
 package net.lerariemann.infinity.mixin;
 
-import com.llamalad7.mixinextras.sugar.Local;
 import com.mojang.authlib.GameProfile;
-import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.Timebombable;
 import net.lerariemann.infinity.access.ServerPlayerEntityAccess;
 import net.lerariemann.infinity.options.InfinityOptions;
 import net.lerariemann.infinity.util.InfinityMethods;
-import net.lerariemann.infinity.util.PortalCreationLogic;
 import net.lerariemann.infinity.util.WarpLogic;
 import net.lerariemann.infinity.var.ModPayloads;
-import net.minecraft.block.Blocks;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.damage.DamageSource;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.network.packet.s2c.play.PositionFlag;
-import net.minecraft.registry.RegistryKey;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
···
     @Inject(method="findRespawnPosition", at = @At("HEAD"), cancellable = true)
     private static void injected(ServerWorld world, BlockPos pos, float angle, boolean forced, boolean alive, CallbackInfoReturnable<Optional<Vec3d>> cir) {
         if (((Timebombable)world).infinity$isTimebombed()) cir.setReturnValue(Optional.empty());
-    }
-
-    /* When the player is using the Infinity portal, this modifies the portal on the other side if needed. */
-    @Inject(method = "teleportTo",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/server/network/ServerPlayerEntity;setServerWorld(Lnet/minecraft/server/world/ServerWorld;)V")
-    )
-    private void injected2(TeleportTarget teleportTarget, CallbackInfoReturnable<Entity> cir, @Local(ordinal = 0) ServerWorld serverWorld, @Local RegistryKey<World> registryKey) {
-        if (InfinityMod.provider.rule("returnPortalsEnabled") &&
-                (registryKey.getValue().getNamespace().equals(InfinityMod.MOD_ID))) {
-            BlockPos pos = BlockPos.ofFloored(teleportTarget.pos());
-            ServerWorld destination = teleportTarget.world();
-            for (BlockPos pos2: new BlockPos[] {pos, pos.add(1, 0, 0), pos.add(0, 0, 1),
-                    pos.add(-1, 0, 0), pos.add(0, 0, -1)}) if (destination.getBlockState(pos2).isOf(Blocks.NETHER_PORTAL)) {
-                Identifier dimensionName = registryKey.getValue();
-
-                PortalCreationLogic.modifyPortalRecursive(destination, pos2, dimensionName, true);
-                break;
-            }
-        }
     }
 
     @Inject(method = "teleportTo",

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

···
             }
 
             /* Set the portal's open status making it usable. */
-            modifyPortalRecursive(world, pos, new PortalModifierUnion()
-                    .addModifier(be -> be.setOpen(true))
-                    .addModifier(BlockEntity::markDirty));
+            modifyPortalRecursive(world, pos, be -> {
+                be.setOpen(true);
+                be.markDirty();
+            });
             runAfterEffects(world, pos, bl, true);
         }
         return bl;
     }
 
     /**
+     * Updates this and all neighbouring portal blocks with a new dimension and open status.
+     */
+    static void modifyPortalRecursive(ServerWorld world, BlockPos pos, Identifier id, boolean open) {
+        modifyPortalRecursive(world, pos, forInitialSetupping(world, pos, id, open));
+    }
+
+    /**
      * Recursively creates a queue of neighbouring portal blocks and for each of them executes an action.
      */
+    static void modifyPortalRecursive(ServerWorld world, BlockPos pos, Consumer<InfinityPortalBlockEntity> consumer) {
+        modifyPortalRecursive(world, pos, new PortalModifier(consumer));
+    }
     static void modifyPortalRecursive(ServerWorld world, BlockPos pos, BiConsumer<World, BlockPos> modifier) {
         Set<BlockPos> set = Sets.newHashSet();
         Queue<BlockPos> queue = Queues.newArrayDeque();
···
                 .addModifier(npbe -> npbe.setColor(applier.apply(npbe.getPos())))
                 .addModifier(npbe -> npbe.setOpen(open))
                 .addModifier(BlockEntity::markDirty);
-    }
-
-    /**
-     * Updates this and all neighbouring portal blocks with a new dimension and open status.
-     */
-    static void modifyPortalRecursive(ServerWorld world, BlockPos pos, Identifier id, boolean open) {
-        modifyPortalRecursive(world, pos, forInitialSetupping(world, pos, id, open));
     }
 
     /**

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

···
   "config.infinity.gameRules.iridescenceInitialDuration.description": "How long it takes for the visual aspects of the iridescent effect to start, in minutes. Set to 0 to start them immediately.",
   "config.infinity.gameRules.iridescenceCooldownDuration": "Iridescence - cooldown duration",
   "config.infinity.gameRules.iridescenceCooldownDuration.description": "Duration of the iridescent cooldown effect in minutes. The full cooldown is twice this, the second half limiting the player to level I of the effect. Set to 0 to disable the cooldown.",
-  "config.infinity.gameRules.returnPortalsEnabled": "Enable Return Portals",
-  "config.infinity.gameRules.returnPortalsEnabled.description": "If enabled, every time you go through a portal from a custom dimension and generate a new portal, it will link back to a dimension you came from. If changed to false, all portals created this way will be normal Nether Portals.",
-  "config.infinity.gameRules.runtimeGenerationEnabled": "Enable Runtime Generation",
+ "config.infinity.gameRules.runtimeGenerationEnabled": "Enable Runtime Generation",
   "config.infinity.gameRules.runtimeGenerationEnabled.description": "If disabled, registration of dimensions and features in runtime will no longer occur, meaning you need to quit to title and enter the world again to access dimensions after tossing the book. Included for compatibility reasons.",
   "config.infinity.gameRules.chaosMobsEnabled": "Enable Chaos Mobs",
   "config.infinity.gameRules.chaosMobsEnabled.description": "If disabled, this mod's Chaos Mobs will no longer spawn, both in dimensions and inside your portals.",

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

···
   "infinity_version": 2003008,
   "gameRules": {
     "runtimeGenerationEnabled": true,
-    "returnPortalsEnabled": true,
     "longArithmeticEnabled": false,
     "forceSolidSurface": false,
     "chaosMobsEnabled": true,

docs/Configuring-the-mod.mdx

···
 
 ### Gamerules
 * `runtimeGenerationEnabled` - setting this to false will disable registration of dimensions and features in runtime, meaning you need to quit to title and enter the world again to access dimensions after tossing the book. Included for compatibility reasons.
-* `returnPortalsEnabled` - leaving this as true means every time you go through a portal from a custom dimension and generate a new portal, it will link back to a dimension you came from. If changed to false, all portals created this way will be normal nether portals.
 * `longArithmeticEnabled` - setting this to true will expand the range in which dimension, biome and feature IDs generate from the integer limit (~2 billion) to the long limit (~9 quintillion). You know, if for some reason 2 billion dimensions is not enough for you :D
 * `forceSolidSurface` - setting this to true will disallow non-full blocks from being used as material for the surface of random biomes.
 * `chaosMobsEnabled` - a toggle to enable/disable custom mobs, added in the mod, from naturally spawning.