X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=cd2ba9154eadac0202782697b47cf2ff5052ce92;hb=d4d49ee8f4d425e7a4136d65f519728869680951;hp=5655ee9ec8d638e862cfe475fe547da731daad01;hpb=4a952f22d779cdce27dbfc68a23a7d13d3e62c0d;p=dragonfireclient.git

diff --git a/src/map.cpp b/src/map.cpp
index 5655ee9ec..cd2ba9154 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -1,6 +1,6 @@
 /*
 Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+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 General Public License as published by
@@ -25,6 +25,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "utility.h"
 #include "voxel.h"
 #include "porting.h"
+#include "mineral.h"
+#include "noise.h"
+#include "serverobject.h"
 
 /*
 	Map
@@ -32,31 +35,16 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 Map::Map(std::ostream &dout):
 	m_dout(dout),
-	m_camera_position(0,0,0),
-	m_camera_direction(0,0,1),
-	m_sector_cache(NULL),
-	m_hwrapper(this)
+	m_sector_cache(NULL)
 {
-	m_sector_mutex.Init();
-	m_camera_mutex.Init();
-	assert(m_sector_mutex.IsInitialized());
-	assert(m_camera_mutex.IsInitialized());
-	
-	// Get this so that the player can stay on it at first
-	//getSector(v2s16(0,0));
+	/*m_sector_mutex.Init();
+	assert(m_sector_mutex.IsInitialized());*/
 }
 
 Map::~Map()
 {
 	/*
-		Stop updater thread
-	*/
-	/*updater.setRun(false);
-	while(updater.IsRunning())
-		sleep_s(1);*/
-
-	/*
-		Free all MapSectors.
+		Free all MapSectors
 	*/
 	core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
 	for(; i.atEnd() == false; i++)
@@ -66,10 +54,31 @@ Map::~Map()
 	}
 }
 
-MapSector * Map::getSectorNoGenerate(v2s16 p)
+void Map::addEventReceiver(MapEventReceiver *event_receiver)
 {
-	JMutexAutoLock lock(m_sector_mutex);
+	m_event_receivers.insert(event_receiver, false);
+}
+
+void Map::removeEventReceiver(MapEventReceiver *event_receiver)
+{
+	if(m_event_receivers.find(event_receiver) == NULL)
+		return;
+	m_event_receivers.remove(event_receiver);
+}
+
+void Map::dispatchEvent(MapEditEvent *event)
+{
+	for(core::map<MapEventReceiver*, bool>::Iterator
+			i = m_event_receivers.getIterator();
+			i.atEnd()==false; i++)
+	{
+		MapEventReceiver* event_receiver = i.getNode()->getKey();
+		event_receiver->onMapEditEvent(event);
+	}
+}
 
+MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p)
+{
 	if(m_sector_cache != NULL && p == m_sector_cache_p){
 		MapSector * sector = m_sector_cache;
 		// Reset inactivity timer
@@ -78,11 +87,9 @@ MapSector * Map::getSectorNoGenerate(v2s16 p)
 	}
 	
 	core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
-	// If sector doesn't exist, throw an exception
+	
 	if(n == NULL)
-	{
-		throw InvalidPositionException();
-	}
+		return NULL;
 	
 	MapSector *sector = n->getValue();
 	
@@ -90,13 +97,27 @@ MapSector * Map::getSectorNoGenerate(v2s16 p)
 	m_sector_cache_p = p;
 	m_sector_cache = sector;
 
-	//MapSector * ref(sector);
-	
 	// Reset inactivity timer
 	sector->usage_timer = 0.0;
 	return sector;
 }
 
+MapSector * Map::getSectorNoGenerateNoEx(v2s16 p)
+{
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
+
+	return getSectorNoGenerateNoExNoLock(p);
+}
+
+MapSector * Map::getSectorNoGenerate(v2s16 p)
+{
+	MapSector *sector = getSectorNoGenerateNoEx(p);
+	if(sector == NULL)
+		throw InvalidPositionException();
+	
+	return sector;
+}
+
 MapBlock * Map::getBlockNoCreate(v3s16 p3d)
 {	
 	v2s16 p2d(p3d.X, p3d.Z);
@@ -122,33 +143,17 @@ MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d)
 	}
 }
 
-f32 Map::getGroundHeight(v2s16 p, bool generate)
-{
-	try{
-		v2s16 sectorpos = getNodeSectorPos(p);
-		MapSector * sref = getSectorNoGenerate(sectorpos);
-		v2s16 relpos = p - sectorpos * MAP_BLOCKSIZE;
-		f32 y = sref->getGroundHeight(relpos);
-		return y;
-	}
-	catch(InvalidPositionException &e)
-	{
-		return GROUNDHEIGHT_NOTFOUND_SETVALUE;
-	}
-}
-
-void Map::setGroundHeight(v2s16 p, f32 y, bool generate)
+/*MapBlock * Map::getBlockCreate(v3s16 p3d)
 {
-	/*m_dout<<DTIME<<"Map::setGroundHeight(("
-			<<p.X<<","<<p.Y
-			<<"), "<<y<<")"<<std::endl;*/
-	v2s16 sectorpos = getNodeSectorPos(p);
-	MapSector * sref = getSectorNoGenerate(sectorpos);
-	v2s16 relpos = p - sectorpos * MAP_BLOCKSIZE;
-	//sref->mutex.Lock();
-	sref->setGroundHeight(relpos, y);
-	//sref->mutex.Unlock();
-}
+	v2s16 p2d(p3d.X, p3d.Z);
+	MapSector * sector = getSectorCreate(p2d);
+	assert(sector);
+	MapBlock *block = sector->getBlockNoCreate(p3d.Y);
+	if(block)
+		return block;
+	block = sector->createBlankBlock(p3d.Y);
+	return block;
+}*/
 
 bool Map::isNodeUnderground(v3s16 p)
 {
@@ -622,11 +627,15 @@ void Map::updateLighting(enum LightBank bank,
 		core::map<v3s16, MapBlock*> & modified_blocks)
 {
 	/*m_dout<<DTIME<<"Map::updateLighting(): "
-			<<a_blocks.getSize()<<" blocks... ";*/
+			<<a_blocks.size()<<" blocks."<<std::endl;*/
+	
+	//TimeTaker timer("updateLighting");
 	
 	// For debugging
-	bool debug=false;
-	u32 count_was = modified_blocks.size();
+	//bool debug=true;
+	//u32 count_was = modified_blocks.size();
+	
+	core::map<v3s16, MapBlock*> blocks_to_update;
 
 	core::map<v3s16, bool> light_sources;
 	
@@ -647,6 +656,8 @@ void Map::updateLighting(enum LightBank bank,
 			v3s16 pos = block->getPos();
 			modified_blocks.insert(pos, block);
 
+			blocks_to_update.insert(pos, block);
+
 			/*
 				Clear all light from block
 			*/
@@ -696,10 +707,12 @@ void Map::updateLighting(enum LightBank bank,
 			}
 			else if(bank == LIGHTBANK_NIGHT)
 			{
+				// For night lighting, sunlight is not propagated
 				break;
 			}
 			else
 			{
+				// Invalid lighting bank
 				assert(0);
 			}
 				
@@ -707,7 +720,7 @@ void Map::updateLighting(enum LightBank bank,
 					<<pos.X<<","<<pos.Y<<","<<pos.Z<<") not valid"
 					<<std::endl;*/
 
-			// Else get the block below and loop to it
+			// Bottom sunlight is not valid; get the block and loop to it
 
 			pos.Y--;
 			try{
@@ -720,9 +733,10 @@ void Map::updateLighting(enum LightBank bank,
 			
 		}
 	}
-	
+
+#if 0
 	{
-		//TimeTaker timer("unspreadLight");
+		TimeTaker timer("unspreadLight");
 		unspreadLight(bank, unlight_from, light_sources, modified_blocks);
 	}
 	
@@ -733,15 +747,8 @@ void Map::updateLighting(enum LightBank bank,
 		dstream<<"unspreadLight modified "<<diff<<std::endl;
 	}
 
-	// TODO: Spread light from propagated sunlight?
-	// Yes, add it to light_sources... somehow.
-	// It has to be added at somewhere above, in the loop.
-	// TODO
-	// NOTE: This actually works fine without doing so
-	//       - Find out why it works
-
 	{
-		//TimeTaker timer("spreadLight");
+		TimeTaker timer("spreadLight");
 		spreadLight(bank, light_sources, modified_blocks);
 	}
 	
@@ -751,6 +758,63 @@ void Map::updateLighting(enum LightBank bank,
 		count_was = modified_blocks.size();
 		dstream<<"spreadLight modified "<<diff<<std::endl;
 	}
+#endif
+	
+	{
+		//MapVoxelManipulator vmanip(this);
+		
+		// Make a manual voxel manipulator and load all the blocks
+		// that touch the requested blocks
+		ManualMapVoxelManipulator vmanip(this);
+		core::map<v3s16, MapBlock*>::Iterator i;
+		i = blocks_to_update.getIterator();
+		for(; i.atEnd() == false; i++)
+		{
+			MapBlock *block = i.getNode()->getValue();
+			v3s16 p = block->getPos();
+			
+			// Add all surrounding blocks
+			vmanip.initialEmerge(p - v3s16(1,1,1), p + v3s16(1,1,1));
+
+			/*
+				Add all surrounding blocks that have up-to-date lighting
+				NOTE: This doesn't quite do the job (not everything
+				      appropriate is lighted)
+			*/
+			/*for(s16 z=-1; z<=1; z++)
+			for(s16 y=-1; y<=1; y++)
+			for(s16 x=-1; x<=1; x++)
+			{
+				v3s16 p(x,y,z);
+				MapBlock *block = getBlockNoCreateNoEx(p);
+				if(block == NULL)
+					continue;
+				if(block->isDummy())
+					continue;
+				if(block->getLightingExpired())
+					continue;
+				vmanip.initialEmerge(p, p);
+			}*/
+			
+			// Lighting of block will be updated completely
+			block->setLightingExpired(false);
+		}
+
+		{
+			//TimeTaker timer("unSpreadLight");
+			vmanip.unspreadLight(bank, unlight_from, light_sources);
+		}
+		{
+			//TimeTaker timer("spreadLight");
+			vmanip.spreadLight(bank, light_sources);
+		}
+		{
+			//TimeTaker timer("blitBack");
+			vmanip.blitBack(modified_blocks);
+		}
+		/*dstream<<"emerge_time="<<emerge_time<<std::endl;
+		emerge_time = 0;*/
+	}
 
 	//m_dout<<"Done ("<<getTimestamp()<<")"<<std::endl;
 }
@@ -778,15 +842,13 @@ void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
 	The lighting value of the node should be left as-is after changing
 	other values. This sets the lighting value to 0.
 */
-/*void Map::nodeAddedUpdate(v3s16 p, u8 lightwas,
-		core::map<v3s16, MapBlock*> &modified_blocks)*/
 void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 		core::map<v3s16, MapBlock*> &modified_blocks)
 {
 	/*PrintInfo(m_dout);
-	m_dout<<DTIME<<"Map::nodeAddedUpdate(): p=("
+	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
@@ -816,11 +878,12 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 	{
 	}
 	
-	if(n.d != CONTENT_TORCH)
+	/*
+		If the new node doesn't propagate sunlight and there is
+		grass below, change it to mud
+	*/
+	if(content_features(n.d).sunlight_propagates == false)
 	{
-		/*
-			If there is grass below, change it to mud
-		*/
 		try{
 			MapNode bottomnode = getNode(bottompos);
 			
@@ -836,6 +899,19 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 		}
 	}
 
+	/*
+		If the new node is mud and it is under sunlight, change it
+		to grass
+	*/
+	if(n.d == CONTENT_MUD && node_under_sunlight)
+	{
+		n.d = CONTENT_GRASS;
+	}
+
+	/*
+		Remove all light that has come out of this node
+	*/
+
 	enum LightBank banks[] =
 	{
 		LIGHTBANK_DAY,
@@ -853,8 +929,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 		assert(block != NULL);
 		modified_blocks.insert(blockpos, block);
 		
-		if(isValidPosition(p) == false)
-			throw;
+		assert(isValidPosition(p));
 			
 		// Unlight neighbours of node.
 		// This means setting light of all consequent dimmer nodes
@@ -865,17 +940,41 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 
 		n.setLight(bank, 0);
 	}
+
+	/*
+		If node lets sunlight through and is under sunlight, it has
+		sunlight too.
+	*/
+	if(node_under_sunlight && content_features(n.d).sunlight_propagates)
+	{
+		n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
+	}
+	
+	/*
+		Set the node on the map
+	*/
 	
 	setNode(p, n);
+
+	/*
+		Add intial metadata
+	*/
+
+	NodeMetadata *meta_proto = content_features(n.d).initial_metadata;
+	if(meta_proto)
+	{
+		NodeMetadata *meta = meta_proto->clone();
+		setNodeMetadata(p, meta);
+	}
 	
 	/*
-		If node is under sunlight, take all sunlighted nodes under
-		it and clear light from them and from where the light has
-		been spread.
+		If node is under sunlight and doesn't let sunlight through,
+		take all sunlighted nodes under it and clear light from them
+		and from where the light has been spread.
 		TODO: This could be optimized by mass-unlighting instead
 		      of looping
 	*/
-	if(node_under_sunlight)
+	if(node_under_sunlight && !content_features(n.d).sunlight_propagates)
 	{
 		s16 y = p.Y - 1;
 		for(;; y--){
@@ -893,7 +992,6 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 
 			if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN)
 			{
-				//m_dout<<DTIME<<"doing"<<std::endl;
 				unLightNeighbors(LIGHTBANK_DAY,
 						n2pos, n2.getLight(LIGHTBANK_DAY),
 						light_sources, modified_blocks);
@@ -904,14 +1002,13 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 				break;
 		}
 	}
-	
+
 	for(s32 i=0; i<2; i++)
 	{
 		enum LightBank bank = banks[i];
 		
 		/*
 			Spread light from all nodes that might be capable of doing so
-			TODO: Convert to spreadLight
 		*/
 		spreadLight(bank, light_sources, modified_blocks);
 	}
@@ -1008,6 +1105,12 @@ void Map::removeNodeAndUpdate(v3s16 p,
 				light_sources, modified_blocks);
 	}
 
+	/*
+		Remove node metadata
+	*/
+
+	removeNodeMetadata(p);
+
 	/*
 		Remove the node.
 		This also clears the lighting.
@@ -1065,7 +1168,7 @@ void Map::removeNodeAndUpdate(v3s16 p,
 		}
 		catch(InvalidPositionException &e)
 		{
-			throw;
+			assert(0);
 		}
 	}
 
@@ -1125,94 +1228,62 @@ void Map::removeNodeAndUpdate(v3s16 p,
 	}
 }
 
-#ifndef SERVER
-void Map::expireMeshes(bool only_daynight_diffed)
+bool Map::addNodeWithEvent(v3s16 p, MapNode n)
 {
-	TimeTaker timer("expireMeshes()");
+	MapEditEvent event;
+	event.type = MEET_ADDNODE;
+	event.p = p;
+	event.n = n;
 
-	core::map<v2s16, MapSector*>::Iterator si;
-	si = m_sectors.getIterator();
-	for(; si.atEnd() == false; si++)
-	{
-		MapSector *sector = si.getNode()->getValue();
+	bool succeeded = true;
+	try{
+		core::map<v3s16, MapBlock*> modified_blocks;
+		addNodeAndUpdate(p, n, modified_blocks);
 
-		core::list< MapBlock * > sectorblocks;
-		sector->getBlocks(sectorblocks);
-		
-		core::list< MapBlock * >::Iterator i;
-		for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
+		// Copy modified_blocks to event
+		for(core::map<v3s16, MapBlock*>::Iterator
+				i = modified_blocks.getIterator();
+				i.atEnd()==false; i++)
 		{
-			MapBlock *block = *i;
-
-			if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false)
-			{
-				continue;
-			}
-			
-			{
-				JMutexAutoLock lock(block->mesh_mutex);
-				if(block->mesh != NULL)
-				{
-					/*block->mesh->drop();
-					block->mesh = NULL;*/
-					block->setMeshExpired(true);
-				}
-			}
+			event.modified_blocks.insert(i.getNode()->getKey(), false);
 		}
 	}
+	catch(InvalidPositionException &e){
+		succeeded = false;
+	}
+
+	dispatchEvent(&event);
+
+	return succeeded;
 }
 
-void Map::updateMeshes(v3s16 blockpos, u32 daynight_ratio)
+bool Map::removeNodeWithEvent(v3s16 p)
 {
-	assert(mapType() == MAPTYPE_CLIENT);
+	MapEditEvent event;
+	event.type = MEET_REMOVENODE;
+	event.p = p;
 
+	bool succeeded = true;
 	try{
-		v3s16 p = blockpos + v3s16(0,0,0);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
-	}
-	catch(InvalidPositionException &e){}
-	// Leading edge
-	try{
-		v3s16 p = blockpos + v3s16(-1,0,0);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
-	}
-	catch(InvalidPositionException &e){}
-	try{
-		v3s16 p = blockpos + v3s16(0,-1,0);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
-	}
-	catch(InvalidPositionException &e){}
-	try{
-		v3s16 p = blockpos + v3s16(0,0,-1);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
-	}
-	catch(InvalidPositionException &e){}
-	/*// Trailing edge
-	try{
-		v3s16 p = blockpos + v3s16(1,0,0);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
-	}
-	catch(InvalidPositionException &e){}
-	try{
-		v3s16 p = blockpos + v3s16(0,1,0);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
+		core::map<v3s16, MapBlock*> modified_blocks;
+		removeNodeAndUpdate(p, modified_blocks);
+
+		// Copy modified_blocks to event
+		for(core::map<v3s16, MapBlock*>::Iterator
+				i = modified_blocks.getIterator();
+				i.atEnd()==false; i++)
+		{
+			event.modified_blocks.insert(i.getNode()->getKey(), false);
+		}
 	}
-	catch(InvalidPositionException &e){}
-	try{
-		v3s16 p = blockpos + v3s16(0,0,1);
-		MapBlock *b = getBlockNoCreate(p);
-		b->updateMesh(daynight_ratio);
+	catch(InvalidPositionException &e){
+		succeeded = false;
 	}
-	catch(InvalidPositionException &e){}*/
-}
 
