org.spongepowered.api.world.storage.WorldProperties Java Examples

@Listener(order = Order.FIRST, beforeModifications = true)
public void onPlayerLogin(ClientConnectionEvent.Login event) {
    GDTimings.PLAYER_LOGIN_EVENT.startTimingIfSync();
    User player = event.getTargetUser();
    if (!GriefDefenderPlugin.getInstance().claimsEnabledForWorld(event.getToTransform().getExtent().getUniqueId())) {
        GDTimings.PLAYER_LOGIN_EVENT.stopTimingIfSync();
        return;
    }

    final WorldProperties worldProperties = event.getToTransform().getExtent().getProperties();
    final UUID playerUniqueId = player.getUniqueId();
    final GDClaimManager claimWorldManager = this.dataStore.getClaimWorldManager(worldProperties.getUniqueId());
    final Instant dateNow = Instant.now();
    for (Claim claim : claimWorldManager.getWorldClaims()) {
        if (claim.getType() != ClaimTypes.ADMIN && claim.getOwnerUniqueId().equals(playerUniqueId)) {
            claim.getData().setDateLastActive(dateNow);
            for (Claim subdivision : ((GDClaim) claim).children) {
                subdivision.getData().setDateLastActive(dateNow);
            }
            ((GDClaim) claim).getInternalClaimData().setRequiresSave(true);
            ((GDClaim) claim).getInternalClaimData().save();
        }
    }
    GDTimings.PLAYER_LOGIN_EVENT.stopTimingIfSync();
}
 

@Override
public CommandResult execute(CommandSource sender, CommandContext args) throws CommandException {
    String name = (String) args.getOne("name").get();

    Path path = Sponge.getGame().getSavesDirectory();
    if (!(Files.exists(path.resolve(name.toLowerCase())) || Files.exists(path.resolve(name)) || Sponge.getServer().getAllWorldProperties().stream().anyMatch(x -> x.getWorldName().equalsIgnoreCase(name)))) {
        throw new ErrorMessageException(Messages.getFormatted(sender, "world.command.world.import.notfound", "%world%", name));
    }

    Messages.send(sender, "world.command.world.import.starting", "%name%", name);

    WorldProperties props;
    try {
        props = Sponge.getServer().createWorldProperties(name, WorldArchetype.builder().build(name.toLowerCase(), name));
    } catch (IOException e) {
        throw new ErrorMessageException(Messages.getFormatted(sender, "world.command.world.import.fileerror", "%error%", e.getMessage()));
    }
    Sponge.getServer().saveWorldProperties(props);
    World world = Sponge.getServer().loadWorld(props).orElseThrow(() -> new ErrorMessageException(Messages.getFormatted(sender, "world.command.world.import.loaderror")));
    Messages.send(sender, "world.command.world.import.success", "%name%", world.getName());
    return CommandResult.success();
}
 

private void saveWorldProperties(WorldProperties props) {
    this.uuid = UUID.fromString(props.getUniqueId().toString());
    this.name = props.getWorldName();
    this.loaded = false;

    this.loadOnStartup = props.loadOnStartup();
    this.keepSpawnLoaded = props.doesKeepSpawnLoaded();
    this.allowCommands = props.areCommandsAllowed();
    this.generateBonusChests = props.doesGenerateBonusChest();
    this.mapFeaturesEnabled = props.usesMapFeatures();
    this.border = new CachedWorldBorder(props);
    this.difficulty = new CachedCatalogType<>(props.getDifficulty());
    this.dimensionType = new CachedCatalogType<>(props.getDimensionType());
    this.gameMode = new CachedCatalogType<>(props.getGameMode());
    this.gameRules = new HashMap<>(props.getGameRules());
    this.generatorType = new CachedCatalogType<>(props.getGeneratorType());
    this.seed = props.getSeed();
    this.spawn = props.getSpawnPosition();
    this.time = props.getWorldTime();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to delete a region."))
            .arguments(
                    GenericArguments.optional(GenericArguments.string(Text.of("regionName"))),
                    GenericArguments.optional(GenericArguments.world(Text.of("world")))
            )
            .permission("redprotect.command.delete")
            .executor((src, args) -> {
                if (!(src instanceof Player)) {
                    HandleHelpPage(src, 1);
                } else {
                    Player player = (Player) src;

                    if (args.hasAny("regionName")) {
                        handleDeleteName(player, args.<String>getOne("regionName").get(), "");
                    } else if (args.hasAny("world")) {
                        handleDeleteName(player, args.<String>getOne("regionName").get(), args.<WorldProperties>getOne("world").get().getWorldName());
                    } else {
                        handleDelete(player);
                    }

                }
                return CommandResult.success();
            }).build();
}
 

