16 files changed, 623 insertions, 103 deletions

diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index d314fc13e..8fad9f5c9 100644
--- a/src/Generating/BioGen.cpp
+++ b/src/Generating/BioGen.cpp
@@ -95,7 +95,7 @@ void cBioGenConstant::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap
 
 void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
 {
-	AString Biome = a_IniFile.GetValueSet("Generator", "ConstantBiome", "Plains");
+	AString Biome = a_IniFile.GetValueSet("Generator", "ConstantBiome", "");
 	m_Biome = StringToBiome(Biome);
 	if (m_Biome == biInvalidBiome)
 	{
diff --git a/src/Generating/CMakeLists.txt b/src/Generating/CMakeLists.txt
index 9063abd97..58df9d421 100644
--- a/src/Generating/CMakeLists.txt
+++ b/src/Generating/CMakeLists.txt
@@ -25,6 +25,7 @@ SET (SRCS
 	PrefabPiecePool.cpp
 	RainbowRoadsGen.cpp
 	Ravines.cpp
+	RoughRavines.cpp
 	StructGen.cpp
 	TestRailsGen.cpp
 	Trees.cpp
@@ -52,6 +53,7 @@ SET (HDRS
 	PrefabPiecePool.h
 	RainbowRoadsGen.h
 	Ravines.h
+	RoughRavines.h
 	StructGen.h
 	TestRailsGen.h
 	Trees.h
diff --git a/src/Generating/Caves.cpp b/src/Generating/Caves.cpp
index 3b71efb57..6fc371958 100644
--- a/src/Generating/Caves.cpp
+++ b/src/Generating/Caves.cpp
@@ -497,29 +497,9 @@ void cCaveTunnel::ProcessChunk(
 				int SqDist = (DifX - x) * (DifX - x) + (DifY - y) * (DifY - y) + (DifZ - z) * (DifZ - z);
 				if (4 * SqDist <= SqRad)
 				{
-					switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))
+					if (cBlockInfo::CanBeTerraformed(cChunkDef::GetBlock(a_BlockTypes, x, y, z)))
 					{
-						// Only carve out these specific block types
-						case E_BLOCK_DIRT:
-						case E_BLOCK_GRASS:
-						case E_BLOCK_STONE:
-						case E_BLOCK_COBBLESTONE:
-						case E_BLOCK_GRAVEL:
-						case E_BLOCK_SAND:
-						case E_BLOCK_SANDSTONE:
-						case E_BLOCK_SOULSAND:
-						case E_BLOCK_NETHERRACK:
-						case E_BLOCK_COAL_ORE:
-						case E_BLOCK_IRON_ORE:
-						case E_BLOCK_GOLD_ORE:
-						case E_BLOCK_DIAMOND_ORE:
-						case E_BLOCK_REDSTONE_ORE:
-						case E_BLOCK_REDSTONE_ORE_GLOWING:
-						{
-							cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);
-							break;
-						}
-						default: break;
+						cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);
 					}
 				}
 			}  // for y
diff --git a/src/Generating/ChunkDesc.cpp b/src/Generating/ChunkDesc.cpp
index e4b305022..c0b646fd0 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -20,7 +20,6 @@ cChunkDesc::cChunkDesc(int a_ChunkX, int a_ChunkZ) :
 	m_bUseDefaultBiomes(true),
 	m_bUseDefaultHeight(true),
 	m_bUseDefaultComposition(true),