-#endif
+	dispatchEvent(&event);
+
+	return succeeded;
+}
 
 bool Map::dayNightDiffed(v3s16 blockpos)
 {
@@ -1276,7 +1347,7 @@ bool Map::dayNightDiffed(v3s16 blockpos)
 */
 void Map::timerUpdate(float dtime)
 {
-	JMutexAutoLock lock(m_sector_mutex);
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 
 	core::map<v2s16, MapSector*>::Iterator si;
 
@@ -1326,7 +1397,7 @@ void Map::deleteSectors(core::list<v2s16> &list, bool only_blocks)
 u32 Map::deleteUnusedSectors(float timeout, bool only_blocks,
 		core::list<v3s16> *deleted_blocks)
 {
-	JMutexAutoLock lock(m_sector_mutex);
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 
 	core::list<v2s16> sector_deletion_queue;
 	core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
@@ -1372,6 +1443,9 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 
 	u32 loopcount = 0;
 	u32 initial_size = m_transforming_liquid.size();
+	
+	/*if(initial_size != 0)
+		dstream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
 
 	while(m_transforming_liquid.size() != 0)
 	{
@@ -1624,7 +1698,7 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 			}
 			
 			// If n2_changed to bottom, don't flow anywhere else
-			if(to_bottom && flowed)
+			if(to_bottom && flowed && !is_source)
 				break;
 				
 			}catch(InvalidPositionException &e)
@@ -1640,185 +1714,110 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 	//dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
 }
 
+NodeMetadata* Map::getNodeMetadata(v3s16 p)
+{
+	v3s16 blockpos = getNodeBlockPos(p);
+	v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+	MapBlock *block = getBlockNoCreateNoEx(blockpos);
+	if(block == NULL)
+	{
+		dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+				<<std::endl;
+		return NULL;
+	}
+	NodeMetadata *meta = block->m_node_metadata.get(p_rel);
+	return meta;
+}
+
+void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
+{
+	v3s16 blockpos = getNodeBlockPos(p);
+	v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+	MapBlock *block = getBlockNoCreateNoEx(blockpos);
+	if(block == NULL)
+	{
+		dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+				<<std::endl;
+		return;
+	}
+	block->m_node_metadata.set(p_rel, meta);
+}
+
+void Map::removeNodeMetadata(v3s16 p)
+{
+	v3s16 blockpos = getNodeBlockPos(p);
+	v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+	MapBlock *block = getBlockNoCreateNoEx(blockpos);
+	if(block == NULL)
+	{
+		dstream<<"WARNING: Map::removeNodeMetadata(): Block not found"
+				<<std::endl;
+		return;
+	}
+	block->m_node_metadata.remove(p_rel);
+}
+
+void Map::nodeMetadataStep(float dtime,
+		core::map<v3s16, MapBlock*> &changed_blocks)
+{
+	/*
+		NOTE:
+		Currently there is no way to ensure that all the necessary
+		blocks are loaded when this is run. (They might get unloaded)
+		NOTE: ^- Actually, that might not be so. In a quick test it
+		reloaded a block with a furnace when I walked back to it from
+		a distance.
+	*/
+	core::map<v2s16, MapSector*>::Iterator si;
+	si = m_sectors.getIterator();
+	for(; si.atEnd() == false; si++)
+	{
+		MapSector *sector = si.getNode()->getValue();
+		core::list< MapBlock * > sectorblocks;
+		sector->getBlocks(sectorblocks);
+		core::list< MapBlock * >::Iterator i;
+		for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
+		{
+			MapBlock *block = *i;
+			bool changed = block->m_node_metadata.step(dtime);
+			if(changed)
+				changed_blocks[block->getPos()] = block;
+		}
+	}
+}
+
 /*
 	ServerMap
 */
 
-ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
+ServerMap::ServerMap(std::string savedir):
 	Map(dout_server),
-	m_heightmap(NULL)
+	m_seed(0),
+	m_map_metadata_changed(true)
 {
+	dstream<<__FUNCTION_NAME<<std::endl;
+	
+	//m_chunksize = 64;
+	//m_chunksize = 16; // Too slow
+	m_chunksize = 8; // Takes a few seconds
+	//m_chunksize = 4;
+	//m_chunksize = 2;
+	
+	m_seed = (((u64)(myrand()%0xffff)<<0)
+			+ ((u64)(myrand()%0xffff)<<16)
+			+ ((u64)(myrand()%0xffff)<<32)
+			+ ((u64)(myrand()%0xffff)<<48));
+
 	/*
 		Experimental and debug stuff
 	*/
 	
 	{
-		dstream<<"Generating map point attribute lists"<<std::endl;
-		
-		PointAttributeList *list_baseheight = m_padb.getList("hm_baseheight");
-		PointAttributeList *list_randmax = m_padb.getList("hm_randmax");
-		PointAttributeList *list_randfactor = m_padb.getList("hm_randfactor");
-		PointAttributeList *list_plants_amount = m_padb.getList("plants_amount");
-		PointAttributeList *list_caves_amount = m_padb.getList("caves_amount");
-
-		/*
-			NOTE: BEWARE: Too big amount of these will make map generation
-			slow. Especially those that are read by every block emerge.
-			
-			Fetch times:
-			1000 points: 2-3ms
-			5000 points: 15ms
-			15000 points: 40ms
-		*/
-		
-		for(u32 i=0; i<5000; i++)
-		{
-			/*u32 lim = MAP_GENERATION_LIMIT;
-			if(i < 400)
-				lim = 2000;*/
-
-			u32 lim = 1000 + MAP_GENERATION_LIMIT * i / 5000;
-
-			v3s16 p(
-				-lim + myrand()%(lim*2),
-				0,
-				-lim + myrand()%(lim*2)
-			);
-			/*float plants_amount = (float)(myrand()%1050) / 1000.0;
-			plants_amount = pow(plants_amount, 5);
-			list_plants_amount->addPoint(p, Attribute(plants_amount));*/
-			
-			float plants_amount = 0;
-			if(myrand()%4 == 0)
-			{
-				plants_amount = 1.5;
-			}
-			else if(myrand()%4 == 0)
-			{
-				plants_amount = 0.5;
-			}
-			else if(myrand()%2 == 0)
-			{
-				plants_amount = 0.03;
-			}
-			else
-			{
-				plants_amount = 0.0;
-			}
-
-
-			list_plants_amount->addPoint(p, Attribute(plants_amount));
-		}
-
-		for(u32 i=0; i<1000; i++)
-		{
-			/*u32 lim = MAP_GENERATION_LIMIT;
-			if(i < 400)
-				lim = 2000;*/
-
-			u32 lim = 500 + MAP_GENERATION_LIMIT * i / 1000;
-
-			v3s16 p(
-				-lim + myrand()%(lim*2),
-				0,
-				-lim + myrand()%(lim*2)
-			);
-
-			float caves_amount = 0;
-			if(myrand()%5 == 0)
-			{
-				caves_amount = 1.0;
-			}
-			else if(myrand()%3 == 0)
-			{
-				caves_amount = 0.3;
-			}
-			else
-			{
-				caves_amount = 0.05;
-			}
-
-			list_caves_amount->addPoint(p, Attribute(caves_amount));
-		}
-		
-		for(u32 i=0; i<5000; i++)
-		{
-			/*u32 lim = MAP_GENERATION_LIMIT;
-			if(i < 400)
-				lim = 2000;*/
-
-			u32 lim = 1000 + MAP_GENERATION_LIMIT * i / 5000;
-
-			v3s16 p(
-				-lim + (myrand()%(lim*2)),
-				0,
-				-lim + (myrand()%(lim*2))
-			);
-			
-			/*s32 bh_i = (myrand()%200) - 50;
-			float baseheight = (float)bh_i;
-			
-			float m = 100.;
-			float e = 3.;
-			float randmax = (float)(myrand()%(int)(10.*pow(m, 1./e)))/10.;
-			randmax = pow(randmax, e);
-
-			//float randmax = (float)(myrand()%60);
-			float randfactor = (float)(myrand()%450) / 1000.0 + 0.4;*/
-
-			float baseheight = 0;
-			float randmax = 0;
-			float randfactor = 0;
-
-			if(myrand()%4 == 0)
-			{
-				baseheight = 100;
-				randmax = 50;
-				randfactor = 0.63;
-			}
-			else if(myrand()%6 == 0)
-			{
-				baseheight = 200;
-				randmax = 100;
-				randfactor = 0.66;
-			}
-			else if(myrand()%4 == 0)
-			{
-				baseheight = -3;
-				randmax = 30;
-				randfactor = 0.7;
-			}
-			else if(myrand()%3 == 0)
-			{
-				baseheight = 0;
-				randmax = 30;
-				randfactor = 0.63;
-			}
-			else
-			{
-				baseheight = -3;
-				randmax = 20;
-				randfactor = 0.5;
-			}
-
-			list_baseheight->addPoint(p, Attribute(baseheight));
-			list_randmax->addPoint(p, Attribute(randmax));
-			list_randfactor->addPoint(p, Attribute(randfactor));
-		}
-
-		/*list_baseheight->addPoint(v3s16(0,0,0), Attribute(5));
-		list_randmax->addPoint(v3s16(0,0,0), Attribute(20));
-		list_randfactor->addPoint(v3s16(0,0,0), Attribute(0.6));*/
-
-		// Easy spawn point
-		/*list_baseheight->addPoint(v3s16(0,0,0), Attribute(0));
-		list_randmax->addPoint(v3s16(0,0,0), Attribute(10));
-		list_randfactor->addPoint(v3s16(0,0,0), Attribute(0.65));*/
-	}
-
-	/*
-		Try to load map; if not found, create a new one.
-	*/
+	}
+	
+	/*
+		Try to load map; if not found, create a new one.
+	*/
 
 	m_savedir = savedir;
 	m_map_saving_enabled = false;
@@ -1837,16 +1836,32 @@ ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
 			}
 			else
 			{
-				// Load master heightmap
-				loadMasterHeightmap();
-				
-				// Load sector (0,0) and throw and exception on fail
+				try{
+					// Load map metadata (seed, chunksize)
+					loadMapMeta();
+
+					// Load chunk metadata
+					loadChunkMeta();
+				}
+				catch(FileNotGoodException &e){
+					dstream<<DTIME<<"WARNING: Server: Could not load "
+							<<"metafile(s). Disabling chunk-based "
+							<<"generation."<<std::endl;
+					m_chunksize = 0;
+				}
+			
+				/*// Load sector (0,0) and throw and exception on fail
 				if(loadSectorFull(v2s16(0,0)) == false)
-					throw LoadError("Failed to load sector (0,0)");
+					throw LoadError("Failed to load sector (0,0)");*/
 
-				dstream<<DTIME<<"Server: Successfully loaded master "
-						"heightmap and sector (0,0) from "<<savedir<<
+				/*dstream<<DTIME<<"Server: Successfully loaded chunk "
+						"metadata and sector (0,0) from "<<savedir<<
 						", assuming valid save directory."
+						<<std::endl;*/
+
+				dstream<<DTIME<<"INFO: Server: Successfully loaded map "
+						<<"and chunk metadata from "<<savedir
+						<<", assuming valid save directory."
 						<<std::endl;
 
 				m_map_saving_enabled = true;
@@ -1861,32 +1876,13 @@ ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
 	}
 	catch(std::exception &e)
 	{
-		dstream<<DTIME<<"Server: Failed to load map from "<<savedir
+		dstream<<DTIME<<"WARNING: Server: Failed to load map from "<<savedir
 				<<", exception: "<<e.what()<<std::endl;
-		dstream<<DTIME<<"Please remove the map or fix it."<<std::endl;
-		dstream<<DTIME<<"WARNING: Map saving will be disabled."<<std::endl;
+		dstream<<"Please remove the map or fix it."<<std::endl;
+		dstream<<"WARNING: Map saving will be disabled."<<std::endl;
 	}
 
-	dstream<<DTIME<<"Initializing new map."<<std::endl;
-	
-	// Create master heightmap
-	/*ValueGenerator *maxgen =
-			ValueGenerator::deSerialize(hmp.randmax);
-	ValueGenerator *factorgen =
-			ValueGenerator::deSerialize(hmp.randfactor);
-	ValueGenerator *basegen =
-			ValueGenerator::deSerialize(hmp.base);
-	m_heightmap = new UnlimitedHeightmap
-			(hmp.blocksize, maxgen, factorgen, basegen, &m_padb);*/
-
-	/*m_heightmap = new UnlimitedHeightmap
-			(hmp.blocksize, &m_padb);*/
-
-	m_heightmap = new UnlimitedHeightmap
-			(32, &m_padb);
-	
-	// Set map parameters
-	m_params = mp;
+	dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;
 	
 	// Create zero sector
 	emergeSector(v2s16(0,0));
@@ -1897,6 +1893,8 @@ ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
 
 ServerMap::~ServerMap()
 {
+	dstream<<__FUNCTION_NAME<<std::endl;
+	
 	try
 	{
 		if(m_map_saving_enabled)
@@ -1917,327 +1915,2104 @@ ServerMap::~ServerMap()
 				<<", exception: "<<e.what()<<std::endl;
 	}
 	
-	if(m_heightmap != NULL)
-		delete m_heightmap;
+	/*
+		Free all MapChunks
+	*/
+	core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
+	for(; i.atEnd() == false; i++)
+	{
+		MapChunk *chunk = i.getNode()->getValue();
+		delete chunk;
+	}
 }
 
-MapSector * ServerMap::emergeSector(v2s16 p2d)
+/*
+	Some helper functions for the map generator
+*/
+
+s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d)
 {
-	DSTACK("%s: p2d=(%d,%d)",
-			__FUNCTION_NAME,
-			p2d.X, p2d.Y);
-	// Check that it doesn't exist already
-	try{
-		return getSectorNoGenerate(p2d);
+	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(content_walkable(n.d))
+			break;
+			
+		vmanip.m_area.add_y(em, i, -1);
 	}
-	catch(InvalidPositionException &e)
+	if(y >= y_nodes_min)
+		return y;
+	else
+		return y_nodes_min;
+}
+
+s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d)
+{
+	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(content_walkable(n.d)
+				&& n.d != CONTENT_TREE
+				&& n.d != CONTENT_LEAVES)
+			break;
+			
+		vmanip.m_area.add_y(em, i, -1);
+	}
+	if(y >= y_nodes_min)
+		return y;
+	else
+		return y_nodes_min;
+}
+
+void make_tree(VoxelManipulator &vmanip, v3s16 p0)
+{
+	MapNode treenode(CONTENT_TREE);
+	MapNode leavesnode(CONTENT_LEAVES);
+
+	s16 trunk_h = myrand_range(3, 6);
+	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++;
 	}
 	
-	/*
-		Try to load the sector from disk.
-	*/
-	if(loadSectorFull(p2d) == true)
+	// p1 is now the last piece of the trunk
+	p1.Y -= 1;
+
+	VoxelArea leaves_a(v3s16(-2,-2,-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
 	{
-		return getSectorNoGenerate(p2d);
+		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;
 
-	/*
-		If there is no master heightmap, throw.
-	*/
-	if(m_heightmap == NULL)
+		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++)
 	{
-		throw InvalidPositionException("emergeSector(): no heightmap");
+		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].d != CONTENT_AIR)
+			continue;
+		u32 i = leaves_a.index(x,y,z);
+		if(leaves_d[i] == 1)
+			vmanip.m_data[vi] = leavesnode;
 	}
+}
 
-	/*
-		Do not generate over-limit
-	*/
-	if(p2d.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p2d.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
-		throw InvalidPositionException("emergeSector(): pos. over limit");
-
-	/*
-		Generate sector and heightmaps
-	*/
-	
-	// Number of heightmaps in sector in each direction
-	u16 hm_split = SECTOR_HEIGHTMAP_SPLIT;
+/*
+	Noise functions. Make sure seed is mangled differently in each one.
+*/
 
-	// Heightmap side width
-	s16 hm_d = MAP_BLOCKSIZE / hm_split;
+// Amount of trees per area in nodes
+double tree_amount_2d(u64 seed, v2s16 p)
+{
+	double noise = noise2d_perlin(
+			0.5+(float)p.X/250, 0.5+(float)p.Y/250,
+			seed+2, 5, 0.66);
+	double zeroval = -0.3;
+	if(noise < zeroval)
+		return 0;
+	else
+		return 0.04 * (noise-zeroval) / (1.0-zeroval);
+}
 
-	ServerMapSector *sector = new ServerMapSector(this, p2d, hm_split);
-	
-	// Sector position on map in nodes
-	v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
+#define AVERAGE_MUD_AMOUNT 4
 
-	/*dstream<<"Generating sector ("<<p2d.X<<","<<p2d.Y<<")"
-			" heightmaps and objects"<<std::endl;*/
+double base_rock_level_2d(u64 seed, v2s16 p)
+{
+	// The base ground level
+	double base = (double)WATER_LEVEL - (double)AVERAGE_MUD_AMOUNT
+			+ 20. * noise2d_perlin(
+			0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+			(seed>>32)+654879876, 6, 0.6);
 	
-	/*
-		Calculate some information about local properties
-	*/
+	/*// A bit hillier one
+	double base2 = WATER_LEVEL - 4.0 + 40. * noise2d_perlin(
+			0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+			(seed>>27)+90340, 6, 0.69);
+	if(base2 > base)
+		base = base2;*/
+#if 1
+	// Higher ground level
+	double higher = (double)WATER_LEVEL + 25. + 35. * noise2d_perlin(
+			0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+			seed+85039, 5, 0.69);
+	//higher = 30; // For debugging
+
+	// Limit higher to at least base
+	if(higher < base)
+		higher = base;
+		
+	// Steepness factor of cliffs
+	double b = 1.0 + 1.0 * noise2d_perlin(
+			0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+			seed-932, 7, 0.7);
+	b = rangelim(b, 0.0, 1000.0);
+	b = pow(b, 5);
+	b *= 7;
+	b = rangelim(b, 3.0, 1000.0);
+	//dstream<<"b="<<b<<std::endl;
+	//double b = 20;
+
+	// Offset to more low
+	double a_off = -0.2;
+	// High/low selector
+	/*double a = 0.5 + b * (a_off + noise2d_perlin(
+			0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+			seed-359, 6, 0.7));*/
+	double a = (double)0.5 + b * (a_off + noise2d_perlin(
+			0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+			seed-359, 5, 0.60));
+	// Limit
+	a = rangelim(a, 0.0, 1.0);
+
+	//dstream<<"a="<<a<<std::endl;
 	
-	v2s16 mhm_p = p2d * hm_split;
-	f32 corners[4] = {
-		m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)*hm_split),
-		m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)*hm_split),
-		m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)*hm_split),
-		m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)*hm_split),
-	};
+	double h = base*(1.0-a) + higher*a;
+#else
+	double h = base;
+#endif
+	return h;
+}
+
+double get_mud_add_amount(u64 seed, v2s16 p)
+{
+	return ((float)AVERAGE_MUD_AMOUNT + 3.0 * noise2d_perlin(
+			0.5+(float)p.X/200, 0.5+(float)p.Y/200,
+			seed+91013, 3, 0.55));
+}
+
+/*
+	Adds random objects to block, depending on the content of the block
+*/
+void addRandomObjects(MapBlock *block)
+{
+	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+	{
+		bool last_node_walkable = false;
+		for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+		{
+			v3s16 p(x0,y0,z0);
+			MapNode n = block->getNodeNoEx(p);
+			if(n.d == CONTENT_IGNORE)
+				continue;
+			if(content_features(n.d).liquid_type != LIQUID_NONE)
+				continue;
+			if(content_features(n.d).walkable)
+			{
+				last_node_walkable = true;
+				continue;
+			}
+			if(last_node_walkable)
+			{
+				// If block contains light information
+				if(content_features(n.d).param_type == CPT_LIGHT)
+				{
+					if(n.getLight(LIGHTBANK_DAY) <= 3)
+					{
+						if(myrand() % 300 == 0)
+						{
+							v3f pos_f = intToFloat(p+block->getPosRelative(), BS);
+							pos_f.Y -= BS*0.4;
+							ServerActiveObject *obj = new RatSAO(NULL, 0, pos_f);
+							std::string data = obj->getStaticData();
+							StaticObject s_obj(obj->getType(),
+									obj->getBasePosition(), data);
+							// Add some
+							block->m_static_objects.insert(0, s_obj);
+							block->m_static_objects.insert(0, s_obj);
+							block->m_static_objects.insert(0, s_obj);
+							block->m_static_objects.insert(0, s_obj);
+							block->m_static_objects.insert(0, s_obj);
+							block->m_static_objects.insert(0, s_obj);
+							delete obj;
+						}
+						if(myrand() % 300 == 0)
+						{
+							v3f pos_f = intToFloat(p+block->getPosRelative(), BS);
+							pos_f.Y -= BS*0.4;
+							ServerActiveObject *obj = new Oerkki1SAO(NULL,0,pos_f);
+							std::string data = obj->getStaticData();
+							StaticObject s_obj(obj->getType(),
+									obj->getBasePosition(), data);
+							// Add one
+							block->m_static_objects.insert(0, s_obj);
+							delete obj;
+						}
+					}
+				}
+			}
+			last_node_walkable = false;
+		}
+	}
+	block->setChangedFlag();
+}
+
+#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1
+
+/*
+	This is the main map generation method
+*/
+
+void makeChunk(ChunkMakeData *data)
+{
+	if(data->no_op)
+		return;
 	
-	float avgheight = (corners[0]+corners[1]+corners[2]+corners[3])/4.0;
-	float avgslope = 0.0;
-	avgslope += fabs(avgheight - corners[0]);
-	avgslope += fabs(avgheight - corners[1]);
-	avgslope += fabs(avgheight - corners[2]);
-	avgslope += fabs(avgheight - corners[3]);
-	avgslope /= 4.0;
-	avgslope /= MAP_BLOCKSIZE;
-	//dstream<<"avgslope="<<avgslope<<std::endl;
-
-	float pitness = 0.0;
-	v2f32 a;
-	a = m_heightmap->getSlope(p2d+v2s16(0,0));
-	pitness += -a.X;
-	pitness += -a.Y;
-	a = m_heightmap->getSlope(p2d+v2s16(0,1));
-	pitness += -a.X;
-	pitness += a.Y;
-	a = m_heightmap->getSlope(p2d+v2s16(1,1));
-	pitness += a.X;
-	pitness += a.Y;
-	a = m_heightmap->getSlope(p2d+v2s16(1,0));
-	pitness += a.X;
-	pitness += -a.Y;
-	pitness /= 4.0;
-	pitness /= MAP_BLOCKSIZE;
-	//dstream<<"pitness="<<pitness<<std::endl;
+	s16 y_nodes_min = data->y_blocks_min * MAP_BLOCKSIZE;
+	s16 y_nodes_max = data->y_blocks_max * MAP_BLOCKSIZE + MAP_BLOCKSIZE - 1;
+	s16 h_blocks = data->y_blocks_max - data->y_blocks_min + 1;
+	u32 relative_volume = (u32)data->sectorpos_base_size*MAP_BLOCKSIZE
+			*(u32)data->sectorpos_base_size*MAP_BLOCKSIZE
+			*(u32)h_blocks*MAP_BLOCKSIZE;
+	v3s16 bigarea_blocks_min(
+		data->sectorpos_bigbase.X,
+		data->y_blocks_min,
+		data->sectorpos_bigbase.Y
+	);
+	v3s16 bigarea_blocks_max(
+		data->sectorpos_bigbase.X + data->sectorpos_bigbase_size - 1,
+		data->y_blocks_max,
+		data->sectorpos_bigbase.Y + data->sectorpos_bigbase_size - 1
+	);
+	s16 lighting_min_d = 0-data->max_spread_amount;
+	s16 lighting_max_d = data->sectorpos_base_size*MAP_BLOCKSIZE
+			+ data->max_spread_amount-1;
+
+	// Clear all flags
+	data->vmanip.clearFlag(0xff);
+
+	TimeTaker timer_generate("makeChunk() generate");
+
+	// Maximum height of the stone surface and obstacles.
+	// This is used to disable cave generation from going too high.
+	s16 stone_surface_max_y = 0;
 
 	/*
-		Get local attributes
+		Generate general ground level to full area
 	*/
-	
-	float local_plants_amount = 0.0;
 	{
-		//dstream<<"emergeSector(): Reading point attribute lists"<<std::endl;
-		//TimeTaker attrtimer("emergeSector() attribute fetch");
+	// 22ms @cs=8
+	TimeTaker timer1("Generating ground level");
+
+#if 0
+	NoiseBuffer noisebuf1;
+	//NoiseBuffer noisebuf2;
+	{
+		v3f minpos_f(
+			data->sectorpos_bigbase.X*MAP_BLOCKSIZE,
+			y_nodes_min,
+			data->sectorpos_bigbase.Y*MAP_BLOCKSIZE
+		);
+		v3f maxpos_f = minpos_f + v3f(
+			data->sectorpos_bigbase_size*MAP_BLOCKSIZE,
+			y_nodes_max-y_nodes_min,
+			data->sectorpos_bigbase_size*MAP_BLOCKSIZE
+		);
+		v3f samplelength_f = v3f(4.0, 4.0, 4.0);
+
+		TimeTaker timer("noisebuf.create");
 		
-		// Get plant amount from attributes
-		PointAttributeList *palist = m_padb.getList("plants_amount");
-		assert(palist);
-		/*local_plants_amount =
-				palist->getNearAttr(nodepos2d).getFloat();*/
-		local_plants_amount =
-				palist->getInterpolatedFloat(nodepos2d);
+		noisebuf1.create(data->seed+25104, 6, 0.60, 200.0,
+				minpos_f.X, minpos_f.Y, minpos_f.Z,
+				maxpos_f.X, maxpos_f.Y, maxpos_f.Z,
+				samplelength_f.X, samplelength_f.Y, samplelength_f.Z);
+		/*noisebuf1.create(data->seed+25104, 3, 0.60, 25.0,
+				minpos_f.X, minpos_f.Y, minpos_f.Z,
+				maxpos_f.X, maxpos_f.Y, maxpos_f.Z,
+				samplelength_f.X, samplelength_f.Y, samplelength_f.Z);
+		noisebuf2.create(data->seed+25105, 4, 0.50, 200.0,
+				minpos_f.X, minpos_f.Y, minpos_f.Z,
+				maxpos_f.X, maxpos_f.Y, maxpos_f.Z,
+				samplelength_f.X, samplelength_f.Y, samplelength_f.Z);*/
 	}
 
-	/*
-		Generate sector heightmap
-	*/
+	for(s16 x=0; x<data->sectorpos_bigbase_size*MAP_BLOCKSIZE; x++)
+	for(s16 z=0; z<data->sectorpos_bigbase_size*MAP_BLOCKSIZE; z++)
+	{
+		// Node position
+		v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		// Ground height at this point
+		float surface_y_f = 0.0;
 
-	// Loop through sub-heightmaps
-	for(s16 y=0; y<hm_split; y++)
-	for(s16 x=0; x<hm_split; x++)
-	{
-		v2s16 p_in_sector = v2s16(x,y);
-		v2s16 mhm_p = p2d * hm_split + p_in_sector;
-		f32 corners[4] = {
-			m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)),
-			m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)),
-			m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)),
-			m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)),
-		};
+		// Use perlin noise for ground height
+		surface_y_f = base_rock_level_2d(data->seed, p2d);
+		//surface_y_f = base_rock_level_2d(data->seed, p2d);
+		
+		// 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;
+
+		/*
+			Fill ground with stone
+		*/
+		{
+			// Use fast index incrementing
+			v3s16 em = data->vmanip.m_area.getExtent();
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y));
+			for(s16 y=y_nodes_min; y<=y_nodes_max; y++)
+			{
+				// Skip if already generated.
+				// This is done here because there might be a cave at
+				// any point in ground, which could look like it
+				// wasn't generated.
+				if(data->vmanip.m_data[i].d != CONTENT_AIR)
+					break;
+
+				/*s16 noiseval = 50.0 * noise3d_perlin(
+						0.5+(float)p2d.X/100.0,
+						0.5+(float)y/100.0,
+						0.5+(float)p2d.Y/100.0,
+						data->seed+123, 5, 0.5);*/
+				double noiseval = 64.0 * noisebuf1.get(p2d.X, y, p2d.Y);
+				/*double noiseval = 30.0 * noisebuf1.get(p2d.X, y, p2d.Y);
+				noiseval *= MYMAX(0, -0.2 + noisebuf2.get(p2d.X, y, p2d.Y));*/
+				
+				//if(y < surface_y + noiseval)
+				if(noiseval > 0)
+				//if(noiseval > y)
+					data->vmanip.m_data[i].d = CONTENT_STONE;
+
+				data->vmanip.m_area.add_y(em, i, 1);
+			}
+		}
+	}
+#endif
+	
+#if 1
+	for(s16 x=0; x<data->sectorpos_bigbase_size*MAP_BLOCKSIZE; x++)
+	for(s16 z=0; z<data->sectorpos_bigbase_size*MAP_BLOCKSIZE; z++)
+	{
+		// Node position
+		v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		/*
+			Skip of already generated
+		*/
+		/*{
+			v3s16 p(p2d.X, y_nodes_min, p2d.Y);
+			if(data->vmanip.m_data[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;
+		}*/
 
-		/*dstream<<"p_in_sector=("<<p_in_sector.X<<","<<p_in_sector.Y<<")"
-				<<" mhm_p=("<<mhm_p.X<<","<<mhm_p.Y<<")"
-				<<std::endl;*/
+		// 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;
 
-		FixedHeightmap *hm = new FixedHeightmap(&m_hwrapper,
-				mhm_p, hm_d);
-		sector->setHeightmap(p_in_sector, hm);
+		/*
+			Fill ground with stone
+		*/
+		{
+			// Use fast index incrementing
+			v3s16 em = data->vmanip.m_area.getExtent();
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y));
+			for(s16 y=y_nodes_min; y<surface_y && y<=y_nodes_max; y++)
+			{
+				// Skip if already generated.
+				// This is done here because there might be a cave at
+				// any point in ground, which could look like it
+				// wasn't generated.
+				if(data->vmanip.m_data[i].d != CONTENT_AIR)
+					break;
 
-		//TODO: Make these values configurable
-		//hm->generateContinued(0.0, 0.0, corners);
-		//hm->generateContinued(0.25, 0.2, corners);
-		//hm->generateContinued(0.5, 0.2, corners);
-		//hm->generateContinued(1.0, 0.2, corners);
-		//hm->generateContinued(2.0, 0.2, corners);
-		//hm->generateContinued(2.0 * avgslope, 0.5, corners);
-		hm->generateContinued(avgslope * MAP_BLOCKSIZE/8, 0.5, corners);
+				data->vmanip.m_data[i].d = CONTENT_STONE;
 
-		//hm->print();
+				data->vmanip.m_area.add_y(em, i, 1);
+			}
+		}
 	}