@DELETE
@Path("/{world}")
@Permission("delete")
@ApiOperation(
        value = "Delete a world",
        notes = "Deletes an existing world. **The world must be unloaded before deleting it**")
public CachedWorld deleteWorld(
        @PathParam("world") @ApiParam("The uuid of the world to delete") CachedWorld world) {
    boolean deleted = WebAPI.runOnMain(() -> {
        Optional<WorldProperties> optLive = world.getLiveProps();
        if (!optLive.isPresent())
            throw new InternalServerErrorException("Could not get live world properties");

        WorldProperties live = optLive.get();
        try {
            return Sponge.getServer().deleteWorld(live).get();
        } catch (InterruptedException | ExecutionException e) {
            throw new InternalServerErrorException(e.getMessage());
        }
    });

    cacheService.removeWorld(world.getUUID());
    return world;
}
 

/**
 * Gets a specific world by UUID.
 *
 * @param uuid The UUID of the world.
 * @return An optional containing the world, or empty if not found.
 */
public Optional<CachedWorld> getWorld(UUID uuid) {
    if (!worlds.containsKey(uuid)) {
        return Optional.empty();
    }

    final CachedWorld res = worlds.get(uuid);
    if (res.isExpired()) {
        return Optional.of(WebAPI.runOnMain(() -> {
            Optional<World> world = Sponge.getServer().getWorld(uuid);
            if (world.isPresent())
                return updateWorld(world.get());
            Optional<WorldProperties> props = Sponge.getServer().getWorldProperties(uuid);
            if (!props.isPresent())
                throw new InternalServerErrorException("Could not get world properties");
            return updateWorld(props.get());
        }));
    } else {
        return Optional.of(res);
    }
}
 

public void unloadWorldData(WorldProperties worldProperties) {
    GPClaimManager claimWorldManager = this.getClaimWorldManager(worldProperties);
    for (Claim claim : claimWorldManager.getWorldClaims()) {
        ((GPClaim) claim).unload();
    }
    // Task must be cancelled before removing the claimWorldManager reference to avoid a memory leak
    Task cleanupTask = cleanupClaimTasks.get(worldProperties.getUniqueId());
    if (cleanupTask != null) {
       cleanupTask.cancel();
       cleanupClaimTasks.remove(worldProperties.getUniqueId());
    }

    claimWorldManager.unload();
    this.claimWorldManagers.remove(worldProperties.getUniqueId());
    DataStore.dimensionConfigMap.remove(worldProperties.getUniqueId());
    DataStore.worldConfigMap.remove(worldProperties.getUniqueId());
}
 

@Listener
public void onServerStart(GameStartingServerEvent evt) {
	asyncExecutor = Sponge.getScheduler().createAsyncExecutor(this);
	
	//save all world properties to generate level_sponge.dat files
	for (WorldProperties properties : Sponge.getServer().getAllWorldProperties()) {
		Sponge.getServer().saveWorldProperties(properties);
	}
	
	//register commands
	for(SpongeCommandProxy command : commands.getRootCommands()) {
		Sponge.getCommandManager().register(this, command, command.getLabel());
	}
	
	asyncExecutor.execute(() -> {
		try {
			Logger.global.logInfo("Loading...");
			bluemap.load();
			if (bluemap.isLoaded()) Logger.global.logInfo("Loaded!");
		} catch (Throwable t) {
			Logger.global.logError("Failed to load!", t);
		}
	});
}
 

