[1.8] Blocks won't generate in world?

[Ms_Raven]

I'm trying to get a block to randomly generate on the surface of the world. But it just won't generate.

 

Could someone explain why?

 

 

  Reveal hidden contents

public class Generation implements IWorldGenerator

{

 

@Override

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

{

switch (world.provider.getDimensionId())

{

case -1:

break;

case 0:

generateSurface(world, random, chunkX * 16, chunkZ * 16);

break;

case 1:

break;

}

}

 

private void generateInEnd(World world, Random random, int x, int z)

{

 

}

 

private void generateSurface(World world, Random random, int x, int z)

{

for(int i = 0; i < 10; i++)

{

int chunkX = x + random.nextInt(16);

int chunkZ = z + random.nextInt(16);

int chunkY = getHeightValue(world, chunkX, chunkZ);

 

BlockPos pos = new BlockPos(chunkX, chunkY, chunkZ);

(new WorldGenMinable(BlockReg.crate.getDefaultState(), 1)).generate(world, random, pos);

}

for(int i = 0; i < 1; i++)

{

int chunkX = x + random.nextInt(16);

int chunkZ = z + random.nextInt(16);

int chunkY = getHeightValue(world, chunkX, chunkZ);

 

BlockPos pos = new BlockPos(chunkX, chunkY, chunkZ);

(new WorldGenMinable(BlockReg.metalCrate.getDefaultState(), 1)).generate(world, random, pos);

}

}

private void generateInNether(World world, Random random, int x, int z)

{

 

}

 

 

 

 

public static int getHeightValue(World world, int x, int z)

{

int chunkX = x >> 4;

int chunkZ = z >> 4;

int height = world.getChunkFromChunkCoords(chunkX, chunkZ).getHeight(x & 15, z & 15);

 

return height;

}

public static double getHeightValue(World world, double parX, double parZ)

{

int intX = MathHelper.floor_double(parX);

int intZ = MathHelper.floor_double(parZ);

 

int chunkX = intX >> 4;

int chunkZ = intZ >> 4;

double height = world.getChunkFromChunkCoords(chunkX, chunkZ).getHeight(intX & 15, intZ & 15);

 

return height;

}

 

}

 

 

[Frontsalat]

Here's my world generator code...compare to your own...

 

 

  Reveal hidden contents

package com.mofakin.materialevolution;

import java.util.Random;

import net.minecraft.world.World;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.feature.WorldGenMinable;
import cpw.mods.fml.common.IWorldGenerator;

public class MaterialEvolutionWorldGenerator implements IWorldGenerator {

@Override
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) {
	switch(world.provider.dimensionId){
	case -1:
	    generateNether(world, random, chunkX * 16, chunkZ * 16);
	    break;
	case 0:
	    generateSurface(world, random, chunkX * 16, chunkZ * 16);
	    break;
	case 1:
	    generateEnd(world, random, chunkX * 16, chunkZ * 16);
	    break;
	}

}

private void generateEnd(World world, Random random, int i, int j) {

}

