Completely refactor player listener

src/main/java/org/mvplugins/multiverse/core/config/MVCoreConfig.java

@@ -188,12 +188,8 @@ public class MVCoreConfig implements MVConfig {
     }
 
     @Override
-    @Nullable
     public String getJoinDestination() {
-        if (Objects.equals(configHandle.get(configNodes.JOIN_DESTINATION), "")) {
+        return configHandle.get(configNodes.JOIN_DESTINATION);
-            return null;
-        }
-        return  configHandle.get(configNodes.JOIN_DESTINATION);
     }
 
     @Override

src/main/java/org/mvplugins/multiverse/core/listeners/MVChatListener.java

@@ -17,7 +17,6 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 public class MVChatListener implements InjectableListener {
     private final MVCoreConfig config;
     private final WorldManager worldManager;
-    private final MVPlayerListener playerListener;
 
     @Inject
     MVChatListener(
@@ -26,7 +25,6 @@ public class MVChatListener implements InjectableListener {
             MVPlayerListener playerListener) {
         this.config = config;
         this.worldManager = worldManager;
-        this.playerListener = playerListener;
     }
 
     /**
@@ -46,13 +44,7 @@ public class MVChatListener implements InjectableListener {
             return;
         }
 
-        String world = playerListener.getPlayerWorld().get(event.getPlayer().getName());
+        String prefix = this.worldManager.getLoadedWorld(event.getPlayer().getWorld())
-        if (world == null) {
-            world = event.getPlayer().getWorld().getName();
-            playerListener.getPlayerWorld().put(event.getPlayer().getName(), world);
-        }
-
-        String prefix = this.worldManager.getLoadedWorld(world)
                 .map(mvworld -> mvworld.isHidden() ? "" : mvworld.getAlias())
                 .getOrElse("");
         String chat = event.getFormat();

src/main/java/org/mvplugins/multiverse/core/listeners/MVPlayerListener.java

@@ -7,17 +7,15 @@
 
 package org.mvplugins.multiverse.core.listeners;
 
-import java.util.Map;
+import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
 
 import com.dumptruckman.minecraft.util.Logging;
 import io.vavr.control.Option;
 import jakarta.inject.Inject;
 import jakarta.inject.Provider;
+import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.Server;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -37,7 +35,6 @@ import org.mvplugins.multiverse.core.api.BlockSafety;
 import org.mvplugins.multiverse.core.commandtools.MVCommandManager;
 import org.mvplugins.multiverse.core.config.MVCoreConfig;
 import org.mvplugins.multiverse.core.destination.DestinationsProvider;
-import org.mvplugins.multiverse.core.destination.ParsedDestination;
 import org.mvplugins.multiverse.core.economy.MVEconomist;
 import org.mvplugins.multiverse.core.event.MVRespawnEvent;
 import org.mvplugins.multiverse.core.inject.InjectableListener;
@@ -45,6 +42,7 @@ import org.mvplugins.multiverse.core.teleportation.AsyncSafetyTeleporter;
 import org.mvplugins.multiverse.core.teleportation.TeleportQueue;
 import org.mvplugins.multiverse.core.utils.result.ResultChain;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.entrycheck.EntryFeeResult;
 import org.mvplugins.multiverse.core.world.entrycheck.WorldEntryCheckerProvider;
@@ -60,7 +58,6 @@ public class MVPlayerListener implements InjectableListener {
     private final Provider<WorldManager> worldManagerProvider;
     private final BlockSafety blockSafety;
     private final AsyncSafetyTeleporter safetyTeleporter;
-    private final Server server;
     private final TeleportQueue teleportQueue;
     private final MVEconomist economist;
     private final WorldEntryCheckerProvider worldEntryCheckerProvider;
@@ -68,8 +65,6 @@ public class MVPlayerListener implements InjectableListener {
     private final DestinationsProvider destinationsProvider;
     private final EnforcementHandler enforcementHandler;
 
-    private final Map<String, String> playerWorld = new ConcurrentHashMap<String, String>();
-
     @Inject
     MVPlayerListener(
             MultiverseCore plugin,
@@ -77,7 +72,6 @@ public class MVPlayerListener implements InjectableListener {
             Provider<WorldManager> worldManagerProvider,
             BlockSafety blockSafety,
             AsyncSafetyTeleporter safetyTeleporter,
-            Server server,
             TeleportQueue teleportQueue,
             MVEconomist economist,
             WorldEntryCheckerProvider worldEntryCheckerProvider,
@@ -89,7 +83,6 @@ public class MVPlayerListener implements InjectableListener {
         this.worldManagerProvider = worldManagerProvider;
         this.blockSafety = blockSafety;
         this.safetyTeleporter = safetyTeleporter;
-        this.server = server;
         this.teleportQueue = teleportQueue;
         this.economist = economist;
         this.worldEntryCheckerProvider = worldEntryCheckerProvider;
@@ -106,15 +99,6 @@ public class MVPlayerListener implements InjectableListener {
         return commandManagerProvider.get();
     }
 
-    /**
-     * Gets the map of player and the world name they are in.
-     *
-     * @return the playerWorld-map
-     */
-    public Map<String, String> getPlayerWorld() {
-        return playerWorld;
-    }
-
     /**
      * This method is called when a player respawns.
      *
@@ -122,189 +106,182 @@ public class MVPlayerListener implements InjectableListener {
      */
     @EventHandler(priority = EventPriority.LOW)
     public void playerRespawn(PlayerRespawnEvent event) {
-        World world = event.getPlayer().getWorld();
+        getWorldManager()
-        LoadedMultiverseWorld mvWorld = getWorldManager().getLoadedWorld(world.getName()).getOrNull();
+                .getLoadedWorld(event.getPlayer().getWorld())
-        // If it's not a World MV manages we stop.
+                .filter(mvWorld -> isBedOrAnchorRespawn(event, mvWorld))
-        if (mvWorld == null) {
+                .flatMap(MultiverseWorld::getRespawnWorld)
-            return;
+                .map(this::getMostAccurateRespawnLocation)
-        }
+                .peek(respawnLocation -> callMVRepawnEvent(event, respawnLocation));
-
-        if (mvWorld.getBedRespawn() && (event.isBedSpawn() || event.isAnchorSpawn())) {
-            Logging.fine("Spawning %s at their %s.", event.getPlayer().getName(), event.isBedSpawn() ? "BED" : "ANCHOR");
-            return;
-        }
-
-        // Get the instance of the World the player should respawn at.
-        LoadedMultiverseWorld respawnWorld = null;
-        if (getWorldManager().isLoadedWorld(mvWorld.getRespawnWorld())) {
-            respawnWorld = getWorldManager().getLoadedWorld(mvWorld.getRespawnWorld()).getOrNull();
-        }
-
-        // If it's null then it either means the World doesn't exist or the value is blank, so we don't handle it.
-        // NOW: We'll always handle it to get more accurate spawns
-        if (respawnWorld != null) {
-            world = respawnWorld.getBukkitWorld().getOrNull();
-        }
-        // World has been set to the appropriate world
-        Location respawnLocation = getMostAccurateRespawnLocation(world);
-
-        MVRespawnEvent respawnEvent = new MVRespawnEvent(respawnLocation, event.getPlayer(), "compatability");
-        this.server.getPluginManager().callEvent(respawnEvent);
-        event.setRespawnLocation(respawnEvent.getPlayersRespawnLocation());
     }
 
-    private Location getMostAccurateRespawnLocation(World w) {
+    private static boolean isBedOrAnchorRespawn(PlayerRespawnEvent event, LoadedMultiverseWorld mvWorld) {
-        LoadedMultiverseWorld mvw = getWorldManager().getLoadedWorld(w.getName()).getOrNull();
+        if (mvWorld.getBedRespawn() && (event.isBedSpawn() || event.isAnchorSpawn())) {
-        if (mvw != null) {
+            Logging.fine("Spawning %s at their %s.",
-            return mvw.getSpawnLocation();
+                    event.getPlayer().getName(),
+                    event.isBedSpawn() ? "BED" : "ANCHOR");
+            return false;
         }
-        return w.getSpawnLocation();
+        return true;
+    }
+
+    private Location getMostAccurateRespawnLocation(World world) {
+        return getWorldManager().getLoadedWorld(world.getName())
+                .map(LoadedMultiverseWorld::getSpawnLocation)
+                .getOrElse(world.getSpawnLocation());
+    }
+
+    private void callMVRepawnEvent(PlayerRespawnEvent event, Location respawnLocation) {
+        MVRespawnEvent respawnEvent = new MVRespawnEvent(
+                respawnLocation, event.getPlayer(), "compatability");
+        Bukkit.getPluginManager().callEvent(respawnEvent);
+        event.setRespawnLocation(respawnEvent.getPlayersRespawnLocation());
     }
 
     /**
      * This method is called when a player joins the server.
+     *
      * @param event The Event that was fired.
      */
     @EventHandler
     public void playerJoin(PlayerJoinEvent event) {
         Player player = event.getPlayer();
-        LoadedMultiverseWorld world = getWorldManager().getLoadedWorld(player.getWorld()).getOrNull();
+        if (player.hasPlayedBefore()) {
-        if (world == null) {
+            playerJoinAgain(event);
-            Logging.finer("Player joined in a world that is not managed by Multiverse.");
+        } else {
+            playerJoinFirstTime(event);
+        }
+
+        // Handle the Players GameMode setting for the new world.
+        this.handleGameModeAndFlight(event.getPlayer(), event.getPlayer().getWorld());
+    }
+
+    private void playerJoinAgain(PlayerJoinEvent event) {
+        Logging.finer("Player joined AGAIN!");
+        if (!config.getEnableJoinDestination()) {
+            return;
+        }
+
+        Option.of(destinationsProvider.parseDestination(config.getJoinDestination()))
+                .peek(joinDestination -> {
+                    Logging.fine("Moving player to: %s", joinDestination);
+                    safetyTeleporter.teleportSafely(event.getPlayer(), joinDestination);
+                })
+                .onEmpty(() -> {
+                    Logging.warning("JoinDestination '%s' is invalid! Not teleporting player!",
+                            config.getJoinDestination());
+                });
+    }
+
+    private void playerJoinFirstTime(PlayerJoinEvent event) {
+        Logging.finer("Player joined for the FIRST time!");
+        if (!config.getFirstSpawnOverride()) {
             return;
         }
 
         Option.of(destinationsProvider.parseDestination(config.getFirstSpawnLocation()))
-                .peek(parsedDestination -> {
+                .peek(firstSpawnDestination -> {
-                    if (!player.hasPlayedBefore()) {
+                    Logging.fine("Moving NEW player to(firstspawnoverride): %s", firstSpawnDestination);
-                        Logging.finer("Player joined for the FIRST time!");
+                    safetyTeleporter.teleportSafely(event.getPlayer(), firstSpawnDestination);
-                        if (config.getFirstSpawnOverride()) {
+                })
-                            Logging.fine("Moving NEW player to(firstspawnoverride): %s", config.getFirstSpawnLocation());
+                .onEmpty(() -> {
-                            this.sendPlayerToDefaultWorld(player, parsedDestination);
+                    Logging.warning("FirstSpawnLocation '%s' is invalid! Not teleporting player!",
-                        }
+                            config.getFirstSpawnLocation());
-                    }
-                    handleJoinDestination(player);
                 });
-
-        // Handle the Players GameMode setting for the new world.
-        this.handleGameModeAndFlight(event.getPlayer(), event.getPlayer().getWorld());
-        playerWorld.put(player.getName(), player.getWorld().getName());
-    }
-
-    /**
-     * Will teleport the player to the destination specified in config
-     * @param player The {@link Player} to teleport
-     */
-    private void handleJoinDestination(@NotNull Player player) {
-        if (!config.getEnableJoinDestination()) {
-            Logging.finer("JoinDestination is disabled");
-            // User has disabled the feature in config
-            return;
-        }
-
-        if (config.getJoinDestination() == null) {
-            Logging.warning("Joindestination is enabled but no destination has been specified in config!");
-            return;
-        }
-
-        Logging.finer("JoinDestination is " + config.getJoinDestination());
-        ParsedDestination<?> joinDestination = destinationsProvider.parseDestination(config.getJoinDestination());
-
-        if (joinDestination == null) {
-            Logging.warning("The destination in JoinDestination in config is invalid");
-            return;
-        }
-
-        // Finally, teleport the player
-        safetyTeleporter.teleportSafely(player, player, joinDestination);
     }
 
     /**
      * This method is called when a player changes worlds.
+     *
      * @param event The Event that was fired.
      */
     @EventHandler(priority = EventPriority.MONITOR)
     public void playerChangedWorld(PlayerChangedWorldEvent event) {
         // Permissions now determine whether or not to handle a gamemode.
-        this.handleGameModeAndFlight(event.getPlayer(), event.getPlayer().getWorld());
+        handleGameModeAndFlight(event.getPlayer(), event.getPlayer().getWorld());
-        playerWorld.put(event.getPlayer().getName(), event.getPlayer().getWorld().getName());
     }
 
     /**
      * This method is called when a player teleports anywhere.
+     *
      * @param event The Event that was fired.
      */
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void playerTeleport(PlayerTeleportEvent event) {
-        Logging.finer("Got teleport event for player '"
+        if (event.getTo() == null) {
-                + event.getPlayer().getName() + "' with cause '" + event.getCause() + "'");
-        if (event.isCancelled()) {
             return;
         }
+
+        Logging.finer("Got teleport event for player '%s' with cause '%s'",
+                event.getPlayer().getName(), event.getCause());
+
         Player teleportee = event.getPlayer();
-        CommandSender teleporter;
+        CommandSender teleporter = getTeleporter(teleportee);
-        Optional<String> teleporterName = teleportQueue.popFromQueue(teleportee.getName());
+
-        if (teleporterName.isPresent()) {
+        World fromWorld = event.getFrom().getWorld();
-            if (teleporterName.equals("CONSOLE")) {
+        World toWorld = event.getTo().getWorld();
-                Logging.finer("We know the teleporter is the console! Magical!");
-                teleporter = this.server.getConsoleSender();
-            } else {
-                teleporter = this.server.getPlayerExact(teleporterName.get());
-            }
-        } else {
-            teleporter = teleportee;
-        }
-        Logging.finer("Inferred sender '" + teleporter + "' from name '"
-                + teleporterName + "', fetched from name '" + teleportee.getName() + "'");
-        LoadedMultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld().getName()).getOrNull();
-        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(event.getTo().getWorld().getName()).getOrNull();
         if (toWorld == null) {
-            Logging.fine("Player '" + teleportee.getName() + "' is teleporting to world '"
+            Logging.warning("Player '%s' is teleporting to a world that does not exist. "
-                    + event.getTo().getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
+                    + "No further actions will be taken by Multiverse-Core.", teleportee.getName());
-                    + "actions will be taken by Multiverse-Core.");
             return;
         }
-        if (event.getFrom().getWorld().equals(event.getTo().getWorld())) {
+
+        if (Objects.equals(fromWorld, toWorld)) {
             // The player is Teleporting to the same world.
-            Logging.finer("Player '" + teleportee.getName() + "' is teleporting to the same world.");
+            Logging.finer("Player '%s' is teleporting to the same world '%s'.",
-            this.stateSuccess(teleportee.getName(), toWorld.getAlias());
+                    teleportee.getName(), toWorld.getName());
             return;
         }
 
-        ResultChain entryResult = worldEntryCheckerProvider.forSender(teleporter).canEnterWorld(fromWorld, toWorld)
+        checkTeleportEntry(event, toWorld, fromWorld, teleporter, teleportee);
-                .onSuccessReason(EntryFeeResult.Success.class, reason -> {
-                    if (reason == EntryFeeResult.Success.ENOUGH_MONEY) {
-                        economist.payEntryFee((Player) teleporter, toWorld);
-                        // Send payment receipt
-                    }
-                })
-                .onFailure(results -> {
-                    event.setCancelled(true);
-                    getCommandManager().getCommandIssuer(teleporter).sendError(results.getLastResultMessage());
-                });
-
-        Logging.fine("Teleport result: %s", entryResult);
     }
 
-    private void stateSuccess(String playerName, String worldName) {
+    private @NotNull CommandSender getTeleporter(Player teleportee) {
-        Logging.fine("MV-Core is allowing Player '" + playerName
+        return teleportQueue.popFromQueue(teleportee.getName())
-                + "' to go to '" + worldName + "'.");
+                .map(teleporterName -> {
+                    Logging.finer("Player '%s' is being teleported by '%s'.",
+                            teleportee.getName(), teleporterName);
+                    return teleporterName.equals("CONSOLE")
+                            ? Bukkit.getConsoleSender()
+                            : Bukkit.getPlayerExact(teleporterName);
+                })
+                .getOrElse(teleportee);
+    }
+
+    private void checkTeleportEntry(
+            PlayerTeleportEvent event, World toWorld, World fromWorld, CommandSender teleporter, Player teleportee) {
+        getWorldManager().getLoadedWorld(toWorld).peek(mvToWorld -> {
+            LoadedMultiverseWorld mvFromWorld = getWorldManager().getLoadedWorld(fromWorld).getOrNull();
+            ResultChain entryResult = worldEntryCheckerProvider.forSender(teleporter)
+                    .canEnterWorld(mvFromWorld, mvToWorld)
+                    .onSuccessReason(EntryFeeResult.Success.class, reason -> {
+                        if (teleporter instanceof Player player && reason == EntryFeeResult.Success.ENOUGH_MONEY) {
+                            economist.payEntryFee(player, mvToWorld);
+                            // Send payment receipt
+                        }
+                    })
+                    .onFailure(results -> {
+                        event.setCancelled(true);
+                        getCommandManager().getCommandIssuer(teleporter).sendError(results.getLastResultMessage());
+                    });
+            Logging.fine("Teleport result: %s", entryResult);
+        }).onEmpty(() -> {
+            Logging.fine("Player '%s' is teleporting to world '%s' which is not managed by Multiverse-Core. "
+                    + "No further actions will be taken by Multiverse-Core.",
+                    teleportee.getName(),
+                    toWorld.getName());
+        });
     }
 
     /**
      * This method is called to adjust the portal location to the actual portal location (and not
      * right outside of it.
+     *
      * @param event The Event that was fired.
      */
-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void playerPortalCheck(PlayerPortalEvent event) {
-        if (event.isCancelled() || event.getFrom() == null) {
+        World fromWorld = event.getFrom().getWorld();
-            return;
+        if (fromWorld != null && fromWorld.getBlockAt(event.getFrom()).getType() != Material.NETHER_PORTAL) {
-        }
-
-        // REMEMBER! getTo MAY be NULL HERE!!!
-        // If the player was actually outside of the portal, adjust the from location
-        if (event.getFrom().getWorld().getBlockAt(event.getFrom()).getType() != Material.NETHER_PORTAL) {
             Location newloc = blockSafety.findPortalBlockNextTo(event.getFrom());
             // TODO: Fix this. Currently, we only check for PORTAL blocks. I'll have to figure out what
             // TODO: we want to do here.
@@ -312,71 +289,56 @@ public class MVPlayerListener implements InjectableListener {
                 event.setFrom(newloc);
             }
         }
-        // Wait for the adjust, then return!
-        if (event.getTo() == null) {
-            return;
-        }
     }
+
     /**
      * This method is called when a player actually portals via a vanilla style portal.
+     *
      * @param event The Event that was fired.
      */
-    @EventHandler(priority = EventPriority.HIGH)
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void playerPortal(PlayerPortalEvent event) {
-        if (event.isCancelled() || (event.getFrom() == null)) {
-            return;
-        }
-        // The adjust should have happened much earlier.
         if (event.getTo() == null) {
             return;
         }
+
         if (config.isUsingCustomPortalSearch()) {
             event.setSearchRadius(config.getCustomPortalSearchRadius());
         }
 
-        LoadedMultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld().getName()).getOrNull();
+        if (Objects.equals(event.getFrom().getWorld(), event.getTo().getWorld())) {
-        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(event.getTo().getWorld().getName()).getOrNull();
-        if (event.getFrom().getWorld().equals(event.getTo().getWorld())) {
-            // The player is Portaling to the same world.
             Logging.finer("Player '" + event.getPlayer().getName() + "' is portaling to the same world.");
             return;
         }
 
-        ResultChain entryResult = worldEntryCheckerProvider.forSender(event.getPlayer()).canEnterWorld(fromWorld, toWorld)
+        checkPortalTeleportEntry(event);
-                .onFailure(results -> {
-                    event.setCancelled(true);
-                    getCommandManager().getCommandIssuer(event.getPlayer()).sendError(results.getLastResultMessage());
-                });
-
-        Logging.fine("Teleport result: %s", entryResult);
     }
 
-    private void sendPlayerToDefaultWorld(final Player player, ParsedDestination parsedDestination) {
+    private void checkPortalTeleportEntry(PlayerPortalEvent event) {
-        // Remove the player 1 tick after the login. I'm sure there's GOT to be a better way to do this...
+        getWorldManager().getLoadedWorld(event.getTo().getWorld()).peek(toWorld -> {
-        this.server.getScheduler().scheduleSyncDelayedTask(this.plugin,
+            LoadedMultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld()).getOrNull();
-            new Runnable() {
+            ResultChain entryResult = worldEntryCheckerProvider.forSender(event.getPlayer())
-                @Override
+                    .canEnterWorld(fromWorld, toWorld)
-                public void run() {
+                    .onFailure(results -> {
-                    safetyTeleporter.teleportSafely(player, player, parsedDestination);
+                        event.setCancelled(true);
-                }
+                        getCommandManager().getCommandIssuer(event.getPlayer())
-            }, 1L);
+                                .sendError(results.getLastResultMessage());
+                    });
+            Logging.fine("Teleport result: %s", entryResult);
+        });
     }
 
     /**
-     * Handles the gamemode for the specified {@link Player}.
+     * Handles the gamemode for the specified {@link Player} with a 1 tick delay.
      *
      * @param player The {@link Player}.
      * @param world  The {@link World} the player is supposed to be in.
      */
     private void handleGameModeAndFlight(final Player player, World world) {
-        // We perform this task one tick later to MAKE SURE that the player actually reaches the
+        if (!player.isOnline() || !player.getWorld().equals(world)) {
-        // destination world, otherwise we'd be changing the player mode if they havent moved anywhere.
+            return;
-        this.server.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> {
+        }
-            if (!player.isOnline() || !player.getWorld().equals(world)) {
+        enforcementHandler.handleFlightEnforcement(player);
-                return;
+        enforcementHandler.handleGameModeEnforcement(player);
-            }
-            enforcementHandler.handleFlightEnforcement(player);
-            enforcementHandler.handleGameModeEnforcement(player);
-        }, 1L);
     }
 }

src/main/java/org/mvplugins/multiverse/core/teleportation/TeleportQueue.java

@@ -2,9 +2,9 @@ package org.mvplugins.multiverse.core.teleportation;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Optional;
 
 import com.dumptruckman.minecraft.util.Logging;
+import io.vavr.control.Option;
 import org.jvnet.hk2.annotations.Service;
 
 @Service
@@ -29,15 +29,16 @@ public class TeleportQueue {
 
     /**
      * This method is used to find out who is teleporting a player.
+     *
      * @param playerName The teleported player (the teleportee).
      * @return The player that teleported the other one (the teleporter).
      */
-    public Optional<String> popFromQueue(String playerName) {
+    public Option<String> popFromQueue(String playerName) {
         if (teleportQueue.containsKey(playerName)) {
             String teleportee = teleportQueue.get(playerName);
             teleportQueue.remove(playerName);
-            return Optional.of(teleportee);
+            return Option.of(teleportee);
         }
-        return Optional.empty();
+        return Option.none();
     }
 }

src/main/java/org/mvplugins/multiverse/core/world/MultiverseWorld.java

@@ -4,6 +4,7 @@ import java.util.Collection;
 import java.util.List;
 
 import com.google.common.base.Strings;
+import io.vavr.control.Option;
 import io.vavr.control.Try;
 import org.bukkit.Bukkit;
 import org.bukkit.Difficulty;
@@ -463,8 +464,8 @@ public class MultiverseWorld {
      *
      * @return A world that exists on the server.
      */
-    public @Nullable World getRespawnWorld() {
+    public @Nullable Option<World> getRespawnWorld() {
-        return Bukkit.getWorld(worldConfig.getRespawnWorld());
+        return Option.of(Bukkit.getWorld(worldConfig.getRespawnWorld()));
     }
 
     /**