private Consumer<CommandSource> createClaimListConsumer(Player src, User user, String type, WorldProperties worldProperties) {
    return consumer -> {
        if (type.equalsIgnoreCase("ALL")) {
            this.displayOwned = false;
        } else {
            this.displayOwned = true;
        }
        showClaimList(src, user, null, worldProperties);
    };
}
 

@CommandCompletion("@gdplayers @gddummy")
@CommandAlias("acb|adjustclaimblocks")
@Description("Updates a player's accrued claim block total")
@Syntax("<player> <amount>")
@Subcommand("player adjustbonusblocks")
public void execute(CommandSource src, User user, int amount, @Optional String world) {
    WorldProperties worldProperties = world == null ? null : Sponge.getServer().getWorldProperties(world).orElse(null);
    if (worldProperties == null) {
        if (src instanceof Player) {
            worldProperties = ((Player) src).getWorld().getProperties();
        } else {
            worldProperties = Sponge.getServer().getDefaultWorld().get();
        }
    }
    if (worldProperties == null || !GriefDefenderPlugin.getInstance().claimsEnabledForWorld(worldProperties.getUniqueId())) {
        GriefDefenderPlugin.sendMessage(src, MessageCache.getInstance().CLAIM_DISABLED_WORLD);
        return;
    }

    // parse the adjustment amount
    int adjustment = amount;
    //User user = args.<User>getOne("user").get();

    // give blocks to player
    GDPlayerData playerData = GriefDefenderPlugin.getInstance().dataStore.getOrCreatePlayerData(worldProperties.getUniqueId(), user.getUniqueId());
    playerData.setBonusClaimBlocks(playerData.getBonusClaimBlocks() + adjustment);
    final Component message = GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.ADJUST_BONUS_BLOCKS_SUCCESS, ImmutableMap.of(
            "player", user.getName(),
            "amount", adjustment,
            "total", playerData.getBonusClaimBlocks()));
    TextAdapter.sendComponent(src, message);
    GriefDefenderPlugin.getInstance().getLogger().info(
            src.getName() + " adjusted " + user.getName() + "'s bonus claim blocks by " + adjustment + ".");
}
 

@Override
public Optional<PlayerData> getGlobalPlayerData(UUID playerUniqueId) {
    final WorldProperties worldProperties = Sponge.getServer().getDefaultWorld().orElse(null);
    if (worldProperties == null) {
        return Optional.empty();
    }

    return this.getWorldPlayerData(worldProperties, playerUniqueId);
}
 

public void createWildernessClaim(WorldProperties worldProperties) {
    World world = Sponge.getServer().getWorld(worldProperties.getUniqueId()).get();
    Location<World> lesserCorner = new Location<World>(world, -30000000, 0, -30000000);
    Location<World> greaterCorner = new Location<World>(world, 29999999, 255, 29999999);
    // Use world UUID as wilderness claim ID
    GPClaim wilderness = new GPClaim(lesserCorner, greaterCorner, worldProperties.getUniqueId(), ClaimType.WILDERNESS, null, false);
    wilderness.setOwnerUniqueId(GriefPreventionPlugin.WORLD_USER_UUID);
    wilderness.initializeClaimData(null);
    DATASTORE.writeClaimToStorage(wilderness);
    this.theWildernessClaim = wilderness;
    this.claimUniqueIdMap.put(wilderness.getUniqueId(), wilderness);
}
 

public GPClaimManager getClaimWorldManager(WorldProperties worldProperties) {
    GPClaimManager claimWorldManager = null;
    if (worldProperties == null) {
        worldProperties = Sponge.getServer().getDefaultWorld().get();
    }
    claimWorldManager = this.claimWorldManagers.get(worldProperties.getUniqueId());

    if (claimWorldManager == null) {
        registerWorld(worldProperties);
        claimWorldManager = this.claimWorldManagers.get(worldProperties.getUniqueId());
    }
    return claimWorldManager;
}
 