private void generateSurface(World world, Random random, int i, int j) {
	for(int k = 0; k < 3; k++) { // 1 = how many veins are there per chunk

		int BlockAntimonyXCoord = i + random.nextInt(16);
		int BlockAntimonyYCoord = random.nextInt(128); // ore level 0-128
		int BlockAntimonyZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAntimony, 2)).generate(world, random, BlockAntimonyXCoord, BlockAntimonyYCoord, BlockAntimonyZCoord);
	    															// 1 = number of blocks per vein
	} // for more then one block generation, copy and paste the for loop, change integer k to something different

	for(int l = 0; l < 7; l++) {

		int BlockStibniteXCoord = i + random.nextInt(16);
		int BlockStibniteYCoord = random.nextInt(128);
		int BlockStibniteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockStibnite, ).generate(world, random, BlockStibniteXCoord, BlockStibniteYCoord, BlockStibniteZCoord);
	    								
	}

	for(int m = 0; m < 8; m++) {

		int BlockBlackcoalXCoord = i + random.nextInt(16);
		int BlockBlackcoalYCoord = random.nextInt(128);
		int BlockBlackcoalZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBlackcoal, 10)).generate(world, random, BlockBlackcoalXCoord, BlockBlackcoalYCoord, BlockBlackcoalZCoord);
	    								
	}

	for(int n = 0; n < 6; n++) {

		int BlockBrowncoalXCoord = i + random.nextInt(16);
		int BlockBrowncoalYCoord = random.nextInt(128);
		int BlockBrowncoalZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBrowncoal, ).generate(world, random, BlockBrowncoalXCoord, BlockBrowncoalYCoord, BlockBrowncoalZCoord);
	    								
	}

	for(int o = 0; o < 5; o++) {

		int BlockAzuriteXCoord = i + random.nextInt(16);
		int BlockAzuriteYCoord = random.nextInt(128);
		int BlockAzuriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAzurite, 3)).generate(world, random, BlockAzuriteXCoord, BlockAzuriteYCoord, BlockAzuriteZCoord);
	    								
	}

	for(int p = 0; p < 8; p++) {

		int BlockChalcopyriteXCoord = i + random.nextInt(16);
		int BlockChalcopyriteYCoord = random.nextInt(128);
		int BlockChalcopyriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockChalcopyrite, 12)).generate(world, random, BlockChalcopyriteXCoord, BlockChalcopyriteYCoord, BlockChalcopyriteZCoord);
	    								
	}

	for(int q = 0; q < 3; q++) {

		int BlockCopperXCoord = i + random.nextInt(16);
		int BlockCopperYCoord = random.nextInt(128);
		int BlockCopperZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCopper, 3)).generate(world, random, BlockCopperXCoord, BlockCopperYCoord, BlockCopperZCoord);
	    								
	}

	for(int r = 0; r < 3; r++) {

		int BlockMalachiteXCoord = i + random.nextInt(16);
		int BlockMalachiteYCoord = random.nextInt(128);
		int BlockMalachiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockMalachite, 3)).generate(world, random, BlockMalachiteXCoord, BlockMalachiteYCoord, BlockMalachiteZCoord);
	    								
	}

	for(int s = 0; s < 3; s++) {

		int BlockCalaveriteXCoord = i + random.nextInt(16);
		int BlockCalaveriteYCoord = random.nextInt(128);
		int BlockCalaveriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCalaverite, 3)).generate(world, random, BlockCalaveriteXCoord, BlockCalaveriteYCoord, BlockCalaveriteZCoord);
	    								
	}

	for(int t = 0; t < 1; t++) {

		int BlockGoldXCoord = i + random.nextInt(16);
		int BlockGoldYCoord = random.nextInt(128);
		int BlockGoldZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockGold, 2)).generate(world, random, BlockGoldXCoord, BlockGoldYCoord, BlockGoldZCoord);
	    								
	}

	for(int u = 0; u < 8; u++) {

		int BlockHaematiteXCoord = i + random.nextInt(16);
		int BlockHaematiteYCoord = random.nextInt(128);
		int BlockHaematiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockHaematite, 10)).generate(world, random, BlockHaematiteXCoord, BlockHaematiteYCoord, BlockHaematiteZCoord);
	    								
	}

	for(int v = 0; v < 2; v++) {

		int BlockMagnetiteXCoord = i + random.nextInt(16);
		int BlockMagnetiteYCoord = random.nextInt(128);
		int BlockMagnetiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockMagnetite, 3)).generate(world, random, BlockMagnetiteXCoord, BlockMagnetiteYCoord, BlockMagnetiteZCoord);
	    								
	}

	for(int w = 0; w < 5; w++) {

		int BlockBogironXCoord = i + random.nextInt(16);
		int BlockBogironYCoord = random.nextInt(128);
		int BlockBogironZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBogiron, 7)).generate(world, random, BlockBogironXCoord, BlockBogironYCoord, BlockBogironZCoord);
	    								
	}

	for(int x = 0; x < 8; x++) {

		int BlockBraunsteinXCoord = i + random.nextInt(16);
		int BlockBraunsteinYCoord = random.nextInt(128);
		int BlockBraunsteinZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBraunstein, 9)).generate(world, random, BlockBraunsteinXCoord, BlockBraunsteinYCoord, BlockBraunsteinZCoord);
	    								
	}

	for(int y = 0; y < 8; y++) {

		int BlockPyriteXCoord = i + random.nextInt(16);
		int BlockPyriteYCoord = random.nextInt(128);
		int BlockPyriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockPyrite, 9)).generate(world, random, BlockPyriteXCoord, BlockPyriteYCoord, BlockPyriteZCoord);
	    								
	}

	for(int z = 0; z < 5; z++) {

		int BlockIlmeniteXCoord = i + random.nextInt(16);
		int BlockIlmeniteYCoord = random.nextInt(128);
		int BlockIlmeniteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockIlmenite, 6)).generate(world, random, BlockIlmeniteXCoord, BlockIlmeniteYCoord, BlockIlmeniteZCoord);
	    								
	}

	for(int a = 0; a < 7; a++) {

		int BlockGalenaXCoord = i + random.nextInt(16);
		int BlockGalenaYCoord = random.nextInt(128);
		int BlockGalenaZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockGalena, 9)).generate(world, random, BlockGalenaXCoord, BlockGalenaYCoord, BlockGalenaZCoord);
	    								
	}

	for(int b = 0; b < 3; b++) {

		int BlockLeadXCoord = i + random.nextInt(16);
		int BlockLeadYCoord = random.nextInt(128);
		int BlockLeadZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockLead, 4)).generate(world, random, BlockLeadXCoord, BlockLeadYCoord, BlockLeadZCoord);
	    								
	}

	for(int c = 0; c < 5; c++) {

		int BlockCinnabarXCoord = i + random.nextInt(16);
		int BlockCinnabarYCoord = random.nextInt(128);
		int BlockCinnabarZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCinnabar, 6)).generate(world, random, BlockCinnabarXCoord, BlockCinnabarYCoord, BlockCinnabarZCoord);
	    								
	}

	for(int d = 0; d < 4; d++) {

		int BlockGarnieriteXCoord = i + random.nextInt(16);
		int BlockGarnieriteYCoord = random.nextInt(128);
		int BlockGarnieriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockGarnierite, 3)).generate(world, random, BlockGarnieriteXCoord, BlockGarnieriteYCoord, BlockGarnieriteZCoord);
	    								
	}

	for(int e = 0; e < 2; e++) {

		int BlockNickelXCoord = i + random.nextInt(16);
		int BlockNickelYCoord = random.nextInt(128);
		int BlockNickelZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockNickel, 2)).generate(world, random, BlockNickelXCoord, BlockNickelYCoord, BlockNickelZCoord);
	    								
	}

	for(int f = 0; f < 6; f++) {

		int BlockNickelineXCoord = i + random.nextInt(16);
		int BlockNickelineYCoord = random.nextInt(128);
		int BlockNickelineZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockNickeline, 5)).generate(world, random, BlockNickelineXCoord, BlockNickelineYCoord, BlockNickelineZCoord);
	    								
	}

	for(int g = 0; g < 1; g++) {

		int BlockPlatinumXCoord = i + random.nextInt(16);
		int BlockPlatinumYCoord = random.nextInt(128);
		int BlockPlatinumZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockPlatinum, 2)).generate(world, random, BlockPlatinumXCoord, BlockPlatinumYCoord, BlockPlatinumZCoord);
	    								
	}

	for(int h = 0; h < 2; h++) {

		int BlockAkanthiteXCoord = i + random.nextInt(16);
		int BlockAkanthiteYCoord = random.nextInt(128);
		int BlockAkanthiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAkanthite, 2)).generate(world, random, BlockAkanthiteXCoord, BlockAkanthiteYCoord, BlockAkanthiteZCoord);
	    								
	}

	for(int par1 = 0; par1 < 3; par1++) {

		int BlockSilverXCoord = i + random.nextInt(16);
		int BlockSilverYCoord = random.nextInt(128);
		int BlockSilverZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSilver, 4)).generate(world, random, BlockSilverXCoord, BlockSilverYCoord, BlockSilverZCoord);
	    								
	}

	for(int par2 = 0; par2 < 3; par2++) {

		int BlockStromeyeriteXCoord = i + random.nextInt(16);
		int BlockStromeyeriteYCoord = random.nextInt(128);
		int BlockStromeyeriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockStromeyerite, 4)).generate(world, random, BlockStromeyeriteXCoord, BlockStromeyeriteYCoord, BlockStromeyeriteZCoord);
	    								
	}

	for(int par3 = 0; par3 < 5; par3++) {

		int BlockCassiteriteXCoord = i + random.nextInt(16);
		int BlockCassiteriteYCoord = random.nextInt(128);
		int BlockCassiteriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCassiterite, 6)).generate(world, random, BlockCassiteriteXCoord, BlockCassiteriteYCoord, BlockCassiteriteZCoord);
	    								
	}

	for(int par4 = 0; par4 < 3; par4++) {

		int BlockStanniteXCoord = i + random.nextInt(16);
		int BlockStanniteYCoord = random.nextInt(128);
		int BlockStanniteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockStannite, 4)).generate(world, random, BlockStanniteXCoord, BlockStanniteYCoord, BlockStanniteZCoord);
	    								
	}

	for(int par5 = 0; par5 < 5; par5++) {

		int BlockSphaleriteXCoord = i + random.nextInt(16);
		int BlockSphaleriteYCoord = random.nextInt(128);
		int BlockSphaleriteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSphalerite, 6)).generate(world, random, BlockSphaleriteXCoord, BlockSphaleriteYCoord, BlockSphaleriteZCoord);
	    								
	}

	for(int par6 = 0; par6 < 3; par6++) {

		int BlockZinciteXCoord = i + random.nextInt(16);
		int BlockZinciteYCoord = random.nextInt(128);
		int BlockZinciteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockZincite, 4)).generate(world, random, BlockZinciteXCoord, BlockZinciteYCoord, BlockZinciteZCoord);
	    								
	}

	for(int par7 = 0; par7 < 1; par7++) {

		int BlockAgateXCoord = i + random.nextInt(16);
		int BlockAgateYCoord = random.nextInt(128);
		int BlockAgateZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAgate, 2)).generate(world, random, BlockAgateXCoord, BlockAgateYCoord, BlockAgateZCoord);
	    								
	}

	for(int par8 = 0; par8 < 1; par8++) {

		int BlockAmethystXCoord = i + random.nextInt(16);
		int BlockAmethystYCoord = random.nextInt(128);
		int BlockAmethystZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAmethyst, 3)).generate(world, random, BlockAmethystXCoord, BlockAmethystYCoord, BlockAmethystZCoord);
	    								
	}

	for(int par9 = 0; par9 < 1; par9++) {

		int BlockAquamarineXCoord = i + random.nextInt(16);
		int BlockAquamarineYCoord = random.nextInt(128);
		int BlockAquamarineZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAquamarine, 2)).generate(world, random, BlockAquamarineXCoord, BlockAquamarineYCoord, BlockAquamarineZCoord);
	    								
	}

	for(int par10 = 0; par10 < 1; par10++) {

		int BlockAzuriteGemXCoord = i + random.nextInt(16);
		int BlockAzuriteGemYCoord = random.nextInt(128);
		int BlockAzuriteGemZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockAzurite, 3)).generate(world, random, BlockAzuriteGemXCoord, BlockAzuriteGemYCoord, BlockAzuriteGemZCoord);
	    								
	}

	for(int par11 = 0; par11 < 1; par11++) {

		int BlockCitrineXCoord = i + random.nextInt(16);
		int BlockCitrineYCoord = random.nextInt(128);
		int BlockCitrineZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCitrine, 4)).generate(world, random, BlockCitrineXCoord, BlockCitrineYCoord, BlockCitrineZCoord);
	    								
	}

	for(int par12 = 0; par12 < 1; par12++) {

		int BlockDiamondXCoord = i + random.nextInt(16);
		int BlockDiamondYCoord = random.nextInt(128);
		int BlockDiamondZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockDiamond, 1)).generate(world, random, BlockDiamondXCoord, BlockDiamondYCoord, BlockDiamondZCoord);
	    								
	}

	for(int par13 = 0; par13 < 1; par13++) {

		int BlockEmeraldXCoord = i + random.nextInt(16);
		int BlockEmeraldYCoord = random.nextInt(128);
		int BlockEmeraldZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockEmerald, 2)).generate(world, random, BlockEmeraldXCoord, BlockEmeraldYCoord, BlockEmeraldZCoord);
	    								
	}

	for(int par14 = 0; par14 < 1; par14++) {

		int BlockGarnetXCoord = i + random.nextInt(16);
		int BlockGarnetYCoord = random.nextInt(128);
		int BlockGarnetZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockGarnet, 2)).generate(world, random, BlockGarnetXCoord, BlockGarnetYCoord, BlockGarnetZCoord);
	    								
	}

	for(int par15 = 0; par15 < 1; par15++) {

		int BlockJadeXCoord = i + random.nextInt(16);
		int BlockJadeYCoord = random.nextInt(128);
		int BlockJadeZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockJade, 5)).generate(world, random, BlockJadeXCoord, BlockJadeYCoord, BlockJadeZCoord);
	    								
	}

	for(int par16 = 0; par16 < 1; par16++) {

		int BlockMalachiteGemXCoord = i + random.nextInt(16);
		int BlockMalachiteGemYCoord = random.nextInt(128);
		int BlockMalachiteGemZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockMalachite, 3)).generate(world, random, BlockMalachiteGemXCoord, BlockMalachiteGemYCoord, BlockMalachiteGemZCoord);
	    								
	}

	for(int par17 = 0; par17 < 1; par17++) {

		int BlockMorionXCoord = i + random.nextInt(16);
		int BlockMorionYCoord = random.nextInt(128);
		int BlockMorionZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockMorion, 4)).generate(world, random, BlockMorionXCoord, BlockMorionYCoord, BlockMorionZCoord);
	    								
	}

	for(int par18 = 0; par18 < 1; par18++) {

		int BlockOnyxXCoord = i + random.nextInt(16);
		int BlockOnyxYCoord = random.nextInt(128);
		int BlockOnyxZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockOnyx, 4)).generate(world, random, BlockOnyxXCoord, BlockOnyxYCoord, BlockOnyxZCoord);
	    								
	}

	for(int par19 = 0; par19 < 1; par19++) {

		int BlockRubyXCoord = i + random.nextInt(16);
		int BlockRubyYCoord = random.nextInt(128);
		int BlockRubyZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockRuby, 2)).generate(world, random, BlockRubyXCoord, BlockRubyYCoord, BlockRubyZCoord);
	    								
	}

	for(int par20 = 0; par20 < 1; par20++) {

		int BlockSaphireXCoord = i + random.nextInt(16);
		int BlockSaphireYCoord = random.nextInt(128);
		int BlockSaphireZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSaphire, 3)).generate(world, random, BlockSaphireXCoord, BlockSaphireYCoord, BlockSaphireZCoord);
	    								
	}

	for(int par21 = 0; par21 < 1; par21++) {

		int BlockTopazXCoord = i + random.nextInt(16);
		int BlockTopazYCoord = random.nextInt(128);
		int BlockTopazZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockTopaz, 3)).generate(world, random, BlockTopazXCoord, BlockTopazYCoord, BlockTopazZCoord);
	    								
	}

	for(int par22 = 0; par22 < 8; par22++) {

		int BlockSlateXCoord = i + random.nextInt(16);
		int BlockSlateYCoord = random.nextInt(128);
		int BlockSlateZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSlate, 15)).generate(world, random, BlockSlateXCoord, BlockSlateYCoord, BlockSlateZCoord);
	    								
	}

	for(int par23 = 0; par23 < 5; par23++) {

		int BlockBasaltXCoord = i + random.nextInt(16);
		int BlockBasaltYCoord = random.nextInt(128);
		int BlockBasaltZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBasalt, 10)).generate(world, random, BlockBasaltXCoord, BlockBasaltYCoord, BlockBasaltZCoord);
	    								
	}

	for(int par24 = 0; par24 < 7; par24++) {

		int BlockGraniteXCoord = i + random.nextInt(16);
		int BlockGraniteYCoord = random.nextInt(128);
		int BlockGraniteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockGranite, 12)).generate(world, random, BlockGraniteXCoord, BlockGraniteYCoord, BlockGraniteZCoord);
	    								
	}

	for(int par25 = 0; par25 < 4; par25++) {

		int BlockLimestoneXCoord = i + random.nextInt(16);
		int BlockLimestoneYCoord = random.nextInt(128);
		int BlockLimestoneZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockLimestone, 15)).generate(world, random, BlockLimestoneXCoord, BlockLimestoneYCoord, BlockLimestoneZCoord);
	    								
	}

	for(int par26 = 0; par26 < 10; par26++) {

		int BlockQuartziteXCoord = i + random.nextInt(16);
		int BlockQuartziteYCoord = random.nextInt(128);
		int BlockQuartziteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockQuartzite, 14)).generate(world, random, BlockQuartziteXCoord, BlockQuartziteYCoord, BlockQuartziteZCoord);
	    								
	}
	for(int par27 = 0; par27 < 10; par27++) {

		int BlockGraphiteXCoord = i + random.nextInt(16);
		int BlockGraphiteYCoord = random.nextInt(128);
		int BlockGraphiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockGraphite, 6)).generate(world, random, BlockGraphiteXCoord, BlockGraphiteYCoord, BlockGraphiteZCoord);
	    								
	}
	for(int par28 = 0; par28 < 4; par28++) {

		int BlockBoneStoneXCoord = i + random.nextInt(16);
		int BlockBoneStoneYCoord = random.nextInt(128);
		int BlockBoneStoneZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBonestone, 4)).generate(world, random, BlockBoneStoneXCoord, BlockBoneStoneYCoord, BlockBoneStoneZCoord);
	    								
	}
	for(int par29 = 0; par29 < 3; par29++) {

		int BlockLapisXCoord = i + random.nextInt(16);
		int BlockLapisYCoord = random.nextInt(128);
		int BlockLapisZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockLapis, 4)).generate(world, random, BlockLapisXCoord, BlockLapisYCoord, BlockLapisZCoord);
	    								
	}
	for(int par30 = 0; par30 < 5; par30++) {

		int BlockBitumenXCoord = i + random.nextInt(16);
		int BlockBitumenYCoord = random.nextInt(128);
		int BlockBitumenZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBitumen, 3)).generate(world, random, BlockBitumenXCoord, BlockBitumenYCoord, BlockBitumenZCoord);
	    								
	}
	for(int par31 = 0; par31 < 8; par31++) {

		int BlockBluestoneXCoord = i + random.nextInt(16);
		int BlockBluestoneYCoord = random.nextInt(128);
		int BlockBluestoneZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBluestone, 6)).generate(world, random, BlockBluestoneXCoord, BlockBluestoneYCoord, BlockBluestoneZCoord);
	    								
	}
	for(int par32 = 0; par32 < 4; par32++) {

		int BlockDiabaseXCoord = i + random.nextInt(16);
		int BlockDiabaseYCoord = random.nextInt(128);
		int BlockDiabaseZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockDiabase, 4)).generate(world, random, BlockDiabaseXCoord, BlockDiabaseYCoord, BlockDiabaseZCoord);
	    								
	}
	for(int par33 = 0; par33 < 4; par33++) {

		int BlockMarbleXCoord = i + random.nextInt(16);
		int BlockMarbleYCoord = random.nextInt(128);
		int BlockMarbleZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockMarble, 4)).generate(world, random, BlockMarbleXCoord, BlockMarbleYCoord, BlockMarbleZCoord);
	    								
	}
	for(int par34 = 0; par34 < 9; par34++) {

		int BlockSandstoneXCoord = i + random.nextInt(16);
		int BlockSandstoneYCoord = random.nextInt(128);
		int BlockSandstoneZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSandstone, ).generate(world, random, BlockSandstoneXCoord, BlockSandstoneYCoord, BlockSandstoneZCoord);
	    								
	}
	for(int par35 = 0; par35 < 4; par35++) {

		int BlockTuffXCoord = i + random.nextInt(16);
		int BlockTuffYCoord = random.nextInt(128);
		int BlockTuffZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockTuff, 4)).generate(world, random, BlockTuffXCoord, BlockTuffYCoord, BlockTuffZCoord);
	    								
	}
	for(int par36 = 0; par36 < 3; par36++) {

		int BlockBromelliteXCoord = i + random.nextInt(16);
		int BlockBromelliteYCoord = random.nextInt(128);
		int BlockBromelliteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBromellite, 4)).generate(world, random, BlockBromelliteXCoord, BlockBromelliteYCoord, BlockBromelliteZCoord);
	    								
	}
	for(int par37 = 0; par37 < 4; par37++) {

		int BlockBismutiteXCoord = i + random.nextInt(16);
		int BlockBismutiteYCoord = random.nextInt(128);
		int BlockBismutiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockBismutite, 5)).generate(world, random, BlockBismutiteXCoord, BlockBismutiteYCoord, BlockBismutiteZCoord);
	    								
	}
	for(int par38 = 0; par38 < 5; par38++) {

		int BlockCobaltiteXCoord = i + random.nextInt(16);
		int BlockCobaltiteYCoord = random.nextInt(128);
		int BlockCobaltiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCobaltite, 6)).generate(world, random, BlockCobaltiteXCoord, BlockCobaltiteYCoord, BlockCobaltiteZCoord);
	    								
	}
	for(int par39 = 0; par39 < 6; par39++) {

		int BlockWolframiteXCoord = i + random.nextInt(16);
		int BlockWolframiteYCoord = random.nextInt(128);
		int BlockWolframiteZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockWolframite, 7)).generate(world, random, BlockWolframiteXCoord, BlockWolframiteYCoord, BlockWolframiteZCoord);
	    								
	}
	for(int par40 = 0; par40 < 7; par40++) {

		int BlockCopperGlossXCoord = i + random.nextInt(16);
		int BlockCopperGlossYCoord = random.nextInt(128);
		int BlockCopperGlossZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockCoppergloss, 7)).generate(world, random, BlockCopperGlossXCoord, BlockCopperGlossYCoord, BlockCopperGlossZCoord);
	    								
	}
	for(int par41 = 0; par41 < 7; par41++) {

		int BlockIronGlossXCoord = i + random.nextInt(16);
		int BlockIronGlossYCoord = random.nextInt(128);
		int BlockIronGlossZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockIrongloss, 7)).generate(world, random, BlockIronGlossXCoord, BlockIronGlossYCoord, BlockIronGlossZCoord);
	    								
	}
	for(int par42 = 0; par42 < 7; par42++) {

		int BlockSilverGlossXCoord = i + random.nextInt(16);
		int BlockSilverGlossYCoord = random.nextInt(128);
		int BlockSilverGlossZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSilvergloss, 7)).generate(world, random, BlockSilverGlossXCoord, BlockSilverGlossYCoord, BlockSilverGlossZCoord);
	    								
	}
	for(int par43 = 0; par43 < 7; par43++) {

		int BlockSulfurXCoord = i + random.nextInt(16);
		int BlockSulfurYCoord = random.nextInt(128);
		int BlockSulfurZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSulfur, 7)).generate(world, random, BlockSulfurXCoord, BlockSulfurYCoord, BlockSulfurZCoord);
	    								
	}
	for(int par44 = 0; par44 < 7; par44++) {

		int BlockSaltpeterXCoord = i + random.nextInt(16);
		int BlockSaltpeterYCoord = random.nextInt(128);
		int BlockSaltpeterZCoord = j + random.nextInt(16);

		(new WorldGenMinable(MaterialEvolutionModBase.blockSaltpeter, 7)).generate(world, random, BlockSaltpeterXCoord, BlockSaltpeterYCoord, BlockSaltpeterZCoord);
	    								
	}

}

private void generateNether(World world, Random random, int i, int j) {
	// TODO Auto-generated method stub

}

}

 

[Ms_Raven]

Isn't that 1.7 code? It doesn't work...

[Frontsalat]

Oups, I'm sorry.

 

https://www.google.de/?gws_rd=ssl#q=minecraft+forge+1.8+modding+tutorial+world+generator

[Ms_Raven]

Already tried Google, that doesn't help...

[Frontsalat]

Well, if you can't be bothered to have some own effort then nobody will^^

[Ms_Raven]

How is Googling something you can't fix yourself, then coming to ask here when Google fails you not having effort?

[LexManos]

You're telling it to generate an ore, above the ground.

Take a look into what WorldGenMineable does... it doesn't work in air...