[Custom Biomes][Custom Dimension] Multiple Biomes how?

OwnAgePau · May 4, 2013

Hi there,

My biome is working so far, and i'm trying to find my way to generate my dimension without using the base classes BiomeGenBase & BiomeDecorator, so far i got my biome te decorate and to spawn in my custom dimension (which generates like the nether).

I would like to have 2 or more biomes to spawn in my custom dimension. How to do that?

I am using forge v 7.7.1.611 and Mcp 7.44.

I am also having troubles with the use of a customBiomeDecorator.

i have tried the following things:

- Searched a lot of forums/tutorials about 2 or more biomes to spawn in your dimension, haven't found anything about it so far.

- Found a tutorial about a customBiomeDecorator, followed it but didn't still work.

(with the normal BiomeDecorator it all worked fine aswell)

- I now have placed the "WorldGen.generate();" inside the chunkprovider but if i wan't to use more biomes this wouldn't work well, or is there anyway you can do a biomeid check or something?

These are my files:

mod_Ores

package Mod_Ores;

import java.util.Random;

import Mod_Ores.Mobs.EntityBlueSlime;
import Mod_Ores.Mobs.EntityEnt;
import Mod_Ores.Mobs.EntitySnowCreeper;

import net.minecraft.block.Block;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.entity.monster.EntityMob;
import net.minecraft.item.EnumArmorMaterial;
import net.minecraft.item.EnumToolMaterial;
import net.minecraft.item.Item;
import net.minecraft.item.ItemFood;
import net.minecraft.item.ItemStack;
import net.minecraft.src.ModLoader;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.gen.feature.WorldGenMinable;
import net.minecraftforge.common.DimensionManager;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.network.NetworkMod;
import cpw.mods.fml.common.network.NetworkMod.SidedPacketHandler;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.common.registry.LanguageRegistry;

@Mod(modid="myOresMod", name="Extra Ores Mod", version="1.1.2")
@NetworkMod(clientSideRequired = true, serverSideRequired = false, clientPacketHandlerSpec =
@SidedPacketHandler(channels = {"mod_Ores" }, packetHandler = ClientPacketHandler.class),
serverPacketHandlerSpec =
@SidedPacketHandler(channels = {"mod_Ores" }, packetHandler = ServerPacketHandler.class))
public class mod_Ores
{
@Instance("myOresMod") // instance
    public static mod_Ores instance;
private IGuiHandlerCustom guiHandler = new IGuiHandlerCustom();
    public static BiomeGenBase SoulForest;
    public static BiomeGenBase FrostCaves;
public static int DimensionSoulForest = 20;

@Init
public void load(FMLInitializationEvent ev)
{		
	GameRegistry.registerWorldGenerator(new WorldGeneratorSoulTrees());
	SoulForest = (new BiomeGenSoulForest(23).setBiomeName("SoulForest").setDisableRain().setMinMaxHeight(0.0F, 0.9F)); //Custom Biome
	FrostCaves = (new BiomeGenFrostCaves(24).setBiomeName("FrostCaves").setEnableSnow().setTemperatureRainfall(0.05F, 0.8F).setMinMaxHeight(0.0F, 0.9F)); //Custom Biome
	GameRegistry.addBiome(SoulForest);
	GameRegistry.addBiome(FrostCaves);
//Dimension
	DimensionManager.registerProviderType(DimensionSoulForest, WorldProviderMarona.class, false);
	DimensionManager.registerDimension(DimensionSoulForest, DimensionSoulForest);
//Entity Blue Slime
		ModLoader.registerEntityID(EntityBlueSlime.class, "Blue Slime", ModLoader.getUniqueEntityId());
		ModLoader.addSpawn(EntityBlueSlime.class, 7, 5, 10, EnumCreatureType.monster, SoulForest);

		//Entity Snow Creeper
		ModLoader.registerEntityID(EntitySnowCreeper.class, "Snow Creeper", ModLoader.getUniqueEntityId());
		ModLoader.addSpawn(EntitySnowCreeper.class, 6, 2, 4, EnumCreatureType.monster, SoulForest);
}

public String getVersion()
{
	return "1.5.1";
}
}

BiomeGenSoulForest

package Mod_Ores;

import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeDecorator;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.biome.SpawnListEntry;
import net.minecraft.world.gen.feature.WorldGenerator;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.terraingen.DecorateBiomeEvent;
import Mod_Ores.Mobs.EntityBlueSlime;
import Mod_Ores.Mobs.EntityEnt;
import Mod_Ores.Mobs.EntitySnowCreeper;

public class BiomeGenSoulForest extends BiomeGenBase
{
TheBiomeDeco customBiomeDecorator;

public BiomeGenSoulForest(int par1)
    {
        super(par1);
        //this.topBlock = (byte)mod_Ores.LateriteGrass.blockID;
        //this.fillerBlock = (byte)mod_Ores.LateriteDirt.blockID;
        this.topBlock = (byte)Block.grass.blockID;
        this.fillerBlock = (byte)Block.dirt.blockID;
        
        spawnableMonsterList.add(new SpawnListEntry(EntityBlueSlime.class, 7, 5, 10));
        spawnableMonsterList.add(new SpawnListEntry(EntityEnt.class, 8, 3, 5));
        spawnableMonsterList.add(new SpawnListEntry(EntitySnowCreeper.class, 10, 2, 4));
        theBiomeDecorator = new TheBiomeDeco(this);
        customBiomeDecorator = (TheBiomeDeco)theBiomeDecorator;
        customBiomeDecorator.treesPerChunk = 10;
        customBiomeDecorator.baneberryvineperchunk = 3;
        customBiomeDecorator.blueberryvineperchunk = 5;
        customBiomeDecorator.blackberryvineperchunk = 3;
        customBiomeDecorator.cranberryvineperchunk = 5;
        customBiomeDecorator.raspberryvineperchunk = 4;
        customBiomeDecorator.razzberryvineperchunk = 4;
        customBiomeDecorator.strawberryvineperchunk = 6;
        customBiomeDecorator.grapetreeperchunk = 20;
        customBiomeDecorator.mushroomsPerChunk = 30;
        customBiomeDecorator.grassPerChunk = 40;
    }
}