@CommandCompletion("@gdworlds @gddummy")
@CommandAlias("abandonworld")
@Description("Special admin command used to abandon ALL user claims in world")
@Subcommand("abandon world")
@Syntax("[<world>]")
public void execute(Player player, @Optional String worldName) {
    WorldProperties world = player.getWorld().getProperties();
    if (worldName != null) {
        world = Sponge.getServer().getWorldProperties(worldName).orElse(null);
        if (world == null) {
            TextAdapter.sendComponent(player, MessageStorage.MESSAGE_DATA.getMessage(MessageStorage.COMMAND_WORLD_NOT_FOUND,
                    ImmutableMap.of("world", worldName)));
            return;
        }
    }
    final GDClaimManager claimWorldManager = GriefDefenderPlugin.getInstance().dataStore.getClaimWorldManager(player.getWorld().getUniqueId());
    if (claimWorldManager.getWorldClaims().size() == 0) {
        try {
            throw new CommandException(MessageCache.getInstance().CLAIM_NO_CLAIMS);
        } catch (CommandException e) {
            TextAdapter.sendComponent(player, e.getText());
            return;
        }
    }

    final Component message = GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.ABANDON_WORLD_WARNING, ImmutableMap.of(
            "world", TextComponent.of(world.getWorldName())));
    final Component confirmationText = TextComponent.builder()
            .append(message)
            .append(TextComponent.builder()
                .append("\n[")
                .append(MessageCache.getInstance().LABEL_CONFIRM.color(TextColor.GREEN))
                .append("]\n")
                .clickEvent(ClickEvent.runCommand(GDCallbackHolder.getInstance().createCallbackRunCommand(player, createConfirmationConsumer(player, world), true)))
                .hoverEvent(HoverEvent.showText(MessageCache.getInstance().UI_CLICK_CONFIRM)).build())
            .build();
    TextAdapter.sendComponent(player, confirmationText);
}
 

public GDClaimManager getClaimWorldManager(UUID worldUniqueId) {
    GDClaimManager claimWorldManager = null;
    if (worldUniqueId == null) {
        worldUniqueId = Sponge.getServer().getDefaultWorld().get().getUniqueId();
    }
    claimWorldManager = this.claimWorldManagers.get(worldUniqueId);

    if (claimWorldManager == null) {
        final WorldProperties defaultWorldProperties = Sponge.getServer().getDefaultWorld().get();
        final World world = Sponge.getServer().getWorld(worldUniqueId).orElse(Sponge.getServer().getWorld(defaultWorldProperties.getUniqueId()).get());
        registerWorld(world);
        claimWorldManager = this.claimWorldManagers.get(world.getUniqueId());
    }
    return claimWorldManager;
}
 

public void updateWorlds() {
    WebAPI.runOnMain(() -> {
        worlds.clear();

        // The worlds that are loaded on server start are overwritten by the world load event later
        // TODO: Sponge has a bug that makes the "getAllWorldProperties" method cache the world properties
        Collection<WorldProperties> unloadedWorlds = Sponge.getServer().getAllWorldProperties();
        for (WorldProperties world : unloadedWorlds) {
            updateWorld(world);
        }
    });
}
 