-	m_bUseDefaultStructures(true),
 	m_bUseDefaultFinish(true)
 {
 	m_BlockArea.Create(cChunkDef::Width, cChunkDef::Height, cChunkDef::Width);
@@ -207,26 +206,6 @@ bool cChunkDesc::IsUsingDefaultComposition(void) const
 
 
 
-void cChunkDesc::SetUseDefaultStructures(bool a_bUseDefaultStructures)
-{
-	LOGWARNING("%s: Structures are no longer accounted for, use Finishers instead", __FUNCTION__);
-	m_bUseDefaultStructures = a_bUseDefaultStructures;
-}
-
-
-
-
-
-bool cChunkDesc::IsUsingDefaultStructures(void) const
-{
-	LOGWARNING("%s: Structures are no longer accounted for, use Finishers instead", __FUNCTION__);
-	return m_bUseDefaultStructures;
-}
-
-
-
-
-
 void cChunkDesc::SetUseDefaultFinish(bool a_bUseDefaultFinish)
 {
 	m_bUseDefaultFinish = a_bUseDefaultFinish;
diff --git a/src/Generating/ChunkDesc.h b/src/Generating/ChunkDesc.h
index b306b1ee5..eeea0c957 100644
--- a/src/Generating/ChunkDesc.h
+++ b/src/Generating/ChunkDesc.h
@@ -68,8 +68,6 @@ public:
 	bool IsUsingDefaultHeight(void) const;
 	void SetUseDefaultComposition(bool a_bUseDefaultComposition);
 	bool IsUsingDefaultComposition(void) const;
-	void SetUseDefaultStructures(bool a_bUseDefaultStructures);
-	bool IsUsingDefaultStructures(void) const;
 	void SetUseDefaultFinish(bool a_bUseDefaultFinish);
 	bool IsUsingDefaultFinish(void) const;
 
@@ -214,7 +212,6 @@ private:
 	bool m_bUseDefaultBiomes;
 	bool m_bUseDefaultHeight;
 	bool m_bUseDefaultComposition;
-	bool m_bUseDefaultStructures;
 	bool m_bUseDefaultFinish;
 } ;  // tolua_export
 
diff --git a/src/Generating/ChunkGenerator.cpp b/src/Generating/ChunkGenerator.cpp
index 0baf1e991..3d5af152c 100644
--- a/src/Generating/ChunkGenerator.cpp
+++ b/src/Generating/ChunkGenerator.cpp
@@ -52,7 +52,7 @@ bool cChunkGenerator::Start(cPluginInterface & a_PluginInterface, cChunkSink & a
 	m_ChunkSink = &a_ChunkSink;
 
 	MTRand rnd;
-	m_Seed = a_IniFile.GetValueSetI("Seed", "Seed", rnd.randInt());
+	m_Seed = a_IniFile.GetValueSetI("Seed", "Seed", (int)rnd.randInt());
 	AString GeneratorName = a_IniFile.GetValueSet("Generator", "Generator", "Composable");
 
 	if (NoCaseCompare(GeneratorName, "Noise3D") == 0)
diff --git a/src/Generating/CompoGen.cpp b/src/Generating/CompoGen.cpp
index 912d74248..178673e32 100644
--- a/src/Generating/CompoGen.cpp
+++ b/src/Generating/CompoGen.cpp
@@ -638,7 +638,7 @@ void cCompoGenNether::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 			CeilingDisguise = -CeilingDisguise;
 		}
 
-		int CeilingDisguiseHeight = Height - 2 - CeilingDisguise * 3;
+		int CeilingDisguiseHeight = Height - 2 - (int)CeilingDisguise * 3;
 
 		for (int y = Height - 1; y > CeilingDisguiseHeight; y--)
 		{
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index ab6accee7..cedb9aeb7 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/src/Generating/ComposableGenerator.cpp
@@ -26,6 +26,7 @@
 #include "POCPieceGenerator.h"
 #include "RainbowRoadsGen.h"
 #include "Ravines.h"
+#include "RoughRavines.h"
 #include "TestRailsGen.h"
 #include "UnderwaterBaseGen.h"
 #include "VillageGen.h"
@@ -44,7 +45,6 @@ cTerrainCompositionGen * cTerrainCompositionGen::CreateCompositionGen(cIniFile &
 	{
 		LOGWARN("[Generator] CompositionGen value not set in world.ini, using \"Biomal\".");
 		CompoGenName = "Biomal";
-		a_IniFile.SetValue("Generator", "CompositionGen", CompoGenName);
 	}
 	
 	cTerrainCompositionGen * res = NULL;
@@ -98,7 +98,6 @@ cTerrainCompositionGen * cTerrainCompositionGen::CreateCompositionGen(cIniFile &
 	else
 	{
 		LOGWARN("Unknown CompositionGen \"%s\", using \"Biomal\" instead.", CompoGenName.c_str());
-		a_IniFile.DeleteValue("Generator", "CompositionGen");
 		a_IniFile.SetValue("Generator", "CompositionGen", "Biomal");
 		return CreateCompositionGen(a_IniFile, a_BiomeGen, a_HeightGen, a_Seed);
 	}
@@ -296,19 +295,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 	int Seed = m_ChunkGenerator.GetSeed();
 	eDimension Dimension = StringToDimension(a_IniFile.GetValue("General", "Dimension", "Overworld"));
 
-	// Older configuration used "Structures" in addition to "Finishers"; we don't distinguish between the two anymore (#398)
-	// Therefore, we load Structures from the ini file for compatibility, but move its contents over to Finishers:
-	AString Structures = a_IniFile.GetValue("Generator", "Structures", "");
-	AString Finishers = a_IniFile.GetValueSet("Generator", "Finishers", "Ravines, WormNestCaves, WaterLakes, LavaLakes, OreNests, Trees, SprinkleFoliage, Ice, Snow, Lilypads, BottomLava, DeadBushes, PreSimulator");
-	if (!Structures.empty())
-	{
-		LOGINFO("[Generator].Structures is deprecated, moving the contents to [Generator].Finishers.");
-		// Structures used to generate before Finishers, so place them first:
-		Structures.append(", ");
-		Finishers = Structures + Finishers;
-		a_IniFile.SetValue("Generator", "Finishers", Finishers);
-	}
-	a_IniFile.DeleteValue("Generator", "Structures");
+	AString Finishers = a_IniFile.GetValueSet("Generator", "Finishers", "");
 
 	// Create all requested finishers:
 	AStringVector Str = StringSplitAndTrim(Finishers, ",");
@@ -323,7 +310,25 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		}
 		else if (NoCaseCompare(*itr, "DeadBushes") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, biDesert, 2, E_BLOCK_SAND, E_BLOCK_SAND));
+			// A list with all the allowed biomes.
+			cFinishGenSingleTopBlock::BiomeList AllowedBiomes;
+			AllowedBiomes.push_back(biDesert);
+			AllowedBiomes.push_back(biDesertHills);
+			AllowedBiomes.push_back(biDesertM);
+			AllowedBiomes.push_back(biMesa);
+			AllowedBiomes.push_back(biMesaBryce);
+			AllowedBiomes.push_back(biMesaPlateau);
+			AllowedBiomes.push_back(biMesaPlateauF);
+			AllowedBiomes.push_back(biMesaPlateauFM);
+			AllowedBiomes.push_back(biMesaPlateauM);
+
+			// A list with all the allowed blocks that can be below the dead bush.
+			cFinishGenSingleTopBlock::BlockList AllowedBlocks;
+			AllowedBlocks.push_back(E_BLOCK_SAND);
+			AllowedBlocks.push_back(E_BLOCK_HARDENED_CLAY);
+			AllowedBlocks.push_back(E_BLOCK_STAINED_CLAY);
+
+			m_FinishGens.push_back(new cFinishGenSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, AllowedBiomes, 2, AllowedBlocks));
 		}
 		else if (NoCaseCompare(*itr, "DirectOverhangs") == 0)
 		{
@@ -370,7 +375,17 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		}
 		else if (NoCaseCompare(*itr, "Lilypads") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_LILY_PAD, biSwampland, 4, E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER));
+			// A list with all the allowed biomes.
+			cFinishGenSingleTopBlock::BiomeList AllowedBiomes;
+			AllowedBiomes.push_back(biSwampland);
+			AllowedBiomes.push_back(biSwamplandM);
+
+			// A list with all the allowed blocks that can be below the lilypad.
+			cFinishGenSingleTopBlock::BlockList AllowedBlocks;
+			AllowedBlocks.push_back(E_BLOCK_WATER);
+			AllowedBlocks.push_back(E_BLOCK_STATIONARY_WATER);
+
+			m_FinishGens.push_back(new cFinishGenSingleTopBlock(Seed, E_BLOCK_LILY_PAD, AllowedBiomes, 4, AllowedBlocks));
 		}
 		else if (NoCaseCompare(*itr, "NetherClumpFoliage") == 0)
 		{
@@ -393,20 +408,54 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		}
 		else if (NoCaseCompare(*itr, "PreSimulator") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenPreSimulator);