+#endif
+	
+	}//timer1
 
 	/*
-		Generate objects
+		Randomize some parameters
 	*/
 	
-	core::map<v3s16, u8> *objects = new core::map<v3s16, u8>;
-	sector->setObjects(objects);
+	//s32 stone_obstacle_count = 0;
+	/*s32 stone_obstacle_count =
+			rangelim((1.0+noise2d(data->seed+897,
+			data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/
+	
+	//s16 stone_obstacle_max_height = 0;
+	/*s16 stone_obstacle_max_height =
+			rangelim((1.0+noise2d(data->seed+5902,
+			data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/
+
+	/*
+		Loop this part, it will make stuff look older and newer nicely
+	*/
+	const u32 age_loops = 2;
+	for(u32 i_age=0; i_age<age_loops; i_age++)
+	{ // Aging loop
+	/******************************
+		BEGINNING OF AGING LOOP
+	******************************/
 
-	float area = MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+#if 1
+	{
+	// 24ms @cs=8
+	//TimeTaker timer1("caves");
 
 	/*
-		Plant some trees if there is not much slope
+		Make caves
 	*/
+	u32 caves_count = relative_volume / 400000;
+	u32 bruises_count = relative_volume * stone_surface_max_y / 40000000;
+	if(stone_surface_max_y < WATER_LEVEL)
+		bruises_count = 0;
+	/*u32 caves_count = 0;
+	u32 bruises_count = 0;*/
+	for(u32 jj=0; jj<caves_count+bruises_count; jj++)
 	{
-		// Avgslope is the derivative of a hill
-		//float t = avgslope * avgslope;
-		float t = avgslope;
-		float a = area/16 * m_params.plants_amount * local_plants_amount;
-		u32 tree_max;
-		//float something = 0.17*0.17;
-		float something = 0.3;
-		if(t > something)
-			tree_max = a / (t/something);
-		else
-			tree_max = a;
+		s16 min_tunnel_diameter = 3;
+		s16 max_tunnel_diameter = 5;
+		u16 tunnel_routepoints = 20;
 		
-		u32 count = (myrand()%(tree_max+1));
-		//u32 count = tree_max;
-		for(u32 i=0; i<count; i++)
+		v3f main_direction(0,0,0);
+
+		bool bruise_surface = (jj > caves_count);
+
+		if(bruise_surface)
 		{
-			s16 x = (myrand()%(MAP_BLOCKSIZE-2))+1;
-			s16 z = (myrand()%(MAP_BLOCKSIZE-2))+1;
-			s16 y = sector->getGroundHeight(v2s16(x,z))+1;
-			if(y < WATER_LEVEL)
-				continue;
-			objects->insert(v3s16(x, y, z),
-					SECTOR_OBJECT_TREE_1);
+			min_tunnel_diameter = 5;
+			max_tunnel_diameter = myrand_range(10, 20);
+			/*min_tunnel_diameter = MYMAX(0, stone_surface_max_y/6);
+			max_tunnel_diameter = myrand_range(MYMAX(0, stone_surface_max_y/6), MYMAX(0, stone_surface_max_y/2));*/
+			
+			/*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(data->seed+42,
+					data->sectorpos_base.X, data->sectorpos_base.Y)), 0, 15);*/
+
+			tunnel_routepoints = 5;
+		}
+		else
+		{
+		}
+
+		// Allowed route area size in nodes
+		v3s16 ar(
+			data->sectorpos_base_size*MAP_BLOCKSIZE,
+			h_blocks*MAP_BLOCKSIZE,
+			data->sectorpos_base_size*MAP_BLOCKSIZE
+		);
+
+		// Area starting point in nodes
+		v3s16 of(
+			data->sectorpos_base.X*MAP_BLOCKSIZE,
+			data->y_blocks_min*MAP_BLOCKSIZE,
+			data->sectorpos_base.Y*MAP_BLOCKSIZE
+		);
+
+		// Allow a bit more
+		//(this should be more than the maximum radius of the tunnel)
+		//s16 insure = 5; // Didn't work with max_d = 20
+		s16 insure = 10;
+		s16 more = data->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;
+
+		/*// If caves, don't go through surface too often
+		if(bruise_surface == false)
+			route_y_max -= myrand_range(0, max_tunnel_diameter*2);*/
+
+		// Limit maximum to area
+		route_y_max = rangelim(route_y_max, 0, ar.Y-1);
+
+		if(bruise_surface)
+		{
+			/*// Minimum is at y=0
+			route_y_min = -of.Y - 0;*/
+			// Minimum is at y=max_tunnel_diameter/4
+			//route_y_min = -of.Y + max_tunnel_diameter/4;
+			//s16 min = -of.Y + max_tunnel_diameter/4;
+			s16 min = -of.Y + 0;
+			route_y_min = myrand_range(min, min + max_tunnel_diameter);
+			route_y_min = rangelim(route_y_min, 0, route_y_max);
+		}
+
+		/*dstream<<"route_y_min = "<<route_y_min
+				<<", route_y_max = "<<route_y_max<<std::endl;*/
+
+		s16 route_start_y_min = route_y_min;
+		s16 route_start_y_max = route_y_max;
+
+		// Start every 2nd cave from surface
+		bool coming_from_surface = (jj % 2 == 0 && bruise_surface == false);
+
+		if(coming_from_surface)
+		{
+			route_start_y_min = -of.Y + stone_surface_max_y + 10;
+		}
+		
+		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)(myrand()%ar.X)+0.5,
+			(float)(myrand_range(route_start_y_min, route_start_y_max))+0.5,
+			(float)(myrand()%ar.Z)+0.5
+		);
+
+		MapNode airnode(CONTENT_AIR);
+		
+		/*
+			Generate some tunnel starting from orp
+		*/
+		
+		for(u16 j=0; j<tunnel_routepoints; j++)
+		{
+			if(j%7==0 && bruise_surface == false)
+			{
+				main_direction = v3f(
+					((float)(myrand()%20)-(float)10)/10,
+					((float)(myrand()%20)-(float)10)/30,
+					((float)(myrand()%20)-(float)10)/10
+				);
+				main_direction *= (float)myrand_range(1, 3);
+			}
+
+			// Randomize size
+			s16 min_d = min_tunnel_diameter;
+			s16 max_d = max_tunnel_diameter;
+			s16 rs = myrand_range(min_d, max_d);
+			
+			v3s16 maxlen;
+			if(bruise_surface)
+			{
+				maxlen = v3s16(rs*7,rs*7,rs*7);
+			}
+			else
+			{
+				maxlen = v3s16(rs*4, myrand_range(1, rs*3), rs*4);
+			}
+
+			v3f vec;
+			
+			if(coming_from_surface && j < 3)
+			{
+				vec = v3f(
+					(float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
+					(float)(myrand()%(maxlen.Y*1))-(float)maxlen.Y,
+					(float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z
+				);
+			}
+			else
+			{
+				vec = v3f(
+					(float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
+					(float)(myrand()%(maxlen.Y*2))-(float)maxlen.Y,
+					(float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z
+				);
+			}
+			
+			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;
+				v3s16 cp(fp.X, fp.Y, fp.Z);
+
+				s16 d0 = -rs/2;
+				s16 d1 = d0 + rs - 1;
+				for(s16 z0=d0; z0<=d1; z0++)
+				{
+					//s16 si = rs - MYMAX(0, abs(z0)-rs/4);
+					s16 si = rs - MYMAX(0, abs(z0)-rs/7);
+					for(s16 x0=-si; x0<=si-1; x0++)
+					{
+						s16 maxabsxz = MYMAX(abs(x0), abs(z0));
+						//s16 si2 = rs - MYMAX(0, maxabsxz-rs/4);
+						s16 si2 = rs - MYMAX(0, maxabsxz-rs/7);
+						//s16 si2 = rs - abs(x0);
+						for(s16 y0=-si2+1+2; y0<=si2-1; y0++)
+						{
+							s16 z = cp.Z + z0;
+							s16 y = cp.Y + y0;
+							s16 x = cp.X + x0;
+							v3s16 p(x,y,z);
+							/*if(isInArea(p, ar) == false)
+								continue;*/
+							// Check only height
+							if(y < 0 || y >= ar.Y)
+								continue;
+							p += of;
+							
+							//assert(data->vmanip.m_area.contains(p));
+							if(data->vmanip.m_area.contains(p) == false)
+							{
+								dstream<<"WARNING: "<<__FUNCTION_NAME
+										<<":"<<__LINE__<<": "
+										<<"point not in area"
+										<<std::endl;
+								continue;
+							}
+							
+							// Just set it to air, it will be changed to
+							// water afterwards
+							u32 i = data->vmanip.m_area.index(p);
+							data->vmanip.m_data[i] = airnode;
+
+							if(bruise_surface == false)
+							{
+								// Set tunnel flag
+								data->vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON;
+							}
+						}
+					}
+				}
+			}
+
+			orp = rp;
+		}
+	
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 46ms @cs=8
+	//TimeTaker timer1("ore veins");
+
+	/*
+		Make ore veins
+	*/
+	for(u32 jj=0; jj<relative_volume/1000; jj++)
+	{
+		s16 max_vein_diameter = 3;
+
+		// Allowed route area size in nodes
+		v3s16 ar(
+			data->sectorpos_base_size*MAP_BLOCKSIZE,
+			h_blocks*MAP_BLOCKSIZE,
+			data->sectorpos_base_size*MAP_BLOCKSIZE
+		);
+
+		// Area starting point in nodes
+		v3s16 of(
+			data->sectorpos_base.X*MAP_BLOCKSIZE,
+			data->y_blocks_min*MAP_BLOCKSIZE,
+			data->sectorpos_base.Y*MAP_BLOCKSIZE
+		);
+
+		// Allow a bit more
+		//(this should be more than the maximum radius of the tunnel)
+		s16 insure = 3;
+		s16 more = data->max_spread_amount - max_vein_diameter/2 - insure;
+		ar += v3s16(1,0,1) * more * 2;
+		of -= v3s16(1,0,1) * more;
+		
+		// Randomize starting position
+		v3f orp(
+			(float)(myrand()%ar.X)+0.5,
+			(float)(myrand()%ar.Y)+0.5,
+			(float)(myrand()%ar.Z)+0.5
+		);
+
+		// Randomize mineral
+		u8 mineral;
+		if(myrand()%3 != 0)
+			mineral = MINERAL_COAL;
+		else
+			mineral = MINERAL_IRON;
+
+		/*
+			Generate some vein starting from orp
+		*/
+
+		for(u16 j=0; j<2; j++)
+		{
+			/*v3f rp(
+				(float)(myrand()%ar.X)+0.5,
+				(float)(myrand()%ar.Y)+0.5,
+				(float)(myrand()%ar.Z)+0.5
+			);
+			v3f vec = rp - orp;*/
+			
+			v3s16 maxlen(5, 5, 5);
+			v3f vec(
+				(float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
+				(float)(myrand()%(maxlen.Y*2))-(float)maxlen.Y,
+				(float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z
+			);
+			v3f rp = orp + vec;
+			if(rp.X < 0)
+				rp.X = 0;
+			else if(rp.X >= ar.X)
+				rp.X = ar.X;
+			if(rp.Y < 0)
+				rp.Y = 0;
+			else if(rp.Y >= ar.Y)
+				rp.Y = ar.Y;
+			if(rp.Z < 0)
+				rp.Z = 0;
+			else if(rp.Z >= ar.Z)
+				rp.Z = ar.Z;
+			vec = rp - orp;
+
+			// Randomize size
+			s16 min_d = 0;
+			s16 max_d = max_vein_diameter;
+			s16 rs = myrand_range(min_d, max_d);
+			
+			for(float f=0; f<1.0; f+=1.0/vec.getLength())
+			{
+				v3f fp = orp + vec * f;
+				v3s16 cp(fp.X, fp.Y, fp.Z);
+				s16 d0 = -rs/2;
+				s16 d1 = d0 + rs - 1;
+				for(s16 z0=d0; z0<=d1; z0++)
+				{
+					s16 si = rs - abs(z0);
+					for(s16 x0=-si; x0<=si-1; x0++)
+					{
+						s16 si2 = rs - abs(x0);
+						for(s16 y0=-si2+1; y0<=si2-1; y0++)
+						{
+							// Don't put mineral to every place
+							if(myrand()%5 != 0)
+								continue;
+
+							s16 z = cp.Z + z0;
+							s16 y = cp.Y + y0;
+							s16 x = cp.X + x0;
+							v3s16 p(x,y,z);
+							/*if(isInArea(p, ar) == false)
+								continue;*/
+							// Check only height
+							if(y < 0 || y >= ar.Y)
+								continue;
+							p += of;
+							
+							assert(data->vmanip.m_area.contains(p));
+							
+							// Just set it to air, it will be changed to
+							// water afterwards
+							u32 i = data->vmanip.m_area.index(p);
+							MapNode *n = &data->vmanip.m_data[i];
+							if(n->d == CONTENT_STONE)
+								n->param = mineral;
+						}
+					}
+				}
+			}
+
+			orp = rp;
+		}
+	
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 15ms @cs=8
+	TimeTaker timer1("add mud");
+
+	/*
+		Add mud to the central chunk
+	*/
+	
+	for(s16 x=0; x<data->sectorpos_base_size*MAP_BLOCKSIZE; x++)
+	for(s16 z=0; z<data->sectorpos_base_size*MAP_BLOCKSIZE; z++)
+	{
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		// Randomize mud amount
+		s16 mud_add_amount = get_mud_add_amount(data->seed, p2d) / 2.0;
+
+		// Find ground level
+		s16 surface_y = find_ground_level_clever(data->vmanip, p2d);
+
+		/*
+			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 = data->vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y));
+			MapNode *n = &data->vmanip.m_data[i];
+			if(n->d == CONTENT_GRASS)
+				*n = MapNode(CONTENT_MUD);
+				//n->d = CONTENT_MUD;
+		}
+
+		/*
+			Add mud on ground
+		*/
+		{
+			s16 mudcount = 0;
+			v3s16 em = data->vmanip.m_area.getExtent();
+			s16 y_start = surface_y+1;
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			for(s16 y=y_start; y<=y_nodes_max; y++)
+			{
+				if(mudcount >= mud_add_amount)
+					break;
+					
+				MapNode &n = data->vmanip.m_data[i];
+				n = MapNode(CONTENT_MUD);
+				//n.d = CONTENT_MUD;
+				mudcount++;
+
+				data->vmanip.m_area.add_y(em, i, 1);
+			}
+		}
+
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 340ms @cs=8
+	TimeTaker timer1("flow mud");
+
+	/*
+		Flow mud away from steep edges
+	*/
+
+	// Limit area by 1 because mud is flown into neighbors.
+	s16 mudflow_minpos = 0-data->max_spread_amount+1;
+	s16 mudflow_maxpos = data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-2;
+
+	// 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 = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		v3s16 em = data->vmanip.m_area.getExtent();
+		u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+		s16 y=y_nodes_max;
+
+		for(;; y--)
+		{
+			MapNode *n = NULL;
+			// Find mud
+			for(; y>=y_nodes_min; y--)
+			{
+				n = &data->vmanip.m_data[i];
+				//if(content_walkable(n->d))
+				//	break;
+				if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS)
+					break;
+					
+				data->vmanip.m_area.add_y(em, i, -1);
+			}
+
+			// Stop if out of area
+			//if(data->vmanip.m_area.contains(i) == false)
+			if(y < y_nodes_min)
+				break;
+
+			/*// If not mud, do nothing to it
+			MapNode *n = &data->vmanip.m_data[i];
+			if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+				continue;*/
+
+			/*
+				Don't flow it if the stuff under it is not mud
+			*/
+			{
+				u32 i2 = i;
+				data->vmanip.m_area.add_y(em, i2, -1);
+				// Cancel if out of area
+				if(data->vmanip.m_area.contains(i2) == false)
+					continue;
+				MapNode *n2 = &data->vmanip.m_data[i2];
+				if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS)
+					continue;
+			}
+
+			// Make it exactly mud
+			n->d = CONTENT_MUD;
+			
+			/*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;
+			data->vmanip.m_area.add_y(em, i3, 1);
+			if(data->vmanip.m_area.contains(i3) == true
+					&& content_walkable(data->vmanip.m_data[i3].d) == true)
+			{
+				continue;
+			}
+
+			// Drop mud on side
+			
+			for(u32 di=0; di<4; di++)
+			{
+				v3s16 dirp = dirs4[di];
+				u32 i2 = i;
+				// Move to side
+				data->vmanip.m_area.add_p(em, i2, dirp);
+				// Fail if out of area
+				if(data->vmanip.m_area.contains(i2) == false)
+					continue;
+				// Check that side is air
+				MapNode *n2 = &data->vmanip.m_data[i2];
+				if(content_walkable(n2->d))
+					continue;
+				// Check that under side is air
+				data->vmanip.m_area.add_y(em, i2, -1);
+				if(data->vmanip.m_area.contains(i2) == false)
+					continue;
+				n2 = &data->vmanip.m_data[i2];
+				if(content_walkable(n2->d))
+					continue;
+				/*// Check that under that is air (need a drop of 2)
+				data->vmanip.m_area.add_y(em, i2, -1);
+				if(data->vmanip.m_area.contains(i2) == false)
+					continue;
+				n2 = &data->vmanip.m_data[i2];
+				if(content_walkable(n2->d))
+					continue;*/
+				// Loop further down until not air
+				do{
+					data->vmanip.m_area.add_y(em, i2, -1);
+					// Fail if out of area
+					if(data->vmanip.m_area.contains(i2) == false)
+						continue;
+					n2 = &data->vmanip.m_data[i2];
+				}while(content_walkable(n2->d) == false);
+				// Loop one up so that we're in air
+				data->vmanip.m_area.add_y(em, i2, 1);
+				n2 = &data->vmanip.m_data[i2];
+
+				// Move mud to new place
+				*n2 = *n;
+				// Set old place to be air
+				*n = MapNode(CONTENT_AIR);
+
+				// Done
+				break;
+			}
+		}
+	}
+	
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 50ms @cs=8
+	TimeTaker timer1("add water");
+
+	/*
+		Add water to the central chunk (and a bit more)
+	*/
+	
+	for(s16 x=0-data->max_spread_amount;
+			x<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount;
+			x++)
+	for(s16 z=0-data->max_spread_amount;
+			z<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount;
+			z++)
+	{
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		// Find ground level
+		//s16 surface_y = find_ground_level(data->vmanip, p2d);
+
+		/*
+			If ground level is over water level, skip.
+			NOTE: This leaves caves near water without water,
+			which looks especially crappy when the nearby water
+			won't start flowing either for some reason
+		*/
+		/*if(surface_y > WATER_LEVEL)
+			continue;*/
+
+		/*
+			Add water on ground
+		*/
+		{
+			v3s16 em = data->vmanip.m_area.getExtent();
+			u8 light = LIGHT_MAX;
+			// Start at global water surface level
+			s16 y_start = WATER_LEVEL;
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			MapNode *n = &data->vmanip.m_data[i];
+
+			for(s16 y=y_start; y>=y_nodes_min; y--)
+			{
+				n = &data->vmanip.m_data[i];
+				
+				// Stop when there is no water and no air
+				if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE
+						&& n->d != CONTENT_WATER)
+				{
+
+					break;
+				}
+				
+				// Make water only not in caves
+				if(!(data->vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON))
+				{
+					n->d = CONTENT_WATERSOURCE;
+					//n->setLight(LIGHTBANK_DAY, light);
+
+					// Add to transforming liquid queue (in case it'd
+					// start flowing)
+					v3s16 p = v3s16(p2d.X, y, p2d.Y);
+					data->transforming_liquid.push_back(p);
+				}
+				
+				// Next one
+				data->vmanip.m_area.add_y(em, i, -1);
+				if(light > 0)
+					light--;
+			}
+		}
+
+	}
+
+	}//timer1
+#endif
+	
+	} // Aging loop
+	/***********************
+		END OF AGING LOOP
+	************************/
+
+#if 1
+	{
+	//TimeTaker timer1("convert mud to sand");
+
+	/*
+		Convert mud to sand
+	*/
+	
+	//s16 mud_add_amount = myrand_range(2, 4);
+	//s16 mud_add_amount = 0;
+	
+	/*for(s16 x=0; x<data->sectorpos_base_size*MAP_BLOCKSIZE; x++)
+	for(s16 z=0; z<data->sectorpos_base_size*MAP_BLOCKSIZE; z++)*/
+	for(s16 x=0-data->max_spread_amount+1;
+			x<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1;
+			x++)
+	for(s16 z=0-data->max_spread_amount+1;
+			z<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1;
+			z++)
+	{
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		// Determine whether to have sand here
+		double sandnoise = noise2d_perlin(
+				0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500,
+				data->seed+59420, 3, 0.50);
+
+		bool have_sand = (sandnoise > -0.15);
+
+		if(have_sand == false)
+			continue;
+
+		// Find ground level
+		s16 surface_y = find_ground_level_clever(data->vmanip, p2d);
+		
+		if(surface_y > WATER_LEVEL + 2)
+			continue;
+
+		{
+			v3s16 em = data->vmanip.m_area.getExtent();
+			s16 y_start = surface_y;
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			u32 not_sand_counter = 0;
+			for(s16 y=y_start; y>=y_nodes_min; y--)
+			{
+				MapNode *n = &data->vmanip.m_data[i];
+				if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS)
+				{
+					n->d = CONTENT_SAND;
+				}
+				else
+				{
+					not_sand_counter++;
+					if(not_sand_counter > 3)
+						break;
+				}
+
+				data->vmanip.m_area.add_y(em, i, -1);
+			}
+		}
+
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 1ms @cs=8
+	//TimeTaker timer1("generate trees");
+
+	/*
+		Generate some trees
+	*/
+	{
+		// Divide area into parts
+		s16 div = 8;
+		s16 sidelen = data->sectorpos_base_size*MAP_BLOCKSIZE / 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(
+				data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen/2 + sidelen*x0,
+				data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen/2 + sidelen*z0
+			);
+			// Minimum edge of part of division
+			v2s16 p2d_min(
+				data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0,
+				data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen*z0
+			);
+			// Maximum edge of part of division
+			v2s16 p2d_max(
+				data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1,
+				data->sectorpos_base.Y*MAP_BLOCKSIZE + 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(data->vmanip, v2s16(x,z));
+				// 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 > y_nodes_max - 6)
+					continue;
+				v3s16 p(x,y,z);
+				/*
+					Trees grow only on mud and grass
+				*/
+				{
+					u32 i = data->vmanip.m_area.index(v3s16(p));
+					MapNode *n = &data->vmanip.m_data[i];
+					if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+						continue;
+				}
+				p.Y++;
+				// Make a tree
+				make_tree(data->vmanip, p);
+			}
+		}
+		/*u32 tree_max = relative_area / 60;
+		//u32 count = myrand_range(0, tree_max);
+		for(u32 i=0; i<count; i++)
+		{
+			s16 x = myrand_range(0, data->sectorpos_base_size*MAP_BLOCKSIZE-1);
+			s16 z = myrand_range(0, data->sectorpos_base_size*MAP_BLOCKSIZE-1);
+			x += data->sectorpos_base.X*MAP_BLOCKSIZE;
+			z += data->sectorpos_base.Y*MAP_BLOCKSIZE;
+			s16 y = find_ground_level(data->vmanip, v2s16(x,z));
+			// Don't make a tree under water level
+			if(y < WATER_LEVEL)
+				continue;
+			v3s16 p(x,y+1,z);
+			// Make a tree
+			make_tree(data->vmanip, p);
+		}*/
+	}
+
+	}//timer1
+#endif
+
+#if 1
+	{
+	// 19ms @cs=8
+	//TimeTaker timer1("grow grass");
+
+	/*
+		Grow grass
+	*/
+
+	/*for(s16 x=0-4; x<data->sectorpos_base_size*MAP_BLOCKSIZE+4; x++)
+	for(s16 z=0-4; z<data->sectorpos_base_size*MAP_BLOCKSIZE+4; z++)*/
+	for(s16 x=0-data->max_spread_amount;
+			x<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount;
+			x++)
+	for(s16 z=0-data->max_spread_amount;
+			z<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount;
+			z++)
+	{
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + 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 = data->vmanip.m_area.getExtent();
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+			s16 y;
+			// Go to ground level
+			for(y=y_nodes_max; y>=y_nodes_min; y--)
+			{
+				MapNode &n = data->vmanip.m_data[i];
+				if(n.d != CONTENT_AIR
+						&& n.d != CONTENT_LEAVES)
+					break;
+				data->vmanip.m_area.add_y(em, i, -1);
+			}
+			if(y >= y_nodes_min)
+				surface_y = y;
+			else
+				surface_y = y_nodes_min;
+		}
+		
+		u32 i = data->vmanip.m_area.index(p2d.X, surface_y, p2d.Y);
+		MapNode *n = &data->vmanip.m_data[i];
+		if(n->d == CONTENT_MUD)
+			n->d = CONTENT_GRASS;
+	}
+
+	}//timer1
+#endif
+
+	/*
+		Initial lighting (sunlight)
+	*/
+
+	core::map<v3s16, bool> light_sources;
+
+	{
+	// 750ms @cs=8, can't optimize more
+	TimeTaker timer1("initial lighting");
+
+	// NOTE: This is no used... umm... for some reason!
+#if 0
+	/*
+		Go through the edges and add all nodes that have light to light_sources
+	*/
+	
+	// Four edges
+	for(s16 i=0; i<4; i++)
+	// Edge length
+	for(s16 j=lighting_min_d;
+			j<=lighting_max_d;
+			j++)
+	{
+		s16 x;
+		s16 z;
+		// +-X
+		if(i == 0 || i == 1)
+		{
+			x = (i==0) ? lighting_min_d : lighting_max_d;
+			if(i == 0)
+				z = lighting_min_d;
+			else
+				z = lighting_max_d;
+		}
+		// +-Z
+		else
+		{
+			z = (i==0) ? lighting_min_d : lighting_max_d;
+			if(i == 0)
+				x = lighting_min_d;
+			else
+				x = lighting_max_d;
+		}
+		
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+		{
+			v3s16 em = data->vmanip.m_area.getExtent();
+			s16 y_start = y_nodes_max;
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			for(s16 y=y_start; y>=y_nodes_min; y--)
+			{
+				MapNode *n = &data->vmanip.m_data[i];
+				if(n->getLight(LIGHTBANK_DAY) != 0)
+				{
+					light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+				}
+				//NOTE: This is broken, at least the index has to
+				// be incremented
+			}
+		}
+	}
+#endif
+
+#if 1
+	/*
+		Go through the edges and apply sunlight to them, not caring
+		about neighbors
+	*/
+	
+	// Four edges
+	for(s16 i=0; i<4; i++)
+	// Edge length
+	for(s16 j=lighting_min_d;
+			j<=lighting_max_d;
+			j++)
+	{
+		s16 x;
+		s16 z;
+		// +-X
+		if(i == 0 || i == 1)
+		{
+			x = (i==0) ? lighting_min_d : lighting_max_d;
+			if(i == 0)
+				z = lighting_min_d;
+			else
+				z = lighting_max_d;
+		}
+		// +-Z
+		else
+		{
+			z = (i==0) ? lighting_min_d : lighting_max_d;
+			if(i == 0)
+				x = lighting_min_d;
+			else
+				x = lighting_max_d;
+		}
+		
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		// Loop from top to down
+		{
+			u8 light = LIGHT_SUN;
+			v3s16 em = data->vmanip.m_area.getExtent();
+			s16 y_start = y_nodes_max;
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			for(s16 y=y_start; y>=y_nodes_min; y--)
+			{
+				MapNode *n = &data->vmanip.m_data[i];
+				if(light_propagates_content(n->d) == false)
+				{
+					light = 0;
+				}
+				else if(light != LIGHT_SUN
+					|| sunlight_propagates_content(n->d) == false)
+				{
+					if(light > 0)
+						light--;
+				}
+				
+				n->setLight(LIGHTBANK_DAY, light);
+				n->setLight(LIGHTBANK_NIGHT, 0);
+				
+				if(light != 0)
+				{
+					// Insert light source
+					light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+				}
+				
+				// Increment index by y
+				data->vmanip.m_area.add_y(em, i, -1);
+			}
 		}
 	}
+#endif
+
+	/*for(s16 x=0; x<data->sectorpos_base_size*MAP_BLOCKSIZE; x++)
+	for(s16 z=0; z<data->sectorpos_base_size*MAP_BLOCKSIZE; z++)*/
+	/*for(s16 x=0-data->max_spread_amount+1;
+			x<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1;
+			x++)
+	for(s16 z=0-data->max_spread_amount+1;
+			z<data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1;
+			z++)*/
+#if 1
 	/*
-		Plant some bushes if sector is pit-like
+		This has to be 1 smaller than the actual area, because
+		neighboring nodes are checked.
 	*/
+	for(s16 x=lighting_min_d+1;
+			x<=lighting_max_d-1;
+			x++)
+	for(s16 z=lighting_min_d+1;
+			z<=lighting_max_d-1;
+			z++)
 	{
-		// Pitness usually goes at around -0.5...0.5
-		u32 bush_max = 0;
-		u32 a = area/16 * 3.0 * m_params.plants_amount * local_plants_amount;
-		if(pitness > 0)
-			bush_max = (pitness*a*4);
-		if(bush_max > a)
-			bush_max = a;
-		u32 count = (myrand()%(bush_max+1));
-		for(u32 i=0; i<count; i++)
+		// Node position in 2d
+		v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+		
+		/*
+			Apply initial sunlight
+		*/
 		{
-			s16 x = myrand()%(MAP_BLOCKSIZE-0)+0;
-			s16 z = myrand()%(MAP_BLOCKSIZE-0)+0;
-			s16 y = sector->getGroundHeight(v2s16(x,z))+1;
-			if(y < WATER_LEVEL)
-				continue;
-			objects->insert(v3s16(x, y, z),
-					SECTOR_OBJECT_BUSH_1);
+			u8 light = LIGHT_SUN;
+			bool add_to_sources = false;
+			v3s16 em = data->vmanip.m_area.getExtent();
+			s16 y_start = y_nodes_max;
+			u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+			for(s16 y=y_start; y>=y_nodes_min; y--)
+			{
+				MapNode *n = &data->vmanip.m_data[i];
+
+				if(light_propagates_content(n->d) == false)
+				{
+					light = 0;
+				}
+				else if(light != LIGHT_SUN
+					|| sunlight_propagates_content(n->d) == false)
+				{
+					if(light > 0)
+						light--;
+				}
+				
+				// This doesn't take much time
+				if(add_to_sources == false)
+				{
+					/*
+						Check sides. If side is not air or water, start
+						adding to light_sources.
+					*/
+					v3s16 dirs4[4] = {
+						v3s16(0,0,1), // back
+						v3s16(1,0,0), // right
+						v3s16(0,0,-1), // front
+						v3s16(-1,0,0), // left
+					};
+					for(u32 di=0; di<4; di++)
+					{
+						v3s16 dirp = dirs4[di];
+						u32 i2 = i;
+						data->vmanip.m_area.add_p(em, i2, dirp);
+						MapNode *n2 = &data->vmanip.m_data[i2];
+						if(
+							n2->d != CONTENT_AIR
+							&& n2->d != CONTENT_WATERSOURCE
+							&& n2->d != CONTENT_WATER
+						){
+							add_to_sources = true;
+							break;
+						}
+					}
+				}
+				
+				n->setLight(LIGHTBANK_DAY, light);
+				n->setLight(LIGHTBANK_NIGHT, 0);
+				
+				// This doesn't take much time
+				if(light != 0 && add_to_sources)
+				{
+					// Insert light source
+					light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+				}
+				
+				// Increment index by y
+				data->vmanip.m_area.add_y(em, i, -1);
+			}
+		}
+	}
+#endif
+
+	}//timer1
+
+	// Spread light around
+	{
+		TimeTaker timer("makeChunk() spreadLight");
+		data->vmanip.spreadLight(LIGHTBANK_DAY, light_sources);
+	}
+	
+	/*
+		Generation ended
+	*/
+
+	timer_generate.stop();
+}
+
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+//###################################################################
+
+void ServerMap::initChunkMake(ChunkMakeData &data, v2s16 chunkpos)
+{
+	if(m_chunksize == 0)
+	{
+		data.no_op = true;
+		return;
+	}
+
+	data.no_op = false;
+
+	// The distance how far into the neighbors the generator is allowed to go.
+	s16 max_spread_amount_sectors = 2;
+	assert(max_spread_amount_sectors <= m_chunksize);
+	s16 max_spread_amount = max_spread_amount_sectors * MAP_BLOCKSIZE;
+
+	s16 y_blocks_min = -4;
+	s16 y_blocks_max = 3;
+
+	v2s16 sectorpos_base = chunk_to_sector(chunkpos);
+	s16 sectorpos_base_size = m_chunksize;
+
+	v2s16 sectorpos_bigbase =
+			sectorpos_base - v2s16(1,1) * max_spread_amount_sectors;
+	s16 sectorpos_bigbase_size =
+			sectorpos_base_size + 2 * max_spread_amount_sectors;
+			
+	data.seed = m_seed;
+	data.chunkpos = chunkpos;
+	data.y_blocks_min = y_blocks_min;
+	data.y_blocks_max = y_blocks_max;
+	data.sectorpos_base = sectorpos_base;
+	data.sectorpos_base_size = sectorpos_base_size;
+	data.sectorpos_bigbase = sectorpos_bigbase;
+	data.sectorpos_bigbase_size = sectorpos_bigbase_size;
+	data.max_spread_amount = max_spread_amount;
+
+	/*
+		Create the whole area of this and the neighboring chunks
+	*/
+	{
+		TimeTaker timer("initChunkMake() create area");
+		
+		for(s16 x=0; x<sectorpos_bigbase_size; x++)
+		for(s16 z=0; z<sectorpos_bigbase_size; z++)
+		{
+			v2s16 sectorpos = sectorpos_bigbase + v2s16(x,z);
+			ServerMapSector *sector = createSector(sectorpos);
+			assert(sector);
+
+			for(s16 y=y_blocks_min; y<=y_blocks_max; y++)
+			{
+				v3s16 blockpos(sectorpos.X, y, sectorpos.Y);
+				MapBlock *block = createBlock(blockpos);
+
+				// Lighting won't be calculated
+				//block->setLightingExpired(true);
+				// Lighting will be calculated
+				block->setLightingExpired(false);
+
+				/*
+					Block gets sunlight if this is true.
+
+					This should be set to true when the top side of a block
+					is completely exposed to the sky.
+
+					Actually this doesn't matter now because the
+					initial lighting is done here.
+				*/
+				block->setIsUnderground(y != y_blocks_max);
+			}
+		}
+	}
+	
+	/*
+		Now we have a big empty area.
+
+		Make a ManualMapVoxelManipulator that contains this and the
+		neighboring chunks
+	*/
+	
+	v3s16 bigarea_blocks_min(
+		sectorpos_bigbase.X,
+		y_blocks_min,
+		sectorpos_bigbase.Y
+	);
+	v3s16 bigarea_blocks_max(
+		sectorpos_bigbase.X + sectorpos_bigbase_size - 1,
+		y_blocks_max,
+		sectorpos_bigbase.Y + sectorpos_bigbase_size - 1
+	);
+	
+	data.vmanip.setMap(this);
+	// Add the area
+	{
+		TimeTaker timer("initChunkMake() initialEmerge");
+		data.vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
+	}
+	
+}
+
+MapChunk* ServerMap::finishChunkMake(ChunkMakeData &data,
+		core::map<v3s16, MapBlock*> &changed_blocks)
+{
+	if(data.no_op)
+		return NULL;
+	
+	/*
+		Blit generated stuff to map
+	*/
+	{
+		// 70ms @cs=8
+		//TimeTaker timer("generateChunkRaw() blitBackAll");
+		data.vmanip.blitBackAll(&changed_blocks);
+	}
+
+	/*
+		Update day/night difference cache of the MapBlocks
+	*/
+	{
+		for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
+				i.atEnd() == false; i++)
+		{
+			MapBlock *block = i.getNode()->getValue();
+			block->updateDayNightDiff();
+		}
+	}
+
+	/*
+		Copy transforming liquid information
+	*/
+	while(data.transforming_liquid.size() > 0)
+	{
+		v3s16 p = data.transforming_liquid.pop_front();
+		m_transforming_liquid.push_back(p);
+	}
+
+	/*
+		Add random objects to blocks
+	*/
+	{
+		for(s16 x=0; x<data.sectorpos_base_size; x++)
+		for(s16 z=0; z<data.sectorpos_base_size; z++)
+		{
+			v2s16 sectorpos = data.sectorpos_base + v2s16(x,z);
+			ServerMapSector *sector = createSector(sectorpos);
+			assert(sector);
+
+			for(s16 y=data.y_blocks_min; y<=data.y_blocks_max; y++)
+			{
+				v3s16 blockpos(sectorpos.X, y, sectorpos.Y);
+				MapBlock *block = createBlock(blockpos);
+				addRandomObjects(block);
+			}
+		}
+	}
+
+	/*
+		Create chunk metadata
+	*/
+
+	for(s16 x=-1; x<=1; x++)
+	for(s16 y=-1; y<=1; y++)
+	{
+		v2s16 chunkpos0 = data.chunkpos + v2s16(x,y);
+		// Add chunk meta information
+		MapChunk *chunk = getChunk(chunkpos0);
+		if(chunk == NULL)
+		{
+			chunk = new MapChunk();
+			m_chunks.insert(chunkpos0, chunk);
+		}
+		//chunk->setIsVolatile(true);
+		if(chunk->getGenLevel() > GENERATED_PARTLY)
+			chunk->setGenLevel(GENERATED_PARTLY);
+	}
+
+	/*
+		Set central chunk non-volatile
+	*/
+	MapChunk *chunk = getChunk(data.chunkpos);
+	assert(chunk);
+	// Set non-volatile
+	//chunk->setIsVolatile(false);
+	chunk->setGenLevel(GENERATED_FULLY);
+	
+	/*
+		Save changed parts of map
+	*/
+	save(true);
+	
+	return chunk;
+}
+
+#if 0
+// NOTE: Deprecated
+MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos,
+		core::map<v3s16, MapBlock*> &changed_blocks,
+		bool force)
+{
+	DSTACK(__FUNCTION_NAME);
+
+	/*
+		Don't generate if already fully generated
+	*/
+	if(force == false)
+	{
+		MapChunk *chunk = getChunk(chunkpos);
+		if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY)
+		{
+			dstream<<"generateChunkRaw(): Chunk "
+					<<"("<<chunkpos.X<<","<<chunkpos.Y<<")"
+					<<" already generated"<<std::endl;
+			return chunk;
 		}
 	}
