Merge branch 'terraingen'

common/net/minecraftforge/common/MinecraftForge.java

@@ -19,11 +19,16 @@ import net.minecraftforge.oredict.OreDictionary;
 public class MinecraftForge
 {
     /**
-     * The core Forge EventBus, all events for Forge will be fired on this,
+     * The core Forge EventBusses, all events for Forge will be fired on these,
      * you should use this to register all your listeners.
      * This replaces every register*Handler() function in the old version of Forge.
+     * TERRAIN_GEN_BUS for terrain gen events
+     * ORE_GEN_BUS for ore gen events
+     * EVENT_BUS for everything else
      */
     public static final EventBus EVENT_BUS = new EventBus();
+    public static final EventBus TERRAIN_GEN_BUS = new EventBus();
+    public static final EventBus ORE_GEN_BUS = new EventBus();
     public static boolean SPAWNER_ALLOW_ON_INVERTED = false;
     private static final ForgeInternalHandler INTERNAL_HANDLER = new ForgeInternalHandler();
 

common/net/minecraftforge/event/terraingen/BiomeEvent.java

@@ -0,0 +1,124 @@
+package net.minecraftforge.event.terraingen;
+
+import cpw.mods.fml.common.Side;
+import cpw.mods.fml.common.asm.SideOnly;
+import net.minecraft.src.*;
+import net.minecraftforge.event.*;
+
+public class BiomeEvent extends Event
+{
+    public final BiomeGenBase biome;
+
+    public BiomeEvent(BiomeGenBase biome)
+    {
+        this.biome = biome;
+    }
+    
+    public static class CreateDecorator extends BiomeEvent
+    {
+        public final BiomeDecorator originalBiomeDecorator;
+        public BiomeDecorator newBiomeDecorator;
+        
+        public CreateDecorator(BiomeGenBase biome, BiomeDecorator original)
+        {
+            super(biome);
+            originalBiomeDecorator = original;
+            newBiomeDecorator = original;
+        }
+    }
+
+    public static class BlockReplacement extends BiomeEvent
+    {
+        public final int original;
+        public int replacement;
+
+        public BlockReplacement(BiomeGenBase biome, int original, int replacement)
+        {
+            super(biome);
+            this.original = original;
+            this.replacement = replacement;
+        }
+    }
+    
+
+    @SideOnly(Side.CLIENT)
+   public static class BiomeColor extends BiomeEvent
+    {
+        public final int originalColor;
+        public int newColor;
+        
+        public BiomeColor(BiomeGenBase biome, int original)
+        {
+            super(biome);
+            originalColor = original;
+            newColor = original;
+        }
+    }
+    
+    /**
+     * This event is fired when the village generator attempts to choose a block ID
+     * based on the village's biome.
+     * 
+     * You can set the result to DENY to prevent the default block ID selection.
+     */
+    @HasResult
+    public static class GetVillageBlockID extends BlockReplacement
+    {
+        public GetVillageBlockID(BiomeGenBase biome, int original, int replacement)
+        {
+            super(biome, original, replacement);
+        }
+    }
+    
+    /**
+     * This event is fired when the village generator attempts to choose a block
+     * metadata based on the village's biome.
+     * 
+     * You can set the result to DENY to prevent the default block metadata selection.
+     */
+    @HasResult
+    public static class GetVillageBlockMeta extends BlockReplacement
+    {
+        public GetVillageBlockMeta(BiomeGenBase biome, int original, int replacement)
+        {
+            super(biome, original, replacement);
+        }
+    }
+    
+    /**
+     * This event is fired when a biome is queried for its grass color. 
+     */
+
+    @SideOnly(Side.CLIENT)
+    public static class GetGrassColor extends BiomeColor
+    {
+        public GetGrassColor(BiomeGenBase biome, int original)
+        {
+            super(biome, original);
+        }
+    }
+    
+    /**
+     * This event is fired when a biome is queried for its grass color. 
+     */
+    @SideOnly(Side.CLIENT)
+    public static class GetFoliageColor extends BiomeColor
+    {
+        public GetFoliageColor(BiomeGenBase biome, int original)
+        {
+            super(biome, original);
+        }
+    }
+    
+    /**
+     * This event is fired when a biome is queried for its water color. 
+     */
+    @SideOnly(Side.CLIENT)
+    public static class GetWaterColor extends BiomeColor
+    {
+        public GetWaterColor(BiomeGenBase biome, int original)
+        {
+            super(biome, original);
+        }
+    }
+}

common/net/minecraftforge/event/terraingen/ChunkProviderEvent.java

@@ -0,0 +1,70 @@
+package net.minecraftforge.event.terraingen;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.*;
+
+public class ChunkProviderEvent extends Event
+{
+
+    public final IChunkProvider chunkProvider;
+    
+    public ChunkProviderEvent(IChunkProvider chunkProvider)
+    {
+        this.chunkProvider = chunkProvider;
+    }
+    
+    /**
+     * This event is fired when a chunks blocks are replaced by a biomes top and
+     * filler blocks.
+     * 
+     * You can set the result to DENY to prevent the default replacement.
+     */
+    @HasResult
+    public static class ReplaceBiomeBlocks extends ChunkProviderEvent 
+    {
+        public final int chunkX;
+        public final int chunkZ;
+        public final byte[] blockArray;
+        public final BiomeGenBase[] biomeArray;
+        
+        public ReplaceBiomeBlocks(IChunkProvider chunkProvider, int chunkX, int chunkZ, byte[] blockArray, BiomeGenBase[] biomeArray)
+        {
+            super(chunkProvider);
+            this.chunkX = chunkX;
+            this.chunkZ = chunkZ;
+            this.blockArray = blockArray;
+            this.biomeArray = biomeArray;
+        }
+       
+    }
+    
+    /**
+     * This event is fired before a chunks terrain noise field is initialized.
+     * 
+     * You can set the result to DENY to substitute your own noise field.
+     */
+    @HasResult
+    public static class InitNoiseField extends ChunkProviderEvent 
+    {
+        public double[] noisefield;
+        public final int posX;
+        public final int posY;
+        public final int posZ;
+        public final int sizeX;
+        public final int sizeY;
+        public final int sizeZ;
+        
+        public InitNoiseField(IChunkProvider chunkProvider, double[] noisefield, int posX, int posY, int posZ, int sizeX, int sizeY, int sizeZ)
+        {
+            super(chunkProvider);
+            this.noisefield = noisefield;
+            this.posX = posX;
+            this.posY = posY;
+            this.posZ = posZ;
+            this.sizeX = sizeX;
+            this.sizeY = sizeX;
+            this.sizeZ = sizeZ;
+        }
+       
+    }
+}

common/net/minecraftforge/event/terraingen/DecorateBiomeEvent.java

@@ -0,0 +1,59 @@
+package net.minecraftforge.event.terraingen;
+
+import java.util.Random;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.*;
+
+public class DecorateBiomeEvent extends Event
+{
+    public final World world;
+    public final Random rand;
+    public final int chunkX;
+    public final int chunkZ;
+    
+    public DecorateBiomeEvent(World world, Random rand, int worldX, int worldZ)
+    {
+        this.world = world;
+        this.rand = rand;
+        this.chunkX = worldX;
+        this.chunkZ = worldZ;
+    }
+    
+    public static class Pre extends DecorateBiomeEvent
+    {
+        public Pre(World world, Random rand, int worldX, int worldZ)
+        {
+            super(world, rand, worldX, worldZ);
+        }
+    }
+    
+    public static class Post extends DecorateBiomeEvent
+    {
+        public Post(World world, Random rand, int worldX, int worldZ)
+        {
+            super(world, rand, worldX, worldZ);
+        }
+    }
+
+    /**
+     * This event is fired when a chunk is decorated with a biome feature.
+     * 
+     * You can set the result to DENY to prevent the default biome decoration.
+     */
+    @HasResult
+    public static class Decorate extends DecorateBiomeEvent
+    {
+        /** Use CUSTOM to filter custom event types
+         */
+        public static enum EventType { BIG_SHROOM, CACTUS, CLAY, DEAD_BUSH, LILYPAD, FLOWERS, GRASS, LAKE, PUMPKIN, REED, SAND, SAND_PASS2, SHROOM, TREE, CUSTOM }
+        
+        public final EventType type;
+        
+        public Decorate(World world, Random rand, int worldX, int worldZ, EventType type)
+        {
+            super(world, rand, worldX, worldZ);
+            this.type = type;
+        }
+    }
+}

common/net/minecraftforge/event/terraingen/InitMapGenEvent.java

@@ -0,0 +1,22 @@
+package net.minecraftforge.event.terraingen;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.*;
+
+public class InitMapGenEvent extends Event
+{
+    /** Use CUSTOM to filter custom event types
+     */
+    public static enum EventType { CAVE, MINESHAFT, NETHER_BRIDGE, NETHER_CAVE, RAVINE, SCATTERED_FEATURE, STRONGHOLD, VILLAGE, CUSTOM }
+    
+    public final EventType type;
+    public final MapGenBase originalGen;
+    public MapGenBase newGen;
+    
+    InitMapGenEvent(EventType type, MapGenBase original)
+    {
+        this.type = type;
+        this.originalGen = original;
+        this.newGen = original;
+    }
+}

common/net/minecraftforge/event/terraingen/InitNoiseGensEvent.java

@@ -0,0 +1,21 @@
+package net.minecraftforge.event.terraingen;
+
+import java.util.Random;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.world.*;
+
+public class InitNoiseGensEvent extends WorldEvent
+{
+    public final Random rand;
+    public final NoiseGeneratorOctaves[] originalNoiseGens;
+    public NoiseGeneratorOctaves[] newNoiseGens;
+    
+    public InitNoiseGensEvent(World world, Random rand, NoiseGeneratorOctaves[] original)
+    {
+        super(world);
+        this.rand = rand;
+        originalNoiseGens = original;
+        newNoiseGens = original.clone();
+    }
+}

common/net/minecraftforge/event/terraingen/OreGenEvent.java

@@ -0,0 +1,59 @@
+package net.minecraftforge.event.terraingen;
+
+import java.util.Random;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.*;
+
+public class OreGenEvent extends Event
+{
+    public final World world;
+    public final Random rand;
+    public final int worldX;
+    public final int worldZ;
+    
+    public OreGenEvent(World world, Random rand, int worldX, int worldZ)
+    {
+        this.world = world;
+        this.rand = rand;
+        this.worldX = worldX;
+        this.worldZ = worldZ;
+    }
+    
+    public static class Pre extends OreGenEvent
+    {
+        public Pre(World world, Random rand, int worldX, int worldZ)
+        {
+            super(world, rand, worldX, worldZ);
+        }
+    }
+    
+    public static class Post extends OreGenEvent
+    {
+        public Post(World world, Random rand, int worldX, int worldZ)
+        {
+            super(world, rand, worldX, worldZ);
+        }
+    }
+    
+    /**
+     * This event is fired when an ore is generated in a chunk.
+     * 
+     * You can set the result to DENY to prevent the default ore generation.
+     */
+    @HasResult
+    public static class GenerateMinable extends OreGenEvent
+    {
+        public static enum EventType { COAL, DIAMOND, DIRT, GOLD, GRAVEL, IRON, LAPIS, REDSTONE, CUSTOM }
+        
+        public final EventType type;
+        public final WorldGenerator generator;
+        
+        public GenerateMinable(World world, Random rand, WorldGenerator generator, int worldX, int worldZ, EventType type)
+        {
+            super(world, rand, worldX, worldZ);
+            this.generator = generator;
+            this.type = type;
+        }
+    }
+}

common/net/minecraftforge/event/terraingen/PopulateChunkEvent.java

@@ -0,0 +1,63 @@
+package net.minecraftforge.event.terraingen;
+
+import java.util.Random;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.world.*;
+
+public class PopulateChunkEvent extends ChunkProviderEvent
+{
+    public final World world;
+    public final Random rand;
+    public final int chunkX;
+    public final int chunkZ;
+    public final boolean hasVillageGenerated;
+    
+    public PopulateChunkEvent(IChunkProvider chunkProvider, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated)
+    {
+        super(chunkProvider);
+        this.world = world;
+        this.rand = rand;
+        this.chunkX = chunkX;
+        this.chunkZ = chunkZ;
+        this.hasVillageGenerated = hasVillageGenerated;
+    }
+    
+    public static class Pre extends PopulateChunkEvent
+    {
+        public Pre(IChunkProvider chunkProvider, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated)
+        {
+            super(chunkProvider, world, rand, chunkX, chunkZ, hasVillageGenerated);
+        }
+    }
+    
+    public static class Post extends PopulateChunkEvent
+    {
+        public Post(IChunkProvider chunkProvider, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated)
+        {
+            super(chunkProvider, world, rand, chunkX, chunkZ, hasVillageGenerated);
+        }
+    }
+    
+    /**
+     * This event is fired when a chunk is populated with a terrain feature.
+     * 
+     * You can set the result to DENY to prevent the default generation
+     * of a terrain feature.
+     */
+    @HasResult
+    public static class Populate extends PopulateChunkEvent
+    {
+        /** Use CUSTOM to filter custom event types
+         */
+        public static enum EventType { DUNGEON, FIRE, GLOWSTONE, ICE, LAKE, LAVA, NETHER_LAVA, CUSTOM }
+        
+        public final EventType type;
+
+        public Populate(IChunkProvider chunkProvider, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated, EventType type)
+        {
+            super(chunkProvider, world, rand, chunkX, chunkZ, hasVillageGenerated);
+            this.type = type;
+        }
+    }
+}

common/net/minecraftforge/event/terraingen/SaplingGrowTreeEvent.java

@@ -0,0 +1,30 @@
+package net.minecraftforge.event.terraingen;
+
+import java.util.Random;
+
+import net.minecraft.src.*;
+import net.minecraftforge.event.Event.*;
+import net.minecraftforge.event.world.*;
+
+/**
+ * This event is fired when a sapling grows a tree.
+ * 
+ * You can set the result to DENY to prevent the default tree growth.
+ */
+@HasResult
+public class SaplingGrowTreeEvent extends WorldEvent
+{
+    public final int x;
+    public final int y;
+    public final int z;
+    public final Random rand;
+    
+    public SaplingGrowTreeEvent(World world, Random rand, int x, int y, int z)
+    {
+        super(world);
+        this.rand = rand;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+}

common/net/minecraftforge/event/terraingen/TerrainGen.java

@@ -0,0 +1,56 @@
+package net.minecraftforge.event.terraingen;
+
+import java.util.Random;
+
+import net.minecraft.src.*;
+import net.minecraftforge.common.*;
+import net.minecraftforge.event.Event.*;
+import net.minecraftforge.event.terraingen.DecorateBiomeEvent.*;
+import net.minecraftforge.event.terraingen.OreGenEvent.*;
+import net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.*;
+import net.minecraftforge.event.terraingen.PopulateChunkEvent.*;
+
+public abstract class TerrainGen
+{
+    public static NoiseGeneratorOctaves[] getModdedNoiseGenerators(World world, Random rand, NoiseGeneratorOctaves[] original)
+    {
+        InitNoiseGensEvent event = new InitNoiseGensEvent(world, rand, original);
+        MinecraftForge.TERRAIN_GEN_BUS.post(event);
+        return event.newNoiseGens;
+    }
+
+    public static MapGenBase getModdedMapGen(MapGenBase original, InitMapGenEvent.EventType type)
+    {
+        InitMapGenEvent event = new InitMapGenEvent(type, original);
+        MinecraftForge.TERRAIN_GEN_BUS.post(event);
+        return event.newGen;
+    }
+    
+    public static boolean populate(IChunkProvider chunkProvider, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated, Populate.EventType type)
+    {
+        PopulateChunkEvent.Populate event = new PopulateChunkEvent.Populate(chunkProvider, world, rand, chunkX, chunkZ, hasVillageGenerated, type);
+        MinecraftForge.TERRAIN_GEN_BUS.post(event);
+        return event.getResult() != Result.DENY;
+    }
+    
+    public static boolean decorate(World world, Random rand, int chunkX, int chunkZ, Decorate.EventType type)
+    {
+        Decorate event = new Decorate(world, rand, chunkX, chunkZ, type);
+        MinecraftForge.TERRAIN_GEN_BUS.post(event);
+        return event.getResult() != Result.DENY;
+    }
+    
+    public static boolean generateOre(World world, Random rand, WorldGenerator generator, int worldX, int worldZ, GenerateMinable.EventType type)
+    {
+        GenerateMinable event = new GenerateMinable(world, rand, generator, worldX, worldZ, type);
+        MinecraftForge.ORE_GEN_BUS.post(event);
+        return event.getResult() != Result.DENY;
+    }
+    
+    public static boolean saplingGrowTree(World world, Random rand, int x, int y, int z)
+    {
+        SaplingGrowTreeEvent event = new SaplingGrowTreeEvent(world, rand, x, y, z);
+        MinecraftForge.TERRAIN_GEN_BUS.post(event);
+        return event.getResult() != Result.DENY;
+    }
+}

common/net/minecraftforge/event/terraingen/WorldTypeEvent.java

@@ -0,0 +1,43 @@
+package net.minecraftforge.event.terraingen;
+
+import net.minecraft.src.GenLayer;
+import net.minecraft.src.WorldType;
+import net.minecraftforge.event.Event;
+
+public class WorldTypeEvent extends Event
+{
+    public final WorldType worldType;
+
+    public WorldTypeEvent(WorldType worldType)
+    {
+        this.worldType = worldType;
+    }
+
+    public static class BiomeSize extends WorldTypeEvent
+    {
+        public final byte originalSize;
+        public byte newSize;
+        
+        public BiomeSize(WorldType worldType, byte original)
+        {
+            super(worldType);
+            originalSize = original;
+            newSize = original;
+        }
+    }
+
+    public static class InitBiomeGens extends WorldTypeEvent
+    {
+        public final long seed;
+        public final GenLayer[] originalBiomeGens;
+        public GenLayer[] newBiomeGens;
+        
+        public InitBiomeGens(WorldType worldType, long seed, GenLayer[] original)
+        {
+            super(worldType);
+            this.seed = seed;
+            originalBiomeGens = original;
+            newBiomeGens = original.clone();
+        }
+    }
+}

patches/common/net/minecraft/src/BiomeDecorator.java.patch

@@ -0,0 +1,221 @@
+--- ../src_base/common/net/minecraft/src/BiomeDecorator.java
++++ ../src_work/common/net/minecraft/src/BiomeDecorator.java
+@@ -1,6 +1,12 @@
+ package net.minecraft.src;
+ 
++import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.*;
++import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.*;
++
+ import java.util.Random;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public class BiomeDecorator
+ {
+@@ -192,26 +198,31 @@
+      */
+     protected void decorate()
+     {
+-        this.generateOres();
++        MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(currentWorld, randomGenerator, chunk_X, chunk_Z));
++        
++       this.generateOres();
+         int var1;
+         int var2;
+         int var3;
+ 
+-        for (var1 = 0; var1 < this.sandPerChunk2; ++var1)
++        boolean doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, SAND);
++        for (var1 = 0; doGen && var1 < this.sandPerChunk2; ++var1)
+         {
+             var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var3 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+             this.sandGen.generate(this.currentWorld, this.randomGenerator, var2, this.currentWorld.getTopSolidOrLiquidBlock(var2, var3), var3);
+         }
+ 
+-        for (var1 = 0; var1 < this.clayPerChunk; ++var1)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, CLAY);
++        for (var1 = 0; doGen && var1 < this.clayPerChunk; ++var1)
+         {
+             var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var3 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+             this.clayGen.generate(this.currentWorld, this.randomGenerator, var2, this.currentWorld.getTopSolidOrLiquidBlock(var2, var3), var3);
+         }
+ 
+-        for (var1 = 0; var1 < this.sandPerChunk; ++var1)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, SAND_PASS2);
++        for (var1 = 0; doGen && var1 < this.sandPerChunk; ++var1)
+         {
+             var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var3 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+@@ -227,7 +238,8 @@
+ 
+         int var4;
+ 
+-        for (var2 = 0; var2 < var1; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, TREE);
++        for (var2 = 0; doGen && var2 < var1; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+@@ -236,7 +248,8 @@
+             var5.generate(this.currentWorld, this.randomGenerator, var3, this.currentWorld.getHeightValue(var3, var4), var4);
+         }
+ 
+-        for (var2 = 0; var2 < this.bigMushroomsPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, BIG_SHROOM);
++        for (var2 = 0; doGen && var2 < this.bigMushroomsPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+@@ -245,7 +258,8 @@
+ 
+         int var7;
+ 
+-        for (var2 = 0; var2 < this.flowersPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, FLOWERS);
++        for (var2 = 0; doGen && var2 < this.flowersPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.randomGenerator.nextInt(128);
+@@ -261,7 +275,8 @@
+             }
+         }
+ 
+-        for (var2 = 0; var2 < this.grassPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, GRASS);
++        for (var2 = 0; doGen && var2 < this.grassPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.randomGenerator.nextInt(128);
+@@ -270,7 +285,8 @@
+             var6.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+         }
+ 
+-        for (var2 = 0; var2 < this.deadBushPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, DEAD_BUSH);
++        for (var2 = 0; doGen && var2 < this.deadBushPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.randomGenerator.nextInt(128);
+@@ -278,7 +294,8 @@
+             (new WorldGenDeadBush(Block.deadBush.blockID)).generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+         }
+ 
+-        for (var2 = 0; var2 < this.waterlilyPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, LILYPAD);
++        for (var2 = 0; doGen && var2 < this.waterlilyPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+@@ -291,7 +308,8 @@
+             this.waterlilyGen.generate(this.currentWorld, this.randomGenerator, var3, var7, var4);
+         }
+ 
+-        for (var2 = 0; var2 < this.mushroomsPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, SHROOM);
++        for (var2 = 0; doGen && var2 < this.mushroomsPerChunk; ++var2)
+         {
+             if (this.randomGenerator.nextInt(4) == 0)
+             {
+@@ -310,7 +328,7 @@
+             }
+         }
+ 
+-        if (this.randomGenerator.nextInt(4) == 0)
++        if (doGen && this.randomGenerator.nextInt(4) == 0)
+         {
+             var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var3 = this.randomGenerator.nextInt(128);
+@@ -318,7 +336,7 @@
+             this.mushroomBrownGen.generate(this.currentWorld, this.randomGenerator, var2, var3, var4);
+         }
+ 
+-        if (this.randomGenerator.nextInt(8) == 0)
++        if (doGen && this.randomGenerator.nextInt(8) == 0)
+         {
+             var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var3 = this.randomGenerator.nextInt(128);
+@@ -326,7 +344,8 @@
+             this.mushroomRedGen.generate(this.currentWorld, this.randomGenerator, var2, var3, var4);
+         }
+ 
+-        for (var2 = 0; var2 < this.reedsPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, REED);
++        for (var2 = 0; doGen && var2 < this.reedsPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.chunk_Z + this.randomGenerator.nextInt(16) + 8;
+@@ -334,7 +353,7 @@
+             this.reedGen.generate(this.currentWorld, this.randomGenerator, var3, var7, var4);
+         }
+ 
+-        for (var2 = 0; var2 < 10; ++var2)
++        for (var2 = 0; doGen && var2 < 10; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.randomGenerator.nextInt(128);
+@@ -342,7 +361,8 @@
+             this.reedGen.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+         }
+ 
+-        if (this.randomGenerator.nextInt(32) == 0)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, PUMPKIN);
++        if (doGen && this.randomGenerator.nextInt(32) == 0)
+         {
+             var2 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var3 = this.randomGenerator.nextInt(128);
+@@ -350,7 +370,8 @@
+             (new WorldGenPumpkin()).generate(this.currentWorld, this.randomGenerator, var2, var3, var4);
+         }
+ 
+-        for (var2 = 0; var2 < this.cactiPerChunk; ++var2)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, CACTUS);
++        for (var2 = 0; doGen && var2 < this.cactiPerChunk; ++var2)
+         {
+             var3 = this.chunk_X + this.randomGenerator.nextInt(16) + 8;
+             var4 = this.randomGenerator.nextInt(128);
+@@ -358,7 +379,8 @@
+             this.cactusGen.generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+         }
+ 
+-        if (this.generateLakes)
++        doGen = TerrainGen.decorate(currentWorld, randomGenerator, chunk_X, chunk_Z, LAKE);
++        if (doGen && this.generateLakes)
+         {
+             for (var2 = 0; var2 < 50; ++var2)
+             {
+@@ -376,6 +398,8 @@
+                 (new WorldGenLiquids(Block.lavaMoving.blockID)).generate(this.currentWorld, this.randomGenerator, var3, var4, var7);
+             }
+         }
++
++        MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(currentWorld, randomGenerator, chunk_X, chunk_Z));
+     }
+ 
+     /**
+@@ -411,13 +435,23 @@
+      */
+     protected void generateOres()
+     {
++        MinecraftForge.ORE_GEN_BUS.post(new OreGenEvent.Pre(currentWorld, randomGenerator, chunk_X, chunk_Z));
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, dirtGen, chunk_X, chunk_Z, DIRT))
+         this.genStandardOre1(20, this.dirtGen, 0, 128);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, gravelGen, chunk_X, chunk_Z, GRAVEL))
+         this.genStandardOre1(10, this.gravelGen, 0, 128);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, coalGen, chunk_X, chunk_Z, COAL))
+         this.genStandardOre1(20, this.coalGen, 0, 128);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, ironGen, chunk_X, chunk_Z, IRON))
+         this.genStandardOre1(20, this.ironGen, 0, 64);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, goldGen, chunk_X, chunk_Z, GOLD))
+         this.genStandardOre1(2, this.goldGen, 0, 32);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, redstoneGen, chunk_X, chunk_Z, REDSTONE))
+         this.genStandardOre1(8, this.redstoneGen, 0, 16);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, diamondGen, chunk_X, chunk_Z, DIAMOND))
+         this.genStandardOre1(1, this.diamondGen, 0, 16);
++        if (TerrainGen.generateOre(currentWorld, randomGenerator, lapisGen, chunk_X, chunk_Z, LAPIS))
+         this.genStandardOre2(1, this.lapisGen, 16, 16);
++        MinecraftForge.ORE_GEN_BUS.post(new OreGenEvent.Post(currentWorld, randomGenerator, chunk_X, chunk_Z));
+     }
+ }

