Java WorldArchetype.Builder方法代码示例

import org.spongepowered.api.world.WorldArchetype; //导入方法依赖的package包/类
@Endpoint(method = HttpMethod.POST, path = "/", perm = "create")
public void createWorld(ServletData data) {
    WorldArchetype.Builder builder = WorldArchetype.builder();

    Optional<CreateWorldRequest> optReq = data.getRequestBody(CreateWorldRequest.class);
    if (!optReq.isPresent()) {
        data.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid world data: " + data.getLastParseError().getMessage());
        return;
    }

    CreateWorldRequest req = optReq.get();

    if (req.getName().isEmpty()) {
        data.sendError(HttpServletResponse.SC_BAD_REQUEST, "No name provided");
        return;
    }

    req.getDimensionType().ifPresent(builder::dimension);
    req.getGeneratorType().ifPresent(builder::generator);
    req.getGameMode().ifPresent(builder::gameMode);
    req.getDifficulty().ifPresent(builder::difficulty);

    if (req.getSeed() != null) {
        builder.seed(req.getSeed());
    }
    if (req.doesLoadOnStartup() != null) {
        builder.loadsOnStartup(req.doesLoadOnStartup());
    }
    if (req.doesKeepSpawnLoaded() != null) {
        builder.keepsSpawnLoaded(req.doesKeepSpawnLoaded());
    }
    if (req.doesAllowCommands() != null) {
        builder.commandsAllowed(req.doesAllowCommands());
    }
    if (req.doesGenerateBonusChest() != null) {
        builder.generateBonusChest(req.doesGenerateBonusChest());
    }
    if (req.doesUseMapFeatures() != null) {
        builder.usesMapFeatures(req.doesUseMapFeatures());
    }

    String archTypeName = UUID.randomUUID().toString();
    WorldArchetype archType = builder.enabled(true).build(archTypeName, archTypeName);

    Optional<ICachedWorld> resWorld = WebAPI.runOnMain(() -> {
        try {
            WorldProperties props = Sponge.getServer().createWorldProperties(req.getName(), archType);
            return cacheService.updateWorld(props);
        } catch (IOException e) {
            data.addData("ok", false, false);
            data.addData("error", e, false);
            return null;
        }
    });

    if (!resWorld.isPresent())
        return;

    data.setStatus(HttpServletResponse.SC_CREATED);
    data.setHeader("Location", resWorld.get().getLink());
    data.addData("ok", true, false);
    data.addData("world", resWorld.get(), true);
}
 

import org.spongepowered.api.world.WorldArchetype; //导入方法依赖的package包/类
@Override
public WorldArchetype.Builder randomSeed() {
    this.seed = null;
    return this;
}
 

import org.spongepowered.api.world.WorldArchetype; //导入方法依赖的package包/类
@Override
public WorldArchetype.Builder portalAgent(PortalAgentType type) {
    this.portalAgentType = (LanternPortalAgentType) checkNotNull(type, "type");
    return this;
}
 

import org.spongepowered.api.world.WorldArchetype; //导入方法依赖的package包/类
private WorldArchetype.Builder obtainAutoloadingWorld() {
  WorldArchetype.Builder builder = WorldArchetype.builder();
  return builder.enabled(true).loadsOnStartup(true);
}
 

