java类net.minecraft.world.chunk.IChunkGenerator的实例源码

/**
 * Callback hook for world gen - if your mod wishes to add extra mod related generation to the world
 * call this
 *
 * @param chunkX         Chunk X coordinate
 * @param chunkZ         Chunk Z coordinate
 * @param world          World we're generating into
 * @param chunkGenerator The chunk generator
 * @param chunkProvider  The chunk provider
 */
public static void generateWorld(int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider)
{
    if (sortedGeneratorList == null)
    {
        computeSortedGeneratorList();
    }
    long worldSeed = world.getSeed();
    Random fmlRandom = new Random(worldSeed);
    long xSeed = fmlRandom.nextLong() >> 2 + 1L;
    long zSeed = fmlRandom.nextLong() >> 2 + 1L;
    long chunkSeed = (xSeed * chunkX + zSeed * chunkZ) ^ worldSeed;

    for (IWorldGenerator generator : sortedGeneratorList)
    {
        fmlRandom.setSeed(chunkSeed);
        generator.generate(fmlRandom, chunkX, chunkZ, world, chunkGenerator, chunkProvider);
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    if (Config.enableOreGen) {
        final BlockPos chunkPos = new BlockPos(chunkX * 16, 0, chunkZ * 16);

        switch (world.provider.getDimensionType()) {
            case OVERWORLD:
                for (int i = 0; i < Config.niterPerChunk; i++) {
                    oreGenNiter.generate(world, random, chunkPos.add(random.nextInt(16), random.nextInt(32) + 16, random.nextInt(16)));
                }
                for (int i = 0; i < Config.saltPerChunk; i++) {
                    oreGenSalt.generate(world, random, chunkPos.add(random.nextInt(16), random.nextInt(64) + 32, random.nextInt(16)));
                }
                for (int i = 0; i < Config.sulfurPerChunk; i++) {
                    oreGenSulfur.generate(world, random, chunkPos.add(random.nextInt(16), random.nextInt(24), random.nextInt(16)));
                }
                break;
            case NETHER:
                break;
            case THE_END:
                break;
        }
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    int x = chunkX * 16;
    int z = chunkZ * 16;
    switch (world.provider.getDimension()) {
        case -1:
            nether(random, x, z, world);
            break;
        case 0:
            world(random, x, z, world);
            break;
        case 1:
            end(random, x, z, world);
            break;
        default:
            if (!blackList.contains(world.provider.getDimension()))
                other(random, x, z, world);
            break;
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator,
                     IChunkProvider chunkProvider) {

    switch (world.provider.getDimension()) {
        case -1: //Nether

            break;
        case 1: //End

            break;
        default:
            if (PrimordialConfig.enableOreSpawn) {
                this.runGenerator(this.MinicioOre, world, random, chunkX, chunkZ, PrimordialConfig.oreSpawnChance, PrimordialConfig.oreSpawnMinZ, PrimordialConfig.oreSpawnMaxZ);
            }
            break;
    }

}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator,
        IChunkProvider chunkProvider) {

    switch (world.provider.getDimension()) {
    case 0:
        this.runGenerator(this.hemp, world, random, chunkX, chunkZ, 3);
        this.runGenerator(this.indica, world, random, chunkX, chunkZ, 1);
        this.runGenerator(this.sativa, world, random, chunkX, chunkZ, 1);
        break;
    case -1: // Nether
        break;
    case 1: // End
        break;
    default:
        break;
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider)
{
    int dimId = world.provider.getDimension();
    switch(dimId)
    {
        case -1:
            //Nether
            genNether(world, random, chunkX,  chunkZ);
            break;
        case 1:
            //End
            genEnd(world, random, chunkX,  chunkZ);
            break;
        default:
            //Overworld and other dimensions in the config
            for(int id : Config.plantGenDimIDs)
                if(dimId == id)
                {
                    genOverworld(world, random, chunkX, chunkZ);
                    break;
                }
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator,
        IChunkProvider chunkProvider) {
    for (int i = 0; i < 25; i++)
    {
        int x = chunkX * 16 + random.nextInt(16);
        int z = chunkZ * 16 + random.nextInt(16);

        BlockPos pos = world.getHeight(new BlockPos(x, 0, z));

        if (world.getBlockState(pos).getBlock() instanceof BlockTallGrass)
        {
            world.setBlockState(pos, ARKCraftBlocks.berryBush.getDefaultState());
        }
    }
}

@Override
public void generate(Random randomDefault, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    if (!allowedDimensions.contains(world.provider.getDimension())) {
        return; // Dimension with given id is not allowed
    }
    Random random = getRandom(world.getSeed(), chunkX, chunkZ);
    int drops = (int) density + (random.nextDouble() <= (density - (int) density) ? 1 : 0);
    net.minecraft.world.biome.Biome biome = world.getBiomeGenForCoords(new BlockPos(chunkX * 16, 64, chunkZ * 16));
    Biome.Style biomeStyle = Biome.determine(biome);
    ArrayList<Cluster> biomeClusters = distributor.getClusters(biomeStyle);
    for (int i = 0; i < drops; ++i) {
        double pointer = random.nextDouble();
        for (Cluster cluster : biomeClusters) {
            if (pointer <= cluster.getChance()) {
                place(world, cluster, chunkX, chunkZ, random.nextLong());
                break;
            }
            pointer -= cluster.getChance();
        }
    }
}

@Override
public void generate(Random randomDefault, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    if (!allowedDimensions.contains(world.provider.getDimension())) {
        return; // Dimension with given id is not allowed
    }
    Random random = getRandom(world.getSeed(), chunkX, chunkZ);
    int drops = (int) density + (random.nextDouble() <= (density - (int) density) ? 1 : 0);
    net.minecraft.world.biome.Biome biome = world.getBiomeGenForCoords(new BlockPos(chunkX * 16, 64, chunkZ * 16));
    Biome.Style biomeStyle = Biome.determine(biome);
    ArrayList<Cluster> biomeClusters = distributor.getClusters(biomeStyle);
    for (int i = 0; i < drops; ++i) {
        double pointer = random.nextDouble();
        for (Cluster cluster : biomeClusters) {
            if (pointer <= cluster.getChance()) {
                place(world, cluster, chunkX, chunkZ, random.nextLong());
                break;
            }
            pointer -= cluster.getChance();
        }
    }
}

@Override
public void generate(Random randomDefault, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    if (!allowedDimensions.contains(world.provider.getDimension())) {
        return; // Dimension with given id is not allowed
    }
    Random random = getRandom(world.getSeed(), chunkX, chunkZ);
    int drops = (int) density + (random.nextDouble() <= (density - (int) density) ? 1 : 0);
    net.minecraft.world.biome.Biome biome = world.getBiomeGenForCoords(new BlockPos(chunkX * 16, 64, chunkZ * 16));
    Biome.Style biomeStyle = Biome.determine(biome);
    ArrayList<Cluster> biomeClusters = distributor.getClusters(biomeStyle);
    for (int i = 0; i < drops; ++i) {
        double pointer = random.nextDouble();
        for (Cluster cluster : biomeClusters) {
            if (pointer <= cluster.getChance()) {
                place(world, cluster, chunkX, chunkZ, random.nextLong());
                break;
            }
            pointer -= cluster.getChance();
        }
    }
}

@Override
public void generate(Random randomDefault, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    if (!allowedDimensions.contains(world.provider.getDimension())) {
        return; // Dimension with given id is not allowed
    }
    Random random = getRandom(world.getSeed(), chunkX, chunkZ);
    int drops = (int) density + (random.nextDouble() <= (density - (int) density) ? 1 : 0);
    BiomeGenBase biome = world.getBiomeGenForCoords(new BlockPos(chunkX * 16, 64, chunkZ * 16));
    Biome.Style biomeStyle = Biome.determine(biome);
    ArrayList<Cluster> biomeClusters = distributor.getClusters(biomeStyle);
    for (int i = 0; i < drops; ++i) {
        double pointer = random.nextDouble();
        for (Cluster cluster : biomeClusters) {
            if (pointer <= cluster.getChance()) {
                place(world, cluster, chunkX, chunkZ, random.nextLong());
                break;
            }
            pointer -= cluster.getChance();
        }
    }
}

@Override
public void generate(Random rand, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) 
{
    int blockX = chunkX * 16;
    int blockZ = chunkZ * 16;

    switch (world.provider.getDimension())
    {
        case -1: 
            generateNether(world, rand, blockX, blockZ);
            break;
        case 0: 
            generateOverworld(world, rand, blockX, blockZ);
            break;
        case 1: 
            generateEnd(world, rand, blockX, blockZ);
            break;
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world,
                     IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {

    random.setSeed(random.nextLong() ^ hash);
    random.nextInt();
    final float r = random.nextFloat();
    for(float f = frequency; f > r; f -= 1 ){
        int x = (chunkX << 4) + random.nextInt(16);
           int y = random.nextInt(maxY - minY) + minY;
           int z = (chunkZ << 4) + random.nextInt(16);
       //    System.out.println("Generating deposite of "+ore.getUnlocalizedName()+" at ("+x+","+y+","+z+")");
        BlockPos pos = new BlockPos(x,y,z);
        OreGenEvent oreEvent = new OreGenEvent(world,random,pos);
        net.minecraftforge.common.MinecraftForge.ORE_GEN_BUS.post(oreEvent);
        if(oreEvent.getResult() == Event.Result.DENY) {
            // canceled by other mod
            continue;
        }
        oreGen.generate(world, random, pos);
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider)
{
    int xSpawn, ySpawn, zSpawn;
    int xPos = chunkX * 16 + 8, zPos = chunkZ * 16 + 8;

    String biomeName = world.getBiomeForCoordsBody(new BlockPos(xPos, 64, zPos)).getBiomeName();;

    if (biomeName == null) {
        return;
    }
    if (biomeName == "Forest" || biomeName == "AutumnWoods" || biomeName == "BirchForest" || biomeName == "PineForest" || biomeName == "Rainforest" || biomeName == "TemperateRainforest"
            || biomeName == "Woodlands" || biomeName == "Plains")
    {

            for (int iter = 0; iter < 3; iter++)
            {
                xSpawn = xPos + random.nextInt(16);
                ySpawn = random.nextInt(300) + 64;
                zSpawn = zPos + random.nextInt(16);
                genCherryTree.generate(world, random, new BlockPos(xSpawn, ySpawn, zSpawn));
            }


    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator,
        IChunkProvider chunkProvider) {
    switch (world.provider.getDimension()) {
    case 0: //Overworld
        // this.runGenerator(this.gen_tutorial_ore, world, random, chunkX, chunkZ, 20, 0, 64);
        break;
    case -1: //Nether

        break;
    case 1: //End

        break;
    }


}

private void generateBuilding(
    Random rand, int chunkX, int groundY, int chunkZ, int chunkSize, int towerFloors, 
    World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) 
{

    this.prepareSpace(world, chunkX, groundY, chunkZ, chunkSize, Blocks.AIR.getDefaultState());
    this.drawStandardRoads(world, chunkX, groundY, chunkZ, chunkSize);
    this.drawStandardSidewalks(world, chunkX, groundY, chunkZ, chunkSize);

    // Draw the tower   
    this.generateTower(rand, world, chunkX * 16 + 4, groundY + 1, chunkZ * 16 + 4, chunkSize - 8, chunkSize - 8, towerFloors);

}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    //System.out.println("Generating "+bs+" at "+chunkX+", "+chunkZ);
    int x = random.nextInt(16);
    int z = random.nextInt(16);
    BlockPos pos = new BlockPos((chunkX*16)+x,0,(chunkZ*16)+z);
    pos = world.getTopSolidOrLiquidBlock(pos);
    //pos = pos.up();
    generate(world, random, pos);
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    byte b = world.getChunkFromChunkCoords(chunkX, chunkZ).getBiomeArray()[0];
    FirmaTree[] tl = FirmaBiome.getTreeForBiome(b, chunkZ*16);
    if(tl.length==0){ return; }
    FirmaTree ft = tl[random.nextInt(tl.length)];
    FirmaBiome bi = (FirmaBiome) Biome.getBiome(b);
    for(int i = 0; i < bi.treeCount; i++){
        ft.generate(random, chunkX, chunkZ, world, chunkGenerator, chunkProvider);
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    count = 0;
    for (OresEnum ore : OresEnum.values()) {
        for (int i = 0; i < 3; i++) {
            if (random.nextInt(100) < ore.getRarity()) {
                new FirmaMinable(ore, random.nextInt(ore.getRarity() / 2) + ore.getRarity(), random.nextInt(5)).generate(world, random, chunkX, chunkZ);
            }
        }
    }
    // System.out.println(count+" ores added to this chunk");
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    for (int i = 0; i < random.nextInt(16); i++) {
        belowTree = false;
        int x = random.nextInt(16) + chunkX * 16;
        int z = random.nextInt(16) + chunkZ * 16;
        int y = world.getHeight();
        BlockPos pos = new BlockPos(x,y,z);
        while(!shitCheck(world, pos)) {
            pos = pos.down();
        }
        IBlockState b = world.getBlockState(pos);
        if (Util.isClay(b.getBlock()) || Util.isDirt(b.getBlock()) || Util.isGrass(b.getBlock()) || Util.isRawStone(b.getBlock())
                || Util.isSand(b.getBlock()) || Util.isGravel(b.getBlock()) && b.getBlock() instanceof BaseBlock) { // Sensible
                                                                                                                    // locations
                                                                                                                    // for
                                                                                                                    // shit
            BaseBlock bb = (BaseBlock) b.getBlock();
            String meta = bb.getMetaName(b.getBlock().getMetaFromState(b));
            pos = pos.up();
            world.setBlockState(pos, FirmaMod.shitOnFloor.getDefaultState(), 2);
            SoFTileEntity te = (SoFTileEntity) world.getTileEntity(pos);
            if (te != null) {
                te.setItem(getItemForArea(random,meta));
                te.markDirty();
            }
        }
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    switch (world.provider.getDimension()){
        case -1:
            break;
        case 0:
            this.runGenerator(this.gen_green_shard_ore, world, random, chunkX, chunkZ, 20,0, 60);
            break;
        case 1:
            break;
    }
}

public ReplaceBiomeBlocks(IChunkGenerator chunkProvider, int x, int z, ChunkPrimer primer, World world)
{
    super(chunkProvider);
    this.x = x;
    this.z = z;
    this.primer = primer;
    this.world = world;
}

public InitNoiseField(IChunkGenerator chunkProvider, double[] noisefield, int posX, int posY, int posZ, int sizeX, int sizeY, int sizeZ)
{
    super(chunkProvider);
    this.setNoisefield(noisefield);
    this.posX = posX;
    this.posY = posY;
    this.posZ = posZ;
    this.sizeX = sizeX;
    this.sizeY = sizeY;
    this.sizeZ = sizeZ;
}

public PopulateChunkEvent(IChunkGenerator gen, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated)
{
    super(gen);
    this.world = world;
    this.rand = rand;
    this.chunkX = chunkX;
    this.chunkZ = chunkZ;
    this.hasVillageGenerated = hasVillageGenerated;
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider)
{
    for (int i = 0; i < clusterCount; i++) {
        int x = chunkX * 16 + random.nextInt(16);
        int y = random.nextInt(16);
        int z = chunkZ * 16 + random.nextInt(16);

        generator.generate(world, random, new BlockPos(x, y, z));
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    for(IGenerationFeature feature : featureList){
        if (feature.generateFeature(world, random, chunkX, chunkZ, true)) {
            world.getChunkFromChunkCoords(chunkX, chunkZ).setChunkModified();
        }
    }
    boolean genSpikes = false;
    if(world.provider.getDimension() == 0 && genSpikes){
        crystexiumSpikeGen.generate(world, chunkX, chunkZ, null);
        crystexiumSpikeGen.generateStructure(world, random, new ChunkPos(chunkX, chunkZ));
    }        
}

public static IChunkGenerator getGenForWorld(DimData data, World worldIn, long seed, boolean mapFeaturesEnabledIn, String settings) {
    if (data.falt) {
        return new ChunkProviderFlat(worldIn, seed, mapFeaturesEnabledIn, "3;minecraft:bedrock,60*minecraft:stone,2*minecraft:dirt,minecraft:grass;3;village(size=50 distance=50),mineshaft(chance=0.5),biome_1,dungeon,decoration,lake,lava_lake");
    }
    //TODO get custom shit
    return new ChunkProviderOverworld(worldIn, seed, mapFeaturesEnabledIn, settings);
}

private void generatePool(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator,
        IChunkProvider chunkProvider) {
    //if(chunkX%(1000/16) != 0|| chunkZ%(1000/16) != 0) return;
    if(random.nextInt(1000)>100) return;
    int x = chunkX*16 + random.nextInt(16);
    int z = chunkZ*16 + random.nextInt(16);
    int y = world.getPrecipitationHeight(new BlockPos(x,0,z)).getY();
    for(int i=0; i<22; i++) {
        for(int j=0; j<22; j++) {
            world.setBlockState(new BlockPos(x+i,y,z+j), Blocks.CLAY.getDefaultState());
        }
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator,
    IChunkProvider chunkProvider) {
    for (TileEntity tileEntity : world.getChunkFromChunkCoords(chunkX, chunkZ).getTileEntityMap().values()) {
        if (tileEntity instanceof TileEntityMobSpawner) {
            MobSpawnerBaseLogic spawner = ((TileEntityMobSpawner) tileEntity).getSpawnerBaseLogic();
            if ("CaveSpider".equals(spawner.getEntityNameToSpawn()) && random.nextInt(4) == 0) {
                spawner.setEntityName("EnderSpider");
            }
        }
    }
}

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {

    switch (world.provider.getDimension()) {

        case -1:
            break;
        case 0:
            runGenerator(this.oreGen, world, random, chunkX, chunkZ, veinsPerChunk, minHeight, maxHeight);
            break;
        case 1:
            break;
    }
}