+			// Load the settings
+			bool PreSimulateFallingBlocks = a_IniFile.GetValueSetB("Generator", "PreSimulatorFallingBlocks", true);
+			bool PreSimulateWater         = a_IniFile.GetValueSetB("Generator", "PreSimulatorWater", true);
+			bool PreSimulateLava          = a_IniFile.GetValueSetB("Generator", "PreSimulatorLava", true);
+
+			m_FinishGens.push_back(new cFinishGenPreSimulator(PreSimulateFallingBlocks, PreSimulateWater, PreSimulateLava));
 		}
 		else if (NoCaseCompare(*itr, "RainbowRoads") == 0)
 		{
-			int GridSize  = a_IniFile.GetValueSetI("Generator", "RainbowRoadsGridSize", 512);
+			int GridSize  = a_IniFile.GetValueSetI("Generator", "RainbowRoadsGridSize",  512);
 			int MaxOffset = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxOffset", 128);
-			int MaxDepth  = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxDepth",  30);
-			int MaxSize   = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxSize",  260);
+			int MaxDepth  = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxDepth",   30);
+			int MaxSize   = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxSize",   260);
 			m_FinishGens.push_back(new cRainbowRoadsGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize));
 		}
 		else if (NoCaseCompare(*itr, "Ravines") == 0)
 		{
 			m_FinishGens.push_back(new cStructGenRavines(Seed, 128));
 		}
+		else if (NoCaseCompare(*itr, "RoughRavines") == 0)
+		{
+			int GridSize                  = a_IniFile.GetValueSetI("Generator", "RoughRavinesGridSize",              256);
+			int MaxOffset                 = a_IniFile.GetValueSetI("Generator", "RoughRavinesMaxOffset",             128);
+			int MaxSize                   = a_IniFile.GetValueSetI("Generator", "RoughRavinesMaxSize",               128);
+			int MinSize                   = a_IniFile.GetValueSetI("Generator", "RoughRavinesMinSize",                64);
+			double MaxCenterWidth         = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCenterWidth",          8);
+			double MinCenterWidth         = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCenterWidth",          2);
+			double MaxRoughness           = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxRoughness",            0.2);
+			double MinRoughness           = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinRoughness",            0.05);
+			double MaxFloorHeightEdge     = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxFloorHeightEdge",      8);
+			double MinFloorHeightEdge     = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinFloorHeightEdge",     30);
+			double MaxFloorHeightCenter   = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxFloorHeightCenter",   20);
+			double MinFloorHeightCenter   = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinFloorHeightCenter",    6);
+			double MaxCeilingHeightEdge   = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCeilingHeightEdge",   56);
+			double MinCeilingHeightEdge   = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCeilingHeightEdge",   38);
+			double MaxCeilingHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCeilingHeightCenter", 58);
+			double MinCeilingHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCeilingHeightCenter", 36);
+			m_FinishGens.push_back(new cRoughRavines(
+				Seed, MaxSize, MinSize,
+				(float)MaxCenterWidth,         (float)MinCenterWidth,
+				(float)MaxRoughness,           (float)MinRoughness,
+				(float)MaxFloorHeightEdge,     (float)MinFloorHeightEdge,
+				(float)MaxFloorHeightCenter,   (float)MinFloorHeightCenter,
+				(float)MaxCeilingHeightEdge,   (float)MinCeilingHeightEdge,
+				(float)MaxCeilingHeightCenter, (float)MinCeilingHeightCenter,
+				GridSize, MaxOffset
+			));
+		}
 		else if (NoCaseCompare(*itr, "Snow") == 0)
 		{
 			m_FinishGens.push_back(new cFinishGenSnow);
diff --git a/src/Generating/DistortedHeightmap.cpp b/src/Generating/DistortedHeightmap.cpp
index 1337896ab..c18c402da 100644
--- a/src/Generating/DistortedHeightmap.cpp
+++ b/src/Generating/DistortedHeightmap.cpp
@@ -809,7 +809,7 @@ void cDistortedHeightmap::FillColumnPattern(cChunkDesc & a_ChunkDesc, int a_RelX
 		}
 		
 		// Select the ocean-floor pattern to use:
-		a_Pattern = ChooseOceanFloorPattern(a_RelX, a_RelZ);
+		a_Pattern = a_ChunkDesc.GetBiome(a_RelX, a_RelZ) == biDeepOcean ? patGravel.Get() : ChooseOceanFloorPattern(a_RelX, a_RelZ);
 		HasHadWater = true;
 	}  // for y
 	a_ChunkDesc.SetBlockType(a_RelX, 0, a_RelZ, E_BLOCK_BEDROCK);
diff --git a/src/Generating/EndGen.cpp b/src/Generating/EndGen.cpp
index abbf050f7..c94cd1eff 100644
--- a/src/Generating/EndGen.cpp
+++ b/src/Generating/EndGen.cpp
@@ -50,7 +50,7 @@ cEndGen::cEndGen(int a_Seed) :
 
 
 
-void cEndGen::Initialize(cIniFile & a_IniFile)
+void cEndGen::InitializeCompoGen(cIniFile & a_IniFile)
 {
 	m_IslandSizeX = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeX", m_IslandSizeX);
 	m_IslandSizeY = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeY", m_IslandSizeY);
diff --git a/src/Generating/EndGen.h b/src/Generating/EndGen.h
index 4904a0e3d..322061810 100644
--- a/src/Generating/EndGen.h
+++ b/src/Generating/EndGen.h
@@ -23,8 +23,6 @@ class cEndGen :
 public:
 	cEndGen(int a_Seed);
 	
-	void Initialize(cIniFile & a_IniFile);
-	
 protected:
 
 	/// Seed for the noise
@@ -66,4 +64,5 @@ protected:
 
 	// cTerrainCompositionGen overrides:
 	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
+	virtual void InitializeCompoGen(cIniFile & a_IniFile) override;
 } ;
