Merge pull request #3421 from Multiverse/fix/null-to-location

Better null checking for to and from event locations

build.gradle

@@ -25,9 +25,9 @@ repositories {
 }
 
 configure(apiDependencies) {
-    serverApiVersion = '1.21.8-R0.1-SNAPSHOT'
+    serverApiVersion = '1.21.11-R0.1-SNAPSHOT'
     mockBukkitServerApiVersion = '1.21'
-    mockBukkitVersion = '4.84.0'
+    mockBukkitVersion = '4.100.0'
 }
 
 dependencies {

src/main/java/org/mvplugins/multiverse/core/MultiverseCore.java

@@ -126,6 +126,7 @@ public class MultiverseCore extends MultiverseModule {
         MultiverseCoreApi.shutdown();
         shutdownDependencyInjection();
         PluginServiceLocatorFactory.get().shutdown();
+        Logging.info("- Disabled");
         Logging.shutdown();
     }
 

src/main/java/org/mvplugins/multiverse/core/PlaceholderExpansionHook.java

@@ -1,6 +1,7 @@
 package org.mvplugins.multiverse.core;
 
 import com.google.common.collect.Lists;
+import io.vavr.control.Option;
 import jakarta.annotation.PostConstruct;
 import jakarta.inject.Inject;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
@@ -12,11 +13,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jvnet.hk2.annotations.Service;
 
+import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.economy.MVEconomist;
 import org.mvplugins.multiverse.core.utils.MinecraftTimeFormatter;
 import org.mvplugins.multiverse.core.utils.REPatterns;
 import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 
 import java.util.List;
@@ -26,12 +29,17 @@ import java.util.Locale;
 final class PlaceholderExpansionHook extends PlaceholderExpansion {
 
     private final MultiverseCore plugin;
+    private final CoreConfig coreConfig;
     private final WorldManager worldManager;
     private final MVEconomist economist;
 
     @Inject
-    public PlaceholderExpansionHook(MultiverseCore plugin, WorldManager worldManager, MVEconomist economist) {
+    public PlaceholderExpansionHook(@NotNull MultiverseCore plugin,
+                                    @NotNull CoreConfig coreConfig,
+                                    @NotNull WorldManager worldManager,
+                                    @NotNull MVEconomist economist) {
         this.plugin = plugin;
+        this.coreConfig = coreConfig;
         this.worldManager = worldManager;
         this.economist = economist;
     }
@@ -42,6 +50,13 @@ final class PlaceholderExpansionHook extends PlaceholderExpansion {
         return super.register();
     }
 
+    @Override
+    public void warning(String msg) {
+        if (coreConfig.getWarnInvalidPapiFormat()) {
+            super.warning(msg);
+        }
+    }
+
     @Override
     public @NotNull String getIdentifier() {
         return "multiverse-core";
@@ -80,22 +95,22 @@ final class PlaceholderExpansionHook extends PlaceholderExpansion {
             return null;
         }
 
-        final var placeholder = paramsArray.remove(0);
+        final var placeholder = paramsArray.remove(0).toLowerCase(Locale.ENGLISH);
 
-        String worldName = parseWorldName(offlinePlayer, paramsArray);
-        if (worldName == null) return null;
-
-        return worldManager.getLoadedWorld(worldName)
-                .onEmpty(() -> warning("Multiverse World not found: " + worldName))
-                .map(world -> getWorldPlaceHolderValue(placeholder, paramsArray, world))
-                .getOrNull();
+        return parseWorldName(offlinePlayer, paramsArray)
+                .flatMap(worldName -> worldManager.getWorld(worldName)
+                    .onEmpty(() -> warning("Multiverse World not found: " + worldName)))
+                .flatMap(world -> world.asLoadedWorld()
+                        .flatMap(loadedWorld -> getLoadedWorldPlaceHolderValue(placeholder, paramsArray, loadedWorld))
+                        .orElse(() -> getWorldPlaceHolderValue(placeholder, paramsArray, world)))
+                .getOrElse(() -> coreConfig.getInvalidPapiFormatReturnsBlank() ? "" : null);
     }
 
-    private @Nullable String parseWorldName(OfflinePlayer offlinePlayer, List<String> paramsArray) {
+    private @NotNull Option<String> parseWorldName(OfflinePlayer offlinePlayer, List<String> paramsArray) {
         // No world defined, get from player
         if (paramsArray.isEmpty()) {
             if (offlinePlayer instanceof Player player) {
-                return player.getWorld().getName();
+                return Option.of(player.getWorld().getName());
             } else {
                 warning("You must specify a world name for non-player placeholders");
                 return null;
@@ -104,112 +119,77 @@ final class PlaceholderExpansionHook extends PlaceholderExpansion {
 
         // Try get from params
         String paramWorldName = paramsArray.get(paramsArray.size() - 1);
-        if (worldManager.isLoadedWorld(paramWorldName)) {
+        if (worldManager.isWorld(paramWorldName)) {
             paramsArray.remove(paramsArray.size() - 1);
-            return paramWorldName;
+            return Option.of(paramWorldName);
         }
 
         // Param not a world, fallback to player
         if (offlinePlayer instanceof Player player) {
-            return player.getWorld().getName();
+            return Option.of(player.getWorld().getName());
         }
         warning("Multiverse World not found: " + paramWorldName);
-        return null;
+        return Option.none();
     }
 
-    private @Nullable String getWorldPlaceHolderValue(@NotNull String placeholder,
-                                                      @NotNull List<String> placeholderParams,
-                                                      @NotNull LoadedMultiverseWorld world) {
-        // Switch to find what specific placeholder we want
-        switch (placeholder.toLowerCase(Locale.ENGLISH)) {
-            case "alias" -> {
-                return world.getAliasOrName();
+    private @NotNull Option<String> getWorldPlaceHolderValue(@NotNull String placeholder,
+                                                             @NotNull List<String> placeholderParams,
+                                                             @NotNull MultiverseWorld world) {
+        return Option.of(switch (placeholder) {
+            case "alias" -> world.getAliasOrName();
+            case "animalspawn" -> String.valueOf(world.getEntitySpawnConfig()
+                    .getSpawnCategoryConfig(SpawnCategory.ANIMAL)
+                    .isSpawn());
+            case "autoheal" -> String.valueOf(world.getAutoHeal());
+            case "blacklist" -> String.join(", ", world.getWorldBlacklist());
+            case "currency" -> String.valueOf(world.getCurrency());
+            case "difficulty" -> world.getDifficulty().toString();
+            case "entryfee" -> economist.formatPrice(world.getPrice(), world.getCurrency());
+            case "environment" -> world.getEnvironment().toString().toLowerCase();
+            case "flight" -> String.valueOf(world.isAllowFlight());
+            case "gamemode" -> world.getGameMode().toString().toLowerCase();
+            case "generator" -> world.getGenerator();
+            case "hunger" -> String.valueOf(world.isHunger());
+            case "monstersspawn" -> String.valueOf(world.getEntitySpawnConfig()
+                    .getSpawnCategoryConfig(SpawnCategory.MONSTER)
+                    .isSpawn());
+            case "name" -> world.getName();
+            case "playerlimit" -> String.valueOf(world.getPlayerLimit());
+            case "price" -> String.valueOf(world.getPrice());
+            case "pvp" -> String.valueOf(world.getPvp());
+            case "seed" -> String.valueOf(world.getSeed());
+            case "weather" -> String.valueOf(world.isAllowWeather());
+            case "playercount", "time", "type" -> {
+                warning("Placeholder '" + placeholder + "' is only available for loaded worlds.");
+                yield null;
             }
-            case "animalspawn" -> {
-                return String.valueOf(world.getEntitySpawnConfig().getSpawnCategoryConfig(SpawnCategory.ANIMAL).isSpawn());
-            }
-            case "autoheal" -> {
-                return String.valueOf(world.getAutoHeal());
-            }
-            case "blacklist" -> {
-                return String.join(", ", world.getWorldBlacklist());
-            }
-            case "currency" -> {
-                return String.valueOf(world.getCurrency());
-            }
-            case "difficulty" -> {
-                return world.getDifficulty().toString();
-            }
-            case "entryfee" -> {
-                return economist.formatPrice(world.getPrice(), world.getCurrency());
-            }
-            case "environment" -> {
-                return world.getEnvironment().toString().toLowerCase();
-            }
-            case "flight" -> {
-                return String.valueOf(world.isAllowFlight());
-            }
-            case "gamemode" -> {
-                return world.getGameMode().toString().toLowerCase();
-            }
-            case "generator" -> {
-                return world.getGenerator();
-            }
-            case "hunger" -> {
-                return String.valueOf(world.isHunger());
-            }
-            case "monstersspawn" -> {
-                return String.valueOf(world.getEntitySpawnConfig().getSpawnCategoryConfig(SpawnCategory.MONSTER).isSpawn());
-            }
-            case "name" -> {
-                return world.getName();
-            }
-            case "playercount" -> {
-                return String.valueOf(world.getBukkitWorld()
-                        .map(World::getPlayers)
-                        .map(List::size)
-                        .getOrElse(-1));
-            }
-            case "playerlimit" -> {
-                return String.valueOf(world.getPlayerLimit());
-            }
-            case "price" -> {
-                return String.valueOf(world.getPrice());
-            }
-            case "pvp" -> {
-                return String.valueOf(world.getPvp());
-            }
-            case "seed" -> {
-                return String.valueOf(world.getSeed());
+            default -> {
+                warning("Unknown Placeholder: " + placeholder);
+                yield null;
             }
+        });
+    }
+
+    private @NotNull Option<String> getLoadedWorldPlaceHolderValue(@NotNull String placeholder,
+                                                                   @NotNull List<String> placeholderParams,
+                                                                   @NotNull LoadedMultiverseWorld world) {
+        return Option.of(switch (placeholder) {
+            case "playercount" -> String.valueOf(world.getBukkitWorld()
+                    .map(World::getPlayers)
+                    .map(List::size)
+                    .getOrElse(-1));
             case "time" -> {
                 String timeFormat = !placeholderParams.isEmpty() ? placeholderParams.get(0) : "";
                 long time = world.getBukkitWorld().map(World::getTime).getOrElse(0L);
-                switch (timeFormat) {
-                    case "" -> {
-                        return String.valueOf(time);
-                    }
-                    case "12h" -> {
-                        return MinecraftTimeFormatter.format12h(time);
-                    }
-                    case "24h" -> {
-                        return MinecraftTimeFormatter.format24h(time);
-                    }
-                    default -> {
-                        return MinecraftTimeFormatter.formatTime(time, timeFormat);
-                    }
-                }
+                yield switch (timeFormat) {
+                    case "" -> String.valueOf(time);
+                    case "12h" -> MinecraftTimeFormatter.format12h(time);
+                    case "24h" -> MinecraftTimeFormatter.format24h(time);
+                    default -> MinecraftTimeFormatter.formatTime(time, timeFormat);
+                };
             }
-            case "type" -> {
-                return world.getBukkitWorld().map(World::getWorldType).map(Enum::name).getOrElse("null");
-            }
-            case "weather" -> {
-                return String.valueOf(world.isAllowWeather());
-            }
-            default -> {
-                warning("Unknown placeholder: " + placeholder);
-                return null;
-            }
-        }
+            case "type" -> world.getBukkitWorld().map(World::getWorldType).map(Enum::name).getOrElse("null");
+            default -> null;
+        });
     }
 }

src/main/java/org/mvplugins/multiverse/core/command/MVCommandCompletions.java

@@ -53,7 +53,7 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.generators.GeneratorPlugin;
 import org.mvplugins.multiverse.core.world.generators.GeneratorProvider;
 
-import static org.mvplugins.multiverse.core.utils.StringFormatter.addonToCommaSeperated;
+import static org.mvplugins.multiverse.core.utils.StringFormatter.addOnToCommaSeparated;
 
 @Service
 public class MVCommandCompletions extends PaperCommandCompletions {
@@ -163,7 +163,7 @@ public class MVCommandCompletions extends PaperCommandCompletions {
             }
         }
         if (context.hasConfig("multiple")) {
-            return addonToCommaSeperated(context.getInput(), handler.getCompletions(context));
+            return addOnToCommaSeparated(context.getInput(), handler.getCompletions(context));
         }
         return handler.getCompletions(context);
     }
@@ -334,7 +334,7 @@ public class MVCommandCompletions extends PaperCommandCompletions {
                 matchedPlayers.add(name);
             }
         }
-        return addonToCommaSeperated(context.getInput(), matchedPlayers);
+        return addOnToCommaSeparated(context.getInput(), matchedPlayers);
     }
 
     private Collection<String> suggestSpawnCategoryPropsName(BukkitCommandCompletionContext context) {

src/main/java/org/mvplugins/multiverse/core/commands/CreateCommand.java

@@ -19,7 +19,6 @@ import org.jvnet.hk2.annotations.Service;
 
 import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.CommandValueFlag;
@@ -27,6 +26,7 @@ import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
+import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.utils.result.Attempt.Failure;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
@@ -53,7 +53,7 @@ class CreateCommand extends CoreCommand {
     @CommandPermission("multiverse.core.create")
     @CommandCompletion("@empty @environments @flags:groupName=" + Flags.NAME)
     @Syntax("<name> <environment> [--seed <seed> --generator <generator[:id]> --world-type <worldtype> --adjust-spawn "
-            + "--no-structures --biome <biome>]")
+            + "--no-structures --biome <biome> --properties <prop1=value1,prop2=value2,...>]")
     @Description("{@@mv-core.create.description}")
     void onCreateCommand(
             MVCommandIssuer issuer,
@@ -68,7 +68,7 @@ class CreateCommand extends CoreCommand {
 
             @Optional
             @Syntax("[--seed <seed> --generator <generator[:id]> --world-type <worldtype> --adjust-spawn "
-                    + "--no-structures --biome <biome>]")
+                    + "--no-structures --biome <biome> --properties <prop1=value1,prop2=value2,...>]")
             @Description("{@@mv-core.create.flags.description}")
             String[] flagArray) {
         ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -78,14 +78,15 @@ class CreateCommand extends CoreCommand {
         issuer.sendInfo(MVCorei18n.CREATE_LOADING);
 
         worldManager.createWorld(CreateWorldOptions.worldName(worldName)
-                .biome(parsedFlags.flagValue(flags.biome, ""))
-                .environment(environment)
-                .seed(parsedFlags.flagValue(flags.seed))
-                .worldType(parsedFlags.flagValue(flags.worldType, WorldType.NORMAL))
-                .useSpawnAdjust(!parsedFlags.hasFlag(flags.noAdjustSpawn))
-                .generator(parsedFlags.flagValue(flags.generator, ""))
-                .generatorSettings(parsedFlags.flagValue(flags.generatorSettings, ""))
-                .generateStructures(!parsedFlags.hasFlag(flags.noStructures)))
+                        .biome(parsedFlags.flagValue(flags.biome, ""))
+                        .environment(environment)
+                        .seed(parsedFlags.flagValue(flags.seed))
+                        .worldType(parsedFlags.flagValue(flags.worldType, WorldType.NORMAL))
+                        .useSpawnAdjust(!parsedFlags.hasFlag(flags.noAdjustSpawn))
+                        .generator(parsedFlags.flagValue(flags.generator, ""))
+                        .generatorSettings(parsedFlags.flagValue(flags.generatorSettings, ""))
+                        .generateStructures(!parsedFlags.hasFlag(flags.noStructures))
+                        .worldPropertyStrings(StringFormatter.parseCSVMap(parsedFlags.flagValue(flags.properties))))
                 .onSuccess(newWorld -> messageSuccess(issuer, newWorld))
                 .onFailure(failure -> messageFailure(issuer, failure));
     }
@@ -180,6 +181,10 @@ class CreateCommand extends CoreCommand {
                 .addAlias("-b")
                 .completion(input -> biomeProviderFactory.suggestBiomeString(input))
                 .build());
+
+        private final CommandValueFlag<String> properties = flag(CommandValueFlag.builder("--properties", String.class)
+                .addAlias("-p")
+                .build());
     }
 
     @Service

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

@@ -186,6 +186,16 @@ public final class CoreConfig {
         return configHandle.get(configNodes.enforceFlight);
     }
 
+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setGamemodeAndFlightEnforceDelay(int delayTicks) {
+        return configHandle.set(configNodes.gamemodeAndFlightEnforceDelay, delayTicks);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public int getGamemodeAndFlightEnforceDelay() {
+        return configHandle.get(configNodes.gamemodeAndFlightEnforceDelay);
+    }
+
     @ApiStatus.AvailableSince("5.3")
     public Try<Void> setApplyEntitySpawnRate(boolean applyEntitySpawnRate) {
         return configHandle.set(configNodes.applyEntitySpawnRate, applyEntitySpawnRate);
@@ -493,6 +503,26 @@ public final class CoreConfig {
         return configHandle.get(configNodes.registerPapiHook);
     }
 
+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setWarnInvalidPapiFormat(boolean warnInvalidPapiFormat) {
+        return configHandle.set(configNodes.warnInvalidPapiFormat, warnInvalidPapiFormat);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public boolean getWarnInvalidPapiFormat() {
+        return configHandle.get(configNodes.warnInvalidPapiFormat);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setInvalidPapiFormatReturnsBlank(boolean invalidPapiFormatReturnsBlank) {
+        return configHandle.set(configNodes.invalidPapiFormatReturnsBlank, invalidPapiFormatReturnsBlank);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public  boolean getInvalidPapiFormatReturnsBlank() {
+        return configHandle.get(configNodes.invalidPapiFormatReturnsBlank);
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -621,6 +651,16 @@ public final class CoreConfig {
         return configHandle.get(configNodes.eventPriorityPlayerTeleport);
     }
 
+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setEventPriorityPlayerWorldChange(EventPriority eventPriorityPlayerWorldChange) {
+        return configHandle.set(configNodes.eventPriorityPlayerWorldChange, eventPriorityPlayerWorldChange);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public EventPriority getEventPriorityPlayerWorldChange() {
+        return configHandle.get(configNodes.eventPriorityPlayerWorldChange);
+    }
+
     public Try<Void> setBukkitYmlPath(String bukkitYmlPath) {
         return configHandle.set(configNodes.bukkitYmlPath, bukkitYmlPath);
     }

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

@@ -135,6 +135,16 @@ final class CoreConfigNodes {
             .name("enforce-flight")
             .build());
 
+    final ConfigNode<Integer> gamemodeAndFlightEnforceDelay = node(ConfigNode.builder("world.gamemode-and-flight-enforce-delay", Integer.class)
+            .comment("")
+            .comment("Sets the delay in ticks before Multiverse enforces gamemode and flight ability on world change.")
+            .comment("Increase this value if you are experiencing issues with other plugins overriding gamemode or flight ability.")
+            .comment("Or set to 0 to enforce immediately during world change event.")
+            .defaultValue(1)
+            .name("gamemode-and-flight-enforce-delay")
+            .suggester((sender -> List.of("0", "1", "2", "5", "10")))
+            .build());
+
     final ConfigNode<Boolean> applyEntitySpawnRate = node(ConfigNode.builder("world.apply-entity-spawn-rate", Boolean.class)
             .comment("")
             .comment("Sets whether Multiverse will apply the world's entity `tick-rate` config in worlds.yml.")
@@ -390,6 +400,23 @@ final class CoreConfigNodes {
             .name("register-papi-hook")
             .build());
 
+    final ConfigNode<Boolean> warnInvalidPapiFormat = node(ConfigNode.builder("messaging.warn-invalid-papi-format", Boolean.class)
+            .comment("")
+            .comment("This config option defines whether or not Multiverse should warn about invalid PlaceholderAPI formats.")
+            .comment("Only applies if PlaceholderAPI is installed, and only to multiverse placeholders.")
+            .defaultValue(true)
+            .name("warn-invalid-papi-format")
+            .build());
+
+    final ConfigNode<Boolean> invalidPapiFormatReturnsBlank = node(ConfigNode.builder("messaging.invalid-papi-format-returns-blank", Boolean.class)
+            .comment("")
+            .comment("By default, invalid formats will return the original placeholder string.")
+            .comment("This config option defines whether or not Multiverse should show invalid PlaceholderAPI formats as blank.")
+            .comment("Only applies if PlaceholderAPI is installed, and only to multiverse placeholders.")
+            .defaultValue(false)
+            .name("invalid-papi-format-returns-blank")
+            .build());
+
     final ConfigNode<Locale> defaultLocale = node(ConfigNode.builder("messaging.default-locale", Locale.class)
             .comment("")
             .comment("This config option defines the default language Multiverse should use.")
@@ -528,6 +555,18 @@ final class CoreConfigNodes {
                             "full effect after a server restart."))
             .build());
 
+    final ConfigNode<EventPriority> eventPriorityPlayerWorldChange = node(ConfigNode.builder("event-priority.player-changed-world", EventPriority.class)
+            .defaultValue(EventPriority.NORMAL)
+            .name("event-priority-player-changed-world")
+            .comment("")
+            .comment("This config option defines the priority for the PlayerChangedWorldEvent.")
+            .onLoadAndChange((oldValue, newValue) ->
+                    eventPriorityMapper.get().setPriority("mvcore-player-changed-world", newValue))
+            .onChange((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'event-priority.player-changed-world' config option will only take " +
+                            "full effect after a server restart."))
+            .build());
+
     private final ConfigHeaderNode miscHeader = node(ConfigHeaderNode.builder("misc")
             .comment("")
             .comment("")

src/main/java/org/mvplugins/multiverse/core/config/node/ListConfigNode.java

@@ -120,9 +120,9 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
     private void setDefaultSuggester() {
         if (itemSuggester instanceof SenderNodeSuggester senderItemSuggester) {
             this.suggester = (SenderNodeSuggester)(sender, input) ->
-                    StringFormatter.addonToCommaSeperated(input, senderItemSuggester.suggest(sender, input));
+                    StringFormatter.addOnToCommaSeparated(input, senderItemSuggester.suggest(sender, input));
         } else {
-            this.suggester = input -> StringFormatter.addonToCommaSeperated(input, itemSuggester.suggest(input));
+            this.suggester = input -> StringFormatter.addOnToCommaSeparated(input, itemSuggester.suggest(input));
         }
     }
 

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

@@ -7,9 +7,7 @@
 
 package org.mvplugins.multiverse.core.listeners;
 
-import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
 
 import com.dumptruckman.minecraft.util.Logging;
 import io.vavr.control.Option;
@@ -38,6 +36,7 @@ import org.mvplugins.multiverse.core.destination.DestinationsProvider;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.DefaultEventPriority;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventMethod;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventPriorityKey;
+import org.mvplugins.multiverse.core.dynamiclistener.annotations.IgnoreIfCancelled;
 import org.mvplugins.multiverse.core.economy.MVEconomist;
 import org.mvplugins.multiverse.core.event.MVRespawnEvent;
 import org.mvplugins.multiverse.core.locale.PluginLocales;
@@ -257,9 +256,9 @@ final class MVPlayerListener implements CoreListener {
      * @param event The Event that was fired.
      */
     @EventMethod
-    @DefaultEventPriority(EventPriority.MONITOR)
+    @EventPriorityKey("mvcore-player-changed-world")
+    @DefaultEventPriority(EventPriority.NORMAL)
     void playerChangedWorld(PlayerChangedWorldEvent event) {
-        // Permissions now determine whether or not to handle a gamemode.
         this.handleGameModeAndFlight(event.getPlayer(), event.getPlayer().getWorld());
     }
 
@@ -271,12 +270,28 @@ final class MVPlayerListener implements CoreListener {
     @EventPriorityKey("mvcore-player-teleport")
     @DefaultEventPriority(EventPriority.HIGHEST)
     void playerTeleport(PlayerTeleportEvent event) {
-        Logging.finer("Got teleport event for player '"
-                + event.getPlayer().getName() + "' with cause '" + event.getCause() + "'");
+        Player teleportee = event.getPlayer();
+
         if (event.isCancelled()) {
+            Logging.finer("Teleport event for player '" + teleportee.getName() + "' was already cancelled.");
             return;
         }
-        Player teleportee = event.getPlayer();
+
+        Logging.finer("Got teleport event for player '"
+                + teleportee.getName() + "' with cause '" + event.getCause() + "'");
+
+        Location fromLocation = event.getFrom();
+        if (fromLocation == null || fromLocation.getWorld() == null) { // should never be null, but just in case
+            Logging.finer("Teleport event for player '" + teleportee.getName() + "' has null from-location or world.");
+            return;
+        }
+
+        Location toLocation = event.getTo();
+        if (toLocation == null || toLocation.getWorld() == null) { // may be null on spigot
+            Logging.finer("Teleport event for player '" + teleportee.getName() + "' has null to-location or world.");
+            return;
+        }
+
         Option<String> teleporterName = teleportQueue.popFromQueue(teleportee.getName());
         CommandSender teleporter = teleporterName.map(name -> {
             if (name.equalsIgnoreCase("CONSOLE")) {
@@ -297,17 +312,17 @@ final class MVPlayerListener implements CoreListener {
         }
 
         Logging.finer("Teleporter %s is teleporting %s from %s to %s", teleporter.getName(), teleportee.getName(),
-                event.getFrom(), event.getTo());
+                fromLocation, toLocation);
 
-        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld()).getOrNull();
-        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(event.getTo().getWorld()).getOrNull();
+        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(fromLocation.getWorld()).getOrNull();
+        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(toLocation.getWorld()).getOrNull();
         if (toWorld == null) {
             Logging.fine("Player '" + teleportee.getName() + "' is teleporting to world '"
-                    + event.getTo().getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
+                    + toLocation.getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
                     + "actions will be taken by Multiverse-Core.");
             return;
         }
-        if (event.getFrom().getWorld().equals(event.getTo().getWorld())) {
+        if (fromLocation.getWorld().equals(toLocation.getWorld())) {
             // The player is Teleporting to the same world.
             Logging.finer("Player '" + teleportee.getName() + "' is teleporting to the same world.");
             this.stateSuccess(teleportee.getName(), toWorld.getName());
@@ -341,20 +356,19 @@ final class MVPlayerListener implements CoreListener {
      */
     @EventMethod
     @DefaultEventPriority(EventPriority.LOWEST)
+    @IgnoreIfCancelled
     void playerPortalCheck(PlayerPortalEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-        if (event.getFrom().getWorld() == null) {
+        Location fromLocation = event.getFrom();
+        if (fromLocation == null || fromLocation.getWorld() == null) {
             Logging.warning("PlayerPortalEvent's from world is null!");
             return;
         }
-        if (event.getFrom().getWorld().getBlockAt(event.getFrom()).getType() == Material.NETHER_PORTAL) {
+        if (fromLocation.getWorld().getBlockAt(fromLocation).getType() == Material.NETHER_PORTAL) {
             return;
         }
 
         // Player was actually outside of the portal, adjust the from location
-        Location newLocation = blockSafety.findPortalBlockNextTo(event.getFrom());
+        Location newLocation = blockSafety.findPortalBlockNextTo(fromLocation);
         if (newLocation != null) {
             event.setFrom(newLocation);
         }
@@ -367,28 +381,33 @@ final class MVPlayerListener implements CoreListener {
     @EventMethod
     @EventPriorityKey("mvcore-player-portal")
     @DefaultEventPriority(EventPriority.HIGH)
+    @IgnoreIfCancelled
     void playerPortal(PlayerPortalEvent event) {
-        if (event.isCancelled()) {
+        Location fromLocation = event.getFrom();
+        if (fromLocation == null || fromLocation.getWorld() == null) { // should never be null, but just in case
+            Logging.finer("PlayerPortalEvent's from world is null!");
             return;
         }
-        if (event.getTo() == null || event.getTo().getWorld() == null) {
+
+        Location toLocation = event.getTo();
+        if (toLocation == null || toLocation.getWorld() == null) { // may be null on spigot
             Logging.finer("PlayerPortalEvent's to world is null!");
             return;
         }
         if (config.isUsingCustomPortalSearch()) {
             event.setSearchRadius(config.getCustomPortalSearchRadius());
         }
-        if (Objects.equals(event.getFrom().getWorld(), event.getTo().getWorld())) {
+        if (Objects.equals(fromLocation.getWorld(), toLocation.getWorld())) {
             // The player is Portaling to the same world.
             Logging.finer("Player '" + event.getPlayer().getName() + "' is portaling to the same world.");
             return;
         }
 
-        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld()).getOrNull();
-        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(event.getTo().getWorld()).getOrNull();
+        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(fromLocation.getWorld()).getOrNull();
+        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(toLocation.getWorld()).getOrNull();
         if (toWorld == null) {
             Logging.fine("Player '" + event.getPlayer().getName() + "' is portaling to world '"
-                    + event.getTo().getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
+                    + toLocation.getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
                     + "actions will be taken by Multiverse-Core.");
             return;
         }
@@ -402,21 +421,31 @@ final class MVPlayerListener implements CoreListener {
     }
 
     /**
-     * Handles the gamemode for the specified {@link Player}.
+     * Handles the gamemode for the specified {@link Player}. Delays the enforcement if configured to do so
+     * to ensure multiverse has final say over other plugins changing gamemodes.
      *
      * @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
-        // destination world, otherwise we'd be changing the player mode if they havent moved anywhere.
-        this.server.getScheduler().runTaskLater(this.plugin, () -> {
-            if (!player.isOnline() || !player.getWorld().equals(world)) {
-                return;
-            }
-            Logging.finer("Handling gamemode and flight for player %s in world '%s'", player.getName(), world.getName());
-            enforcementHandler.handleFlightEnforcement(player);
-            enforcementHandler.handleGameModeEnforcement(player);
-        }, 1L);
+        if (config.getGamemodeAndFlightEnforceDelay() <= 0) {
+            doGameModeAndFlightEnforcement(player, world);
+            return;
+        }
+        server.getScheduler().runTaskLater(
+                this.plugin,
+                () -> doGameModeAndFlightEnforcement(player, world),
+                config.getGamemodeAndFlightEnforceDelay()
+        );
+    }
+
+    private void doGameModeAndFlightEnforcement(Player player, World world) {
+        if (!player.isOnline() || !player.getWorld().equals(world)) {
+            Logging.finer("Player %s is no longer online or not in the expected world '%s'", player.getName(), world.getName());
+            return;
+        }
+        Logging.finer("Handling gamemode and flight for player %s in world '%s'", player.getName(), world.getName());
+        enforcementHandler.handleFlightEnforcement(player);
+        enforcementHandler.handleGameModeEnforcement(player);
     }
 }

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

@@ -132,6 +132,10 @@ public final class BlockSafety {
      */
     public boolean canSpawnAtBlockSafely(@NotNull Block block) {
         Logging.finest("Checking spawn safety for location: %s, %s, %s", block.getX(), block.getY(), block.getZ());
+        if (!block.getWorld().getWorldBorder().isInside(block.getLocation())) {
+            Logging.finest("Location is outside world border.");
+            return false;
+        }
         if (isUnsafeSpawnBody(block)) {
             // Player body will be stuck in solid
             Logging.finest("Unsafe location for player's body: " + block);

src/main/java/org/mvplugins/multiverse/core/utils/CaseInsensitiveStringMap.java

@@ -0,0 +1,92 @@
+package org.mvplugins.multiverse.core.utils;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A map with case-insensitive String keys. All keys are stored in lower-case form.
+ *
+ * @param <T> the type of mapped values
+ *
+ * @since 5.5
+ */
+@ApiStatus.AvailableSince("5.5")
+public class CaseInsensitiveStringMap<T> implements Map<String, T> {
+
+    private final Map<String, T> map;
+
+    public CaseInsensitiveStringMap() {
+        map = new HashMap<>();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return map.containsKey(normalizeKey(key));
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return map.containsValue(value);
+    }
+
+    @Override
+    public T get(Object key) {
+        return map.get(normalizeKey(key));
+    }
+
+    @Override
+    public @Nullable T put(String key, T value) {
+        return map.put(normalizeKey(key), value);
+    }
+
+    @Override
+    public T remove(Object key) {
+        return map.remove(normalizeKey(key));
+    }
+
+    @Override
+    public void putAll(@NonNull Map<? extends String, ? extends T> m) {
+        m.forEach((key, value) -> map.put(normalizeKey(key), value));
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+    }
+
+    @Override
+    public @NonNull Set<String> keySet() {
+        return map.keySet();
+    }
+
+    @Override
+    public @NonNull Collection<T> values() {
+        return map.values();
+    }
+
+    @Override
+    public @NonNull Set<Entry<String, T>> entrySet() {
+        return map.entrySet();
+    }
+
+    private String normalizeKey(Object key) {
+        return String.valueOf(key).toLowerCase(Locale.ROOT);
+    }
+}

src/main/java/org/mvplugins/multiverse/core/utils/StringFormatter.java

@@ -2,13 +2,17 @@ package org.mvplugins.multiverse.core.utils;
 
 import com.google.common.base.Strings;
 import com.google.common.collect.Sets;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -30,15 +34,15 @@ public final class StringFormatter {
      * @param list the list of strings to join. If the list is empty, an empty string is returned.
      * @return the concatenated string
      */
-    public static @NotNull String joinAnd(List<String> list) {
+    public static @NotNull String joinAnd(@Nullable List<String> list) {
         return join(list, ", ", " and ");
     }
 
-    public static @NotNull String join(Collection list, String separator) {
+    public static @NotNull String join(@Nullable Collection<?> list, @NotNull String separator) {
         if (list == null || list.isEmpty()) {
             return "";
         }
-        return list.stream().map(String::valueOf).collect(Collectors.joining(separator)).toString();
+        return list.stream().map(String::valueOf).collect(Collectors.joining(separator));
     }
 
     /**
@@ -50,7 +54,7 @@ public final class StringFormatter {
      * @param lastSeparator the separator to use before the last element. For example, " and ".
      * @return the concatenated string
      */
-    public static @NotNull String join(List<String> list, String separator, String lastSeparator) {
+    public static @NotNull String join(@Nullable List<String> list, @NotNull String separator, @NotNull String lastSeparator) {
         if (list == null || list.isEmpty()) {
             return "";
         }
@@ -71,11 +75,30 @@ public final class StringFormatter {
 
     /**
      * Appends a list of suggestions to the end of the input string, separated by commas.
+     *
      * @param input     The current input
      * @param addons    The autocomplete suggestions
      * @return A collection of suggestions with the next suggestion appended
+     *
+     * @deprecated Method name has a spelling error. Use {@link #addOnToCommaSeparated(String, Collection)} instead.
      */
+    @Deprecated(forRemoval = true, since = "5.5")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
     public static Collection<String> addonToCommaSeperated(@Nullable String input, @NotNull Collection<String> addons) {
+        return addOnToCommaSeparated(input, addons);
+    }
+
+    /**
+     * Appends a list of suggestions to the end of the input string, separated by commas.
+     *
+     * @param input     The current input
+     * @param addons    The autocomplete suggestions
+     * @return A collection of suggestions with the next suggestion appended
+     *
+     * @since 5.5
+     */
+    @ApiStatus.AvailableSince("5.5")
+    public static Collection<String> addOnToCommaSeparated(@Nullable String input, @NotNull Collection<String> addons) {
         if (Strings.isNullOrEmpty(input)) {
             return addons;
         }
@@ -94,7 +117,7 @@ public final class StringFormatter {
      * @param args  The args to parse
      * @return The parsed args
      */
-    public static Collection<String> parseQuotesInArgs(String[] args) {
+    public static @NotNull Collection<String> parseQuotesInArgs(@NotNull String[] args) {
         List<String> result = new ArrayList<>(args.length);
         StringBuilder current = new StringBuilder();
         boolean inQuotes = false;
@@ -139,7 +162,28 @@ public final class StringFormatter {
      * @param input The string to add quotes to
      * @return The quoted string
      */
-    public static String quoteMultiWordString(String input) {
-        return input.contains(" ") ? "\"" + input + "\"" : input;
+    @Contract("null -> null")
+    public static @Nullable String quoteMultiWordString(@Nullable String input) {
+        return input != null && input.contains(" ") ? "\"" + input + "\"" : input;
+    }
+
+    /**
+     * Parses a CSV string of key=value pairs into a map.
+     * E.g. "key1=value1,key2=value2" -> {key1=value1, key2=value2}
+     *
+     * @param input The CSV string to parse
+     * @return The parsed map
+     *
+     * @since 5.5
+     */
+    @ApiStatus.AvailableSince("5.5")
+    public static @Unmodifiable Map<String, String> parseCSVMap(@Nullable String input) {
+        if (Strings.isNullOrEmpty(input)) {
+            return Map.of();
+        }
+        return REPatterns.COMMA.splitAsStream(input)
+                .map(s -> REPatterns.EQUALS.split(s, 2))
+                .filter(parts -> parts.length == 2)
+                .collect(Collectors.toUnmodifiableMap(parts -> parts[0], parts -> parts[1]));
     }
 }

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

@@ -3,6 +3,7 @@ package org.mvplugins.multiverse.core.world;
 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;
@@ -10,6 +11,7 @@ import org.bukkit.GameMode;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.World;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -66,7 +68,8 @@ public sealed class MultiverseWorld permits LoadedMultiverseWorld {
     }
 
     /**
-     * Gets whether this world is loaded.
+     * Gets whether this world is loaded. Note that this may return false even if this is a stored instance of
+     * {@link LoadedMultiverseWorld} as worlds can be unloaded anytime.
      *
      * @return True if the world is loaded, else false.
      */
@@ -74,6 +77,23 @@ public sealed class MultiverseWorld permits LoadedMultiverseWorld {
         return worldConfig.isLoadedWorld();
     }
 
+    /**
+     * Attempts to get loaded world instance. Only returns a value if the world is loaded at the time of calling, even
+     * if this is a stored instance of {@link LoadedMultiverseWorld}.
+     * <br/>
+     * You may use {@link #isLoaded()} to check if the world is loaded first.
+     *
+     * @return Loaded world instance wrapped in an Option, or None if the world is not loaded.
+     *
+     * @since 5.5
+     */
+    @ApiStatus.AvailableSince("5.5")
+    public Option<LoadedMultiverseWorld> asLoadedWorld() {
+        return Option.of(worldConfig.getMVWorld())
+                .filter(world -> world instanceof LoadedMultiverseWorld)
+                .map(world -> (LoadedMultiverseWorld) world);
+    }
+
     /**
      * Gets the properties handler of this world.
      *

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

@@ -381,6 +381,10 @@ final class WorldConfig {
         configNodes.setWorld(world);
     }
 
+    MultiverseWorld getMVWorld() {
+        return configNodes.getWorld();
+    }
+
     boolean isLoadedWorld() {
         return configNodes.getWorld() instanceof LoadedMultiverseWorld;
     }

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

@@ -6,9 +6,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicReference;
@@ -48,6 +46,7 @@ import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.permissions.CorePermissions;
 import org.mvplugins.multiverse.core.teleportation.BlockSafety;
 import org.mvplugins.multiverse.core.teleportation.LocationManipulation;
+import org.mvplugins.multiverse.core.utils.CaseInsensitiveStringMap;
 import org.mvplugins.multiverse.core.utils.ReflectHelper;
 import org.mvplugins.multiverse.core.utils.ServerProperties;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
@@ -91,8 +90,8 @@ public final class WorldManager {
     private static final DimensionFormat DEFAULT_NETHER_FORMAT = new DimensionFormat("%overworld%_nether");
     private static final DimensionFormat DEFAULT_END_FORMAT = new DimensionFormat("%overworld%_the_end");
 
-    private final Map<String, MultiverseWorld> worldsMap;
-    private final Map<String, LoadedMultiverseWorld> loadedWorldsMap;
+    private final CaseInsensitiveStringMap<MultiverseWorld> worldsMap;
+    private final CaseInsensitiveStringMap<LoadedMultiverseWorld> loadedWorldsMap;
     private final List<String> unloadTracker;
     private final List<String> loadTracker;
     private final WorldsConfigManager worldsConfigManager;
@@ -135,8 +134,8 @@ public final class WorldManager {
         this.config = config;
         this.entityPurger = entityPurger;
 
-        this.worldsMap = new HashMap<>();
-        this.loadedWorldsMap = new HashMap<>();
+        this.worldsMap = new CaseInsensitiveStringMap<>();
+        this.loadedWorldsMap = new CaseInsensitiveStringMap<>();
         this.unloadTracker = new ArrayList<>();
         this.loadTracker = new ArrayList<>();
     }
@@ -277,7 +276,16 @@ public final class WorldManager {
                             generatorString,
                             options.biome(),
                             options.useSpawnAdjust()))
-                .peek(loadedWorld -> pluginManager.callEvent(new MVWorldCreatedEvent(loadedWorld)));
+                .peek(loadedWorld -> postCreateWorld(loadedWorld, options));
+    }
+
+    private void postCreateWorld(LoadedMultiverseWorld loadedWorld, CreateWorldOptions options) {
+        options.worldPropertyStrings().forEach((key, value) -> loadedWorld.getStringPropertyHandle()
+                .setPropertyString(key, value)
+                .onFailure(failure -> Logging.warning("Failed to set property '%s' to '%s' for world %s: %s",
+                        key, value, loadedWorld.getName(), failure.getMessage())));
+        pluginManager.callEvent(new MVWorldCreatedEvent(loadedWorld));
+        saveWorldsConfig();
     }
 
     /**
@@ -345,7 +353,7 @@ public final class WorldManager {
 
     private MultiverseWorld newMultiverseWorld(String worldName, WorldConfig worldConfig) {
         MultiverseWorld mvWorld = new MultiverseWorld(worldName, worldConfig, config);
-        worldsMap.put(mvWorld.getName().toLowerCase(Locale.ENGLISH), mvWorld);
+        worldsMap.put(mvWorld.getName(), mvWorld);
         corePermissions.addWorldPermissions(mvWorld);
         return mvWorld;
     }
@@ -382,7 +390,7 @@ public final class WorldManager {
                 locationManipulation,
                 entityPurger
         );
-        loadedWorldsMap.put(loadedWorld.getName().toLowerCase(Locale.ENGLISH), loadedWorld);
+        loadedWorldsMap.put(loadedWorld.getName(), loadedWorld);
         saveWorldsConfig();
         pluginManager.callEvent(new MVWorldLoadedEvent(loadedWorld));
         return loadedWorld;
@@ -501,7 +509,7 @@ public final class WorldManager {
                 locationManipulation,
                 entityPurger
         );
-        loadedWorldsMap.put(loadedWorld.getName().toLowerCase(Locale.ENGLISH), loadedWorld);
+        loadedWorldsMap.put(loadedWorld.getName(), loadedWorld);
         saveWorldsConfig();
         pluginManager.callEvent(new MVWorldLoadedEvent(loadedWorld));
         return Attempt.success(loadedWorld);
@@ -1010,7 +1018,7 @@ public final class WorldManager {
      * @return True if the world is a world is known to multiverse, but may or may not be loaded.
      */
     public boolean isWorld(@Nullable String worldName) {
-        return worldName != null && worldsMap.containsKey(worldName.toLowerCase(Locale.ENGLISH));
+        return worldName != null && worldsMap.containsKey(worldName);
     }
 
     /**
@@ -1022,7 +1030,7 @@ public final class WorldManager {
     public Option<MultiverseWorld> getUnloadedWorld(@Nullable String worldName) {
         return isLoadedWorld(worldName)
                 ? Option.none()
-                : Option.of(worldName).flatMap(name -> Option.of(worldsMap.get(name.toLowerCase(Locale.ENGLISH))));
+                : Option.of(worldName).flatMap(name -> Option.of(worldsMap.get(name)));
     }
 
     /**
@@ -1095,7 +1103,7 @@ public final class WorldManager {
      */
     public Option<LoadedMultiverseWorld> getLoadedWorld(@Nullable String worldName) {
         return Option.of(worldName)
-                .flatMap(name -> Option.of(loadedWorldsMap.get(name.toLowerCase(Locale.ENGLISH))));
+                .flatMap(name -> Option.of(loadedWorldsMap.get(name)));
     }
 
     /**
@@ -1156,7 +1164,7 @@ public final class WorldManager {
      * @return True if the world is a multiverse world that is loaded.
      */
     public boolean isLoadedWorld(@Nullable String worldName) {
-        return worldName != null && loadedWorldsMap.containsKey(worldName.toLowerCase(Locale.ENGLISH));
+        return worldName != null && loadedWorldsMap.containsKey(worldName);
     }
 
     /**

src/main/java/org/mvplugins/multiverse/core/world/options/CreateWorldOptions.java

@@ -3,8 +3,14 @@ package org.mvplugins.multiverse.core.world.options;
 import co.aikar.commands.ACFUtil;
 import org.bukkit.World;
 import org.bukkit.WorldType;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * Options for customizing the creation of a new world.
@@ -31,6 +37,7 @@ public final class CreateWorldOptions {
     private boolean useSpawnAdjust = true;
     private WorldType worldType = WorldType.NORMAL;
     private boolean doFolderCheck = true;
+    private final Map<String, String> worldPropertyStrings = new HashMap<>();
 
     /**
      * Creates a new {@link CreateWorldOptions} instance with the given world name.
@@ -260,4 +267,46 @@ public final class CreateWorldOptions {
     public boolean doFolderCheck() {
         return doFolderCheck;
     }
+
+    /**
+     * Sets a world property string key-value pair. Overwrites any existing key.
+     *
+     * @param key   The key of the world property string.
+     * @param value The value of the world property string.
+     * @return This {@link CreateWorldOptions} instance.
+     *
+     * @since 5.5
+     */
+    @ApiStatus.AvailableSince("5.5")
+    public @NotNull CreateWorldOptions worldPropertyString(@NotNull String key, @Nullable String value) {
+        this.worldPropertyStrings.put(key, value);
+        return this;
+    }
+
+    /**
+     * Sets multiple world property string key-value pairs. Overwrites any existing keys.
+     *
+     * @param worldProperties   A map of world property string key-value pairs.
+     * @return This {@link CreateWorldOptions} instance.
+     *
+     * @since 5.5
+     */
+    @ApiStatus.AvailableSince("5.5")
+    public @NotNull CreateWorldOptions worldPropertyStrings(@NotNull Map<@NotNull String, @Nullable String> worldProperties) {
+        this.worldPropertyStrings.putAll(worldProperties);
+        return this;
+    }
+
+    /**
+     * Gets an unmodifiable view of the world property strings. Use {@link #worldPropertyString(String, String)} and
+     * {@link #worldPropertyStrings(Map)} to modify the world property strings.
+     *
+     * @return An unmodifiable view of the world property strings.
+     *
+     * @since 5.5
+     */
+    @ApiStatus.AvailableSince("5.5")
+    public @UnmodifiableView @NotNull Map<String, String> worldPropertyStrings() {
+        return Collections.unmodifiableMap(worldPropertyStrings);
+    }
 }

src/test/java/org/mvplugins/multiverse/core/utils/StringFormatterTest.kt

@@ -2,6 +2,7 @@ package org.mvplugins.multiverse.core.utils
 
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNull
 
 class StringFormatterTest {
     @Test
@@ -42,5 +43,22 @@ class StringFormatterTest {
             "test",
             StringFormatter.quoteMultiWordString("test")
         )
+        assertNull(StringFormatter.quoteMultiWordString(null))
+    }
+
+    @Test
+    fun `StringFormatter parseCSVMap`() {
+        assertEquals(
+            emptyMap<String, String>(),
+            StringFormatter.parseCSVMap("")
+        )
+        assertEquals(
+            mapOf("key" to "value"),
+            StringFormatter.parseCSVMap("key=value")
+        )
+        assertEquals(
+            mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3"),
+            StringFormatter.parseCSVMap("key1=value1,key2=value2,key3=value3")
+        )
     }
 }

src/test/java/org/mvplugins/multiverse/core/world/WorldManagerTest.kt

@@ -36,8 +36,8 @@ class WorldManagerTest : TestWithMockBukkit() {
         world = worldManager.getLoadedWorld("world").get()
         assertNotNull(world)
 
-        assertTrue(worldManager.createWorld(CreateWorldOptions.worldName("world2")).isSuccess)
-        world2 = worldManager.getLoadedWorld("world2").get()
+        assertTrue(worldManager.createWorld(CreateWorldOptions.worldName("World2")).isSuccess)
+        world2 = worldManager.getLoadedWorld("World2").get()
         assertNotNull(world2)
     }
 
@@ -122,6 +122,11 @@ class WorldManagerTest : TestWithMockBukkit() {
         assertFalse(worldManager.getLoadedWorld("world").isDefined)
         assertFalse(worldManager.getUnloadedWorld("world").isDefined)
 
+        assertTrue(worldManager.removeWorld(RemoveWorldOptions.world(world2)).isSuccess)
+        assertFalse(worldManager.getWorld("World2").isDefined)
+        assertFalse(worldManager.getLoadedWorld("World2").isDefined)
+        assertFalse(worldManager.getUnloadedWorld("World2").isDefined)
+
         assertThat(server.pluginManager, hasFiredEventInstance(MVWorldUnloadedEvent::class.java))
         assertThat(server.pluginManager, hasFiredEventInstance(MVWorldRemovedEvent::class.java))
     }
@@ -130,9 +135,18 @@ class WorldManagerTest : TestWithMockBukkit() {
     fun `Delete world`() {
         assertTrue(File(Bukkit.getWorldContainer(), "world").isDirectory)
         assertTrue(worldManager.deleteWorld(DeleteWorldOptions.world(world)).isSuccess)
+        assertFalse(worldManager.getWorld("world").isDefined)
         assertFalse(worldManager.getLoadedWorld("world").isDefined)
+        assertFalse(worldManager.getUnloadedWorld("world").isDefined)
         assertFalse(File(Bukkit.getWorldContainer(), "world").isDirectory)
 
+        assertTrue(File(Bukkit.getWorldContainer(), "World2").isDirectory)
+        assertTrue(worldManager.deleteWorld(DeleteWorldOptions.world(world2)).isSuccess)
+        assertFalse(worldManager.getWorld("World2").isDefined)
+        assertFalse(worldManager.getLoadedWorld("World2").isDefined)
+        assertFalse(worldManager.getUnloadedWorld("World2").isDefined)
+        assertFalse(File(Bukkit.getWorldContainer(), "World2").isDirectory)
+
         assertThat(server.pluginManager, hasFiredEventInstance(MVWorldDeleteEvent::class.java))
         assertThat(server.pluginManager, hasFiredEventInstance(MVWorldUnloadedEvent::class.java))
         assertThat(server.pluginManager, hasFiredEventInstance(MVWorldRemovedEvent::class.java))
@@ -143,21 +157,21 @@ class WorldManagerTest : TestWithMockBukkit() {
         assertTrue(worldManager.unloadWorld(UnloadWorldOptions.world(world2).saveBukkitWorld(true)).isSuccess)
         assertFalse(world2.isLoaded)
         assertFalse(world2.bukkitWorld.isDefined)
-        assertFalse(worldManager.getLoadedWorld("world2").isDefined)
-        assertTrue(worldManager.getWorld("world2").isDefined)
-        assertTrue(worldManager.getUnloadedWorld("world2").isDefined)
+        assertFalse(worldManager.getLoadedWorld("World2").isDefined)
+        assertTrue(worldManager.getWorld("World2").isDefined)
+        assertTrue(worldManager.getUnloadedWorld("World2").isDefined)
 
         assertTrue(worldManager.loadWorld(LoadWorldOptions.world(world2)).isSuccess)
         assertTrue(world2.isLoaded)
-        assertTrue(worldManager.getLoadedWorld("world2").flatMap{ w -> w.bukkitWorld }.isDefined)
-        assertTrue(worldManager.getLoadedWorld("world2").isDefined)
-        assertFalse(worldManager.getUnloadedWorld("world2").isDefined)
+        assertTrue(worldManager.getLoadedWorld("World2").flatMap{ w -> w.bukkitWorld }.isDefined)
+        assertTrue(worldManager.getLoadedWorld("World2").isDefined)
+        assertFalse(worldManager.getUnloadedWorld("World2").isDefined)
     }
 
     @Test
     fun `Load world failed - invalid world folder`() {
         assertTrue(worldManager.unloadWorld(UnloadWorldOptions.world(world2)).isSuccess)
-        File(Bukkit.getWorldContainer(), "world2/").deleteRecursively()
+        File(Bukkit.getWorldContainer(), "World2/").deleteRecursively()
         assertEquals(
             LoadFailureReason.WORLD_FOLDER_INVALID,
             worldManager.loadWorld(LoadWorldOptions.world(world2)).failureReason
@@ -190,7 +204,7 @@ class WorldManagerTest : TestWithMockBukkit() {
             .seed(4321L)
         ).isSuccess)
 
-        val getWorld = worldManager.getLoadedWorld("world2")
+        val getWorld = worldManager.getLoadedWorld("World2")
         assertTrue(getWorld.isDefined)
         val world = getWorld.get()
         assertNotNull(world)
@@ -230,7 +244,7 @@ class WorldManagerTest : TestWithMockBukkit() {
     fun `Clone world failed - target world exists and loaded`() {
         assertEquals(
             CloneFailureReason.WORLD_EXIST_LOADED,
-            worldManager.cloneWorld(CloneWorldOptions.fromTo(world, "world2")).failureReason
+            worldManager.cloneWorld(CloneWorldOptions.fromTo(world, "World2")).failureReason
         )
     }
 
@@ -239,7 +253,7 @@ class WorldManagerTest : TestWithMockBukkit() {
         assertTrue(worldManager.unloadWorld(UnloadWorldOptions.world(world2)).isSuccess)
         assertEquals(
             CloneFailureReason.WORLD_EXIST_UNLOADED,
-            worldManager.cloneWorld(CloneWorldOptions.fromTo(world, "world2")).failureReason
+            worldManager.cloneWorld(CloneWorldOptions.fromTo(world, "World2")).failureReason
         )
     }
 

src/test/resources/configs/fresh_config.yml

@@ -4,6 +4,7 @@ world:
   enforce-access: false
   enforce-gamemode: true
   enforce-flight: true
+  gamemode-and-flight-enforce-delay: 1
   apply-entity-spawn-rate: true
   apply-entity-spawn-limit: true
   auto-purge-entities: false
@@ -36,6 +37,8 @@ messaging:
   enable-chat-prefix: false
   chat-prefix-format: '[%world%]%chat%'
   register-papi-hook: true
+  warn-invalid-papi-format: true
+  invalid-papi-format-returns-blank: false
   default-locale: en
   per-player-locale: true
 
@@ -52,6 +55,7 @@ event-priority:
   player-respawn: low
   player-spawn-location: normal
   player-teleport: highest
+  player-changed-world: normal
 
 misc:
   bukkit-yml-path: bukkit.yml