Readded and optimized mapgen V6

12 files changed, 1720 insertions, 204 deletions

diff --git a/games/minimal/mods/default/init.lua b/games/minimal/mods/default/init.lua
index 15cc5a0bd..fbb481a0c 100644
--- a/games/minimal/mods/default/init.lua
+++ b/games/minimal/mods/default/init.lua
@@ -1587,7 +1587,7 @@ minetest.register_alias("mapgen_stone_with_iron", "default:stone_with_iron")
 minetest.register_alias("mapgen_mese", "default:mese")
 
 minetest.register_biome_groups({
-0.35, 0.30, 0.20
+0.35, 0.10, 0.30
 })
 
 --
@@ -1619,7 +1619,7 @@ minetest.register_biome({
 	num_top_nodes = 5,
 	height_min = -3000,
 	height_max = 3000,
-	heat_min = 60.0,
+	heat_min = 5.0,
 	heat_max = 100.0,
 	humidity_min = 0.0,
 	humidity_max = 100.0,
@@ -1628,6 +1628,23 @@ minetest.register_biome({
 })
 
 minetest.register_biome({
+	group_id = 1,
+	name = "Gravel Beach",
+	terrain_type = "normal",
+	node_top = "default:gravel",
+	node_filler = "default:cobble",
+	num_top_nodes = 5,
+	height_min = -3000,
+	height_max = 3000,
+	heat_min = -50.0,
+	heat_max = 5.0,
+	humidity_min = 0.0,
+	humidity_max = 100.0,
+	scale = 5.0,
+	offset = 5.0,
+})
+
+minetest.register_biome({
 	group_id = 2,
 	name = "Land",
 	terrain_type = "normal",
@@ -1641,7 +1658,7 @@ minetest.register_biome({
 	humidity_min = 0.0,
 	humidity_max = 100.0,
 	scale = 12.0,
-	offset = 10.0,
+	offset = 20.0,
 })
 
 minetest.register_biome({
@@ -1657,8 +1674,8 @@ minetest.register_biome({
 	heat_max = 100.0,
 	humidity_min = 0.0,
 	humidity_max = 100.0,
-	scale = 70.0,
-	offset = 30.0,
+	scale = 60.0,
+	offset = 20.0,
 })
 
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 995d031e3..8d0363548 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -188,6 +188,7 @@ set(common_SRCS
 	log.cpp
 	content_sao.cpp
 	mapgen.cpp
+	mapgen_v6.cpp
 	treegen.cpp
 	content_nodemeta.cpp
 	content_mapnode.cpp
diff --git a/src/biome.cpp b/src/biome.cpp
index c66c2494c..07dad1f23 100644
--- a/src/biome.cpp
+++ b/src/biome.cpp
@@ -20,6 +20,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "biome.h"
 #include "nodedef.h"
 #include "map.h" //for ManualMapVoxelManipulator
+#include "log.h"
 #include "main.h"
 
 #define BT_NONE			0
@@ -64,15 +65,15 @@ int bg4_biomes[]  = {BT_HILLS, BT_EXTREMEHILLS, BT_MOUNTAINS, BT_DESERT, BT_DESE
 float bg5_temps[] = {5.0, 40.0};
 int bg5_biomes[]  = {BT_LAKE, BT_PLAINS, BT_DESERT};*/
 
-NoiseParams np_default = {0.0, 20.0, v3f(250., 250., 250.), 82341, 5, 0.6};
+NoiseParams np_default = {20.0, 15.0, v3f(250., 250., 250.), 82341, 5, 0.6};
 
 
 BiomeDefManager::BiomeDefManager(IGameDef *gamedef) {
 	this->m_gamedef = gamedef;
 	this->ndef      = gamedef->ndef();
 
-	bgroups.push_back(new std::vector<Biome *>); //the initial biome group
-	//addDefaultBiomes(); //can't do this in the ctor, too early
+	//the initial biome group
+	bgroups.push_back(new std::vector<Biome *>);
 }
 
 
@@ -106,20 +107,26 @@ void BiomeDefManager::addBiomeGroup(float freq) {
 		newfreq += bgroup_freqs[size - 1];
 	bgroup_freqs.push_back(newfreq);
 	bgroups.push_back(new std::vector<Biome *>);
-	printf("added biome with freq %f\n", newfreq);
+
+	verbosestream << "BiomeDefManager: added biome group with frequency " <<
+		newfreq << std::endl;
 }
 
 
-void BiomeDefManager::addBiome(int groupid, Biome *b) {
+void BiomeDefManager::addBiome(Biome *b) {
 	std::vector<Biome *> *bgroup;
 
-	if (groupid >= bgroups.size()) {
-		printf("blahblahblah");
+	if (b->groupid >= bgroups.size()) {
+		errorstream << "BiomeDefManager: attempted to add biome '" << b->name
+		 << "' to nonexistent biome group " << b->groupid << std::endl;
 		return;
 	}
 
-	bgroup = bgroups[groupid];
+	bgroup = bgroups[b->groupid];
 	bgroup->push_back(b);
+
+	verbosestream << "BiomeDefManager: added biome '" << b->name <<
+		"' to biome group " << b->groupid << std::endl;
 }
 
 
@@ -156,7 +163,7 @@ Biome *BiomeDefManager::getBiome(float bgfreq, float heat, float humidity) {
 
 	int nbiomes = bgroup->size();
 	for (i = 0; i != nbiomes; i++) {
-		b = bgroup->operator[](i);///////////////////////////
+		b = bgroup->operator[](i);
 		if (heat >= b->heat_min && heat <= b->heat_max &&
 			humidity >= b->humidity_min && humidity <= b->humidity_max)
 			return b;
@@ -174,9 +181,24 @@ int Biome::getSurfaceHeight(float noise_terrain) {
 }
 
 
-void Biome::genColumn(Mapgen *mg, int x, int z, int y1, int y2) {
+void Biome::genColumn(MapgenV7 *mg, int x, int z, int y1, int y2) {
 	int i = (z - mg->node_min.Z) * mg->csize.Z + (x - mg->node_min.X);
 	int surfaceh = np->offset + np->scale * mg->map_terrain[i];
+
+	/*///experimental
+	if (groupid > 0) {
+		float prevfreq = mg->biomedef->bgroup_freqs[groupid - 1];
+		float range    = mg->biomedef->bgroup_freqs[groupid] - prevfreq;
+		float factor   = (mg->map_bgroup[i] - prevfreq) / range;
+
+		std::vector<Biome *> *bg = mg->biomedef->bgroups[groupid - 1];
+		Biome *b = (*bg)[0];
+		int h1 = b->np->offset + b->np->scale * mg->map_terrain[i];
+		surfaceh += (int)round((surfaceh - h1) * factor);
+		//printf("h1: %d, surfaceh: %d, factor %f\n", h1, surfaceh, factor);
+	}*/
+
+
 	int y = y1;
 
 	i = mg->vmanip->m_area.index(x, y, z);
@@ -189,12 +211,10 @@ void Biome::genColumn(Mapgen *mg, int x, int z, int y1, int y2) {
 }
 
 
-
 ///////////////////////////// [ Ocean biome ] /////////////////////////////////
 
 
-
-void BiomeLiquid::genColumn(Mapgen *mg, int x, int z, int y1, int y2) {
+void BiomeLiquid::genColumn(MapgenV7 *mg, int x, int z, int y1, int y2) {
 	int i = (z - mg->node_min.Z) * mg->csize.Z + (x - mg->node_min.X);
 	int surfaceh = np->offset + np->scale * mg->map_terrain[i];
 	int y = y1;
@@ -219,7 +239,7 @@ int BiomeHell::getSurfaceHeight(float noise_terrain) {
 }
 
 
-void BiomeHell::genColumn(Mapgen *mg, int x, int z, int y1, int y2) {
+void BiomeHell::genColumn(MapgenV7 *mg, int x, int z, int y1, int y2) {
 
 }
 
@@ -232,7 +252,7 @@ int BiomeAether::getSurfaceHeight(float noise_terrain) {
 }
 
 
-void BiomeAether::genColumn(Mapgen *mg, int x, int z, int y1, int y2) {
+void BiomeAether::genColumn(MapgenV7 *mg, int x, int z, int y1, int y2) {
 
 }
 
@@ -245,6 +265,15 @@ int BiomeSuperflat::getSurfaceHeight(float noise_terrain) {
 }
 
 
-void BiomeSuperflat::genColumn(Mapgen *mg, int x, int z, int y1, int y2) {
+void BiomeSuperflat::genColumn(MapgenV7 *mg, int x, int z, int y1, int y2) {
+	int surfaceh = ntopnodes;
+	int y = y1;
 
+	int i = mg->vmanip->m_area.index(x, y, z);
+	for (; y <= surfaceh - ntopnodes && y <= y2; y++, i += mg->ystride)
+		mg->vmanip->m_data[i] = n_filler;
+	for (; y <= surfaceh && y <= y2; y++, i += mg->ystride)
+		mg->vmanip->m_data[i] = n_top;
+	for (; y <= y2; y++, i += mg->ystride)
+		mg->vmanip->m_data[i] = mg->n_air;
 }
diff --git a/src/biome.h b/src/biome.h
index bb35dd1c4..3bf7a5d34 100644
--- a/src/biome.h
+++ b/src/biome.h
@@ -42,7 +42,8 @@ public:
 	MapNode n_top;
 	MapNode n_filler;
 	s16 ntopnodes;
-	s16 flags;
+	s8 groupid;
+	s8 flags;
 	s16 height_min;
 	s16 height_max;
 	float heat_min;
@@ -52,26 +53,26 @@ public:
 	std::string name;
 	NoiseParams *np;
 
-	virtual void genColumn(Mapgen *mg, int x, int z, int y1, int y2);
+	virtual void genColumn(MapgenV7 *mg, int x, int z, int y1, int y2);
 	virtual int getSurfaceHeight(float noise_terrain);
 };
 
 class BiomeLiquid : public Biome {
-	virtual void genColumn(Mapgen *mg, int x, int z, int y1, int y2);
+	virtual void genColumn(MapgenV7 *mg, int x, int z, int y1, int y2);
 };
 
 class BiomeHell : public Biome {
-	virtual void genColumn(Mapgen *mg, int x, int z, int y1, int y2);
+	virtual void genColumn(MapgenV7 *mg, int x, int z, int y1, int y2);
 	virtual int getSurfaceHeight(float noise_terrain);
 };
 
 class BiomeAether : public Biome {
-	virtual void genColumn(Mapgen *mg, int x, int z, int y1, int y2);
+	virtual void genColumn(MapgenV7 *mg, int x, int z, int y1, int y2);
 	virtual int getSurfaceHeight(float noise_terrain);
 };
 
 class BiomeSuperflat : public Biome {
-	virtual void genColumn(Mapgen *mg, int x, int z, int y1, int y2);
+	virtual void genColumn(MapgenV7 *mg, int x, int z, int y1, int y2);
 	virtual int getSurfaceHeight(float noise_terrain);
 };
 
@@ -90,7 +91,7 @@ public:
 	Biome *getBiome(float bgfreq, float heat, float humidity);
 
 	void addBiomeGroup(float freq);
-	void addBiome(int groupid, Biome *b);
+	void addBiome(Biome *b);
 	void addDefaultBiomes();
 };
 
diff --git a/src/defaultsettings.cpp b/src/defaultsettings.cpp
index 38b9accd1..1ccaf887d 100644
--- a/src/defaultsettings.cpp
+++ b/src/defaultsettings.cpp
@@ -153,6 +153,7 @@ void set_default_settings(Settings *settings)
 
 	settings->setDefault("profiler_print_interval", "0");
 	settings->setDefault("enable_mapgen_debug_info", "false");
+	settings->setDefault("use_mapgen_version", "6");
 	settings->setDefault("active_object_send_range_blocks", "3");
 	settings->setDefault("active_block_range", "2");
 	//settings->setDefault("max_simultaneous_block_sends_per_client", "1");
@@ -169,6 +170,7 @@ void set_default_settings(Settings *settings)
 	settings->setDefault("full_block_send_enable_min_time_from_building", "2.0");
 	settings->setDefault("dedicated_server_step", "0.1");
 	settings->setDefault("ignore_world_load_errors", "false");
+	settings->setDefault("mgv6_use_smooth_biome_trans", "true"); //temporary
 	settings->setDefault("congestion_control_aim_rtt", "0.2");
 	settings->setDefault("congestion_control_max_rate", "400");
 	settings->setDefault("congestion_control_min_rate", "10");
diff --git a/src/map.cpp b/src/map.cpp
index 0896c9b4f..3f18ef2e0 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -39,13 +39,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 /*
 	SQLite format specification:
 	- Initially only replaces sectors/ and sectors2/
-	
+
 	If map.sqlite does not exist in the save dir
 	or the block was not found in the database
 	the map will try to load from sectors folder.
 	In either case, map.sqlite will be created
 	and all future saves will save there.
-	
+
 	Structure of map.sqlite:
 	Tables:
 		blocks
@@ -108,14 +108,14 @@ MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p)
 		MapSector * sector = m_sector_cache;
 		return sector;
 	}
-	
+
 	core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
-	
+
 	if(n == NULL)
 		return NULL;
-	
+
 	MapSector *sector = n->getValue();
-	
+
 	// Cache the last result
 	m_sector_cache_p = p;
 	m_sector_cache = sector;
@@ -133,7 +133,7 @@ MapSector * Map::getSectorNoGenerate(v2s16 p)
 	MapSector *sector = getSectorNoGenerateNoEx(p);
 	if(sector == NULL)
 		throw InvalidPositionException();
-	
+
 	return sector;
 }
 
@@ -148,7 +148,7 @@ MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d)
 }
 
 MapBlock * Map::getBlockNoCreate(v3s16 p3d)
-{	
+{
 	MapBlock *block = getBlockNoCreateNoEx(p3d);
 	if(block == NULL)
 		throw InvalidPositionException();
@@ -248,10 +248,10 @@ void Map::unspreadLight(enum LightBank bank,
 		v3s16(0,-1,0), // bottom
 		v3s16(-1,0,0), // left
 	};
-	
+
 	if(from_nodes.size() == 0)
 		return;
-	
+
 	u32 blockchangecount = 0;
 
 	core::map<v3s16, u8> unlighted_nodes;
@@ -265,12 +265,12 @@ void Map::unspreadLight(enum LightBank bank,
 	MapBlock *block = NULL;
 	// Cache this a bit, too
 	bool block_checked_in_modified = false;
-	
+
 	for(; j.atEnd() == false; j++)
 	{
 		v3s16 pos = j.getNode()->getKey();
 		v3s16 blockpos = getNodeBlockPos(pos);
-		
+
 		// Only fetch a new block if the block position has changed
 		try{
 			if(block == NULL || blockpos != blockpos_last){
@@ -693,7 +693,7 @@ void Map::updateLighting(enum LightBank bank,
 	core::map<v3s16, u8> unlight_from;
 
 	int num_bottom_invalid = 0;
-	
+
 	{
 	//TimeTaker t("first stuff");
 
@@ -847,7 +847,7 @@ void Map::updateLighting(enum LightBank bank,
 #if 0
 	{
 		//MapVoxelManipulator vmanip(this);
-		
+
 		// Make a manual voxel manipulator and load all the blocks
 		// that touch the requested blocks
 		ManualMapVoxelManipulator vmanip(this);
@@ -938,7 +938,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 	/*PrintInfo(m_dout);
 	m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
 			<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
-	
+
 	/*
 		From this node to nodes underneath:
 		If lighting is sunlight (1.0), unlight neighbours and
@@ -951,7 +951,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 
 	bool node_under_sunlight = true;
 	core::map<v3s16, bool> light_sources;
-	
+
 	/*
 		Collect old node for rollback
 	*/
@@ -1440,10 +1440,10 @@ void Map::timerUpdate(float dtime, float unload_timeout,
 		core::list<v3s16> *unloaded_blocks)
 {
 	bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
-	
+
 	// Profile modified reasons
 	Profiler modprofiler;
-	
+
 	core::list<v2s16> sector_deletion_queue;
 	u32 deleted_blocks_count = 0;
 	u32 saved_blocks_count = 0;
@@ -1461,12 +1461,12 @@ void Map::timerUpdate(float dtime, float unload_timeout,
 
 		core::list<MapBlock*> blocks;
 		sector->getBlocks(blocks);
-		
+
 		for(core::list<MapBlock*>::Iterator i = blocks.begin();
 				i != blocks.end(); i++)
 		{
 			MapBlock *block = (*i);
-			
+
 			block->incrementUsageTimer(dtime);
 
 			if(block->refGet() == 0 && block->getUsageTimer() > unload_timeout)
@@ -1503,10 +1503,10 @@ void Map::timerUpdate(float dtime, float unload_timeout,
 		}
 	}
 	endSave();
-	
+
 	// Finally delete the empty sectors
 	deleteSectors(sector_deletion_queue);
-	
+
 	if(deleted_blocks_count != 0)
 	{
 		PrintInfo(infostream); // ServerMap/ClientMap:
@@ -1560,7 +1560,7 @@ void Map::unloadUnusedData(float timeout,
 				i != blocks.end(); i++)
 		{
 			MapBlock *block = (*i);
-			
+
 			if(block->getUsageTimer() > timeout)
 			{
 				// Save if modified
@@ -1629,7 +1629,7 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 
 	// list of nodes that due to viscosity have not reached their max level height
 	UniqueQueue<v3s16> must_reflow;
-	
+
 	// List of MapBlocks that will require a lighting update (due to lava)
 	core::map<v3s16, MapBlock*> lighting_modified_blocks;
 
@@ -1714,7 +1714,7 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 					}
 					break;
 				case LIQUID_SOURCE:
-					// if this node is not (yet) of a liquid type, choose the first liquid type we encounter 
+					// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
 					if (liquid_kind == CONTENT_AIR)
 						liquid_kind = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing);
 					if (nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing) != liquid_kind) {
@@ -1824,7 +1824,7 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 			n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
 		}
 		n0.setContent(new_node_content);
-		
+
 		// Find out whether there is a suspect for this action
 		std::string suspect;
 		if(m_gamedef->rollback()){
@@ -2021,7 +2021,9 @@ ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emer
 	}
 	emerge->seed = m_seed;
 	emerge->water_level = g_settings->getS16("default_water_level");
-	//<set noiseparams here>
+	//mapgen version
+	//chunksize
+	//noiseparams
 
 	/*
 		Experimental and debug stuff
@@ -2149,7 +2151,7 @@ void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 				<<"("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<") - "
 				<<"("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
 				<<std::endl;
-	
+
 	//s16 chunksize = 3;
 	//v3s16 chunk_offset(-1,-1,-1);
 	//s16 chunksize = 4;
@@ -2172,7 +2174,7 @@ void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 		data->no_op = true;
 		return;
 	}
-	
+
 	data->no_op = false;
 	data->seed = m_seed;
 	data->blockpos_min = blockpos_min;
@@ -2185,7 +2187,7 @@ void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 	*/
 	{
 		//TimeTaker timer("initBlockMake() create area");
-		
+
 		for(s16 x=blockpos_min.X-extra_borders.X;
 				x<=blockpos_max.X+extra_borders.X; x++)
 		for(s16 z=blockpos_min.Z-extra_borders.Z;
@@ -2224,18 +2226,18 @@ void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 			}
 		}
 	}
-	
+
 	/*
 		Now we have a big empty area.
 
 		Make a ManualMapVoxelManipulator that contains this and the
 		neighboring blocks
 	*/
-	
+
 	// The area that contains this block and it's neighbors
 	v3s16 bigarea_blocks_min = blockpos_min - extra_borders;
 	v3s16 bigarea_blocks_max = blockpos_max + extra_borders;
-	
+
 	data->vmanip = new ManualMapVoxelManipulator(this);
 	//data->vmanip->setMap(this);
 
@@ -2319,7 +2321,7 @@ MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
 		TimeTaker t("finishBlockMake lighting update");
 
 		core::map<v3s16, MapBlock*> lighting_update_blocks;
-		
+
 		// Center blocks
 		for(s16 x=blockpos_min.X-extra_borders.X;
 				x<=blockpos_max.X+extra_borders.X; x++)
@@ -2336,7 +2338,7 @@ MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
 
 		updateLighting(lighting_update_blocks, changed_blocks);
 #endif
-		
+
 		/*
 			Set lighting to non-expired state in all of them.
 			This is cheating, but it is not fast enough if all of them
@@ -2390,7 +2392,7 @@ MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
 		assert(block);
 		block->setGenerated(true);
 	}
-	
+
 	/*
 		Save changed parts of map
 		NOTE: Will be saved later.
@@ -2434,14 +2436,14 @@ ServerMapSector * ServerMap::createSector(v2s16 p2d)
 	DSTACKF("%s: p2d=(%d,%d)",
 			__FUNCTION_NAME,
 			p2d.X, p2d.Y);
-	
+
 	/*
 		Check if it exists already in memory
 	*/
 	ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
 	if(sector != NULL)
 		return sector;
-	
+
 	/*
 		Try to load it from disk (with blocks)
 	*/
@@ -2474,9 +2476,9 @@ ServerMapSector * ServerMap::createSector(v2s16 p2d)
 	/*
 		Generate blank sector
 	*/
-	
+
 	sector = new ServerMapSector(this, p2d, m_gamedef);
-	
+
 	// Sector position on map in nodes
 	v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
 
@@ -2484,7 +2486,7 @@ ServerMapSector * ServerMap::createSector(v2s16 p2d)
 		Insert to container
 	*/
 	m_sectors.insert(p2d, sector);
-	
+
 	return sector;
 }
 
@@ -2498,20 +2500,20 @@ MapBlock * ServerMap::generateBlock(
 )
 {
 	DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
-	
+
 	/*infostream<<"generateBlock(): "
 			<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 			<<std::endl;*/
-	
+
 	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 
 	TimeTaker timer("generateBlock");
-	
+
 	//MapBlock *block = original_dummy;
-			
+
 	v2s16 p2d(p.X, p.Z);
 	v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
-	
+
 	/*
 		Do not generate over-limit
 	*/
@@ -2608,7 +2610,7 @@ MapBlock * ServerMap::createBlock(v3s16 p)
 {
 	DSTACKF("%s: p=(%d,%d,%d)",
 			__FUNCTION_NAME, p.X, p.Y, p.Z);
-	
+
 	/*
 		Do not create over-limit
 	*/
@@ -2619,7 +2621,7 @@ MapBlock * ServerMap::createBlock(v3s16 p)
 	|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 	|| p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
 		throw InvalidPositionException("createBlock(): pos. over limit");
-	
+
 	v2s16 p2d(p.X, p.Z);
 	s16 block_y = p.Y;
 	/*
@@ -2673,7 +2675,7 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
 	DSTACKF("%s: p=(%d,%d,%d), create_blank=%d",
 			__FUNCTION_NAME,
 			p.X, p.Y, p.Z, create_blank);
-	
+
 	{
 		MapBlock *block = getBlockNoCreateNoEx(p);
 		if(block && block->isDummy() == false)
@@ -2712,7 +2714,7 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
 
 			// Queue event
 			dispatchEvent(&event);
-								
+
 			return block;
 		}
 	}*/
@@ -2756,7 +2758,7 @@ plan_b:
 	/*
 		Determine from map generator noise functions
 	*/
-	
+
 	s16 level = m_emerge->getGroundLevelAtPoint(p2d);
 	return level;
 
@@ -2782,48 +2784,48 @@ void ServerMap::createDatabase() {
 void ServerMap::verifyDatabase() {
 	if(m_database)
 		return;
-	
+
 	{
 		std::string dbp = m_savedir + DIR_DELIM + "map.sqlite";
 		bool needs_create = false;
 		int d;
-		
+
 		/*
 			Open the database connection
 		*/
-	
+
 		createDirs(m_savedir);
-	
+
 		if(!fs::PathExists(dbp))
 			needs_create = true;
-	
+
 		d = sqlite3_open_v2(dbp.c_str(), &m_database, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 		if(d != SQLITE_OK) {
 			infostream<<"WARNING: Database failed to open: "<<sqlite3_errmsg(m_database)<<std::endl;
 			throw FileNotGoodException("Cannot open database file");
 		}
-		
+
 		if(needs_create)
 			createDatabase();
-	
+
 		d = sqlite3_prepare(m_database, "SELECT `data` FROM `blocks` WHERE `pos`=? LIMIT 1", -1, &m_database_read, NULL);
 		if(d != SQLITE_OK) {
 			infostream<<"WARNING: Database read statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
 			throw FileNotGoodException("Cannot prepare read statement");
 		}
-		
+
 		d = sqlite3_prepare(m_database, "REPLACE INTO `blocks` VALUES(?, ?)", -1, &m_database_write, NULL);
 		if(d != SQLITE_OK) {
 			infostream<<"WARNING: Database write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
 			throw FileNotGoodException("Cannot prepare write statement");
 		}
-		
+
 		d = sqlite3_prepare(m_database, "SELECT `pos` FROM `blocks`", -1, &m_database_list, NULL);
 		if(d != SQLITE_OK) {
 			infostream<<"WARNING: Database list statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
 			throw FileNotGoodException("Cannot prepare read statement");
 		}
-		
+
 		infostream<<"ServerMap: Database opened"<<std::endl;
 	}
 }
@@ -2928,11 +2930,11 @@ void ServerMap::save(ModifiedState save_level)
 		infostream<<"WARNING: Not saving map, saving disabled."<<std::endl;
 		return;
 	}
-	
+
 	if(save_level == MOD_STATE_CLEAN)
 		infostream<<"ServerMap: Saving whole map, this can take time."
 				<<std::endl;
-	
+
 	if(m_map_metadata_changed || save_level == MOD_STATE_CLEAN)
 	{
 		saveMapMeta();
@@ -2940,11 +2942,11 @@ void ServerMap::save(ModifiedState save_level)
 
 	// Profile modified reasons
 	Profiler modprofiler;
-	
+
 	u32 sector_meta_count = 0;
 	u32 block_count = 0;
 	u32 block_count_all = 0; // Number of blocks in memory
-	
+
 	// Don't do anything with sqlite unless something is really saved
 	bool save_started = false;
 
@@ -2953,7 +2955,7 @@ void ServerMap::save(ModifiedState save_level)
 	{
 		ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
 		assert(sector->getId() == MAPSECTOR_SERVER);
-	
+
 		if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN)
 		{
 			saveSectorMeta(sector);
@@ -2962,11 +2964,11 @@ void ServerMap::save(ModifiedState save_level)
 		core::list<MapBlock*> blocks;
 		sector->getBlocks(blocks);
 		core::list<MapBlock*>::Iterator j;
-		
+
 		for(j=blocks.begin(); j!=blocks.end(); j++)
 		{
 			MapBlock *block = *j;
-			
+
 			block_count_all++;
 
 			if(block->getModified() >= save_level)
@@ -3042,10 +3044,10 @@ void ServerMap::listAllLoadableBlocks(core::list<v3s16> &dst)
 		errorstream<<"Map::listAllLoadableBlocks(): Result will be missing "
 				<<"all blocks that are stored in flat files"<<std::endl;
 	}
-	
+
 	{
 		verifyDatabase();
-		
+
 		while(sqlite3_step(m_database_list) == SQLITE_ROW)
 		{
 			sqlite3_int64 block_i = sqlite3_column_int64(m_database_list, 0);
@@ -3059,13 +3061,13 @@ void ServerMap::listAllLoadableBlocks(core::list<v3s16> &dst)
 void ServerMap::saveMapMeta()
 {
 	DSTACK(__FUNCTION_NAME);
-	
+
 	/*infostream<<"ServerMap::saveMapMeta(): "
 			<<"seed="<<m_seed
 			<<std::endl;*/
 
 	createDirs(m_savedir);
-	
+
 	std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
 	std::ofstream os(fullpath.c_str(), std::ios_base::binary);
 	if(os.good() == false)
@@ -3074,7 +3076,7 @@ void ServerMap::saveMapMeta()
 				<<"could not open"<<fullpath<<std::endl;
 		throw FileNotGoodException("Cannot open chunk metadata");
 	}
-	
+
 	Settings params;
 	params.setU64("seed", m_seed);
 	params.setS16("water_level", m_emerge->water_level);
@@ -3082,14 +3084,14 @@ void ServerMap::saveMapMeta()
 	params.writeLines(os);
 
 	os<<"[end_of_params]\n";
-	
+
 	m_map_metadata_changed = false;
 }
 
 void ServerMap::loadMapMeta()
 {
 	DSTACK(__FUNCTION_NAME);
-	
+
 	/*infostream<<"ServerMap::loadMapMeta(): Loading map metadata"
 			<<std::endl;*/
 
@@ -3116,7 +3118,7 @@ void ServerMap::loadMapMeta()
 			break;
 		params.parseConfigLine(line);
 	}
-	
+
 	m_seed = params.getU64("seed");
 	m_emerge->seed        = m_seed;
 	m_emerge->water_level = params.getS16("water_level");
@@ -3134,14 +3136,14 @@ void ServerMap::saveSectorMeta(ServerMapSector *sector)
 	v2s16 pos = sector->getPos();
 	std::string dir = getSectorDir(pos);
 	createDirs(dir);
-	
+
 	std::string fullpath = dir + DIR_DELIM + "meta";
 	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
 	if(o.good() == false)
 		throw FileNotGoodException("Cannot open sector metafile");
 
 	sector->serialize(o, version);
-	
+
 	sector->differs_from_disk = false;
 }
 
@@ -3180,7 +3182,7 @@ MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load
 		if(save_after_load)
 			saveSectorMeta(sector);
 	}
-	
+
 	sector->differs_from_disk = false;
 
 	return sector;
@@ -3225,7 +3227,7 @@ bool ServerMap::loadSectorMeta(v2s16 p2d)
 	{
 		return false;
 	}
-	
+
 	return true;
 }
 
@@ -3269,7 +3271,7 @@ bool ServerMap::loadSectorFull(v2s16 p2d)
 	{
 		return false;
 	}
-	
+
 	/*
 		Load blocks
 	*/
@@ -3331,8 +3333,8 @@ void ServerMap::saveBlock(MapBlock *block)
 	u8 version = SER_FMT_VER_HIGHEST;
 	// Get destination
 	v3s16 p3d = block->getPos();
-	
-	
+
+
 #if 0
 	v2s16 p2d(p3d.X, p3d.Z);
 	std::string sectordir = getSectorDir(p2d);
@@ -3348,21 +3350,21 @@ void ServerMap::saveBlock(MapBlock *block)
 		[0] u8 serialization version
 		[1] data
 	*/
-	
+
 	verifyDatabase();
-	
+
 	std::ostringstream o(std::ios_base::binary);
-	
+
 	o.write((char*)&version, 1);
-	
+
 	// Write basic data
 	block->serialize(o, version, true);
-	
+
 	// Write block to database
-	
+
 	std::string tmp = o.str();
 	const char *bytes = tmp.c_str();
-	
+
 	bool success = true;
 	if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK) {
 		infostream<<"WARNING: Block position failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
@@ -3380,7 +3382,7 @@ void ServerMap::saveBlock(MapBlock *block)
 	}
 	// Make ready for later reuse
 	sqlite3_reset(m_database_write);
-	
+
 	// We just wrote it to the disk so clear modified flag
 	if (success)
 		block->resetModified();
@@ -3396,12 +3398,12 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 		std::ifstream is(fullpath.c_str(), std::ios_base::binary);
 		if(is.good() == false)
 			throw FileNotGoodException("Cannot open block file");
-		
+
 		v3s16 p3d = getBlockPos(sectordir, blockfile);
 		v2s16 p2d(p3d.X, p3d.Z);
-		
+
 		assert(sector->getPos() == p2d);
-		
+
 		u8 version = SER_FMT_VER_INVALID;
 		is.read((char*)&version, 1);
 
@@ -3424,14 +3426,14 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 			block = sector->createBlankBlockNoInsert(p3d.Y);
 			created_new = true;
 		}
-		
+
 		// Read basic data
 		block->deSerialize(is, version, true);
 
 		// If it's a new block, insert it to the map
 		if(created_new)
 			sector->insertBlock(block);
-		
+
 		/*
 			Save blocks loaded in old format in new format
 		*/
@@ -3439,11 +3441,11 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 		if(version < SER_FMT_VER_HIGHEST || save_after_load)
 		{
 			saveBlock(block);
-			
+
 			// Should be in database now, so delete the old file
 			fs::RecursiveDelete(fullpath);
 		}
-		
+
 		// We just loaded it from the disk, so it's up-to-date.
 		block->resetModified();
 
@@ -3468,7 +3470,7 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool
 
 	try {
 		std::istringstream is(*blob, std::ios_base::binary);
-		
+
 		u8 version = SER_FMT_VER_INVALID;
 		is.read((char*)&version, 1);
 
@@ -3491,14 +3493,14 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool
 			block = sector->createBlankBlockNoInsert(p3d.Y);
 			created_new = true;
 		}
-		
+
 		// Read basic data
 		block->deSerialize(is, version, true);
-		
+
 		// If it's a new block, insert it to the map
 		if(created_new)
 			sector->insertBlock(block);
-		
+
 		/*
 			Save blocks loaded in old format in new format
 		*/
@@ -3507,7 +3509,7 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool
 		// Only save if asked to; no need to update version
 		if(save_after_load)
 			saveBlock(block);
-		
+
 		// We just loaded it from, so it's up-to-date.
 		block->resetModified();
 
@@ -3517,7 +3519,7 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool
 		errorstream<<"Invalid block data in database"
 				<<" ("<<p3d.X<<","<<p3d.Y<<","<<p3d.Z<<")"
 				<<" (SerializationError): "<<e.what()<<std::endl;
-		
+
 		// TODO: Block should be marked as invalid in memory so that it is
 		// not touched but the game can run
 
@@ -3539,7 +3541,7 @@ MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 
 	if(!loadFromFolders()) {
 		verifyDatabase();
-		
+
 		if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK)
 			infostream<<"WARNING: Could not bind block position for load: "
 				<<sqlite3_errmsg(m_database)<<std::endl;
@@ -3548,15 +3550,15 @@ MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 				Make sure sector is loaded
 			*/
 			MapSector *sector = createSector(p2d);
-			
+
 			/*
 				Load block
 			*/
 			const char * data = (const char *)sqlite3_column_blob(m_database_read, 0);
 			size_t len = sqlite3_column_bytes(m_database_read, 0);
-			
+
 			std::string datastr(data, len);
-			
+
 			loadBlock(&datastr, blockpos, sector, false);
 
 			sqlite3_step(m_database_read);
@@ -3566,7 +3568,7 @@ MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 			return getBlockNoCreateNoEx(blockpos);
 		}
 		sqlite3_reset(m_database_read);
-		
+
 		// Not found in database, try the files
 	}
 
@@ -3587,7 +3589,7 @@ MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 		loadlayout = 2;
 		sectordir = getSectorDir(p2d, 2);
 	}
-	
+
 	/*
 		Make sure sector is loaded
 	*/
@@ -3610,7 +3612,7 @@ MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 			return NULL;
 		}
 	}
-	
+
 	/*
 		Make sure file exists
 	*/
@@ -3668,7 +3670,7 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 		n = m_loaded_blocks.find(p);
 		if(n != NULL)
 			continue;
-		
+
 		bool block_data_inexistent = false;
 		try
 		{
@@ -3679,7 +3681,7 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 					<<" wanted area: ";
 			a.print(infostream);
 			infostream<<std::endl;*/
-			
+
 			MapBlock *block = m_map->getBlockNoCreate(p);
 			if(block->isDummy())
 				block_data_inexistent = true;
@@ -3719,12 +3721,12 @@ void MapVoxelManipulator::blitBack
 {
 	if(m_area.getExtent() == v3s16(0,0,0))
 		return;
-	
+
 	//TimeTaker timer1("blitBack");
 
 	/*infostream<<"blitBack(): m_loaded_blocks.size()="
 			<<m_loaded_blocks.size()<<std::endl;*/
-	
+
 	/*
 		Initialize block cache
 	*/
@@ -3743,9 +3745,9 @@ void MapVoxelManipulator::blitBack
 			continue;
 
 		MapNode &n = m_data[m_area.index(p)];
-			
+
 		v3s16 blockpos = getNodeBlockPos(p);
-		
+
 		try
 		{
 			// Get block
@@ -3754,7 +3756,7 @@ void MapVoxelManipulator::blitBack
 				blockpos_last = blockpos;
 				block_checked_in_modified = false;
 			}
-			
+
 			// Calculate relative position in block
 			v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
 
@@ -3764,7 +3766,7 @@ void MapVoxelManipulator::blitBack
 
 			//m_map->setNode(m_area.MinEdge + p, n);
 			block->setNode(relpos, n);
-			
+
 			/*
 				Make sure block is in modified_blocks
 			*/
@@ -3807,7 +3809,7 @@ void ManualMapVoxelManipulator::initialEmerge(
 
 	VoxelArea block_area_nodes
 			(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
-	
+
 	u32 size_MB = block_area_nodes.getVolume()*4/1000000;
 	if(size_MB >= 1)
 	{
@@ -3828,7 +3830,7 @@ void ManualMapVoxelManipulator::initialEmerge(
 		n = m_loaded_blocks.find(p);
 		if(n != NULL)
 			continue;
-		
+
 		bool block_data_inexistent = false;
 		try
 		{
@@ -3869,7 +3871,7 @@ void ManualMapVoxelManipulator::blitBackAll(
 {
 	if(m_area.getExtent() == v3s16(0,0,0))
 		return;
-	
+
 	/*
 		Copy data of all blocks
 	*/
diff --git a/src/mapgen.cpp b/src/mapgen.cpp
index f9c27ac1e..a141fc165 100644
--- a/src/mapgen.cpp
+++ b/src/mapgen.cpp
@@ -52,21 +52,21 @@ Mapgen::Mapgen(BiomeDefManager *biomedef) {
 }*/
 
 
-Mapgen::Mapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed) {
-	initMapgen(biomedef, mapgenid, seed,
+MapgenV7::MapgenV7(BiomeDefManager *biomedef, int mapgenid, u64 seed) {
+	init(biomedef, mapgenid, seed,
 		&nparams_mtdefault, &nparams_def_bgroup,
 		&nparams_def_heat,  &nparams_def_humidity);
 }
 
 
-Mapgen::Mapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed,
+MapgenV7::MapgenV7(BiomeDefManager *biomedef, int mapgenid, u64 seed,
 			   NoiseParams *np_terrain, NoiseParams *np_bgroup,
 			   NoiseParams *np_heat,    NoiseParams *np_humidity) {
-	initMapgen(biomedef, mapgenid, seed,
+	init(biomedef, mapgenid, seed,
 		np_terrain, np_bgroup, np_heat, np_humidity);
 }
 
-void Mapgen::initMapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed,
+void MapgenV7::init(BiomeDefManager *biomedef, int mapgenid, u64 seed,
 			   NoiseParams *np_terrain, NoiseParams *np_bgroup,
 			   NoiseParams *np_heat,    NoiseParams *np_humidity) {
 	this->generating  = false;
@@ -75,6 +75,7 @@ void Mapgen::initMapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed,
 	this->biomedef = biomedef;
 	this->csize       = v3s16(5, 5, 5) * MAP_BLOCKSIZE; /////////////////get this from config!
 	this->water_level = g_settings->getS16("default_water_level"); ////fix this!
+	this->ystride = csize.X;
 
 	this->np_terrain  = np_terrain;
 	this->np_bgroup   = np_bgroup;
@@ -92,7 +93,7 @@ void Mapgen::initMapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed,
 }
 
 
-Mapgen::~Mapgen() {
+MapgenV7::~MapgenV7() {
 	delete noise_terrain;
 	delete noise_bgroup;
 	delete noise_heat;
@@ -100,12 +101,10 @@ Mapgen::~Mapgen() {
 }
 
 
-void Mapgen::makeChunk(BlockMakeData *data) {
+void MapgenV7::makeChunk(BlockMakeData *data) {
 	if (data->no_op)
 		return;
 
-	//printf("generating...\n");//////////////
-
 	assert(data->vmanip);
 	assert(data->nodedef);
 	assert(data->blockpos_requested.X >= data->blockpos_min.X &&
@@ -123,6 +122,9 @@ void Mapgen::makeChunk(BlockMakeData *data) {
 	this->ystride = em.X;
 	this->zstride = em.Y * em.X;
 
+	if (node_max.X - node_min.X != 80)
+		printf("uhoh, diff = %d, ystride = %d\n", node_max.X - node_min.X, ystride);
+
 	node_min = (data->blockpos_min) * MAP_BLOCKSIZE;
 	node_max = (data->blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
 	v3s16 full_node_min = (data->blockpos_min - 1) * MAP_BLOCKSIZE;
@@ -132,7 +134,7 @@ void Mapgen::makeChunk(BlockMakeData *data) {
 	int y2 = node_max.Y;
 	int x  = node_min.X;
 	int z  = node_min.Z;
-	//printf("full_node_min.X: %d  |  full_node_min.Z:  %d   |  MinEdge:  %d   |  MaxEdge:  %d\n", node_min.X, node_min.Z, vmanip->m_area.MinEdge.X, vmanip->m_area.MinEdge.Z);
+
 	TimeTaker timer("Generating terrain");
 	map_terrain  = noise_terrain->perlinMap2D(x, z);
 	map_bgroup   = noise_bgroup->perlinMap2D(x, z);
@@ -161,11 +163,10 @@ void Mapgen::makeChunk(BlockMakeData *data) {
 	updateLighting(node_min, node_max);
 
 	this->generating = false;
-	//printf("generated block (%d, %d) to (%d, %d)\n", node_min.X, node_min.Y, node_max.X, node_max.Y);//////////
 }
 
 
-void Mapgen::updateLiquid(v3s16 node_min, v3s16 node_max) {
+void MapgenV7::updateLiquid(v3s16 node_min, v3s16 node_max) {
 	bool isliquid, wasliquid;
 	u32 i;
 
@@ -190,7 +191,7 @@ void Mapgen::updateLiquid(v3s16 node_min, v3s16 node_max) {
 }
 
 
-void Mapgen::updateLighting(v3s16 node_min, v3s16 node_max) {
+void MapgenV7::updateLighting(v3s16 node_min, v3s16 node_max) {
 	enum LightBank banks[2] = {LIGHTBANK_DAY, LIGHTBANK_NIGHT};
 
 	VoxelArea a(node_min - v3s16(1,0,1) * MAP_BLOCKSIZE,
@@ -207,30 +208,13 @@ void Mapgen::updateLighting(v3s16 node_min, v3s16 node_max) {
 		voxalgo::clearLightAndCollectSources(*vmanip, a, bank, ndef,
                                         light_sources, unlight_from);
 		voxalgo::propagateSunlight(*vmanip, a, sunlight, light_sources, ndef);
-        printf("light_sources: %d\t\tunlight_from: %d\n", light_sources.size(), unlight_from.size());
+        //printf("light_sources: %d\t\tunlight_from: %d\n", light_sources.size(), unlight_from.size());
 		vmanip->unspreadLight(bank, unlight_from, light_sources, ndef);
 		vmanip->spreadLight(bank, light_sources, ndef);
 	}
 }
 
 
-/*class EmergeManager {
-public:
-	int seed;
-	int water_level;
-	BiomeDefManager *biomedef;
-
-	//mapgen objects here
-
-	void addBlockToQueue();
-
-
-	//mapgen helper methods
-	int getGroundLevelAtPoint(u64 mseed, v2s16 p);
-	bool isBlockUnderground(u64 mseed, v3s16 blockpos);
-	u32 getBlockSeed(u64 mseed, v3s16 p);
-};*/
-
 EmergeManager::EmergeManager(IGameDef *gamedef) {
 	this->seed = 0;
 	this->water_level = 0;
@@ -279,7 +263,7 @@ bool EmergeManager::isBlockUnderground(v3s16 blockpos) {
 
 	//yuck, but then again, should i bother being accurate?
 	//the height of the nodes in a single block is quite variable
-	return false; //blockpos.Y * (MAP_BLOCKSIZE + 1) <= water_level;
+	return blockpos.Y * (MAP_BLOCKSIZE + 1) <= water_level;
 }
 
 
diff --git a/src/mapgen.h b/src/mapgen.h
index d6e932ca0..76ae73c52 100644
--- a/src/mapgen.h
+++ b/src/mapgen.h
@@ -32,8 +32,17 @@ class Biome;
 //struct BlockMakeData;
 class MapBlock;
 class ManualMapVoxelManipulator;
+class VoxelManipulator;
 class INodeDefManager;
 
+
+enum BiomeType
+{
+	BT_NORMAL,
+	BT_DESERT
+};
+
+
 struct BlockMakeData {
 	bool no_op;
 	ManualMapVoxelManipulator *vmanip;
@@ -48,8 +57,82 @@ struct BlockMakeData {
 	~BlockMakeData();
 };
 
+
 class Mapgen {
 public:
+
+	int seed;
+	int water_level;
+
+	bool generating;
+	int id;
+
+
+	//virtual Mapgen(BiomeDefManager *biomedef, int mapgenid=0, u64 seed=0);
+	//virtual ~Mapgen();
+	virtual void makeChunk(BlockMakeData *data) {};
+
+	//Legacy functions for Farmesh (pending removal)
+	static bool get_have_beach(u64 seed, v2s16 p2d);
+	static double tree_amount_2d(u64 seed, v2s16 p);
+	static s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);
+};
+
+
+class MapgenV6 : public Mapgen {
+public:
+	//ManualMapVoxelManipulator &vmanip;
+
+	int ystride;
+	v3s16 csize;
+
+	v3s16 node_min;
+	v3s16 node_max;
+
+	Noise *noise_terrain_base;
+	Noise *noise_terrain_higher;
+	Noise *noise_steepness;
+	Noise *noise_height_select;
+	Noise *noise_trees;
+	Noise *noise_mud;
+	Noise *noise_beach;
+	Noise *noise_biome;
+	Noise *noise_cave;
+
+	float *map_terrain_base;
+	float *map_terrain_higher;
+	float *map_steepness;
+	float *map_height_select;
+	float *map_trees;
+	float *map_mud;
+	float *map_beach;
+	float *map_biome;
+	float *map_cave;
+
+	bool use_smooth_biome_trans;
+
+	MapgenV6(int mapgenid=0, u64 seed=0);
+	~MapgenV6();
+
+	void makeChunk(BlockMakeData *data);
+
+
+	static s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d, INodeDefManager *ndef);
+	static s16 find_stone_level(VoxelManipulator &vmanip, v2s16 p2d, INodeDefManager *ndef);
+	void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0, bool is_apple_tree, INodeDefManager *ndef);
+	double tree_amount_2d(u64 seed, v2s16 p);
+	bool block_is_underground(u64 seed, v3s16 blockpos);
+	double base_rock_level_2d(u64 seed, v2s16 p);
+	s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);
+	double get_mud_add_amount(u64 seed, v2s16 p);
+	bool get_have_beach(u64 seed, v2s16 p2d);
+	BiomeType get_biome(u64 seed, v2s16 p2d);
+	u32 get_blockseed(u64 seed, v3s16 p);
+};
+
+
+class MapgenV7 : public Mapgen {
+public:
 	BlockMakeData *data;
 	ManualMapVoxelManipulator *vmanip;
 	INodeDefManager *ndef;
@@ -59,8 +142,8 @@ public:
 	int zstride;
 
 	v3s16 csize;
-	int seed;
-	int water_level;
+	//int seed;
+	//int water_level;
 
 	Noise *noise_terrain;
 	Noise *noise_bgroup;
@@ -88,23 +171,23 @@ public:
 	MapNode n_water;
 	MapNode n_lava;
 
-	Mapgen(BiomeDefManager *biomedef, int mapgenid=0, u64 seed=0);
-	Mapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed,
+	MapgenV7(BiomeDefManager *biomedef, int mapgenid=0, u64 seed=0);
+	MapgenV7(BiomeDefManager *biomedef, int mapgenid, u64 seed,
 		   NoiseParams *np_terrain, NoiseParams *np_bgroup,
 		   NoiseParams *np_heat,    NoiseParams *np_humidity);
-	void initMapgen(BiomeDefManager *biomedef, int mapgenid, u64 seed,
+	void init(BiomeDefManager *biomedef, int mapgenid, u64 seed,
 			   NoiseParams *np_terrain, NoiseParams *np_bgroup,
 			   NoiseParams *np_heat,    NoiseParams *np_humidity);
-	~Mapgen();
+	~MapgenV7();
 
 	void makeChunk(BlockMakeData *data);
 	void updateLiquid(v3s16 node_min, v3s16 node_max);
 	void updateLighting(v3s16 node_min, v3s16 node_max);
 
 	//Legacy functions for Farmesh (pending removal)
-	static bool get_have_beach(u64 seed, v2s16 p2d);
-	static double tree_amount_2d(u64 seed, v2s16 p);
-	static s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);
+//	static bool get_have_beach(u64 seed, v2s16 p2d);
+//	static double tree_amount_2d(u64 seed, v2s16 p);
+//	static s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);
 };
 
 class EmergeManager {
diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp
new file mode 100644
index 000000000..b1c2583ba
--- /dev/null
+++ b/src/mapgen_v6.cpp
@@ -0,0 +1,1391 @@
+/*
+Minetest-c55
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "mapgen.h"
+#include "voxel.h"
+#include "noise.h"
+#include "mapblock.h"
+#include "mapnode.h"
+#include "map.h"
+//#include "serverobject.h"
+#include "content_sao.h"
+#include "nodedef.h"
+#include "content_mapnode.h" // For content_mapnode_get_new_name
+#include "voxelalgorithms.h"
+#include "profiler.h"
+#include "settings.h" // For g_settings
+#include "main.h" // For g_profiler
+
+#define AVERAGE_MUD_AMOUNT 4
+
+
+NoiseParams nparams_v6_def_terrain_base =
+	{-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6};
+NoiseParams nparams_v6_def_terrain_higher =
+	{20.0, 16.0, v3f(500.0, 500.0, 500.0), 85309, 5, 0.6};
+NoiseParams nparams_v6_def_steepness =
+	{0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7};
+NoiseParams nparams_v6_def_height_select =
+	{0.5, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69};
+NoiseParams nparams_v6_def_trees =
+	{0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
+NoiseParams nparams_v6_def_mud =
+	{AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55};
+NoiseParams nparams_v6_def_beach =
+	{0.0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50};
+NoiseParams nparams_v6_def_biome =
+	{0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50};
+//NoiseParams nparams_v6_def_cave =
+//	{6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50};
+
+
+NoiseParams *np_terrain_base   = &nparams_v6_def_terrain_base;
+NoiseParams *np_terrain_higher = &nparams_v6_def_terrain_higher;
+NoiseParams *np_steepness      = &nparams_v6_def_steepness;
+NoiseParams *np_height_select  = &nparams_v6_def_height_select;
+NoiseParams *np_trees          = &nparams_v6_def_trees;
+NoiseParams *np_mud            = &nparams_v6_def_mud;
+NoiseParams *np_beach          = &nparams_v6_def_beach;
+NoiseParams *np_biome          = &nparams_v6_def_biome;
+//NoiseParams *np_cave           = &nparams_v6_def_cave;
+
+
+MapgenV6::MapgenV6(int mapgenid, u64 seed) {
+	this->generating  = false;
+	this->id       = mapgenid;
+	this->seed     = (int)seed;
+
+	this->water_level = 1;
+
+	this->csize   = v3s16(5, 5, 5) * MAP_BLOCKSIZE; /////////////////get this from config!
+	this->ystride = csize.X;
+
+	this->use_smooth_biome_trans = g_settings->getBool("mgv6_use_smooth_biome_trans");
+
+	noise_terrain_base   = new Noise(np_terrain_base,   seed, csize.X, csize.Y);
+	noise_terrain_higher = new Noise(np_terrain_higher, seed, csize.X, csize.Y);
+	noise_steepness      = new Noise(np_steepness,      seed, csize.X, csize.Y);
+	noise_height_select  = new Noise(np_height_select,  seed, csize.X, csize.Y);
+	noise_trees          = new Noise(np_trees,          seed, csize.X, csize.Y);
+	noise_mud            = new Noise(np_mud,            seed, csize.X, csize.Y);
+	noise_beach          = new Noise(np_beach,          seed, csize.X, csize.Y);
+	noise_biome          = new Noise(np_biome,          seed, csize.X, csize.Y);
+	//noise_cave           = new Noise(np_cave,           seed, csize.X, csize.Y);
+
+	map_terrain_base   = noise_terrain_base->result;
+	map_terrain_higher = noise_terrain_higher->result;
+	map_steepness      = noise_steepness->result;
+	map_height_select  = noise_height_select->result;
+	map_trees          = noise_trees->result;
+	map_mud            = noise_mud->result;
+	map_beach          = noise_beach->result;
+	map_biome          = noise_biome->result;
+	//map_cave           = noise_cave->result;
+}
+
+
+MapgenV6::~MapgenV6() {
+	delete noise_terrain_base;
+	delete noise_terrain_higher;
+	delete noise_steepness;
+	delete noise_height_select;
+	delete noise_trees;
+	delete noise_mud;
+	delete noise_beach;
+	delete noise_biome;
+	delete noise_cave;
+}
+
+
+/*
+	Some helper functions for the map generator
+*/
+
+#if 1
+// Returns Y one under area minimum if not found
+s16 MapgenV6::find_ground_level(VoxelManipulator &vmanip, v2s16 p2d,
+		INodeDefManager *ndef)
+{
+	v3s16 em = vmanip.m_area.getExtent();
+	s16 y_nodes_max = vmanip.m_area.MaxEdge.Y;
+	s16 y_nodes_min = vmanip.m_area.MinEdge.Y;
+	u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+	s16 y;
+	for(y=y_nodes_max; y>=y_nodes_min; y--)
+	{
+		MapNode &n = vmanip.m_data[i];
+		if(ndef->get(n).walkable)
+			break;
+
+		vmanip.m_area.add_y(em, i, -1);
+	}
+	if(y >= y_nodes_min)
+		return y;
+	else
+		return y_nodes_min - 1;
+}
+
+// Returns Y one under area minimum if not found
+s16 MapgenV6::find_stone_level(VoxelManipulator &vmanip, v2s16 p2d,
+		INodeDefManager *ndef)
+{
+	v3s16 em = vmanip.m_area.getExtent();
+	s16 y_nodes_max = vmanip.m_area.MaxEdge.Y;
+	s16 y_nodes_min = vmanip.m_area.MinEdge.Y;
+	u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+	s16 y;
+	content_t c_stone = ndef->getId("mapgen_stone");
+	content_t c_desert_stone = ndef->getId("mapgen_desert_stone");
+	for(y=y_nodes_max; y>=y_nodes_min; y--)
+	{
+		MapNode &n = vmanip.m_data[i];
+		content_t c = n.getContent();
+		if(c != CONTENT_IGNORE && (
+				c == c_stone || c == c_desert_stone))
+			break;
+
+		vmanip.m_area.add_y(em, i, -1);
+	}
+	if(y >= y_nodes_min)
+		return y;
+	else
+		return y_nodes_min - 1;
+}
+#endif
+
+void MapgenV6::make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0,
+		bool is_apple_tree, INodeDefManager *ndef)
+{
+	MapNode treenode(ndef->getId("mapgen_tree"));
+	MapNode leavesnode(ndef->getId("mapgen_leaves"));
+	MapNode applenode(ndef->getId("mapgen_apple"));
+
+	s16 trunk_h = myrand_range(4, 5);
+	v3s16 p1 = p0;
+	for(s16 ii=0; ii<trunk_h; ii++)
+	{
+		if(vmanip.m_area.contains(p1))
+			vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
+		p1.Y++;
+	}
+
+	// p1 is now the last piece of the trunk
+	p1.Y -= 1;
+
+	VoxelArea leaves_a(v3s16(-2,-1,-2), v3s16(2,2,2));
+	//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
+	Buffer<u8> leaves_d(leaves_a.getVolume());
+	for(s32 i=0; i<leaves_a.getVolume(); i++)
+		leaves_d[i] = 0;
+
+	// Force leaves at near the end of the trunk
+	{
+		s16 d = 1;
+		for(s16 z=-d; z<=d; z++)
+		for(s16 y=-d; y<=d; y++)
+		for(s16 x=-d; x<=d; x++)
+		{
+			leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
+		}
+	}
+
+	// Add leaves randomly
+	for(u32 iii=0; iii<7; iii++)
+	{
+		s16 d = 1;
+
+		v3s16 p(
+			myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
+			myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
+			myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
+		);
+
+		for(s16 z=0; z<=d; z++)
+		for(s16 y=0; y<=d; y++)
+		for(s16 x=0; x<=d; x++)
+		{
+			leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
+		}
+	}
+
+	// Blit leaves to vmanip
+	for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
+	for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
+	for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
+	{
+		v3s16 p(x,y,z);
+		p += p1;
+		if(vmanip.m_area.contains(p) == false)
+			continue;
+		u32 vi = vmanip.m_area.index(p);
+		if(vmanip.m_data[vi].getContent() != CONTENT_AIR
+				&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
+			continue;
+		u32 i = leaves_a.index(x,y,z);
+		if(leaves_d[i] == 1) {
+			bool is_apple = myrand_range(0,99) < 10;
+			if(is_apple_tree && is_apple) {
+				vmanip.m_data[vi] = applenode;
+			} else {
+				vmanip.m_data[vi] = leavesnode;
+			}
+		}
+	}
+}
+
+
+/*
+	Noise functions. Make sure seed is mangled differently in each one.
+*/
+
+
+// Amount of trees per area in nodes
+double MapgenV6::tree_amount_2d(u64 seed, v2s16 p)
+{
+	/*double noise = noise2d_perlin(
+			0.5+(float)p.X/125, 0.5+(float)p.Y/125,
+			seed+2, 4, 0.66);*/
+	double noise = map_trees[(p.Y - node_min.Z) * ystride + (p.X - node_min.X)];
+	double zeroval = -0.39;
+	if(noise < zeroval)
+		return 0;
+	else
+		return 0.04 * (noise-zeroval) / (1.0-zeroval);
+}
+
+// Required by mapgen.h
+bool MapgenV6::block_is_underground(u64 seed, v3s16 blockpos)
+{
+	/*s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level(
+			seed, v2s16(blockpos.X, blockpos.Z));*/
+	// Nah, this is just a heuristic, just return something
+	s16 minimum_groundlevel = water_level;
+
+	if(blockpos.Y*MAP_BLOCKSIZE + MAP_BLOCKSIZE <= minimum_groundlevel)
+		return true;
+	else
+		return false;
+}
+
+
+double MapgenV6::base_rock_level_2d(u64 seed, v2s16 p)
+{
+	int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
+
+	// The base ground level
+	/*double base = (double)WATER_LEVEL - (double)AVERAGE_MUD_AMOUNT
+			+ 20. * noise2d_perlin(
+			0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+			seed+82341, 5, 0.6);*/
+	double base = water_level + map_terrain_base[index];
+	//return base;
+//printf("%f ", base);
+//return base;
+	// Higher ground level
+	/*double higher = (double)WATER_LEVEL + 20. + 16. * noise2d_perlin(
+			0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+			seed+85039, 5, 0.6);*/
+	double higher = water_level + map_terrain_higher[index];
+
+	// Limit higher to at least base
+	if(higher < base)
+		higher = base;
+
+	// Steepness factor of cliffs
+	/*double b = 0.85 + 0.5 * noise2d_perlin(
+			0.5+(float)p.X/125., 0.5+(float)p.Y/125.,
+			seed-932, 5, 0.7);*/
+	double b = map_steepness[index];
+	b = rangelim(b, 0.0, 1000.0);
+	b = pow(b, 7);
+	b *= 5;
+	b = rangelim(b, 0.5, 1000.0);
+	// Values 1.5...100 give quite horrible looking slopes
+	if(b > 1.5 && b < 100.0){
+		if(b < 10.0)
+			b = 1.5;
+		else
+			b = 100.0;
+	}
+	//dstream<<"b="<<b<<std::endl;
+	//double b = 20;
+	//b = 0.25;
+
+	// Offset to more low
+	double a_off = -0.20;
+	// High/low selector
+	/*double a = (double)0.5 + b * (a_off + noise2d_perlin(
+			0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+			seed+4213, 5, 0.69));*/
+	double a = 0.5 + b * (a_off + map_height_select[index]);
+	// Limit
+	a = rangelim(a, 0.0, 1.0);
+
+	//dstream<<"a="<<a<<std::endl;
+
+	double h = base*(1.0-a) + higher*a;
+
+	return h;
+}
+
+s16 MapgenV6::find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision)
+{
+	return base_rock_level_2d(seed, p2d) + AVERAGE_MUD_AMOUNT;
+}
+
+double MapgenV6::get_mud_add_amount(u64 seed, v2s16 p)
+{
+	/*return ((float)AVERAGE_MUD_AMOUNT + 2.0 * noise2d_perlin(
+			0.5+(float)p.X/200, 0.5+(float)p.Y/200,
+			seed+91013, 3, 0.55));*/
+	int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
+	return map_mud[index];
+}
+
+bool MapgenV6::get_have_beach(u64 seed, v2s16 p2d)
+{
+	// Determine whether to have sand here
+	/*double sandnoise = noise2d_perlin(
+			0.2+(float)p2d.X/250, 0.7+(float)p2d.Y/250,
+			seed+59420, 3, 0.50);*/
+	int index = (p2d.Y - node_min.Z) * ystride + (p2d.X - node_min.X);
+	double sandnoise = map_beach[index];
+
+	return (sandnoise > 0.15);
+}
+
+BiomeType MapgenV6::get_biome(u64 seed, v2s16 p2d)
+{
+	// Just do something very simple as for now
+	/*double d = noise2d_perlin(
+			0.6+(float)p2d.X/250, 0.2+(float)p2d.Y/250,
+			seed+9130, 3, 0.50);*/
+	int index = (p2d.Y - node_min.Z) * ystride + (p2d.X - node_min.X);
+	double d = map_biome[index];
+	if(d > 0.45)
+		return BT_DESERT;
+	if (use_smooth_biome_trans) {
+		if(d > 0.35 && (noise2d( p2d.X, p2d.Y, int(seed) ) + 1.0) > ( 0.45 - d ) * 20.0  )
+			return BT_DESERT;
+	}
+	return BT_NORMAL;
+};
+
+u32 MapgenV6::get_blockseed(u64 seed, v3s16 p)
+{
+	s32 x=p.X, y=p.Y, z=p.Z;
+	return (u32)(seed%0x100000000ULL) + z*38134234 + y*42123 + x*23;
+}
+
+#define VMANIP_FLAG_CAVE VOXELFLAG_CHECKED1
+
+void MapgenV6::makeChunk(BlockMakeData *data)
+{
+	if(data->no_op)
+	{
+		//dstream<<"makeBlock: no-op"<<std::endl;
+		return;
+	}
+
+	this->generating = true;
+
+	assert(data->vmanip);
+	assert(data->nodedef);
+	assert(data->blockpos_requested.X >= data->blockpos_min.X &&
+			data->blockpos_requested.Y >= data->blockpos_min.Y &&
+			data->blockpos_requested.Z >= data->blockpos_min.Z);
+	assert(data->blockpos_requested.X <= data->blockpos_max.X &&
+			data->blockpos_requested.Y <= data->blockpos_max.Y &&
+			data->blockpos_requested.Z <= data->blockpos_max.Z);
+
+	INodeDefManager *ndef = data->nodedef;
+
+	// Hack: use minimum block coordinates for old code that assumes
+	// a single block
+	v3s16 blockpos = data->blockpos_requested;
+
+	/*dstream<<"makeBlock(): ("<<blockpos.X<<","<<blockpos.Y<<","
+			<<blockpos.Z<<")"<<std::endl;*/
+
+	v3s16 blockpos_min = data->blockpos_min;
+	v3s16 blockpos_max = data->blockpos_max;
+	v3s16 blockpos_full_min = blockpos_min - v3s16(1,1,1);
+	v3s16 blockpos_full_max = blockpos_max + v3s16(1,1,1);
+
+	ManualMapVoxelManipulator &vmanip = *(data->vmanip);
+	// Area of central chunk
+	node_min = blockpos_min*MAP_BLOCKSIZE;
+	node_max = (blockpos_max+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1);
+	// Full allocated area
+	v3s16 full_node_min = (blockpos_min-1)*MAP_BLOCKSIZE;
+	v3s16 full_node_max = (blockpos_max+2)*MAP_BLOCKSIZE-v3s16(1,1,1);
+
+	v3s16 central_area_size = node_max - node_min + v3s16(1,1,1);
+
+	const s16 max_spread_amount = MAP_BLOCKSIZE;
+
+	int volume_blocks = (blockpos_max.X - blockpos_min.X + 1)
+			* (blockpos_max.Y - blockpos_min.Y + 1)
+			* (blockpos_max.Z - blockpos_max.Z + 1);
+
+	int volume_nodes = volume_blocks *
+			MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+
+	// Generated surface area
+	//double gen_area_nodes = MAP_BLOCKSIZE*MAP_BLOCKSIZE * rel_volume;
+
+	// Horribly wrong heuristic, but better than nothing
+	bool block_is_underground = (water_level > node_max.Y);
+
+	/*
+		Create a block-specific seed
+	*/
+	u32 blockseed = get_blockseed(data->seed, full_node_min);
+
+	/*
+		Make some noise
+	*/
+	{
+		int x = node_min.X;
+		int z = node_min.Z;
+
+		// Need to adjust for the original implementation's +.5 offset...
+		noise_terrain_base->perlinMap2D(
+			x + 0.5 * noise_terrain_base->np->spread.X,
+			z + 0.5 * noise_terrain_base->np->spread.Z);
+		noise_terrain_base->transformNoiseMap();
+
+		noise_terrain_higher->perlinMap2D(
+			x + 0.5 * noise_terrain_higher->np->spread.X,
+			z + 0.5 * noise_terrain_higher->np->spread.Z);
+		noise_terrain_higher->transformNoiseMap();
+
+		noise_steepness->perlinMap2D(
+			x + 0.5 * noise_steepness->np->spread.X,
+			z + 0.5 * noise_steepness->np->spread.Z);
+		noise_steepness->transformNoiseMap();
+
+		noise_height_select->perlinMap2D(
+			x + 0.5 * noise_height_select->np->spread.X,
+			z + 0.5 * noise_height_select->np->spread.Z);
+
+		noise_mud->perlinMap2D(
+			x + 0.5 * noise_mud->np->spread.X,
+			z + 0.5 * noise_mud->np->spread.Z);
+		noise_mud->transformNoiseMap();
+
+		noise_beach->perlinMap2D(
+			x + 0.2 * noise_beach->np->spread.X,
+			z + 0.7 * noise_beach->np->spread.Z);
+
+		noise_biome->perlinMap2D(
+			x + 0.6 * noise_biome->np->spread.X,
+			z + 0.2 * noise_biome->np->spread.Z);
+
+/*		noise_cave->perlinMap2D(
+			x + 0.5 * noise_cave->np->spread.X,
+			z + 0.5 * noise_cave->np->spread.Z);
+		noise_cave->transformNoiseMap();*/
+	}
+
+
+	/*
+		Cache some ground type values for speed
+	*/
+
+// Creates variables c_name=id and n_name=node
+#define CONTENT_VARIABLE(ndef, name)\
+	content_t c_##name = ndef->getId("mapgen_" #name);\
+	MapNode n_##name(c_##name);
+// Default to something else if was CONTENT_IGNORE
+#define CONTENT_VARIABLE_FALLBACK(name, dname)\
+	if(c_##name == CONTENT_IGNORE){\
+		c_##name = c_##dname;\
+		n_##name = n_##dname;\
+	}
+
+	CONTENT_VARIABLE(ndef, stone);
+	CONTENT_VARIABLE(ndef, air);
+	CONTENT_VARIABLE(ndef, water_source);
+	CONTENT_VARIABLE(ndef, dirt);
+	CONTENT_VARIABLE(ndef, sand);
+	CONTENT_VARIABLE(ndef, gravel);
+	CONTENT_VARIABLE(ndef, clay);
+	CONTENT_VARIABLE(ndef, lava_source);
+	CONTENT_VARIABLE(ndef, cobble);
+	CONTENT_VARIABLE(ndef, mossycobble);
+	CONTENT_VARIABLE(ndef, dirt_with_grass);
+	CONTENT_VARIABLE(ndef, junglegrass);
+	CONTENT_VARIABLE(ndef, stone_with_coal);
+	CONTENT_VARIABLE(ndef, stone_with_iron);
+	CONTENT_VARIABLE(ndef, mese);
+	CONTENT_VARIABLE(ndef, desert_sand);
+	CONTENT_VARIABLE_FALLBACK(desert_sand, sand);
+	CONTENT_VARIABLE(ndef, desert_stone);
+	CONTENT_VARIABLE_FALLBACK(desert_stone, stone);
+
+	// Maximum height of the stone surface and obstacles.
+	// This is used to guide the cave generation
+	s16 stone_surface_max_y = 0;
+
+	/*
+		Generate general ground level to full area
+	*/
+	{
+#if 1
+	TimeTaker timer1("Generating ground level");
+
+	for(s16 x=node_min.X; x<=node_max.X; x++)
+	for(s16 z=node_min.Z; z<=node_max.Z; z++)
+	{
+		// Node position
+		v2s16 p2d = v2s16(x,z);
+
+		/*
+			Skip of already generated
+		*/
+		/*{
+			v3s16 p(p2d.X, node_min.Y, p2d.Y);
+			if(vmanip.m_data[vmanip.m_area.index(p)].d != CONTENT_AIR)
+				continue;
+		}*/
+
+		// Ground height at this point
+		float surface_y_f = 0.0;
+
+		// Use perlin noise for ground height
+		surface_y_f = base_rock_level_2d(data->seed, p2d);
+
+		/*// Experimental stuff
+		{
+			float a = highlands_level_2d(data->seed, p2d);
+			if(a > surface_y_f)
+				surface_y_f = a;
+		}*/
+
+		// Convert to integer
+		s16 surface_y = (s16)surface_y_f;
+
+		// Log it
+		if(surface_y > stone_surface_max_y)
+			stone_surface_max_y = surface_y;
+
+		BiomeType bt = get_biome(data->seed, p2d);
+		/*
+			Fill ground with stone
+		*/
+		{
+			// Use fast index incrementing
+			v3s16 em = vmanip.m_area.getExtent();
+			u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y));
+			for(s16 y=node_min.Y; y<=node_max.Y; y++)
+			{
+				if(vmanip.m_data[i].getContent() == CONTENT_IGNORE){
+					if(y <= surface_y){
+						if(y > water_level && bt == BT_DESERT)
+							vmanip.m_data[i] = n_desert_stone;
+						else
+							vmanip.m_data[i] = n_stone;
+					} else if(y <= water_level){
+						vmanip.m_data[i] = MapNode(c_water_source);
+					} else {
+						vmanip.m_data[i] = MapNode(c_air);
+					}
+				}
+				vmanip.m_area.add_y(em, i, 1);
+			}
+		}
+	}
+#endif
+
+	}//timer1
+
+	// Limit dirt flow area by 1 because mud is flown into neighbors.
+	assert(central_area_size.X == central_area_size.Z);
+	s16 mudflow_minpos = 0-max_spread_amount+1;
+	s16 mudflow_maxpos = central_area_size.X+max_spread_amount-2;
+
+	/*
+		Loop this part, it will make stuff look older and newer nicely
+	*/
+
+	double cave_amount = 6.0 + 6.0 * noise2d_perlin(
+			0.5+(double)node_min.X/250, 0.5+(double)node_min.Y/250,
+			data->seed+34329, 3, 0.50);
+
+	const u32 age_loops = 2;
+	for(u32 i_age=0; i_age<age_loops; i_age++)
+	{ // Aging loop
+	/******************************
+		BEGINNING OF AGING LOOP
+	******************************/
+
+#if 1
+	{
+	// 24ms @cs=8
+	//TimeTaker timer1("caves");
+
+	/*
+		Make caves (this code is relatively horrible)
+	*/
+	cave_amount = MYMAX(0.0, cave_amount);
+	u32 caves_count = cave_amount * volume_nodes / 50000;
+	u32 bruises_count = 1;
+	PseudoRandom ps(blockseed+21343);
+	PseudoRandom ps2(blockseed+1032);
+	if(ps.range(1, 6) == 1)
+		bruises_count = ps.range(0, ps.range(0, 2));
+	if(get_biome(data->seed, v2s16(node_min.X, node_min.Y)) == BT_DESERT){
+		caves_count /= 3;
+		bruises_count /= 3;
+	}
+	for(u32 jj=0; jj<caves_count+bruises_count; jj++)
+	{
+		bool large_cave = (jj >= caves_count);
+		s16 min_tunnel_diameter = 2;
+		s16 max_tunnel_diameter = ps.range(2,6);
+		int dswitchint = ps.range(1,14);
+		u16 tunnel_routepoints = 0;
+		int part_max_length_rs = 0;
+		if(large_cave){
+			part_max_length_rs = ps.range(2,4);
+			tunnel_routepoints = ps.range(5, ps.range(15,30));
+			min_tunnel_diameter = 5;
+			max_tunnel_diameter = ps.range(7, ps.range(8,24));
+		} else {
+			part_max_length_rs = ps.range(2,9);
+			tunnel_routepoints = ps.range(10, ps.range(15,30));
+		}
+		bool large_cave_is_flat = (ps.range(0,1) == 0);
+
+		v3f main_direction(0,0,0);
+
+		// Allowed route area size in nodes
+		v3s16 ar = central_area_size;
+
+		// Area starting point in nodes
+		v3s16 of = node_min;
+
+		// Allow a bit more
+		//(this should be more than the maximum radius of the tunnel)
+		s16 insure = 10;
+		s16 more = max_spread_amount - max_tunnel_diameter/2 - insure;
+		ar += v3s16(1,0,1) * more * 2;
+		of -= v3s16(1,0,1) * more;
+
+		s16 route_y_min = 0;
+		// Allow half a diameter + 7 over stone surface
+		s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2 + 7;
+
+		// Limit maximum to area
+		route_y_max = rangelim(route_y_max, 0, ar.Y-1);
+
+		if(large_cave)
+		{
+			s16 min = 0;
+			if(node_min.Y < water_level && node_max.Y > water_level)
+			{
+				min = water_level - max_tunnel_diameter/3 - of.Y;
+				route_y_max = water_level + max_tunnel_diameter/3 - of.Y;
+			}
+			route_y_min = ps.range(min, min + max_tunnel_diameter);
+			route_y_min = rangelim(route_y_min, 0, route_y_max);
+		}
+
+		s16 route_start_y_min = route_y_min;
+		s16 route_start_y_max = route_y_max;
+
+		route_start_y_min = rangelim(route_start_y_min, 0, ar.Y-1);
+		route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y-1);
+
+		// Randomize starting position
+		v3f orp(
+			(float)(ps.next()%ar.X)+0.5,
+			(float)(ps.range(route_start_y_min, route_start_y_max))+0.5,
+			(float)(ps.next()%ar.Z)+0.5
+		);
+
+		v3s16 startp(orp.X, orp.Y, orp.Z);
+		startp += of;
+
+		MapNode airnode(CONTENT_AIR);
+		MapNode waternode(c_water_source);
+		MapNode lavanode(c_lava_source);
+
+		/*
+			Generate some tunnel starting from orp
+		*/
+
+		for(u16 j=0; j<tunnel_routepoints; j++)
+		{
+			if(j%dswitchint==0 && large_cave == false)
+			{
+				main_direction = v3f(
+					((float)(ps.next()%20)-(float)10)/10,
+					((float)(ps.next()%20)-(float)10)/30,
+					((float)(ps.next()%20)-(float)10)/10
+				);
+				main_direction *= (float)ps.range(0, 10)/10;
+			}
+
+			// Randomize size
+			s16 min_d = min_tunnel_diameter;
+			s16 max_d = max_tunnel_diameter;
+			s16 rs = ps.range(min_d, max_d);
+
+			// Every second section is rough
+			bool randomize_xz = (ps2.range(1,2) == 1);
+
+			v3s16 maxlen;
+			if(large_cave)
+			{
+				maxlen = v3s16(
+					rs*part_max_length_rs,
+					rs*part_max_length_rs/2,
+					rs*part_max_length_rs
+				);
+			}
+			else
+			{
+				maxlen = v3s16(
+					rs*part_max_length_rs,
+					ps.range(1, rs*part_max_length_rs),
+					rs*part_max_length_rs
+				);
+			}
+
+			v3f vec;
+
+			vec = v3f(
+				(float)(ps.next()%(maxlen.X*1))-(float)maxlen.X/2,
+				(float)(ps.next()%(maxlen.Y*1))-(float)maxlen.Y/2,
+				(float)(ps.next()%(maxlen.Z*1))-(float)maxlen.Z/2
+			);
+
+			// Jump downward sometimes
+			if(!large_cave && ps.range(0,12) == 0)
+			{
+				vec = v3f(
+					(float)(ps.next()%(maxlen.X*1))-(float)maxlen.X/2,
+					(float)(ps.next()%(maxlen.Y*2))-(float)maxlen.Y*2/2,
+					(float)(ps.next()%(maxlen.Z*1))-(float)maxlen.Z/2
+				);
+			}
+
+			/*if(large_cave){
+				v3f p = orp + vec;
+				s16 h = find_ground_level_clever(vmanip,
+						v2s16(p.X, p.Z), ndef);
+				route_y_min = h - rs/3;
+				route_y_max = h + rs;
+			}*/
+
+			vec += main_direction;
+
+			v3f rp = orp + vec;
+			if(rp.X < 0)
+				rp.X = 0;
+			else if(rp.X >= ar.X)
+				rp.X = ar.X-1;
+			if(rp.Y < route_y_min)
+				rp.Y = route_y_min;
+			else if(rp.Y >= route_y_max)
+				rp.Y = route_y_max-1;
+			if(rp.Z < 0)
+				rp.Z = 0;
+			else if(rp.Z >= ar.Z)
+				rp.Z = ar.Z-1;
+			vec = rp - orp;
+
+			for(float f=0; f<1.0; f+=1.0/vec.getLength())
+			{
+				v3f fp = orp + vec * f;
+				fp.X += 0.1*ps.range(-10,10);
+				fp.Z += 0.1*ps.range(-10,10);
+				v3s16 cp(fp.X, fp.Y, fp.Z);
+
+				s16 d0 = -rs/2;
+				s16 d1 = d0 + rs;
+				if(randomize_xz){
+					d0 += ps.range(-1,1);
+					d1 += ps.range(-1,1);
+				}
+				for(s16 z0=d0; z0<=d1; z0++)
+				{
+					s16 si = rs/2 - MYMAX(0, abs(z0)-rs/7-1);
+					for(s16 x0=-si-ps.range(0,1); x0<=si-1+ps.range(0,1); x0++)
+					{
+						s16 maxabsxz = MYMAX(abs(x0), abs(z0));
+						s16 si2 = rs/2 - MYMAX(0, maxabsxz-rs/7-1);
+						for(s16 y0=-si2; y0<=si2; y0++)
+						{
+							/*// Make better floors in small caves
+							if(y0 <= -rs/2 && rs<=7)
+								continue;*/
+							if(large_cave_is_flat){
+								// Make large caves not so tall
+								if(rs > 7 && abs(y0) >= rs/3)
+									continue;
+							}
+
+							s16 z = cp.Z + z0;
+							s16 y = cp.Y + y0;
+							s16 x = cp.X + x0;
+							v3s16 p(x,y,z);
+							p += of;
+
+							if(vmanip.m_area.contains(p) == false)
+								continue;
+
+							u32 i = vmanip.m_area.index(p);
+
+							if(large_cave)
+							{
+								if(full_node_min.Y < water_level &&
+									full_node_max.Y > water_level){
+									if(p.Y <= water_level)
+										vmanip.m_data[i] = waternode;
+									else
+										vmanip.m_data[i] = airnode;
+								} else if(full_node_max.Y < water_level){
+									if(p.Y < startp.Y - 2)
+										vmanip.m_data[i] = lavanode;
+									else
+										vmanip.m_data[i] = airnode;
+								} else {
+									vmanip.m_data[i] = airnode;
+								}
+							} else {
+								// Don't replace air or water or lava or ignore
+								if(vmanip.m_data[i].getContent() == CONTENT_IGNORE ||
+								vmanip.m_data[i].getContent() == CONTENT_AIR ||
+								vmanip.m_data[i].getContent() == c_water_source ||
+								vmanip.m_data[i].getContent() == c_lava_source)
+									continue;
+
+								vmanip.m_data[i] = airnode;
+
+								// Set tunnel flag
+								vmanip.m_flags[i] |= VMANIP_FLAG_CAVE;
+							}
+						}
+					}
+				}
+			}
+
+			orp = rp;
+		}
+
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 15ms @cs=8
+	TimeTaker timer1("add mud");
+
+	/*
+		Add mud to the central chunk
+	*/
+
+	for(s16 x=node_min.X; x<=node_max.X; x++)
+	for(s16 z=node_min.Z; z<=node_max.Z; z++)
+	{
+		// Node position in 2d
+		v2s16 p2d = v2s16(x,z);
+
+		// Randomize mud amount
+		s16 mud_add_amount = get_mud_add_amount(data->seed, p2d) / 2.0 + 0.5;
+
+		// Find ground level
+		s16 surface_y = find_stone_level(vmanip, p2d, ndef);
+		// Handle area not found
+		if(surface_y == vmanip.m_area.MinEdge.Y - 1)
+			continue;
+
+		MapNode addnode(c_dirt);
+		BiomeType bt = get_biome(data->seed, p2d);
+
+		if(bt == BT_DESERT)
+			addnode = MapNode(c_desert_sand);
+
+		if(bt == BT_DESERT && surface_y + mud_add_amount <= water_level+1){
+			addnode = MapNode(c_sand);
+		} else if(mud_add_amount <= 0){
+			mud_add_amount = 1 - mud_add_amount;
+			addnode = MapNode(c_gravel);
+		} else if(bt == BT_NORMAL && get_have_beach(data->seed, p2d) &&
+				surface_y + mud_add_amount <= water_level+2){
+			addnode = MapNode(c_sand);
+		}
+
+		if(bt == BT_DESERT){
+			if(surface_y > 20){
+				mud_add_amount = MYMAX(0, mud_add_amount - (surface_y - 20)/5);
+			}
+		}
+
+		/*
+			If topmost node is grass, change it to mud.
+			It might be if it was flown to there from a neighboring
+			chunk and then converted.
+		*/
+		{
+			u32 i = vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y));
+			MapNode *n = &vmanip.m_data[i];
+			if(n->getContent() == c_dirt_with_grass)
+				*n = MapNode(c_dirt);
+		}
+
+		/*
+			Add mud on ground
+		*/
+		{
+			s16 mudcount = 0;
+			v3s16 em = vmanip.m_area.getExtent();
+			s16 y_start = surface_y+1;
+			u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			for(s16 y=y_start; y<=node_max.Y; y++)
+			{
+				if(mudcount >= mud_add_amount)
+					break;
+
+				MapNode &n = vmanip.m_data[i];
+				n = addnode;
+				mudcount++;
+
+				vmanip.m_area.add_y(em, i, 1);
+			}
+		}
+
+	}
+
+	}//timer1
+#endif
+
+	/*
+		Add blobs of dirt and gravel underground
+	*/
+	if(get_biome(data->seed, v2s16(node_min.X, node_min.Y)) == BT_NORMAL)
+	{
+	PseudoRandom pr(blockseed+983);
+	for(int i=0; i<volume_nodes/10/10/10; i++)
+	{
+		bool only_fill_cave = (myrand_range(0,1) != 0);
+		v3s16 size(
+			pr.range(1, 8),
+			pr.range(1, 8),
+			pr.range(1, 8)
+		);
+		v3s16 p0(
+			pr.range(node_min.X, node_max.X)-size.X/2,
+			pr.range(node_min.Y, node_max.Y)-size.Y/2,
+			pr.range(node_min.Z, node_max.Z)-size.Z/2
+		);
+		MapNode n1;
+		if(p0.Y > -32 && pr.range(0,1) == 0)
+			n1 = MapNode(c_dirt);
+		else
+			n1 = MapNode(c_gravel);
+		for(int x1=0; x1<size.X; x1++)
+		for(int y1=0; y1<size.Y; y1++)
+		for(int z1=0; z1<size.Z; z1++)
+		{
+			v3s16 p = p0 + v3s16(x1,y1,z1);
+			u32 i = vmanip.m_area.index(p);
+			if(!vmanip.m_area.contains(i))
+				continue;
+			// Cancel if not stone and not cave air
+			if(vmanip.m_data[i].getContent() != c_stone &&
+					!(vmanip.m_flags[i] & VMANIP_FLAG_CAVE))
+				continue;
+			if(only_fill_cave && !(vmanip.m_flags[i] & VMANIP_FLAG_CAVE))
+				continue;
+			vmanip.m_data[i] = n1;
+		}
+	}
+	}
+
+#if 1
+	{
+	// 340ms @cs=8
+	TimeTaker timer1("flow mud");
+
+	/*
+		Flow mud away from steep edges
+	*/
+
+	// Iterate a few times
+	for(s16 k=0; k<3; k++)
+	{
+
+	for(s16 x=mudflow_minpos; x<=mudflow_maxpos; x++)
+	for(s16 z=mudflow_minpos; z<=mudflow_maxpos; z++)
+	{
+		// Invert coordinates every 2nd iteration
+		if(k%2 == 0)
+		{
+			x = mudflow_maxpos - (x-mudflow_minpos);
+			z = mudflow_maxpos - (z-mudflow_minpos);
+		}
+
+		// Node position in 2d
+		v2s16 p2d = v2s16(node_min.X, node_min.Z) + v2s16(x,z);
+
+		v3s16 em = vmanip.m_area.getExtent();
+		u32 i = vmanip.m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y));
+		s16 y=node_max.Y;
+
+		while(y >= node_min.Y)
+		{
+
+		for(;; y--)
+		{
+			MapNode *n = NULL;
+			// Find mud
+			for(; y>=node_min.Y; y--)
+			{
+				n = &vmanip.m_data[i];
+				//if(content_walkable(n->d))
+				//	break;
+				if(n->getContent() == c_dirt ||
+						n->getContent() == c_dirt_with_grass ||
+						n->getContent() == c_gravel)
+					break;
+
+				vmanip.m_area.add_y(em, i, -1);
+			}
+
+			// Stop if out of area
+			//if(vmanip.m_area.contains(i) == false)
+			if(y < node_min.Y)
+				break;
+
+			/*// If not mud, do nothing to it
+			MapNode *n = &vmanip.m_data[i];
+			if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+				continue;*/
+
+			if(n->getContent() == c_dirt ||
+					n->getContent() == c_dirt_with_grass)
+			{
+				// Make it exactly mud
+				n->setContent(c_dirt);
+
+				/*
+					Don't flow it if the stuff under it is not mud
+				*/
+				{
+					u32 i2 = i;
+					vmanip.m_area.add_y(em, i2, -1);
+					// Cancel if out of area
+					if(vmanip.m_area.contains(i2) == false)
+						continue;
+					MapNode *n2 = &vmanip.m_data[i2];
+					if(n2->getContent() != c_dirt &&
+							n2->getContent() != c_dirt_with_grass)
+						continue;
+				}
+			}
+
+			/*s16 recurse_count = 0;
+	mudflow_recurse:*/
+
+			v3s16 dirs4[4] = {
+				v3s16(0,0,1), // back
+				v3s16(1,0,0), // right
+				v3s16(0,0,-1), // front
+				v3s16(-1,0,0), // left
+			};
+
+			// Theck that upper is air or doesn't exist.
+			// Cancel dropping if upper keeps it in place
+			u32 i3 = i;
+			vmanip.m_area.add_y(em, i3, 1);
+			if(vmanip.m_area.contains(i3) == true
+					&& ndef->get(vmanip.m_data[i3]).walkable)
+			{
+				continue;
+			}
+
+			// Drop mud on side
+
+			for(u32 di=0; di<4; di++)
+			{
+				v3s16 dirp = dirs4[di];
+				u32 i2 = i;
+				// Move to side
+				vmanip.m_area.add_p(em, i2, dirp);
+				// Fail if out of area
+				if(vmanip.m_area.contains(i2) == false)
+					continue;
+				// Check that side is air
+				MapNode *n2 = &vmanip.m_data[i2];
+				if(ndef->get(*n2).walkable)
+					continue;
+				// Check that under side is air
+				vmanip.m_area.add_y(em, i2, -1);
+				if(vmanip.m_area.contains(i2) == false)
+					continue;
+				n2 = &vmanip.m_data[i2];
+				if(ndef->get(*n2).walkable)
+					continue;
+				/*// Check that under that is air (need a drop of 2)
+				vmanip.m_area.add_y(em, i2, -1);
+				if(vmanip.m_area.contains(i2) == false)
+					continue;
+				n2 = &vmanip.m_data[i2];
+				if(content_walkable(n2->d))
+					continue;*/
+				// Loop further down until not air
+				bool dropped_to_unknown = false;
+				do{
+					vmanip.m_area.add_y(em, i2, -1);
+					n2 = &vmanip.m_data[i2];
+					// if out of known area
+					if(vmanip.m_area.contains(i2) == false
+							|| n2->getContent() == CONTENT_IGNORE){
+						dropped_to_unknown = true;
+						break;
+					}
+				}while(ndef->get(*n2).walkable == false);
+				// Loop one up so that we're in air
+				vmanip.m_area.add_y(em, i2, 1);
+				n2 = &vmanip.m_data[i2];
+
+				bool old_is_water = (n->getContent() == c_water_source);
+				// Move mud to new place
+				if(!dropped_to_unknown) {
+					*n2 = *n;
+					// Set old place to be air (or water)
+					if(old_is_water)
+						*n = MapNode(c_water_source);
+					else
+						*n = MapNode(CONTENT_AIR);
+				}
+
+				// Done
+				break;
+			}
+		}
+		}
+	}
+
+	}
+
+	}//timer1
+#endif
+
+	} // Aging loop
+	/***********************
+		END OF AGING LOOP
+	************************/
+
+	/*
+		Add top and bottom side of water to transforming_liquid queue
+	*/
+
+	for(s16 x=full_node_min.X; x<=full_node_max.X; x++)
+	for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++)
+	{
+		// Node position
+		v2s16 p2d(x,z);
+		{
+			bool water_found = false;
+			// Use fast index incrementing
+			v3s16 em = vmanip.m_area.getExtent();
+			u32 i = vmanip.m_area.index(v3s16(p2d.X, full_node_max.Y, p2d.Y));
+			for(s16 y=full_node_max.Y; y>=full_node_min.Y; y--)
+			{
+				if(y == full_node_max.Y){
+					water_found =
+						(vmanip.m_data[i].getContent() == c_water_source ||
+						vmanip.m_data[i].getContent() == c_lava_source);
+				}
+				else if(water_found == false)
+				{
+					if(vmanip.m_data[i].getContent() == c_water_source ||
+							vmanip.m_data[i].getContent() == c_lava_source)
+					{
+						v3s16 p = v3s16(p2d.X, y, p2d.Y);
+						data->transforming_liquid.push_back(p);
+						water_found = true;
+					}
+				}
+				else
+				{
+					// This can be done because water_found can only
+					// turn to true and end up here after going through
+					// a single block.
+					if(vmanip.m_data[i+1].getContent() != c_water_source ||
+							vmanip.m_data[i+1].getContent() != c_lava_source)
+					{
+						v3s16 p = v3s16(p2d.X, y+1, p2d.Y);
+						data->transforming_liquid.push_back(p);
+						water_found = false;
+					}
+				}
+
+				vmanip.m_area.add_y(em, i, -1);
+			}
+		}
+	}
+
+	/*
+		Grow grass
+	*/
+
+	for(s16 x=full_node_min.X; x<=full_node_max.X; x++)
+	for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++)
+	{
+		// Node position in 2d
+		v2s16 p2d = v2s16(x,z);
+
+		/*
+			Find the lowest surface to which enough light ends up
+			to make grass grow.
+
+			Basically just wait until not air and not leaves.
+		*/
+		s16 surface_y = 0;
+		{
+			v3s16 em = vmanip.m_area.getExtent();
+			u32 i = vmanip.m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y));
+			s16 y;
+			// Go to ground level
+			for(y=node_max.Y; y>=full_node_min.Y; y--)
+			{
+				MapNode &n = vmanip.m_data[i];
+				if(ndef->get(n).param_type != CPT_LIGHT
+						|| ndef->get(n).liquid_type != LIQUID_NONE)
+					break;
+				vmanip.m_area.add_y(em, i, -1);
+			}
+			if(y >= full_node_min.Y)
+				surface_y = y;
+			else
+				surface_y = full_node_min.Y;
+		}
+
+		u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y);
+		MapNode *n = &vmanip.m_data[i];
+		if(n->getContent() == c_dirt){
+			// Well yeah, this can't be overground...
+			if(surface_y < water_level - 20)
+				continue;
+			n->setContent(c_dirt_with_grass);
+		}
+	}
+
+	/*
+		Generate some trees
+	*/
+	assert(central_area_size.X == central_area_size.Z);
+	{
+		// Divide area into parts
+		s16 div = 8;
+		s16 sidelen = central_area_size.X / div;
+		double area = sidelen * sidelen;
+		for(s16 x0=0; x0<div; x0++)
+		for(s16 z0=0; z0<div; z0++)
+		{
+			// Center position of part of division
+			v2s16 p2d_center(
+				node_min.X + sidelen/2 + sidelen*x0,
+				node_min.Z + sidelen/2 + sidelen*z0
+			);
+			// Minimum edge of part of division
+			v2s16 p2d_min(
+				node_min.X + sidelen*x0,
+				node_min.Z + sidelen*z0
+			);
+			// Maximum edge of part of division
+			v2s16 p2d_max(
+				node_min.X + sidelen + sidelen*x0 - 1,
+				node_min.Z + sidelen + sidelen*z0 - 1
+			);
+			// Amount of trees
+			u32 tree_count = area * tree_amount_2d(data->seed, p2d_center);
+			// Put trees in random places on part of division
+			for(u32 i=0; i<tree_count; i++)
+			{
+				s16 x = myrand_range(p2d_min.X, p2d_max.X);
+				s16 z = myrand_range(p2d_min.Y, p2d_max.Y);
+				s16 y = find_ground_level(vmanip, v2s16(x,z), ndef);
+				// Don't make a tree under water level
+				if(y < water_level)
+					continue;
+				// Don't make a tree so high that it doesn't fit
+				if(y > node_max.Y - 6)
+					continue;
+				v3s16 p(x,y,z);
+				/*
+					Trees grow only on mud and grass
+				*/
+				{
+					u32 i = vmanip.m_area.index(v3s16(p));
+					MapNode *n = &vmanip.m_data[i];
+					if(n->getContent() != c_dirt
+							&& n->getContent() != c_dirt_with_grass)
+						continue;
+				}
+				p.Y++;
+				// Make a tree
+				make_tree(vmanip, p, false, ndef);
+			}
+		}
+	}
+
+
+	/*
+		Calculate lighting
+	*/
+	{
+	ScopeProfiler sp(g_profiler, "EmergeThread: mapgen lighting update",
+			SPT_AVG);
+	//VoxelArea a(node_min, node_max);
+	VoxelArea a(node_min-v3s16(1,0,1)*MAP_BLOCKSIZE,
+			node_max+v3s16(1,0,1)*MAP_BLOCKSIZE);
+	/*VoxelArea a(node_min-v3s16(1,0,1)*MAP_BLOCKSIZE/2,
+			node_max+v3s16(1,0,1)*MAP_BLOCKSIZE/2);*/
+	enum LightBank banks[2] = {LIGHTBANK_DAY, LIGHTBANK_NIGHT};
+	for(int i=0; i<2; i++)
+	{
+		enum LightBank bank = banks[i];
+
+		core::map<v3s16, bool> light_sources;
+		core::map<v3s16, u8> unlight_from;
+
+		voxalgo::clearLightAndCollectSources(vmanip, a, bank, ndef,
+				light_sources, unlight_from);
+
+		bool inexistent_top_provides_sunlight = !block_is_underground;
+		voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight(
+				vmanip, a, inexistent_top_provides_sunlight,
+				light_sources, ndef);
+		// TODO: Do stuff according to bottom_sunlight_valid
+
+		vmanip.unspreadLight(bank, unlight_from, light_sources, ndef);
+
+		vmanip.spreadLight(bank, light_sources, ndef);
+	}
+	}
+}
diff --git a/src/noise.cpp b/src/noise.cpp
index c038384db..17b5df018 100644
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -289,8 +289,8 @@ void Noise::init(NoiseParams *np, int seed, int sx, int sy, int sz) {
 	this->noisebuf = NULL;
 	resizeNoiseBuf(sz > 1);
 
-	this->buf      = new float[sx * sy * sz];
-	this->result   = new float[sx * sy * sz];
+	this->buf    = new float[sx * sy * sz];
+	this->result = new float[sx * sy * sz];
 }
 
 
@@ -311,10 +311,13 @@ void Noise::setSize(int sx, int sy, int sz) {
 	this->sy = sy;
 	this->sz = sz;
 
+	this->noisebuf = NULL;
 	resizeNoiseBuf(sz > 1);
 
 	delete[] buf;
 	delete[] result;
+	this->buf    = new float[sx * sy * sz];
+	this->result = new float[sx * sy * sz];	
 }
 
 
diff --git a/src/scriptapi.cpp b/src/scriptapi.cpp
index 27f48be27..56fdef3f9 100644
--- a/src/scriptapi.cpp
+++ b/src/scriptapi.cpp
@@ -4460,10 +4460,8 @@ static int l_register_biome_groups(lua_State *L)
 {
 	luaL_checktype(L, 1, LUA_TTABLE);
 	int index = 1;
-	if (!lua_istable(L, index)) {
-
-		return 0;
-	}
+	if (!lua_istable(L, index))
+		throw LuaError(L, "register_biome_groups: parameter is not a table");
 
 	BiomeDefManager *bmgr = get_server(L)->getEmergeManager()->biomedef;
 
@@ -4514,15 +4512,16 @@ static int l_register_biome(lua_State *L)
 	b->humidity_min = getfloatfield_default(L, index, "humidity_min", 0.);
 	b->humidity_max = getfloatfield_default(L, index, "humidity_max", 0.);
 
-//////hrm, what to do about the noiseparams...
-	b->np = new NoiseParams; /////just a hacky solution
+	b->np = new NoiseParams; // should read an entire NoiseParams later on...
 	getfloatfield(L, index, "scale", b->np->scale);
 	getfloatfield(L, index, "offset", b->np->offset);
-	//TODO: add configurable spread factor and octaves!?
-	//I'd have to create a Noise for every Biome...
-	bmgr->addBiome(groupid, b);
-	printf(" - added biome '%s'  -  %d %d\n", b->name.c_str(), b->n_top.param0, b->n_filler.param0);
 
+	b->groupid = (s8)groupid;
+	b->flags   = 0; //reserved
+
+	bmgr->addBiome(b);
+
+	verbosestream << "register_biome: " << b->name << std::endl;
 	return 0;
 }
 
diff --git a/src/server.cpp b/src/server.cpp
index a3c0b66ed..22c828bc2 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -172,8 +172,12 @@ void * EmergeThread::Thread()
 
 	ServerMap &map = ((ServerMap&)m_server->m_env->getMap());
 	EmergeManager *emerge = m_server->m_emerge;
-	Mapgen *mapgen = new Mapgen( m_server->m_emerge->biomedef,/*mapgenid*/ 0, map.getSeed()); ////////fix this...!
 
+	Mapgen *mapgen;
+	if (g_settings->getS16("use_mapgen_version") == 7)   ////////this is okay for now, fix later
+		mapgen = new MapgenV7( m_server->m_emerge->biomedef,/*mapgenid*/ 0, map.getSeed());
+	else
+		mapgen = new MapgenV6(0, map.getSeed());
 	/*
 		Get block info from queue, emerge them and send them
 		to clients.