diff --git a/src/Generating/FinishGen.cpp b/src/Generating/FinishGen.cpp
index 03137f616..e8324095e 100644
--- a/src/Generating/FinishGen.cpp
+++ b/src/Generating/FinishGen.cpp
@@ -135,13 +135,22 @@ void cFinishGenNetherClumpFoliage::TryPlaceClump(cChunkDesc & a_ChunkDesc, int a
 			int zz = a_ChunkDesc.GetChunkZ() * cChunkDef::Width + z;
 			for (int y = MinY; y < MaxY; y++)
 			{
+				if (
+					((x < 0) || (x >= cChunkDef::Width)) ||
+					((y < 0) || (y >= cChunkDef::Height)) ||
+					((z < 0) || (z >= cChunkDef::Width))
+					)
+				{
+					continue;
+				}
+
 				if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_AIR)  // Don't replace non air blocks.
 				{
 					continue;
 				}
 
 				BLOCKTYPE BlockBelow = a_ChunkDesc.GetBlockType(x, y - 1, z);
-				if (!cBlockInfo::IsSolid(BlockBelow))  // Only place on solid blocks
+				if (!cBlockInfo::FullyOccupiesVoxel(BlockBelow))  // Only place on solid blocks
 				{
 					continue;
 				}
@@ -454,14 +463,14 @@ void cFinishGenIce::GenFinish(cChunkDesc & a_ChunkDesc)
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// cFinishGenLilypads:
+// cFinishGenSingleTopBlock:
 
-int cFinishGenSingleBiomeSingleTopBlock::GetNumToGen(const cChunkDef::BiomeMap & a_BiomeMap)
+int cFinishGenSingleTopBlock::GetNumToGen(const cChunkDef::BiomeMap & a_BiomeMap)
 {
 	int res = 0;
 	for (size_t i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)
 	{
-		if (a_BiomeMap[i] == m_Biome)
+		if (IsAllowedBiome(a_BiomeMap[i]))
 		{
 			res++;
 		}
@@ -473,7 +482,7 @@ int cFinishGenSingleBiomeSingleTopBlock::GetNumToGen(const cChunkDef::BiomeMap &
 
 
 
-void cFinishGenSingleBiomeSingleTopBlock::GenFinish(cChunkDesc & a_ChunkDesc)
+void cFinishGenSingleTopBlock::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	// Add Lilypads on top of water surface in Swampland
 
@@ -486,11 +495,13 @@ void cFinishGenSingleBiomeSingleTopBlock::GenFinish(cChunkDesc & a_ChunkDesc)
 		int z = (m_Noise.IntNoise3DInt(ChunkX - ChunkZ, i, ChunkZ) / 11) % cChunkDef::Width;
 
 		// Place the block at {x, z} if possible:
-		if (a_ChunkDesc.GetBiome(x, z) != m_Biome)
+		EMCSBiome Biome = a_ChunkDesc.GetBiome(x, z);
+		if (!IsAllowedBiome(Biome))
 		{
 			// Incorrect biome
 			continue;
 		}
+
 		int Height = a_ChunkDesc.GetHeight(x, z);
 		if (Height >= cChunkDef::Height)
 		{
@@ -502,13 +513,16 @@ void cFinishGenSingleBiomeSingleTopBlock::GenFinish(cChunkDesc & a_ChunkDesc)
 			// Not an empty block
 			continue;
 		}
+
 		BLOCKTYPE BlockBelow = a_ChunkDesc.GetBlockType(x, Height, z);
-		if ((BlockBelow == m_AllowedBelow1) || (BlockBelow == m_AllowedBelow2))
+		if (!IsAllowedBlockBelow(BlockBelow))
 		{
-			a_ChunkDesc.SetBlockType(x, Height + 1, z, m_BlockType);
-			a_ChunkDesc.SetHeight(x, z, Height + 1);
+			continue;
 		}
-	}  // for i
+
+		a_ChunkDesc.SetBlockType(x, Height + 1, z, m_BlockType);
+		a_ChunkDesc.SetHeight(x, z, Height + 1);
+	}
 }
 
 
@@ -541,7 +555,10 @@ void cFinishGenBottomLava::GenFinish(cChunkDesc & a_ChunkDesc)
 ////////////////////////////////////////////////////////////////////////////////
 // cFinishGenPreSimulator:
 
-cFinishGenPreSimulator::cFinishGenPreSimulator(void)
+cFinishGenPreSimulator::cFinishGenPreSimulator(bool a_PreSimulateFallingBlocks, bool a_PreSimulateWater, bool a_PreSimulateLava) :
+	m_PreSimulateFallingBlocks(a_PreSimulateFallingBlocks),
+	m_PreSimulateWater(a_PreSimulateWater),
+	m_PreSimulateLava(a_PreSimulateLava)
 {
 	// Nothing needed yet
 }
@@ -552,9 +569,20 @@ cFinishGenPreSimulator::cFinishGenPreSimulator(void)
 
 void cFinishGenPreSimulator::GenFinish(cChunkDesc & a_ChunkDesc)
 {
-	CollapseSandGravel(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
-	StationarizeFluid(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap(), E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER);
-	StationarizeFluid(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap(), E_BLOCK_LAVA,  E_BLOCK_STATIONARY_LAVA);
+	if (m_PreSimulateFallingBlocks)
+	{
+		CollapseSandGravel(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
+	}
+
+	if (m_PreSimulateWater)
+	{
+		StationarizeFluid(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap(), E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER);
+	}
+
+	if (m_PreSimulateLava)
+	{
+		StationarizeFluid(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap(), E_BLOCK_LAVA, E_BLOCK_STATIONARY_LAVA);
+	}
 	// TODO: other operations
 }
 
diff --git a/src/Generating/FinishGen.h b/src/Generating/FinishGen.h
index 810bb4a91..4a08d70c8 100644
--- a/src/Generating/FinishGen.h
+++ b/src/Generating/FinishGen.h
@@ -143,32 +143,69 @@ Used for:
 - Lilypads finisher
 - DeadBushes finisher
 */
-class cFinishGenSingleBiomeSingleTopBlock :
+class cFinishGenSingleTopBlock :
 	public cFinishGen
 {
 public:
-	cFinishGenSingleBiomeSingleTopBlock(
-		int a_Seed, BLOCKTYPE a_BlockType, EMCSBiome a_Biome, int a_Amount,
-		BLOCKTYPE a_AllowedBelow1, BLOCKTYPE a_AllowedBelow2
+	typedef std::vector<BLOCKTYPE> BlockList;
+	bool m_IsAllowedBelow[256];
+
+	typedef std::vector<EMCSBiome> BiomeList;
+	bool m_IsBiomeAllowed[256];
+
+
+	cFinishGenSingleTopBlock(
+		int a_Seed, BLOCKTYPE a_BlockType, BiomeList a_Biomes, int a_Amount,
+		BlockList a_AllowedBelow
 	) :
 		m_Noise(a_Seed),
 		m_BlockType(a_BlockType),
-		m_Biome(a_Biome),
-		m_Amount(a_Amount),
-		m_AllowedBelow1(a_AllowedBelow1),
-		m_AllowedBelow2(a_AllowedBelow2)
+		m_Amount(a_Amount)
 	{
+		// Initialize all the block types.
+		for (size_t idx = 0; idx < ARRAYCOUNT(m_IsAllowedBelow); ++idx)
+		{
+			m_IsAllowedBelow[idx] = false;
+		}
+		
+		// Load the allowed blocks into m_IsAllowedBelow
+		for (BlockList::iterator itr = a_AllowedBelow.begin(); itr != a_AllowedBelow.end(); ++itr)
+		{
+			m_IsAllowedBelow[*itr] = true;
+		}
+		
+		// Initialize all the biome types.
+		for (size_t idx = 0; idx < ARRAYCOUNT(m_IsBiomeAllowed); ++idx)
+		{
+			m_IsBiomeAllowed[idx] = false;
+		}
+		
+		// Load the allowed biomes into m_IsBiomeAllowed
+		for (BiomeList::iterator itr = a_Biomes.begin(); itr != a_Biomes.end(); ++itr)
+		{
+			m_IsBiomeAllowed[*itr] = true;
+		}
 	}
 	
 protected:
 	cNoise m_Noise;
 	BLOCKTYPE m_BlockType;
-	EMCSBiome m_Biome;
 	int       m_Amount;         ///< Relative amount of blocks to try adding. 1 = one block per 256 biome columns.
-	BLOCKTYPE m_AllowedBelow1;  ///< First  of the two blocktypes that are allowed below m_BlockType
-	BLOCKTYPE m_AllowedBelow2;  ///< Second of the two blocktypes that are allowed below m_BlockType
 	
 	int GetNumToGen(const cChunkDef::BiomeMap & a_BiomeMap);
+
+	// Returns true if the given biome is a biome that is allowed.
+	inline bool IsAllowedBiome(EMCSBiome a_Biome)
+	{
+		return m_IsBiomeAllowed[a_Biome];
+	}
+
+	// Returns true if the given blocktype may be below m_BlockType
+	inline bool IsAllowedBlockBelow(BLOCKTYPE a_BlockBelow)
+	{
+		return m_IsAllowedBelow[a_BlockBelow];
+	}
+
 	
 	// cFinishGen override:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
@@ -203,9 +240,14 @@ class cFinishGenPreSimulator :
 	public cFinishGen
 {
 public:
-	cFinishGenPreSimulator(void);
+	cFinishGenPreSimulator(bool a_PreSimulateFallingBlocks, bool a_PreSimulateWater, bool a_PreSimulateLava);
 	
 protected:
+
+	bool m_PreSimulateFallingBlocks;
+	bool m_PreSimulateWater;
+	bool m_PreSimulateLava;
+
 	// Drops hanging sand and gravel down to the ground, recalculates heightmap
 	void CollapseSandGravel(
 		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
diff --git a/src/Generating/RoughRavines.cpp b/src/Generating/RoughRavines.cpp
new file mode 100644
index 000000000..2ee3704b3
--- /dev/null
+++ b/src/Generating/RoughRavines.cpp
@@ -0,0 +1,300 @@
+
+// RoughRavines.cpp
+
+// Implements the cRoughRavines class representing the rough ravine generator
+
+#include "Globals.h"
+
+#include "RoughRavines.h"
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cRoughRavine:
+
+class cRoughRavine :
+	public cGridStructGen::cStructure
+{
+	typedef cGridStructGen::cStructure super;
+	
+public:
+	cRoughRavine(
+		int a_Seed, int a_Size,
+		float a_CenterWidth, float a_Roughness,
+		float a_FloorHeightEdge1,   float a_FloorHeightEdge2,   float a_FloorHeightCenter,
+		float a_CeilingHeightEdge1, float a_CeilingHeightEdge2, float a_CeilingHeightCenter,
+		int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ
+	) :
+		super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
+		m_Seed(a_Seed + 100),
+		m_Noise(a_Seed + 100),
+		m_Roughness(a_Roughness)
+	{
+		// Create the basic structure - 2 lines meeting at the centerpoint:
+		int Max = 2 * a_Size;
+		int Half = a_Size;  // m_DefPoints[Half] will be the centerpoint
+		m_DefPoints.resize(Max + 1);
+		int rnd = m_Noise.IntNoise2DInt(a_OriginX, a_OriginZ) / 7;
+		float Len = (float)a_Size;
+		float Angle = (float)rnd;  // Angle is in radians, will be wrapped in the "sin" and "cos" operations
+		float OfsX = sin(Angle) * Len;
+		float OfsZ = cos(Angle) * Len;
+		m_DefPoints[0].Set   (a_OriginX - OfsX, a_OriginZ - OfsZ, 1,             a_CeilingHeightEdge1,  a_FloorHeightEdge1);
+		m_DefPoints[Half].Set((float)a_OriginX, (float)a_OriginZ, a_CenterWidth, a_CeilingHeightCenter, a_FloorHeightCenter);
+		m_DefPoints[Max].Set (a_OriginX + OfsX, a_OriginZ + OfsZ, 1,             a_CeilingHeightEdge2,  a_FloorHeightEdge2);
+		
+		// Calculate the points in between, recursively:
+		SubdivideLine(0, Half);
+		SubdivideLine(Half, Max);
+		
+		// Initialize the per-height radius modifiers:
+		InitPerHeightRadius(a_GridX, a_GridZ);
+	}
+	
+protected:
+	struct sRavineDefPoint
+	{
+		float m_X;
+		float m_Z;
+		float m_Radius;
+		float m_Top;
+		float m_Bottom;
+		
+		void Set(float a_X, float a_Z, float a_Radius, float a_Top, float a_Bottom)
+		{
+			m_X = a_X;
+			m_Z = a_Z;
+			m_Radius = a_Radius;
+			m_Top = a_Top;
+			m_Bottom = a_Bottom;
+		}
+	};
+	typedef std::vector<sRavineDefPoint> sRavineDefPoints;
+	
+	int m_Seed;
+	
+	cNoise m_Noise;
+	
+	int m_MaxSize;
+	
+	sRavineDefPoints m_DefPoints;
+	
+	float m_Roughness;
+	
+	/** Number to add to the radius based on the height. This creates the "ledges" in the ravine walls. */
+	float m_PerHeightRadius[cChunkDef::Height];
+	
+	
+	/** Recursively subdivides the line between the points of the specified index.
+	Sets the midpoint to the center of the line plus or minus a random offset, then calls itself for each half
+	of the new line. */
+	void SubdivideLine(int a_Idx1, int a_Idx2)
+	{
+		// Calculate the midpoint:
+		const sRavineDefPoint & p1 = m_DefPoints[a_Idx1];
+		const sRavineDefPoint & p2 = m_DefPoints[a_Idx2];
+		float MidX = (p1.m_X + p2.m_X) / 2;
+		float MidZ = (p1.m_Z + p2.m_Z) / 2;
+		float MidR = (p1.m_Radius + p2.m_Radius) / 2 + 0.1f;
+		float MidT = (p1.m_Top    + p2.m_Top)    / 2;
+		float MidB = (p1.m_Bottom + p2.m_Bottom) / 2;
+
+		// Adjust the midpoint by a small amount of perpendicular vector in a random one of its two directions:
+		float dx = p2.m_X - p1.m_X;
+		float dz = p2.m_Z - p1.m_Z;
+		if ((m_Noise.IntNoise2DInt((int)MidX, (int)MidZ) / 11) % 2 == 0)
+		{
+			MidX += dz * m_Roughness;
+			MidZ -= dx * m_Roughness;
+		}
+		else
+		{
+			MidX -= dz * m_Roughness;
+			MidZ += dx * m_Roughness;
+		}
+		int MidIdx = (a_Idx1 + a_Idx2) / 2;
+		m_DefPoints[MidIdx].Set(MidX, MidZ, MidR, MidT, MidB);
+		
+		// Recurse the two halves, if they are worth recursing:
+		if (MidIdx - a_Idx1 > 1)
+		{
+			SubdivideLine(a_Idx1, MidIdx);
+		}
+		if (a_Idx2 - MidIdx > 1)
+		{
+			SubdivideLine(MidIdx, a_Idx2);
+		}
+	}
+	
+	
+	void InitPerHeightRadius(int a_GridX, int a_GridZ)
+	{
+		int h = 0;
+		while (h < cChunkDef::Height)
+		{
+			m_Noise.SetSeed(m_Seed + h);
+			int rnd = m_Noise.IntNoise2DInt(a_GridX, a_GridZ) / 13;
+			int NumBlocks = (rnd % 3) + 2;
+			rnd = rnd / 4;
+			float Val = (float)(rnd % 256) / 128 - 1;  // Random float in range [-1, +1]
+			if (h + NumBlocks > cChunkDef::Height)
+			{
+				NumBlocks = cChunkDef::Height - h;
+			}
+			for (int i = 0; i < NumBlocks; i++)
+			{
+				m_PerHeightRadius[h + i] = Val;
+			}
+			h += NumBlocks;
+		}
+	}
+	
+	
+	virtual void DrawIntoChunk(cChunkDesc & a_ChunkDesc) override
+	{
+		int BlockStartX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+		int BlockStartZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+		int BlockEndX = BlockStartX + cChunkDef::Width;
+		int BlockEndZ = BlockStartZ + cChunkDef::Width;
+		for (sRavineDefPoints::const_iterator itr = m_DefPoints.begin(), end = m_DefPoints.end(); itr != end; ++itr)
+		{
+			if (
+				(ceilf (itr->m_X + itr->m_Radius + 2) < BlockStartX) ||
+				(floorf(itr->m_X - itr->m_Radius - 2) > BlockEndX) ||
+				(ceilf (itr->m_Z + itr->m_Radius + 2) < BlockStartZ) ||
+				(floorf(itr->m_Z - itr->m_Radius - 2) > BlockEndZ)
+			)
+			{
+				// Cannot intersect, bail out early
+				continue;
+			}
+			
+			// Carve out a cylinder around the xz point, up to (m_Radius + 2) in diameter, from Bottom to Top:
+			// On each height level, use m_PerHeightRadius[] to modify the actual radius used
+			// EnlargedRadiusSq is the square of the radius enlarged by the maximum m_PerHeightRadius offset - anything outside it will never be touched.
+			float RadiusSq = (itr->m_Radius + 2) * (itr->m_Radius + 2);
+			float DifX = BlockStartX - itr->m_X;  // substitution for faster calc
+			float DifZ = BlockStartZ - itr->m_Z;  // substitution for faster calc
+			for (int x = 0; x < cChunkDef::Width; x++) for (int z = 0; z < cChunkDef::Width; z++)
+			{
+				#ifdef _DEBUG
+				// DEBUG: Make the roughravine shapepoints visible on a single layer (so that we can see with Minutor what's going on)
+				if ((DifX + x == 0) && (DifZ + z == 0))
+				{
+					a_ChunkDesc.SetBlockType(x, 4, z, E_BLOCK_LAPIS_ORE);
+				}
+				#endif  // _DEBUG
+				
+				// If the column is outside the enlarged radius, bail out completely
+				float DistSq = (DifX + x) * (DifX + x) + (DifZ + z) * (DifZ + z);
+				if (DistSq > RadiusSq)
+				{
+					continue;
+				}
+				
+				int Top = std::min((int)ceilf(itr->m_Top), +cChunkDef::Height);
+				for (int y = std::max((int)floorf(itr->m_Bottom), 1); y <= Top; y++)
+				{
+					if ((itr->m_Radius + m_PerHeightRadius[y]) * (itr->m_Radius + m_PerHeightRadius[y]) < DistSq)
+					{
+						continue;
+					}
+
+					if (cBlockInfo::CanBeTerraformed(a_ChunkDesc.GetBlockType(x, y, z)))
+					{
+						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);
+					}
+				}  // for y
+			}  // for x, z - a_BlockTypes
+		}  // for itr - m_Points[]
+	}
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cRoughRavines:
+
+cRoughRavines::cRoughRavines(
+	int a_Seed,
+	int a_MaxSize, int a_MinSize,
+	float a_MaxCenterWidth, float a_MinCenterWidth,
+	float a_MaxRoughness,   float a_MinRoughness,
+	float a_MaxFloorHeightEdge,     float a_MinFloorHeightEdge,
+	float a_MaxFloorHeightCenter,   float a_MinFloorHeightCenter,
+	float a_MaxCeilingHeightEdge,   float a_MinCeilingHeightEdge,
+	float a_MaxCeilingHeightCenter, float a_MinCeilingHeightCenter,
+	int a_GridSize, int a_MaxOffset
+) :
+	super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 64),
+	m_Seed(a_Seed),
+	m_MaxSize(a_MaxSize),
+	m_MinSize(a_MinSize),
+	m_MaxCenterWidth(a_MaxCenterWidth),
+	m_MinCenterWidth(a_MinCenterWidth),
+	m_MaxRoughness(a_MaxRoughness),
+	m_MinRoughness(a_MinRoughness),
+	m_MaxFloorHeightEdge(a_MaxFloorHeightEdge),
+	m_MinFloorHeightEdge(a_MinFloorHeightEdge),
+	m_MaxFloorHeightCenter(a_MaxFloorHeightCenter),
+	m_MinFloorHeightCenter(a_MinFloorHeightCenter),
+	m_MaxCeilingHeightEdge(a_MaxCeilingHeightEdge),
+	m_MinCeilingHeightEdge(a_MinCeilingHeightEdge),
+	m_MaxCeilingHeightCenter(a_MaxCeilingHeightCenter),
+	m_MinCeilingHeightCenter(a_MinCeilingHeightCenter)
+{
+	if (m_MinSize > m_MaxSize)
+	{
+		std::swap(m_MinSize, m_MaxSize);
+		std::swap(a_MinSize, a_MaxSize);
+	}
+	if (m_MaxSize < 16)
+	{
+		m_MaxSize = 16;
+		LOGWARNING("RoughRavines: MaxSize too small, adjusting request from %d to %d", a_MaxSize, m_MaxSize);
+	}
+	if (m_MinSize < 16)
+	{
+		m_MinSize = 16;
+		LOGWARNING("RoughRavines: MinSize too small, adjusting request from %d to %d", a_MinSize, m_MinSize);
+	}
+	if (m_MinSize == m_MaxSize)
+	{
+		m_MaxSize = m_MinSize + 1;
+	}
+}
+
+
+
+
+
+cGridStructGen::cStructurePtr cRoughRavines::CreateStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ)
+{
+	// Pick a random value for each of the ravine's parameters:
+	int Size = m_MinSize + (m_Noise.IntNoise2DInt(a_GridX, a_GridZ) / 7) % (m_MaxSize - m_MinSize);  // Random int from m_MinSize to m_MaxSize
+	float CenterWidth         = m_Noise.IntNoise2DInRange(a_GridX + 10, a_GridZ, m_MinCenterWidth,         m_MaxCenterWidth);
+	float Roughness           = m_Noise.IntNoise2DInRange(a_GridX + 20, a_GridZ, m_MinRoughness,           m_MaxRoughness);
+	float FloorHeightEdge1    = m_Noise.IntNoise2DInRange(a_GridX + 30, a_GridZ, m_MinFloorHeightEdge,     m_MaxFloorHeightEdge);
+	float FloorHeightEdge2    = m_Noise.IntNoise2DInRange(a_GridX + 40, a_GridZ, m_MinFloorHeightEdge,     m_MaxFloorHeightEdge);
+	float FloorHeightCenter   = m_Noise.IntNoise2DInRange(a_GridX + 50, a_GridZ, m_MinFloorHeightCenter,   m_MaxFloorHeightCenter);
+	float CeilingHeightEdge1  = m_Noise.IntNoise2DInRange(a_GridX + 60, a_GridZ, m_MinCeilingHeightEdge,   m_MaxCeilingHeightEdge);
+	float CeilingHeightEdge2  = m_Noise.IntNoise2DInRange(a_GridX + 70, a_GridZ, m_MinCeilingHeightEdge,   m_MaxCeilingHeightEdge);
+	float CeilingHeightCenter = m_Noise.IntNoise2DInRange(a_GridX + 80, a_GridZ, m_MinCeilingHeightCenter, m_MaxCeilingHeightCenter);
+	
+	// Create a ravine:
+	return cStructurePtr(new cRoughRavine(
+		m_Seed,
+		Size, CenterWidth, Roughness,
+		FloorHeightEdge1,   FloorHeightEdge2,   FloorHeightCenter,
+		CeilingHeightEdge1, CeilingHeightEdge2, CeilingHeightCenter,
+		a_GridX, a_GridZ, a_OriginX, a_OriginZ
+	));
+}
+
+
+
+
diff --git a/src/Generating/RoughRavines.h b/src/Generating/RoughRavines.h
new file mode 100644
index 000000000..4c905b641
--- /dev/null
+++ b/src/Generating/RoughRavines.h
@@ -0,0 +1,86 @@
+
+// RoughRavines.h
+
+// Declares the cRoughRavines class representing the rough ravine generator
+
+
+
+
+#pragma once
+
+#include "GridStructGen.h"
+
+
+
+
+
+class cRoughRavines :
+	public cGridStructGen
+{
+	typedef cGridStructGen super;
+	
+public:
+	cRoughRavines(
+		int a_Seed,
+		int a_MaxSize, int a_MinSize,
+		float a_MaxCenterWidth, float a_MinCenterWidth,
+		float a_MaxRoughness,   float a_MinRoughness,
+		float a_MaxFloorHeightEdge,     float a_MinFloorHeightEdge,
+		float a_MaxFloorHeightCenter,   float a_MinFloorHeightCenter,
+		float a_MaxCeilingHeightEdge,   float a_MinCeilingHeightEdge,
+		float a_MaxCeilingHeightCenter, float a_MinCeilingHeightCenter,
+		int a_GridSize, int a_MaxOffset
+	);
+	
+protected:
+	int m_Seed;
+	
+	/** Maximum size of the ravine, in each of the X / Z axis */
+	int m_MaxSize;
+	
+	/** Minimum size of the ravine */
+	int m_MinSize;
+
+	/** Maximum width of the ravine's center, in blocks */
+	float m_MaxCenterWidth;
+	
+	/** Minimum width of the ravine's center, in blocks */
+	float m_MinCenterWidth;
+	
+	/** Maximum roughness of the ravine */
+	float m_MaxRoughness;
+
+	/** Minimum roughness of the ravine */
+	float m_MinRoughness;
+
+	/** Maximum floor height at the ravine's edge */
+	float m_MaxFloorHeightEdge;
+	
+	/** Minimum floor height at the ravine's edge */
+	float m_MinFloorHeightEdge;
+	
+	/** Maximum floor height at the ravine's center */
+	float m_MaxFloorHeightCenter;
+	
+	/** Minimum floor height at the ravine's center */
+	float m_MinFloorHeightCenter;
+	
+	/** Maximum ceiling height at the ravine's edge */
+	float m_MaxCeilingHeightEdge;
+	
+	/** Minimum ceiling height at the ravine's edge */
+	float m_MinCeilingHeightEdge;
+	
+	/** Maximum ceiling height at the ravine's center */
+	float m_MaxCeilingHeightCenter;
+	
+	/** Minimum ceiling height at the ravine's center */
+	float m_MinCeilingHeightCenter;
+
+	// cGridStructGen overrides:
+	virtual cStructurePtr CreateStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ) override;
+};
+
+
+
+
diff --git a/src/Generating/Trees.cpp b/src/Generating/Trees.cpp
index c40322630..32594d0b4 100644
--- a/src/Generating/Trees.cpp
+++ b/src/Generating/Trees.cpp
@@ -218,7 +218,6 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 			return;
 		}
 
-		case biRoofedForest:
 		case biColdTaiga:
 		case biColdTaigaHills:
 		case biMegaTaiga:
@@ -238,7 +237,6 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 		case biIcePlainsSpikes:
 		case biJungleM:
 		case biJungleEdgeM:
-		case biRoofedForestM:
 		case biColdTaigaM:
 		case biMegaSpruceTaiga:
 		case biMegaSpruceTaigaHills:
@@ -253,6 +251,13 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 			GetBirchTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
 			return;
 		}
+
+		case biRoofedForest:
+		case biRoofedForestM:
+		{
+			GetDarkoakTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
+			return;
+		}
 			
 		case biDesert:
 		case biDesertHills:
@@ -407,7 +412,60 @@ void GetAcaciaTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noi
 
 void GetDarkoakTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
 {
-	// TODO
+	// Pick a height
+	int Height = 5 + (a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY, a_BlockZ + 32 * a_Seq) / 11) % 4;
+
+	// Create the trunk
+	for (int i = 0; i < Height; i++)
+	{
+		a_LogBlocks.push_back(sSetBlock(a_BlockX, a_BlockY + i, a_BlockZ, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));
+		a_LogBlocks.push_back(sSetBlock(a_BlockX + 1, a_BlockY + i, a_BlockZ, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));
+		a_LogBlocks.push_back(sSetBlock(a_BlockX, a_BlockY + i, a_BlockZ + 1, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));
+		a_LogBlocks.push_back(sSetBlock(a_BlockX + 1, a_BlockY + i, a_BlockZ + 1, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));
+	}
+
+	// Create branches
+	for (int i = 0; i < 3; i++)
+	{
+		int x = (a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY * i, a_BlockZ + 32 * a_Seq) % 3) - 1;
+		int z = (a_Noise.IntNoise3DInt(a_BlockX - 32 * a_Seq, a_BlockY * i, a_BlockZ - 32 * a_Seq) % 3) - 1;
+
+		// The branches would end up in the trunk.
+		if ((x >= a_BlockX) && (x <= a_BlockX + 1) && (z >= a_BlockZ) && (z <= a_BlockZ + 1))
+		{
+			NOISE_DATATYPE Val1 = a_Noise.IntNoise2D(x, z);
+			if (Val1 < 0)
+			{
+				x = a_BlockX + ((Val1 < -0.5) ? -1 : 3);
+			}
+			else
+			{
+				z = a_BlockZ + ((Val1 < 0.5) ? -1 : 3);
+			}
+		}
+
+		int y = Height - (a_Noise.IntNoise3DInt(a_BlockX + x, a_BlockY * i, a_BlockZ - z) % (Height - (Height / 4)));
+
+		for (int Y = y; Y < Height; Y++)
+		{
+			a_LogBlocks.push_back(sSetBlock(a_BlockX + x, a_BlockY + Y, a_BlockZ + z, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));
+		}
+	}
+
+	int hei = a_BlockY + Height - 2;
+
+	// The lower two leaves layers are BigO4 with log in the middle and possibly corners:
+	for (int i = 0; i < 2; i++)
+	{
+		PushCoordBlocks(a_BlockX, hei, a_BlockZ, a_OtherBlocks, BigO4, ARRAYCOUNT(BigO4), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);
+		PushCornerBlocks(a_BlockX, hei, a_BlockZ, a_Seq, a_Noise, 0x5fffffff, a_OtherBlocks, 3, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);
+		hei++;
+	}  // for i < 2
+
+	// The top leaves layer is a BigO3 with leaves in the middle and possibly corners:
+	PushCoordBlocks(a_BlockX, hei, a_BlockZ, a_OtherBlocks, BigO3, ARRAYCOUNT(BigO3), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);
+	PushCornerBlocks(a_BlockX, hei, a_BlockZ, a_Seq, a_Noise, 0x5fffffff, a_OtherBlocks, 3, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);
+	a_OtherBlocks.push_back(sSetBlock(a_BlockX, hei, a_BlockZ, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD));
 }