patches/common/net/minecraft/src/BiomeGenBase.java.patch

@@ -0,0 +1,72 @@
+--- ../src_base/common/net/minecraft/src/BiomeGenBase.java
++++ ../src_work/common/net/minecraft/src/BiomeGenBase.java
+@@ -6,6 +6,9 @@
+ import java.util.ArrayList;
+ import java.util.List;
+ import java.util.Random;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public abstract class BiomeGenBase
+ {
+@@ -155,8 +158,8 @@
+      * Allocate a new BiomeDecorator for this BiomeGenBase
+      */
+     public BiomeDecorator createBiomeDecorator()
+-    {
+-        return new BiomeDecorator(this);
++    {   
++        return getModdedBiomeDecorator(new BiomeDecorator(this));
+     }
+ 
+     /**
+@@ -348,7 +351,7 @@
+     {
+         double var1 = (double)MathHelper.clamp_float(this.getFloatTemperature(), 0.0F, 1.0F);
+         double var3 = (double)MathHelper.clamp_float(this.getFloatRainfall(), 0.0F, 1.0F);
+-        return ColorizerGrass.getGrassColor(var1, var3);
++        return getModdedBiomeGrassColor(ColorizerGrass.getGrassColor(var1, var3));
+     }
+ 
+     @SideOnly(Side.CLIENT)
+@@ -360,6 +363,38 @@
+     {
+         double var1 = (double)MathHelper.clamp_float(this.getFloatTemperature(), 0.0F, 1.0F);
+         double var3 = (double)MathHelper.clamp_float(this.getFloatRainfall(), 0.0F, 1.0F);
+-        return ColorizerFoliage.getFoliageColor(var1, var3);
++        return getModdedBiomeFoliageColor(ColorizerFoliage.getFoliageColor(var1, var3));
++    }
++
++    public BiomeDecorator getModdedBiomeDecorator(BiomeDecorator original)
++    {
++        BiomeEvent.CreateDecorator event = new BiomeEvent.CreateDecorator(this, original);
++        MinecraftForge.TERRAIN_GEN_BUS.post(event);
++        return event.newBiomeDecorator;
++    }
++
++    @SideOnly(Side.CLIENT)
++    public int getWaterColorMultiplier()
++    {
++        BiomeEvent.GetWaterColor event = new BiomeEvent.GetWaterColor(this, waterColorMultiplier);
++        MinecraftForge.EVENT_BUS.post(event);
++        return event.newColor;
++    }
++    
++    @SideOnly(Side.CLIENT)
++    public int getModdedBiomeGrassColor(int original)
++    {
++        BiomeEvent.GetGrassColor event = new BiomeEvent.GetGrassColor(this, original);
++        MinecraftForge.EVENT_BUS.post(event);
++        return event.newColor;
++    }
++    
++
++    @SideOnly(Side.CLIENT)
++    public int getModdedBiomeFoliageColor(int original)
++    {
++        BiomeEvent.GetFoliageColor event = new BiomeEvent.GetFoliageColor(this, original);
++        MinecraftForge.EVENT_BUS.post(event);
++        return event.newColor;
+     }
+ }

patches/common/net/minecraft/src/BlockFluid.java.patch

@@ -0,0 +1,11 @@
+--- ../src_base/common/net/minecraft/src/BlockFluid.java
++++ ../src_work/common/net/minecraft/src/BlockFluid.java
+@@ -48,7 +48,7 @@
+             {
+                 for (int var9 = -1; var9 <= 1; ++var9)
+                 {
+-                    int var10 = par1IBlockAccess.getBiomeGenForCoords(par2 + var9, par4 + var8).waterColorMultiplier;
++                    int var10 = par1IBlockAccess.getBiomeGenForCoords(par2 + var9, par4 + var8).getWaterColorMultiplier();
+                     var5 += (var10 & 16711680) >> 16;
+                     var6 += (var10 & 65280) >> 8;
+                     var7 += var10 & 255;

patches/common/net/minecraft/src/BlockSapling.java.patch

@@ -0,0 +1,20 @@
+--- ../src_base/common/net/minecraft/src/BlockSapling.java
++++ ../src_work/common/net/minecraft/src/BlockSapling.java
+@@ -4,6 +4,8 @@
+ import cpw.mods.fml.common.asm.SideOnly;
+ import java.util.List;
+ import java.util.Random;
++
++import net.minecraftforge.event.terraingen.TerrainGen;
+ 
+ public class BlockSapling extends BlockFlower
+ {
+@@ -56,6 +58,8 @@
+      */
+     public void growTree(World par1World, int par2, int par3, int par4, Random par5Random)
+     {
++        if (!TerrainGen.saplingGrowTree(par1World, par5Random, par2, par3, par4)) return;
++        
+         int var6 = par1World.getBlockMetadata(par2, par3, par4) & 3;
+         Object var7 = null;
+         int var8 = 0;

patches/common/net/minecraft/src/ChunkProviderEnd.java.patch

@@ -0,0 +1,69 @@
+--- ../src_base/common/net/minecraft/src/ChunkProviderEnd.java
++++ ../src_work/common/net/minecraft/src/ChunkProviderEnd.java
+@@ -2,6 +2,10 @@
+ 
+ import java.util.List;
+ import java.util.Random;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.Event.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public class ChunkProviderEnd implements IChunkProvider
+ {
+@@ -32,7 +36,15 @@
+         this.noiseGen3 = new NoiseGeneratorOctaves(this.endRNG, 8);
+         this.noiseGen4 = new NoiseGeneratorOctaves(this.endRNG, 10);
+         this.noiseGen5 = new NoiseGeneratorOctaves(this.endRNG, 16);
+-    }
++
++        NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5};
++        noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.endRNG, noiseGens);
++        this.noiseGen1 = noiseGens[0];
++        this.noiseGen2 = noiseGens[1];
++        this.noiseGen3 = noiseGens[2];
++        this.noiseGen4 = noiseGens[3];
++        this.noiseGen5 = noiseGens[4];
++   }
+ 
+     public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
+     {
+@@ -104,6 +116,10 @@
+ 
+     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;
++
+         for (int var5 = 0; var5 < 16; ++var5)
+         {
+             for (int var6 = 0; var6 < 16; ++var6)
+@@ -191,6 +207,10 @@
+      */
+     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];
+@@ -338,10 +358,16 @@
+     public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)
+     {
+         BlockSand.fallInstantly = true;
++
++        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, endWorld, endWorld.rand, par2, par3, false));
++
+         int var4 = par2 * 16;
+         int var5 = par3 * 16;
+         BiomeGenBase var6 = this.endWorld.getBiomeGenForCoords(var4 + 16, var5 + 16);
+         var6.decorate(this.endWorld, this.endWorld.rand, var4, var5);
++
++        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, endWorld, endWorld.rand, par2, par3, false));
++
+         BlockSand.fallInstantly = false;
+     }
+ 

