debug errors & better warp

common/src/main/java/net/lerariemann/infinity/access/Timebombable.java

···
 package net.lerariemann.infinity.access;
 
+import net.lerariemann.infinity.util.InfinityMethods;
+import net.lerariemann.infinity.util.WarpLogic;
+import net.lerariemann.infinity.var.ModCriteria;
+import net.minecraft.entity.damage.DamageSource;
+import net.minecraft.entity.damage.DamageType;
+import net.minecraft.registry.Registry;
+import net.minecraft.registry.RegistryKeys;
+import net.minecraft.registry.entry.RegistryEntry;
+import net.minecraft.server.network.ServerPlayerEntity;
+
 public interface Timebombable {
     int cooldownTicks = 6000;
 
···
 
     boolean infinity$isTimebombed();
     int infinity$getTimebombProgress();
+
+    default void tickTimebombProgress(ServerPlayerEntity player) {
+        int i = infinity$getTimebombProgress();
+        if (i > 3540) {
+            WarpLogic.respawnAlive(player);
+        }
+        else if (i > 3500) {
+            ModCriteria.WHO_REMAINS.get().trigger(player);
+        }
+        else if (i > 200) {
+            if (i%4 == 0) {
+                Registry<DamageType> r = player.getServerWorld().getServer().getRegistryManager().get(RegistryKeys.DAMAGE_TYPE);
+                RegistryEntry<DamageType> entry = r.getEntry(r.get(InfinityMethods.getId("world_ceased")));
+                player.damage(new DamageSource(entry), i > 400 ? 2.0f : 1.0f);
+            }
+        }
+    }
 }

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

···
 import net.lerariemann.infinity.entity.ModEntities;
 import net.lerariemann.infinity.entity.custom.ChaosPawn;
 import net.lerariemann.infinity.item.ModItems;
-import net.lerariemann.infinity.util.WarpLogic;
 import net.lerariemann.infinity.var.ModPoi;
 import net.minecraft.block.*;
 import net.minecraft.block.entity.BlockEntity;
···
 import net.minecraft.particle.DustParticleEffect;
 import net.minecraft.particle.ParticleEffect;
 import net.minecraft.particle.ParticleTypes;
-import net.minecraft.registry.Registries;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundCategory;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.state.StateManager;
 import net.minecraft.state.property.BooleanProperty;
 import net.minecraft.state.property.Properties;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.Hand;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.WorldSavePath;
+import net.minecraft.text.MutableText;
+import net.minecraft.text.Text;
+import net.minecraft.util.*;
 import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
···
 import net.minecraft.world.poi.PointOfInterest;
 import net.minecraft.world.poi.PointOfInterestStorage;
 import net.minecraft.world.poi.PointOfInterestTypes;
-import org.apache.logging.log4j.LogManager;
 import org.jetbrains.annotations.Nullable;
 import org.joml.Vector3f;
 