import org.spongepowered.api.world.WorldArchetype; //导入方法依赖的package包/类
@Command(desc = "Creates a new world")
public void create(CommandSource context,
                   String name,
                   @Default @Named({"dimension", "dim"}) DimensionType dimension,
                   @Named("seed") String seed,
                   @Default @Named({"type"}) GeneratorType type,
                   @Default @Label("generate") @Named({"structure", "struct"}) boolean generateStructures,
                   @Default @Named({"gamemode", "mode"}) GameMode gamemode,
                   @Default @Named({"difficulty", "diff"}) Difficulty difficulty,
                   @org.cubeengine.butler.parametric.Optional @Label("name") @Named({"generator","gen"}) WorldGeneratorModifier generator,
                   @Flag boolean recreate,
                   @Flag boolean noload,
                   @Flag boolean spawnInMemory)
{
    Optional<World> world = Sponge.getServer().getWorld(name);
    if (world.isPresent())
    {
        if (recreate)
        {
            i18n.send(context, NEGATIVE, "You have to unload a world before recreating it!");
            return;
        }
        i18n.send(context, NEGATIVE, "A world named {world} already exists and is loaded!", world.get());
        return;
    }
    Optional<WorldProperties> worldProperties = Sponge.getServer().getWorldProperties(name);
    if (worldProperties.isPresent())
    {
        if (!recreate)
        {
            i18n.send(context, NEGATIVE, "A world named {name#world} already exists but is not loaded!", name);
            return;
        }
        worldProperties.get().setEnabled(false);
        String newName = name + "_" + new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss").format(new Date());
        Sponge.getServer().renameWorld(worldProperties.get(), newName);
        i18n.send(context, POSITIVE, "Old world moved to {name#folder}", newName);
    }

    WorldArchetype.Builder builder = WorldArchetype.builder().from(WorldArchetypes.OVERWORLD);
    builder.keepsSpawnLoaded(spawnInMemory);
    builder.loadsOnStartup(!noload);
    if (seed != null)
    {
        try
        {
            builder.seed(Long.parseLong(seed));
        }
        catch (NumberFormatException ignore)
        {
            builder.seed(seed.hashCode());
        }
    }

    builder.generator(type);
    builder.dimension(dimension);
    builder.usesMapFeatures(generateStructures);
    builder.gameMode(gamemode);
    if (generator != null)
    {
        builder.generatorModifiers(generator);
    }
    builder.difficulty(difficulty);
    try
    {
        WorldProperties properties = Sponge.getServer().createWorldProperties(name, builder.build("org.cubeengine.customworld:" + UUID.randomUUID().toString(), name));
        i18n.send(context, POSITIVE, "World {name} successfully created!", name);
        i18n.send(context, NEUTRAL, "This world is not yet loaded! Click {txt#here} to load.",
                i18n.translate(context, TextFormat.NONE, "here").toBuilder().onClick(TextActions.runCommand("/worlds load " + name)).build());
    }
    catch (IOException e)
    {
        i18n.send(context, NEGATIVE, "Could not create world!");
        throw new IllegalStateException(e); // TODO handle exception better
    }
}
 

import org.spongepowered.api.world.WorldArchetype; //导入方法依赖的package包/类
@Override
public CommandResult execute(CommandSource sender, CommandContext args) throws CommandException {
    String name = (String) args.getOne("name").get();
    Optional<DimensionType> dimension = args.getOne("dimension");
    Optional<GeneratorType> generator = args.getOne("generator");
    Collection<WorldGeneratorModifier> wgm = args.getAll("wgm");
    Optional<Long> seed = args.getOne("seed");
    Optional<GameMode> gm = args.getOne("gamemode");
    Optional<Difficulty> diff = args.getOne("difficulty");

    boolean nostructures = args.hasAny("n");
    boolean load = args.<Boolean>getOne("l").orElse(true);
    boolean keepspawnloaded = args.<Boolean>getOne("k").orElse(true);
    boolean allowcommands = args.<Boolean>getOne("c").orElse(true);
    boolean bonuschest = args.<Boolean>getOne("b").orElse(true);

    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.exists", "%name%", name));
    }

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

    WorldArchetype.Builder archetype = WorldArchetype.builder().enabled(true);
    dimension.ifPresent(archetype::dimension);
    generator.ifPresent(archetype::generator);
    archetype.generatorModifiers(wgm.toArray(new WorldGeneratorModifier[wgm.size()]));
    seed.ifPresent(archetype::seed);
    gm.ifPresent(archetype::gameMode);
    diff.ifPresent(archetype::difficulty);
    archetype.usesMapFeatures(!nostructures);
    archetype.loadsOnStartup(load);
    archetype.keepsSpawnLoaded(keepspawnloaded);
    archetype.commandsAllowed(allowcommands);
    archetype.generateBonusChest(bonuschest);

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