net.minecraft.world.gen.feature.WorldGenMinable Java Examples

public void addOreSpawn(Block block, byte blockMeta, Block targetBlock, World world, Random random, int blockXPos,
        int blockZPos, int minVeinSize, int maxVeinSize, int chancesToSpawn, int minY, int maxY, boolean restrictBiome) {
    WorldGenMinable minable = new WorldGenMinable(block.getStateFromMeta(blockMeta),
            (minVeinSize + random.nextInt(maxVeinSize - minVeinSize + 1)), BlockStateMatcher.forBlock(targetBlock));
    for (int i = 0; i < chancesToSpawn; i++) {
        int posX = blockXPos + random.nextInt(16);
        int posY = minY + random.nextInt(maxY - minY);
        int posZ = blockZPos + random.nextInt(16);

        BlockPos plannedPosition = new BlockPos(posX, posY, posZ);

        Biome blockBiome = world.getBiome(plannedPosition);

        for (Biome biome : validBiomes) {
            if (biome == blockBiome || !restrictBiome) {
                minable.generate(world, random, new BlockPos(posX, posY, posZ));
                break;
            }
        }
    }
}
 

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

	Predicate<IBlockState> predicate = null;
	if(DimensionManager.getInstance().isDimensionCreated(world.provider.getDimension()))
	{
		IBlockState state = ((DimensionProperties)DimensionManager.getInstance().getDimensionProperties(world.provider.getDimension())).getStoneBlock();
		if(state != null)
			predicate = new CustomPredicate(state);
	}
	
	for(int i = 0; i < numPerChunk; i++) {
		int coordX = 16*chunkX + random.nextInt(16);
		int coordY = heightLevel + random.nextInt(difference);
		int coordZ = 16*chunkZ + random.nextInt(16);

		if(predicate != null)
			new WorldGenMinable(oreToGen, clumpSize, predicate).generate(world, random, new BlockPos(coordX, coordY, coordZ));
		else
			new WorldGenMinable(oreToGen, clumpSize).generate(world, random, new BlockPos(coordX, coordY, coordZ));
	}

}
 

/** rare ore generator **/
public static void generateRareVein(Block block, boolean generate, int blockAmount, int chancesToSpawn,
		int minHeight, int maxHeight, Block blockToReplace, World world, Random rand, int chunkX, int chunkZ) {
	if (generate) {
		WorldGenMinable generator = new WorldGenMinable(block.getDefaultState(), blockAmount, BlockMatcher.forBlock(blockToReplace));
		int heightdiff = maxHeight - minHeight + 1;
		for (int i = 0; i < chancesToSpawn; i++) {
			int var1 = rand.nextInt(1024);
			if (var1 == 0) {
				int x = chunkX * 16 + rand.nextInt(16);
				int y = minHeight + rand.nextInt(heightdiff);
				int z = chunkZ * 16 + rand.nextInt(16);
				generator.generate(world, rand, new BlockPos(x, y, z));
			}
		}
	}
}
 

@Override
public void generate(Random random, int chunkX, int chunkZ, World world,
    IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
    if (ValkyrienSkiesWorld.OREGEN_ENABLED && VSConfig.valkyriumSpawnRate > 0) {
        if (this.genValkyriumOre == null) {
            this.genValkyriumOre = new WorldGenMinable(
                ValkyrienSkiesWorld.INSTANCE.valkyriumOre.getDefaultState(), 8);
        }
        switch (world.provider.getDimension()) {
            case 0: //Overworld
                this.runValkyriumGenerator(this.genValkyriumOre, world, random, chunkX, chunkZ, VSConfig.valkyriumSpawnRate,
                    0, 25);
                // runDungeonGenerator(world, random, chunkX, chunkZ, 1);
                break;
            case -1: //Nvalkyrium
                break;
            case 1: //End
                break;
        }
    }
}
 