···
             BlockEntity blockEntity = world.getBlockEntity(pos);
             if (blockEntity instanceof InfinityPortalBlockEntity npbe) {
                 /* If the portal is open already, nothing should happen. */
-                if (npbe.getOpen() && world_exists(s, npbe.getDimension()))
+                if (npbe.isOpen() && world_exists(s, npbe.getDimension()))
                     return ActionResult.SUCCESS;
 
                 /* If the portal key is blank, open the portal on any right-click. */
                 RandomProvider prov = InfinityMod.provider;
-                if (prov.portalKey.isBlank()) {
+                Optional<Item> key = prov.getPortalKeyAsItem();
+                if (key.isEmpty()) {
                     PortalCreationLogic.openWithStatIncrease(player, s, world, pos);
                 }
 
                 /* Otherwise check if we're using the correct key. If so, open. */
                 else {
                     ItemStack usedKey = player.getStackInHand(Hand.MAIN_HAND);
-                    Item correctKey = Registries.ITEM.get(Identifier.of(prov.portalKey));
-                    if (usedKey.isOf(correctKey)) {
+                    if (usedKey.isOf(key.get())) {
                         if (!player.getAbilities().creativeMode && prov.rule("consumePortalKey")) {
                             usedKey.decrement(1); // Consume the key if needed
                         }
···
     }
 
     public static ComponentMap getKeyComponents(Identifier dim) {
-        Integer keycolor = WarpLogic.getKeyColorFromId(dim);
+        Integer keycolor = InfinityMethods.getKeyColorFromId(dim);
         return (ComponentMap.builder()
                 .add(ModItemFunctions.KEY_DESTINATION.get(), dim)
                 .add(ModItemFunctions.COLOR.get(), keycolor)).build();
···
                 ModItemFunctions.checkCollisionRecipes(world, e, ModItemFunctions.PORTAL_CRAFTING_TYPE.get(),
                     item -> getKeyComponents(item, npbe.getDimension()));
             if (entity instanceof PlayerEntity player
-                    && InfinityMod.provider.portalKey.isBlank()) {
+                    && InfinityMod.provider.isPortalKeyBlank()) {
                 ServerWorld world1 = server.getWorld(RegistryKey.of(RegistryKeys.WORLD, npbe.getDimension()));
-                if ((world1 == null) || !npbe.getOpen())
+                if ((world1 == null) || !npbe.isOpen())
                     PortalCreationLogic.openWithStatIncrease(player, server, world, pos);
                 else {
                     Timebombable tw = (Timebombable)world1;
···
      */
     @Nullable @Override
     public TeleportTarget createTeleportTarget(ServerWorld worldFrom, Entity entity, BlockPos posFrom) {
-        try {
-            if (worldFrom.getBlockEntity(posFrom) instanceof InfinityPortalBlockEntity ipbe) {
-                Identifier id = ipbe.getDimension();
-                RegistryKey<World> keyTo = RegistryKey.of(RegistryKeys.WORLD, id);
-                ServerWorld worldTo = worldFrom.getServer().getWorld(keyTo);
+        if (worldFrom.getBlockEntity(posFrom) instanceof InfinityPortalBlockEntity ipbe) {
+            Identifier id = ipbe.getDimension();
+            RegistryKey<World> keyTo = RegistryKey.of(RegistryKeys.WORLD, id);
+            ServerWorld worldTo = worldFrom.getServer().getWorld(keyTo);
 
-                if (WarpLogic.dimExists(worldTo) && ipbe.getOpen()) {
-                    BlockPos targetPos = ipbe.getOtherSidePos();
-                    if (isValidDestinationStrong(worldFrom, worldTo, targetPos))
-                        return getExistingTarget(worldTo, targetPos, entity);
-                    return findNewTeleportTarget(worldFrom, posFrom, worldTo, entity);
-                }
+            if (InfinityMethods.dimExists(worldTo) && ipbe.isOpen()) {
+                BlockPos targetPos = ipbe.getOtherSidePos();
+                if (isValidDestinationStrong(worldFrom, worldTo, targetPos))
+                    return getExistingTarget(worldTo, targetPos, entity);
+                return findNewTeleportTarget(worldFrom, posFrom, worldTo, entity);
+            }
+
+            //below this point is error handling. note that not all such errors are bugs
+            if (worldTo == null && ipbe.isOpen()) { //an open portal with no destination? close that
+                PortalCreationLogic.modifyPortalRecursive(worldFrom, posFrom,
+                        new PortalCreationLogic.PortalModifier(e -> e.setOpen(false)));
+            }
+            if (entity instanceof ServerPlayerEntity player) {
+                sendErrors(player, worldTo, ipbe);
             }
         }
-        catch (Exception ignored) {}
+        else if (entity instanceof ServerPlayerEntity player)
+            InfinityMethods.sendUnexpectedError(player, "portal");
         return emptyTarget(entity); //if anything goes wrong, don't teleport anywhere
     }
 
+    static void sendErrors(ServerPlayerEntity player, ServerWorld worldTo, InfinityPortalBlockEntity ipbe) {
+        if (worldTo != null && ((Timebombable)worldTo).infinity$isTimebombed())
+            player.sendMessage(Text.translatable("error.infinity.portal.deleted"));
+        else if (!ipbe.isOpen())
+            InfinityMod.provider.getPortalKeyAsItem().ifPresent(item -> player.sendMessage(
+                    Text.translatable("error.infinity.portal.closed",
+                            ((MutableText)item.getName()).formatted(Formatting.AQUA))));
+        else if (worldTo == null)
+            player.sendMessage(Text.translatable("error.infinity.portal.null"));
+        else InfinityMethods.sendUnexpectedError(player, "portal");
+    }
+
     static Direction.Axis getAxisOrDefault(BlockState state) {
         if (state.getProperties().contains(Properties.HORIZONTAL_AXIS))
             return state.get(Properties.HORIZONTAL_AXIS);
···
      * Filter for portal blocks except infinity portals of other destinations.
      */
     public static boolean isValidDestinationWeak(ServerWorld worldFrom, ServerWorld worldTo, BlockPos posTo) {
-        if (posTo == null || !WarpLogic.dimExists(worldTo)) return false;
+        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) {
-        if (posTo == null || !WarpLogic.dimExists(worldTo)) return false;
+        if (posTo == null || !InfinityMethods.dimExists(worldTo)) return false;
         return (worldTo.getBlockEntity(posTo) instanceof InfinityPortalBlockEntity ipbe
                 && ipbe.getDimension().toString().equals(worldFrom.getRegistryKey().getValue().toString()));
     }
···
             Direction.Axis axis = worldFrom.getBlockState(posFrom).getOrEmpty(AXIS).orElse(Direction.Axis.X);
             Optional<BlockLocating.Rectangle> optional2 = worldTo.getPortalForcer().createPortal(originOfTesting, axis);
             if (optional2.isEmpty()) {
-                LogManager.getLogger().error("Unable to create a portal, likely target out of worldborder");
+                if (teleportingEntity instanceof ServerPlayerEntity player) {
+                    player.sendMessage(Text.translatable("error.infinity.portal.cannot_create"));
+                }
                 return emptyTarget(teleportingEntity);
             }
             rectangleTo = optional2.get();
···
         Identifier idFrom = worldFrom.getRegistryKey().getValue();
 
         if (worldTo.getBlockEntity(posTo) instanceof InfinityPortalBlockEntity ipbe) {
-            if (ipbe.getDimension() != idFrom || isValidDestinationStrong(worldTo, worldFrom, ipbe.getOtherSidePos())) return; //don't resync what's already synced
+            if (ipbe.getDimension() != idFrom) return;
+            if (isValidDestinationStrong(worldTo, worldFrom, ipbe.getOtherSidePos())) 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

common/src/main/java/net/lerariemann/infinity/block/entity/InfinityPortalBlockEntity.java

···
 package net.lerariemann.infinity.block.entity;
 
+import net.lerariemann.infinity.options.PortalColorApplier;
 import net.lerariemann.infinity.util.InfinityMethods;
-import net.lerariemann.infinity.util.WarpLogic;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.nbt.NbtCompound;
···
     public int getPortalColor() {
         return this.portalColor;
     }
-    public boolean getOpen() {
+    public boolean isOpen() {
         return this.isOpen;
     }
     @Nullable
···
             this.dimension = Identifier.of(tag.getString("Dimension"));
             this.portalColor = tag.contains("Color", NbtElement.INT_TYPE) ?
                     tag.getInt("Color") :
-                    (world != null ? WarpLogic.getPortalColorApplier(dimension, world.getServer()) :
-                            WarpLogic.getPortalColorApplier(dimension, new NbtCompound())).apply(pos);
+                    (world != null ? PortalColorApplier.of(dimension, world.getServer()) :
+                            PortalColorApplier.of(dimension, new NbtCompound())).apply(pos);
         }
         else {
             setDimension(InfinityMethods.getRandomSeed(new Random())); //random by default

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

···
 import net.lerariemann.infinity.util.CommonIO;
 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;
···
         this.server = server;
         PROVIDER = InfinityMod.provider;
         identifier = id;
-        numericId = WarpLogic.getNumericFromId(identifier);
+        numericId = InfinityMethods.getNumericFromId(identifier);
         random = new Random(numericId);
         initializeStorage();
         /* Code for easter dimensions */

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

···
             if (Iridescence.shouldWarp(duration, amplifier)) {
                 player.setInvulnerable(true);
                 Identifier id = Iridescence.getIdForWarp(player);
-                WarpLogic.warpWithTimer(player, id, 10, false);
+                WarpLogic.requestWarpWithTimer(player, id, 10, false);
             }
             if (Iridescence.shouldReturn(duration, amplifier)) {
                 player.setInvulnerable(false);

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

···
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.PortalCreationLogic;
 import net.lerariemann.infinity.util.WarpLogic;
-import net.lerariemann.infinity.var.ModCriteria;
 import net.lerariemann.infinity.var.ModPayloads;
-import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.damage.DamageSource;
-import net.minecraft.entity.damage.DamageType;
-import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.network.packet.s2c.play.PositionFlag;
-import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
-import net.minecraft.registry.RegistryKeys;
-import net.minecraft.registry.entry.RegistryEntry;
-import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.GameMode;
 import net.minecraft.world.TeleportTarget;
 import net.minecraft.world.World;
-import net.minecraft.world.dimension.DimensionType;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
···
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-import java.util.HashSet;
 import java.util.Optional;
 import java.util.Set;
 
···
     @Shadow public abstract ServerWorld getServerWorld();
 
     @Shadow public abstract boolean teleport(ServerWorld world, double destX, double destY, double destZ, Set<PositionFlag> flags, float yaw, float pitch);
-
-    @Shadow public abstract Entity getCameraEntity();
 
     @Shadow public abstract boolean damage(DamageSource source, float amount);
 
···
     @Inject(method = "teleportTo",
             at = @At(value = "INVOKE", target = "Lnet/minecraft/server/MinecraftServer;getPlayerManager()Lnet/minecraft/server/PlayerManager;"))
     private void injected3(TeleportTarget teleportTarget, CallbackInfoReturnable<Entity> cir) {
-        InfinityMethods.sendS2CPayload(((ServerPlayerEntity)(Object)this), ModPayloads.setShaderFromWorld(teleportTarget.world()));
-        InfinityMethods.sendS2CPayload(((ServerPlayerEntity)(Object)this), ModPayloads.StarsRePayLoad.INSTANCE);
+        ServerPlayerEntity player = (ServerPlayerEntity)(Object)this;
+        InfinityMethods.sendS2CPayload(player, ModPayloads.setShaderFromWorld(teleportTarget.world()));
+        InfinityMethods.sendS2CPayload(player, ModPayloads.StarsRePayLoad.INSTANCE);
     }
 
     @Inject(method = "tick", at = @At("TAIL"))
     private void onTick(CallbackInfo ci) {
-        /* Handle infinity options */
-        InfinityOptions opt = InfinityOptions.access(getWorld());
-        if (!opt.effect.isEmpty()) {
-            if (getWorld().getTime() % opt.effect.cooldown() == 0) {
-                addStatusEffect(new StatusEffectInstance(opt.effect.id(), opt.effect.duration(), opt.effect.amplifier()));
-            }
-        }
+        ServerPlayerEntity player = (ServerPlayerEntity)(Object)this;
 
+        /* Handle infinity options */
+        InfinityOptions.access(getWorld()).effect.tryGiveEffect(player);
         /* Handle the warp command */
-        if (--this.infinity$ticksUntilWarp == 0L) {
-            MinecraftServer s = this.getServerWorld().getServer();
-            ServerWorld w = s.getWorld(RegistryKey.of(RegistryKeys.WORLD, this.infinity$idForWarp));
-            if (w==null) return;
-            double d = DimensionType.getCoordinateScaleFactor(this.getServerWorld().getDimension(), w.getDimension());
-            Entity self = getCameraEntity();
-            double y = MathHelper.clamp(self.getY(), w.getBottomY(), w.getTopY());
-            BlockPos blockPos2 = WarpLogic.getPosForWarp(w.getWorldBorder().clamp(self.getX() * d, y, self.getZ() * d), w);
-            BlockState state = w.getBlockState(blockPos2.down());
-            if (state.isAir() || state.isOf(Blocks.LAVA)) w.setBlockState(blockPos2.down(), Blocks.OBSIDIAN.getDefaultState());
-            this.teleport(w, blockPos2.getX() + 0.5, blockPos2.getY(), blockPos2.getZ() + 0.5, new HashSet<>(), self.getYaw(), self.getPitch());
-        }
-
+        if (--this.infinity$ticksUntilWarp == 0L)
+            WarpLogic.performWarp(player, infinity$idForWarp);
         /* Handle effects from dimension deletion */
-        int i = ((Timebombable)(getServerWorld())).infinity$getTimebombProgress();
-        if (i > 3540) {
-            WarpLogic.respawnAlive((ServerPlayerEntity)(Object)this);
-        }
-        else if (i > 3500) {
-            ModCriteria.WHO_REMAINS.get().trigger((ServerPlayerEntity)(Object)this);
-        }
-        else if (i > 200) {
-            if (i%4 == 0) {
-                Registry<DamageType> r = getServerWorld().getServer().getRegistryManager().get(RegistryKeys.DAMAGE_TYPE);
-                RegistryEntry<DamageType> entry = r.getEntry(r.get(InfinityMethods.getId("world_ceased")));
-                damage(new DamageSource(entry), i > 400 ? 2.0f : 1.0f);
-            }
-        }
+        ((Timebombable)getServerWorld()).tickTimebombProgress(player);
     }
 
     @Inject(method = "changeGameMode", at = @At("RETURN"))

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

···
 
 import net.minecraft.entity.effect.InstantStatusEffect;
 import net.minecraft.entity.effect.StatusEffect;
+import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.registry.entry.RegistryEntry;
+import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.util.Identifier;
 
 public record EffectGiver(RegistryEntry<StatusEffect> id, int duration, int amplifier, int cooldown) {
···
                 InfinityOptions.test(data, "amplifier", 0),
                 Math.min(InfinityOptions.test(data, "cooldown", 100), 100));
         return new EffectGiver(null, 0,0,200);
+    }
+
+    public void tryGiveEffect(ServerPlayerEntity player) {
+        if (!isEmpty() && player.getWorld().getTime() % cooldown == 0) {
+            player.addStatusEffect(new StatusEffectInstance(id, duration, amplifier));
+        }
     }
 
     public boolean isEmpty() {

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

···
 package net.lerariemann.infinity.options;
 
+import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.util.InfinityMethods;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtElement;
 import net.minecraft.nbt.NbtList;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 
 import java.awt.Color;
 import java.util.Random;
 
 public interface PortalColorApplier {
-    static PortalColorApplier extract(NbtCompound data, int def) {
-        if (!data.contains("portal_color")) return new PortalColorApplier.Simple(def);
+    static PortalColorApplier of(Identifier id, MinecraftServer server) {
+        return of(id, InfinityOptions.readData(server, id));
+    }
+    static PortalColorApplier of(Identifier id, NbtCompound defaultData) {
+        NbtCompound data = InfinityMod.provider.easterizer.optionmap.get(id.getPath());
+        if (data == null) data = defaultData;
+        return of(data, (int)InfinityMethods.getNumericFromId(id));
+    }
+    static PortalColorApplier of(NbtCompound data, int defaultColor) {
+        if (!data.contains("portal_color")) return new PortalColorApplier.Simple(defaultColor);
         if (data.contains("portal_color", NbtElement.INT_TYPE)) return new PortalColorApplier.Simple(data.getInt("portal_color"));
         NbtCompound applierData = data.getCompound("portal_color");
         return switch (applierData.getString("type")) {
···
             case "checker" -> new PortalColorApplier.Checker(applierData.getList("values", NbtElement.INT_TYPE));
             case "random_hue" -> new PortalColorApplier.RandomHue(applierData);
             case "random" -> PortalColorApplier.RandomColor.INSTANCE;
-            default -> new PortalColorApplier.Simple(def);
+            default -> new PortalColorApplier.Simple(defaultColor);
         };
     }
 

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

···
 package net.lerariemann.infinity.util;
 
+import com.google.common.hash.HashCode;
+import com.google.common.hash.Hashing;
 import dev.architectury.platform.Platform;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.lerariemann.infinity.InfinityMod;
+import net.lerariemann.infinity.access.Timebombable;
 import net.lerariemann.infinity.block.entity.BiomeBottleBlockEntity;
 import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
 import net.lerariemann.infinity.item.function.ModItemFunctions;
···
 import net.minecraft.network.packet.CustomPayload;
 import net.minecraft.registry.RegistryKey;
 import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.text.Text;
 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;
+
+import java.nio.charset.StandardCharsets;
 
 import static net.lerariemann.infinity.InfinityModClient.sampler;
 
···
         return (res >= 0) ? res : b + res;
     }
 
+    static void sendUnexpectedError(ServerPlayerEntity player, String type) {
+        player.sendMessage(Text.translatable("error.infinity." + type + ".unexpected"));
+    }
+
+    /**
+     * Convert a provided string into a dimension ID.
+     * This also checks if it matches an Easter Egg dimension.
+     */
+    static Identifier getIdentifier(String text) {
+        if (text.equals("abatised redivides")) return World.END.getValue();
+        if (text.isEmpty()) return InfinityMethods.getId("missingno");
+        if (InfinityMod.provider.easterizer.isEaster(text, InfinityMod.provider) && !text.equals("missingno")) return InfinityMethods.getId(text);
+        return InfinityMethods.getDimId(getDimensionSeed(text));
+    }
+
+    /**
+     * Check if a dimension exists and has not been timebombed.
+     */
+    static boolean dimExists(ServerWorld world) {
+        return (world != null && !((Timebombable)world).infinity$isTimebombed());
+    }
+
+    /**
+     * Hashes text into dimension ID.
+     */
+    static long getDimensionSeed(String text) {
+        HashCode f = Hashing.sha256().hashString(text + InfinityMod.provider.salt, StandardCharsets.UTF_8);
+        return InfinityMethods.longArithmeticEnabled() ? f.asLong() & Long.MAX_VALUE : f.asInt() & Integer.MAX_VALUE;
+    }
+
+    static long getNumericFromId(Identifier id) {
+        String dimensionName = id.getPath();
+        String numericId = dimensionName.substring(dimensionName.lastIndexOf("_") + 1);
+        long i;
+        try {
+            i = Long.parseLong(numericId);
+        } catch (Exception e) {
+            /* Simply hash the name if it isn't of "generated_..." format. */
+            i = getDimensionSeed(numericId);
+        }
+        return i;
+    }
+
     /**
      * Converts a coordinate value to a "random" color.
      */
···
             }
         }
         return 0xFFFFFF;
+    }
+
+    static int getKeyColorFromId(Identifier id) {
+        if(id.getNamespace().equals(InfinityMod.MOD_ID) && id.getPath().contains("generated_"))
+            return ColorHelper.Argb.fullAlpha((int) getNumericFromId(id) & 0xFFFFFF);
+        return 0;
     }
 
     static long getRandomSeed(java.util.Random random) {

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

···
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.SoundCategory;
 import net.minecraft.sound.SoundEvents;
+import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
···
         }
         if (writableComponent != null || writtenComponent != null || printedComponent != null) {
             String content = parseComponents(writableComponent, writtenComponent, printedComponent);
-            Identifier id = WarpLogic.getIdentifier(content);
+            Identifier id = InfinityMethods.getIdentifier(content);
             boolean bl = modifyOnInitialCollision(id, world, pos);
             if (bl) entity.remove(Entity.RemovalReason.CHANGED_DIMENSION);
         }
···
         PlayerEntity nearestPlayer = world.getClosestPlayer(pos.getX(), pos.getY(), pos.getZ(), 5, false);
 
         if (((MinecraftServerAccess)server).infinity$needsInvocation()) {
-            WarpLogic.onInvocationNeedDetected(nearestPlayer);
+            onInvocationNeedDetected(nearestPlayer);
             return false;
         }
 
···
         }
 
         /* If the portal key is blank, open the portal immediately. */
-        else if (InfinityMod.provider.portalKey.isBlank()) {
+        else if (InfinityMod.provider.isPortalKeyBlank()) {
             openWithStatIncrease(nearestPlayer, server, world, pos);
         }
         return true;
···
     /* Calls to open the portal and attributes the relevant statistics to a player provided. */
     static void openWithStatIncrease(PlayerEntity player, MinecraftServer s, ServerWorld world, BlockPos pos) {
         if (((MinecraftServerAccess)s).infinity$needsInvocation()) {
-            WarpLogic.onInvocationNeedDetected(player);
+            onInvocationNeedDetected(player);
             return;
         }
         boolean isDimensionNew = open(s, world, pos);
···
             }
             player.increaseStat(ModStats.PORTALS_OPENED_STAT, 1);
         }
+    }
+
+    static void onInvocationNeedDetected(PlayerEntity player) {
+        if (player != null) player.sendMessage(Text.translatable("error.infinity.invocation_needed"));
     }
 
     /**
···
     }
 
     static PortalModifierUnion forInitialSetupping(ServerWorld world, BlockPos pos, Identifier id, boolean open) {
-        PortalColorApplier applier = WarpLogic.getPortalColorApplier(id, world.getServer());
+        PortalColorApplier applier = PortalColorApplier.of(id, world.getServer());
         return new PortalModifierUnion()
                 .addSetupper(infPortalSetupper(world, pos))
                 .addModifier(nbpe -> nbpe.setDimension(id))

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

···
 package net.lerariemann.infinity.util;
 
 import net.lerariemann.infinity.InfinityMod;
+import net.minecraft.item.Item;
 import net.minecraft.nbt.*;
 import net.minecraft.registry.DynamicRegistryManager;
 import net.minecraft.registry.Registries;
···
                 rootChances.put(s, rootchances.getCompound(c).getDouble(s));
             }
         }
+    }
+
+    public Optional<Item> getPortalKeyAsItem() {
+        if (portalKey.isBlank()) return Optional.empty();
+        return Registries.ITEM.getOrEmpty(Identifier.of(portalKey));
+    }
+    public boolean isPortalKeyBlank() {
+        return getPortalKeyAsItem().isEmpty();
     }
 
     public NbtCompound notRandomTree(String tree, String block) {

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

···
 package net.lerariemann.infinity.util;
-import com.google.common.hash.HashCode;
-import com.google.common.hash.Hashing;
+
 import com.mojang.brigadier.context.CommandContext;
-import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.access.ServerPlayerEntityAccess;
-import net.lerariemann.infinity.access.Timebombable;
-import net.lerariemann.infinity.options.InfinityOptions;
-import net.lerariemann.infinity.options.PortalColorApplier;
 import net.lerariemann.infinity.var.ModStats;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.nbt.NbtCompound;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.fluid.FluidState;
+import net.minecraft.fluid.Fluids;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.RegistryKeys;
+import net.minecraft.registry.tag.FluidTags;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
-import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.ColorHelper;
+import net.minecraft.util.math.MathHelper;
 import net.minecraft.world.BlockView;
 import net.minecraft.world.TeleportTarget;
 import net.minecraft.world.World;
+import net.minecraft.world.dimension.DimensionType;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.nio.charset.StandardCharsets;
-
+import java.util.HashSet;
 
 public interface WarpLogic {
     /**
      * Handles the /warpid command, converting their numeric ID to an Identifier
      * and passing the data along to /warp.
      */
-    static void warpId(CommandContext<ServerCommandSource> context, long value) {
-        warp(context, InfinityMethods.getDimId(value));
+    static void requestWarpById(CommandContext<ServerCommandSource> context, long value) {
+        requestWarp(context, InfinityMethods.getDimId(value));
     }
 
     /**
      * Handles the /warp command, warping the player to their specified dimension.
      * The player-provided text should have already been converted to an Identifier.
      */
-    static void warp(CommandContext<ServerCommandSource> context, Identifier value) {
-        warpWithTimer(context.getSource().getPlayer(), value, 20, true);
+    static void requestWarp(CommandContext<ServerCommandSource> context, Identifier value) {
+        requestWarpWithTimer(context.getSource().getPlayer(), value, 2, true);
     }
 
     /**
      * Handles moving a specified player to a specified dimension.
      * This is used by both the warp commands and Iridescence.
      */
-    static void warpWithTimer(@Nullable ServerPlayerEntity player, Identifier value, int ticks, boolean increaseStats) {
+    static void requestWarpWithTimer(@Nullable ServerPlayerEntity player, Identifier value, int ticks, boolean increaseStats) {
         if (player == null) return;
         MinecraftServer s = player.getServer();
         if (s == null) return;
         if (((MinecraftServerAccess)s).infinity$needsInvocation()) {
-            onInvocationNeedDetected(player);
+            PortalCreationLogic.onInvocationNeedDetected(player);
             return;
         }
         boolean isThisANewDimension = PortalCreationLogic.addInfinityDimension(s, value);
···
     }
     /* will implement a proper end-of-time dimension later */
     static void sendToMissingno(ServerPlayerEntity player) {
-        warpWithTimer(player, InfinityMethods.getId("missingno"), 2, false);
+        requestWarpWithTimer(player, InfinityMethods.getId("missingno"), 2, false);
     }
 
-    static void onInvocationNeedDetected(PlayerEntity player) {
-        if (player != null) player.sendMessage(Text.translatable("error.infinity.invocation_needed"));
-    }
+    static void performWarp(ServerPlayerEntity player, Identifier idForWarp) {
+        MinecraftServer s = player.getServerWorld().getServer();
+        RegistryKey<World> key = RegistryKey.of(RegistryKeys.WORLD, idForWarp);
+        ServerWorld w = s.getWorld(key);
+        if (w==null) {
+            InfinityMethods.sendUnexpectedError(player, "warp");
+            return;
+        }
+
+        double d = DimensionType.getCoordinateScaleFactor(player.getServerWorld().getDimension(), w.getDimension());
+        double y = MathHelper.clamp(player.getY(), w.getBottomY(), w.getTopY());
+
+        BlockPos blockPos2 = getPosForWarp(w.getWorldBorder().clamp(player.getX() * d, y, player.getZ() * d), w);
 
-    static PortalColorApplier getPortalColorApplier(Identifier id, MinecraftServer server) {
-        return getPortalColorApplier(id, InfinityOptions.readData(server, id));
+        ensureSafety(w, blockPos2.down(), Blocks.OBSIDIAN);
+        ensureSafety(w, blockPos2, Blocks.AIR);
+        ensureSafety(w, blockPos2.up(), Blocks.AIR);
+        player.teleport(w, blockPos2.getX() + 0.5, blockPos2.getY(), blockPos2.getZ() + 0.5,
+                new HashSet<>(), player.getYaw(), player.getPitch());
     }
-    static PortalColorApplier getPortalColorApplier(Identifier id, NbtCompound def) {
-        NbtCompound c = InfinityMod.provider.easterizer.optionmap.get(id.getPath());
-        if (c == null) c = def;
-        return PortalColorApplier.extract(c, (int)WarpLogic.getNumericFromId(id));
+
+    static void ensureSafety(ServerWorld world, BlockPos pos, Block fallback) {
+        BlockState fb = fallback.getDefaultState();
+        if (!isSafe(world.getBlockState(pos), fb))
+            world.setBlockState(pos, fb);
     }
 
-    static long getNumericFromId(Identifier id) {
-        String dimensionName = id.getPath();
-        String numericId = dimensionName.substring(dimensionName.lastIndexOf("_") + 1);
-        long i;
-        try {
-            i = Long.parseLong(numericId);
-        } catch (Exception e) {
-            /* Simply hash the name if it isn't of "generated_..." format. */
-            i = WarpLogic.getDimensionSeed(numericId);
-        }
-        return i;
+    static boolean isSafe(BlockState state, BlockState fallback) {
+        if (state.isAir()) return fallback.isAir();
+        FluidState fluidState = state.getFluidState();
+        return (fluidState.isOf(Fluids.EMPTY) || fluidState.isIn(FluidTags.WATER));
     }
 
-    static int getKeyColorFromId(Identifier id) {
-        if(id.getNamespace().equals(InfinityMod.MOD_ID) && id.getPath().contains("generated_"))
-            return ColorHelper.Argb.fullAlpha((int) getNumericFromId(id) & 0xFFFFFF);
-        return 0;
+    static BlockPos getPosForWarp(@NotNull BlockPos orig, @NotNull ServerWorld world) {
+        BlockPos pos = scanColumn(orig, world);
+        BlockPos iter = orig;
+        int counter = 0;
+        while (pos == null) {
+            if (++counter > 8) pos = orig;
+            else {
+                iter = iter.add(world.random.nextInt(8), 0, world.random.nextInt(8));
+                pos = scanColumn(iter, world);
+            }
+        }
+        return pos;
     }
 
-    static BlockPos getPosForWarp(BlockPos orig, ServerWorld world) {
+    @Nullable
+    static BlockPos scanColumn(BlockPos orig, ServerWorld world) {
         int x = orig.getX();
         int y1 = orig.getY();
         int z = orig.getZ();
···
             y2+=1;
             if (isPosViable(x, y2, z, world)) return new BlockPos(x, y2, z);
         }
-        return orig;
+        return null;
     }
 
     static boolean isPosViable(int x, int y, int z, BlockView w) {
+        if (w.isOutOfHeightLimit(y)) return false;
         boolean bl = w.getBlockState(new BlockPos(x, y+1, z)).isAir();
         boolean bl2 = w.getBlockState(new BlockPos(x, y, z)).isAir();
         boolean bl3 = w.getBlockState(new BlockPos(x, y-1, z)).isAir();
         return (!bl3 && bl2 && bl);
-    }
-
-    /**
-     * Convert a provided string into a dimension ID.
-     * This also checks if it matches an Easter Egg dimension.
-     */
-    static Identifier getIdentifier(String text) {
-        if (text.equals("abatised redivides")) return World.END.getValue();
-        if (text.isEmpty()) return InfinityMethods.getId("missingno");
-        if (InfinityMod.provider.easterizer.isEaster(text, InfinityMod.provider) && !text.equals("missingno")) return InfinityMethods.getId(text);
-        return InfinityMethods.getDimId(getDimensionSeed(text));
-    }
-
-    /**
-     * Check if a dimension exists and has not been timebombed.
-     */
-    static boolean dimExists(ServerWorld world) {
-        return (world != null && !((Timebombable)world).infinity$isTimebombed());
-    }
-
-    /**
-     * Hashes text into dimension ID.
-     */
-    static long getDimensionSeed(String text) {
-        HashCode f = Hashing.sha256().hashString(text + InfinityMod.provider.salt, StandardCharsets.UTF_8);
-        return InfinityMethods.longArithmeticEnabled() ? f.asLong() & Long.MAX_VALUE : f.asInt() & Integer.MAX_VALUE;
     }
 }

common/src/main/java/net/lerariemann/infinity/var/ModCommands.java

···
 import com.mojang.brigadier.arguments.IntegerArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import dev.architectury.event.events.common.CommandRegistrationEvent;
+import net.lerariemann.infinity.util.InfinityMethods;
 import net.lerariemann.infinity.util.WarpLogic;
 
 import static net.minecraft.server.command.CommandManager.argument;
···
                 .requires(source -> source.hasPermissionLevel(2))
                 .then(argument("id", IntegerArgumentType.integer()).executes(context -> {
                     final int value = IntegerArgumentType.getInteger(context, "id");
-                    WarpLogic.warpId(context, value);
+                    WarpLogic.requestWarpById(context, value);
                     return 1;
                 }))));
         CommandRegistrationEvent.EVENT.register((dispatcher, registryAccess, environment) -> dispatcher.register(literal("warp")
                 .requires(source -> source.hasPermissionLevel(2))
                 .then(argument("text", StringArgumentType.string()).executes(context -> {
                     final String text = StringArgumentType.getString(context, "text");
-                    WarpLogic.warp(context, WarpLogic.getIdentifier(text));
+                    WarpLogic.requestWarp(context, InfinityMethods.getIdentifier(text));
                     return 1;
                 }))));
 

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

···
   "entity.infinity.chaos_creeper.description": "These hostile mobs change the biome around them when they explode. They can be washed with a water bucket to reset the stored biome.",
   "entity.infinity.chaos_pawn.description": "These neutral mobs can be found in some dimensions and sometimes spawn randomly in Infinity Portals. They drop a random item when killed.",
   "error.infinity.invocation_needed": "This multiverse still needs invocation. This is a bug, please contact Lera",
+  "error.infinity.portal.null": "This dimension does not exist. This is a bug, please contact Lera",
+  "error.infinity.portal.deleted": "This dimension ceased to exist",
+  "error.infinity.portal.closed": "This portal is closed; use a key (%s) to open it",
+  "error.infinity.portal.cannot_create": "Unable to create an exit portal, likely target out of world border",
+  "error.infinity.portal.unexpected": "An unexpected teleportation error has occurred, please contact Lera",
+  "error.infinity.warp.unexpected": "An unexpected warp error has occurred, please contact Lera",
   "fluid.infinity.iridescence": "Iridescence",
   "item.infinity.chaos_skeleton_spawn_egg": "Chaos Skeleton Spawn Egg",
   "item.infinity.chaos_slime_spawn_egg": "Chaos Slime Spawn Egg",