import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
@Override
public LanternWorldArchetypeBuilder from(WorldArchetype archetype) {
    final LanternWorldArchetype archetype0 = (LanternWorldArchetype)
            checkNotNull(archetype, "archetype");
    this.difficulty = archetype0.getDifficulty();
    this.hardcore = archetype0.isHardcore();
    this.enabled = archetype0.isEnabled();
    this.gameMode = archetype0.getGameMode();
    this.keepsSpawnLoaded = archetype0.keepsSpawnLoaded;
    this.usesMapFeatures = archetype0.usesMapFeatures();
    this.generatorModifiers = archetype0.getGeneratorModifiers();
    this.dimensionType = archetype0.getDimensionType();
    this.generatorType = archetype0.generatorType;
    this.generatorSettings = archetype0.generatorSettings;
    this.generateBonusChest = archetype0.doesGenerateBonusChest();
    this.commandsAllowed = archetype0.areCommandsAllowed();
    this.waterEvaporates = archetype0.waterEvaporates;
    this.buildHeight = archetype0.getBuildHeight();
    this.allowPlayerRespawns = archetype0.allowPlayerRespawns;
    this.pvpEnabled = archetype0.isPVPEnabled();
    this.generateSpawnOnLoad = archetype0.doesGenerateSpawnOnLoad();
    this.portalAgentType = archetype0.getPortalAgentType();
    this.seed = archetype0.isSeedRandomized() ? null : archetype0.getSeed();
    return this;
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
private World getOrCreateWorld(WorldConfig worldConfig) throws Throwable {
  String worldName = worldConfig.getName();
  Optional<World> optTargetWorld = Sponge.getServer().getWorld(worldName);
  if (optTargetWorld.isPresent()) {
    return optTargetWorld.get();
  }

  GameRegistry registry = Sponge.getRegistry();
  String archetypeName = worldConfig.getArchetype();
  WorldArchetype archetype = registry.getType(WorldArchetype.class, archetypeName).orElseThrow((Supplier<Throwable>) () -> {
    return new RuntimeException("No world archetype: " + archetypeName);
  });
  optTargetWorld = service.loadWorld(worldName, archetype);
  service.registerWorld(worldName);
  return optTargetWorld.get();
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
@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();
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource commandSource, CommandContext args) throws CommandException {
    String worldURI = args.<String>getOne("uri").get();
    // TODO (HACK) for now we'll just interpret this as a directory
    // the idea is to later handle URIs, like in BundleManager, and be able to import e.g. from GitHub!! ;)
    File worldSavesDir = Sponge.getGame().getSavesDirectory().resolve("world").toFile();
    // worlds apparently (learnt the hard way..) HAVE to be in the saves directory!
    // if later we want arbitrary dirs, or stream from git, we'd have to copy/move them here:
    File worldDirectory = new File(worldSavesDir, worldURI);
    if (!(worldDirectory.exists() && worldDirectory.isDirectory())) {
        throw new CommandException(Text.of("Must be an existing directory, but isn't: " + worldDirectory));
    }

    // TODO this WorldArchetype metadata should be read from some properties [JSON/YAML] file along the world/ (saves/ ?) dir.
    String newWorldName = worldDirectory.getName();
    WorldArchetype archetype = WorldArchetypes.OVERWORLD;

    WorldProperties loadedWorldProperties = CommandExceptions.getOrThrow("createWorldProperties: " + newWorldName,
            () -> Sponge.getServer().createWorldProperties(newWorldName, archetype));
    if (loadedWorldProperties != null) {
        Sponge.getServer().saveWorldProperties(loadedWorldProperties);

        if (!loadedWorldProperties.getWorldName().equals(newWorldName)) {
            commandSource.sendMessage(Texts.inRed("Uh oh; imported folder name does not match new world name... this is BAD!"));
        }

        // TODO .onClick(TextActions.executeCallback(/tpw) ..
        commandSource.sendMessage(Text.of("OK, created new world " + loadedWorldProperties.getWorldName()));
    } else {
        throw CommandExceptions.create("Failed to load: " + newWorldName);
    }
    return CommandResult.success();
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
@Override
public void registerDefaults() {
    final WorldArchetype overworld = WorldArchetype.builder()
            .enabled(true)
            .loadsOnStartup(true)
            .keepsSpawnLoaded(true)
            .generateSpawnOnLoad(true)
            .commandsAllowed(true)
            .gameMode(GameModes.SURVIVAL)
            .generator(GeneratorTypes.DEFAULT)
            .dimension(DimensionTypes.OVERWORLD)
            .difficulty(Difficulties.NORMAL)
            .usesMapFeatures(true)
            .hardcore(false)
            .pvp(true)
            .generateBonusChest(false)
            .serializationBehavior(SerializationBehaviors.AUTOMATIC)
            .build("minecraft:overworld", "Overworld");
    register(overworld);
    register(WorldArchetype.builder()
            .from(overworld)
            .generator(GeneratorTypes.NETHER)
            .dimension(DimensionTypes.NETHER)
            .build("minecraft:the_nether", "The Nether"));
    register(WorldArchetype.builder()
            .from(overworld)
            .generator(GeneratorTypes.THE_END)
            .dimension(DimensionTypes.THE_END)
            .build("minecraft:the_end", "The End"));
    register(WorldArchetype.builder()
            .from(overworld)
            .generatorModifiers(WorldGeneratorModifiers.VOID)
            .build("sponge:the_void", "The Void"));
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
@Override
public Optional<World> loadWorld(String name, WorldArchetype archetype) {
  try {
    return Sponge.getServer().loadWorld(Sponge.getServer().createWorldProperties(name, archetype));
  } catch (IOException e) {
    return Optional.empty();
  }
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
public Optional<Long> scanWorld() {
    WorldProperties wp = null;
    try {
        UUID id = UUID.randomUUID();
        WorldArchetype wa = WorldArchetype.builder().build(id.toString(), id.toString());
        OceanManPlugin.logger().info("Creating new world");
        wp = Sponge.getServer().createWorldProperties(id.toString(), wa);
        Sponge.getServer().saveWorldProperties(wp);
        long seed = wp.getSeed();
        OceanManPlugin.logger().info("Starting scan for seed " + seed);
        world = getServer().loadWorld(id.toString()).get();
        total = 0;
        ocean = 0;

        boolean failed = false;
        outer:
        for (int r = 0; r <= OceanManPlugin.config().scanRadius; r++) {
            OceanManPlugin.logger().info("Scanning radius level " + r);
            boolean intolerant = r <= OceanManPlugin.config().minOceanDistance;
            // this isn't even close to DRY but idk how else to write it
            for (int i = -r; i <= r; i++) {
                if (!scanAndCheck(-r, i, intolerant)) {
                    failed = true;
                    break outer;
                }
                if (!scanAndCheck(r, i, intolerant)) {
                    failed = true;
                    break outer;
                }
                if (r != i && r != -i) {
                    if (!scanAndCheck(i, -r, intolerant)) {
                        failed = true;
                        break outer;
                    }
                    if (!scanAndCheck(i, r, intolerant)) {
                        failed = true;
                        break outer;
                    }
                }
            }
        }
        if (failed) {
            OceanManPlugin.logger().info("World failed requirements; discarding");
        }
        return !failed ? Optional.of(seed) : Optional.empty();
    } catch (IOException ex) {
        OceanManPlugin.logger().error("Failed to create world");
        ex.printStackTrace();
        return Optional.empty();
    } finally {
        if (world != null) {
            Sponge.getServer().unloadWorld(world);
            world = null;
        }
        if (wp != null) {
            wp.setEnabled(false);
            Sponge.getServer().saveWorldProperties(wp);
            Sponge.getServer().deleteWorld(wp);
        }
    }
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
@Override
public WorldProperties createWorldProperties(String folderName, WorldArchetype archetype) throws IOException {
	return this.server.createWorldProperties(folderName, archetype);
}
 

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 WorldProperties createWorldProperties(String folderName, WorldArchetype worldArchetype) throws IOException {
    return this.worldManager.createWorldProperties(folderName, worldArchetype);
}
 

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包/类
public CommandResult execute(CommandSource src, CommandContext ctx) throws CommandException
{
	String name = ctx.<String> getOne("name").get();
	String dimensionInput = ctx.<String> getOne("dimension").get();
	String generatorInput = ctx.<String> getOne("generator").get();
	String difficultyInput = ctx.<String> getOne("difficulty").get();
	GameMode gamemode = ctx.<GameMode> getOne("gamemode").get();
	Difficulty difficulty = null;
	DimensionType dimension = null;
	GeneratorType generator = null;

	if (Sponge.getRegistry().getType(DimensionType.class, dimensionInput).isPresent())
	{
		dimension = Sponge.getRegistry().getType(DimensionType.class, dimensionInput).get();
	}
	else
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Dimension type specified not found."));
		return CommandResult.success();
	}

	if (Sponge.getRegistry().getType(GeneratorType.class, generatorInput).isPresent())
	{
		generator = Sponge.getRegistry().getType(GeneratorType.class, generatorInput).get();
	}
	else
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Generator type specified not found."));
		return CommandResult.success();
	}

	if (Sponge.getRegistry().getType(Difficulty.class, difficultyInput).isPresent())
	{
		difficulty = Sponge.getRegistry().getType(Difficulty.class, difficultyInput).get();
	}
	else
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "Difficulty specified not found."));
		return CommandResult.success();
	}

	src.sendMessage(Text.of(TextColors.GREEN, "Success! ", TextColors.YELLOW, "Beginning creation of world."));

	WorldArchetype worldSettings = WorldArchetype.builder()
		.enabled(true)
		.loadsOnStartup(true)
		.keepsSpawnLoaded(true)
		.dimension(dimension)
		.generator(generator)
		.gameMode(gamemode)
		.build(name.toLowerCase(), name);

	try
	{
		WorldProperties worldProperties = Sponge.getGame().getServer().createWorldProperties(name, worldSettings);
		Optional<World> world = Sponge.getGame().getServer().loadWorld(worldProperties);

		if (world.isPresent())
		{
			world.get().getProperties().setDifficulty(difficulty);
			src.sendMessage(Text.of(TextColors.GREEN, "Success! ", TextColors.GOLD, "World ", TextColors.GRAY, name, TextColors.GOLD, " has been created."));
		}
		else
		{
			src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "The world could not be created."));
		}
	}
	catch (IOException e)
	{
		src.sendMessage(Text.of(TextColors.DARK_RED, "Error! ", TextColors.RED, "The world properties could not be created."));
	}

	return CommandResult.success();
}
 

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();
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
/**
 * Creates a new world from the given {@link WorldArchetype}. For the
 * creation of the WorldCreationSettings please see
 * {@link org.spongepowered.api.world.WorldArchetype.Builder}.
 *
 * <p>If the world already exists then the existing {@link WorldProperties}
 * are returned else a new world is created and the new WorldProperties
 * returned.</p>
 *
 * <p>Although the world is created it is not loaded at this time. Please
 * see one of the following methods for loading the world.</p>
 *
 * <ul> <li>{@link #loadWorld(String)}</li> <li>{@link #loadWorld(UUID)}
 * </li> <li>{@link #loadWorld(WorldProperties)}</li> </ul>
 *
 * @param worldArchetype The world archetype for creation
 * @return The new or existing world properties, if creation was successful
 */
public WorldProperties createWorldProperties(String folderName, WorldArchetype worldArchetype) throws IOException {
    checkNotNull(worldArchetype, "worldArchetype");
    WorldLookupEntry entry = this.worldByName.get(worldArchetype.getName());
    if (entry != null) {
        return entry.properties;
    }
    // Get the next dimension id
    final int dimensionId = this.getNextFreeDimensionId();
    // Create the world properties
    return this.createWorld(worldArchetype, folderName, dimensionId);
}
 

import org.spongepowered.api.world.WorldArchetype; //导入依赖的package包/类
Optional<World> loadWorld(String name, WorldArchetype archetype);