@CommandAlias("deletealladmin")
@Description("Deletes all administrative claims.")
@Subcommand("delete alladmin")
public void execute(Player player, @Optional String worldName) {
    WorldProperties worldProperties = null;
    if (worldName != null) {
        worldProperties = Sponge.getServer().getWorldProperties(worldName).orElse(null);
        if (worldProperties == null) {
            TextAdapter.sendComponent(player, MessageStorage.MESSAGE_DATA.getMessage(MessageStorage.COMMAND_WORLD_NOT_FOUND,
                    ImmutableMap.of("world", worldName)));
            return;
        }
    }

    Component message = null;
    if (worldProperties != null) {
        message = GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.DELETE_ALL_TYPE_WARNING_WORLD, ImmutableMap.of(
                "type", TextComponent.of("ADMIN").color(TextColor.RED),
                "world", worldProperties.getWorldName()));
    } else {
        message = GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.DELETE_ALL_TYPE_WARNING, ImmutableMap.of(
                "type", TextComponent.of("ADMIN").color(TextColor.RED)));
    }
    final Component confirmationText = TextComponent.builder("")
            .append(message)
            .append(TextComponent.builder()
                .append("\n[")
                .append(MessageCache.getInstance().LABEL_CONFIRM.color(TextColor.GREEN))
                .append("]\n")
                .clickEvent(ClickEvent.runCommand(GDCallbackHolder.getInstance().createCallbackRunCommand(player, createConfirmationConsumer(player, worldProperties), true)))
                .hoverEvent(HoverEvent.showText(MessageCache.getInstance().UI_CLICK_CONFIRM)).build())
            .build();
    TextAdapter.sendComponent(player, confirmationText);
}
 