ChunkProviderMarona

package Mod_Ores;

import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON;
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 static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE;
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.WorldGenDungeons;
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.WorldGenLiquids;
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 static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.*;
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*;
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*;
import net.minecraftforge.event.terraingen.TerrainGen;

public class ChunkProviderMarona implements IChunkProvider
{
//NETHER SOUL FOREST IDEA	

private Random soulRNG;

    /** A NoiseGeneratorOctaves used in generating nether terrain */
    private NoiseGeneratorOctaves netherNoiseGen1;
    private NoiseGeneratorOctaves netherNoiseGen2;
    private NoiseGeneratorOctaves netherNoiseGen3;
    public NoiseGeneratorOctaves mobSpawnerNoise;

    /** Determines whether lateriteGrass or porphyry can be generated at a location */
    private NoiseGeneratorOctaves lateriteGrassPorphyryNoise;

    /**
     * Determines whether something other than porphyry can be generated at a location
     */
    private NoiseGeneratorOctaves porphyryExclusivityNoiseGen;
    public NoiseGeneratorOctaves netherNoiseGen6;
    public NoiseGeneratorOctaves netherNoiseGen7;

    /** The biomes that are used to generate the chunk */
    private BiomeGenBase[] biomesForGeneration;
   
    /** 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 lateriteGrass can be generated at a location
     */
    private double[] lateriteGrassNoise = new double[256];
    private double[] porphyryNoise = new double[256];

    /**
     * Holds the noise used to determine whether something other than porphyry can be generated at a location
     */
    private double[] porphyryExclusivityNoise = new double[256];
    private MapGenBase netherCaveGenerator = new MapGenCavesHell();
    double[] noiseData1;
    double[] noiseData2;
    double[] noiseData3;
    double[] noiseData4;
    double[] noiseData5;

private Object theBiomeDecorator;