patches/common/net/minecraft/src/ChunkProviderGenerate.java.patch

@@ -0,0 +1,130 @@
+--- ../src_base/common/net/minecraft/src/ChunkProviderGenerate.java
++++ ../src_work/common/net/minecraft/src/ChunkProviderGenerate.java
+@@ -1,7 +1,14 @@
+ package net.minecraft.src;
++
++import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*;
++import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*;
+ 
+ import java.util.List;
+ import java.util.Random;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.Event.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public class ChunkProviderGenerate implements IChunkProvider
+ {
+@@ -74,6 +81,15 @@
+      */
+     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 ChunkProviderGenerate(World par1World, long par2, boolean par4)
+     {
+@@ -87,6 +103,16 @@
+         this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
+         this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
+         this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
++
++        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];
+     }
+ 
+     /**
+@@ -172,6 +198,10 @@
+      */
+     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 var5 = 63;
+         double var6 = 0.03125D;
+         this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D);
+@@ -307,6 +337,10 @@
+      */
+     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];
+@@ -475,6 +509,8 @@
+         this.rand.setSeed((long)par2 * var7 + (long)par3 * var9 ^ this.worldObj.getSeed());
+         boolean var11 = false;
+ 
++        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, rand, par2, par3, var11));
++
+         if (this.mapFeaturesEnabled)
+         {
+             this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
+@@ -487,7 +523,8 @@
+         int var13;
+         int var14;
+ 
+-        if (!var11 && this.rand.nextInt(4) == 0)
++        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, LAKE) && 
++                !var11 && this.rand.nextInt(4) == 0)
+         {
+             var12 = var4 + this.rand.nextInt(16) + 8;
+             var13 = this.rand.nextInt(128);
+@@ -495,7 +532,8 @@
+             (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, var12, var13, var14);
+         }
+ 
+-        if (!var11 && this.rand.nextInt(8) == 0)
++        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, LAVA) &&
++                !var11 && this.rand.nextInt(8) == 0)
+         {
+             var12 = var4 + this.rand.nextInt(16) + 8;
+             var13 = this.rand.nextInt(this.rand.nextInt(120) + 8);
+@@ -507,7 +545,8 @@
+             }
+         }
+ 
+-        for (var12 = 0; var12 < 8; ++var12)
++        boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, DUNGEON);
++        for (var12 = 0; doGen && var12 < 8; ++var12)
+         {
+             var13 = var4 + this.rand.nextInt(16) + 8;
+             var14 = this.rand.nextInt(128);
+@@ -524,7 +563,8 @@
+         var4 += 8;
+         var5 += 8;
+ 
+-        for (var12 = 0; var12 < 16; ++var12)
++        doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, ICE);
++        for (var12 = 0; doGen && var12 < 16; ++var12)
+         {
+             for (var13 = 0; var13 < 16; ++var13)
+             {
+@@ -541,6 +581,8 @@
+                 }
+             }
+         }
++
++        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, rand, par2, par3, var11));
+ 
+         BlockSand.fallInstantly = false;
+     }

