Java WorldCreator.seed方法代码示例

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包/类
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 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 World createWorld(WorldCreator creator) {
    Validate.notNull(creator, "Creator may not be null");

    String name = creator.name();
    ChunkGenerator generator = creator.generator();
    File folder = new File(getWorldContainer(), name);
    World world = getWorld(name);
    net.minecraft.world.WorldType type = net.minecraft.world.WorldType.parseWorldType(creator.type().getName());
    boolean generateStructures = creator.generateStructures();

    if ((folder.exists()) && (!folder.isDirectory())) {
        throw new IllegalArgumentException("File exists with the name '" + name + "' and isn't a folder");
    }

    if (world != null) {
        return world;
    }

    boolean hardcore = false;
    WorldSettings worldSettings = new WorldSettings(creator.seed(), net.minecraft.world.WorldSettings.GameType.getByID(getDefaultGameMode().getValue()), generateStructures, hardcore, type);
    net.minecraft.world.WorldServer worldserver = DimensionManager.initDimension(creator, worldSettings);

    pluginManager.callEvent(new WorldInitEvent(worldserver.getWorld()));
    net.minecraftforge.cauldron.CauldronHooks.craftWorldLoading = true;
    System.out.print("Preparing start region for level " + (console.worlds.size() - 1) + " (Dimension: " + worldserver.provider.dimensionId + ", Seed: " + worldserver.getSeed() + ")"); // Cauldron - log dimension

    if (worldserver.getWorld().getKeepSpawnInMemory()) {
        short short1 = 196;
        long i = System.currentTimeMillis();
        for (int j = -short1; j <= short1; j += 16) {
            for (int k = -short1; k <= short1; k += 16) {
                long l = System.currentTimeMillis();

                if (l < i) {
                    i = l;
                }

                if (l > i + 1000L) {
                    int i1 = (short1 * 2 + 1) * (short1 * 2 + 1);
                    int j1 = (j + short1) * (short1 * 2 + 1) + k + 1;

                    System.out.println("Preparing spawn area for " + worldserver.getWorld().getName() + ", " + (j1 * 100 / i1) + "%");
                    i = l;
                }

                net.minecraft.util.ChunkCoordinates chunkcoordinates = worldserver.getSpawnPoint();
                worldserver.theChunkProviderServer.loadChunk(chunkcoordinates.posX + j >> 4, chunkcoordinates.posZ + k >> 4);
            }
        }
    }
    pluginManager.callEvent(new WorldLoadEvent(worldserver.getWorld()));
    net.minecraftforge.cauldron.CauldronHooks.craftWorldLoading = false;
    return worldserver.getWorld();
}
 

import org.bukkit.WorldCreator; //导入方法依赖的package包/类
@Override
public void configureWorld(WorldCreator worldCreator) {
    worldCreator.generator(vanilla ? null : new NullChunkGenerator());
    worldCreator.seed(seed);
}
 

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