@SubscribeEvent
public void onOreGen(OreGenEvent.Post event) {
	World worldIn = event.getWorld();
       int genY = 10 + event.getRand().nextInt(24);
	if (SakuraConfig.every_where_sakura_diamond||(worldIn.getBiome(new BlockPos(event.getPos().getX(), 0, event.getPos().getZ())) == SakuraBiomes.BAMBOOFOREST ||
		worldIn.getBiome(new BlockPos(event.getPos().getX(), 0, event.getPos().getZ())) == SakuraBiomes.MAPLEFOREST)) {
		BlockPos pos=new BlockPos(event.getPos().getX(),genY, event.getPos().getZ());
               for (int i = 0; i < 2; i++) {
                   new WorldGenMinable(BlockLoader.SAKURA_DIAMOND_ORE.getDefaultState(),3 + event.getRand().nextInt(5)).generate(worldIn, event.getRand(), pos);
               }
       }
}
 

protected void genStandardOre(WorldGenMinable gen, WorldGenInfo info, World world, Random random, int x, int z) {
	for (int l = 0; l < info.amount; ++l) {
		if (random.nextDouble() < info.chance) {
			int avgX = x + random.nextInt(16);
			int avgY = info.minY + random.nextInt(info.maxY - info.minY) + 1;
			int avgZ = z + random.nextInt(16);
			gen.generate(world, random, avgX, avgY, avgZ);
		}
	}
}
 

@Override
public void generate(Random random, int chunkX, int chunkZ, World world,
		IChunkGenerator chunkGenerator, IChunkProvider chunkProvider) {
	
	OreGenEvent event = new OreGenEvent.GenerateMinable(world, random, this, new BlockPos(chunkX,0,chunkZ), EventType.CUSTOM);
	MinecraftForge.ORE_GEN_BUS.post(event);
	if(event.getResult() != Result.DENY) {
		if(Configuration.generateCopper) {
			generate(world, MaterialRegistry.getMaterialFromName("Copper"), Configuration.copperPerChunk, Configuration.copperClumpSize, chunkX, chunkZ, random);
		}

		if(Configuration.generateTin) {
			generate(world, MaterialRegistry.getMaterialFromName("Tin"), Configuration.tinPerChunk, Configuration.tinClumpSize, chunkX, chunkZ, random);
		}
		if(Configuration.generateRutile) {
			generate(world, MaterialRegistry.getMaterialFromName("Rutile"), Configuration.rutilePerChunk, Configuration.rutileClumpSize, chunkX, chunkZ, random);
		}
		if(Configuration.generateAluminum) {
			generate(world, MaterialRegistry.getMaterialFromName("Aluminum"), Configuration.aluminumPerChunk, Configuration.aluminumClumpSize, chunkX, chunkZ, random);
		}
		if(Configuration.generateIridium) {
			generate(world, MaterialRegistry.getMaterialFromName("Iridium"), Configuration.IridiumPerChunk, Configuration.IridiumClumpSize, chunkX, chunkZ, random);
		}

		if(Configuration.generateDilithium) {
			int dilithiumChance = Configuration.dilithiumPerChunk;
			if(world.provider instanceof WorldProviderPlanet) {
				dilithiumChance = DimensionProperties.AtmosphereTypes.getAtmosphereTypeFromValue(DimensionManager.getInstance().getDimensionProperties(world.provider.getDimension()).getAtmosphereDensity()) == DimensionProperties.AtmosphereTypes.NONE ? Configuration.dilithiumPerChunkMoon : Configuration.dilithiumPerChunk;;
			}
			
			for(int i = 0; i < dilithiumChance; i++) {
				int coordX = 16*chunkX + random.nextInt(16);
				int coordY = random.nextInt(64);
				int coordZ = 16*chunkZ + random.nextInt(16);

				new WorldGenMinable(MaterialRegistry.getMaterialFromName("Dilithium").getBlock().getDefaultState(), Configuration.dilithiumClumpSize).generate(world, random, new BlockPos(coordX, coordY, coordZ));
			}
		}
	}
}
 

private void generate(World world, Material material, int numPerChunk,int clumpSize, int chunkX, int chunkZ, Random random) {
	for(int i = 0; i < numPerChunk; i++) {
		int coordX = 16*chunkX + random.nextInt(16);
		int coordY = random.nextInt(64);
		int coordZ = 16*chunkZ + random.nextInt(16);

		Block block = Block.getBlockFromItem(material.getProduct(AllowedProducts.getProductByName("ORE")).getItem());

		new WorldGenMinable(block.getStateFromMeta(material.getMeta()),
				clumpSize).generate(world, random, new BlockPos(coordX, coordY, coordZ));
	}
}
 