patches/common/net/minecraft/src/ChunkProviderHell.java.patch

@@ -0,0 +1,148 @@
+--- ../src_base/common/net/minecraft/src/ChunkProviderHell.java
++++ ../src_work/common/net/minecraft/src/ChunkProviderHell.java
+@@ -1,7 +1,15 @@
+ package net.minecraft.src;
++
++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 java.util.List;
+ import java.util.Random;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.Event.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public class ChunkProviderHell implements IChunkProvider
+ {
+@@ -43,6 +51,11 @@
+     double[] noiseData3;
+     double[] noiseData4;
+     double[] noiseData5;
++
++    {
++        genNetherBridge = (MapGenNetherBridge) TerrainGen.getModdedMapGen(genNetherBridge, NETHER_BRIDGE);
++        netherCaveGenerator = TerrainGen.getModdedMapGen(netherCaveGenerator, NETHER_CAVE);
++    }
+ 
+     public ChunkProviderHell(World par1World, long par2)
+     {
+@@ -55,6 +68,16 @@
+         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];
+     }
+ 
+     /**
+@@ -139,6 +162,10 @@
+      */
+     public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte)
+     {
++        ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, null);
++        MinecraftForge.EVENT_BUS.post(event);
++        if (event.getResult() == Result.DENY) return;
++
+         byte var4 = 64;
+         double var5 = 0.03125D;
+         this.slowsandNoise = this.slowsandGravelNoiseGen.generateNoiseOctaves(this.slowsandNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, var5, var5, 1.0D);
+@@ -274,6 +301,9 @@
+      */
+     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];
+@@ -426,6 +456,9 @@
+     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 var4 = par2 * 16;
+         int var5 = par3 * 16;
+         this.genNetherBridge.generateStructuresInChunk(this.worldObj, this.hellRNG, par2, par3);
+@@ -434,7 +467,8 @@
+         int var8;
+         int var9;
+ 
+-        for (var6 = 0; var6 < 8; ++var6)
++        boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, NETHER_LAVA);
++        for (var6 = 0; doGen && var6 < 8; ++var6)
+         {
+             var7 = var4 + this.hellRNG.nextInt(16) + 8;
+             var8 = this.hellRNG.nextInt(120) + 4;
+@@ -445,7 +479,8 @@
+         var6 = this.hellRNG.nextInt(this.hellRNG.nextInt(10) + 1) + 1;
+         int var10;
+ 
+-        for (var7 = 0; var7 < var6; ++var7)
++        doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, FIRE);
++        for (var7 = 0; doGen && var7 < var6; ++var7)
+         {
+             var8 = var4 + this.hellRNG.nextInt(16) + 8;
+             var9 = this.hellRNG.nextInt(120) + 4;
+@@ -455,7 +490,8 @@
+ 
+         var6 = this.hellRNG.nextInt(this.hellRNG.nextInt(10) + 1);
+ 
+-        for (var7 = 0; var7 < var6; ++var7)
++        doGen = TerrainGen.populate(par1IChunkProvider, worldObj, hellRNG, par2, par3, false, GLOWSTONE);
++        for (var7 = 0; doGen && var7 < var6; ++var7)
+         {
+             var8 = var4 + this.hellRNG.nextInt(16) + 8;
+             var9 = this.hellRNG.nextInt(120) + 4;
+@@ -463,7 +499,7 @@
+             (new WorldGenGlowStone1()).generate(this.worldObj, this.hellRNG, var8, var9, var10);
+         }
+ 
+-        for (var7 = 0; var7 < 10; ++var7)
++        for (var7 = 0; doGen && var7 < 10; ++var7)
+         {
+             var8 = var4 + this.hellRNG.nextInt(16) + 8;
+             var9 = this.hellRNG.nextInt(128);
+@@ -471,7 +507,10 @@
+             (new WorldGenGlowStone2()).generate(this.worldObj, this.hellRNG, var8, var9, var10);
+         }
+ 
+-        if (this.hellRNG.nextInt(1) == 0)
++        MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(worldObj, hellRNG, var4, var5));
++        
++        doGen = TerrainGen.decorate(worldObj, hellRNG, var4, var5, SHROOM);
++        if (doGen && this.hellRNG.nextInt(1) == 0)
+         {
+             var7 = var4 + this.hellRNG.nextInt(16) + 8;
+             var8 = this.hellRNG.nextInt(128);
+@@ -479,7 +518,7 @@
+             (new WorldGenFlowers(Block.mushroomBrown.blockID)).generate(this.worldObj, this.hellRNG, var7, var8, var9);
+         }
+ 
+-        if (this.hellRNG.nextInt(1) == 0)
++        if (doGen && this.hellRNG.nextInt(1) == 0)
+         {
+             var7 = var4 + this.hellRNG.nextInt(16) + 8;
+             var8 = this.hellRNG.nextInt(128);
+@@ -487,6 +526,9 @@
+             (new WorldGenFlowers(Block.mushroomRed.blockID)).generate(this.worldObj, this.hellRNG, var7, var8, var9);
+         }
+ 
++        MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(worldObj, hellRNG, var4, var5));
++        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, hellRNG, par2, par3, false));
++
+         BlockSand.fallInstantly = false;
+     }
+ 

