Package org.spongepowered.api.world.server

Interface WorldManager

  • public interface WorldManager

    • Method Detail

      • server

        Server server()
        Gets the Server.
        Returns:
        The server

      • worldDirectory

        java.util.Optional<java.nio.file.Path> worldDirectory​(ResourceKey key)
        Gets a directory that exists for the provided world key.

        It is not required for the implementation to validate that the directory contains a proper world, only that the directory exists.

        Parameters:
        key - The key
        Returns:
        The directory or Optional.empty() if not found

      • defaultWorld

        @Deprecated
ServerWorld defaultWorld()
        Deprecated.
        Use world(ResourceKey) with DefaultWorldKeys.DEFAULT instead
        Gets the default world.

        If the default world isn't loaded, an IllegalStateException will be thrown as this means the manager is not loaded yet.

        It is up to the implementation to define what the default world actually is.

        Returns:
        The default world

      • worlds

        java.util.Collection<ServerWorld> worlds()
        Gets all currently loaded worlds.
        Returns:
        The worlds

      • worldKeys

        java.util.List<ResourceKey> worldKeys()
        Gets the keys of both online and offline worlds.

        It is up to the implementation to determine how offline keys are provided to the developer.

        Returns:
        The keys

      • templateKeys

        java.util.List<ResourceKey> templateKeys()
        Gets the keys of templates.

        It is up to the implementation to determine how template keys are provided to the developer.

        Returns:
        The keys

      • offlineWorldKeys

        default java.util.List<ResourceKey> offlineWorldKeys()
        Gets the keys of offline worlds.

        It is up to the implementation to determine how offline keys are provided to the developer.

        Returns:
        The keys

      • worldExists

        boolean worldExists​(ResourceKey key)
        Gets if a key exists as an actual world, offline or online.
        Parameters:
        key - The key
        Returns:
        True if existed, false if not

      • worldKey

        java.util.Optional<ResourceKey> worldKey​(java.util.UUID uniqueId)
        Gets a key by unique id.
        Parameters:
        uniqueId - The unique id
        Returns:
        The key or Optional.empty() if not found

      • worldsOfType

        java.util.Collection<ServerWorld> worldsOfType​(WorldType type)
        Retrieves all worlds that are of a particular type.
        Parameters:
        type - The type
        Returns:
        The worlds

      • loadWorld

        java.util.concurrent.CompletableFuture<ServerWorld> loadWorld​(WorldTemplate template)
        Loads a world from a template.

        If a world is already loaded by the key of the template, the world will be returned instead.

        Parameters:
        template - The template
        Returns:
        The world

      • loadWorld

        java.util.concurrent.CompletableFuture<ServerWorld> loadWorld​(ResourceKey key)
        Loads a world by a key.

        If a world with the given name is already loaded then it is returned instead.

        Parameters:
        key - The key
        Returns:
        The world

      • unloadWorld

        java.util.concurrent.CompletableFuture<java.lang.Boolean> unloadWorld​(ResourceKey key)
        Unloads a world by a key.

        The default Minecraft world cannot be unloaded. Additional conditions for how and when a world may be unloaded are left up to the implementation to define.

        Parameters:
        key - The key to unload
        Returns:
        Whether the operation was successful

      • unloadWorld

        java.util.concurrent.CompletableFuture<java.lang.Boolean> unloadWorld​(ServerWorld world)
        Unloads a world.

        The default Minecraft world cannot be unloaded. Additional conditions for how and when a world may be unloaded are left up to the implementation to define.

        Parameters:
        world - The world to unload
        Returns:
        Whether the operation was successful

      • templateExists

        boolean templateExists​(ResourceKey key)
        Gets if a key exists as a template.
        Parameters:
        key - The key
        Returns:
        True if it exists, false if not

      • loadTemplate

        java.util.concurrent.CompletableFuture<java.util.Optional<WorldTemplate>> loadTemplate​(ResourceKey key)
        Gets a template by a key.
        Parameters:
        key - The key
        Returns:
        The template or Optional.empty() if not found

      • saveTemplate

        java.util.concurrent.CompletableFuture<java.lang.Boolean> saveTemplate​(WorldTemplate template)
        Saves a template.

        It is left up to the implementation on how exactly templates are saved, if at all.

        Parameters:
        template - The template
        Returns:
        Whether the operation was successful

      • loadProperties

        java.util.concurrent.CompletableFuture<java.util.Optional<ServerWorldProperties>> loadProperties​(ResourceKey key)
        Loads an offline properties.

        It is left up to the implementation on what conditions cause a failure of loading properties.

        Parameters:
        key - The key
        Returns:
        The properties

      • saveProperties

        java.util.concurrent.CompletableFuture<java.lang.Boolean> saveProperties​(ServerWorldProperties properties)
        Saves a properties.
        Parameters:
        properties - The properties
        Returns:
        True if successful, false if not

      • copyWorld

        java.util.concurrent.CompletableFuture<java.lang.Boolean> copyWorld​(ResourceKey key,
                                                                    ResourceKey copyKey)
        Copies world data under the provided key to a provided key.

        If the world is loaded, the following will occur:

        • World is saved
        • World saving is disabled
        • World is copied
        • World saving is enabled

        It is left up to the implementation on exactly what is copied.

        Parameters:
        key - The key
        copyKey - The copied key for the new properties
        Returns:
        The copied properties

      • moveWorld

        java.util.concurrent.CompletableFuture<java.lang.Boolean> moveWorld​(ResourceKey key,
                                                                    ResourceKey moveKey)
        Moves world data under the provided key to another key.

        If the world is loaded, the following will occur:

        • World is saved
        • World is unloaded
        • World is moved

        The default Minecraft world cannot be moved. Additionally, it is left up to the implementation on exactly what is moved.

        Parameters:
        key - The key
        moveKey - The move key
        Returns:
        True if the move was successful

      • deleteWorld

        java.util.concurrent.CompletableFuture<java.lang.Boolean> deleteWorld​(ResourceKey key)
        Deletes world data under the provided key.

        If the world is loaded, the following will occur:

        • World is unloaded
        • World is deleted

        The default Minecraft world cannot be deleted. Additionally, it is left up to the implementation on exactly what is deleted.

        Parameters:
        key - The key
        Returns:
        True if the deletion was successful.