+
+	dstream<<"generateChunkRaw(): Generating chunk "
+			<<"("<<chunkpos.X<<","<<chunkpos.Y<<")"
+			<<std::endl;
+	
+	TimeTaker timer("generateChunkRaw()");
+
+	ChunkMakeData data;
+	
+	// Initialize generation
+	initChunkMake(data, chunkpos);
+	
+	// Generate stuff
+	makeChunk(&data);
+
+	// Finalize generation
+	MapChunk *chunk = finishChunkMake(data, changed_blocks);
+
+	/*
+		Return central chunk (which was requested)
+	*/
+	return chunk;
+}
+
+// NOTE: Deprecated
+MapChunk* ServerMap::generateChunk(v2s16 chunkpos1,
+		core::map<v3s16, MapBlock*> &changed_blocks)
+{
+	dstream<<"generateChunk(): Generating chunk "
+			<<"("<<chunkpos1.X<<","<<chunkpos1.Y<<")"
+			<<std::endl;
+	
+	/*for(s16 x=-1; x<=1; x++)
+	for(s16 y=-1; y<=1; y++)*/
+	for(s16 x=-0; x<=0; x++)
+	for(s16 y=-0; y<=0; y++)
+	{
+		v2s16 chunkpos0 = chunkpos1 + v2s16(x,y);
+		MapChunk *chunk = getChunk(chunkpos0);
+		// Skip if already generated
+		if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY)
+			continue;
+		generateChunkRaw(chunkpos0, changed_blocks);
+	}
+	
+	assert(chunkNonVolatile(chunkpos1));
+
+	MapChunk *chunk = getChunk(chunkpos1);
+	return chunk;
+}
+#endif
+
+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;
+	
 	/*
-		Add ravine (randomly)
+		Try to load it from disk (with blocks)
 	*/
