Java WorldCreator.type方法代码示例

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
private static World createArenaWorld(ConfigArena arena, String name) {
	World world;
	world = Bukkit.getServer().getWorld(name);
	if (world == null) {
		WorldCreator wc = new WorldCreator(name);
		wc.environment(Environment.NORMAL);
		wc.type(WorldType.FLAT);
		wc.generateStructures(false);
		
		world = Bukkit.getServer().createWorld(wc);
		world.setAutoSave(false);
		world.setSpawnFlags(false, false);
		world.setKeepSpawnInMemory(false);
		ChunkCoord.addWorld(world);
	}
	
	return world;
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
public void create() {
    arenaWorld = plugin.getServer().getWorld(Statics.ARENA_WORLD_NAME);
    if (arenaWorld == null) {
        plugin.getLogger().info("Loading world '" + Statics.ARENA_WORLD_NAME + "'.");
        WorldCreator arenaWorldCreator = new WorldCreator(Statics.ARENA_WORLD_NAME);
        arenaWorldCreator.generateStructures(false);
        arenaWorldCreator.generator(new VoidGenerator());
        arenaWorldCreator.type(WorldType.FLAT);
        arenaWorldCreator.seed(0);
        arenaWorld = arenaWorldCreator.createWorld();
        plugin.getLogger().info("Done loading world '" + Statics.ARENA_WORLD_NAME + "'.");
    } else {
        plugin.getLogger().info("The world '" + Statics.ARENA_WORLD_NAME + "' was already loaded.");
    }
    arenaWorld.setAutoSave(false);
    arenaWorld.getBlockAt(-5000, 45, -5000).setType(Material.STONE);
    arenaWorld.setSpawnLocation(-5000, 50, -5000);
    for (Map.Entry<String, String> entry : plugin.getConfiguration().getArenaGamerules().entrySet()) {
        arenaWorld.setGameRuleValue(entry.getKey(), entry.getValue());
    }
    arenaWorld.setTime(4000);
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
@Override
public void loadLocalWorld(@Nonnull String name) {
    WorldCreator wc = new WorldCreator(name);
    wc.environment(World.Environment.NORMAL); //TODO do we need support for environment in maps?
    wc.generateStructures(false);
    wc.type(WorldType.NORMAL);
    wc.generator(new CleanRoomChunkGenerator());
    wc.generatorSettings("");
    World world = wc.createWorld();
    world.setAutoSave(false);
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
public void createWorld() {
    if (!name.isPresent()) {
        throw new UnsupportedOperationException("You must supply a name if you want to create a world using a nameless creator: " + this);
    }
    WorldCreator creator = new WorldCreator(name.get());
    creator.environment(dimension.toEnvironment());
    creator.type(type);
    creator.seed(seed.orElseGet(() -> new Random().nextLong()));
    generator.ifPresent(creator::generator);
    creator.generatorSettings(generatorSettings);
    creator.generateStructures(structures);
    creator.createWorld();
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
private World createBukkitWorld(String name, long seed, String generator, Environment env, WorldType type, boolean genStructures, boolean providedSeed) {
    WorldCreator c = new WorldCreator(name);
    if(providedSeed) {
        c.seed(seed);
    }

    if(generator != null) {
        c.generator(generator);
    }

    c.environment(env);
    c.type(type);
    c.generateStructures(genStructures);
    return c.createWorld();
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
private void loadBukkitWorld(WorldData world) {
    WorldCreator c = new WorldCreator(world.getName());
    c.seed(world.getSeed());
    if(world.hasGenerator()) {
        c.generator(world.getGenerator());
    }

    c.environment(world.getEnvironment());
    c.type(world.getType());
    c.generateStructures(world.generateStructures());
    c.createWorld();
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
public void create_cmd() throws CivException {
	String name = getNamedString(1, "enter a world name");
	
	WorldCreator wc = new WorldCreator(name);
	wc.environment(Environment.NORMAL);
	wc.type(WorldType.FLAT);
	wc.generateStructures(false);
	
	World world = Bukkit.getServer().createWorld(wc);
	world.setSpawnFlags(false, false);
	ChunkCoord.addWorld(world);
	
	CivMessage.sendSuccess(sender, "World "+name+" created.");
	
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
public WorldCreator getWorldCreator(String name) {

        WorldCreator worldCreator = new WorldCreator(name);
        worldCreator.environment(environment);
        worldCreator.generateStructures(generateStructures);
        worldCreator.type(worldType);
        // worldCreator.seed(randomSeed());

        return worldCreator;
    }
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
public SGWorld(String name, String map) {
	this.name = name;
	displayName = map;

	wc = new WorldCreator(name);
	wc.environment(World.Environment.NORMAL);
	wc.type(WorldType.NORMAL);
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
@Override
protected World generateWorld()
{
    if (!TFM_ConfigEntry.GENERATE_FLATLANDS.getBoolean())
    {
        return null;
    }

    wipeFlatlandsIfFlagged();

    WorldCreator worldCreator = new WorldCreator(WORLD_NAME);
    worldCreator.generateStructures(false);
    worldCreator.type(WorldType.NORMAL);
    worldCreator.environment(World.Environment.NORMAL);
    worldCreator.generator(new CleanroomChunkGenerator(GENERATION_PARAMETERS));

    World world = Bukkit.getServer().createWorld(worldCreator);

    world.setSpawnFlags(false, false);
    world.setSpawnLocation(0, 50, 0);

    Block welcomeSignBlock = world.getBlockAt(0, 50, 0);
    welcomeSignBlock.setType(Material.SIGN_POST);
    org.bukkit.block.Sign welcomeSign = (org.bukkit.block.Sign) welcomeSignBlock.getState();

    org.bukkit.material.Sign signData = (org.bukkit.material.Sign) welcomeSign.getData();
    signData.setFacingDirection(BlockFace.NORTH);

    welcomeSign.setLine(0, ChatColor.GREEN + "Flatlands");
    welcomeSign.setLine(1, ChatColor.DARK_GRAY + "---");
    welcomeSign.setLine(2, ChatColor.YELLOW + "Spawn Point");
    welcomeSign.setLine(3, ChatColor.DARK_GRAY + "---");
    welcomeSign.update();

    TFM_GameRuleHandler.commitGameRules();

    return world;
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
public World create(org.bukkit.WorldType type) {
    if (type == null) {
        type = org.bukkit.WorldType.NORMAL;
    }
    try {
        if (WorldUtil.isLoaded(this.worldName) != null || WorldUtil.exists(this.worldName) != null) {
            throw new IllegalStateException("World already exists");
        }
    } catch (final IOException e) {
        return null;
    }
    final WorldCreator creator = new WorldCreator(this.worldName);
    creator.seed(this.getSeed());
    creator.type(type);
    switch (this.type) {
        case ADDITIONAL:
        case STOCK:
            creator.environment(World.Environment.NORMAL);
            break;
        case ADDITIONAL_SUB_NETHER:
        case STOCK_NETHER:
            creator.environment(World.Environment.NETHER);
            break;
        case ADDITIONAL_SUB_END:
        case STOCK_END:
            creator.environment(World.Environment.THE_END);
            break;
        default:
            throw new IllegalStateException("Incorrect world type: " + this.type);
    }
    final World result = creator.createWorld();
    this.setSpawnLocation(result.getSpawnLocation());
    return result;
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
@Override
public void loadWorld(String world, int flags) {
	WorldCreator create = new WorldCreator(world);
	switch (flags & ENV_FLAGS) {
	case NETHER_FLAG:
		create.environment(Environment.NETHER);
		break;
	case END_FLAG:
		create.environment(Environment.THE_END);
		break;
	case 0:
		create.environment(Environment.NORMAL);
		break;
	default:
		throw new IllegalArgumentException("Illegal env flag passed");
	}
	
	switch (flags & TYPE_FLAGS) {
	case FLAT_FLAG:
		create.type(WorldType.FLAT);
		break;
	case LARGE_BIOME_FLAG:
		create.type(WorldType.LARGE_BIOMES);
		break;
	case 0:
		create.type(WorldType.NORMAL);
		break;
	default:
		throw new IllegalArgumentException("Illegal type flag passed");
	}
	
	create.createWorld();
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
@Override
public boolean onCommand(CommandSender sender, Command arg1,
		String arg2, String[] args) {

	Object[] params = {"", 
					   String.valueOf(new Random().nextLong()), 
					   WorldType.NORMAL, 
					   Environment.NORMAL,
					   true};
	
	if(args.length > 0){
		if(args.length > params.length){
			sender.sendMessage(ChatColor.RED + "Too many arguments were provided!");
		} else {
			for(int index = (args.length - 1); index > -1; index--){
				Object obj = getParameters().get(index).getParameterValue(args[index]);
				if(obj != null){
					params[index] = obj;
				} else {
					sender.sendMessage(ChatColor.RED + "Invalid parameter supplied at index " + index);
					return false;
				}
			}
		
            if(!WorldManagerHelper.isWorldFolder(new File(Bukkit.getWorldContainer(), (String) params[0]))){
            	
                WorldCreator creator = new WorldCreator((String) params[0]);
                
                String seedStr = (String) params[1];
                long seed = seedStr.hashCode();
                try {
                	seed = Long.valueOf(seedStr);
                } catch (NumberFormatException e){}
             
                creator.seed(seed);
                creator.type((WorldType) params[2]);
                creator.environment((Environment) params[3]);
                creator.generateStructures((boolean) params[4]);

                sender.sendMessage("Generating world");
                creator.createWorld().save();
                //Bukkit.getLogger().info("Generator String: " + creator.generatorSettings());
                sender.sendMessage("Done generating world");
                return true;
            } else {
            	sender.sendMessage(ChatColor.RED + "That world already exists. You must delete the world before creating a new world with the same name!");
            }
		}
	} else {
		sender.sendMessage(ChatColor.RED + "You must provide at least a world name");
	}
       
       return false;
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
/**
 * Create a New World
 *
 * @param wname         the name of the world as a {@link java.lang.String}
 * @param worldType     the world type {@link org.bukkit.WorldType}
 * @param environment   the world {@link org.bukkit.World.Environment}
 * @param genStructures {@link java.lang.Boolean} true to generate
 *                      structures
 * @param genSettings   the generator settings as a {@link java.lang.String}
 * @param theSeed       the seed for the world
 * @return the newly created {@link org.bukkit.World}
 */
public World createNew(String wname, WorldType worldType, World.Environment environment, boolean genStructures, String genSettings, long theSeed) {

    WorldCreator wc = getCreator(wname);
    wc.type(worldType);
    wc.environment(environment);
    wc.generateStructures(genStructures);
    wc.generator(genSettings);
    wc.seed(theSeed);

    return wc.createWorld();
}