ok so i copyied the ChunkProviderHell and edited it to this below, aslo in the biome i use above i changed the filler block to nether rack
package com.Dimension.world;
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.SHROOM;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.NETHER_BRIDGE;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.NETHER_CAVE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.FIRE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.GLOWSTONE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.NETHER_LAVA;
import java.util.List;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.MapGenBase;
import net.minecraft.world.gen.MapGenCavesHell;
import net.minecraft.world.gen.NoiseGeneratorOctaves;
import net.minecraft.world.gen.feature.WorldGenFire;
import net.minecraft.world.gen.feature.WorldGenFlowers;
import net.minecraft.world.gen.feature.WorldGenGlowStone1;
import net.minecraft.world.gen.feature.WorldGenGlowStone2;
import net.minecraft.world.gen.feature.WorldGenHellLava;
import net.minecraft.world.gen.feature.WorldGenMinable;
import net.minecraft.world.gen.structure.MapGenNetherBridge;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.Event.Result;
import net.minecraftforge.event.terraingen.ChunkProviderEvent;
import net.minecraftforge.event.terraingen.DecorateBiomeEvent;
import net.minecraftforge.event.terraingen.PopulateChunkEvent;
import net.minecraftforge.event.terraingen.TerrainGen;
public class ChunkProviderNether2 implements IChunkProvider
{
private Random hellRNG;
/** A NoiseGeneratorOctaves used in generating nether terrain */
private NoiseGeneratorOctaves netherNoiseGen1;
private NoiseGeneratorOctaves netherNoiseGen2;
private NoiseGeneratorOctaves netherNoiseGen3;
/** Determines whether slowsand or gravel can be generated at a location */
private NoiseGeneratorOctaves slowsandGravelNoiseGen;
/**
* Determines whether something other than nettherack can be generated at a location
*/
private NoiseGeneratorOctaves netherrackExculsivityNoiseGen;
public NoiseGeneratorOctaves netherNoiseGen6;
public NoiseGeneratorOctaves netherNoiseGen7;
/** Is the world that the nether is getting generated. */
private World worldObj;
private double[] noiseField;
public MapGenNetherBridge genNetherBridge = new MapGenNetherBridge();
/**
* Holds the noise used to determine whether slowsand can be generated at a location
*/
private double[] slowsandNoise = new double[256];
private double[] gravelNoise = new double[256];
private double[] netherNoise = new double[256];//ADDED FOR BLOCK REPLACEMENT
/**
* Holds the noise used to determine whether something other than netherrack can be generated at a location
*/
private double[] netherrackExclusivityNoise = new double[256];
private MapGenBase netherCaveGenerator = new MapGenCavesHell();
double[] noiseData1;
double[] noiseData2;
double[] noiseData3;
double[] noiseData4;
double[] noiseData5;
{
genNetherBridge = (MapGenNetherBridge) TerrainGen.getModdedMapGen(genNetherBridge, NETHER_BRIDGE);
netherCaveGenerator = TerrainGen.getModdedMapGen(netherCaveGenerator, NETHER_CAVE);
}
public ChunkProviderNether2(World par1World, long par2)
{
this.worldObj = par1World;
this.hellRNG = new Random(par2);
this.netherNoise = new double[256];//ADDED FOR BLOCK REPLACEMENT
this.netherNoiseGen1 = new NoiseGeneratorOctaves(this.hellRNG, 16);
this.netherNoiseGen2 = new NoiseGeneratorOctaves(this.hellRNG, 16);
this.netherNoiseGen3 = new NoiseGeneratorOctaves(this.hellRNG, 8);
this.slowsandGravelNoiseGen = new NoiseGeneratorOctaves(this.hellRNG, 4);
this.netherrackExculsivityNoiseGen = new NoiseGeneratorOctaves(this.hellRNG, 4);
this.netherNoiseGen6 = new NoiseGeneratorOctaves(this.hellRNG, 10);
this.netherNoiseGen7 = new NoiseGeneratorOctaves(this.hellRNG, 16);
NoiseGeneratorOctaves[] noiseGens = {netherNoiseGen1, netherNoiseGen2, netherNoiseGen3, slowsandGravelNoiseGen, netherrackExculsivityNoiseGen, netherNoiseGen6, netherNoiseGen7};
noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.hellRNG, noiseGens);
this.netherNoiseGen1 = noiseGens[0];
this.netherNoiseGen2 = noiseGens[1];
this.netherNoiseGen3 = noiseGens[2];
this.slowsandGravelNoiseGen = noiseGens[3];
this.netherrackExculsivityNoiseGen = noiseGens[4];
this.netherNoiseGen6 = noiseGens[5];
this.netherNoiseGen7 = noiseGens[6];
}
/**
* Generates the shape of the terrain in the nether.
*/
public void generateNetherTerrain(int par1, int par2, byte[] par3ArrayOfByte)
{
byte b0 = 4;
byte b1 = 32;
int k = b0 + 1;
byte b2 = 17;
int l = b0 + 1;
this.noiseField = this.initializeNoiseField(this.noiseField, par1 * b0, 0, par2 * b0, k, b2, l);
for (int i1 = 0; i1 < b0; ++i1)
{
for (int j1 = 0; j1 < b0; ++j1)
{
for (int k1 = 0; k1 < 16; ++k1)
{
double d0 = 0.125D;
double d1 = this.noiseField[((i1 + 0) * l + j1 + 0) * b2 + k1 + 0];
double d2 = this.noiseField[((i1 + 0) * l + j1 + 1) * b2 + k1 + 0];
double d3 = this.noiseField[((i1 + 1) * l + j1 + 0) * b2 + k1 + 0];
double d4 = this.noiseField[((i1 + 1) * l + j1 + 1) * b2 + k1 + 0];
double d5 = (this.noiseField[((i1 + 0) * l + j1 + 0) * b2 + k1 + 1] - d1) * d0;
double d6 = (this.noiseField[((i1 + 0) * l + j1 + 1) * b2 + k1 + 1] - d2) * d0;
double d7 = (this.noiseField[((i1 + 1) * l + j1 + 0) * b2 + k1 + 1] - d3) * d0;
double d8 = (this.noiseField[((i1 + 1) * l + j1 + 1) * b2 + k1 + 1] - d4) * d0;
for (int l1 = 0; l1 < 8; ++l1)
{
double d9 = 0.25D;
double d10 = d1;
double d11 = d2;
double d12 = (d3 - d1) * d9;
double d13 = (d4 - d2) * d9;
for (int i2 = 0; i2 < 4; ++i2)
{
int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1;
short short1 = 128;
double d14 = 0.25D;
double d15 = d10;
double d16 = (d11 - d10) * d14;
for (int k2 = 0; k2 < 4; ++k2)
{
int l2 = 0;
if (k1 * 8 + l1 < b1)
{
l2 = Block.lavaStill.blockID;
}
if (d15 > 0.0D)
{
l2 = Block.netherrack.blockID;
}
par3ArrayOfByte[j2] = (byte)l2;
j2 += short1;
d15 += d16;
}
d10 += d12;
d11 += d13;
}
d1 += d5;
d2 += d6;
d3 += d7;
d4 += d8;
}
}
}
}
}
/**
* name based on ChunkProviderGenerate
*/
public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)//added BiomeGenBase[] par4ArrayOfBiomeGenBase
{
ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, null);
MinecraftForge.EVENT_BUS.post(event);
if (event.getResult() == Result.DENY) return;
byte b0 = 64;
double d0 = 0.03125D;
this.slowsandNoise = this.slowsandGravelNoiseGen.generateNoiseOctaves(this.slowsandNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0, d0, 1.0D);
this.gravelNoise = this.slowsandGravelNoiseGen.generateNoiseOctaves(this.gravelNoise, par1 * 16, 109, par2 * 16, 16, 1, 16, d0, 1.0D, d0);
this.netherrackExclusivityNoise = this.netherrackExculsivityNoiseGen.generateNoiseOctaves(this.netherrackExclusivityNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D, d0 * 2.0D);
for (int k = 0; k < 16; ++k)
{
for (int l = 0; l < 16; ++l)
{
BiomeGenBase biomegenbase = par4ArrayOfBiomeGenBase[k + l * 16];//ADDED FOR BLOCK REPLACEMENT
boolean flag = this.slowsandNoise[k + l * 16] + this.hellRNG.nextDouble() * 0.2D > 0.0D;
boolean flag1 = this.gravelNoise[k + l * 16] + this.hellRNG.nextDouble() * 0.2D > 0.0D;
int i1 = (int)(this.netherrackExclusivityNoise[k + l * 16] / 3.0D + 3.0D + this.hellRNG.nextDouble() * 0.25D);
int j1 = -1;
byte b1 = biomegenbase.topBlock;//ADDED FOR BLOCK REPLACEMENT was (byte)Block.netherrack.blockID;
byte b2 = biomegenbase.fillerBlock;//ADDED FOR BLOCK REPLACEMENT was (byte)Block.netherrack.blockID;
for (int k1 = 127; k1 >= 0; --k1)
{
int l1 = (l * 16 + k) * 128 + k1;
if (k1 < 127 - this.hellRNG.nextInt(5) && k1 > 0 + this.hellRNG.nextInt(5))
{
byte b3 = par3ArrayOfByte[l1];
if (b3 == 0)
{
j1 = -1;
}
else if (b3 == Block.netherrack.blockID)
{
if (j1 == -1)
{
int index = (k1 * 16 + l) * 128 + k1;
byte blockID = par3ArrayOfByte[l1];
if (i1 <= 0)
{
b1 = 0;
b2 = (byte)Block.netherrack.blockID;
}
else if (k1 >= 5 && k1 <= 128)// CHANGED FROM (k1 >= b0 - 4 && k1 <= b0 + 1)
{
b1 = par3ArrayOfByte[l1] = biomegenbase.topBlock;//ADDED FOR BLOCK REPLACEMENT
b2 = par3ArrayOfByte[l1] = biomegenbase.fillerBlock;//CHANGED FROM (byte)Block.netherrack.blockID;
if (flag1)
{
b1 = biomegenbase.topBlock;//CHANGED FROM (byte)Block.gravel.blockID;
}
if (flag1)
{
b2 = (byte)Block.netherrack.blockID;
}
if (flag)
{
b1 = (byte)Block.slowSand.blockID;
}
if (flag)
{
b2 = (byte)Block.slowSand.blockID;
}
}
if (k1 < b0 && b1 == 0)
{
b1 = (byte)Block.lavaStill.blockID;
}
j1 = i1;
if (k1 >= b0 - 1)
{
par3ArrayOfByte[l1] = b1;
}
else
{
par3ArrayOfByte[l1] = b1;//CHANGED TO = b1 was = b2
}
}
else if (j1 > 0)
{
--j1;
par3ArrayOfByte[l1] = b2;
}
}
}
else
{
par3ArrayOfByte[l1] = (byte)Block.bedrock.blockID;
}
}
}
}
}
/**
* loads or generates the chunk at the chunk location specified
*/
public Chunk loadChunk(int par1, int par2)
{
return this.provideChunk(par1, par2);
}
/**
* Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the
* specified chunk from the map seed and chunk seed
*/
public Chunk provideChunk(int par1, int par2)
{
BiomeGenBase[] abiomegenbase = this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[])null, par1 * 16, par2 * 16, 16, 16);
this.hellRNG.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
byte[] abyte = new byte[32768];
this.generateNetherTerrain(par1, par2, abyte);
this.replaceBlocksForBiome(par1, par2, abyte, abiomegenbase);
this.netherCaveGenerator.generate(this, this.worldObj, par1, par2, abyte);
this.genNetherBridge.generate(this, this.worldObj, par1, par2, abyte);
Chunk chunk = new Chunk(this.worldObj, abyte, par1, par2);
byte[] abyte1 = chunk.getBiomeArray();
for (int k = 0; k < abyte1.length; ++k)
{
abyte1[k] = (byte)abiomegenbase[k].biomeID;
}
chunk.resetRelightChecks();
return chunk;
}
/**
* generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
* size.
*/
private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
{
ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
MinecraftForge.EVENT_BUS.post(event);
if (event.getResult() == Result.DENY) return event.noisefield;
if (par1ArrayOfDouble == null)
{
par1ArrayOfDouble = new double[par5 * par6 * par7];
}
double d0 = 684.412D;
double d1 = 2053.236D;
this.noiseData4 = this.netherNoiseGen6.generateNoiseOctaves(this.noiseData4, par2, par3, par4, par5, 1, par7, 1.0D, 0.0D, 1.0D);
this.noiseData5 = this.netherNoiseGen7.generateNoiseOctaves(this.noiseData5, par2, par3, par4, par5, 1, par7, 100.0D, 0.0D, 100.0D);
this.noiseData1 = this.netherNoiseGen3.generateNoiseOctaves(this.noiseData1, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 60.0D, d0 / 80.0D);
this.noiseData2 = this.netherNoiseGen1.generateNoiseOctaves(this.noiseData2, par2, par3, par4, par5, par6, par7, d0, d1, d0);
this.noiseData3 = this.netherNoiseGen2.generateNoiseOctaves(this.noiseData3, par2, par3, par4, par5, par6, par7, d0, d1, d0);
int k1 = 0;
int l1 = 0;
double[] adouble1 = new double[par6];
int i2;
for (i2 = 0; i2 < par6; ++i2)
{
adouble1[i2] = Math.cos((double)i2 * Math.PI * 6.0D / (double)par6) * 2.0D;
double d2 = (double)i2;
if (i2 > par6 / 2)
{
d2 = (double)(par6 - 1 - i2);
}
if (d2 < 4.0D)
{
d2 = 4.0D - d2;
adouble1[i2] -= d2 * d2 * d2 * 10.0D;
}
}
for (i2 = 0; i2 < par5; ++i2)
{
for (int j2 = 0; j2 < par7; ++j2)
{
double d3 = (this.noiseData4[l1] + 256.0D) / 512.0D;
if (d3 > 1.0D)
{
d3 = 1.0D;
}
double d4 = 0.0D;
double d5 = this.noiseData5[l1] / 8000.0D;
if (d5 < 0.0D)
{
d5 = -d5;
}
d5 = d5 * 3.0D - 3.0D;
if (d5 < 0.0D)
{
d5 /= 2.0D;
if (d5 < -1.0D)
{
d5 = -1.0D;
}
d5 /= 1.4D;
d5 /= 2.0D;
d3 = 0.0D;
}
else
{
if (d5 > 1.0D)
{
d5 = 1.0D;
}
d5 /= 6.0D;
}
d3 += 0.5D;
d5 = d5 * (double)par6 / 16.0D;
++l1;
for (int k2 = 0; k2 < par6; ++k2)
{
double d6 = 0.0D;
double d7 = adouble1[k2];
double d8 = this.noiseData2[k1] / 512.0D;
double d9 = this.noiseData3[k1] / 512.0D;
double d10 = (this.noiseData1[k1] / 10.0D + 1.0D) / 2.0D;
if (d10 < 0.0D)
{
d6 = d8;
}
else if (d10 > 1.0D)
{
d6 = d9;
}
else
{
d6 = d8 + (d9 - d8) * d10;
}
d6 -= d7;
double d11;
if (k2 > par6 - 4)
{
d11 = (double)((float)(k2 - (par6 - 4)) / 3.0F);
d6 = d6 * (1.0D - d11) + -10.0D * d11;
}
if ((double)k2 < d4)
{
d11 = (d4 - (double)k2) / 4.0D;
if (d11 < 0.0D)
{
d11 = 0.0D;
}
if (d11 > 1.0D)
{
d11 = 1.0D;
}
d6 = d6 * (1.0D - d11) + -10.0D * d11;
}
par1ArrayOfDouble[k1] = d6;
++k1;
}
}
}
return par1ArrayOfDouble;
}
/**
* Checks to see if a chunk exists at x, y
*/
public boolean chunkExists(int par1, int par2)
{
return true;
}
/**
* Populates chunk with ores etc etc
*/
public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)
{
BlockSand.fallInstantly = true;
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, hellRNG, par2, par3, false));
int k = par2 * 16;
int l = par3 * 16;
this.genNetherBridge.generateStructuresInChunk(this.worldObj, this.hellRNG, par2, par3);
int i1;
int j1;
int k1;
int l1;
boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, NETHER_LAVA);
for (i1 = 0; doGen && i1 < 8; ++i1)
{
j1 = k + this.hellRNG.nextInt(16) + 8;
k1 = this.hellRNG.nextInt(120) + 4;
l1 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenHellLava(Block.lavaMoving.blockID, false)).generate(this.worldObj, this.hellRNG, j1, k1, l1);
}
i1 = this.hellRNG.nextInt(this.hellRNG.nextInt(10) + 1) + 1;
int i2;
doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, FIRE);
for (j1 = 0; doGen && j1 < i1; ++j1)
{
k1 = k + this.hellRNG.nextInt(16) + 8;
l1 = this.hellRNG.nextInt(120) + 4;
i2 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenFire()).generate(this.worldObj, this.hellRNG, k1, l1, i2);
}
i1 = this.hellRNG.nextInt(this.hellRNG.nextInt(10) + 1);
doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, GLOWSTONE);
for (j1 = 0; doGen && j1 < i1; ++j1)
{
k1 = k + this.hellRNG.nextInt(16) + 8;
l1 = this.hellRNG.nextInt(120) + 4;
i2 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenGlowStone1()).generate(this.worldObj, this.hellRNG, k1, l1, i2);
}
for (j1 = 0; doGen && j1 < 10; ++j1)
{
k1 = k + this.hellRNG.nextInt(16) + 8;
l1 = this.hellRNG.nextInt(128);
i2 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenGlowStone2()).generate(this.worldObj, this.hellRNG, k1, l1, i2);
}
MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(worldObj, hellRNG, k, l));
doGen = TerrainGen.decorate(worldObj, hellRNG, k, l, SHROOM);
if (doGen && this.hellRNG.nextInt(1) == 0)
{
j1 = k + this.hellRNG.nextInt(16) + 8;
k1 = this.hellRNG.nextInt(128);
l1 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenFlowers(Block.mushroomBrown.blockID)).generate(this.worldObj, this.hellRNG, j1, k1, l1);
}
if (doGen && this.hellRNG.nextInt(1) == 0)
{
j1 = k + this.hellRNG.nextInt(16) + 8;
k1 = this.hellRNG.nextInt(128);
l1 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenFlowers(Block.mushroomRed.blockID)).generate(this.worldObj, this.hellRNG, j1, k1, l1);
}
WorldGenMinable worldgenminable = new WorldGenMinable(Block.oreNetherQuartz.blockID, 13, Block.netherrack.blockID);
int j2;
for (k1 = 0; k1 < 16; ++k1)
{
l1 = k + this.hellRNG.nextInt(16);
i2 = this.hellRNG.nextInt(108) + 10;
j2 = l + this.hellRNG.nextInt(16);
worldgenminable.generate(this.worldObj, this.hellRNG, l1, i2, j2);
}
for (k1 = 0; k1 < 16; ++k1)
{
l1 = k + this.hellRNG.nextInt(16);
i2 = this.hellRNG.nextInt(108) + 10;
j2 = l + this.hellRNG.nextInt(16);
(new WorldGenHellLava(Block.lavaMoving.blockID, true)).generate(this.worldObj, this.hellRNG, l1, i2, j2);
}
MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(worldObj, hellRNG, k, l));
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, hellRNG, par2, par3, false));
BlockSand.fallInstantly = false;
}
/**
* Two modes of operation: if passed true, save all Chunks in one go. If passed false, save up to two chunks.
* Return true if all chunks have been saved.
*/
public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate)
{
return true;
}
public void func_104112_b() {}
/**
* Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk.
*/
public boolean unloadQueuedChunks()
{
return false;
}
/**
* Returns if the IChunkProvider supports saving.
*/
public boolean canSave()
{
return true;
}
/**
* Converts the instance data to a readable string.
*/
public String makeString()
{
return "HellRandomLevelSource";
}
/**
* Returns a list of creatures of the specified type that can spawn at the given location.
*/
public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
{
if (par1EnumCreatureType == EnumCreatureType.monster && this.genNetherBridge.hasStructureAt(par2, par3, par4))
{
return this.genNetherBridge.getSpawnList();
}
else
{
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2, par4);
return biomegenbase == null ? null : biomegenbase.getSpawnableList(par1EnumCreatureType);
}
}
/**
* Returns the location of the closest structure of the specified type. If not found returns null.
*/
public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
{
return null;
}
public int getLoadedChunkCount()
{
return 0;
}
public void recreateStructures(int par1, int par2)
{
this.genNetherBridge.generate(this, this.worldObj, par1, par2, (byte[])null);
}
}
hope this one helps
I just.. don't understand XD how did you do it?? I've spent weeks trying to do this. Also, is there a way to generate a ground covering like snow in the taiga biome? because I have my own ground covering block that I'd like to use.
i will take a look today for you and post later, you can add my name if you want to aswell thanks
Thanks a bunch dude you can also join our skype group if you would like to pre-alpha test the mod, once we have a working playable pre-alpha i'll be distributing it to everyone on the team and a couple friends on there. Or I could just private message a link, either way works.
Ok soo i looked through the code to make the chunk provider use more than one biome and this is what i got, its only running 2 biomes but you could add as meny as you want
Now to do this you would need a NewWorldChunkManager, GenLayerTutorial classes and edit your chunk provider.
if you have followed the multi biome tutorial already you should have them already and all the files need to do it.
For it to work you would need to change the WorldProvider for your dimension and edit the line that says
this.worldChunkMgr = new WorldChunkManagerHell(MainBiomes.ModHell, 1.0F, 0.0F);
and change that to this
this.worldChunkMgr = new WorldChunkManagerNether2(worldObj.getSeed(), terrainType);
now you can create the WorldChunkManagerNether2 or whatever you called it.mine is called WorldChunkManagerNether2
package com.Dimension.world;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import com.Dimension.biomes.MainBiomes;
import com.Dimension.world.gen.layer.GenLayerTutorial;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.WorldType;
import net.minecraft.world.biome.BiomeCache;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.biome.WorldChunkManager;
import net.minecraft.world.gen.layer.GenLayer;
import net.minecraft.world.gen.layer.IntCache;
public class WorldChunkManagerNether2 extends WorldChunkManager
{
private GenLayer myGenBiomes;
private GenLayer myBiomeIndexLayer;
private BiomeCache myBiomeCache;
private List<BiomeGenBase> myBiomesToSpawnIn;
protected WorldChunkManagerNether2()
{
this.myBiomeCache = new BiomeCache(this);
//BIOMES TO SPAWN IN ?
//CHANGE THE BIOMES TO YOURS
this.myBiomesToSpawnIn = new ArrayList<BiomeGenBase>();
this.myBiomesToSpawnIn.add(MainBiomes.BiomeGenForest);
this.myBiomesToSpawnIn.add(MainBiomes.BiomeGenJungle);
this.myBiomesToSpawnIn.add(MainBiomes.BiomeGenPlains);
this.myBiomesToSpawnIn.add(MainBiomes.BiomeGenTut);
}
// ADDS OUR CUSTOM GEN LAYER CLASSES
public WorldChunkManagerNether2(long seed, WorldType worldtype)
{
this();
GenLayer[] agenlayer = GenLayerTutorial.makeTheWorld(seed);
this.myGenBiomes = agenlayer[0];
this.myBiomeIndexLayer = agenlayer[1];
}
public WorldChunkManagerNether2(World world)
{
this(world.getSeed(), world.provider.terrainType);
}
/**
* Gets the list of valid biomes for the player to spawn in.
*/
public List<BiomeGenBase> getBiomesToSpawnIn()
{
return this.myBiomesToSpawnIn;
}
/**
* Returns the BiomeGenBase related to the x, z position on the world.
*/
public BiomeGenBase getBiomeGenAt(int x, int z)
{
BiomeGenBase biome = this.myBiomeCache.getBiomeGenAt(x, z);
if (biome == null)
{
return MainBiomes.BiomeGenTut;//CHNAGE THIS TO ONE OF YOUR BIOMES
}
return biome;
}
/**
* Returns a list of rainfall values for the specified blocks. Args:
* listToReuse, x, z, width, length.
*/
public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)
{
IntCache.resetIntCache();
if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)
{
par1ArrayOfFloat = new float[par4 * par5];
}
int[] aint = this.myBiomeIndexLayer.getInts(par2, par3, par4, par5);
for (int i1 = 0; i1 < par4 * par5; ++i1)
{
float f = (float) BiomeGenBase.biomeList[aint[i1]].getIntRainfall() / 65536.0F;
if (f > 1.0F)
{
f = 1.0F;
}
par1ArrayOfFloat[i1] = f;
}
return par1ArrayOfFloat;
}
/**
* Return an adjusted version of a given temperature based on the y height
*/
@SideOnly(Side.CLIENT)
public float getTemperatureAtHeight(float par1, int par2)
{
return par1;
}
/**
* Returns a list of temperatures to use for the specified blocks. Args:
* listToReuse, x, y, width, length
*/
public float[] getTemperatures(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)
{
IntCache.resetIntCache();
if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)
{
par1ArrayOfFloat = new float[par4 * par5];
}
int[] aint = this.myBiomeIndexLayer.getInts(par2, par3, par4, par5);
for (int i1 = 0; i1 < par4 * par5; ++i1)
{
float f = (float) BiomeGenBase.biomeList[aint[i1]].getIntTemperature() / 65536.0F;
if (f > 1.0F)
{
f = 1.0F;
}
par1ArrayOfFloat[i1] = f;
}
return par1ArrayOfFloat;
}
/**
* Returns an array of biomes for the location input.
*/
public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) {
IntCache.resetIntCache();
if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)
{
par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
}
int[] aint = this.myGenBiomes.getInts(par2, par3, par4, par5);
for (int i = 0; i < par4 * par5; ++i) {
if (aint[i] >= 0) {
par1ArrayOfBiomeGenBase[i] = BiomeGenBase.biomeList[aint[i]];
} else {
par1ArrayOfBiomeGenBase[i] = MainBiomes.BiomeGenTut;//CHANGE THIS TO ONE OF YOUR BIOMES
}
}
return par1ArrayOfBiomeGenBase;
}
/**
* Returns biomes to use for the blocks and loads the other data like
* temperature and humidity onto the WorldChunkManager Args: oldBiomeList,
* x, z, width, depth
*/
public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)
{
return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true);
}
/**
* Return a list of biomes for the specified blocks. Args: listToReuse, x,
* y, width, length, cacheFlag (if false, don't check biomeCache to avoid
* infinite loop in BiomeCacheBlock)
*/
public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] par1ArrayOfBiomeGenBase, int x, int y, int width, int length, boolean cacheFlag)
{
IntCache.resetIntCache();
if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < width * length)
{
par1ArrayOfBiomeGenBase = new BiomeGenBase[width * length];
}
if (cacheFlag && width == 16 && length == 16 && (x & 15) == 0 && (y & 15) == 0)
{
BiomeGenBase[] abiomegenbase1 = this.myBiomeCache.getCachedBiomes(x, y);
System.arraycopy(abiomegenbase1, 0, par1ArrayOfBiomeGenBase, 0, width * length);
return par1ArrayOfBiomeGenBase;
}
else
{
int[] aint = this.myBiomeIndexLayer.getInts(x, y, width, length);
for (int i = 0; i < width * length; ++i)
{
if (aint[i] >= 0)
{
par1ArrayOfBiomeGenBase[i] = BiomeGenBase.biomeList[aint[i]];
}
else
{
par1ArrayOfBiomeGenBase[i] = MainBiomes.BiomeGenTut;//CHANGE THIS TO ONE OF YOUR BIOMES
}
}
return par1ArrayOfBiomeGenBase;
}
}
/**
* checks given Chunk's Biomes against List of allowed ones
*/
public boolean areBiomesViable(int par1, int par2, int par3, List par4List)
{
IntCache.resetIntCache();
int l = par1 - par3 >> 2;
int i1 = par2 - par3 >> 2;
int j1 = par1 + par3 >> 2;
int k1 = par2 + par3 >> 2;
int l1 = j1 - l + 1;
int i2 = k1 - i1 + 1;
int[] aint = this.myGenBiomes.getInts(l, i1, l1, i2);
for (int j2 = 0; j2 < l1 * i2; ++j2)
{
BiomeGenBase biomegenbase = BiomeGenBase.biomeList[aint[j2]];
if (!par4List.contains(biomegenbase))
{
return false;
}
}
return true;
}
/**
* Finds a valid position within a range, that is in one of the listed
* biomes. Searches {par1,par2} +-par3 blocks. Strongly favors positive y
* positions.
*/
public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random)
{
IntCache.resetIntCache();
int l = par1 - par3 >> 2;
int i1 = par2 - par3 >> 2;
int j1 = par1 + par3 >> 2;
int k1 = par2 + par3 >> 2;
int l1 = j1 - l + 1;
int i2 = k1 - i1 + 1;
int[] aint = this.myGenBiomes.getInts(l, i1, l1, i2);
ChunkPosition chunkposition = null;
int j2 = 0;
for (int k2 = 0; k2 < l1 * i2; ++k2)
{
int l2 = l + k2 % l1 << 2;
int i3 = i1 + k2 / l1 << 2;
BiomeGenBase biomegenbase = BiomeGenBase.biomeList[aint[k2]];
if (par4List.contains(biomegenbase) && (chunkposition == null || par5Random.nextInt(j2 + 1) == 0))
{
chunkposition = new ChunkPosition(l2, 0, i3);
++j2;
}
}
return chunkposition;
}
/**
* Calls the WorldChunkManager's biomeCache.cleanupCache()
*/
public void cleanupCache()
{
this.myBiomeCache.cleanupCache();
}
}
chnage what i have commented on
Now you should have the rest apart from the changes i made to the chunk provider which i will post below
package com.Dimension.world;
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.SHROOM;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.NETHER_BRIDGE;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.NETHER_CAVE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.FIRE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.GLOWSTONE;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.NETHER_LAVA;
import java.util.List;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.SpawnerAnimals;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.MapGenBase;
import net.minecraft.world.gen.MapGenCavesHell;
import net.minecraft.world.gen.NoiseGeneratorOctaves;
import net.minecraft.world.gen.feature.WorldGenFire;
import net.minecraft.world.gen.feature.WorldGenFlowers;
import net.minecraft.world.gen.feature.WorldGenGlowStone1;
import net.minecraft.world.gen.feature.WorldGenGlowStone2;
import net.minecraft.world.gen.feature.WorldGenHellLava;
import net.minecraft.world.gen.feature.WorldGenMinable;
import net.minecraft.world.gen.structure.MapGenNetherBridge;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.Event.Result;
import net.minecraftforge.event.terraingen.ChunkProviderEvent;
import net.minecraftforge.event.terraingen.DecorateBiomeEvent;
import net.minecraftforge.event.terraingen.PopulateChunkEvent;
import net.minecraftforge.event.terraingen.TerrainGen;
public class ChunkProviderNether2 implements IChunkProvider
{
private Random hellRNG;
/** A NoiseGeneratorOctaves used in generating nether terrain */
private NoiseGeneratorOctaves netherNoiseGen1;
private NoiseGeneratorOctaves netherNoiseGen2;
private NoiseGeneratorOctaves netherNoiseGen3;
/** Determines whether slowsand or gravel can be generated at a location */
//private NoiseGeneratorOctaves slowsandGravelNoiseGen;
/**
* Determines whether something other than nettherack can be generated at a location
*/
private NoiseGeneratorOctaves netherrackExculsivityNoiseGen;
public NoiseGeneratorOctaves netherNoiseGen6;
public NoiseGeneratorOctaves netherNoiseGen7;
/** Is the world that the nether is getting generated. */
private World worldObj;
private double[] noiseField;
public MapGenNetherBridge genNetherBridge = new MapGenNetherBridge();
/** The biomes that are used to generate the chunk */
private BiomeGenBase[] biomesForGeneration;//ADDED FOR BIOMES
/**
* Holds the noise used to determine whether slowsand can be generated at a location
*/
// private double[] slowsandNoise = new double[256];
// private double[] gravelNoise = new double[256];
private double[] netherNoise = new double[256];//ADDED FOR BLOCK REPLACEMENT
/**
* Holds the noise used to determine whether something other than netherrack can be generated at a location
*/
private double[] netherrackExclusivityNoise = new double[256];
private MapGenBase netherCaveGenerator = new MapGenCavesHell();
double[] noiseData1;
double[] noiseData2;
double[] noiseData3;
double[] noiseData4;
double[] noiseData5;
{
genNetherBridge = (MapGenNetherBridge) TerrainGen.getModdedMapGen(genNetherBridge, NETHER_BRIDGE);
netherCaveGenerator = TerrainGen.getModdedMapGen(netherCaveGenerator, NETHER_CAVE);
}
public ChunkProviderNether2(World par1World, long par2)
{
this.worldObj = par1World;
this.hellRNG = new Random(par2);
this.netherNoise = new double[256];//ADDED FOR BLOCK REPLACEMENT
this.netherNoiseGen1 = new NoiseGeneratorOctaves(this.hellRNG, 16);
this.netherNoiseGen2 = new NoiseGeneratorOctaves(this.hellRNG, 16);
this.netherNoiseGen3 = new NoiseGeneratorOctaves(this.hellRNG, 8);
//this.slowsandGravelNoiseGen = new NoiseGeneratorOctaves(this.hellRNG, 4);
this.netherrackExculsivityNoiseGen = new NoiseGeneratorOctaves(this.hellRNG, 4);
this.netherNoiseGen6 = new NoiseGeneratorOctaves(this.hellRNG, 10);
this.netherNoiseGen7 = new NoiseGeneratorOctaves(this.hellRNG, 16);
NoiseGeneratorOctaves[] noiseGens = {netherNoiseGen1, netherNoiseGen2, netherNoiseGen3, netherrackExculsivityNoiseGen, netherNoiseGen6, netherNoiseGen7};//REMOVED "slowsandGravelNoiseGen"
noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.hellRNG, noiseGens);
this.netherNoiseGen1 = noiseGens[0];
this.netherNoiseGen2 = noiseGens[1];
this.netherNoiseGen3 = noiseGens[2];
//this.slowsandGravelNoiseGen = noiseGens[3];
this.netherrackExculsivityNoiseGen = noiseGens[4];
this.netherNoiseGen6 = noiseGens[5];
//this.netherNoiseGen7 = noiseGens[6];
}
/**
* Generates the shape of the terrain in the nether.
*/
public void generateNetherTerrain(int par1, int par2, byte[] par3ArrayOfByte)
{
byte b0 = 4;
byte b1 = 32;
int k = b0 + 1;
byte b2 = 17;
int l = b0 + 1;
this.noiseField = this.initializeNoiseField(this.noiseField, par1 * b0, 0, par2 * b0, k, b2, l);
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 2 - 1, par2 * 2 - 1, k + 5, l + 5);//ADDED FOR BIOMES
for (int i1 = 0; i1 < b0; ++i1)
{
for (int j1 = 0; j1 < b0; ++j1)
{
for (int k1 = 0; k1 < 16; ++k1)
{
double d0 = 0.125D;
double d1 = this.noiseField[((i1 + 0) * l + j1 + 0) * b2 + k1 + 0];
double d2 = this.noiseField[((i1 + 0) * l + j1 + 1) * b2 + k1 + 0];
double d3 = this.noiseField[((i1 + 1) * l + j1 + 0) * b2 + k1 + 0];
double d4 = this.noiseField[((i1 + 1) * l + j1 + 1) * b2 + k1 + 0];
double d5 = (this.noiseField[((i1 + 0) * l + j1 + 0) * b2 + k1 + 1] - d1) * d0;
double d6 = (this.noiseField[((i1 + 0) * l + j1 + 1) * b2 + k1 + 1] - d2) * d0;
double d7 = (this.noiseField[((i1 + 1) * l + j1 + 0) * b2 + k1 + 1] - d3) * d0;
double d8 = (this.noiseField[((i1 + 1) * l + j1 + 1) * b2 + k1 + 1] - d4) * d0;
for (int l1 = 0; l1 < 8; ++l1)
{
double d9 = 0.25D;
double d10 = d1;
double d11 = d2;
double d12 = (d3 - d1) * d9;
double d13 = (d4 - d2) * d9;
for (int i2 = 0; i2 < 4; ++i2)
{
int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1;
short short1 = 128;
double d14 = 0.25D;
double d15 = d10;
double d16 = (d11 - d10) * d14;
for (int k2 = 0; k2 < 4; ++k2)
{
int l2 = 0;
if (k1 * 8 + l1 < b1)
{
l2 = Block.lavaStill.blockID;
}
if (d15 > 0.0D)
{
l2 = Block.netherrack.blockID;
}
par3ArrayOfByte[j2] = (byte)l2;
j2 += short1;
d15 += d16;
}
d10 += d12;
d11 += d13;
}
d1 += d5;
d2 += d6;
d3 += d7;
d4 += d8;
}
}
}
}
}
/**
* name based on ChunkProviderGenerate
*/
public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)//added BiomeGenBase[] par4ArrayOfBiomeGenBase
{
ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, null);
MinecraftForge.EVENT_BUS.post(event);
if (event.getResult() == Result.DENY) return;
byte b0 = 64;
double d0 = 0.03125D;
//this.slowsandNoise = this.slowsandGravelNoiseGen.generateNoiseOctaves(this.slowsandNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0, d0, 1.0D);
//this.gravelNoise = this.slowsandGravelNoiseGen.generateNoiseOctaves(this.gravelNoise, par1 * 16, 109, par2 * 16, 16, 1, 16, d0, 1.0D, d0);
this.netherrackExclusivityNoise = this.netherrackExculsivityNoiseGen.generateNoiseOctaves(this.netherrackExclusivityNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D, d0 * 2.0D);
for (int k = 0; k < 16; ++k)
{
for (int l = 0; l < 16; ++l)
{
BiomeGenBase biomegenbase = par4ArrayOfBiomeGenBase[k + l * 16];//ADDED FOR BLOCK REPLACEMENT
//boolean flag = this.slowsandNoise[k + l * 16] + this.hellRNG.nextDouble() * 0.2D > 0.0D;
//boolean flag1 = this.gravelNoise[k + l * 16] + this.hellRNG.nextDouble() * 0.2D > 0.0D;
int i1 = (int)(this.netherrackExclusivityNoise[k + l * 16] / 3.0D + 3.0D + this.hellRNG.nextDouble() * 0.25D);
int j1 = -1;
byte b1 = biomegenbase.topBlock;//ADDED FOR BLOCK REPLACEMENT was (byte)Block.netherrack.blockID;
byte b2 = biomegenbase.fillerBlock;//ADDED FOR BLOCK REPLACEMENT was (byte)Block.netherrack.blockID;
for (int k1 = 127; k1 >= 0; --k1)
{
int l1 = (l * 16 + k) * 128 + k1;
if (k1 < 127 - this.hellRNG.nextInt(5) && k1 > 0 + this.hellRNG.nextInt(5))
{
byte b3 = par3ArrayOfByte[l1];
if (b3 == 0)
{
j1 = -1;
}
else if (b3 == Block.netherrack.blockID)
{
if (j1 == -1)
{
int index = (k1 * 16 + l) * 128 + k1;
byte blockID = par3ArrayOfByte[l1];
if (i1 <= 0)
{
b1 = 0;
b2 = (byte)Block.netherrack.blockID;
}
else if (k1 >= 5 && k1 <= 128)// CHANGED FROM (k1 >= b0 - 4 && k1 <= b0 + 1)
{
b1 = par3ArrayOfByte[l1] = biomegenbase.topBlock;//ADDED FOR BLOCK REPLACEMENT
b2 = par3ArrayOfByte[l1] = biomegenbase.fillerBlock;//CHANGED FROM (byte)Block.netherrack.blockID;
/** if (flag1)
{
b1 = biomegenbase.topBlock;//CHANGED FROM (byte)Block.gravel.blockID;
}
if (flag1)
{
b2 = (byte)Block.netherrack.blockID;
}
if (flag)
{
b1 = (byte)Block.slowSand.blockID;
}
if (flag)
{
b2 = (byte)Block.slowSand.blockID;
}**/
}
if (k1 < b0 && b1 == 0)
{
b1 = (byte)Block.lavaStill.blockID;
}
j1 = i1;
if (k1 >= b0 - 1)
{
par3ArrayOfByte[l1] = b1;
}
else
{
par3ArrayOfByte[l1] = b1;//CHANGED TO = b1 was = b2
}
}
else if (j1 > 0)
{
--j1;
par3ArrayOfByte[l1] = b2;
}
}
}
else
{
par3ArrayOfByte[l1] = (byte)Block.bedrock.blockID;
}
}
}
}
}
/**
* loads or generates the chunk at the chunk location specified
*/
public Chunk loadChunk(int par1, int par2)
{
return this.provideChunk(par1, par2);
}
/**
* Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the
* specified chunk from the map seed and chunk seed
*/
public Chunk provideChunk(int par1, int par2)
{
//BiomeGenBase[] abiomegenbase = this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[])null, par1 * 16, par2 * 16, 16, 16);
this.hellRNG.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
byte[] abyte = new byte[32768];
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
this.generateNetherTerrain(par1, par2, abyte);
this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);//EDITED FOR BIOMES
this.netherCaveGenerator.generate(this, this.worldObj, par1, par2, abyte);
this.genNetherBridge.generate(this, this.worldObj, par1, par2, abyte);
Chunk chunk = new Chunk(this.worldObj, abyte, par1, par2);
byte[] abyte1 = chunk.getBiomeArray();
for (int k = 0; k < abyte1.length; ++k)
{
abyte1[k] = (byte)biomesForGeneration[k].biomeID;
}
chunk.resetRelightChecks();
return chunk;
}
/**
* generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
* size.
*/
private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
{
ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
MinecraftForge.EVENT_BUS.post(event);
if (event.getResult() == Result.DENY) return event.noisefield;
if (par1ArrayOfDouble == null)
{
par1ArrayOfDouble = new double[par5 * par6 * par7];
}
double d0 = 684.412D;
double d1 = 2053.236D;
this.noiseData4 = this.netherNoiseGen6.generateNoiseOctaves(this.noiseData4, par2, par3, par4, par5, 1, par7, 1.0D, 0.0D, 1.0D);
this.noiseData5 = this.netherNoiseGen7.generateNoiseOctaves(this.noiseData5, par2, par3, par4, par5, 1, par7, 100.0D, 0.0D, 100.0D);
this.noiseData1 = this.netherNoiseGen3.generateNoiseOctaves(this.noiseData1, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 60.0D, d0 / 80.0D);
this.noiseData2 = this.netherNoiseGen1.generateNoiseOctaves(this.noiseData2, par2, par3, par4, par5, par6, par7, d0, d1, d0);
this.noiseData3 = this.netherNoiseGen2.generateNoiseOctaves(this.noiseData3, par2, par3, par4, par5, par6, par7, d0, d1, d0);
int k1 = 0;
int l1 = 0;
double[] adouble1 = new double[par6];
int i2;
for (i2 = 0; i2 < par6; ++i2)
{
adouble1[i2] = Math.cos((double)i2 * Math.PI * 6.0D / (double)par6) * 2.0D;
double d2 = (double)i2;
if (i2 > par6 / 2)
{
d2 = (double)(par6 - 1 - i2);
}
if (d2 < 4.0D)
{
d2 = 4.0D - d2;
adouble1[i2] -= d2 * d2 * d2 * 10.0D;
}
}
for (i2 = 0; i2 < par5; ++i2)
{
for (int j2 = 0; j2 < par7; ++j2)
{
double d3 = (this.noiseData4[l1] + 256.0D) / 512.0D;
if (d3 > 1.0D)
{
d3 = 1.0D;
}
double d4 = 0.0D;
double d5 = this.noiseData5[l1] / 8000.0D;
if (d5 < 0.0D)
{
d5 = -d5;
}
d5 = d5 * 3.0D - 3.0D;
if (d5 < 0.0D)
{
d5 /= 2.0D;
if (d5 < -1.0D)
{
d5 = -1.0D;
}
d5 /= 1.4D;
d5 /= 2.0D;
d3 = 0.0D;
}
else
{
if (d5 > 1.0D)
{
d5 = 1.0D;
}
d5 /= 6.0D;
}
d3 += 0.5D;
d5 = d5 * (double)par6 / 16.0D;
++l1;
for (int k2 = 0; k2 < par6; ++k2)
{
double d6 = 0.0D;
double d7 = adouble1[k2];
double d8 = this.noiseData2[k1] / 512.0D;
double d9 = this.noiseData3[k1] / 512.0D;
double d10 = (this.noiseData1[k1] / 10.0D + 1.0D) / 2.0D;
if (d10 < 0.0D)
{
d6 = d8;
}
else if (d10 > 1.0D)
{
d6 = d9;
}
else
{
d6 = d8 + (d9 - d8) * d10;
}
d6 -= d7;
double d11;
if (k2 > par6 - 4)
{
d11 = (double)((float)(k2 - (par6 - 4)) / 3.0F);
d6 = d6 * (1.0D - d11) + -10.0D * d11;
}
if ((double)k2 < d4)
{
d11 = (d4 - (double)k2) / 4.0D;
if (d11 < 0.0D)
{
d11 = 0.0D;
}
if (d11 > 1.0D)
{
d11 = 1.0D;
}
d6 = d6 * (1.0D - d11) + -10.0D * d11;
}
par1ArrayOfDouble[k1] = d6;
++k1;
}
}
}
return par1ArrayOfDouble;
}
/**
* Checks to see if a chunk exists at x, y
*/
public boolean chunkExists(int par1, int par2)
{
return true;
}
/**
* Populates chunk with ores etc etc
*/
public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)
{
BlockSand.fallInstantly = true;
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2 + 16, par3 + 16);
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, hellRNG, par2, par3, false));
int k = par2 * 16;
int l = par3 * 16;
this.genNetherBridge.generateStructuresInChunk(this.worldObj, this.hellRNG, par2, par3);
int i1;
int j1;
int k1;
int l1;
boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, NETHER_LAVA);
for (i1 = 0; doGen && i1 < 8; ++i1)
{
j1 = k + this.hellRNG.nextInt(16) + 8;
k1 = this.hellRNG.nextInt(120) + 4;
l1 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenHellLava(Block.lavaMoving.blockID, false)).generate(this.worldObj, this.hellRNG, j1, k1, l1);
}
i1 = this.hellRNG.nextInt(this.hellRNG.nextInt(10) + 1) + 1;
int i2;
doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, FIRE);
for (j1 = 0; doGen && j1 < i1; ++j1)
{
k1 = k + this.hellRNG.nextInt(16) + 8;
l1 = this.hellRNG.nextInt(120) + 4;
i2 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenFire()).generate(this.worldObj, this.hellRNG, k1, l1, i2);
}
i1 = this.hellRNG.nextInt(this.hellRNG.nextInt(10) + 1);
doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, GLOWSTONE);
for (j1 = 0; doGen && j1 < i1; ++j1)
{
k1 = k + this.hellRNG.nextInt(16) + 8;
l1 = this.hellRNG.nextInt(120) + 4;
i2 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenGlowStone1()).generate(this.worldObj, this.hellRNG, k1, l1, i2);
}
for (j1 = 0; doGen && j1 < 10; ++j1)
{
k1 = k + this.hellRNG.nextInt(16) + 8;
l1 = this.hellRNG.nextInt(128);
i2 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenGlowStone2()).generate(this.worldObj, this.hellRNG, k1, l1, i2);
}
MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(worldObj, hellRNG, k, l));
doGen = TerrainGen.decorate(worldObj, hellRNG, k, l, SHROOM);
if (doGen && this.hellRNG.nextInt(1) == 0)
{
j1 = k + this.hellRNG.nextInt(16) + 8;
k1 = this.hellRNG.nextInt(128);
l1 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenFlowers(Block.mushroomBrown.blockID)).generate(this.worldObj, this.hellRNG, j1, k1, l1);
}
if (doGen && this.hellRNG.nextInt(1) == 0)
{
j1 = k + this.hellRNG.nextInt(16) + 8;
k1 = this.hellRNG.nextInt(128);
l1 = l + this.hellRNG.nextInt(16) + 8;
(new WorldGenFlowers(Block.mushroomRed.blockID)).generate(this.worldObj, this.hellRNG, j1, k1, l1);
}
WorldGenMinable worldgenminable = new WorldGenMinable(Block.oreNetherQuartz.blockID, 13, Block.netherrack.blockID);
int j2;
for (k1 = 0; k1 < 16; ++k1)
{
l1 = k + this.hellRNG.nextInt(16);
i2 = this.hellRNG.nextInt(108) + 10;
j2 = l + this.hellRNG.nextInt(16);
worldgenminable.generate(this.worldObj, this.hellRNG, l1, i2, j2);
}
for (k1 = 0; k1 < 16; ++k1)
{
l1 = k + this.hellRNG.nextInt(16);
i2 = this.hellRNG.nextInt(108) + 10;
j2 = l + this.hellRNG.nextInt(16);
(new WorldGenHellLava(Block.lavaMoving.blockID, true)).generate(this.worldObj, this.hellRNG, l1, i2, j2);
}
biomegenbase.decorate(this.worldObj, this.hellRNG, k, l);
SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.hellRNG);
MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(worldObj, hellRNG, k, l));
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, hellRNG, par2, par3, false));
BlockSand.fallInstantly = false;
}
/**
* Two modes of operation: if passed true, save all Chunks in one go. If passed false, save up to two chunks.
* Return true if all chunks have been saved.
*/
public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate)
{
return true;
}
public void func_104112_b() {}
/**
* Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk.
*/
public boolean unloadQueuedChunks()
{
return false;
}
/**
* Returns if the IChunkProvider supports saving.
*/
public boolean canSave()
{
return true;
}
/**
* Converts the instance data to a readable string.
*/
public String makeString()
{
return "HellRandomLevelSource";
}
/**
* Returns a list of creatures of the specified type that can spawn at the given location.
*/
public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
{
if (par1EnumCreatureType == EnumCreatureType.monster && this.genNetherBridge.hasStructureAt(par2, par3, par4))
{
return this.genNetherBridge.getSpawnList();
}
else
{
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2, par4);
return biomegenbase == null ? null : biomegenbase.getSpawnableList(par1EnumCreatureType);
}
}
/**
* Returns the location of the closest structure of the specified type. If not found returns null.
*/
public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
{
return null;
}
public int getLoadedChunkCount()
{
return 0;
}
public void recreateStructures(int par1, int par2)
{
this.genNetherBridge.generate(this, this.worldObj, par1, par2, (byte[])null);
}
}
Now i think that's everythink i think, if you still have issues send me a download for the files and i will edit it to work with yours
also i commented out the gravel/slowSand gen so you can un comment them if u need to
hope this helps
Thanks man but, it won't let me use a custom main filler besides netherrack. I have a custom stone I would like to use, however, when I try to use it, the top blocks don't generate, and I can't find the problem :c
It is? It looks just like the Erebus one
I just.. don't understand XD how did you do it?? I've spent weeks trying to do this. Also, is there a way to generate a ground covering like snow in the taiga biome? because I have my own ground covering block that I'd like to use.
One more thing, could you figure out how to hook biomes into this? I tried your tutorial and a couple others, none of them worked :c
EDIT: I changed netherrack to my custom stone and the top blocks didn't generate
Thanks a bunch dude you can also join our skype group if you would like to pre-alpha test the mod, once we have a working playable pre-alpha i'll be distributing it to everyone on the team and a couple friends on there. Or I could just private message a link, either way works.
Sorry , didn't see that there are 2 pages and answered to an already solved question.
Input is always welcome though!
Sweet will do!
Thanks man but, it won't let me use a custom main filler besides netherrack. I have a custom stone I would like to use, however, when I try to use it, the top blocks don't generate, and I can't find the problem :c