-	if(m_params.ravines_amount > 0.001)
+	if(loadSectorFull(p2d) == true)
 	{
-		if(myrand()%(s32)(200.0 / m_params.ravines_amount) == 0)
+		ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
+		if(sector == NULL)
 		{
-			s16 s = 6;
-			s16 x = myrand()%(MAP_BLOCKSIZE-s*2-1)+s;
-			s16 z = myrand()%(MAP_BLOCKSIZE-s*2-1)+s;
-			/*s16 x = 8;
-			s16 z = 8;*/
-			s16 y = sector->getGroundHeight(v2s16(x,z))+1;
-			objects->insert(v3s16(x, y, z),
-					SECTOR_OBJECT_RAVINE);
+			dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<<std::endl;
+			throw InvalidPositionException("");
 		}
+		return sector;
 	}
 
+	/*
+		Do not create over-limit
+	*/
+	if(p2d.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p2d.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+		throw InvalidPositionException("createSector(): pos. over limit");
+
+	/*
+		Generate blank sector
+	*/
+	
+	sector = new ServerMapSector(this, p2d);
+	
+	// Sector position on map in nodes
+	v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
+
 	/*
 		Insert to container
 	*/
-	JMutexAutoLock lock(m_sector_mutex);
 	m_sectors.insert(p2d, sector);
 	
 	return sector;
 }
 
-MapBlock * ServerMap::emergeBlock(
-		v3s16 p,
-		bool only_from_disk,
-		core::map<v3s16, MapBlock*> &changed_blocks,
-		core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
-)
+#if 0
+MapSector * ServerMap::emergeSector(v2s16 p2d,
+		core::map<v3s16, MapBlock*> &changed_blocks)
 {
-	DSTACK("%s: p=(%d,%d,%d), only_from_disk=%d",
+	DSTACK("%s: p2d=(%d,%d)",
 			__FUNCTION_NAME,
-			p.X, p.Y, p.Z, only_from_disk);
-			
-	/*dstream<<"ServerMap::emergeBlock(): "
-			<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
-			<<", only_from_disk="<<only_from_disk<<std::endl;*/
-	v2s16 p2d(p.X, p.Z);
-	s16 block_y = p.Y;
+			p2d.X, p2d.Y);
+	
 	/*
-		This will create or load a sector if not found in memory.
-		If block exists on disk, it will be loaded.
-
-		NOTE: On old save formats, this will be slow, as it generates
-		      lighting on blocks for them.
+		Check chunk status
 	*/
-	ServerMapSector *sector = (ServerMapSector*)emergeSector(p2d);
-	assert(sector->getId() == MAPSECTOR_SERVER);
+	v2s16 chunkpos = sector_to_chunk(p2d);
+	/*bool chunk_nonvolatile = false;
+	MapChunk *chunk = getChunk(chunkpos);
+	if(chunk && chunk->getIsVolatile() == false)
+		chunk_nonvolatile = true;*/
+	bool chunk_nonvolatile = chunkNonVolatile(chunkpos);
 
-	// Try to get a block from the sector
-	MapBlock *block = NULL;
-	bool not_on_disk = false;
-	try{
-		block = sector->getBlockNoCreate(block_y);
-		if(block->isDummy() == true)
-			not_on_disk = true;
-		else
-			return block;
-	}
-	catch(InvalidPositionException &e)
+	/*
+		If chunk is not fully generated, generate chunk
+	*/
+	if(chunk_nonvolatile == false)
 	{
-		not_on_disk = true;
+		// Generate chunk and neighbors
+		generateChunk(chunkpos, changed_blocks);
 	}
 	
 	/*
-		If block was not found on disk and not going to generate a
-		new one, make sure there is a dummy block in place.
+		Return sector if it exists now
+	*/
+	MapSector *sector = getSectorNoGenerateNoEx(p2d);
+	if(sector != NULL)
+		return sector;
+	
+	/*
+		Try to load it from disk
 	*/
-	if(not_on_disk && only_from_disk)
+	if(loadSectorFull(p2d) == true)
 	{
-		if(block == NULL)
+		MapSector *sector = getSectorNoGenerateNoEx(p2d);
+		if(sector == NULL)
 		{
-			// Create dummy block
-			block = new MapBlock(this, p, true);
-
-			// Add block to sector
-			sector->insertBlock(block);
+			dstream<<"ServerMap::emergeSector(): loadSectorFull didn't make a sector"<<std::endl;
+			throw InvalidPositionException("");
 		}
-		// Done.
-		return block;
+		return sector;
 	}
 
-	//dstream<<"Not found on disk, generating."<<std::endl;
-	//TimeTaker("emergeBlock()", g_irrlicht);
+	/*
+		generateChunk should have generated the sector
+	*/
+	//assert(0);
+	
+	dstream<<"WARNING: ServerMap::emergeSector: Cannot find sector ("
+			<<p2d.X<<","<<p2d.Y<<" and chunk is already generated. "
+			<<std::endl;
+
+#if 0
+	dstream<<"WARNING: Creating an empty sector."<<std::endl;
+
+	return createSector(p2d);
+	
+#endif
+	
+#if 1
+	dstream<<"WARNING: Forcing regeneration of chunk."<<std::endl;
+
+	// Generate chunk
+	generateChunkRaw(chunkpos, changed_blocks, true);
 
 	/*
-		Do not generate over-limit
+		Return sector if it exists now
 	*/
-	if(blockpos_over_limit(p))
-		throw InvalidPositionException("emergeBlock(): pos. over limit");
-
+	sector = getSectorNoGenerateNoEx(p2d);
+	if(sector != NULL)
+		return sector;
+	
+	dstream<<"ERROR: Could not get sector from anywhere."<<std::endl;
+	
+	assert(0);
+#endif
+	
 	/*
-		OK; Not found.
+		Generate directly
+	*/
+	//return generateSector();
+}
+#endif
 