public GPPlayerData(WorldProperties worldProperties, UUID playerUniqueId, PlayerStorageData playerStorage, GriefPreventionConfig<?> activeConfig, Set<Claim> claims) {
    this.worldProperties = worldProperties;
    this.playerID = playerUniqueId;
    this.playerStorage = playerStorage;
    this.claimList = claims;
    this.refreshPlayerOptions();
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext args) {
    WorldProperties worldProperties = args.<WorldProperties> getOne("world").orElse(Sponge.getServer().getDefaultWorld().get());

    if (worldProperties == null) {
        if (src instanceof Player) {
            worldProperties = ((Player) src).getWorld().getProperties();
        } else {
            worldProperties = Sponge.getServer().getDefaultWorld().get();
        }
    }
    if (worldProperties == null || !GriefPreventionPlugin.instance.claimsEnabledForWorld(worldProperties)) {
        GriefPreventionPlugin.sendMessage(src, GriefPreventionPlugin.instance.messageData.claimDisabledWorld.toText());
        return CommandResult.success();
    }

    // parse the adjustment amount
    int adjustment = args.<Integer>getOne("amount").get();
    User user = args.<User>getOne("user").get();

    // give blocks to player
    GPPlayerData playerData = GriefPreventionPlugin.instance.dataStore.getOrCreatePlayerData(worldProperties, user.getUniqueId());
    playerData.setBonusClaimBlocks(playerData.getBonusClaimBlocks() + adjustment);
    playerData.getStorageData().save();
    final Text message = GriefPreventionPlugin.instance.messageData.adjustBlocksSuccess
            .apply(ImmutableMap.of(
            "player", Text.of(user.getName()),
            "adjustment", Text.of(adjustment),
            "total", Text.of(playerData.getBonusClaimBlocks()))).build();
    GriefPreventionPlugin
            .sendMessage(src, message);
    GriefPreventionPlugin.addLogEntry(
            src.getName() + " adjusted " + user.getName() + "'s bonus claim blocks by " + adjustment + ".",
            CustomLogEntryTypes.AdminActivity);

    return CommandResult.success();
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext args) {
    WorldProperties worldProperties = args.<WorldProperties> getOne("world").orElse(null);
    Player player = src instanceof Player ? (Player)src : null;
    if (worldProperties == null) {
        if (player != null) {
            worldProperties = player.getWorld().getProperties();
        } else {
            src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "No valid world could be found!"));
            return CommandResult.success();
        }
    }

    if (!GriefPreventionPlugin.instance.claimsEnabledForWorld(worldProperties)) {
        GriefPreventionPlugin.sendMessage(src, GriefPreventionPlugin.instance.messageData.claimDisabledWorld.toText());
        return CommandResult.success();
    }

    // parse the adjustment amount
    int newAmount = args.<Integer>getOne("amount").get();
    User user = args.<User>getOne("user").get();

    // set player's blocks
    GPPlayerData playerData = GriefPreventionPlugin.instance.dataStore.getOrCreatePlayerData(worldProperties, user.getUniqueId());
    if (!playerData.setAccruedClaimBlocks(newAmount)) {
        if (player != null) {
            player.sendMessage(Text.of(TextColors.RED, "User " + user.getName() + " has a total of " + playerData.getAccruedClaimBlocks() + " and will exceed the maximum allowed accrued claim blocks if granted an additional " + newAmount + " blocks. ",
                    "Either lower the amount or have an admin grant the user with an override."));
        }
        return CommandResult.success();
    }

    playerData.getStorageData().save();
    GriefPreventionPlugin.sendMessage(src, GriefPreventionPlugin.instance.messageData.commandAcbSuccess.toText());
    GriefPreventionPlugin.addLogEntry(src.getName() + " set " + user.getName() + "'s accrued claim blocks to " + newAmount + ".",
            CustomLogEntryTypes.AdminActivity);
    return CommandResult.success();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to see info about regions."))
            .arguments(
                    GenericArguments.optional(GenericArguments.string(Text.of("region"))),
                    GenericArguments.optional(GenericArguments.world(Text.of("world"))))
            .permission("redprotect.command.info")
            .executor((src, args) -> {
                if (!(src instanceof Player) && args.hasAny("region") && args.hasAny("world")) {
                    if (Sponge.getServer().getWorld(args.<WorldProperties>getOne("world").get().getWorldName()).isPresent()) {
                        Region r = RedProtect.get().rm.getRegion(args.<String>getOne("region").get(), args.<WorldProperties>getOne("world").get().getWorldName());
                        if (r != null) {
                            src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("general.color") + "-----------------------------------------"));
                            src.sendMessage(r.info());
                            src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("general.color") + "-----------------------------------------"));
                        } else {
                            src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("correct.usage") + "&eInvalid region: " + args.<String>getOne("region").get()));
                        }
                    } else {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("correct.usage") + " " + "&eInvalid World: " + args.<WorldProperties>getOne("world").get().getWorldName()));
                    }
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    if (args.hasAny("region") && args.hasAny("world")) {
                        handleInfo(player, args.<String>getOne("region").get(), args.<WorldProperties>getOne("world").get().getWorldName());
                    } else if (args.hasAny("region")) {
                        handleInfo(player, args.<String>getOne("region").get(), "");
                    } else {
                        handleInfoTop(player);
                    }
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "info", true);
                return CommandResult.success();
            }).build();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to remove members to regions."))
            .arguments(GenericArguments.string(Text.of("player")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.string(Text.of("region")), "redprotect.command.admin.removemember")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.world(Text.of("world")), "redprotect.command.admin.removemember")))
            .permission("redprotect.command.removemember")
            .executor((src, args) -> {
                if (args.hasAny("region") && args.hasAny("world")) {
                    String region = args.<String>getOne("region").get();
                    WorldProperties worldProperties = args.<WorldProperties>getOne("world").get();

                    if (!RedProtect.get().getServer().getWorld(worldProperties.getWorldName()).isPresent()) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.invalidworld")));
                        return CommandResult.success();
                    }
                    Region r = RedProtect.get().rm.getRegion(region, worldProperties.getWorldName());
                    if (r == null) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.doesntexist") + ": " + region));
                        return CommandResult.success();
                    }
                    handleRemoveMember(src, args.<String>getOne("player").get(), r);
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    handleRemoveMember(player, args.<String>getOne("player").get(), null);
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "removemember", true);
                return CommandResult.success();
            }).build();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to add leaders to regions."))
            .arguments(GenericArguments.string(Text.of("player")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.string(Text.of("region")), "redprotect.command.admin.addleader")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.world(Text.of("world")), "redprotect.command.admin.addleader")))
            .permission("redprotect.command.addleader")
            .executor((src, args) -> {
                if (args.hasAny("region") && args.hasAny("world")) {
                    String region = args.<String>getOne("region").get();
                    WorldProperties worldProperties = args.<WorldProperties>getOne("world").get();

                    if (!RedProtect.get().getServer().getWorld(worldProperties.getWorldName()).isPresent()) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.invalidworld")));
                        return CommandResult.success();
                    }
                    Region r = RedProtect.get().rm.getRegion(region, worldProperties.getWorldName());
                    if (r == null) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.doesntexist") + ": " + region));
                        return CommandResult.success();
                    }
                    handleAddLeader(src, args.<String>getOne("player").get(), r);
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    handleAddLeader(player, args.<String>getOne("player").get(), null);
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "addleader", true);
                return CommandResult.success();
            }).build();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to remove admins to regions."))
            .arguments(GenericArguments.string(Text.of("player")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.string(Text.of("region")), "redprotect.command.admin.removeadmin")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.world(Text.of("world")), "redprotect.command.admin.removeadmin")))
            .permission("redprotect.command.removeadmin")
            .executor((src, args) -> {
                if (args.hasAny("region") && args.hasAny("world")) {
                    String region = args.<String>getOne("region").get();
                    WorldProperties worldProperties = args.<WorldProperties>getOne("world").get();

                    if (!RedProtect.get().getServer().getWorld(worldProperties.getWorldName()).isPresent()) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.invalidworld")));
                        return CommandResult.success();
                    }
                    Region r = RedProtect.get().rm.getRegion(region, worldProperties.getWorldName());
                    if (r == null) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.doesntexist") + ": " + region));
                        return CommandResult.success();
                    }
                    handleRemoveAdmin(src, args.<String>getOne("player").get(), r);
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    handleRemoveAdmin(player, args.<String>getOne("player").get(), null);
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "removeadmin", true);
                return CommandResult.success();
            }).build();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to add members to regions."))
            .arguments(GenericArguments.string(Text.of("player")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.string(Text.of("region")), "redprotect.command.admin.addmember")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.world(Text.of("world")), "redprotect.command.admin.addmember")))
            .permission("redprotect.command.addmember")
            .executor((src, args) -> {
                if (args.hasAny("region") && args.hasAny("world")) {
                    String region = args.<String>getOne("region").get();
                    WorldProperties worldProperties = args.<WorldProperties>getOne("world").get();

                    if (!RedProtect.get().getServer().getWorld(worldProperties.getWorldName()).isPresent()) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.invalidworld")));
                        return CommandResult.success();
                    }
                    Region r = RedProtect.get().rm.getRegion(region, worldProperties.getWorldName());
                    if (r == null) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.doesntexist") + ": " + region));
                        return CommandResult.success();
                    }
                    handleAddMember(src, args.<String>getOne("player").get(), r);
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    handleAddMember(player, args.<String>getOne("player").get(), null);
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "addmember", true);
                return CommandResult.success();
            }).build();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to remove leaders to regions."))
            .arguments(GenericArguments.string(Text.of("player")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.string(Text.of("region")), "redprotect.command.admin.removeleader")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.world(Text.of("world")), "redprotect.command.admin.removeleader")))
            .permission("redprotect.command.removeleader")
            .executor((src, args) -> {
                if (args.hasAny("region") && args.hasAny("world")) {
                    String region = args.<String>getOne("region").get();
                    WorldProperties worldProperties = args.<WorldProperties>getOne("world").get();

                    if (!RedProtect.get().getServer().getWorld(worldProperties.getWorldName()).isPresent()) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.invalidworld")));
                        return CommandResult.success();
                    }
                    Region r = RedProtect.get().rm.getRegion(region, worldProperties.getWorldName());
                    if (r == null) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.doesntexist") + ": " + region));
                        return CommandResult.success();
                    }
                    handleRemoveLeader(src, args.<String>getOne("player").get(), r);
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    handleRemoveLeader(player, args.<String>getOne("player").get(), null);
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "removeleader", true);
                return CommandResult.success();
            }).build();
}
 