    public ChunkProviderMarona(World par1World, long par2)
    {
        this.worldObj = par1World;
        this.soulRNG = new Random(par2);
        this.netherNoiseGen1 = new NoiseGeneratorOctaves(this.soulRNG, 16);
        this.netherNoiseGen2 = new NoiseGeneratorOctaves(this.soulRNG, 16);
        this.netherNoiseGen3 = new NoiseGeneratorOctaves(this.soulRNG, ;
        this.lateriteGrassPorphyryNoise = new NoiseGeneratorOctaves(this.soulRNG, 4);
        this.porphyryExclusivityNoiseGen = new NoiseGeneratorOctaves(this.soulRNG, 4);
        this.netherNoiseGen6 = new NoiseGeneratorOctaves(this.soulRNG, 10);
        this.netherNoiseGen7 = new NoiseGeneratorOctaves(this.soulRNG, 16);
        this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.soulRNG, ;

        NoiseGeneratorOctaves[] noiseGens = {netherNoiseGen1, netherNoiseGen2, netherNoiseGen3, lateriteGrassPorphyryNoise, porphyryExclusivityNoiseGen, netherNoiseGen6, netherNoiseGen7, mobSpawnerNoise};
        noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.soulRNG, noiseGens);
        this.netherNoiseGen1 = noiseGens[0];
        this.netherNoiseGen2 = noiseGens[1];
        this.netherNoiseGen3 = noiseGens[2];
        this.lateriteGrassPorphyryNoise = noiseGens[3];
        this.porphyryExclusivityNoiseGen = noiseGens[4];
        this.netherNoiseGen6 = noiseGens[5];
        this.netherNoiseGen7 = noiseGens[6];
        this.mobSpawnerNoise = noiseGens[7];
    }

    
    /**
     * 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.waterStill.blockID;
                                }

                                if (d15 > 0.0D)
                                {
                                    l2 = (byte)mod_Ores.Porphyry.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)
    {
        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.lateriteGrassNoise = this.lateriteGrassPorphyryNoise.generateNoiseOctaves(this.lateriteGrassNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0, d0, 1.0D);
        this.porphyryNoise = this.lateriteGrassPorphyryNoise.generateNoiseOctaves(this.porphyryNoise, par1 * 16, 109, par2 * 16, 16, 1, 16, d0, 1.0D, d0);
        this.porphyryExclusivityNoise = this.porphyryExclusivityNoiseGen.generateNoiseOctaves(this.porphyryExclusivityNoise, 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[l + k * 16];
                boolean flag = this.lateriteGrassNoise[k + l * 16] + this.soulRNG.nextDouble() * 0.2D > 0.0D;
                boolean flag1 = this.porphyryNoise[k + l * 16] + this.soulRNG.nextDouble() * 0.2D > 0.0D;
                int i1 = (int)(this.porphyryExclusivityNoise[k + l * 16] / 3.0D + 3.0D + this.soulRNG.nextDouble() * 0.25D);
                int j1 = -1;
                byte b1 = biomegenbase.topBlock;
                byte b2 = biomegenbase.fillerBlock;

                for (int k1 = 127; k1 >= 0; --k1)
                {
                    int l1 = (l * 16 + k) * 128 + k1;

                    if (k1 < 127 - this.soulRNG.nextInt(5) && k1 > 0 + this.soulRNG.nextInt(5))
                    {
                        byte b3 = par3ArrayOfByte[l1];

                        if (b3 == 0)
                        {
                            j1 = -1;
                        }
                        else if (b3 == (byte)mod_Ores.Porphyry.blockID)
                        {
                            if (j1 == -1)
                            {
                                if (i1 <= 0)
                                {
                                    b1 = 0;
                                    b2 = (byte)mod_Ores.Porphyry.blockID;
                                }
                                else if (k1 >= b0 - 4 && k1 <= b0 + 1)
                                {
                                	 b1 = biomegenbase.topBlock;
                                     b2 = biomegenbase.fillerBlock;

                                    if (flag1)
                                    {
                                        b1 = (byte)Block.grass.blockID;
                                    }

                                    if (flag1)
                                    {
                                        b2 = (byte)mod_Ores.Porphyry.blockID;
                                    }

                                    if (flag)
                                    {
                                        b1 = (byte)Block.grass.blockID;
                                    }

                                    if (flag)
                                    {
                                        b2 = (byte)mod_Ores.Slate.blockID;
                                    }
                                }

                                if (k1 < b0 && b1 == 0)
                                {
                                    b1 = (byte)Block.waterStill.blockID;
                                }

                                j1 = i1;

                                if (k1 >= b0 - 1)
                                {
                                    par3ArrayOfByte[l1] = b1;
                                }
                                else
                                {
                                    par3ArrayOfByte[l1] = 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
     */
    @Override
    public Chunk provideChunk(int par1, int par2)
    {
        this.soulRNG.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
        byte[] abyte = new byte[32768];
        this.generateNetherTerrain(par1, par2, abyte);
        this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
        this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);
        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);
        BiomeGenBase[] abiomegenbase = this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[])null, par1 * 16, par2 * 16, 16, 16);
        byte[] abyte1 = chunk.getBiomeArray();

        for (int k = 0; k < abyte1.length; ++k)
        {
            abyte1[k] = (byte)abiomegenbase[k].biomeID;
        }

        chunk.resetRelightChecks();
        return chunk;
    }

    public void decorate(World par1World, Random par2Random, int par3, int par4)
    {
        ((BiomeGenBase) this.theBiomeDecorator).decorate(par1World, par2Random, par3, par4);
    }
    /**
     * 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, soulRNG, par2, par3, false));

        int k = par2 * 16;
        int l = par3 * 16;
        //this.genNetherBridge.generateStructuresInChunk(this.worldObj, this.soulRNG, par2, par3);
        int i1;
        int j1;
        int k1;
        int l1 = 0;

        boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, soulRNG, par2, par3, false, NETHER_LAVA);
        for (i1 = 0; doGen && i1 < 8; ++i1)
        {
            j1 = k + this.soulRNG.nextInt(16) + 8;
            k1 = this.soulRNG.nextInt(128) + 4;
            l1 = l + this.soulRNG.nextInt(16) + 8;
            (new WorldGenHellLava(Block.waterMoving.blockID, false)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        
        //doGen = TerrainGen.populate(par1IChunkProvider, worldObj, soulRNG, par2, par3, false, DUNGEON);

        MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(worldObj, soulRNG, k, l));
        
        /*doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, TREE);
        for (int i = 0; i < 100; ++i)
        {
                j1 = k + soulRNG.nextInt(16) + 8;
                k1 = soulRNG.nextInt(128);
                l1 = l + soulRNG.nextInt(16) + 8;
                (new WorldGenGrapeTree(true)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }*/
        
        i1 = this.soulRNG.nextInt(this.soulRNG.nextInt(10) + 1) + 1;
        int i2;
        
        doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, SHROOM);
        if (doGen && this.soulRNG.nextInt(1) == 0)
        {
            j1 = k + this.soulRNG.nextInt(16) + 8;
            k1 = this.soulRNG.nextInt(128);
            l1 = l + this.soulRNG.nextInt(16) + 8;
            (new WorldGenFlowers(Block.mushroomBrown.blockID)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }

        doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, SHROOM);
        if (doGen && this.soulRNG.nextInt(1) == 0)
        {
            j1 = k + this.soulRNG.nextInt(16) + 8;
            k1 = this.soulRNG.nextInt(128);
            l1 = l + this.soulRNG.nextInt(16) + 8;
            (new WorldGenFlowers(Block.mushroomRed.blockID)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        
        /*doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, FLOWERS);
        if (doGen && this.soulRNG.nextInt(1) == 0)
        {
            j1 = k + this.soulRNG.nextInt(16) + 8;
            k1 = this.soulRNG.nextInt(128);
            l1 = l + this.soulRNG.nextInt(16) + 8;
            (new WorldGenFlowers(mod_Ores.plantCantaloupe.blockID)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }*/
        
        
        for (int i = 0; i < 1; ++i)
        {
       	 	j1 = k + soulRNG.nextInt(16);
       	 	k1 = soulRNG.nextInt(128);
       	 	l1 = l + soulRNG.nextInt(16);
            (new WorldGenSoulTemple()).generate(worldObj, soulRNG, j1, k1, l1);
        }
	for (int g1 = 0; g1 < 50; g1++)
        {
		j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenGrapeTree(false)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        //vines
        for (int g1 = 0; g1 < 8; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenBaneberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        for (int g1 = 0; g1 < 7; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenBlueberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        for (int g1 = 0; g1 < 9; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenBlackberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        for (int g1 = 0; g1 < 13; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenCranberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        for (int g1 = 0; g1 < 10; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenRaspberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        for (int g1 = 0; g1 < 12; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenRazzberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
        for (int g1 = 0; g1 < 15; g1++)
        {
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenStrawberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }
      //flowers
        /*for (int g1 = 0; g1 < 10; g1++)
        {      
        	j1 = k + this.soulRNG.nextInt(16) + 8;
		k1 = this.soulRNG.nextInt(128);
		l1 = l + this.soulRNG.nextInt(16) + 8;
        (new WorldGenCantaloupe(2000)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
        }*/
                
        // #region Ore Gen
        WorldGenMinable worldgenminable;
        int j2;

        for (int i = 0; i < 7; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 6 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Amazoniteore.blockID, 7, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Amethystore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);	
		(new WorldGenMinable(mod_Ores.Aquamarineore.blockID, 9, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 2; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 12 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Blackdiamondore.blockID, 5, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 7; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 6 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Chromiteore.blockID, 7, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);	
		(new WorldGenMinable(mod_Ores.Citrineore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 7; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);	
		(new WorldGenMinable(mod_Ores.Emeraldore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Jadeore.blockID, 8, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);	
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Jetore.blockID, 8, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Lilaore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 4; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 8 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Mithrilore.blockID, 6, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 8; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Olivineore.blockID, 8, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 2; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 10 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);	
		(new WorldGenMinable(mod_Ores.Onyxore.blockID, 4, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 13; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 1 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Opalore.blockID, 12, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 8 ; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 5 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Rubyore.blockID, 5, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 8; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 5 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Sapphireore.blockID, 5, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Scarletiteore.blockID, 6, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 9; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 4 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Tanzaniteore.blockID, 7, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 2; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 11 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Titaniumore.blockID, 4, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 10; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Topazore.blockID, 7, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 10; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Turquoiseore.blockID, 8, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 10; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Violetore.blockID, 7, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}
	for (int i = 0; i < 10; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Whiteopalore.blockID, 6, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}		
	for (int i = 0; i < 5; i++)
	{
		int randPosX = k + soulRNG.nextInt(16);
		int randPosY = soulRNG.nextInt(128);				//Rarerity 3 (1-15) 1 is very common 15 is extremely rare
		int randPosZ = l + soulRNG.nextInt(16);
		(new WorldGenMinable(mod_Ores.Bauxite.blockID, 30,mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
	}	

        for (k1 = 0; k1 < 16; ++k1)
        {
            l1 = k + this.soulRNG.nextInt(16);
            i2 = this.soulRNG.nextInt(108) + 10;
            j2 = l + this.soulRNG.nextInt(16);
            (new WorldGenHellLava(Block.waterMoving.blockID, true)).generate(this.worldObj, this.soulRNG, l1, i2, j2);
        }

        MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(worldObj, soulRNG, k, l));
        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, soulRNG, 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;
    }

    /**
     * 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 "SoulForestLevelSource";
    }

    /**
     * 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);
    }



//NORMAL SOULFOREST IDEA


/*	/** RNG. */
/*    private Random rand;

    /** A NoiseGeneratorOctaves used in generating terrain */
/*    private NoiseGeneratorOctaves noiseGen1;

    /** A NoiseGeneratorOctaves used in generating terrain */
/*    private NoiseGeneratorOctaves noiseGen2;

    /** A NoiseGeneratorOctaves used in generating terrain */
/*    private NoiseGeneratorOctaves noiseGen3;

    /** A NoiseGeneratorOctaves used in generating terrain */
/*    private NoiseGeneratorOctaves noiseGen4;

    /** A NoiseGeneratorOctaves used in generating terrain */
/*    public NoiseGeneratorOctaves noiseGen5;

    /** A NoiseGeneratorOctaves used in generating terrain */
/*    public NoiseGeneratorOctaves noiseGen6;
    public NoiseGeneratorOctaves mobSpawnerNoise;

    /** Reference to the World object. */
/*    private World worldObj;

    /** are map structures going to be generated (e.g. strongholds) */
/*    private final boolean mapFeaturesEnabled;

    /** Holds the overall noise array used in chunk generation */
/*    private double[] noiseArray;
    private double[] stoneNoise = new double[256];
    private MapGenBase caveGenerator = new MapGenCaves();

    /** Holds Stronghold Generator */
/*    private MapGenStronghold strongholdGenerator = new MapGenStronghold();

    /** Holds Village Generator */
/*    private MapGenVillage villageGenerator = new MapGenVillage();

    /** Holds Mineshaft Generator */
/*    private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();
    private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();

    /** Holds ravine generator */
/*    private MapGenBase ravineGenerator = new MapGenRavine();

    /** The biomes that are used to generate the chunk */
/*    private BiomeGenBase[] biomesForGeneration;

    /** A double array that hold terrain noise from noiseGen3 */
/*    double[] noise3;

    /** A double array that hold terrain noise */
/*    double[] noise1;

    /** A double array that hold terrain noise from noiseGen2 */
/*    double[] noise2;

    /** A double array that hold terrain noise from noiseGen5 */
/*    double[] noise5;

    /** A double array that holds terrain noise from noiseGen6 */
/*    double[] noise6;

    /**
     * Used to store the 5x5 parabolic field that is used during terrain generation.
     */
/*    float[] parabolicField;
    int[][] field_73219_j = new int[32][32];

    {
        caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);
        strongholdGenerator = (MapGenStronghold) TerrainGen.getModdedMapGen(strongholdGenerator, STRONGHOLD);
        villageGenerator = (MapGenVillage) TerrainGen.getModdedMapGen(villageGenerator, VILLAGE);
        mineshaftGenerator = (MapGenMineshaft) TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT);
        scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);
        ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);
    }

    public ChunkProviderMarona(World par1World, long par2, boolean par4)
    {
        this.worldObj = par1World;
        this.mapFeaturesEnabled = par4;
        this.rand = new Random(par2);
        this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);
        this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);
        this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, ;
        this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4);
        this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
        this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
        this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, ;

        NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise};
        noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.rand, noiseGens);
        this.noiseGen1 = noiseGens[0];
        this.noiseGen2 = noiseGens[1];
        this.noiseGen3 = noiseGens[2];
        this.noiseGen4 = noiseGens[3];
        this.noiseGen5 = noiseGens[4];
        this.noiseGen6 = noiseGens[5];
        this.mobSpawnerNoise = noiseGens[6];
    }

    /**
     * Generates the shape of the terrain for the chunk though its all stone though the water is frozen if the
     * temperature is low enough
     */
/*    public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte)
    {
        byte b0 = 4;
        byte b1 = 16;
        byte b2 = 63;
        int k = b0 + 1;
        byte b3 = 17;
        int l = b0 + 1;
        this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, k + 5, l + 5);
        this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * b0, 0, par2 * b0, k, b3, l);

        for (int i1 = 0; i1 < b0; ++i1)
        {
            for (int j1 = 0; j1 < b0; ++j1)
            {
                for (int k1 = 0; k1 < b1; ++k1)
                {
                    double d0 = 0.125D;
                    double d1 = this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 0];
                    double d2 = this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 0];
                    double d3 = this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 0];
                    double d4 = this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 0];
                    double d5 = (this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 1] - d1) * d0;
                    double d6 = (this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 1] - d2) * d0;
                    double d7 = (this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 1] - d3) * d0;
                    double d8 = (this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + 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;
                            j2 -= short1;
                            double d14 = 0.25D;
                            double d15 = (d11 - d10) * d14;
                            double d16 = d10 - d15;

                            for (int k2 = 0; k2 < 4; ++k2)
                            {
                                if ((d16 += d15) > 0.0D)
                                {
                                    par3ArrayOfByte[j2 += short1] = (byte)mod_Ores.Porphyry.blockID;
                                }
                                else if (k1 * 8 + l1 < b2)
                                {
                                    par3ArrayOfByte[j2 += short1] = (byte)Block.waterStill.blockID;
                                }
                                else
                                {
                                    par3ArrayOfByte[j2 += short1] = 0;
                                }
                            }

                            d10 += d12;
                            d11 += d13;
                        }

                        d1 += d5;
                        d2 += d6;
                        d3 += d7;
                        d4 += d8;
                    }
                }
            }
        }
    }

    /**
     * Replaces the stone that was placed in with blocks that match the biome
     */
/*    public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
    {
        ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase);
        MinecraftForge.EVENT_BUS.post(event);
        if (event.getResult() == Result.DENY) return;

        byte b0 = 63;
        double d0 = 0.03125D;
        this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, 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[l + k * 16];
                float f = biomegenbase.getFloatTemperature();
                int i1 = (int)(this.stoneNoise[k + l * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);
                int j1 = -1;
                byte b1 = biomegenbase.topBlock;
                byte b2 = biomegenbase.fillerBlock;

                for (int k1 = 127; k1 >= 0; --k1)
                {
                    int l1 = (l * 16 + k) * 128 + k1;

                    if (k1 <= 0 + this.rand.nextInt(5))
                    {
                        par3ArrayOfByte[l1] = (byte)Block.bedrock.blockID;
                    }
                    else
                    {
                        byte b3 = par3ArrayOfByte[l1];

                        if (b3 == 0)
                        {
                            j1 = -1;
                        }
                        else if (b3 == (byte)mod_Ores.Porphyry.blockID)
                        {
                            if (j1 == -1)
                            {
                                if (i1 <= 0)
                                {
                                    b1 = 0;
                                    b2 = (byte)mod_Ores.Porphyry.blockID;
                                }
                                else if (k1 >= b0 - 4 && k1 <= b0 + 1)
                                {
                                    b1 = biomegenbase.topBlock;
                                    b2 = biomegenbase.fillerBlock;
                                }

                                if (k1 < b0 && b1 == 0)
                                {
                                    if (f < 0.15F)
                                    {
                                        b1 = (byte)Block.waterStill.blockID;
                                    }
                                    else
                                    {
                                        b1 = (byte)Block.waterStill.blockID;
                                    }
                                }

                                j1 = i1;

                                if (k1 >= b0 - 1)
                                {
                                    par3ArrayOfByte[l1] = b1;
                                }
                                else
                                {
                                    par3ArrayOfByte[l1] = b2;
                                }
                            }
                            else if (j1 > 0)
                            {
                                --j1;
                                par3ArrayOfByte[l1] = b2;

                                if (j1 == 0 && b2 == (byte)mod_Ores.Slate.blockID)
                                {
                                    j1 = this.rand.nextInt(4);
                                    b2 = (byte)mod_Ores.Slate.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)
    {
        this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
        byte[] abyte = new byte[32768];
        this.generateTerrain(par1, par2, abyte);
        this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
        this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);
        this.caveGenerator.generate(this, this.worldObj, par1, par2, abyte);
        this.ravineGenerator.generate(this, this.worldObj, par1, par2, abyte);

        if (this.mapFeaturesEnabled)
        {
            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, abyte);
            this.villageGenerator.generate(this, this.worldObj, par1, par2, abyte);
            this.strongholdGenerator.generate(this, this.worldObj, par1, par2, abyte);
            this.scatteredFeatureGenerator.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)this.biomesForGeneration[k].biomeID;
        }

        chunk.generateSkylightMap();
        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];
        }

        if (this.parabolicField == null)
        {
            this.parabolicField = new float[25];

            for (int k1 = -2; k1 <= 2; ++k1)
            {
                for (int l1 = -2; l1 <= 2; ++l1)
                {
                    float f = 10.0F / MathHelper.sqrt_float((float)(k1 * k1 + l1 * l1) + 0.2F);
                    this.parabolicField[k1 + 2 + (l1 + 2) * 5] = f;
                }
            }
        }

        double d0 = 684.412D;
        double d1 = 684.412D;
        this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
        this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
        this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D);
        this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, d0, d1, d0);
        this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, d0, d1, d0);
        boolean flag = false;
        boolean flag1 = false;
        int i2 = 0;
        int j2 = 0;

        for (int k2 = 0; k2 < par5; ++k2)
        {
            for (int l2 = 0; l2 < par7; ++l2)
            {
                float f1 = 0.0F;
                float f2 = 0.0F;
                float f3 = 0.0F;
                byte b0 = 2;
                BiomeGenBase biomegenbase = this.biomesForGeneration[k2 + 2 + (l2 + 2) * (par5 + 5)];

                for (int i3 = -b0; i3 <= b0; ++i3)
                {
                    for (int j3 = -b0; j3 <= b0; ++j3)
                    {
                        BiomeGenBase biomegenbase1 = this.biomesForGeneration[k2 + i3 + 2 + (l2 + j3 + 2) * (par5 + 5)];
                        float f4 = this.parabolicField[i3 + 2 + (j3 + 2) * 5] / (biomegenbase1.minHeight + 2.0F);

                        if (biomegenbase1.minHeight > biomegenbase.minHeight)
                        {
                            f4 /= 2.0F;
                        }

                        f1 += biomegenbase1.maxHeight * f4;
                        f2 += biomegenbase1.minHeight * f4;
                        f3 += f4;
                    }
                }

                f1 /= f3;
                f2 /= f3;
                f1 = f1 * 0.9F + 0.1F;
                f2 = (f2 * 4.0F - 1.0F) / 8.0F;
                double d2 = this.noise6[j2] / 8000.0D;

                if (d2 < 0.0D)
                {
                    d2 = -d2 * 0.3D;
                }

                d2 = d2 * 3.0D - 2.0D;

                if (d2 < 0.0D)
                {
                    d2 /= 2.0D;

                    if (d2 < -1.0D)
                    {
                        d2 = -1.0D;
                    }

                    d2 /= 1.4D;
                    d2 /= 2.0D;
                }
                else
                {
                    if (d2 > 1.0D)
                    {
                        d2 = 1.0D;
                    }

                    d2 /= 8.0D;
                }

                ++j2;

                for (int k3 = 0; k3 < par6; ++k3)
                {
                    double d3 = (double)f2;
                    double d4 = (double)f1;
                    d3 += d2 * 0.2D;
                    d3 = d3 * (double)par6 / 16.0D;
                    double d5 = (double)par6 / 2.0D + d3 * 4.0D;
                    double d6 = 0.0D;
                    double d7 = ((double)k3 - d5) * 12.0D * 128.0D / 128.0D / d4;

                    if (d7 < 0.0D)
                    {
                        d7 *= 4.0D;
                    }

                    double d8 = this.noise1[i2] / 512.0D;
                    double d9 = this.noise2[i2] / 512.0D;
                    double d10 = (this.noise3[i2] / 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;

                    if (k3 > par6 - 4)
                    {
                        double d11 = (double)((float)(k3 - (par6 - 4)) / 3.0F);
                        d6 = d6 * (1.0D - d11) + -10.0D * d11;
                    }

                    par1ArrayOfDouble[i2] = d6;
                    ++i2;
                }
            }
        }

        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;
        int k = par2 * 16;
        int l = par3 * 16;
        BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(k + 16, l + 16);
        this.rand.setSeed(this.worldObj.getSeed());
        long i1 = this.rand.nextLong() / 2L * 2L + 1L;
        long j1 = this.rand.nextLong() / 2L * 2L + 1L;
        this.rand.setSeed((long)par2 * i1 + (long)par3 * j1 ^ this.worldObj.getSeed());
        boolean flag = false;

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, rand, par2, par3, flag));

        if (this.mapFeaturesEnabled)
        {
            this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
            flag = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
            this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
            this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
        }

        int k1;
        int l1;
        int i2;

        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, LAKE) && 
                !flag && this.rand.nextInt(4) == 0)
        {
            k1 = k + this.rand.nextInt(16) + 8;
            l1 = this.rand.nextInt(128);
            i2 = l + this.rand.nextInt(16) + 8;
            (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, k1, l1, i2);
        }

        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, LAVA) &&
                !flag && this.rand.nextInt( == 0)
        {
            k1 = k + this.rand.nextInt(16) + 8;
            l1 = this.rand.nextInt(this.rand.nextInt(120) + ;
            i2 = l + this.rand.nextInt(16) + 8;

            if (l1 < 63 || this.rand.nextInt(10) == 0)
            {
                (new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, k1, l1, i2);
            }
        }

        boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, DUNGEON);
        for (k1 = 0; doGen && k1 < 8; ++k1)
        {
            l1 = k + this.rand.nextInt(16) + 8;
            i2 = this.rand.nextInt(128);
            int j2 = l + this.rand.nextInt(16) + 8;

            if ((new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2))
            {
                ;
            }
        }

        biomegenbase.decorate(this.worldObj, this.rand, k, l);
        SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand);
        k += 8;
        l += 8;

        doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, ICE);
        for (k1 = 0; doGen && k1 < 16; ++k1)
        {
            for (l1 = 0; l1 < 16; ++l1)
            {
                i2 = this.worldObj.getPrecipitationHeight(k + k1, l + l1);

                if (this.worldObj.isBlockFreezable(k1 + k, i2 - 1, l1 + l))
                {
                    this.worldObj.setBlock(k1 + k, i2 - 1, l1 + l, Block.ice.blockID, 0, 2);
                }

                if (this.worldObj.canSnowAt(k1 + k, i2, l1 + l))
                {
                    this.worldObj.setBlock(k1 + k, i2, l1 + l, Block.snow.blockID, 0, 2);
                }
            }
        }

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, rand, par2, par3, flag));

        BlockSand.fallInstantly = true;
    }

    /**
     * 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;
    }

    /**
     * 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 "RandomLevelSource";
    }

    /**
     * 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)
    {
        BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2, par4);
        return biomegenbase == null ? null : (biomegenbase == BiomeGenBase.swampland && par1EnumCreatureType == EnumCreatureType.monster && this.scatteredFeatureGenerator.hasStructureAt(par2, par3, par4) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : 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 "Stronghold".equals(par2Str) && this.strongholdGenerator != null ? this.strongholdGenerator.getNearestInstance(par1World, par3, par4, par5) : null;
    }

    public int getLoadedChunkCount()
    {
        return 0;
    }

    public void recreateStructures(int par1, int par2)
    {
        if (this.mapFeaturesEnabled)
        {
            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);
            this.villageGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);
            this.strongholdGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);
            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);
        }
    }*/
}

WorldProviderMarona

package Mod_Ores;

import java.util.Random;

import net.minecraft.world.WorldProviderHell;
import net.minecraft.world.WorldProviderSurface;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.biome.WorldChunkManager;
import net.minecraft.world.biome.WorldChunkManagerHell;
import net.minecraft.world.chunk.IChunkProvider;

public class WorldProviderMarona extends WorldProviderSurface
{

//The WorldProvider covers all the basics of the dimension. Look in WorldProviderBase.java and
//WorldProvider.java for all the potential qualities you can assign to your dimension.

public WorldProviderMarona()
{
}

//The save file will be called DIM65 (DIM + id number).
public int getDimensionID()
{

	return 65;

}
public String getDimensionName()
{
return "Soul Forest";
}

public String getRespawnMessage()
{

return "Leaving Soul Forest";

}

//You can use an existing WorldChunkManager, or create your own. You must create your own to
//add multiple unique biomes to a dimension.
public void registerWorldChunkManager()
{

this.worldChunkMgr = new WorldChunkManagerHell(mod_Ores.SoulForest, 2.5F, 2.0F); //Your Biome goes here
//worldChunkMgr = new WorldChunkManagerHell(BiomeGenBase.FrostCaves, 2.5F, 2.0F); 
this.dimensionId = mod_Ores.DimensionSoulForest;
}

//This is where you define your terrain generator.
@Override
public IChunkProvider createChunkGenerator()
{

return new ChunkProviderMarona(worldObj, worldObj.getSeed());

}

//Note that, if you respawn in the dimension, you will end up at the coordinates 	of your
//overworld spawn point, not at the location of your first entrance to the dimension or
//something like that. Note also that beds don't work if yo	u cannot respawn in the dimension.
public boolean canRespawnHere()
{

return true;

}

}

Thanks for reading and thanks for your time.

Please help me i'm still trying out different stuff but i would really appreciate your help, even if it is just an idea or a link to a different post.

Every bits help!

Mazetar · May 4, 2013

I did look into this and did some searching, most of the statements I found was like this:

Pain inn the ass hard

I refuse to believe that it's that hard, it's all about commitment

I did find one thread which had some useful information, maybe it could help you on your way?

http://www.minecraftforge.net/forum/index.php?topic=3331.0

The last post at least seems to lead to a good read

It's quite recent so go take a look

Edit: The github seems to have been moved, I guess this is the current location but it wasn't too easy to navigate the folder names: https://github.com/tuyapin/MinecraftMods

robustus · May 5, 2013

biome decorator is not what generates the various biomes, it just decorates them.... I would assume you would need the custom chunkprovider, custom worldprovider, and then you would need to modify the GenLayer and stuff like that, clone the overworld regular field and start tweaking from there.

OwnAgePau · May 18, 2013

Unfortunately i haven't gotten this to work still.

I don't have to make a custom WorldChunkManager, GenLayer (+ all subGenLayer), WorldType, WorldTypeEvent, IntCache, BiomeCacheBlock, BiomeCache etc would i?

I also found out that i could use the list of the normal worldchunkmanager and delete biomes using Forge's .removeBiome(""); But that also deletes it from the overworld. I have tried several things to fix this but i haven't gotten it to work properly with loads of "NullPointerExceptions" and "Exception Ticking World".

Blade Avuari · May 19, 2013

Unfortunately i haven't gotten this to work still.

I don't have to make a custom WorldChunkManager, GenLayer (+ all subGenLayer), WorldType, WorldTypeEvent, IntCache, BiomeCacheBlock, BiomeCache etc would i?

I believe you do, sadly. At least, that's what I had to do when I made my "Dig Deeper!" mod. I'll give you some of the basic stuff from my MCM here.


public class WorldChunkManagerDeeper extends WorldChunkManager
{
    private GenLayer genBiomes;

    /** A GenLayer containing the indices into BiomeGenBase.biomeList[] */
    private GenLayer biomeIndexLayer;

    /** The BiomeCache object for this world. */
    private BiomeCacheDeeper biomeCache;

    /** A list of biomes that the player can spawn in. */
    private List biomesToSpawnIn;

    protected WorldChunkManagerDeeper()
    {
        biomeCache = new BiomeCacheDeeper(this);
        biomesToSpawnIn = new ArrayList();
        biomesToSpawnIn.add(BiomeGenBase.forest);

        biomesToSpawnIn.add(BiomeGenBase.jungleHills);
    }

    public WorldChunkManagerDeeper(long par1, WorldType par3WorldType)
    {
        this();
        GenLayer agenlayer[] = GenLayer.initializeAllBiomeGenerators(par1, par3WorldType);
        genBiomes = agenlayer[0];
        biomeIndexLayer = agenlayer[1];
    }

    public WorldChunkManagerDeeper(World par1World)
    {
        this(par1World.getSeed(), par1World.getWorldInfo().getTerrainType());
    }

    /**
     * Gets the list of valid biomes for the player to spawn in.
     */
    public List getBiomesToSpawnIn()
    {
        return biomesToSpawnIn;
    }

    /**
     * Returns the BiomeGenBase related to the x, z position on the world.
     */
    public BiomeGenBase getBiomeGenAt(int par1, int par2)
    {
        return biomeCache.getBiomeGenAt(par1, par2);
    }

    /**
     * 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 ai[] = biomeIndexLayer.getInts(par2, par3, par4, par5);

        for (int i = 0; i < par4 * par5; i++)
        {
            float f = (float)BiomeGenBase.biomeList[ai[i]].getIntRainfall() / 65536F;

            if (f > 1.0F)
            {
                f = 1.0F;
            }

            par1ArrayOfFloat[i] = f;
        }

        return par1ArrayOfFloat;
    }

    /**
     * Return an adjusted version of a given temperature based on the y height
     */
    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 ai[] = biomeIndexLayer.getInts(par2, par3, par4, par5);

        for (int i = 0; i < par4 * par5; i++)
        {
            float f = (float)BiomeGenBase.biomeList[ai[i]].getIntTemperature() / 65536F;

            if (f > 1.0F)
            {
                f = 1.0F;
            }

            par1ArrayOfFloat[i] = 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 ai[] = genBiomes.getInts(par2, par3, par4, par5);

        for (int i = 0; i < par4 * par5; i++)
        {
            par1ArrayOfBiomeGenBase[i] = BiomeGenBase.biomeList[ai[i]];
        }

        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 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 par2, int par3, int par4, int par5, boolean par6)
    {
        IntCache.resetIntCache();

        if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)
        {
            par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
        }

        if (par6 && par4 == 16 && par5 == 16 && (par2 & 0xf) == 0 && (par3 & 0xf) == 0)
        {
            BiomeGenBase abiomegenbase[] = biomeCache.getCachedBiomes(par2, par3);
            System.arraycopy(abiomegenbase, 0, par1ArrayOfBiomeGenBase, 0, par4 * par5);
            return par1ArrayOfBiomeGenBase;
        }

        int ai[] = biomeIndexLayer.getInts(par2, par3, par4, par5);

        for (int i = 0; i < par4 * par5; i++)
        {
            par1ArrayOfBiomeGenBase[i] = BiomeGenBase.biomeList[ai[i]];
        }

        return par1ArrayOfBiomeGenBase;
    }

    /**
     * checks given Chunk's Biomes against List of allowed ones
     */
    public boolean areBiomesViable(int par1, int par2, int par3, List par4List)
    {
        int i = par1 - par3 >> 2;
        int j = par2 - par3 >> 2;
        int k = par1 + par3 >> 2;
        int l = par2 + par3 >> 2;
        int i1 = (k - i) + 1;
        int j1 = (l - j) + 1;
        int ai[] = genBiomes.getInts(i, j, i1, j1);

        for (int k1 = 0; k1 < i1 * j1; k1++)
        {
            BiomeGenBase biomegenbase = BiomeGenBase.biomeList[ai[k1]];

            if (!par4List.contains(biomegenbase))
            {
                return false;
            }
        }

        return true;
    }

    /**
     * Finds a valid position within a range, that is once of the listed biomes.
     */
    public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random)
    {
        int i = par1 - par3 >> 2;
        int j = par2 - par3 >> 2;
        int k = par1 + par3 >> 2;
        int l = par2 + par3 >> 2;
        int i1 = (k - i) + 1;
        int j1 = (l - j) + 1;
        int ai[] = genBiomes.getInts(i, j, i1, j1);
        ChunkPosition chunkposition = null;
        int k1 = 0;

        for (int l1 = 0; l1 < ai.length; l1++)
        {
            int i2 = i + l1 % i1 << 2;
            int j2 = j + l1 / i1 << 2;
            BiomeGenBase biomegenbase = BiomeGenBase.biomeList[ai[l1]];

            if (par4List.contains(biomegenbase) && (chunkposition == null || par5Random.nextInt(k1 + 1) == 0))
            {
                chunkposition = new ChunkPosition(i2, 0, j2);
                k1++;
            }
        }

        return chunkposition;
    }

    /**
     * Calls the WorldChunkManager's biomeCache.cleanupCache()
     */
    public void cleanupCache()
    {
        biomeCache.cleanupCache();
    }
}

OwnAgePau · May 20, 2013

So if i get this right you use overworld biomes in your custom dimension and you use BiomeGenBase aswell?

Squawkers13 · May 22, 2013

I think you want Forge code, not Minecraft code.

Otherwise it would be a jar mod.

EDIT: Where did you get your code?

OwnAgePau · May 23, 2013

I think you want Forge code, not Minecraft code.
Otherwise it would be a jar mod.

EDIT: Where did you get your code?

Well first of all if you know how to add multiple biomes to your custom dimension then please tell us.

You say i shouldn't use minecraft code but that doesn't make any sense in any way. Although it is true that i should not code inside the minecraft base classes which i ofcourse try to avoid. I am not sure if you mean that by "jar mod".

StormTiberius · June 26, 2013

The way i have managed to get it done is by having custom worldchunkmanager in WorldType or WorldProvider depending if you are making dimension or a worldtype.

The worldchunkmanager is mostly untouched it just points to the custom genLayer.

The GenLayerBiome decides what biomes gets generated you should tell it where it can find your custom BiomeGenBase[] array.

and remember to register your worldprovider or worldtype with forge too

redria7 · June 26, 2013

The way i have managed to get it done is by having custom worldchunkmanager in WorldType or WorldProvider depending if you are making dimension or a worldtype.

That. I have no explanation to help you with, but in making my own dimension, I wanted all of the vanilla overworld biomes to spawn in my dimension. The 2 world chunk managers I know of are WorldChunkManager and WorldChunkManagerHell. The Hell one does one biome, which you specify. The regular one does multiple. You will have to make your own world chunk manager and look in to how the regular one works.

Jacknoshima · June 27, 2013

use this

http://www.minecraftforum.net/topic/1797143-152-forge-dimension-tutorial-multi-biome-dimension-tutorial-ore-generation-basic-house-gen-in-dimension-tree-generation/

OwnAgePau · June 27, 2013

Well the problem lies a bit different as i try to do the multiple biomes in a Nether type generated landscape so its a bit different, if someone points me to the stuff i should change inside the ChunkProvider then im good.

Xackery · February 25, 2015

Blade your reply worked, just note with 1.7.1+ you need to do some changes as per : http://www.wuppy29.com/minecraft/modding-tutorials/wuppys-minecraft-forge-modding-tutorials-for-1-7-updating-1-6-to-1-7-part-1-modfile-and-recipes/#sthash.9BCseiYx.dpbs

Basically, biomeList becomes getBiomeGenArray()

as well as getIntTemperature() changes to getFloatTemperature() with additional parameters.

As per original answer, I managed to get multiple biomes on a custom dimension with modding ChunkProvider, WorldProvider, WorldChunkManager

Jacky2611 · February 25, 2015

Wahh! We have a necromancer!

larsgerrits · February 25, 2015

Blade your reply worked, just note with 1.7.1+ you need to do some changes as per : http://www.wuppy29.com/minecraft/modding-tutorials/wuppys-minecraft-forge-modding-tutorials-for-1-7-updating-1-6-to-1-7-part-1-modfile-and-recipes/#sthash.9BCseiYx.dpbs

Basically, biomeList becomes getBiomeGenArray()

as well as getIntTemperature() changes to getFloatTemperature() with additional parameters.

As per original answer, I managed to get multiple biomes on a custom dimension with modding ChunkProvider, WorldProvider, WorldChunkManager

Dude, this thread is 2 years old... Make your own if you need help.

Sign In

[Custom Biomes][Custom Dimension] Multiple Biomes how?

Recommended Posts

OwnAgePau

Mazetar

robustus

OwnAgePau

Blade Avuari

OwnAgePau

Squawkers13

OwnAgePau

StormTiberius

redria7

Jacknoshima

OwnAgePau

Xackery

Jacky2611

larsgerrits

Join the conversation

Announcements

Recently Browsing

Posts

Topics

Who's Online (See full list)

Browse

Activity

Important Information