-		Go on generating the block.
+/*
+	NOTE: This is not used for main map generation, only for blocks
+	that are very high or low
+*/
+MapBlock * ServerMap::generateBlock(
+		v3s16 p,
+		MapBlock *original_dummy,
+		ServerMapSector *sector,
+		core::map<v3s16, MapBlock*> &changed_blocks,
+		core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
+)
+{
+	DSTACKF("%s: p=(%d,%d,%d)",
+			__FUNCTION_NAME,
+			p.X, p.Y, p.Z);
 
-		TODO: If a dungeon gets generated so that it's side gets
-		      revealed to the outside air, the lighting should be
-			  recalculated.
-	*/
+	// If chunks are disabled
+	/*if(m_chunksize == 0)
+	{
+		dstream<<"ServerMap::generateBlock(): Chunks disabled -> "
+				<<"not generating."<<std::endl;
+		return NULL;
+	}*/
+	
+	/*dstream<<"generateBlock(): "
+			<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+			<<std::endl;*/
+	
+	MapBlock *block = original_dummy;
+			
+	v2s16 p2d(p.X, p.Z);
+	s16 block_y = p.Y;
+	v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
 	
+	/*
+		Do not generate over-limit
+	*/
+	if(blockpos_over_limit(p))
+	{
+		dstream<<__FUNCTION_NAME<<": Block position over limit"<<std::endl;
+		throw InvalidPositionException("generateBlock(): pos. over limit");
+	}
+
 	/*
 		If block doesn't exist, create one.
 		If it exists, it is a dummy. In that case unDummify() it.
@@ -2256,56 +4031,52 @@ MapBlock * ServerMap::emergeBlock(
 		block->unDummify();
 	}
 	
-	/*u8 water_material = CONTENT_WATER;
-	if(g_settings.getBool("endless_water"))
-		water_material = CONTENT_WATERSOURCE;*/
+#if 0
+	/*
+		Generate a completely empty block
+	*/
+	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+	{
+		for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+		{
+			MapNode n;
+			n.d = CONTENT_AIR;
+			block->setNode(v3s16(x0,y0,z0), n);
+		}
+	}
+#else
+	/*
+		Generate a proper block
+	*/
+	
 	u8 water_material = CONTENT_WATERSOURCE;
 	
 	s32 lowest_ground_y = 32767;
 	s32 highest_ground_y = -32768;
 	
-	// DEBUG
-	//sector->printHeightmaps();
-
 	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
 	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
 	{
-		//dstream<<"emergeBlock: x0="<<x0<<", z0="<<z0<<std::endl;
+		//dstream<<"generateBlock: x0="<<x0<<", z0="<<z0<<std::endl;
 
-		float surface_y_f = sector->getGroundHeight(v2s16(x0,z0));
-		//assert(surface_y_f > GROUNDHEIGHT_VALID_MINVALUE);
-		if(surface_y_f < GROUNDHEIGHT_VALID_MINVALUE)
-		{
-			dstream<<"WARNING: Surface height not found in sector "
-					"for block that is being emerged"<<std::endl;
-			surface_y_f = 0.0;
-		}
+		//s16 surface_y = 0;
+
+		s16 mud_add_amount = get_mud_add_amount(m_seed, p2d_nodes+v2s16(x0,z0));
+
+		s16 surface_y = base_rock_level_2d(m_seed, p2d_nodes+v2s16(x0,z0))
+				+ mud_add_amount;
+		// If chunks are disabled
+		if(m_chunksize == 0)
+			surface_y = WATER_LEVEL + 1;
 
-		s16 surface_y = surface_y_f;
-		//avg_ground_y += surface_y;
 		if(surface_y < lowest_ground_y)
 			lowest_ground_y = surface_y;
 		if(surface_y > highest_ground_y)
 			highest_ground_y = surface_y;
 
-		s32 surface_depth = 0;
-		
-		float slope = sector->getSlope(v2s16(x0,z0)).getLength();
+		s32 surface_depth = AVERAGE_MUD_AMOUNT;
 		
-		//float min_slope = 0.45;
-		//float max_slope = 0.85;
-		float min_slope = 0.60;
-		float max_slope = 1.20;
-		float min_slope_depth = 5.0;
-		float max_slope_depth = 0;
-
-		if(slope < min_slope)
-			surface_depth = min_slope_depth;
-		else if(slope > max_slope)
-			surface_depth = max_slope_depth;
-		else
-			surface_depth = (1.-(slope-min_slope)/max_slope) * min_slope_depth;
-
 		for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
 		{
 			s16 real_y = block_y * MAP_BLOCKSIZE + y0;
@@ -2343,7 +4114,7 @@ MapBlock * ServerMap::emergeBlock(
 				else
 					n.d = CONTENT_AIR;
 			}
-			// Else it's ground or dungeons (air)
+			// Else it's ground or caves (air)
 			else
 			{
 				// If it's surface_depth under ground, it's stone
@@ -2403,26 +4174,28 @@ MapBlock * ServerMap::emergeBlock(
 		Get local attributes
 	*/
 
-	//dstream<<"emergeBlock(): Getting local attributes"<<std::endl;
+	//dstream<<"generateBlock(): Getting local attributes"<<std::endl;
 
-	float caves_amount = 0;
-	
+	float caves_amount = 0.5;
+
+#if 0
 	{
 		/*
 			NOTE: BEWARE: Too big amount of attribute points slows verything
 			down by a lot.
 			1 interpolation from 5000 points takes 2-3ms.
 		*/
-		//TimeTaker timer("emergeBlock() local attribute retrieval");
+		//TimeTaker timer("generateBlock() local attribute retrieval");
 		v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
 		PointAttributeList *list_caves_amount = m_padb.getList("caves_amount");
 		caves_amount = list_caves_amount->getInterpolatedFloat(nodepos2d);
 	}
+#endif
 
-	//dstream<<"emergeBlock(): Done"<<std::endl;
+	//dstream<<"generateBlock(): Done"<<std::endl;
 
 	/*
-		Generate dungeons
+		Generate caves
 	*/
 
 	// Initialize temporary table
@@ -2560,36 +4333,36 @@ MapBlock * ServerMap::emergeBlock(
 continue_generating:
 		
 		/*
-			Choose whether to actually generate dungeon
+			Choose whether to actually generate cave
 		*/
-		bool do_generate_dungeons = true;
+		bool do_generate_caves = true;
 		// Don't generate if no part is underground
 		if(!some_part_underground)
 		{
-			do_generate_dungeons = false;
+			do_generate_caves = false;
 		}
 		// Don't generate if mostly underwater surface
-		else if(mostly_underwater_surface)
+		/*else if(mostly_underwater_surface)
 		{
-			do_generate_dungeons = false;
-		}
+			do_generate_caves = false;
+		}*/
 		// Partly underground = cave
 		else if(!completely_underground)
 		{
-			do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100));
+			do_generate_caves = (rand() % 100 <= (s32)(caves_amount*100));
 		}
-		// Found existing dungeon underground
+		// Found existing cave underground
 		else if(found_existing && completely_underground)
 		{
-			do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100));
+			do_generate_caves = (rand() % 100 <= (s32)(caves_amount*100));
 		}
-		// Underground and no dungeons found
+		// Underground and no caves found
 		else
 		{
-			do_generate_dungeons = (rand() % 300 <= (s32)(caves_amount*100));
+			do_generate_caves = (rand() % 300 <= (s32)(caves_amount*100));
 		}
 
-		if(do_generate_dungeons)
+		if(do_generate_caves)
 		{
 			/*
 				Generate some tunnel starting from orp and ors
@@ -2602,7 +4375,7 @@ MapBlock * ServerMap::emergeBlock(
 					(float)(myrand()%ued)+0.5
 				);
 				s16 min_d = 0;
-				s16 max_d = 6;
+				s16 max_d = 4;
 				s16 rs = (myrand()%(max_d-min_d+1))+min_d;
 				
 				v3f vec = rp - orp;
@@ -2641,7 +4414,7 @@ MapBlock * ServerMap::emergeBlock(
 
 	// Set to true if has caves.
 	// Set when some non-air is changed to air when making caves.
-	bool has_dungeons = false;
+	bool has_caves = false;
 
 	/*
 		Apply temporary cave data to block
@@ -2654,16 +4427,16 @@ MapBlock * ServerMap::emergeBlock(
 		{
 			MapNode n = block->getNode(v3s16(x0,y0,z0));
 
-			// Create dungeons
+			// Create caves
 			if(underground_emptiness[
 					ued*ued*(z0*ued/MAP_BLOCKSIZE)
 					+ued*(y0*ued/MAP_BLOCKSIZE)
 					+(x0*ued/MAP_BLOCKSIZE)])
 			{
-				if(is_ground_content(n.d))
+				if(content_features(n.d).walkable/*is_ground_content(n.d)*/)
 				{
 					// Has now caves
-					has_dungeons = true;
+					has_caves = true;
 					// Set air to node
 					n.d = CONTENT_AIR;
 				}
@@ -2675,7 +4448,7 @@ MapBlock * ServerMap::emergeBlock(
 	
 	/*
 		This is used for guessing whether or not the block should
-		receive sunlight from the top if the top block doesn't exist
+		receive sunlight from the top if the block above doesn't exist
 	*/
 	block->setIsUnderground(completely_underground);
 
@@ -2683,7 +4456,7 @@ MapBlock * ServerMap::emergeBlock(
 		Force lighting update if some part of block is partly
 		underground and has caves.
 	*/
-	/*if(some_part_underground && !completely_underground && has_dungeons)
+	/*if(some_part_underground && !completely_underground && has_caves)
 	{
 		//dstream<<"Half-ground caves"<<std::endl;
 		lighting_invalidated_blocks[block->getPos()] = block;
@@ -2716,17 +4489,11 @@ MapBlock * ServerMap::emergeBlock(
 				MapNode n;
 				n.d = CONTENT_MESE;
 				
-				//if(is_ground_content(block->getNode(cp).d))
-				if(block->getNode(cp).d == CONTENT_STONE)
-					if(myrand()%8 == 0)
-						block->setNode(cp, n);
-
-				for(u16 i=0; i<26; i++)
+				for(u16 i=0; i<27; i++)
 				{
-					//if(is_ground_content(block->getNode(cp+g_26dirs[i]).d))
-					if(block->getNode(cp+g_26dirs[i]).d == CONTENT_STONE)
+					if(block->getNode(cp+g_27dirs[i]).d == CONTENT_STONE)
 						if(myrand()%8 == 0)
-							block->setNode(cp+g_26dirs[i], n);
+							block->setNode(cp+g_27dirs[i], n);
 				}
 			}
 		}
@@ -2734,7 +4501,7 @@ MapBlock * ServerMap::emergeBlock(
 		/*
 			Add coal
 		*/
-		u16 coal_amount = 30.0 * g_settings.getFloat("coal_amount");
+		u16 coal_amount = 30;
 		u16 coal_rareness = 60 / coal_amount;
 		if(coal_rareness == 0)
 			coal_rareness = 1;
@@ -2751,21 +4518,47 @@ MapBlock * ServerMap::emergeBlock(
 				);
 
 				MapNode n;
-				n.d = CONTENT_COALSTONE;
+				n.d = CONTENT_STONE;
+				n.param = MINERAL_COAL;
 
-				//dstream<<"Adding coalstone"<<std::endl;
-				
-				//if(is_ground_content(block->getNode(cp).d))
-				if(block->getNode(cp).d == CONTENT_STONE)
-					if(myrand()%8 == 0)
-						block->setNode(cp, n);
+				for(u16 i=0; i<27; i++)
+				{
+					if(block->getNode(cp+g_27dirs[i]).d == CONTENT_STONE)
+						if(myrand()%8 == 0)
+							block->setNode(cp+g_27dirs[i], n);
+				}
+			}
+		}
+
+		/*
+			Add iron
+		*/
+		//TODO: change to iron_amount or whatever
+		u16 iron_amount = 15;
+		u16 iron_rareness = 60 / iron_amount;
+		if(iron_rareness == 0)
+			iron_rareness = 1;
+		if(myrand()%iron_rareness == 0)
+		{
+			u16 a = myrand() % 16;
+			u16 amount = iron_amount * a*a*a / 1000;
+			for(s16 i=0; i<amount; i++)
+			{
+				v3s16 cp(
+					(myrand()%(MAP_BLOCKSIZE-2))+1,
+					(myrand()%(MAP_BLOCKSIZE-2))+1,
+					(myrand()%(MAP_BLOCKSIZE-2))+1
+				);
+
+				MapNode n;
+				n.d = CONTENT_STONE;
+				n.param = MINERAL_IRON;
 
-				for(u16 i=0; i<26; i++)
+				for(u16 i=0; i<27; i++)
 				{
-					//if(is_ground_content(block->getNode(cp+g_26dirs[i]).d))
-					if(block->getNode(cp+g_26dirs[i]).d == CONTENT_STONE)
+					if(block->getNode(cp+g_27dirs[i]).d == CONTENT_STONE)
 						if(myrand()%8 == 0)
-							block->setNode(cp+g_26dirs[i], n);
+							block->setNode(cp+g_27dirs[i], n);
 				}
 			}
 		}
@@ -2788,250 +4581,231 @@ MapBlock * ServerMap::emergeBlock(
 			//if(!is_ground_content(block->getNode(cp).d))
 			if(1)
 			{
-				RatObject *obj = new RatObject(NULL, -1, intToFloat(cp));
+				RatObject *obj = new RatObject(NULL, -1, intToFloat(cp, BS));
 				block->addObject(obj);
 			}
 		}
 	}
+
+#endif // end of proper block generation
 	
 	/*
 		Add block to sector.
 	*/
 	sector->insertBlock(block);
 	
+	// Lighting is invalid after generation.
+	block->setLightingExpired(true);
+	
+#if 0
 	/*
-		Sector object stuff
+		Debug information
 	*/
-		
-	// An y-wise container of changed blocks
-	core::map<s16, MapBlock*> changed_blocks_sector;
+	dstream
+	<<"lighting_invalidated_blocks.size()"
+	<<", has_caves"
+	<<", completely_ug"
+	<<", some_part_ug"
+	<<"  "<<lighting_invalidated_blocks.size()
+	<<", "<<has_caves
+	<<", "<<completely_underground
+	<<", "<<some_part_underground
+	<<std::endl;
+#endif
 
+	return block;
+}
+
+MapBlock * ServerMap::createBlock(v3s16 p)
+{
+	DSTACKF("%s: p=(%d,%d,%d)",
+			__FUNCTION_NAME, p.X, p.Y, p.Z);
+	
 	/*
-		Check if any sector's objects can be placed now.
-		If so, place them.
+		Do not create over-limit
 	*/
-	core::map<v3s16, u8> *objects = sector->getObjects();
-	core::list<v3s16> objects_to_remove;
-	for(core::map<v3s16, u8>::Iterator i = objects->getIterator();
-			i.atEnd() == false; i++)
+	if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| 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;
+	/*
+		This will create or load a sector if not found in memory.
+		If block exists on disk, it will be loaded.
+
+		NOTE: On old save formats, this will be slow, as it generates
+		      lighting on blocks for them.
+	*/
+	ServerMapSector *sector;
+	try{
+		sector = (ServerMapSector*)createSector(p2d);
+		assert(sector->getId() == MAPSECTOR_SERVER);
+	}
+	catch(InvalidPositionException &e)
 	{
-		v3s16 p = i.getNode()->getKey();
-		v2s16 p2d(p.X,p.Z);
-		u8 d = i.getNode()->getValue();
+		dstream<<"createBlock: createSector() failed"<<std::endl;
+		throw e;
+	}
+	/*
+		NOTE: This should not be done, or at least the exception
+		should not be passed on as std::exception, because it
+		won't be catched at all.
+	*/
+	/*catch(std::exception &e)
+	{
+		dstream<<"createBlock: createSector() failed: "
+				<<e.what()<<std::endl;
+		throw e;
+	}*/
 
-		// Ground level point (user for stuff that is on ground)
-		v3s16 gp = p;
-		bool ground_found = true;
-		
-		// Search real ground level
-		try{
-			for(;;)
-			{
-				MapNode n = sector->getNode(gp);
+	/*
+		Try to get a block from the sector
+	*/
 
-				// If not air, go one up and continue to placing the tree
-				if(n.d != CONTENT_AIR)
-				{
-					gp += v3s16(0,1,0);
-					break;
-				}
+	MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
+	if(block)
+		return block;
+	// Create blank
+	block = sector->createBlankBlock(block_y);
+	return block;
+}
 
-				// If air, go one down
-				gp += v3s16(0,-1,0);
-			}
-		}catch(InvalidPositionException &e)
-		{
-			// Ground not found.
-			ground_found = false;
-			// This is most close to ground
-			gp += v3s16(0,1,0);
-		}
+MapBlock * ServerMap::emergeBlock(
+		v3s16 p,
+		bool only_from_disk,
+		core::map<v3s16, MapBlock*> &changed_blocks,
+		core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
+)
+{
+	DSTACKF("%s: p=(%d,%d,%d), only_from_disk=%d",
+			__FUNCTION_NAME,
+			p.X, p.Y, p.Z, only_from_disk);
+	
+	/*
+		Do not generate over-limit
+	*/
+	if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+	|| p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+		throw InvalidPositionException("emergeBlock(): pos. over limit");
+	
+	v2s16 p2d(p.X, p.Z);
+	s16 block_y = p.Y;
+	/*
+		This will create or load a sector if not found in memory.
+		If block exists on disk, it will be loaded.
+	*/
+	ServerMapSector *sector;
+	try{
+		sector = (ServerMapSector*)emergeSector(p2d, changed_blocks);
+		assert(sector->getId() == MAPSECTOR_SERVER);
+	}
+	catch(InvalidPositionException &e)
+	{
+		dstream<<"emergeBlock: emergeSector() failed: "
+				<<e.what()<<std::endl;
+		dstream<<"Path to failed sector: "<<getSectorDir(p2d)
+				<<std::endl
+				<<"You could try to delete it."<<std::endl;
+		throw e;
+	}
+	catch(VersionMismatchException &e)
+	{
+		dstream<<"emergeBlock: emergeSector() failed: "
+				<<e.what()<<std::endl;
+		dstream<<"Path to failed sector: "<<getSectorDir(p2d)
+				<<std::endl
+				<<"You could try to delete it."<<std::endl;
+		throw e;
+	}
+	/*
+		NOTE: This should not be done, or at least the exception
+		should not be passed on as std::exception, because it
+		won't be catched at all.
+	*/
+	/*catch(std::exception &e)
+	{
+		dstream<<"emergeBlock: emergeSector() failed: "
+				<<e.what()<<std::endl;
+		dstream<<"Path to failed sector: "<<getSectorDir(p2d)
+				<<std::endl
+				<<"You could try to delete it."<<std::endl;
+		throw e;
+	}*/
 
-		try
-		{
+	/*
+		Try to get a block from the sector
+	*/
 
-		if(d == SECTOR_OBJECT_TEST)
-		{
-			if(sector->isValidArea(p + v3s16(0,0,0),
-					p + v3s16(0,0,0), &changed_blocks_sector))
-			{
-				MapNode n;
-				n.d = CONTENT_TORCH;
-				sector->setNode(p, n);
-				objects_to_remove.push_back(p);
-			}
-		}
-		else if(d == SECTOR_OBJECT_TREE_1)
-		{
-			if(ground_found == false)
-				continue;
+	bool does_not_exist = false;
+	bool lighting_expired = false;
+	MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
 
-			v3s16 p_min = gp + v3s16(-1,0,-1);
-			v3s16 p_max = gp + v3s16(1,5,1);
-			if(sector->isValidArea(p_min, p_max,
-					&changed_blocks_sector))
-			{
-				MapNode n;
-				n.d = CONTENT_TREE;
-				sector->setNode(gp+v3s16(0,0,0), n);
-				sector->setNode(gp+v3s16(0,1,0), n);
-				sector->setNode(gp+v3s16(0,2,0), n);
-				sector->setNode(gp+v3s16(0,3,0), n);
-
-				n.d = CONTENT_LEAVES;
-
-				if(myrand()%4!=0) sector->setNode(gp+v3s16(0,5,0), n);
-
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,5,0), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(1,5,0), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(0,5,-1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(0,5,1), n);
-				/*if(myrand()%3!=0) sector->setNode(gp+v3s16(1,5,1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,5,1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,5,-1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(1,5,-1), n);*/
-
-				sector->setNode(gp+v3s16(0,4,0), n);
-				
-				sector->setNode(gp+v3s16(-1,4,0), n);
-				sector->setNode(gp+v3s16(1,4,0), n);
-				sector->setNode(gp+v3s16(0,4,-1), n);
-				sector->setNode(gp+v3s16(0,4,1), n);
-				sector->setNode(gp+v3s16(1,4,1), n);
-				sector->setNode(gp+v3s16(-1,4,1), n);
-				sector->setNode(gp+v3s16(-1,4,-1), n);
-				sector->setNode(gp+v3s16(1,4,-1), n);
-
-				sector->setNode(gp+v3s16(-1,3,0), n);
-				sector->setNode(gp+v3s16(1,3,0), n);
-				sector->setNode(gp+v3s16(0,3,-1), n);
-				sector->setNode(gp+v3s16(0,3,1), n);
-				sector->setNode(gp+v3s16(1,3,1), n);
-				sector->setNode(gp+v3s16(-1,3,1), n);
-				sector->setNode(gp+v3s16(-1,3,-1), n);
-				sector->setNode(gp+v3s16(1,3,-1), n);
-				
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,2,0), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(1,2,0), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(0,2,-1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(0,2,1), n);
-				/*if(myrand()%3!=0) sector->setNode(gp+v3s16(1,2,1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,2,1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,2,-1), n);
-				if(myrand()%3!=0) sector->setNode(gp+v3s16(1,2,-1), n);*/
-				
-				// Objects are identified by wanted position
-				objects_to_remove.push_back(p);
-				
-				// Lighting has to be recalculated for this one.
-				sector->getBlocksInArea(p_min, p_max, 
-						lighting_invalidated_blocks);
-			}
-		}
-		else if(d == SECTOR_OBJECT_BUSH_1)
-		{
-			if(ground_found == false)
-				continue;
-			
-			if(sector->isValidArea(gp + v3s16(0,0,0),
-					gp + v3s16(0,0,0), &changed_blocks_sector))
-			{
-				MapNode n;
-				n.d = CONTENT_LEAVES;
-				sector->setNode(gp+v3s16(0,0,0), n);
-				
-				// Objects are identified by wanted position
-				objects_to_remove.push_back(p);
-			}
-		}
-		else if(d == SECTOR_OBJECT_RAVINE)
-		{
-			s16 maxdepth = -20;
-			v3s16 p_min = p + v3s16(-6,maxdepth,-6);
-			v3s16 p_max = p + v3s16(6,6,6);
-			if(sector->isValidArea(p_min, p_max,
-					&changed_blocks_sector))
-			{
-				MapNode n;
-				n.d = CONTENT_STONE;
-				MapNode n2;
-				n2.d = CONTENT_AIR;
-				s16 depth = maxdepth + (myrand()%10);
-				s16 z = 0;
-				s16 minz = -6 - (-2);
-				s16 maxz = 6 -1;
-				for(s16 x=-6; x<=6; x++)
-				{
-					z += -1 + (myrand()%3);
-					if(z < minz)
-						z = minz;
-					if(z > maxz)
-						z = maxz;
-					for(s16 y=depth+(myrand()%2); y<=6; y++)
-					{
-						/*std::cout<<"("<<p2.X<<","<<p2.Y<<","<<p2.Z<<")"
-								<<std::endl;*/
-						{
-							v3s16 p2 = p + v3s16(x,y,z-2);
-							if(is_ground_content(sector->getNode(p2).d)
-									&& !is_mineral(sector->getNode(p2).d))
-								sector->setNode(p2, n);
-						}
-						{
-							v3s16 p2 = p + v3s16(x,y,z-1);
-							if(is_ground_content(sector->getNode(p2).d)
-									&& !is_mineral(sector->getNode(p2).d))
-								sector->setNode(p2, n2);
-						}
-						{
-							v3s16 p2 = p + v3s16(x,y,z+0);
-							if(is_ground_content(sector->getNode(p2).d)
-									&& !is_mineral(sector->getNode(p2).d))
-								sector->setNode(p2, n2);
-						}
-						{
-							v3s16 p2 = p + v3s16(x,y,z+1);
-							if(is_ground_content(sector->getNode(p2).d)
-									&& !is_mineral(sector->getNode(p2).d))
-								sector->setNode(p2, n);
-						}
+	if(block == NULL)
+	{
+		does_not_exist = true;
+	}
+	else if(block->isDummy() == true)
+	{
+		does_not_exist = true;
+	}
+	else if(block->getLightingExpired())
+	{
+		lighting_expired = true;
+	}
+	else
+	{
+		// Valid block
+		//dstream<<"emergeBlock(): Returning already valid block"<<std::endl;
+		return block;
+	}
+	
+	/*
+		If block was not found on disk and not going to generate a
+		new one, make sure there is a dummy block in place.
+	*/
+	if(only_from_disk && (does_not_exist || lighting_expired))
+	{
+		//dstream<<"emergeBlock(): Was not on disk but not generating"<<std::endl;
 
-						//if(sector->getNode(p+v3s16(x,y,z+1)).solidness()==2)
-						//if(p.Y+y <= sector->getGroundHeight(p2d+v2s16(x,z-2))+0.5)
-					}
-				}
-				
-				objects_to_remove.push_back(p);
-				
-				// Lighting has to be recalculated for this one.
-				sector->getBlocksInArea(p_min, p_max, 
-						lighting_invalidated_blocks);
-			}
-		}
-		else
+		if(block == NULL)
 		{
-			dstream<<"ServerMap::emergeBlock(): "
-					"Invalid heightmap object"
-					<<std::endl;
-		}
+			// Create dummy block
+			block = new MapBlock(this, p, true);
 
-		}//try
-		catch(InvalidPositionException &e)
-		{
-			dstream<<"WARNING: "<<__FUNCTION_NAME
-					<<": while inserting object "<<(int)d
-					<<" to ("<<p.X<<","<<p.Y<<","<<p.Z<<"):"
-					<<" InvalidPositionException.what()="
-					<<e.what()<<std::endl;
-			// This is not too fatal and seems to happen sometimes.
-			assert(0);
+			// Add block to sector
+			sector->insertBlock(block);
 		}
+		// Done.
+		return block;
+	}
+
+	//dstream<<"Not found on disk, generating."<<std::endl;
+	// 0ms
+	//TimeTaker("emergeBlock() generate");
+
+	//dstream<<"emergeBlock(): Didn't find valid block -> making one"<<std::endl;
+
+	/*
+		If the block doesn't exist, generate the block.
+	*/
+	if(does_not_exist)
+	{
+		block = generateBlock(p, block, sector, changed_blocks,
+				lighting_invalidated_blocks); 
 	}
 
-	for(core::list<v3s16>::Iterator i = objects_to_remove.begin();
-			i != objects_to_remove.end(); i++)
+	if(lighting_expired)
 	{
-		objects->remove(*i);
+		lighting_invalidated_blocks.insert(p, block);
 	}
 
 	/*
@@ -3047,7 +4821,8 @@ MapBlock * ServerMap::emergeBlock(
 
 		// If sunlight didn't reach everywhere and part of block is
 		// above ground, lighting has to be properly updated
-		if(black_air_left && some_part_underground)
+		//if(black_air_left && some_part_underground)
+		if(black_air_left)
 		{
 			lighting_invalidated_blocks[block->getPos()] = block;
 		}
@@ -3057,53 +4832,52 @@ MapBlock * ServerMap::emergeBlock(
 			lighting_invalidated_blocks[block->getPos()] = block;
 		}
 	}
+	
+	return block;
+}
 
+s16 ServerMap::findGroundLevel(v2s16 p2d)
+{
 	/*
-		Translate sector's changed blocks to global changed blocks
+		Uh, just do something random...
 	*/
-	
-	for(core::map<s16, MapBlock*>::Iterator
-			i = changed_blocks_sector.getIterator();
-			i.atEnd() == false; i++)
+	// Find existing map from top to down
+	s16 max=63;
+	s16 min=-64;
+	v3s16 p(p2d.X, max, p2d.Y);
+	for(; p.Y>min; p.Y--)
 	{
-		MapBlock *block = i.getNode()->getValue();
-
-		changed_blocks.insert(block->getPos(), block);
+		MapNode n = getNodeNoEx(p);
+		if(n.d != CONTENT_IGNORE)
+			break;
 	}
-
-	/*
-		Debug information
-	*/
-	if(0)
+	if(p.Y == min)
+		goto plan_b;
+	// If this node is not air, go to plan b
+	if(getNodeNoEx(p).d != CONTENT_AIR)
+		goto plan_b;
+	// Search existing walkable and return it
+	for(; p.Y>min; p.Y--)
 	{
-		dstream
-		<<"lighting_invalidated_blocks.size()"
-		<<", has_dungeons"
-		<<", completely_ug"
-		<<", some_part_ug"
-		<<"  "<<lighting_invalidated_blocks.size()
-		<<", "<<has_dungeons
-		<<", "<<completely_underground
-		<<", "<<some_part_underground
-		<<std::endl;
+		MapNode n = getNodeNoEx(p);
+		if(content_walkable(n.d) && n.d != CONTENT_IGNORE)
+			return p.Y;
 	}
-
+	// Move to plan b
+plan_b:
 	/*
-		Debug mode operation
+		Plan B: Get from map generator perlin noise function
 	*/
-	bool haxmode = g_settings.getBool("haxmode");
-	if(haxmode)
-	{
-		// Don't calculate lighting at all
-		//lighting_invalidated_blocks.clear();
-	}
-
-	return block;
+	// This won't work if proper generation is disabled
+	if(m_chunksize == 0)
+		return WATER_LEVEL+2;
+	double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
+	return (s16)level;
 }
 
-void ServerMap::createDir(std::string path)
+void ServerMap::createDirs(std::string path)
 {
-	if(fs::CreateDir(path) == false)
+	if(fs::CreateAllDirs(path) == false)
 	{
 		m_dout<<DTIME<<"ServerMap: Failed to create directory "
 				<<"\""<<path<<"\""<<std::endl;
@@ -3111,29 +4885,52 @@ void ServerMap::createDir(std::string path)
 	}
 }
 