patches/common/net/minecraft/src/ComponentVillage.java.patch

@@ -0,0 +1,35 @@
+--- ../src_base/common/net/minecraft/src/ComponentVillage.java
++++ ../src_work/common/net/minecraft/src/ComponentVillage.java
+@@ -2,6 +2,10 @@
+ 
+ import java.util.List;
+ import java.util.Random;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.Event.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public abstract class ComponentVillage extends StructureComponent
+ {
+@@ -133,6 +137,10 @@
+      */
+     protected int getBiomeSpecificBlock(int par1, int par2)
+     {
++        BiomeEvent.GetVillageBlockID event = new BiomeEvent.GetVillageBlockID(startPiece.biome, par1, par2);
++        MinecraftForge.TERRAIN_GEN_BUS.post(event);
++        if (event.getResult() == Result.DENY) return event.replacement;
++
+         if (this.startPiece.inDesert)
+         {
+             if (par1 == Block.wood.blockID)
+@@ -174,6 +182,10 @@
+      */
+     protected int getBiomeSpecificBlockMetadata(int par1, int par2)
+     {
++        BiomeEvent.GetVillageBlockMeta event = new BiomeEvent.GetVillageBlockMeta(startPiece.biome, par1, par2);
++        MinecraftForge.TERRAIN_GEN_BUS.post(event);
++        if (event.getResult() == Result.DENY) return event.replacement;
++
+         if (this.startPiece.inDesert)
+         {
+             if (par1 == Block.wood.blockID)

patches/common/net/minecraft/src/ComponentVillageStartPiece.java.patch

@@ -0,0 +1,18 @@
+--- ../src_base/common/net/minecraft/src/ComponentVillageStartPiece.java
++++ ../src_work/common/net/minecraft/src/ComponentVillageStartPiece.java
+@@ -9,6 +9,7 @@
+ 
+     /** Boolean that determines if the village is in a desert or not. */
+     public final boolean inDesert;
++    public final BiomeGenBase biome;
+ 
+     /** World terrain type, 0 for normal, 1 for flap map */
+     public final int terrainType;
+@@ -30,6 +31,7 @@
+         this.terrainType = par7;
+         BiomeGenBase var8 = par1WorldChunkManager.getBiomeGenAt(par4, par5);
+         this.inDesert = var8 == BiomeGenBase.desert || var8 == BiomeGenBase.desertHills;
++        this.biome = var8;
+         this.startPiece = this;
+     }
+ 

patches/common/net/minecraft/src/GenLayer.java.patch

@@ -0,0 +1,30 @@
+--- ../src_base/common/net/minecraft/src/GenLayer.java
++++ ../src_work/common/net/minecraft/src/GenLayer.java
+@@ -1,4 +1,7 @@
+ package net.minecraft.src;
++
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.terraingen.*;
+ 
+ public abstract class GenLayer
+ {
+@@ -40,6 +43,7 @@
+         {
+             var4 = 6;
+         }
++        var4 = getModdedBiomeSize(par2WorldType, var4);
+ 
+         GenLayer var5 = GenLayerZoom.func_75915_a(1000L, var16, 0);
+         GenLayerRiverInit var13 = new GenLayerRiverInit(100L, var5);
+@@ -149,4 +153,11 @@
+      * amounts, or biomeList[] indices based on the particular GenLayer subclass.
+      */
+     public abstract int[] getInts(int var1, int var2, int var3, int var4);
++    
++    public static byte getModdedBiomeSize(WorldType worldType, byte original)
++    {
++        WorldTypeEvent.BiomeSize event = new WorldTypeEvent.BiomeSize(worldType, original);
++        MinecraftForge.TERRAIN_GEN_BUS.post(event);
++        return event.newSize;
++    }
+ }

patches/common/net/minecraft/src/WorldChunkManager.java.patch

@@ -1,21 +1,24 @@
 --- ../src_base/common/net/minecraft/src/WorldChunkManager.java
 +++ ../src_work/common/net/minecraft/src/WorldChunkManager.java
-@@ -3,11 +3,14 @@
+@@ -3,11 +3,17 @@
  import cpw.mods.fml.common.Side;
  import cpw.mods.fml.common.asm.SideOnly;
  import java.util.ArrayList;
 +import java.util.Arrays;
  import java.util.List;
  import java.util.Random;
-+import static net.minecraft.src.BiomeGenBase.*;
  
++import net.minecraftforge.common.*;
++import net.minecraftforge.event.terraingen.*;
++import static net.minecraft.src.BiomeGenBase.*;
++
  public class WorldChunkManager
  {
 +    public static ArrayList<BiomeGenBase> allowedBiomes = new ArrayList<BiomeGenBase>(Arrays.asList(forest, plains, taiga, taigaHills, forestHills, jungle. jungleHills));
      private GenLayer genBiomes;
  
      /** A GenLayer containing the indices into BiomeGenBase.biomeList[] */
-@@ -23,13 +26,7 @@
+@@ -23,19 +29,14 @@
      {
          this.biomeCache = new BiomeCache(this);
          this.biomesToSpawnIn = new ArrayList();
@@ -30,3 +33,22 @@
      }
  
      public WorldChunkManager(long par1, WorldType par3WorldType)
+     {
+         this();
+         GenLayer[] var4 = GenLayer.initializeAllBiomeGenerators(par1, par3WorldType);
++        var4 = getModdedBiomeGenerators(par3WorldType, par1, var4);
+         this.genBiomes = var4[0];
+         this.biomeIndexLayer = var4[1];
+     }
+@@ -259,4 +260,11 @@
+     {
+         this.biomeCache.cleanupCache();
+     }
++
++    public GenLayer[] getModdedBiomeGenerators(WorldType worldType, long seed, GenLayer[] original)
++    {
++        WorldTypeEvent.InitBiomeGens event = new WorldTypeEvent.InitBiomeGens(worldType, seed, original);
++        MinecraftForge.TERRAIN_GEN_BUS.post(event);
++        return event.newBiomeGens;
++    }
+ }