Merge pull request #3440 from Multiverse/fix/26.1-folders-lowercased

Fix world folder being lowercased due to namespace changes in 26.1

.github/workflows/generic.platform_uploads.yml

@@ -107,7 +107,7 @@ jobs:
         files: '["${{ github.workspace }}/${{ inputs.plugin_name }}-${{ steps.release-info.outputs.tag_name }}.jar"]'
         name: ${{ steps.release-info.outputs.tag_name }}
         changelog: ${{ steps.release-artifact.outputs.body }}
-        game_versions: 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
+        game_versions: 26.1.1, 26.1, 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
         version_type: ${{ steps.parse-release-type.outputs.release_type }}
         loaders: bukkit, spigot, paper, purpur
         dependencies: ${{ inputs.modrinth_dependencies }}
@@ -121,7 +121,7 @@ jobs:
         changelog: ${{ steps.release-artifact.outputs.body }}
         changelog_type: markdown
         display_name: ${{ steps.release-info.outputs.tag_name }}
-        game_versions: 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
+        game_versions: 26.1.1, 26.1, 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
         release_type: ${{ steps.parse-release-type.outputs.release_type }}
         project_relations: ${{ inputs.dbo_project_relations }}
         file_path: ${{ github.workspace }}/${{ inputs.plugin_name }}-${{ steps.release-info.outputs.tag_name }}.jar
@@ -136,5 +136,5 @@ jobs:
         channel: ${{ steps.parse-release-type.outputs.release_type }}
         files: '[{"path": "${{ github.workspace }}/${{ inputs.plugin_name }}-${{ steps.release-info.outputs.tag_name }}.jar", "platforms": ["PAPER"]}]'
         description: ${{ steps.release-artifact.outputs.body }}
-        platform_dependencies: '{"PAPER": ["1.18.2-1.21.11"]}'
+        platform_dependencies: '{"PAPER": ["1.18.2-26.1.1"]}'
         plugin_dependencies: ${{ inputs.hangar_plugin_dependencies }}

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();
     }
 
@@ -225,11 +226,12 @@ public class MultiverseCore extends MultiverseModule {
      * Logs the enable message.
      */
     private void logEnableMessage() {
-        Logging.config("\u001B[32mVersion %s (API v%s) Enabled - By %s\u001B[39m",
+        Logging.config("\u001B[32mVersion %s (API v%s) Enabled - By %s\u001B[0m",
                 this.getDescription().getVersion(), getVersionAsNumber(), StringFormatter.joinAnd(getDescription().getAuthors()));
 
         if (configProvider.get().isShowingDonateMessage()) {
-            Logging.config("\u001B[32mLoving Multiverse-Core? Please consider supporting the project with a small donation: https://github.com/sponsors/Multiverse\u001B[39m");
+            Logging.config("\u001B[32mLoving Multiverse-Core? Please consider supporting the project with a " +
+                    "small donation: https://github.com/sponsors/Multiverse\u001B[0m");
         }
     }
 

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,136 +95,102 @@ 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;
+                return Option.none();
             }
         }
 
         // 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 "isloaded" -> String.valueOf(world.isLoaded());
+            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/CloneCommand.java

@@ -20,7 +20,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.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.options.CloneWorldOptions;
 