-std::string ServerMap::getSectorSubDir(v2s16 pos)
+std::string ServerMap::getSectorDir(v2s16 pos, int layout)
 {
 	char cc[9];
-	snprintf(cc, 9, "%.4x%.4x",
-			(unsigned int)pos.X&0xffff,
-			(unsigned int)pos.Y&0xffff);
-
-	return std::string(cc);
-}
-
-std::string ServerMap::getSectorDir(v2s16 pos)
-{
-	return m_savedir + "/sectors/" + getSectorSubDir(pos);
+	switch(layout)
+	{
+		case 1:
+			snprintf(cc, 9, "%.4x%.4x",
+				(unsigned int)pos.X&0xffff,
+				(unsigned int)pos.Y&0xffff);
+
+			return m_savedir + "/sectors/" + cc;
+		case 2:
+			snprintf(cc, 9, "%.3x/%.3x",
+				(unsigned int)pos.X&0xfff,
+				(unsigned int)pos.Y&0xfff);
+
+			return m_savedir + "/sectors2/" + cc;
+		default:
+			assert(false);
+	}
 }
 
 v2s16 ServerMap::getSectorPos(std::string dirname)
 {
-	if(dirname.size() != 8)
-		throw InvalidFilenameException("Invalid sector directory name");
 	unsigned int x, y;
-	int r = sscanf(dirname.c_str(), "%4x%4x", &x, &y);
-	if(r != 2)
-		throw InvalidFilenameException("Invalid sector directory name");
+	int r;
+	size_t spos = dirname.rfind('/') + 1;
+	assert(spos != std::string::npos);
+	if(dirname.size() - spos == 8)
+	{
+		// Old layout
+		r = sscanf(dirname.substr(spos).c_str(), "%4x%4x", &x, &y);
+	}
+	else if(dirname.size() - spos == 3)
+	{
+		// New layout
+		r = sscanf(dirname.substr(spos-4).c_str(), "%3x/%3x", &x, &y);
+		// Sign-extend the 12 bit values up to 16 bits...
+		if(x&0x800) x|=0xF000;
+		if(y&0x800) y|=0xF000;
+	}
+	else
+	{
+		assert(false);
+	}
+	assert(r == 2);
 	v2s16 pos((s16)x, (s16)y);
 	return pos;
 }
@@ -3152,12 +4949,6 @@ v3s16 ServerMap::getBlockPos(std::string sectordir, std::string blockfile)
 	return v3s16(p2d.X, y, p2d.Y);
 }
 
-// Debug helpers
-#define ENABLE_SECTOR_SAVING 1
-#define ENABLE_SECTOR_LOADING 1
-#define ENABLE_BLOCK_SAVING 1
-#define ENABLE_BLOCK_LOADING 1
-
 void ServerMap::save(bool only_changed)
 {
 	DSTACK(__FUNCTION_NAME);
@@ -3171,41 +4962,51 @@ void ServerMap::save(bool only_changed)
 		dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
 				<<std::endl;
 	
-	saveMasterHeightmap();
+	if(only_changed == false || m_map_metadata_changed)
+	{
+		saveMapMeta();
+	}
+
+	// Disable saving chunk metadata if chunks are disabled
+	if(m_chunksize != 0)
+	{
+		if(only_changed == false || anyChunkModified())
+			saveChunkMeta();
+	}
 	
 	u32 sector_meta_count = 0;
 	u32 block_count = 0;
 	
 	{ //sectorlock
-	JMutexAutoLock lock(m_sector_mutex);
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 	
 	core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
 	for(; i.atEnd() == false; i++)
 	{
 		ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
 		assert(sector->getId() == MAPSECTOR_SERVER);
-		
-		if(ENABLE_SECTOR_SAVING)
+	
+		if(sector->differs_from_disk || only_changed == false)
 		{
-			if(sector->differs_from_disk || only_changed == false)
-			{
-				saveSectorMeta(sector);
-				sector_meta_count++;
-			}
+			saveSectorMeta(sector);
+			sector_meta_count++;
 		}
-		if(ENABLE_BLOCK_SAVING)
+		core::list<MapBlock*> blocks;
+		sector->getBlocks(blocks);
+		core::list<MapBlock*>::Iterator j;
+		for(j=blocks.begin(); j!=blocks.end(); j++)
 		{
-			core::list<MapBlock*> blocks;
-			sector->getBlocks(blocks);
-			core::list<MapBlock*>::Iterator j;
-			for(j=blocks.begin(); j!=blocks.end(); j++)
+			MapBlock *block = *j;
+			if(block->getChangedFlag() || only_changed == false)
 			{
-				MapBlock *block = *j;
-				if(block->getChangedFlag() || only_changed == false)
-				{
-					saveBlock(block);
-					block_count++;
-				}
+				saveBlock(block);
+				block_count++;
+
+				/*dstream<<"ServerMap: Written block ("
+						<<block->getPos().X<<","
+						<<block->getPos().Y<<","
+						<<block->getPos().Z<<")"
+						<<std::endl;*/
 			}
 		}
 	}
@@ -3225,18 +5026,21 @@ void ServerMap::save(bool only_changed)
 	}
 }
 
+#if 0
+// NOTE: Doing this is insane. Deprecated and probably broken.
 void ServerMap::loadAll()
 {
 	DSTACK(__FUNCTION_NAME);
 	dstream<<DTIME<<"ServerMap: Loading map..."<<std::endl;
-
-	loadMasterHeightmap();
+	
+	loadMapMeta();
+	loadChunkMeta();
 
 	std::vector<fs::DirListNode> list = fs::GetDirListing(m_savedir+"/sectors/");
 
 	dstream<<DTIME<<"There are "<<list.size()<<" sectors."<<std::endl;
 	
-	JMutexAutoLock lock(m_sector_mutex);
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 	
 	s32 counter = 0;
 	s32 printed_counter = -100000;
@@ -3265,72 +5069,218 @@ void ServerMap::loadAll()
 			// This catches unknown crap in directory
 		}
 		
-		if(ENABLE_BLOCK_LOADING)
+		std::vector<fs::DirListNode> list2 = fs::GetDirListing
+				(m_savedir+"/sectors/"+i->name);
+		std::vector<fs::DirListNode>::iterator i2;
+		for(i2=list2.begin(); i2!=list2.end(); i2++)
 		{
-			std::vector<fs::DirListNode> list2 = fs::GetDirListing
-					(m_savedir+"/sectors/"+i->name);
-			std::vector<fs::DirListNode>::iterator i2;
-			for(i2=list2.begin(); i2!=list2.end(); i2++)
+			// We want files
+			if(i2->dir)
+				continue;
+			try{
+				loadBlock(i->name, i2->name, sector);
+			}
+			catch(InvalidFilenameException &e)
 			{
-				// We want files
-				if(i2->dir)
-					continue;
-				try{
-					loadBlock(i->name, i2->name, sector);
-				}
-				catch(InvalidFilenameException &e)
-				{
-					// This catches unknown crap in directory
-				}
+				// This catches unknown crap in directory
 			}
 		}
 	}
 	dstream<<DTIME<<"ServerMap: Map loaded."<<std::endl;
 }
+#endif
 
+#if 0
 void ServerMap::saveMasterHeightmap()
 {
 	DSTACK(__FUNCTION_NAME);
+	
+	dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
+
 	createDir(m_savedir);
 	
-	std::string fullpath = m_savedir + "/master_heightmap";
+	/*std::string fullpath = m_savedir + "/master_heightmap";
 	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
 	if(o.good() == false)
-		throw FileNotGoodException("Cannot open master heightmap");
+		throw FileNotGoodException("Cannot open master heightmap");*/
 	
 	// Format used for writing
-	u8 version = SER_FMT_VER_HIGHEST;
-
-#if 0
-	SharedBuffer<u8> hmdata = m_heightmap->serialize(version);
-	/*
-		[0] u8 serialization version
-		[1] X master heightmap
-	*/
-	u32 fullsize = 1 + hmdata.getSize();
-	SharedBuffer<u8> data(fullsize);
+	//u8 version = SER_FMT_VER_HIGHEST;
+}
 
-	data[0] = version;
-	memcpy(&data[1], *hmdata, hmdata.getSize());
+void ServerMap::loadMasterHeightmap()
+{
+	DSTACK(__FUNCTION_NAME);
+	
+	dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
 
-	o.write((const char*)*data, fullsize);
+	/*std::string fullpath = m_savedir + "/master_heightmap";
+	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+	if(is.good() == false)
+		throw FileNotGoodException("Cannot open master heightmap");*/
+}
 #endif
+
+void ServerMap::saveMapMeta()
+{
+	DSTACK(__FUNCTION_NAME);
+	
+	dstream<<"INFO: ServerMap::saveMapMeta(): "
+			<<"seed="<<m_seed<<", chunksize="<<m_chunksize
+			<<std::endl;
+
+	createDirs(m_savedir);
+	
+	std::string fullpath = m_savedir + "/map_meta.txt";
+	std::ofstream os(fullpath.c_str(), std::ios_base::binary);
+	if(os.good() == false)
+	{
+		dstream<<"ERROR: ServerMap::saveMapMeta(): "
+				<<"could not open"<<fullpath<<std::endl;
+		throw FileNotGoodException("Cannot open chunk metadata");
+	}
+	
+	Settings params;
+	params.setU64("seed", m_seed);
+	params.setS32("chunksize", m_chunksize);
+
+	params.writeLines(os);
+
+	os<<"[end_of_params]\n";
 	
-	m_heightmap->serialize(o, version);
+	m_map_metadata_changed = false;
 }
 
-void ServerMap::loadMasterHeightmap()
+void ServerMap::loadMapMeta()
 {
 	DSTACK(__FUNCTION_NAME);
-	std::string fullpath = m_savedir + "/master_heightmap";
+	
+	dstream<<"INFO: ServerMap::loadMapMeta(): Loading map metadata"
+			<<std::endl;
+
+	std::string fullpath = m_savedir + "/map_meta.txt";
 	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
 	if(is.good() == false)
-		throw FileNotGoodException("Cannot open master heightmap");
+	{
+		dstream<<"ERROR: ServerMap::loadMapMeta(): "
+				<<"could not open"<<fullpath<<std::endl;
+		throw FileNotGoodException("Cannot open map metadata");
+	}
+
+	Settings params;
+
+	for(;;)
+	{
+		if(is.eof())
+			throw SerializationError
+					("ServerMap::loadMapMeta(): [end_of_params] not found");
+		std::string line;
+		std::getline(is, line);
+		std::string trimmedline = trim(line);
+		if(trimmedline == "[end_of_params]")
+			break;
+		params.parseConfigLine(line);
+	}
+
+	m_seed = params.getU64("seed");
+	m_chunksize = params.getS32("chunksize");
+
+	dstream<<"INFO: ServerMap::loadMapMeta(): "
+			<<"seed="<<m_seed<<", chunksize="<<m_chunksize
+			<<std::endl;
+}
+
+void ServerMap::saveChunkMeta()
+{
+	DSTACK(__FUNCTION_NAME);
+
+	// This should not be called if chunks are disabled.
+	assert(m_chunksize != 0);
 	
-	if(m_heightmap != NULL)
-		delete m_heightmap;
-		
-	m_heightmap = UnlimitedHeightmap::deSerialize(is, &m_padb);
+	u32 count = m_chunks.size();
+
+	dstream<<"INFO: ServerMap::saveChunkMeta(): Saving metadata of "
+			<<count<<" chunks"<<std::endl;
+
+	createDirs(m_savedir);
+	
+	std::string fullpath = m_savedir + "/chunk_meta";
+	std::ofstream os(fullpath.c_str(), std::ios_base::binary);
+	if(os.good() == false)
+	{
+		dstream<<"ERROR: ServerMap::saveChunkMeta(): "
+				<<"could not open"<<fullpath<<std::endl;
+		throw FileNotGoodException("Cannot open chunk metadata");
+	}
+	
+	u8 version = 0;
+	
+	// Write version
+	os.write((char*)&version, 1);
+
+	u8 buf[4];
+	
+	// Write count
+	writeU32(buf, count);
+	os.write((char*)buf, 4);
+	
+	for(core::map<v2s16, MapChunk*>::Iterator
+			i = m_chunks.getIterator();
+			i.atEnd()==false; i++)
+	{
+		v2s16 p = i.getNode()->getKey();
+		MapChunk *chunk = i.getNode()->getValue();
+		// Write position
+		writeV2S16(buf, p);
+		os.write((char*)buf, 4);
+		// Write chunk data
+		chunk->serialize(os, version);
+	}
+
+	setChunksNonModified();
+}
+
+void ServerMap::loadChunkMeta()
+{
+	DSTACK(__FUNCTION_NAME);
+	
+	dstream<<"INFO: ServerMap::loadChunkMeta(): Loading chunk metadata"
+			<<std::endl;
+
+	std::string fullpath = m_savedir + "/chunk_meta";
+	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+	if(is.good() == false)
+	{
+		dstream<<"ERROR: ServerMap::loadChunkMeta(): "
+				<<"could not open"<<fullpath<<std::endl;
+		throw FileNotGoodException("Cannot open chunk metadata");
+	}
+
+	u8 version = 0;
+	
+	// Read version
+	is.read((char*)&version, 1);
+
+	u8 buf[4];
+	
+	// Read count
+	is.read((char*)buf, 4);
+	u32 count = readU32(buf);
+
+	dstream<<"INFO: ServerMap::loadChunkMeta(): Loading metadata of "
+			<<count<<" chunks"<<std::endl;
+	
+	for(u32 i=0; i<count; i++)
+	{
+		v2s16 p;
+		MapChunk *chunk = new MapChunk();
+		// Read position
+		is.read((char*)buf, 4);
+		p = readV2S16(buf);
+		// Read chunk data
+		chunk->deSerialize(is, version);
+		m_chunks.insert(p, chunk);
+	}
 }
 
 void ServerMap::saveSectorMeta(ServerMapSector *sector)
@@ -3340,35 +5290,54 @@ void ServerMap::saveSectorMeta(ServerMapSector *sector)
 	u8 version = SER_FMT_VER_HIGHEST;
 	// Get destination
 	v2s16 pos = sector->getPos();
-	createDir(m_savedir);
-	createDir(m_savedir+"/sectors");
 	std::string dir = getSectorDir(pos);
-	createDir(dir);
+	createDirs(dir);
 	
-	std::string fullpath = dir + "/heightmap";
+	std::string fullpath = dir + "/meta";
 	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
 	if(o.good() == false)
-		throw FileNotGoodException("Cannot open master heightmap");
+		throw FileNotGoodException("Cannot open sector metafile");
 
 	sector->serialize(o, version);
 	
 	sector->differs_from_disk = false;
 }
 
-MapSector* ServerMap::loadSectorMeta(std::string dirname)
+MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load)
 {
 	DSTACK(__FUNCTION_NAME);
 	// Get destination
-	v2s16 p2d = getSectorPos(dirname);
-	std::string dir = m_savedir + "/sectors/" + dirname;
-	
-	std::string fullpath = dir + "/heightmap";
+	v2s16 p2d = getSectorPos(sectordir);
+
+	ServerMapSector *sector = NULL;
+
+	std::string fullpath = sectordir + "/meta";
 	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
 	if(is.good() == false)
-		throw FileNotGoodException("Cannot open sector heightmap");
-
-	ServerMapSector *sector = ServerMapSector::deSerialize
-			(is, this, p2d, &m_hwrapper, m_sectors);
+	{
+		// If the directory exists anyway, it probably is in some old
+		// format. Just go ahead and create the sector.
+		if(fs::PathExists(sectordir))
+		{
+			dstream<<"ServerMap::loadSectorMeta(): Sector metafile "
+					<<fullpath<<" doesn't exist but directory does."
+					<<" Continuing with a sector with no metadata."
+					<<std::endl;
+			sector = new ServerMapSector(this, p2d);
+			m_sectors.insert(p2d, sector);
+		}
+		else
+		{
+			throw FileNotGoodException("Cannot open sector metafile");
+		}
+	}
+	else
+	{
+		sector = ServerMapSector::deSerialize
+				(is, this, p2d, m_sectors);
+		if(save_after_load)
+			saveSectorMeta(sector);
+	}
 	
 	sector->differs_from_disk = false;
 
@@ -3378,14 +5347,31 @@ MapSector* ServerMap::loadSectorMeta(std::string dirname)
 bool ServerMap::loadSectorFull(v2s16 p2d)
 {
 	DSTACK(__FUNCTION_NAME);
-	std::string sectorsubdir = getSectorSubDir(p2d);
 
 	MapSector *sector = NULL;
 
-	JMutexAutoLock lock(m_sector_mutex);
+	// The directory layout we're going to load from.
+	//  1 - original sectors/xxxxzzzz/
+	//  2 - new sectors2/xxx/zzz/
+	//  If we load from anything but the latest structure, we will
+	//  immediately save to the new one, and remove the old.
+	int loadlayout = 1;
+	std::string sectordir1 = getSectorDir(p2d, 1);
+	std::string sectordir;
+	if(fs::PathExists(sectordir1))
+	{
+		sectordir = sectordir1;
+	}
+	else
+	{
+		loadlayout = 2;
+		sectordir = getSectorDir(p2d, 2);
+	}
+
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 
 	try{
-		sector = loadSectorMeta(sectorsubdir);
+		sector = loadSectorMeta(sectordir, loadlayout != 2);
 	}
 	catch(InvalidFilenameException &e)
 	{
@@ -3399,51 +5385,37 @@ bool ServerMap::loadSectorFull(v2s16 p2d)
 	{
 		return false;
 	}
-
-	if(ENABLE_BLOCK_LOADING)
+	
+	/*
+		Load blocks
+	*/
+	std::vector<fs::DirListNode> list2 = fs::GetDirListing
+			(sectordir);
+	std::vector<fs::DirListNode>::iterator i2;
+	for(i2=list2.begin(); i2!=list2.end(); i2++)
 	{
-		std::vector<fs::DirListNode> list2 = fs::GetDirListing
-				(m_savedir+"/sectors/"+sectorsubdir);
-		std::vector<fs::DirListNode>::iterator i2;
-		for(i2=list2.begin(); i2!=list2.end(); i2++)
+		// We want files
+		if(i2->dir)
+			continue;
+		try{
+			loadBlock(sectordir, i2->name, sector, loadlayout != 2);
+		}
+		catch(InvalidFilenameException &e)
 		{
-			// We want files
-			if(i2->dir)
-				continue;
-			try{
-				loadBlock(sectorsubdir, i2->name, sector);
-			}
-			catch(InvalidFilenameException &e)
-			{
-				// This catches unknown crap in directory
-			}
+			// This catches unknown crap in directory
 		}
 	}
-	return true;
-}
 
-#if 0
-bool ServerMap::deFlushSector(v2s16 p2d)
-{
-	DSTACK(__FUNCTION_NAME);
-	// See if it already exists in memory
-	try{
-		MapSector *sector = getSectorNoGenerate(p2d);
-		return true;
-	}
-	catch(InvalidPositionException &e)
+	if(loadlayout != 2)
 	{
-		/*
-			Try to load the sector from disk.
-		*/
-		if(loadSectorFull(p2d) == true)
-		{
-			return true;
-		}
+		dstream<<"Sector converted to new layout - deleting "<<
+			sectordir1<<std::endl;
+		fs::RecursiveDelete(sectordir1);
 	}
-	return false;
+
+	return true;
 }
-#endif
+
 
 void ServerMap::saveBlock(MapBlock *block)
 {
@@ -3464,12 +5436,9 @@ void ServerMap::saveBlock(MapBlock *block)
 	// Get destination
 	v3s16 p3d = block->getPos();
 	v2s16 p2d(p3d.X, p3d.Z);
-	createDir(m_savedir);
-	createDir(m_savedir+"/sectors");
 	std::string dir = getSectorDir(p2d);
-	createDir(dir);
+	createDirs(dir);
 	
-	// Block file is map/sectors/xxxxxxxx/xxxx
 	char cc[5];
 	snprintf(cc, 5, "%.4x", (unsigned int)p3d.Y&0xffff);
 	std::string fullpath = dir + "/" + cc;
@@ -3493,103 +5462,104 @@ void ServerMap::saveBlock(MapBlock *block)
 		block->serializeObjects(o, version);
 	}
 	
+	/*
+		Versions up from 15 have static objects.
+	*/
+	if(version >= 15)
+	{
+		block->m_static_objects.serialize(o);
+	}
+	
 	// We just wrote it to the disk
 	block->resetChangedFlag();
 }
 
-void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector)
+void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load)
 {
 	DSTACK(__FUNCTION_NAME);
 
+	std::string fullpath = sectordir+"/"+blockfile;
 	try{
 
-	// Block file is map/sectors/xxxxxxxx/xxxx
-	std::string fullpath = m_savedir+"/sectors/"+sectordir+"/"+blockfile;
-	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
-	if(is.good() == false)
-		throw FileNotGoodException("Cannot open block file");
+		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);
 
-	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);
+		if(is.fail())
+			throw SerializationError("ServerMap::loadBlock(): Failed"
+					" to read MapBlock version");
 
-	/*u32 block_size = MapBlock::serializedLength(version);
-	SharedBuffer<u8> data(block_size);
-	is.read((char*)*data, block_size);*/
+		/*u32 block_size = MapBlock::serializedLength(version);
+		SharedBuffer<u8> data(block_size);
+		is.read((char*)*data, block_size);*/
 
-	// This will always return a sector because we're the server
-	//MapSector *sector = emergeSector(p2d);
+		// This will always return a sector because we're the server
+		//MapSector *sector = emergeSector(p2d);
 