public CommandSpec register() {
    return CommandSpec.builder()
            .description(Text.of("Command to add admins to regions."))
            .arguments(
                    GenericArguments.string(Text.of("player")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.string(Text.of("region")), "redprotect.command.admin.addadmin")),
                    GenericArguments.optional(GenericArguments.requiringPermission(GenericArguments.world(Text.of("world")), "redprotect.command.admin.addadmin")))
            .permission("redprotect.command.addadmin")
            .executor((src, args) -> {
                if (args.hasAny("region") && args.hasAny("world")) {
                    String region = args.<String>getOne("region").get();
                    WorldProperties worldProperties = args.<WorldProperties>getOne("world").get();

                    if (!RedProtect.get().getServer().getWorld(worldProperties.getWorldName()).isPresent()) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.invalidworld")));
                        return CommandResult.success();
                    }
                    Region r = RedProtect.get().rm.getRegion(region, worldProperties.getWorldName());
                    if (r == null) {
                        src.sendMessage(RedProtect.get().getUtil().toText(RedProtect.get().lang.get("cmdmanager.region.doesntexist") + ": " + region));
                        return CommandResult.success();
                    }
                    handleAddAdmin(src, args.<String>getOne("player").get(), r);
                    return CommandResult.success();
                } else if (src instanceof Player) {
                    Player player = (Player) src;
                    handleAddAdmin(player, args.<String>getOne("player").get(), null);
                    return CommandResult.success();
                }

                RedProtect.get().lang.sendCommandHelp(src, "addadmin", true);
                return CommandResult.success();
            }).build();
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    WorldProperties world;
    if (!args.hasAny("world")) {
        checkIfPlayer(src);
        Player p = (Player) src;
        world = p.getWorld().getProperties();
    } else {
        world = args.<WorldProperties>getOne("world").get();
    }
    Messages.send(src, "world.command.world.info.single.title", "%world%", world.getWorldName());
    Messages.send(src, "world.command.world.info.single.id-uuid", "%id%", world.getUniqueId().toString());
    String numeric;
    try {
        numeric = world.getAdditionalProperties().getView(DataQuery.of("SpongeData")).get().get(DataQuery.of("dimensionId")).get().toString();
    } catch (Exception ex) {
        numeric = "?";
    }
    Messages.send(src, "world.command.world.info.single.id-numeric", "%id%", numeric);
    Messages.send(src, "world.command.world.info.single.enabled", "%enabled%", world.loadOnStartup() ? Messages.getFormatted(src, "world.enabled") : Messages.getFormatted(src, "world.disabled"));
    Messages.send(src, "world.command.world.info.single.difficulty", "%difficulty%", world.getDifficulty().getName());
    Messages.send(src, "world.command.world.info.single.gamemode", "%gamemode%", world.getGameMode().getName());
    Messages.send(src, "world.command.world.info.single.hardcore", "%hardcore%", world.isHardcore() ? Messages.getFormatted(src, "world.enabled") : Messages.getFormatted(src, "world.disabled"));
    Messages.send(src, "world.command.world.info.single.pvp", "%pvp%", world.isPVPEnabled() ? Messages.getFormatted(src, "world.enabled") : Messages.getFormatted(src, "world.disabled"));
    src.sendMessage(Messages.getFormatted(src, "world.command.world.info.single.gamerules").toBuilder().onClick(TextActions.runCommand("/world gamerule " + world.getWorldName())).build());
    return CommandResult.success();
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    WorldProperties world = (WorldProperties) args.getOne("world").get();
    world.setLoadOnStartup(true);
    Sponge.getServer().loadWorld(world);
    Messages.send(src, "world.command.world.enable.success", "%world%", world.getWorldName());
    return CommandResult.success();
}
 

@Nullable
@Override
public WorldProperties parseValue(CommandSource source, CommandArgs args) throws ArgumentParseException {
    String value = args.next();
    Optional<WorldProperties> t = Sponge.getServer().getWorldProperties(value);
    if (t.isPresent()) {
        return t.get();
    } else {
        throw args.createError(Messages.getFormatted("core.worldnotfound", "%world%", value));
    }
}