private void generateOre(World world, Random rand, int chunkX, int chunkZ) {
    for (int k = 0; k < TICKET; k++) {
        int x = chunkX * 16 + rand.nextInt(16);
        int y = rand.nextInt(MAX_HEIGHT);
        int z = chunkZ * 16 + rand.nextInt(16);

        new WorldGenMinable(GEN_BLOCK, GEN_SIZE).generate(world, rand, new BlockPos(x, y, z));
    }
}
 

public OreGen(String name, IBlockState state, int maxVeinSize, Block replaceTarget, int minY, int maxY, int chunkOccurence, int weight) {
	this.name = name;
	this.ore = new WorldGenMinable(state, maxVeinSize, BlockMatcher.forBlock(replaceTarget));
	this.minY = minY;
	this.maxY = maxY;
	this.chunkOccurence = chunkOccurence;
	this. weight = weight;
}
 

public void addOreSpawn(Block block, byte blockMeta, Block targetBlock, World world, Random random, int blockXPos, int blockZPos, int minVeinSize, int maxVeinSize, int chancesToSpawn, int minY, int maxY) {
    WorldGenMinable minable = new WorldGenMinable(block.getStateFromMeta(blockMeta), (minVeinSize + random.nextInt(maxVeinSize - minVeinSize + 1)), BlockMatcher.forBlock(targetBlock));
    for (int i = 0 ; i < chancesToSpawn ; i++) {
        int posX = blockXPos + random.nextInt(16);
        int posY = minY + random.nextInt(maxY - minY);
        int posZ = blockZPos + random.nextInt(16);
        minable.generate(world, random, new BlockPos(posX, posY, posZ));
    }
}
 

/** default ore generator **/
public static void generateBasicVein(Block block, boolean generate, int blockAmount, int chancesToSpawn,
		int minHeight, int maxHeight, Block blockToReplace, World world, Random rand, int chunkX, int chunkZ) {
	if (generate) {
		WorldGenMinable generator = new WorldGenMinable(block.getDefaultState(), blockAmount, BlockMatcher.forBlock(blockToReplace));
		int heightdiff = maxHeight - minHeight + 1;
		for (int i = 0; i < chancesToSpawn; i++) {
			int x = chunkX * 16 + rand.nextInt(16);
			int y = minHeight + rand.nextInt(heightdiff);
			int z = chunkZ * 16 + rand.nextInt(16);
			generator.generate(world, rand, new BlockPos(x, y, z));
		}
	}
}
 

private void generateOre(World world, Random random, int x, int z) {
    if (world.provider instanceof WorldProviderSurface) {
        for (int i = 0; i < 9; i++) {
            int genX = x + random.nextInt(16);
            int genY = 10 + random.nextInt(60);
            int genZ = z + random.nextInt(16);
            new WorldGenMinable(
                    BlockLoader.TOFUGEM_ORE.getDefaultState(), 3 + random.nextInt(6)).generate(world, random, new BlockPos(genX, genY, genZ));
        }
    }
}
 

public QuantumOreGenerator()
{
    m_oreGen = new WorldGenMinable( QCraft.Blocks.quantumOre, 5 );
}
 

public EtFuturumWorldGenerator() {
	generators.add(new WorldGenMinable(ModBlocks.stone, 1, EtFuturum.maxStonesPerCluster, Blocks.stone));
	generators.add(new WorldGenMinable(ModBlocks.stone, 3, EtFuturum.maxStonesPerCluster, Blocks.stone));
	generators.add(new WorldGenMinable(ModBlocks.stone, 5, EtFuturum.maxStonesPerCluster, Blocks.stone));
}
 

public void addFeature(Block block, int count, int amount, int minY, int maxY, double chance) {
	map.put(new WorldGenMinable(block, count), new WorldGenInfo(amount, minY, maxY, chance));
}
 

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) {
	for (WorldGenMinable gen : map.keySet()) {
		genStandardOre(gen, map.get(gen), world, random, chunkX * 16, chunkZ * 16);
	}
}
 

public GeneratorLimestone(Block block, int count, int am)
{
    gen = new WorldGenMinable(block, count);
    amount = am;
}
 

public GeneratorMarble(Block block, int count, int am)
{
    gen = new WorldGenMinable(block, count);
    amount = am;
}