-	MapBlock *block = NULL;
-	bool created_new = false;
-	try{
-		block = sector->getBlockNoCreate(p3d.Y);
-	}
-	catch(InvalidPositionException &e)
-	{
-		block = sector->createBlankBlockNoInsert(p3d.Y);
-		created_new = true;
-	}
-	
-	// deserialize block data
-	block->deSerialize(is, version);
-	
-	/*
-		Versions up from 9 have block objects.
-	*/
-	if(version >= 9)
-	{
-		block->updateObjects(is, version, NULL, 0);
-	}
+		MapBlock *block = NULL;
+		bool created_new = false;
+		try{
+			block = sector->getBlockNoCreate(p3d.Y);
+		}
+		catch(InvalidPositionException &e)
+		{
+			block = sector->createBlankBlockNoInsert(p3d.Y);
+			created_new = true;
+		}
+		
+		// deserialize block data
+		block->deSerialize(is, version);
+		
+		/*
+			Versions up from 9 have block objects.
+		*/
+		if(version >= 9)
+		{
+			block->updateObjects(is, version, NULL, 0);
+		}
 
-	if(created_new)
-		sector->insertBlock(block);
-	
-	/*
-		Convert old formats to new and save
-	*/
+		/*
+			Versions up from 15 have static objects.
+		*/
+		if(version >= 15)
+		{
+			block->m_static_objects.deSerialize(is);
+		}
+		
+		if(created_new)
+			sector->insertBlock(block);
+		
+		/*
+			Convert old formats to new and save
+		*/
 
-	// Save old format blocks in new format
-	if(version < SER_FMT_VER_HIGHEST)
-	{
-		saveBlock(block);
-	}
-	
-	// We just loaded it from the disk, so it's up-to-date.
-	block->resetChangedFlag();
+		// Save old format blocks in new format
+		if(version < SER_FMT_VER_HIGHEST || save_after_load)
+		{
+			saveBlock(block);
+		}
+		
+		// We just loaded it from the disk, so it's up-to-date.
+		block->resetChangedFlag();
 
 	}
 	catch(SerializationError &e)
 	{
 		dstream<<"WARNING: Invalid block data on disk "
-				"(SerializationError). Ignoring."
+				"(SerializationError). Ignoring. "
+				"A new one will be generated."
 				<<std::endl;
-	}
-}
 
-// Gets from master heightmap
-void ServerMap::getSectorCorners(v2s16 p2d, s16 *corners)
-{
-	assert(m_heightmap != NULL);
-	/*
-		Corner definition:
-		v2s16(0,0),
-		v2s16(1,0),
-		v2s16(1,1),
-		v2s16(0,1),
-	*/
-	corners[0] = m_heightmap->getGroundHeight
-			((p2d+v2s16(0,0))*SECTOR_HEIGHTMAP_SPLIT);
-	corners[1] = m_heightmap->getGroundHeight
-			((p2d+v2s16(1,0))*SECTOR_HEIGHTMAP_SPLIT);
-	corners[2] = m_heightmap->getGroundHeight
-			((p2d+v2s16(1,1))*SECTOR_HEIGHTMAP_SPLIT);
-	corners[3] = m_heightmap->getGroundHeight
-			((p2d+v2s16(0,1))*SECTOR_HEIGHTMAP_SPLIT);
+		// TODO: Backup file; name is in fullpath.
+	}
 }
 
 void ServerMap::PrintInfo(std::ostream &out)
@@ -3613,32 +5583,26 @@ ClientMap::ClientMap(
 	Map(dout_client),
 	scene::ISceneNode(parent, mgr, id),
 	m_client(client),
-	mesh(NULL),
-	m_control(control)
+	m_control(control),
+	m_camera_position(0,0,0),
+	m_camera_direction(0,0,1)
 {
-	mesh_mutex.Init();
-
-	/*m_box = core::aabbox3d<f32>(0,0,0,
-			map->getW()*BS, map->getH()*BS, map->getD()*BS);*/
-	/*m_box = core::aabbox3d<f32>(0,0,0,
-			map->getSizeNodes().X * BS,
-			map->getSizeNodes().Y * BS,
-			map->getSizeNodes().Z * BS);*/
+	m_camera_mutex.Init();
+	assert(m_camera_mutex.IsInitialized());
+	
 	m_box = core::aabbox3d<f32>(-BS*1000000,-BS*1000000,-BS*1000000,
 			BS*1000000,BS*1000000,BS*1000000);
-	
-	//setPosition(v3f(BS,BS,BS));
 }
 
 ClientMap::~ClientMap()
 {
-	JMutexAutoLock lock(mesh_mutex);
+	/*JMutexAutoLock lock(mesh_mutex);
 	
 	if(mesh != NULL)
 	{
 		mesh->drop();
 		mesh = NULL;
-	}
+	}*/
 }
 
 MapSector * ClientMap::emergeSector(v2s16 p2d)
@@ -3652,11 +5616,11 @@ MapSector * ClientMap::emergeSector(v2s16 p2d)
 	{
 	}
 	
-	// Create a sector with no heightmaps
+	// Create a sector
 	ClientMapSector *sector = new ClientMapSector(this, p2d);
 	
 	{
-		JMutexAutoLock lock(m_sector_mutex);
+		//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 		m_sectors.insert(p2d, sector);
 	}
 	
@@ -3668,7 +5632,7 @@ void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is)
 	DSTACK(__FUNCTION_NAME);
 	ClientMapSector *sector = NULL;
 
-	JMutexAutoLock lock(m_sector_mutex);
+	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 	
 	core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p2d);
 
@@ -3681,7 +5645,7 @@ void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is)
 	{
 		sector = new ClientMapSector(this, p2d);
 		{
-			JMutexAutoLock lock(m_sector_mutex);
+			//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
 			m_sectors.insert(p2d, sector);
 		}
 	}
@@ -3715,7 +5679,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 	*/
 	int time1 = time(0);
 
-	u32 daynight_ratio = m_client->getDayNightRatio();
+	//u32 daynight_ratio = m_client->getDayNightRatio();
 
 	m_camera_mutex.Lock();
 	v3f camera_position = m_camera_position;
@@ -3766,6 +5730,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 			timecheck_counter++;
 			if(timecheck_counter > 50)
 			{
+				timecheck_counter = 0;
 				int time2 = time(0);
 				if(time2 > time1 + 4)
 				{
@@ -3809,80 +5774,25 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 			float range = 100000 * BS;
 			if(m_control.range_all == false)
 				range = m_control.wanted_range * BS;
-
+			
+			float d = 0.0;
 			if(isBlockInSight(block->getPos(), camera_position,
-					camera_direction, range) == false)
+					camera_direction, range, &d) == false)
 			{
 				continue;
 			}
-
-#if 0			
-			v3s16 blockpos_nodes = block->getPosRelative();
-			
-			// Block center position
-			v3f blockpos(
-					((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS,
-					((float)blockpos_nodes.Y + MAP_BLOCKSIZE/2) * BS,
-					((float)blockpos_nodes.Z + MAP_BLOCKSIZE/2) * BS
-			);
-
-			// Block position relative to camera
-			v3f blockpos_relative = blockpos - camera_position;
-
-			// Distance in camera direction (+=front, -=back)
-			f32 dforward = blockpos_relative.dotProduct(camera_direction);
-
-			// Total distance
-			f32 d = blockpos_relative.getLength();
-			
-			if(m_control.range_all == false)
-			{
-				// If block is far away, don't draw it
-				if(d > m_control.wanted_range * BS)
-					continue;
-			}
-			
-			// Maximum radius of a block
-			f32 block_max_radius = 0.5*1.44*1.44*MAP_BLOCKSIZE*BS;
-			
-			// If block is (nearly) touching the camera, don't
-			// bother validating further (that is, render it anyway)
-			if(d > block_max_radius * 1.5)
-			{
-				// Cosine of the angle between the camera direction
-				// and the block direction (camera_direction is an unit vector)
-				f32 cosangle = dforward / d;
-				
-				// Compensate for the size of the block
-				// (as the block has to be shown even if it's a bit off FOV)
-				// This is an estimate.
-				cosangle += block_max_radius / dforward;
-
-				// If block is not in the field of view, skip it
-				//if(cosangle < cos(FOV_ANGLE/2))
-				if(cosangle < cos(FOV_ANGLE/2. * 4./3.))
-					continue;
-			}
-#endif			
-
-			v3s16 blockpos_nodes = block->getPosRelative();
 			
-			// Block center position
-			v3f blockpos(
-					((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS,
-					((float)blockpos_nodes.Y + MAP_BLOCKSIZE/2) * BS,
-					((float)blockpos_nodes.Z + MAP_BLOCKSIZE/2) * BS
-			);
-
-			// Block position relative to camera
-			v3f blockpos_relative = blockpos - camera_position;
+			// This is ugly (spherical distance limit?)
+			/*if(m_control.range_all == false &&
+					d - 0.5*BS*MAP_BLOCKSIZE > range)
+				continue;*/
 
-			// Total distance
-			f32 d = blockpos_relative.getLength();
-			
 #if 1
 			/*
-				Update expired mesh
+				Update expired mesh (used for day/night change)
+
+				It doesn't work exactly like it should now with the
+				tasked mesh update but whatever.
 			*/
 
 			bool mesh_expired = false;
@@ -3919,28 +5829,12 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 				mesh_update_count++;
 
 				// Mesh has been expired: generate new mesh
-				//block->updateMeshes(daynight_i);
-				block->updateMesh(daynight_ratio);
+				//block->updateMesh(daynight_ratio);
+				m_client->addUpdateMeshTask(block->getPos());
 
 				mesh_expired = false;
 			}
 			
-			/*
-				Don't draw an expired mesh that is far away
-			*/
-			/*if(mesh_expired && d >= faraway)
-			//if(mesh_expired)
-			{
-				// Instead, delete it
-				JMutexAutoLock lock(block->mesh_mutex);
-				if(block->mesh)
-				{
-					block->mesh->drop();
-					block->mesh = NULL;
-				}
-				// And continue to next block
-				continue;
-			}*/
 #endif
 			/*
 				Draw the faces of the block
@@ -3972,6 +5866,11 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 					// Render transparent on transparent pass and likewise.
 					if(transparent == is_transparent_pass)
 					{
+						/*
+							This *shouldn't* hurt too much because Irrlicht
+							doesn't change opengl textures if the old
+							material is set again.
+						*/
 						driver->setMaterial(buf->getMaterial());
 						driver->drawMeshBuffer(buf);
 						vertex_count += buf->getVertexCount();
@@ -3988,8 +5887,10 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 			<<", rendered "<<vertex_count<<" vertices."<<std::endl;*/
 }
 
-v3s16 ClientMap::setTempMod(v3s16 p, NodeMod mod, bool *changed)
+bool ClientMap::setTempMod(v3s16 p, NodeMod mod,
+		core::map<v3s16, MapBlock*> *affected_blocks)
 {
+	bool changed = false;
 	/*
 		Add it to all blocks touching it
 	*/
@@ -4014,14 +5915,29 @@ v3s16 ClientMap::setTempMod(v3s16 p, NodeMod mod, bool *changed)
 		v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 		if(blockref->setTempMod(relpos, mod))
 		{
-			if(changed != NULL)
-				*changed = true;
+			changed = true;
+		}
+	}
+	if(changed && affected_blocks!=NULL)
+	{
+		for(u16 i=0; i<7; i++)
+		{
+			v3s16 p2 = p + dirs[i];
+			// Block position of neighbor (or requested) node
+			v3s16 blockpos = getNodeBlockPos(p2);
+			MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
+			if(blockref == NULL)
+				continue;
+			affected_blocks->insert(blockpos, blockref);
 		}
 	}
-	return getNodeBlockPos(p);
+	return changed;
 }
-v3s16 ClientMap::clearTempMod(v3s16 p, bool *changed)
+
+bool ClientMap::clearTempMod(v3s16 p,
+		core::map<v3s16, MapBlock*> *affected_blocks)
 {
+	bool changed = false;
 	v3s16 dirs[7] = {
 		v3s16(0,0,0), // this
 		v3s16(0,0,1), // back
@@ -4043,12 +5959,132 @@ v3s16 ClientMap::clearTempMod(v3s16 p, bool *changed)
 		v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 		if(blockref->clearTempMod(relpos))
 		{
-			if(changed != NULL)
-				*changed = true;
+			changed = true;
+		}
+	}
+	if(changed && affected_blocks!=NULL)
+	{
+		for(u16 i=0; i<7; i++)
+		{
+			v3s16 p2 = p + dirs[i];
+			// Block position of neighbor (or requested) node
+			v3s16 blockpos = getNodeBlockPos(p2);
+			MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
+			if(blockref == NULL)
+				continue;
+			affected_blocks->insert(blockpos, blockref);
+		}
+	}
+	return changed;
+}
+
+void ClientMap::expireMeshes(bool only_daynight_diffed)
+{
+	TimeTaker timer("expireMeshes()");
+
+	core::map<v2s16, MapSector*>::Iterator si;
+	si = m_sectors.getIterator();
+	for(; si.atEnd() == false; si++)
+	{
+		MapSector *sector = si.getNode()->getValue();
+
+		core::list< MapBlock * > sectorblocks;
+		sector->getBlocks(sectorblocks);
+		
+		core::list< MapBlock * >::Iterator i;
+		for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
+		{
+			MapBlock *block = *i;
+
+			if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false)
+			{
+				continue;
+			}
+			
+			{
+				JMutexAutoLock lock(block->mesh_mutex);
+				if(block->mesh != NULL)
+				{
+					/*block->mesh->drop();
+					block->mesh = NULL;*/
+					block->setMeshExpired(true);
+				}
+			}
+		}
+	}
+}
+
+void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio)
+{
+	assert(mapType() == MAPTYPE_CLIENT);
+
+	try{
+		v3s16 p = blockpos + v3s16(0,0,0);
+		MapBlock *b = getBlockNoCreate(p);
+		b->updateMesh(daynight_ratio);
+		//b->setMeshExpired(true);
+	}
+	catch(InvalidPositionException &e){}
+	// Leading edge
+	try{
+		v3s16 p = blockpos + v3s16(-1,0,0);
+		MapBlock *b = getBlockNoCreate(p);
+		b->updateMesh(daynight_ratio);
+		//b->setMeshExpired(true);
+	}
+	catch(InvalidPositionException &e){}
+	try{
+		v3s16 p = blockpos + v3s16(0,-1,0);
+		MapBlock *b = getBlockNoCreate(p);
+		b->updateMesh(daynight_ratio);
+		//b->setMeshExpired(true);
+	}
+	catch(InvalidPositionException &e){}
+	try{
+		v3s16 p = blockpos + v3s16(0,0,-1);
+		MapBlock *b = getBlockNoCreate(p);
+		b->updateMesh(daynight_ratio);
+		//b->setMeshExpired(true);
+	}
+	catch(InvalidPositionException &e){}
+}
+
+#if 0
+/*
+	Update mesh of block in which the node is, and if the node is at the
+	leading edge, update the appropriate leading blocks too.
+*/
+void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio)
+{
+	v3s16 dirs[4] = {
+		v3s16(0,0,0),
+		v3s16(-1,0,0),
+		v3s16(0,-1,0),
+		v3s16(0,0,-1),
+	};
+	v3s16 blockposes[4];
+	for(u32 i=0; i<4; i++)
+	{
+		v3s16 np = nodepos + dirs[i];
+		blockposes[i] = getNodeBlockPos(np);
+		// Don't update mesh of block if it has been done already
+		bool already_updated = false;
+		for(u32 j=0; j<i; j++)
+		{
+			if(blockposes[j] == blockposes[i])
+			{
+				already_updated = true;
+				break;
+			}
 		}
+		if(already_updated)
+			continue;
+		// Update mesh
+		MapBlock *b = getBlockNoCreate(blockposes[i]);
+		b->updateMesh(daynight_ratio);
 	}
-	return getNodeBlockPos(p);
 }
+#endif
 
 void ClientMap::PrintInfo(std::ostream &out)
 {
@@ -4072,7 +6108,6 @@ MapVoxelManipulator::~MapVoxelManipulator()
 			<<std::endl;*/
 }
 
-#if 1
 void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 {
 	TimeTaker timer1("emerge", &emerge_time);
@@ -4130,51 +6165,14 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 			}
 		}
 
-		m_loaded_blocks.insert(p, true);
+		m_loaded_blocks.insert(p, !block_data_inexistent);
 	}
 
 	//dstream<<"emerge done"<<std::endl;
 }
-#endif
-
-#if 0
-void MapVoxelManipulator::emerge(VoxelArea a)
-{
-	TimeTaker timer1("emerge", &emerge_time);
-	
-	v3s16 size = a.getExtent();
-	
-	VoxelArea padded = a;
-	padded.pad(m_area.getExtent() / 4);
-	addArea(padded);
-
-	for(s16 z=0; z<size.Z; z++)
-	for(s16 y=0; y<size.Y; y++)
-	for(s16 x=0; x<size.X; x++)
-	{
-		v3s16 p(x,y,z);
-		s32 i = m_area.index(a.MinEdge + p);
-		// Don't touch nodes that have already been loaded
-		if(!(m_flags[i] & VOXELFLAG_NOT_LOADED))
-			continue;
-		try
-		{
-			TimeTaker timer1("emerge load", &emerge_load_time);
-			MapNode n = m_map->getNode(a.MinEdge + p);
-			m_data[i] = n;
-			m_flags[i] = 0;
-		}
-		catch(InvalidPositionException &e)
-		{
-			m_flags[i] = VOXELFLAG_INEXISTENT;
-		}
-	}
-}
-#endif
-
 
 /*
-	TODO: Add an option to only update eg. water and air nodes.
+	SUGG: Add an option to only update eg. water and air nodes.
 	      This will make it interfere less with important stuff if
 		  run on background.
 */
@@ -4185,6 +6183,9 @@ void MapVoxelManipulator::blitBack
 		return;
 	
 	//TimeTaker timer1("blitBack");
+
+	/*dstream<<"blitBack(): m_loaded_blocks.size()="
+			<<m_loaded_blocks.size()<<std::endl;*/
 	
 	/*
 		Initialize block cache
@@ -4241,4 +6242,122 @@ void MapVoxelManipulator::blitBack
 	}
 }
 
+ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
+		MapVoxelManipulator(map),
+		m_create_area(false)
+{
+}
+
+ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
+{
+}
+
+void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
+{
+	// Just create the area so that it can be pointed to
+	VoxelManipulator::emerge(a, caller_id);
+}
+
+void ManualMapVoxelManipulator::initialEmerge(
+		v3s16 blockpos_min, v3s16 blockpos_max)
+{
+	TimeTaker timer1("initialEmerge", &emerge_time);
+
+	// Units of these are MapBlocks
+	v3s16 p_min = blockpos_min;
+	v3s16 p_max = blockpos_max;
+
+	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)
+	{
+		dstream<<"initialEmerge: area: ";
+		block_area_nodes.print(dstream);
+		dstream<<" ("<<size_MB<<"MB)";
+		dstream<<std::endl;
+	}
+
+	addArea(block_area_nodes);
+
+	for(s32 z=p_min.Z; z<=p_max.Z; z++)
+	for(s32 y=p_min.Y; y<=p_max.Y; y++)
+	for(s32 x=p_min.X; x<=p_max.X; x++)
+	{
+		v3s16 p(x,y,z);
+		core::map<v3s16, bool>::Node *n;
+		n = m_loaded_blocks.find(p);
+		if(n != NULL)
+			continue;
+		
+		bool block_data_inexistent = false;
+		try
+		{
+			TimeTaker timer1("emerge load", &emerge_load_time);
+
+			MapBlock *block = m_map->getBlockNoCreate(p);
+			if(block->isDummy())
+				block_data_inexistent = true;
+			else
+				block->copyTo(*this);
+		}
+		catch(InvalidPositionException &e)
+		{
+			block_data_inexistent = true;
+		}
+
+		if(block_data_inexistent)
+		{
+			/*
+				Mark area inexistent
+			*/
+			VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
+			// Fill with VOXELFLAG_INEXISTENT
+			for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
+			for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
+			{
+				s32 i = m_area.index(a.MinEdge.X,y,z);
+				memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
+			}
+		}
+
+		m_loaded_blocks.insert(p, !block_data_inexistent);
+	}
+}
+
+void ManualMapVoxelManipulator::blitBackAll(
+		core::map<v3s16, MapBlock*> * modified_blocks)
+{
+	if(m_area.getExtent() == v3s16(0,0,0))
+		return;
+	
+	/*
+		Copy data of all blocks
+	*/
+	for(core::map<v3s16, bool>::Iterator
+			i = m_loaded_blocks.getIterator();
+			i.atEnd() == false; i++)
+	{
+		bool existed = i.getNode()->getValue();
+		if(existed == false)
+			continue;
+		v3s16 p = i.getNode()->getKey();
+		MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+		if(block == NULL)
+		{
+			dstream<<"WARNING: "<<__FUNCTION_NAME
+					<<": got NULL block "
+					<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+					<<std::endl;
+			continue;
+		}
+
+		block->copyFrom(*this);
+
+		if(modified_blocks)
+			modified_blocks->insert(p, block);
+	}
+}
+
 //END