@@ -48,7 +48,7 @@ class CloneCommand extends CoreCommand {
 
             @Syntax("<world>")
             @Description("{@@mv-core.clone.world.description}")
-            LoadedMultiverseWorld world,
+            MultiverseWorld world,
 
             @Syntax("<new-world-name>")
             @Description("{@@mv-core.clone.newWorld.description}")
@@ -114,7 +114,7 @@ class CloneCommand extends CoreCommand {
 
         @Override
         @CommandAlias("mvcl|mvclone")
-        void onCloneCommand(MVCommandIssuer issuer, LoadedMultiverseWorld world, String newWorldName, String[] flags) {
+        void onCloneCommand(MVCommandIssuer issuer, MultiverseWorld world, String newWorldName, String[] flags) {
             super.onCloneCommand(issuer, world, newWorldName, flags);
         }
     }

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/commands/LoadCommand.java

@@ -16,8 +16,8 @@ import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
+import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
-import org.mvplugins.multiverse.core.command.flags.RemovePlayerFlags;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
@@ -38,7 +38,7 @@ class LoadCommand extends CoreCommand {
 
     @Subcommand("load")
     @CommandPermission("multiverse.core.load")
-    @CommandCompletion("@mvworlds:scope=unloaded")
+    @CommandCompletion("@mvworlds:scope=unloaded @flags:groupName=" + Flags.NAME)
     @Syntax("<world>")
     @Description("{@@mv-core.load.description}")
     void onLoadCommand(
@@ -49,7 +49,7 @@ class LoadCommand extends CoreCommand {
             MultiverseWorld world,
 
             @Optional
-            @Syntax("[--remove-players]")
+            @Syntax("[--skip-folder-check]")
             @Description("")
             String[] flagArray) {
         ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -67,9 +67,9 @@ class LoadCommand extends CoreCommand {
     }
 
     @Service
-    private static final class Flags extends RemovePlayerFlags {
+    private static final class Flags extends FlagBuilder {
 
-        private static final String NAME = "mvunload";
+        private static final String NAME = "mvload";
 
         @Inject
         private Flags(@NotNull CommandFlagsManager flagsManager) {

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.")
@@ -210,7 +220,10 @@ final class CoreConfigNodes {
 
     final ConfigNode<PassengerModes> passengerMode = node(ConfigNode.builder("teleport.passenger-mode", PassengerModes.class)
             .comment("")
-            .comment("Configures how passengers and vehicles are handled when an entity is teleported.")
+            .comment("Configures how passengers and vehicles are handled when an entity is teleported. This config is")
+            .comment("only applied to /mvtp, join-destination and first-spawn-override. It will not touch any other")
+            .comment("teleport by other plugins or commands.")
+            .comment("========= Available options: =========")
             .comment("  default: Server will handle passengers and vehicles. On papermc 1.21.10+, all will be retained by default.")
             .comment("                                                       On older versions, all will be dismounted if world changes.")
             .comment("  dismount_passengers: Passengers will be removed from the parent entity before the teleport.")
@@ -390,6 +403,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 +558,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/event/world/MVWorldClonedEvent.java

@@ -1,8 +1,11 @@
 package org.mvplugins.multiverse.core.event.world;
 
 import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 
 /**
  * Called when a world has been successfully cloned.
@@ -10,14 +13,24 @@ import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 public final class MVWorldClonedEvent extends MultiverseWorldEvent<LoadedMultiverseWorld> {
     private static final HandlerList HANDLERS = new HandlerList();
 
-    private final LoadedMultiverseWorld fromWorld;
+    private final MultiverseWorld fromWorld;
 
-    public MVWorldClonedEvent(LoadedMultiverseWorld world, LoadedMultiverseWorld fromWorld) {
+    public MVWorldClonedEvent(LoadedMultiverseWorld world, MultiverseWorld fromWorld) {
         super(world);
         this.fromWorld = fromWorld;
     }
 
-    public LoadedMultiverseWorld getFromWorld() {
+    /**
+     * @deprecated Cloning can be done from unloaded worlds as well. Use {@link #getSourceWorld()} instead.
+     */
+    @Deprecated(forRemoval = true, since = "5.6")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
+    public @Nullable LoadedMultiverseWorld getFromWorld() {
+        return fromWorld.asLoadedWorld().getOrNull();
+    }
+
+    @ApiStatus.AvailableSince("5.6")
+    public @NotNull MultiverseWorld getSourceWorld() {
         return fromWorld;
     }
 
@@ -37,5 +50,4 @@ public final class MVWorldClonedEvent extends MultiverseWorldEvent<LoadedMultive
     public static HandlerList getHandlerList() {
         return HANDLERS;
     }
-
 }

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;
@@ -245,7 +244,7 @@ final class MVPlayerListener implements CoreListener {
     }
 
     private void teleportToDestinationOnJoin(Player player, DestinationInstance<?, ?> destination) {
-        asyncSafetyTeleporter.to(destination).teleportSingle(player)
+        asyncSafetyTeleporter.to(destination).passengerMode(config.getPassengerMode()).teleportSingle(player)
                 .onSuccess(result -> Logging.fine("Player %s has been teleported on join",
                         player.getName()))
                 .onFailure(failure -> Logging.warning("Failed to teleport player %s on join: %s",
@@ -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/locale/MVCorei18n.java

@@ -292,6 +292,7 @@ public enum MVCorei18n implements MessageKeyProvider {
     CLONEWORLD_WORLDEXISTFOLDER,
     CLONEWORLD_WORLDEXISTUNLOADED,
     CLONEWORLD_WORLDEXISTLOADED,
+    CLONEWORLD_FROMWORLDFOLDERINVALID,
     CLONEWORLD_COPYFAILED,
 
     CREATEWORLD_INVALIDWORLDNAME,

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/FileUtils.java

@@ -18,6 +18,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import com.dumptruckman.minecraft.util.Logging;
@@ -25,6 +26,7 @@ import io.vavr.control.Try;
 import jakarta.inject.Inject;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.NonNull;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.config.CoreConfig;
 
@@ -210,16 +212,19 @@ public final class FileUtils {
 
         private final Path sourceDir;
         private final Path targetDir;
-        private final List<String> excludeFiles;
+        private final List<Path> excludeFiles;
 
         private CopyDirFileVisitor(@NotNull Path sourceDir, @NotNull Path targetDir, @NotNull List<String> excludeFiles) {
             this.sourceDir = sourceDir;
             this.targetDir = targetDir;
-            this.excludeFiles = excludeFiles;
+            this.excludeFiles = excludeFiles.stream()
+                    .map(sourceDir::resolve)
+                    .toList();
+            Logging.finest(this.excludeFiles.stream().map(Path::toString).collect(Collectors.joining(", ", "Exclude files: [", "]")));
         }
 
         @Override
-        public @NotNull FileVisitResult preVisitDirectory(Path dir, @NotNull BasicFileAttributes attrs) throws IOException {
+        public @NotNull FileVisitResult preVisitDirectory(@NonNull Path dir, @NotNull BasicFileAttributes attrs) throws IOException {
             Path newDir = targetDir.resolve(sourceDir.relativize(dir));
             if (!Files.isDirectory(newDir)) {
                 Files.createDirectory(newDir);
@@ -228,10 +233,10 @@ public final class FileUtils {
         }
 
         @Override
-        public @NotNull FileVisitResult visitFile(Path file, @NotNull BasicFileAttributes attrs) throws IOException {
+        public @NotNull FileVisitResult visitFile(@NonNull Path file, @NotNull BasicFileAttributes attrs) throws IOException {
             // Pass files that are set to ignore
-            if (excludeFiles.contains(file.getFileName().toString())) {
-                Logging.finest("Ignoring file: " + file.getFileName());
+            if (excludeFiles.contains(file)) {
+                Logging.finest("Ignoring file: " + file);
                 return FileVisitResult.CONTINUE;
             }
             // Copy the files

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/utils/compatibility/BukkitCompatibility.java

@@ -0,0 +1,91 @@
+package org.mvplugins.multiverse.core.utils.compatibility;
+
+import io.vavr.control.Option;
+import org.bukkit.Bukkit;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.mvplugins.multiverse.core.utils.ReflectHelper;
+
+import java.lang.reflect.Method;
+import java.nio.file.Path;
+
+/**
+ * Compatibility class used to handle API changes in {@link Bukkit} class.
+ *
+ * @since 5.6
+ */
+@ApiStatus.AvailableSince("5.6")
+public final class BukkitCompatibility {
+
+    private static final Option<Method> GET_LEVEL_DIRECTORY_METHOD;
+    private static final Option<Method> GET_WORLD_NAMESPACED_KEY_METHOD;
+
+    static {
+        GET_LEVEL_DIRECTORY_METHOD = Option.of(ReflectHelper.getMethod(Server.class, "getLevelDirectory"));
+        GET_WORLD_NAMESPACED_KEY_METHOD = Option.of(ReflectHelper.getMethod(Bukkit.class, "getWorld", NamespacedKey.class));
+    }
+
+    /**
+     * Check whether the server is using the new dimension storage system introduced in PaperMC 26.1.
+     * <br />
+     * This is based of whether getLevelDirectory method exists in the server class,which is the main API change for
+     * the new dimension storage system.
+     *
+     * @return True if the server is using the new dimension storage system, else false.
+     *
+     * @since 5.6
+     */
+    @ApiStatus.AvailableSince("5.6")
+    public static boolean isUsingNewDimensionStorage() {
+        return GET_LEVEL_DIRECTORY_METHOD
+                .flatMap(method -> Option.of(ReflectHelper.invokeMethod(Bukkit.getServer(), method)))
+                .isDefined();
+    }
+
+    /**
+     * Gets the folder where all the worlds will be store. Before 26.1, all worlds are stored in the root directory
+     * of the server, which can be obtained by {@link Server#getWorldContainer()}.
+     * <br />
+     * After 26.1, PaperMC changed all worlds are stored in the "[level]/dimensions/minecraft" folder under the world
+     * level directory, which needs to be manually parsed.
+     *
+     * @return The location where all the worlds folders should be, depending on server's mc version.
+     *
+     * @since 5.6
+     */
+    @ApiStatus.AvailableSince("5.6")
+    @NotNull
+    public static Path getWorldFoldersDirectory() {
+        Server server = Bukkit.getServer();
+        return GET_LEVEL_DIRECTORY_METHOD.map(method -> ReflectHelper.invokeMethod(server, method))
+                .filter(Path.class::isInstance)
+                .map(Path.class::cast)
+                .map(path -> path.resolve("dimensions/minecraft"))
+                .getOrElse(() -> server.getWorldContainer().toPath());
+    }
+
+    /**
+     * Check if the world with the given name or namespaced key (e.g. minecraft:overworld) exists,
+     * and return it if it does.
+     * <br />
+     * Note that some default world names have different namespaced key matched with them.
+     * E.g.: world -> minecraft:overworld, world_nether -> minecraft:the_nether, world_the_end -> minecraft:the_end.
+     *
+     * @param nameOrKey Either a name or namespaced key string representation.
+     * @return The world if it exists
+     *
+     * @since 5.6
+     */
+    @ApiStatus.AvailableSince("5.6")
+    @NotNull
+    public static Option<World> getWorldByNameOrKey(@NotNull String nameOrKey) {
+        return Option.of(Bukkit.getWorld(nameOrKey))
+                .orElse(() -> GET_WORLD_NAMESPACED_KEY_METHOD
+                        .map(method -> ReflectHelper.invokeMethod(null, method, NamespacedKey.fromString(nameOrKey)))
+                        .filter(World.class::isInstance)
+                        .map(World.class::cast));
+    }
+}

src/main/java/org/mvplugins/multiverse/core/utils/compatibility/package-info.java

@@ -0,0 +1,5 @@
+/**
+ * Contains classes to handle compatibility due to differing API methods across different server versions and the
+ * API gaps between PaperMC and Spigot.
+ */
+package org.mvplugins.multiverse.core.utils.compatibility;

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;
     }
@@ -392,7 +396,7 @@ final class WorldConfig {
     /**
      * Migrates the entry fee settings. Assumes entry fee is disabled if currency is not set.
      */
-    static final class EntryFeeMigrator implements MigratorAction {
+    private static final class EntryFeeMigrator implements MigratorAction {
         @Override
         public void migrate(ConfigurationSection config) {
             String currency = config.getString("entry-fee.currency", "");

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;
@@ -22,8 +20,10 @@ import io.vavr.control.Option;
 import io.vavr.control.Try;
 import jakarta.inject.Inject;
 import org.bukkit.Bukkit;
+import org.bukkit.GameRule;
 import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.WorldBorder;
 import org.bukkit.WorldCreator;
 import org.bukkit.WorldType;
 import org.bukkit.plugin.PluginManager;
@@ -48,8 +48,10 @@ 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.compatibility.BukkitCompatibility;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
 import org.mvplugins.multiverse.core.utils.result.FailureReason;
 import org.mvplugins.multiverse.core.utils.FileUtils;
@@ -87,12 +89,16 @@ import static org.mvplugins.multiverse.core.world.helpers.DataStore.WorldConfigS
 @Service // SUPPRESS CHECKSTYLE: ClassFanOutComplexity This is the world manager, it's going to be complex.
 public final class WorldManager {
 
-    private static final List<String> CLONE_IGNORE_FILES = Arrays.asList("uid.dat", "session.lock");
+    private static final List<String> CLONE_IGNORE_FILES = List.of(
+            "uid.dat", "session.lock", // All pre 26.1 format
+            "data/paper/metadata.dat"  // New papermc format for 26.1+
+    );
+
     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 +141,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 +283,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();
     }
 
     /**
@@ -302,8 +317,17 @@ public final class WorldManager {
         String worldName = options.worldName();
         if (!worldNameChecker.isValidWorldName(worldName)) {
             return worldActionResult(ImportFailureReason.INVALID_WORLDNAME, worldName);
-        } else if (options.doFolderCheck() && !worldNameChecker.isValidWorldFolder(worldName)) {
-            return worldActionResult(ImportFailureReason.WORLD_FOLDER_INVALID, worldName);
+        } else if (options.doFolderCheck()) {
+            //todo This is a duplicate of folder check in load world
+            WorldNameChecker.FolderStatus folderStatus = worldNameChecker.checkFolder(options.worldName());
+            if (!folderStatus.isLoadable()) {
+                return worldActionResult(ImportFailureReason.WORLD_FOLDER_INVALID, options.worldName());
+            }
+            if (folderStatus == WorldNameChecker.FolderStatus.REQUIRES_MIGRATION) {
+                Logging.info("World '%s' will be automatically migrated by PaperMC to the new dimension " +
+                                "location. If you face any issue with migration, please contact PaperMC support!",
+                        options.worldName());
+            }
         }
         return worldActionResult(options);
     }
@@ -345,7 +369,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 +406,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;
@@ -465,8 +489,16 @@ public final class WorldManager {
             return doLoadBukkitWorld(bukkitWorld, mvWorld);
         }
 
-        if (options.doFolderCheck() && !worldNameChecker.isValidWorldFolder(mvWorld.getName())) {
-            return worldActionResult(LoadFailureReason.WORLD_FOLDER_INVALID, mvWorld.getName());
+        if (options.doFolderCheck()) {
+            WorldNameChecker.FolderStatus folderStatus = worldNameChecker.checkFolder(mvWorld.getName());
+            if (!folderStatus.isLoadable()) {
+                return worldActionResult(LoadFailureReason.WORLD_FOLDER_INVALID, mvWorld.getName());
+            }
+            if (folderStatus == WorldNameChecker.FolderStatus.REQUIRES_MIGRATION) {
+                Logging.info("World '%s' will be automatically migrated by PaperMC to the new dimension " +
+                        "location. If you face any issue with migration, please contact PaperMC support!",
+                        mvWorld.getName());
+            }
         }
 
         WorldCreator worldCreator = WorldCreator.name(mvWorld.getName())
@@ -501,7 +533,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);
@@ -691,6 +723,7 @@ public final class WorldManager {
     private Attempt<File, DeleteFailureReason> validateWorldToDelete(
             @NotNull LoadedMultiverseWorld world) {
         return world.getBukkitWorld().map(World::getWorldFolder)
+                .peek(folder -> Logging.finer("World folder for world %s is at: %s", world.getName(), folder.getPath()))
                 .filter(worldNameChecker::isValidWorldFolder)
                 .map(this::<File, DeleteFailureReason>worldActionResult)
                 .getOrElse(() -> {
@@ -711,18 +744,19 @@ public final class WorldManager {
                 .mapAttempt(validatedOptions -> {
                     ImportWorldOptions importWorldOptions = ImportWorldOptions
                             .worldName(validatedOptions.newWorldName())
-                            .biome(validatedOptions.world().getBiome())
-                            .environment(validatedOptions.world().getEnvironment())
-                            .generator(validatedOptions.world().getGenerator());
+                            .biome(validatedOptions.fromWorld().getBiome())
+                            .environment(validatedOptions.fromWorld().getEnvironment())
+                            .generator(validatedOptions.fromWorld().getGenerator());
                     return importWorld(importWorldOptions).transform(CloneFailureReason.IMPORT_FAILED);
                 })
                 .onSuccess(newWorld -> {
                     cloneWorldTransferData(options, newWorld);
                     if (options.keepWorldConfig()) {
-                        newWorld.setSpawnLocation(options.world().getSpawnLocation());
+                        // Special case for spawn location as it's considered a hidden config
+                        newWorld.setSpawnLocation(options.fromWorld().getSpawnLocation());
                     }
                     saveWorldsConfig();
-                    pluginManager.callEvent(new MVWorldClonedEvent(newWorld, options.world()));
+                    pluginManager.callEvent(new MVWorldClonedEvent(newWorld, options.fromWorld()));
                 });
     }
 
@@ -744,19 +778,24 @@ public final class WorldManager {
         if (worldNameChecker.hasWorldFolder(newWorldName)) {
             return worldActionResult(CloneFailureReason.WORLD_EXIST_FOLDER, newWorldName);
         }
+        if (!worldNameChecker.isValidWorldFolder(options.fromWorld().getName())) {
+            return worldActionResult(CloneFailureReason.FROM_WORLD_FOLDER_INVALID, options.fromWorld().getName());
+        }
         return worldActionResult(options);
     }
 
     private Attempt<CloneWorldOptions, CloneFailureReason> cloneWorldCopyFolder(@NotNull CloneWorldOptions options) {
         if (options.saveBukkitWorld()) {
-            Logging.finer("Saving bukkit world before cloning: " + options.world().getName());
-            options.world().getBukkitWorld().peek(this::saveWorldWithFlush);
+            options.fromWorld().asLoadedWorld().peek(loadedWorld -> {
+                Logging.finer("Saving world before cloning: " + loadedWorld.getName());
+                loadedWorld.getBukkitWorld().peek(this::saveWorldWithFlush);
+            });
         }
-        File worldFolder = options.world().getBukkitWorld().map(World::getWorldFolder).get();
-        File newWorldFolder = new File(Bukkit.getWorldContainer(), options.newWorldName());
+        File worldFolder = BukkitCompatibility.getWorldFoldersDirectory().resolve(options.fromWorld().getName()).toFile();
+        File newWorldFolder = BukkitCompatibility.getWorldFoldersDirectory().resolve(options.newWorldName()).toFile();
         return fileUtils.copyFolder(worldFolder, newWorldFolder, CLONE_IGNORE_FILES).fold(
                 exception -> worldActionResult(CloneFailureReason.COPY_FAILED,
-                        options.world().getName(), exception),
+                        options.fromWorld().getName(), exception),
                 success -> worldActionResult(options));
     }
 
@@ -772,25 +811,30 @@ public final class WorldManager {
     }
 
     private void cloneWorldTransferData(@NotNull CloneWorldOptions options, @NotNull LoadedMultiverseWorld newWorld) {
-        DataTransfer<LoadedMultiverseWorld> dataTransfer = transferData(options, options.world());
-        dataTransfer.pasteAllTo(newWorld);
-    }
-
-    private DataTransfer<LoadedMultiverseWorld> transferData(
-            @NotNull KeepWorldSettingsOptions options, @NotNull LoadedMultiverseWorld world) {
-        DataTransfer<LoadedMultiverseWorld> dataTransfer = new DataTransfer<>();
-
         if (options.keepWorldConfig()) {
-            dataTransfer.addDataStore(new WorldConfigStore(), world);
-        }
-        if (options.keepGameRule()) {
-            dataTransfer.addDataStore(new GameRulesStore(), world);
-        }
-        if (options.keepWorldBorder()) {
-            dataTransfer.addDataStore(new WorldBorderStore(), world);
+            new DataTransfer<MultiverseWorld>()
+                    .addDataStore(new WorldConfigStore<>(), options.fromWorld())
+                    .pasteAllTo(newWorld);
         }
 
-        return dataTransfer;
+        newWorld.getBukkitWorld().peek(bukkitWorld -> {
+            if (!options.keepWorldBorder()) {
+                WorldBorder worldBorder = bukkitWorld.getWorldBorder();
+                worldBorder.reset();
+            }
+
+            if (!options.keepGameRule()) {
+                Arrays.stream(bukkitWorld.getGameRules())
+                        .map(gameRuleName -> GameRule.getByName(gameRuleName))
+                        .filter(Objects::nonNull)
+                        .forEach(gameRule -> {
+                            Object gameRuleDefault = bukkitWorld.getGameRuleDefault(gameRule);
+                            if (gameRuleDefault != null) {
+                                bukkitWorld.setGameRule(gameRule, gameRuleDefault);
+                            }
+                        });
+            }
+        });
     }
 
     /**
@@ -801,11 +845,12 @@ public final class WorldManager {
      */
     public Attempt<LoadedMultiverseWorld, RegenFailureReason> regenWorld(@NotNull RegenWorldOptions options) {
         LoadedMultiverseWorld world = options.world();
-        DataTransfer<LoadedMultiverseWorld> dataTransfer = transferData(options, world);
+        DataTransfer<LoadedMultiverseWorld> dataTransfer = regenWorldTransferData(options, world);
         boolean shouldKeepSpawnLocation = options.keepWorldConfig() && options.seed() == world.getSeed();
         Location spawnLocation = world.getSpawnLocation();
 
         CreateWorldOptions createWorldOptions = CreateWorldOptions.worldName(world.getName())
+                .biome(world.getBiome())
                 .environment(world.getEnvironment())
                 .generateStructures(world.canGenerateStructures().getOrElse(true))
                 .generator(world.getGenerator())
@@ -829,6 +874,23 @@ public final class WorldManager {
                 });
     }
 
+    private DataTransfer<LoadedMultiverseWorld> regenWorldTransferData(
+            @NotNull KeepWorldSettingsOptions options, @NotNull LoadedMultiverseWorld world) {
+        DataTransfer<LoadedMultiverseWorld> dataTransfer = new DataTransfer<>();
+
+        if (options.keepWorldConfig()) {
+            dataTransfer.addDataStore(new WorldConfigStore<>(), world);
+        }
+        if (options.keepGameRule()) {
+            dataTransfer.addDataStore(new GameRulesStore(), world);
+        }
+        if (options.keepWorldBorder()) {
+            dataTransfer.addDataStore(new WorldBorderStore(), world);
+        }
+
+        return dataTransfer;
+    }
+
     private <T, F extends FailureReason> Attempt<T, F> worldActionResult(@NotNull T value) {
         return Attempt.success(value);
     }
@@ -938,12 +1000,12 @@ public final class WorldManager {
      * @return A list of all potential worlds.
      */
     public List<String> getPotentialWorlds() {
-        File[] files = Bukkit.getWorldContainer().listFiles();
+        File[] files = BukkitCompatibility.getWorldFoldersDirectory().toFile().listFiles();
         if (files == null) {
             return Collections.emptyList();
         }
         return Arrays.stream(files)
-                .filter(file -> !isWorld(file.getName()))
+                .filter(file -> BukkitCompatibility.getWorldByNameOrKey(file.getName()).isEmpty())
                 .filter(worldNameChecker::isValidWorldFolder)
                 .map(File::getName)
                 .toList();
@@ -1010,7 +1072,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 +1084,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 +1157,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 +1218,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/helpers/DataStore.java

@@ -10,6 +10,7 @@ import org.bukkit.World;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.config.handle.StringPropertyHandle;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 
 /**
  * A data store for storing and restoring data from an object.
@@ -90,14 +91,14 @@ public interface DataStore<T> {
     /**
      * A {@link DataStore} for storing and restoring world properties for a multiverse world.
      */
-    class WorldConfigStore implements DataStore<LoadedMultiverseWorld> {
+    class WorldConfigStore<T extends MultiverseWorld> implements DataStore<T> {
         private Map<String, Object> configMap;
 
         /**
          * {@inheritDoc}
          */
         @Override
-        public WorldConfigStore copyFrom(LoadedMultiverseWorld world) {
+        public WorldConfigStore<T> copyFrom(T world) {
             this.configMap = new HashMap<>();
             StringPropertyHandle worldPropertyHandler = world.getStringPropertyHandle();
             worldPropertyHandler.getAllPropertyNames().forEach(name -> worldPropertyHandler.getProperty(name)
@@ -111,7 +112,7 @@ public interface DataStore<T> {
          * {@inheritDoc}
          */
         @Override
-        public WorldConfigStore pasteTo(LoadedMultiverseWorld world) {
+        public WorldConfigStore<T> pasteTo(T world) {
             if (configMap == null) {
                 return this;
             }

src/main/java/org/mvplugins/multiverse/core/world/helpers/WorldNameChecker.java

@@ -1,15 +1,18 @@
 package org.mvplugins.multiverse.core.world.helpers;
 
 import java.io.File;
+import java.util.List;
 import java.util.Locale;
 import java.util.Set;
 
 import io.vavr.control.Option;
 import org.bukkit.Bukkit;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.utils.REPatterns;
+import org.mvplugins.multiverse.core.utils.compatibility.BukkitCompatibility;
 
 /**
  * <p>Utility class in helping to check the status of a world name and it's associated world folder.</p>
@@ -29,6 +32,18 @@ public final class WorldNameChecker {
             "plugins",
             "versions");
 
+    private static final List<WorldFolderSchema> WORLD_FOLDER_SCHEMA = List.of(
+            // OLD
+            WorldFolderSchema.file("level.dat"),
+            WorldFolderSchema.folder("DIM1"),
+            WorldFolderSchema.folder("DIM-1"),
+            // NEW
+            WorldFolderSchema.file("paper-world.yml"),
+            WorldFolderSchema.folder("data"),
+            WorldFolderSchema.folder("entities"),
+            WorldFolderSchema.folder("poi"),
+            WorldFolderSchema.folder("region"));
+
     /**
      * Checks if a world name is valid.
      *
@@ -81,7 +96,7 @@ public final class WorldNameChecker {
      * @return True if check result is valid, else false.
      */
     public boolean isValidWorldFolder(@Nullable String worldName) {
-        return checkFolder(worldName) == FolderStatus.VALID;
+        return checkFolder(worldName).loadable;
     }
 
     /**
@@ -91,7 +106,7 @@ public final class WorldNameChecker {
      * @return True if check result is valid, else false.
      */
     public boolean isValidWorldFolder(@Nullable File worldFolder) {
-        return checkFolder(worldFolder) == FolderStatus.VALID;
+        return checkFolder(worldFolder).loadable;
     }
 
     /**
@@ -105,7 +120,16 @@ public final class WorldNameChecker {
         if (worldName == null) {
             return FolderStatus.DOES_NOT_EXIST;
         }
-        File worldFolder = new File(Bukkit.getWorldContainer(), worldName);
+
+        if (BukkitCompatibility.isUsingNewDimensionStorage()) {
+            File oldWorldFolder = Bukkit.getWorldContainer().toPath().resolve(worldName).toFile();
+            if (checkFolder(oldWorldFolder) == FolderStatus.VALID) {
+                return FolderStatus.REQUIRES_MIGRATION;
+            }
+            worldName = worldName.toLowerCase(Locale.ENGLISH); // namespace is case-insensitive and stored as lowercase
+        }
+
+        File worldFolder = BukkitCompatibility.getWorldFoldersDirectory().resolve(worldName).toFile();
         return checkFolder(worldFolder);
     }
 
@@ -120,7 +144,7 @@ public final class WorldNameChecker {
         if (worldFolder == null || !worldFolder.exists() || !worldFolder.isDirectory()) {
             return FolderStatus.DOES_NOT_EXIST;
         }
-        if (!folderHasDat(worldFolder)) {
+        if (!folderWorldSchemaCheck(worldFolder)) {
             return FolderStatus.NOT_A_WORLD;
         }
         return FolderStatus.VALID;
@@ -133,9 +157,54 @@ public final class WorldNameChecker {
      * @param worldFolder   The File that may be a world.
      * @return True if it looks like a world, else false.
      */
-    private boolean folderHasDat(@NotNull File worldFolder) {
-        File[] files = worldFolder.listFiles((file, name) -> name.toLowerCase(Locale.ENGLISH).endsWith(".dat"));
-        return files != null && files.length > 0;
+    private boolean folderWorldSchemaCheck(@NotNull File worldFolder) {
+        return WORLD_FOLDER_SCHEMA.stream()
+                .filter(schema -> schema.check(worldFolder))
+                .count() >= 2;
+    }
+
+    /**
+     * Helper class to check if a file or folder exist.
+     */
+    private interface WorldFolderSchema {
+
+        static WorldFolderSchema file(String path) {
+            return new WorldFile(path);
+        }
+
+        static WorldFolderSchema folder(String path) {
+            return new WorldFolder(path);
+        }
+
+        boolean check(File worldFolder);
+
+        final class WorldFile implements WorldFolderSchema {
+            private final String path;
+
+            private WorldFile(String path) {
+                this.path = path;
+            }
+
+            @Override
+            public boolean check(File worldFolder) {
+                File thisFolder = worldFolder.toPath().resolve(path).toFile();
+                return thisFolder.exists() && thisFolder.isFile();
+            }
+        }
+
+        final class WorldFolder implements WorldFolderSchema {
+            private final String path;
+
+            private WorldFolder(String path) {
+                this.path = path;
+            }
+
+            @Override
+            public boolean check(File worldFolder) {
+                File thisFolder = worldFolder.toPath().resolve(path).toFile();
+                return thisFolder.exists() && thisFolder.isDirectory();
+            }
+        }
     }
 
     /**
@@ -170,16 +239,39 @@ public final class WorldNameChecker {
         /**
          * Folder is valid.
          */
-        VALID,
+        VALID(true),
+
+        /**
+         * This folder will cause PaperMC to migrate to new dimension world folder in 26.1+
+         */
+        REQUIRES_MIGRATION(true),
 
         /**
          * Folder exist, but contents in it doesnt look like a world.
          */
-        NOT_A_WORLD,
+        NOT_A_WORLD(false),
 
         /**
          * Folder does not exist.
          */
-        DOES_NOT_EXIST
+        DOES_NOT_EXIST(false),
+        ;
+
+        private final boolean loadable;
+
+        FolderStatus(boolean loadable) {
+            this.loadable = loadable;
+        }
+
+        /**
+         * Whether this folder status is loadable, meaning it has the basic world data and can be loaded as a world.
+         * Note that this does not guarantee the server will definitely load the world with no errors.
+         *
+         * @return True if folder probably is loadable by the server, else false.
+         */
+        @ApiStatus.AvailableSince("5.6")
+        public boolean isLoadable() {
+            return loadable;
+        }
     }
 }

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

@@ -1,7 +1,9 @@
 package org.mvplugins.multiverse.core.world.options;
 
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 
 /**
  * Options for customizing the cloning of a world.
@@ -9,17 +11,35 @@ import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 public final class CloneWorldOptions implements KeepWorldSettingsOptions {
 
     /**
-     * Creates a new {@link CloneWorldOptions} instance with the given world.
+     * Creates a new {@link CloneWorldOptions} instance with the given loaded world.
      *
-     * @param world         The world to clone.
+     * @param fromWorld     The loaded world to clone.
      * @param newWorldName  The name of the new world.
      * @return A new {@link CloneWorldOptions} instance.
+     *
+     * @deprecated Cloning can be done from unloaded worlds as well. Use {@link #fromTo(MultiverseWorld, String)} instead.
      */
-    public static CloneWorldOptions fromTo(LoadedMultiverseWorld world, String newWorldName) {
-        return new CloneWorldOptions(world, newWorldName);
+    @Deprecated(forRemoval = true, since = "5.6")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
+    public static @NotNull CloneWorldOptions fromTo(@NotNull LoadedMultiverseWorld fromWorld, @NotNull String newWorldName) {
+        return new CloneWorldOptions(fromWorld, newWorldName);
     }
 
-    private final LoadedMultiverseWorld world;
+    /**
+     * Creates a new {@link CloneWorldOptions} instance with the given world.
+     *
+     * @param fromWorld     The world to clone.
+     * @param newWorldName  The name of the new world.
+     * @return A new {@link CloneWorldOptions} instance.
+     *
+     * @since 5.6
+     */
+    @ApiStatus.AvailableSince("5.6")
+    public static @NotNull CloneWorldOptions fromTo(@NotNull MultiverseWorld fromWorld, @NotNull String newWorldName) {
+        return new CloneWorldOptions(fromWorld, newWorldName);
+    }
+
+    private final MultiverseWorld fromWorld;
     private final String newWorldName;
     private boolean keepGameRule = true;
     private boolean keepWorldConfig = true;
@@ -27,18 +47,34 @@ public final class CloneWorldOptions implements KeepWorldSettingsOptions {
 
     private boolean keepWorldBorder = true;
 
-    CloneWorldOptions(LoadedMultiverseWorld world, String newWorldName) {
-        this.world = world;
+    CloneWorldOptions(MultiverseWorld fromWorld, String newWorldName) {
+        this.fromWorld = fromWorld;
         this.newWorldName = newWorldName;
     }
 
     /**
-     * Gets the world to clone.
+     * Gets the loaded world to clone.
      *
      * @return The world to clone.
+     *
+     * @deprecated Cloning can be done from unloaded worlds as well. Use {@link #fromWorld()} instead.
      */
+    @Deprecated(forRemoval = true, since = "5.6")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
     public LoadedMultiverseWorld world() {
-        return world;
+        return fromWorld.asLoadedWorld().getOrNull();
+    }
+
+    /**
+     * Gets the loaded world to clone.
+     *
+     * @return The world to clone.
+     *
+     * @since 5.6
+     */
+    @ApiStatus.AvailableSince("5.6")
+    public @NotNull MultiverseWorld fromWorld() {
+        return fromWorld;
     }
 
     /**
@@ -46,7 +82,7 @@ public final class CloneWorldOptions implements KeepWorldSettingsOptions {
      *
      * @return The name of the new world.
      */
-    public String newWorldName() {
+    public @NotNull String newWorldName() {
         return newWorldName;
     }
 

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/main/java/org/mvplugins/multiverse/core/world/reasons/CloneFailureReason.java

@@ -3,6 +3,7 @@ package org.mvplugins.multiverse.core.world.reasons;
 import co.aikar.locales.MessageKey;
 import co.aikar.locales.MessageKeyProvider;
 
+import org.jetbrains.annotations.ApiStatus;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.utils.result.FailureReason;
 
@@ -30,6 +31,14 @@ public enum CloneFailureReason implements FailureReason {
      */
     WORLD_EXIST_LOADED(MVCorei18n.CLONEWORLD_WORLDEXISTLOADED),
 
+    /**
+     * The source world folder is invalid.
+     *
+     * @since 5.6
+     */
+    @ApiStatus.AvailableSince("5.6")
+    FROM_WORLD_FOLDER_INVALID(MVCorei18n.CLONEWORLD_FROMWORLDFOLDERINVALID),
+
     /**
      * Failed to copy the world folder contents.
      */

src/main/resources/multiverse-core_en.properties

@@ -273,6 +273,7 @@ mv-core.cloneworld.invalidworldname=World '{world}' contains invalid characters!
 mv-core.cloneworld.worldexistfolder=World '{world}' exists in server folders! You need to delete it first before cloning.
 mv-core.cloneworld.worldexistunloaded=World '{world}' already exists and it's unloaded! You need to delete it first before cloning.
 mv-core.cloneworld.worldexistloaded=World '{world}' already exists! You need to delete it first before cloning.
+mv-core.cloneworld.fromworldfolderinvalid=Source world '{world}' folder contents does not seem to be a valid world! Make sure it contains the correct world structure of data and region folders.
 mv-core.cloneworld.copyfailed=Failed to copy world to '{world}': {error}\n&fSee console for more details.
 
 mv-core.createworld.invalidworldname=World '{world}' contains invalid characters!
@@ -288,7 +289,7 @@ mv-core.deleteworld.failedtodeletefolder=Failed to delete world folder '{world}'
 mv-core.importworld.invalidworldname=World '{world}' contains invalid characters!
 mv-core.importworld.worldexistunloaded=World '{world}' already exists, but it's not loaded!&f Type '&a/mv load {world}&f' if you wish to load it.
 mv-core.importworld.worldexistloaded=World '{world}' already exists!
-mv-core.importworld.worldfolderinvalid=World '{world}' folder contents does not seem to be a valid world!\n&cIf the server software does something different with world folders, or you are very certain the world is valid, use '&3--skip-folder-check&c' flag.
+mv-core.importworld.worldfolderinvalid=World '{world}' folder contents does not seem to be a valid world! Make sure it contains the correct world structure of data and region folders.\n&cIf the server software does something different with world folders, or you are very certain the world is valid, use '&3--skip-folder-check&c' flag.
 mv-core.importworld.bukkitenvironmentmismatch=Environment mismatch detected!&f The world '{world}' is already loaded with environment '{bukkitEnvironment}', but Multiverse is trying to import it with environment '{mvEnvironment}'.
 
 mv-core.loadworld.worldalreadyloading=World '{world}' is already loading! Please wait...

src/test/java/org/mvplugins/multiverse/core/mock/MVServerMock.java

@@ -39,6 +39,8 @@ public class MVServerMock extends ServerMock {
         world.getWorldFolder().mkdirs();
         createFile(new File(world.getWorldFolder(), "uid.dat"));
         createFile(new File(world.getWorldFolder(), "level.dat"));
+        new File(world.getWorldFolder(), "region").mkdir();
+        new File(world.getWorldFolder(), "data").mkdir();
         addWorld(world);
         return world;
     }

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

@@ -7,7 +7,15 @@ import org.hamcrest.MatcherAssert.assertThat
 import org.mockbukkit.mockbukkit.matcher.plugin.PluginManagerFiredEventClassMatcher.hasFiredEventInstance
 import org.mockbukkit.mockbukkit.matcher.plugin.PluginManagerFiredEventClassMatcher.hasNotFiredEventInstance
 import org.mvplugins.multiverse.core.TestWithMockBukkit
-import org.mvplugins.multiverse.core.event.world.*
+import org.mvplugins.multiverse.core.event.world.MVWorldClonedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldCreatedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldDeleteEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldImportedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldLoadedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldPropertyChangedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldRegeneratedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldRemovedEvent
+import org.mvplugins.multiverse.core.event.world.MVWorldUnloadedEvent
 import org.mvplugins.multiverse.core.world.options.CloneWorldOptions
 import org.mvplugins.multiverse.core.world.options.CreateWorldOptions
 import org.mvplugins.multiverse.core.world.options.DeleteWorldOptions
@@ -36,8 +44,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 +130,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 +143,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 +165,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
@@ -176,6 +198,8 @@ class WorldManagerTest : TestWithMockBukkit() {
     fun `Load world failed - world folder exists but not imported`() {
         File(Bukkit.getWorldContainer(), "worldfolder").mkdir()
         File(Bukkit.getWorldContainer(), "worldfolder/level.dat").createNewFile()
+        File(Bukkit.getWorldContainer(), "worldfolder/data").mkdir()
+        File(Bukkit.getWorldContainer(), "worldfolder/region").mkdir()
         assertEquals(
             LoadFailureReason.WORLD_EXIST_FOLDER,
             worldManager.loadWorld("worldfolder").failureReason
@@ -190,7 +214,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 +254,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 +263,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
         )
     }
 
@@ -256,8 +280,10 @@ class WorldManagerTest : TestWithMockBukkit() {
     fun `Get potential worlds`() {
         File(Bukkit.getWorldContainer(), "newworld1").mkdir()
         File(Bukkit.getWorldContainer(), "newworld1/level.dat").createNewFile()
+        File(Bukkit.getWorldContainer(), "newworld1/data").mkdir()
         File(Bukkit.getWorldContainer(), "newworld2").mkdir()
         File(Bukkit.getWorldContainer(), "newworld2/level.dat").createNewFile()
+        File(Bukkit.getWorldContainer(), "newworld2/data").mkdir()
         assertEquals(setOf("newworld1", "newworld2"), worldManager.getPotentialWorlds().toSet())
     }
 

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

@@ -45,6 +45,15 @@ class WorldNameCheckerTest : TestWithMockBukkit() {
     fun `Valid world folder`() {
         File(Bukkit.getWorldContainer(), "test").mkdir()
         File(Bukkit.getWorldContainer(), "test/level.dat").createNewFile()
+        File(Bukkit.getWorldContainer(), "test/data").mkdir()
+        assertEquals(WorldNameChecker.FolderStatus.VALID, worldNameChecker.checkFolder("test"))
+    }
+
+    @Test
+    fun `Valid world folder v26-1 format`() {
+        File(Bukkit.getWorldContainer(), "test").mkdir()
+        File(Bukkit.getWorldContainer(), "test/region").mkdir()
+        File(Bukkit.getWorldContainer(), "test/data").mkdir()
         assertEquals(WorldNameChecker.FolderStatus.VALID, worldNameChecker.checkFolder("test"))
     }
 

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