minetest/src/map.cpp

/*
Minetest-c55
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "map.h"
#include "main.h"
#include "jmutexautolock.h"
#include "client.h"
#include "filesys.h"
#include "utility.h"
#include "voxel.h"
#include "porting.h"
#include "mineral.h"
#include "noise.h"
#include "serverobject.h"
#include "content_mapnode.h"

extern "C" {
	#include "sqlite3.h"
}
/*
	SQLite format specification:
	- Initially only replaces sectors/ and sectors2/
*/

/*
	Map
*/

Map::Map(std::ostream &dout):
	m_dout(dout),
	m_sector_cache(NULL)
{
	/*m_sector_mutex.Init();
	assert(m_sector_mutex.IsInitialized());*/
}

Map::~Map()
{
	/*
		Free all MapSectors
	*/
	core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
	for(; i.atEnd() == false; i++)
	{
		MapSector *sector = i.getNode()->getValue();
		delete sector;
	}
}

void Map::addEventReceiver(MapEventReceiver *event_receiver)
{
	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;
		return sector;
	}
	
	core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
	
	if(n == NULL)
		return NULL;
	
	MapSector *sector = n->getValue();
	
	// Cache the last result
	m_sector_cache_p = p;
	m_sector_cache = sector;

	return sector;
}

MapSector * Map::getSectorNoGenerateNoEx(v2s16 p)
{
	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);
	MapSector * sector = getSectorNoGenerate(p2d);

	MapBlock *block = sector->getBlockNoCreate(p3d.Y);

	return block;
}

MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d)
{
	try
	{
		v2s16 p2d(p3d.X, p3d.Z);
		MapSector * sector = getSectorNoGenerate(p2d);
		MapBlock *block = sector->getBlockNoCreate(p3d.Y);
		return block;
	}
	catch(InvalidPositionException &e)
	{
		return NULL;
	}
}

/*MapBlock * Map::getBlockCreate(v3s16 p3d)
{
	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)
{
	v3s16 blockpos = getNodeBlockPos(p);
	try{
		MapBlock * block = getBlockNoCreate(blockpos);
		return block->getIsUnderground();
	}
	catch(InvalidPositionException &e)
	{
		return false;
	}
}

/*
	Goes recursively through the neighbours of the node.

	Alters only transparent nodes.

	If the lighting of the neighbour is lower than the lighting of
	the node was (before changing it to 0 at the step before), the
	lighting of the neighbour is set to 0 and then the same stuff
	repeats for the neighbour.

	The ending nodes of the routine are stored in light_sources.
	This is useful when a light is removed. In such case, this
	routine can be called for the light node and then again for
	light_sources to re-light the area without the removed light.

	values of from_nodes are lighting values.
*/
void Map::unspreadLight(enum LightBank bank,
		core::map<v3s16, u8> & from_nodes,
		core::map<v3s16, bool> & light_sources,
		core::map<v3s16, MapBlock*>  & modified_blocks)
{
	v3s16 dirs[6] = {
		v3s16(0,0,1), // back
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};
	
	if(from_nodes.size() == 0)
		return;
	
	u32 blockchangecount = 0;

	core::map<v3s16, u8> unlighted_nodes;
	core::map<v3s16, u8>::Iterator j;
	j = from_nodes.getIterator();

	/*
		Initialize block cache
	*/
	v3s16 blockpos_last;
	MapBlock *block = NULL;
	// Cache this a bit, too
	bool block_checked_in_modified = false;
	
	for(; j.atEnd() == false; j++)
	{
		v3s16 pos = j.getNode()->getKey();
		v3s16 blockpos = getNodeBlockPos(pos);
		
		// Only fetch a new block if the block position has changed
		try{
			if(block == NULL || blockpos != blockpos_last){
				block = getBlockNoCreate(blockpos);
				blockpos_last = blockpos;

				block_checked_in_modified = false;
				blockchangecount++;
			}
		}
		catch(InvalidPositionException &e)
		{
			continue;
		}

		if(block->isDummy())
			continue;

		// Calculate relative position in block
		v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;

		// Get node straight from the block
		MapNode n = block->getNode(relpos);

		u8 oldlight = j.getNode()->getValue();

		// Loop through 6 neighbors
		for(u16 i=0; i<6; i++)
		{
			// Get the position of the neighbor node
			v3s16 n2pos = pos + dirs[i];

			// Get the block where the node is located
			v3s16 blockpos = getNodeBlockPos(n2pos);

			try
			{
				// Only fetch a new block if the block position has changed
				try{
					if(block == NULL || blockpos != blockpos_last){
						block = getBlockNoCreate(blockpos);
						blockpos_last = blockpos;

						block_checked_in_modified = false;
						blockchangecount++;
					}
				}
				catch(InvalidPositionException &e)
				{
					continue;
				}

				// Calculate relative position in block
				v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
				// Get node straight from the block
				MapNode n2 = block->getNode(relpos);

				bool changed = false;

				//TODO: Optimize output by optimizing light_sources?

				/*
					If the neighbor is dimmer than what was specified
					as oldlight (the light of the previous node)
				*/
				if(n2.getLight(bank) < oldlight)
				{
					/*
						And the neighbor is transparent and it has some light
					*/
					if(n2.light_propagates() && n2.getLight(bank) != 0)
					{
						/*
							Set light to 0 and add to queue
						*/

						u8 current_light = n2.getLight(bank);
						n2.setLight(bank, 0);
						block->setNode(relpos, n2);

						unlighted_nodes.insert(n2pos, current_light);
						changed = true;

						/*
							Remove from light_sources if it is there
							NOTE: This doesn't happen nearly at all
						*/
						/*if(light_sources.find(n2pos))
						{
							std::cout<<"Removed from light_sources"<<std::endl;
							light_sources.remove(n2pos);
						}*/
					}

					/*// DEBUG
					if(light_sources.find(n2pos) != NULL)
						light_sources.remove(n2pos);*/
				}
				else{
					light_sources.insert(n2pos, true);
				}

				// Add to modified_blocks
				if(changed == true && block_checked_in_modified == false)
				{
					// If the block is not found in modified_blocks, add.
					if(modified_blocks.find(blockpos) == NULL)
					{
						modified_blocks.insert(blockpos, block);
					}
					block_checked_in_modified = true;
				}
			}
			catch(InvalidPositionException &e)
			{
				continue;
			}
		}
	}

	/*dstream<<"unspreadLight(): Changed block "
			<<blockchangecount<<" times"
			<<" for "<<from_nodes.size()<<" nodes"
			<<std::endl;*/

	if(unlighted_nodes.size() > 0)
		unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
}

/*
	A single-node wrapper of the above
*/
void Map::unLightNeighbors(enum LightBank bank,
		v3s16 pos, u8 lightwas,
		core::map<v3s16, bool> & light_sources,
		core::map<v3s16, MapBlock*>  & modified_blocks)
{
	core::map<v3s16, u8> from_nodes;
	from_nodes.insert(pos, lightwas);

	unspreadLight(bank, from_nodes, light_sources, modified_blocks);
}

/*
	Lights neighbors of from_nodes, collects all them and then
	goes on recursively.
*/
void Map::spreadLight(enum LightBank bank,
		core::map<v3s16, bool> & from_nodes,
		core::map<v3s16, MapBlock*> & modified_blocks)
{
	const v3s16 dirs[6] = {
		v3s16(0,0,1), // back
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};

	if(from_nodes.size() == 0)
		return;

	u32 blockchangecount = 0;

	core::map<v3s16, bool> lighted_nodes;
	core::map<v3s16, bool>::Iterator j;
	j = from_nodes.getIterator();

	/*
		Initialize block cache
	*/
	v3s16 blockpos_last;
	MapBlock *block = NULL;
	// Cache this a bit, too
	bool block_checked_in_modified = false;

	for(; j.atEnd() == false; j++)
	//for(; j != from_nodes.end(); j++)
	{
		v3s16 pos = j.getNode()->getKey();
		//v3s16 pos = *j;
		//dstream<<"pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
		v3s16 blockpos = getNodeBlockPos(pos);

		// Only fetch a new block if the block position has changed
		try{
			if(block == NULL || blockpos != blockpos_last){
				block = getBlockNoCreate(blockpos);
				blockpos_last = blockpos;

				block_checked_in_modified = false;
				blockchangecount++;
			}
		}
		catch(InvalidPositionException &e)
		{
			continue;
		}

		if(block->isDummy())
			continue;

		// Calculate relative position in block
		v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;

		// Get node straight from the block
		MapNode n = block->getNode(relpos);

		u8 oldlight = n.getLight(bank);
		u8 newlight = diminish_light(oldlight);

		// Loop through 6 neighbors
		for(u16 i=0; i<6; i++){
			// Get the position of the neighbor node
			v3s16 n2pos = pos + dirs[i];

			// Get the block where the node is located
			v3s16 blockpos = getNodeBlockPos(n2pos);

			try
			{
				// Only fetch a new block if the block position has changed
				try{
					if(block == NULL || blockpos != blockpos_last){
						block = getBlockNoCreate(blockpos);
						blockpos_last = blockpos;

						block_checked_in_modified = false;
						blockchangecount++;
					}
				}
				catch(InvalidPositionException &e)
				{
					continue;
				}

				// Calculate relative position in block
				v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
				// Get node straight from the block
				MapNode n2 = block->getNode(relpos);

				bool changed = false;
				/*
					If the neighbor is brighter than the current node,
					add to list (it will light up this node on its turn)
				*/
				if(n2.getLight(bank) > undiminish_light(oldlight))
				{
					lighted_nodes.insert(n2pos, true);
					//lighted_nodes.push_back(n2pos);
					changed = true;
				}
				/*
					If the neighbor is dimmer than how much light this node
					would spread on it, add to list
				*/
				if(n2.getLight(bank) < newlight)
				{
					if(n2.light_propagates())
					{
						n2.setLight(bank, newlight);
						block->setNode(relpos, n2);
						lighted_nodes.insert(n2pos, true);
						//lighted_nodes.push_back(n2pos);
						changed = true;
					}
				}

				// Add to modified_blocks
				if(changed == true && block_checked_in_modified == false)
				{
					// If the block is not found in modified_blocks, add.
					if(modified_blocks.find(blockpos) == NULL)
					{
						modified_blocks.insert(blockpos, block);
					}
					block_checked_in_modified = true;
				}
			}
			catch(InvalidPositionException &e)
			{
				continue;
			}
		}
	}

	/*dstream<<"spreadLight(): Changed block "
			<<blockchangecount<<" times"
			<<" for "<<from_nodes.size()<<" nodes"
			<<std::endl;*/

	if(lighted_nodes.size() > 0)
		spreadLight(bank, lighted_nodes, modified_blocks);
}

/*
	A single-node source variation of the above.
*/
void Map::lightNeighbors(enum LightBank bank,
		v3s16 pos,
		core::map<v3s16, MapBlock*> & modified_blocks)
{
	core::map<v3s16, bool> from_nodes;
	from_nodes.insert(pos, true);
	spreadLight(bank, from_nodes, modified_blocks);
}

v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p)
{
	v3s16 dirs[6] = {
		v3s16(0,0,1), // back
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};

	u8 brightest_light = 0;
	v3s16 brightest_pos(0,0,0);
	bool found_something = false;

	// Loop through 6 neighbors
	for(u16 i=0; i<6; i++){
		// Get the position of the neighbor node
		v3s16 n2pos = p + dirs[i];
		MapNode n2;
		try{
			n2 = getNode(n2pos);
		}
		catch(InvalidPositionException &e)
		{
			continue;
		}
		if(n2.getLight(bank) > brightest_light || found_something == false){
			brightest_light = n2.getLight(bank);
			brightest_pos = n2pos;
			found_something = true;
		}
	}

	if(found_something == false)
		throw InvalidPositionException();

	return brightest_pos;
}

/*
	Propagates sunlight down from a node.
	Starting point gets sunlight.

	Returns the lowest y value of where the sunlight went.

	Mud is turned into grass in where the sunlight stops.
*/
s16 Map::propagateSunlight(v3s16 start,
		core::map<v3s16, MapBlock*> & modified_blocks)
{
	s16 y = start.Y;
	for(; ; y--)
	{
		v3s16 pos(start.X, y, start.Z);

		v3s16 blockpos = getNodeBlockPos(pos);
		MapBlock *block;
		try{
			block = getBlockNoCreate(blockpos);
		}
		catch(InvalidPositionException &e)
		{
			break;
		}

		v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE;
		MapNode n = block->getNode(relpos);

		if(n.sunlight_propagates())
		{
			n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
			block->setNode(relpos, n);

			modified_blocks.insert(blockpos, block);
		}
		else
		{
			/*// Turn mud into grass
			if(n.d == CONTENT_MUD)
			{
				n.d = CONTENT_GRASS;
				block->setNode(relpos, n);
				modified_blocks.insert(blockpos, block);
			}*/

			// Sunlight goes no further
			break;
		}
	}
	return y + 1;
}

void Map::updateLighting(enum LightBank bank,
		core::map<v3s16, MapBlock*> & a_blocks,
		core::map<v3s16, MapBlock*> & modified_blocks)
{
	/*m_dout<<DTIME<<"Map::updateLighting(): "
			<<a_blocks.size()<<" blocks."<<std::endl;*/

	//TimeTaker timer("updateLighting");

	// For debugging
	//bool debug=true;
	//u32 count_was = modified_blocks.size();

	core::map<v3s16, MapBlock*> blocks_to_update;

	core::map<v3s16, bool> light_sources;

	core::map<v3s16, u8> unlight_from;

	core::map<v3s16, MapBlock*>::Iterator i;
	i = a_blocks.getIterator();
	for(; i.atEnd() == false; i++)
	{
		MapBlock *block = i.getNode()->getValue();

		for(;;)
		{
			// Don't bother with dummy blocks.
			if(block->isDummy())
				break;

			v3s16 pos = block->getPos();
			modified_blocks.insert(pos, block);

			blocks_to_update.insert(pos, block);

			/*
				Clear all light from block
			*/
			for(s16 z=0; z<MAP_BLOCKSIZE; z++)
			for(s16 x=0; x<MAP_BLOCKSIZE; x++)
			for(s16 y=0; y<MAP_BLOCKSIZE; y++)
			{

				try{
					v3s16 p(x,y,z);
					MapNode n = block->getNode(v3s16(x,y,z));
					u8 oldlight = n.getLight(bank);
					n.setLight(bank, 0);
					block->setNode(v3s16(x,y,z), n);

					// Collect borders for unlighting
					if(x==0 || x == MAP_BLOCKSIZE-1
					|| y==0 || y == MAP_BLOCKSIZE-1
					|| z==0 || z == MAP_BLOCKSIZE-1)
					{
						v3s16 p_map = p + v3s16(
								MAP_BLOCKSIZE*pos.X,
								MAP_BLOCKSIZE*pos.Y,
								MAP_BLOCKSIZE*pos.Z);
						unlight_from.insert(p_map, oldlight);
					}
				}
				catch(InvalidPositionException &e)
				{
					/*
						This would happen when dealing with a
						dummy block.
					*/
					//assert(0);
					dstream<<"updateLighting(): InvalidPositionException"
							<<std::endl;
				}
			}

			if(bank == LIGHTBANK_DAY)
			{
				bool bottom_valid = block->propagateSunlight(light_sources);

				// If bottom is valid, we're done.
				if(bottom_valid)
					break;
			}
			else if(bank == LIGHTBANK_NIGHT)
			{
				// For night lighting, sunlight is not propagated
				break;
			}
			else
			{
				// Invalid lighting bank
				assert(0);
			}

			/*dstream<<"Bottom for sunlight-propagated block ("
					<<pos.X<<","<<pos.Y<<","<<pos.Z<<") not valid"
					<<std::endl;*/

			// Bottom sunlight is not valid; get the block and loop to it

			pos.Y--;
			try{
				block = getBlockNoCreate(pos);
			}
			catch(InvalidPositionException &e)
			{
				assert(0);
			}

		}
	}

#if 0
	{
		TimeTaker timer("unspreadLight");
		unspreadLight(bank, unlight_from, light_sources, modified_blocks);
	}

	if(debug)
	{
		u32 diff = modified_blocks.size() - count_was;
		count_was = modified_blocks.size();
		dstream<<"unspreadLight modified "<<diff<<std::endl;
	}

	{
		TimeTaker timer("spreadLight");
		spreadLight(bank, light_sources, modified_blocks);
	}

	if(debug)
	{
		u32 diff = modified_blocks.size() - count_was;
		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;
}

void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
		core::map<v3s16, MapBlock*> & modified_blocks)
{
	updateLighting(LIGHTBANK_DAY, a_blocks, modified_blocks);
	updateLighting(LIGHTBANK_NIGHT, a_blocks, modified_blocks);

	/*
		Update information about whether day and night light differ
	*/
	for(core::map<v3s16, MapBlock*>::Iterator
			i = modified_blocks.getIterator();
			i.atEnd() == false; i++)
	{
		MapBlock *block = i.getNode()->getValue();
		block->updateDayNightDiff();
	}
}

/*
*/
void Map::addNodeAndUpdate(v3s16 p, MapNode n,
		core::map<v3s16, MapBlock*> &modified_blocks)
{
	/*PrintInfo(m_dout);
	m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
			<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/

	/*
		From this node to nodes underneath:
		If lighting is sunlight (1.0), unlight neighbours and
		set lighting to 0.
		Else discontinue.
	*/

	v3s16 toppos = p + v3s16(0,1,0);
	v3s16 bottompos = p + v3s16(0,-1,0);

	bool node_under_sunlight = true;
	core::map<v3s16, bool> light_sources;

	/*
		If there is a node at top and it doesn't have sunlight,
		there has not been any sunlight going down.

		Otherwise there probably is.
	*/
	try{
		MapNode topnode = getNode(toppos);

		if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
			node_under_sunlight = false;
	}
	catch(InvalidPositionException &e)
	{
	}

#if 1
	/*
		If the new node is solid and there is grass below, change it to mud
	*/
	if(content_features(n.d).walkable == true)
	{
		try{
			MapNode bottomnode = getNode(bottompos);

			if(bottomnode.d == CONTENT_GRASS
					|| bottomnode.d == CONTENT_GRASS_FOOTSTEPS)
			{
				bottomnode.d = CONTENT_MUD;
				setNode(bottompos, bottomnode);
			}
		}
		catch(InvalidPositionException &e)
		{
		}
	}
#endif

#if 0
	/*
		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;
	}
#endif

	/*
		Remove all light that has come out of this node
	*/

	enum LightBank banks[] =
	{
		LIGHTBANK_DAY,
		LIGHTBANK_NIGHT
	};
	for(s32 i=0; i<2; i++)
	{
		enum LightBank bank = banks[i];

		u8 lightwas = getNode(p).getLight(bank);

		// Add the block of the added node to modified_blocks
		v3s16 blockpos = getNodeBlockPos(p);
		MapBlock * block = getBlockNoCreate(blockpos);
		assert(block != NULL);
		modified_blocks.insert(blockpos, block);

		assert(isValidPosition(p));

		// Unlight neighbours of node.
		// This means setting light of all consequent dimmer nodes
		// to 0.
		// This also collects the nodes at the border which will spread
		// light again into this.
		unLightNeighbors(bank, p, lightwas, light_sources, modified_blocks);

		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 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 && !content_features(n.d).sunlight_propagates)
	{
		s16 y = p.Y - 1;
		for(;; y--){
			//m_dout<<DTIME<<"y="<<y<<std::endl;
			v3s16 n2pos(p.X, y, p.Z);

			MapNode n2;
			try{
				n2 = getNode(n2pos);
			}
			catch(InvalidPositionException &e)
			{
				break;
			}

			if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN)
			{
				unLightNeighbors(LIGHTBANK_DAY,
						n2pos, n2.getLight(LIGHTBANK_DAY),
						light_sources, modified_blocks);
				n2.setLight(LIGHTBANK_DAY, 0);
				setNode(n2pos, n2);
			}
			else
				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
		*/
		spreadLight(bank, light_sources, modified_blocks);
	}

	/*
		Update information about whether day and night light differ
	*/
	for(core::map<v3s16, MapBlock*>::Iterator
			i = modified_blocks.getIterator();
			i.atEnd() == false; i++)
	{
		MapBlock *block = i.getNode()->getValue();
		block->updateDayNightDiff();
	}

	/*
		Add neighboring liquid nodes and the node itself if it is
		liquid (=water node was added) to transform queue.
	*/
	v3s16 dirs[7] = {
		v3s16(0,0,0), // self
		v3s16(0,0,1), // back
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};
	for(u16 i=0; i<7; i++)
	{
		try
		{

		v3s16 p2 = p + dirs[i];

		MapNode n2 = getNode(p2);
		if(content_liquid(n2.d))
		{
			m_transforming_liquid.push_back(p2);
		}

		}catch(InvalidPositionException &e)
		{
		}
	}
}

/*
*/
void Map::removeNodeAndUpdate(v3s16 p,
		core::map<v3s16, MapBlock*> &modified_blocks)
{
	/*PrintInfo(m_dout);
	m_dout<<DTIME<<"Map::removeNodeAndUpdate(): p=("
			<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/

	bool node_under_sunlight = true;

	v3s16 toppos = p + v3s16(0,1,0);

	// Node will be replaced with this
	u8 replace_material = CONTENT_AIR;

	/*
		If there is a node at top and it doesn't have sunlight,
		there will be no sunlight going down.
	*/
	try{
		MapNode topnode = getNode(toppos);

		if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
			node_under_sunlight = false;
	}
	catch(InvalidPositionException &e)
	{
	}

	core::map<v3s16, bool> light_sources;

	enum LightBank banks[] =
	{
		LIGHTBANK_DAY,
		LIGHTBANK_NIGHT
	};
	for(s32 i=0; i<2; i++)
	{
		enum LightBank bank = banks[i];

		/*
			Unlight neighbors (in case the node is a light source)
		*/
		unLightNeighbors(bank, p,
				getNode(p).getLight(bank),
				light_sources, modified_blocks);
	}

	/*
		Remove node metadata
	*/

	removeNodeMetadata(p);

	/*
		Remove the node.
		This also clears the lighting.
	*/

	MapNode n;
	n.d = replace_material;
	setNode(p, n);

	for(s32 i=0; i<2; i++)
	{
		enum LightBank bank = banks[i];

		/*
			Recalculate lighting
		*/
		spreadLight(bank, light_sources, modified_blocks);
	}

	// Add the block of the removed node to modified_blocks
	v3s16 blockpos = getNodeBlockPos(p);
	MapBlock * block = getBlockNoCreate(blockpos);
	assert(block != NULL);
	modified_blocks.insert(blockpos, block);

	/*
		If the removed node was under sunlight, propagate the
		sunlight down from it and then light all neighbors
		of the propagated blocks.
	*/
	if(node_under_sunlight)
	{
		s16 ybottom = propagateSunlight(p, modified_blocks);
		/*m_dout<<DTIME<<"Node was under sunlight. "
				"Propagating sunlight";
		m_dout<<DTIME<<" -> ybottom="<<ybottom<<std::endl;*/
		s16 y = p.Y;
		for(; y >= ybottom; y--)
		{
			v3s16 p2(p.X, y, p.Z);
			/*m_dout<<DTIME<<"lighting neighbors of node ("
					<<p2.X<<","<<p2.Y<<","<<p2.Z<<")"
					<<std::endl;*/
			lightNeighbors(LIGHTBANK_DAY, p2, modified_blocks);
		}
	}
	else
	{
		// Set the lighting of this node to 0
		// TODO: Is this needed? Lighting is cleared up there already.
		try{
			MapNode n = getNode(p);
			n.setLight(LIGHTBANK_DAY, 0);
			setNode(p, n);
		}
		catch(InvalidPositionException &e)
		{
			assert(0);
		}
	}

	for(s32 i=0; i<2; i++)
	{
		enum LightBank bank = banks[i];

		// Get the brightest neighbour node and propagate light from it
		v3s16 n2p = getBrightestNeighbour(bank, p);
		try{
			MapNode n2 = getNode(n2p);
			lightNeighbors(bank, n2p, modified_blocks);
		}
		catch(InvalidPositionException &e)
		{
		}
	}

	/*
		Update information about whether day and night light differ
	*/
	for(core::map<v3s16, MapBlock*>::Iterator
			i = modified_blocks.getIterator();
			i.atEnd() == false; i++)
	{
		MapBlock *block = i.getNode()->getValue();
		block->updateDayNightDiff();
	}

	/*
		Add neighboring liquid nodes to transform queue.
	*/
	v3s16 dirs[6] = {
		v3s16(0,0,1), // back
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};
	for(u16 i=0; i<6; i++)
	{
		try
		{

		v3s16 p2 = p + dirs[i];

		MapNode n2 = getNode(p2);
		if(content_liquid(n2.d))
		{
			m_transforming_liquid.push_back(p2);
		}

		}catch(InvalidPositionException &e)
		{
		}
	}
}

bool Map::addNodeWithEvent(v3s16 p, MapNode n)
{
	MapEditEvent event;
	event.type = MEET_ADDNODE;
	event.p = p;
	event.n = n;

	bool succeeded = true;
	try{
		core::map<v3s16, MapBlock*> modified_blocks;
		addNodeAndUpdate(p, n, 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){
		succeeded = false;
	}

	dispatchEvent(&event);

	return succeeded;
}

bool Map::removeNodeWithEvent(v3s16 p)
{
	MapEditEvent event;
	event.type = MEET_REMOVENODE;
	event.p = p;

	bool succeeded = true;
	try{
		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){
		succeeded = false;
	}

	dispatchEvent(&event);

	return succeeded;
}

bool Map::dayNightDiffed(v3s16 blockpos)
{
	try{
		v3s16 p = blockpos + v3s16(0,0,0);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}
	// Leading edges
	try{
		v3s16 p = blockpos + v3s16(-1,0,0);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}
	try{
		v3s16 p = blockpos + v3s16(0,-1,0);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}
	try{
		v3s16 p = blockpos + v3s16(0,0,-1);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}
	// Trailing edges
	try{
		v3s16 p = blockpos + v3s16(1,0,0);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}
	try{
		v3s16 p = blockpos + v3s16(0,1,0);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}
	try{
		v3s16 p = blockpos + v3s16(0,0,1);
		MapBlock *b = getBlockNoCreate(p);
		if(b->dayNightDiffed())
			return true;
	}
	catch(InvalidPositionException &e){}

	return false;
}

/*
	Updates usage timers
*/
void Map::timerUpdate(float dtime)
{
	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out

	core::map<v2s16, MapSector*>::Iterator si;

	si = m_sectors.getIterator();
	for(; si.atEnd() == false; si++)
	{
		MapSector *sector = si.getNode()->getValue();

		core::list<MapBlock*> blocks;
		sector->getBlocks(blocks);
		for(core::list<MapBlock*>::Iterator i = blocks.begin();
				i != blocks.end(); i++)
		{
			(*i)->incrementUsageTimer(dtime);
		}
	}
}

void Map::deleteSectors(core::list<v2s16> &list, bool only_blocks)
{
	core::list<v2s16>::Iterator j;
	for(j=list.begin(); j!=list.end(); j++)
	{
		MapSector *sector = m_sectors[*j];
		if(only_blocks)
		{
			sector->deleteBlocks();
		}
		else
		{
			/*
				If sector is in sector cache, remove it from there
			*/
			if(m_sector_cache == sector)
			{
				m_sector_cache = NULL;
			}
			/*
				Remove from map and delete
			*/
			m_sectors.remove(*j);
			delete sector;
		}
	}
}

u32 Map::unloadUnusedData(float timeout, bool only_blocks,
		core::list<v3s16> *deleted_blocks)
{
	core::list<v2s16> sector_deletion_queue;

	core::map<v2s16, MapSector*>::Iterator si = m_sectors.getIterator();
	for(; si.atEnd() == false; si++)
	{
		MapSector *sector = si.getNode()->getValue();

		bool all_blocks_deleted = true;

		core::list<MapBlock*> blocks;
		sector->getBlocks(blocks);
		for(core::list<MapBlock*>::Iterator i = blocks.begin();
				i != blocks.end(); i++)
		{
			MapBlock *block = (*i);

			if(block->getUsageTimer() > timeout)
			{
				// Save if modified
				if(block->getModified() != MOD_STATE_CLEAN)
					saveBlock(block);
				// Unload
				sector->removeBlock(block);
				delete block;
			}
			else
			{
				all_blocks_deleted = false;
			}
		}

		if(all_blocks_deleted)
		{
			sector_deletion_queue.push_back(si.getNode()->getKey());
		}
	}

#if 0
	core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
	for(; i.atEnd() == false; i++)
	{
		MapSector *sector = i.getNode()->getValue();
		/*
			Delete sector from memory if it hasn't been used in a long time
		*/
		if(sector->usage_timer > timeout)
		{
			sector_deletion_queue.push_back(i.getNode()->getKey());

			if(deleted_blocks != NULL)
			{
				// Collect positions of blocks of sector
				MapSector *sector = i.getNode()->getValue();
				core::list<MapBlock*> blocks;
				sector->getBlocks(blocks);
				for(core::list<MapBlock*>::Iterator i = blocks.begin();
						i != blocks.end(); i++)
				{
					deleted_blocks->push_back((*i)->getPos());
				}
			}
		}
	}
#endif

	deleteSectors(sector_deletion_queue, only_blocks);
	return sector_deletion_queue.getSize();
}

void Map::PrintInfo(std::ostream &out)
{
	out<<"Map: ";
}

#define WATER_DROP_BOOST 4

void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
{
	DSTACK(__FUNCTION_NAME);
	//TimeTaker timer("transformLiquids()");

	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)
	{
		/*
			Get a queued transforming liquid node
		*/
		v3s16 p0 = m_transforming_liquid.pop_front();

		MapNode n0 = getNode(p0);

		// Don't deal with non-liquids
		if(content_liquid(n0.d) == false)
			continue;

		bool is_source = !content_flowing_liquid(n0.d);

		u8 liquid_level = 8;
		if(is_source == false)
			liquid_level = n0.param2 & 0x0f;

		// Turn possible source into non-source
		u8 nonsource_c = make_liquid_flowing(n0.d);

		/*
			If not source, check that some node flows into this one
			and what is the level of liquid in this one
		*/
		if(is_source == false)
		{
			s8 new_liquid_level_max = -1;

			v3s16 dirs_from[5] = {
				v3s16(0,1,0), // top
				v3s16(0,0,1), // back
				v3s16(1,0,0), // right
				v3s16(0,0,-1), // front
				v3s16(-1,0,0), // left
			};
			for(u16 i=0; i<5; i++)
			{
				try
				{

				bool from_top = (i==0);

				v3s16 p2 = p0 + dirs_from[i];
				MapNode n2 = getNode(p2);

				if(content_liquid(n2.d))
				{
					u8 n2_nonsource_c = make_liquid_flowing(n2.d);
					// Check that the liquids are the same type
					if(n2_nonsource_c != nonsource_c)
					{
						dstream<<"WARNING: Not handling: different liquids"
								" collide"<<std::endl;
						continue;
					}
					bool n2_is_source = !content_flowing_liquid(n2.d);
					s8 n2_liquid_level = 8;
					if(n2_is_source == false)
						n2_liquid_level = n2.param2 & 0x07;

					s8 new_liquid_level = -1;
					if(from_top)
					{
						//new_liquid_level = 7;
						if(n2_liquid_level >= 7 - WATER_DROP_BOOST)
							new_liquid_level = 7;
						else
							new_liquid_level = n2_liquid_level + WATER_DROP_BOOST;
					}
					else if(n2_liquid_level > 0)
					{
						new_liquid_level = n2_liquid_level - 1;
					}

					if(new_liquid_level > new_liquid_level_max)
						new_liquid_level_max = new_liquid_level;
				}

				}catch(InvalidPositionException &e)
				{
				}
			} //for

			/*
				If liquid level should be something else, update it and
				add all the neighboring water nodes to the transform queue.
			*/
			if(new_liquid_level_max != liquid_level)
			{
				if(new_liquid_level_max == -1)
				{
					// Remove water alltoghether
					n0.d = CONTENT_AIR;
					n0.param2 = 0;
					setNode(p0, n0);
				}
				else
				{
					n0.param2 = new_liquid_level_max;
					setNode(p0, n0);
				}

				// Block has been modified
				{
					v3s16 blockpos = getNodeBlockPos(p0);
					MapBlock *block = getBlockNoCreateNoEx(blockpos);
					if(block != NULL)
						modified_blocks.insert(blockpos, block);
				}

				/*
					Add neighboring non-source liquid nodes to transform queue.
				*/
				v3s16 dirs[6] = {
					v3s16(0,0,1), // back
					v3s16(0,1,0), // top
					v3s16(1,0,0), // right
					v3s16(0,0,-1), // front
					v3s16(0,-1,0), // bottom
					v3s16(-1,0,0), // left
				};
				for(u16 i=0; i<6; i++)
				{
					try
					{

					v3s16 p2 = p0 + dirs[i];

					MapNode n2 = getNode(p2);
					if(content_flowing_liquid(n2.d))
					{
						m_transforming_liquid.push_back(p2);
					}

					}catch(InvalidPositionException &e)
					{
					}
				}
			}
		}

		// Get a new one from queue if the node has turned into non-water
		if(content_liquid(n0.d) == false)
			continue;

		/*
			Flow water from this node
		*/
		v3s16 dirs_to[5] = {
			v3s16(0,-1,0), // bottom
			v3s16(0,0,1), // back
			v3s16(1,0,0), // right
			v3s16(0,0,-1), // front
			v3s16(-1,0,0), // left
		};
		for(u16 i=0; i<5; i++)
		{
			try
			{

			bool to_bottom = (i == 0);

			// If liquid is at lowest possible height, it's not going
			// anywhere except down
			if(liquid_level == 0 && to_bottom == false)
				continue;

			u8 liquid_next_level = 0;
			// If going to bottom
			if(to_bottom)
			{
				//liquid_next_level = 7;
				if(liquid_level >= 7 - WATER_DROP_BOOST)
					liquid_next_level = 7;
				else
					liquid_next_level = liquid_level + WATER_DROP_BOOST;
			}
			else
				liquid_next_level = liquid_level - 1;

			bool n2_changed = false;
			bool flowed = false;

			v3s16 p2 = p0 + dirs_to[i];

			MapNode n2 = getNode(p2);
			//dstream<<"[1] n2.param="<<(int)n2.param<<std::endl;

			if(content_liquid(n2.d))
			{
				u8 n2_nonsource_c = make_liquid_flowing(n2.d);
				// Check that the liquids are the same type
				if(n2_nonsource_c != nonsource_c)
				{
					dstream<<"WARNING: Not handling: different liquids"
							" collide"<<std::endl;
					continue;
				}
				bool n2_is_source = !content_flowing_liquid(n2.d);
				u8 n2_liquid_level = 8;
				if(n2_is_source == false)
					n2_liquid_level = n2.param2 & 0x07;

				if(to_bottom)
				{
					flowed = true;
				}

				if(n2_is_source)
				{
					// Just flow into the source, nothing changes.
					// n2_changed is not set because destination didn't change
					flowed = true;
				}
				else
				{
					if(liquid_next_level > liquid_level)
					{
						n2.param2 = liquid_next_level;
						setNode(p2, n2);

						n2_changed = true;
						flowed = true;
					}
				}
			}
			else if(n2.d == CONTENT_AIR)
			{
				n2.d = nonsource_c;
				n2.param2 = liquid_next_level;
				setNode(p2, n2);

				n2_changed = true;
				flowed = true;
			}

			//dstream<<"[2] n2.param="<<(int)n2.param<<std::endl;

			if(n2_changed)
			{
				m_transforming_liquid.push_back(p2);

				v3s16 blockpos = getNodeBlockPos(p2);
				MapBlock *block = getBlockNoCreateNoEx(blockpos);
				if(block != NULL)
					modified_blocks.insert(blockpos, block);
			}

			// If n2_changed to bottom, don't flow anywhere else
			if(to_bottom && flowed && !is_source)
				break;

			}catch(InvalidPositionException &e)
			{
			}
		}

		loopcount++;
		//if(loopcount >= 100000)
		if(loopcount >= initial_size * 1)
			break;
	}
	//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):
	Map(dout_server),
	m_seed(0),
	m_map_metadata_changed(true)
{
	dstream<<__FUNCTION_NAME<<std::endl;

	//m_chunksize = 8; // Takes a few seconds

	m_seed = (((u64)(myrand()%0xffff)<<0)
			+ ((u64)(myrand()%0xffff)<<16)
			+ ((u64)(myrand()%0xffff)<<32)
			+ ((u64)(myrand()%0xffff)<<48));

	/*
		Experimental and debug stuff
	*/

	{
	}

	/*
		Try to load map; if not found, create a new one.
	*/

	m_savedir = savedir;
	m_map_saving_enabled = false;

	try
	{
		// If directory exists, check contents and load if possible
		if(fs::PathExists(m_savedir))
		{
			// If directory is empty, it is safe to save into it.
			if(fs::GetDirListing(m_savedir).size() == 0)
			{
				dstream<<DTIME<<"Server: Empty save directory is valid."
						<<std::endl;
				m_map_saving_enabled = true;
			}
			else
			{
				try{
					// Load map metadata (seed, chunksize)
					loadMapMeta();
				}
				catch(FileNotGoodException &e){
					dstream<<DTIME<<"WARNING: Could not load map metadata"
							//<<" Disabling chunk-based generator."
							<<std::endl;
					//m_chunksize = 0;
				}

				/*try{
					// Load chunk metadata
					loadChunkMeta();
				}
				catch(FileNotGoodException &e){
					dstream<<DTIME<<"WARNING: Could not load chunk metadata."
							<<" Disabling chunk-based generator."
							<<std::endl;
					m_chunksize = 0;
				}*/

				/*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;
				// Map loaded, not creating new one
				return;
			}
		}
		// If directory doesn't exist, it is safe to save to it
		else{
			m_map_saving_enabled = true;
		}
	}
	catch(std::exception &e)
	{
		dstream<<DTIME<<"WARNING: Server: Failed to load map from "<<savedir
				<<", exception: "<<e.what()<<std::endl;
		dstream<<"Please remove the map or fix it."<<std::endl;
		dstream<<"WARNING: Map saving will be disabled."<<std::endl;
	}

	dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;

	// Create zero sector
	emergeSector(v2s16(0,0));

	// Initially write whole map
	save(false);
}

ServerMap::~ServerMap()
{
	dstream<<__FUNCTION_NAME<<std::endl;

	try
	{
		if(m_map_saving_enabled)
		{
			//save(false);
			// Save only changed parts
			save(true);
			dstream<<DTIME<<"Server: saved map to "<<m_savedir<<std::endl;
		}
		else
		{
			dstream<<DTIME<<"Server: map not saved"<<std::endl;
		}
	}
	catch(std::exception &e)
	{
		dstream<<DTIME<<"Server: Failed to save map to "<<m_savedir
				<<", exception: "<<e.what()<<std::endl;
	}

#if 0
	/*
		Free all MapChunks
	*/
	core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
	for(; i.atEnd() == false; i++)
	{
		MapChunk *chunk = i.getNode()->getValue();
		delete chunk;
	}
#endif
}

/*
	Some helper functions for the map generator
*/

s16 find_ground_level(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))
			break;

		vmanip.m_area.add_y(em, i, -1);
	}
	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++;
	}

	// 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
	{
		s16 d = 1;
		for(s16 z=-d; z<=d; z++)
		for(s16 y=-d; y<=d; y++)
		for(s16 x=-d; x<=d; x++)
		{
			leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
		}
	}

	// Add leaves randomly
	for(u32 iii=0; iii<7; iii++)
	{
		s16 d = 1;

		v3s16 p(
			myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
			myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
			myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
		);

		for(s16 z=0; z<=d; z++)
		for(s16 y=0; y<=d; y++)
		for(s16 x=0; x<=d; x++)
		{
			leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
		}
	}

	// Blit leaves to vmanip
	for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
	for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
	for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
	{
		v3s16 p(x,y,z);
		p += p1;
		if(vmanip.m_area.contains(p) == false)
			continue;
		u32 vi = vmanip.m_area.index(p);
		if(vmanip.m_data[vi].d != CONTENT_AIR
				&& vmanip.m_data[vi].d != CONTENT_IGNORE)
			continue;
		u32 i = leaves_a.index(x,y,z);
		if(leaves_d[i] == 1)
			vmanip.m_data[vi] = leavesnode;
	}
}

#if 0
void make_randomstone(VoxelManipulator &vmanip, v3s16 p0)
{
	MapNode stonenode(CONTENT_STONE);

	s16 size = myrand_range(3, 6);
	
	VoxelArea stone_a(v3s16(-2,0,-2), v3s16(2,size,2));
	Buffer<u8> stone_d(stone_a.getVolume());
	for(s32 i=0; i<stone_a.getVolume(); i++)
		stone_d[i] = 0;

	// Force stone at bottom to make it usually touch the ground
	{
		for(s16 z=0; z<=0; z++)
		for(s16 y=0; y<=0; y++)
		for(s16 x=0; x<=0; x++)
		{
			stone_d[stone_a.index(v3s16(x,y,z))] = 1;
		}
	}

	// Generate from perlin noise
	for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++)
	for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++)
	for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++)
	{
		double d = noise3d_perlin((float)x/3.,(float)z/3.,(float)y/3.,
				p0.Z*4243+p0.Y*34+p0.X, 2, 0.5);
		if(z == stone_a.MinEdge.Z || z == stone_a.MaxEdge.Z)
			d -= 0.3;
		if(/*y == stone_a.MinEdge.Y ||*/ y == stone_a.MaxEdge.Y)
			d -= 0.3;
		if(x == stone_a.MinEdge.X || x == stone_a.MaxEdge.X)
			d -= 0.3;
		if(d > 0.0)
		{
			u32 vi = stone_a.index(v3s16(x,y,z));
			stone_d[vi] = 1;
		}
	}

	/*// Add stone randomly
	for(u32 iii=0; iii<7; iii++)
	{
		s16 d = 1;

		v3s16 p(
			myrand_range(stone_a.MinEdge.X, stone_a.MaxEdge.X-d),
			myrand_range(stone_a.MinEdge.Y, stone_a.MaxEdge.Y-d),
			myrand_range(stone_a.MinEdge.Z, stone_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++)
		{
			stone_d[stone_a.index(p+v3s16(x,y,z))] = 1;
		}
	}*/

	// Blit stone to vmanip
	for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++)
	for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++)
	for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++)
	{
		v3s16 p(x,y,z);
		p += p0;
		if(vmanip.m_area.contains(p) == false)
			continue;
		u32 vi = vmanip.m_area.index(p);
		if(vmanip.m_data[vi].d != CONTENT_AIR
				&& vmanip.m_data[vi].d != CONTENT_IGNORE)
			continue;
		u32 i = stone_a.index(x,y,z);
		if(stone_d[i] == 1)
			vmanip.m_data[vi] = stonenode;
	}
}
#endif

void make_largestone(VoxelManipulator &vmanip, v3s16 p0)
{
	MapNode stonenode(CONTENT_STONE);

	s16 size = myrand_range(8, 16);
	
	VoxelArea stone_a(v3s16(-size/2,0,-size/2), v3s16(size/2,size,size/2));
	Buffer<u8> stone_d(stone_a.getVolume());
	for(s32 i=0; i<stone_a.getVolume(); i++)
		stone_d[i] = 0;

	// Force stone at bottom to make it usually touch the ground
	{
		for(s16 z=0; z<=0; z++)
		for(s16 y=0; y<=0; y++)
		for(s16 x=0; x<=0; x++)
		{
			stone_d[stone_a.index(v3s16(x,y,z))] = 1;
		}
	}

	// Generate from perlin noise
	for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++)
	for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++)
	for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++)
	{
		double d = 1.0;
		d += noise3d_perlin((float)x/10.,(float)z/10.,(float)y/10.,
				p0.Z*5123+p0.Y*2439+p0.X, 2, 0.5);
		double mid_z = (stone_a.MaxEdge.Z+stone_a.MinEdge.Z)/2;
		double mid_x = (stone_a.MaxEdge.X+stone_a.MinEdge.X)/2;
		double mid_y = (stone_a.MaxEdge.Y+stone_a.MinEdge.Y)/2;
		double dz = (double)z-mid_z;
		double dx = (double)x-mid_x;
		double dy = MYMAX(0, (double)y-mid_y);
		double r = sqrt(dz*dz+dx*dx+dy*dy);
		d /= (2*r/size)*2 + 0.01;
		if(d > 1.0)
		{
			u32 vi = stone_a.index(v3s16(x,y,z));
			stone_d[vi] = 1;
		}
	}

	/*// Add stone randomly
	for(u32 iii=0; iii<7; iii++)
	{
		s16 d = 1;

		v3s16 p(
			myrand_range(stone_a.MinEdge.X, stone_a.MaxEdge.X-d),
			myrand_range(stone_a.MinEdge.Y, stone_a.MaxEdge.Y-d),
			myrand_range(stone_a.MinEdge.Z, stone_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++)
		{
			stone_d[stone_a.index(p+v3s16(x,y,z))] = 1;
		}
	}*/

	// Blit stone to vmanip
	for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++)
	for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++)
	for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++)
	{
		v3s16 p(x,y,z);
		p += p0;
		if(vmanip.m_area.contains(p) == false)
			continue;
		u32 vi = vmanip.m_area.index(p);
		/*if(vmanip.m_data[vi].d != CONTENT_AIR
				&& vmanip.m_data[vi].d != CONTENT_IGNORE)
			continue;*/
		u32 i = stone_a.index(x,y,z);
		if(stone_d[i] == 1)
			vmanip.m_data[vi] = stonenode;
	}
}

/*
	Dungeon making routines
*/

#define VMANIP_FLAG_DUNGEON_INSIDE VOXELFLAG_CHECKED1
#define VMANIP_FLAG_DUNGEON_PRESERVE VOXELFLAG_CHECKED2
#define VMANIP_FLAG_DUNGEON_UNTOUCHABLE (\
		VMANIP_FLAG_DUNGEON_INSIDE|VMANIP_FLAG_DUNGEON_PRESERVE)

void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace)
{
	// Make +-X walls
	for(s16 z=0; z<roomsize.Z; z++)
	for(s16 y=0; y<roomsize.Y; y++)
	{
		{
			v3s16 p = roomplace + v3s16(0,y,z);
			if(vmanip.m_area.contains(p) == false)
				continue;
			u32 vi = vmanip.m_area.index(p);
			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
				continue;
			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
		}
		{
			v3s16 p = roomplace + v3s16(roomsize.X-1,y,z);
			if(vmanip.m_area.contains(p) == false)
				continue;
			u32 vi = vmanip.m_area.index(p);
			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
				continue;
			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
		}
	}
	
	// Make +-Z walls
	for(s16 x=0; x<roomsize.X; x++)
	for(s16 y=0; y<roomsize.Y; y++)
	{
		{
			v3s16 p = roomplace + v3s16(x,y,0);
			if(vmanip.m_area.contains(p) == false)
				continue;
			u32 vi = vmanip.m_area.index(p);
			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
				continue;
			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
		}
		{
			v3s16 p = roomplace + v3s16(x,y,roomsize.Z-1);
			if(vmanip.m_area.contains(p) == false)
				continue;
			u32 vi = vmanip.m_area.index(p);
			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
				continue;
			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
		}
	}
	
	// Make +-Y walls (floor and ceiling)
	for(s16 z=0; z<roomsize.Z; z++)
	for(s16 x=0; x<roomsize.X; x++)
	{
		{
			v3s16 p = roomplace + v3s16(x,0,z);
			if(vmanip.m_area.contains(p) == false)
				continue;
			u32 vi = vmanip.m_area.index(p);
			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
				continue;
			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
		}
		{
			v3s16 p = roomplace + v3s16(x,roomsize.Y-1,z);
			if(vmanip.m_area.contains(p) == false)
				continue;
			u32 vi = vmanip.m_area.index(p);
			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
				continue;
			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
		}
	}
	
	// Fill with air
	for(s16 z=1; z<roomsize.Z-1; z++)
	for(s16 y=1; y<roomsize.Y-1; y++)
	for(s16 x=1; x<roomsize.X-1; x++)
	{
		v3s16 p = roomplace + v3s16(x,y,z);
		if(vmanip.m_area.contains(p) == false)
			continue;
		u32 vi = vmanip.m_area.index(p);
		vmanip.m_flags[vi] |= VMANIP_FLAG_DUNGEON_UNTOUCHABLE;
		vmanip.m_data[vi] = MapNode(CONTENT_AIR);
	}
}

void make_fill(VoxelManipulator &vmanip, v3s16 place, v3s16 size,
		u8 avoid_flags, MapNode n, u8 or_flags)
{
	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 = place + v3s16(x,y,z);
		if(vmanip.m_area.contains(p) == false)
			continue;
		u32 vi = vmanip.m_area.index(p);
		if(vmanip.m_flags[vi] & avoid_flags)
			continue;
		vmanip.m_flags[vi] |= or_flags;
		vmanip.m_data[vi] = n;
	}
}

void make_hole1(VoxelManipulator &vmanip, v3s16 place)
{
	make_fill(vmanip, place, v3s16(1,2,1), 0, MapNode(CONTENT_AIR),
			VMANIP_FLAG_DUNGEON_INSIDE);
}

void make_door1(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir)
{
	make_hole1(vmanip, doorplace);
}

v3s16 rand_ortho_dir()
{
	if(myrand()%2==0)
		return myrand()%2 ? v3s16(-1,0,0) : v3s16(1,0,0);
	else
		return myrand()%2 ? v3s16(0,0,-1) : v3s16(0,0,1);
}

void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir,
		v3s16 &result_place, v3s16 &result_dir)
{
	make_hole1(vmanip, doorplace);
	v3s16 p0 = doorplace;
	v3s16 dir = doordir;
	u32 length;
	if(myrand()%2)
		length = myrand_range(1,13);
	else
		length = myrand_range(1,6);
	u32 partlength = myrand_range(1,length);
	u32 partcount = 0;
	s16 make_stairs = 0;
	if(myrand()%2 == 0 && partlength >= 3)
		make_stairs = myrand()%2 ? 1 : -1;
	for(u32 i=0; i<length; i++)
	{
		v3s16 dir0 = dir;
		// If first part of stairs, don't go up or down yet (wouldn't fit)
		if(partcount == 0)
			dir0.Y = 0;
		v3s16 p = p0 + dir0;
		/*// If already empty
		if(vmanip.getNodeNoExNoEmerge(p).d
				== CONTENT_AIR
		&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
				== CONTENT_AIR)
		{
		}*/
		if(make_stairs)
		{
			make_fill(vmanip, p+v3s16(-1,-1,-1), v3s16(3,5,3),
					VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(CONTENT_COBBLE), 0);
			make_fill(vmanip, p, v3s16(1,3,1), 0, MapNode(CONTENT_AIR),
					VMANIP_FLAG_DUNGEON_INSIDE);
		}
		else
		{
			make_fill(vmanip, p+v3s16(-1,-1,-1), v3s16(3,4,3),
					VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(CONTENT_COBBLE), 0);
			make_hole1(vmanip, p);
			/*make_fill(vmanip, p, v3s16(1,2,1), 0, MapNode(CONTENT_AIR),
					VMANIP_FLAG_DUNGEON_INSIDE);*/
		}
		p0 = p;
		partcount++;
		if(partcount >= partlength)
		{
			partcount = 0;
			
			v3s16 newdir = rand_ortho_dir();
			partlength = myrand_range(1,7);
			make_stairs = 0;
			if(myrand()%2 == 0 && partlength >= 3)
				make_stairs = myrand()%2 ? 1 : -1;

			if(make_stairs != 0)
			{
				if(newdir.X == 0 && dir.X != 0)
					dir = newdir;
				if(newdir.Z == 0 && dir.Z != 0)
					dir = newdir;
			}
			else
			{
				dir = newdir;
			}
			dir.Y = make_stairs;
		}
	}
	//p0.Y -= make_stairs;
	dir.Y = 0;
	result_place = p0;
	result_dir = dir;
}

class RoomWalker
{
public:

	RoomWalker(VoxelManipulator &vmanip_, v3s16 pos):
			vmanip(vmanip_),
			m_pos(pos)
	{
		randomizeDir();
	}

	void randomizeDir()
	{
		m_dir = rand_ortho_dir();
	}

	void setPos(v3s16 pos)
	{
		m_pos = pos;
	}

	void setDir(v3s16 dir)
	{
		m_dir = dir;
	}
	
	bool findPlaceForDoor(v3s16 &result_place, v3s16 &result_dir)
	{
		for(u32 i=0; i<100; i++)
		{
			v3s16 p = m_pos + m_dir;
			v3s16 p1 = p + v3s16(0,1,0);
			if(vmanip.m_area.contains(p) == false
					|| vmanip.m_area.contains(p1) == false
					|| i % 4 == 0)
			{
				randomizeDir();
				continue;
			}
			if(vmanip.getNodeNoExNoEmerge(p).d
					== CONTENT_COBBLE
			&& vmanip.getNodeNoExNoEmerge(p1).d
					== CONTENT_COBBLE)
			{
				// Found wall, this is a good place!
				result_place = p;
				result_dir = m_dir;
				// Randomize next direction
				randomizeDir();
				return true;
			}
			/*
				Determine where to move next
			*/
			// Jump one up if the actual space is there
			if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).d
					== CONTENT_COBBLE
			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
					== CONTENT_AIR
			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,2,0)).d
					== CONTENT_AIR)
				p += v3s16(0,1,0);
			// Jump one down if the actual space is there
			if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
					== CONTENT_COBBLE
			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).d
					== CONTENT_AIR
			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,-1,0)).d
					== CONTENT_AIR)
				p += v3s16(0,-1,0);
			// Check if walking is now possible
			if(vmanip.getNodeNoExNoEmerge(p).d
					!= CONTENT_AIR
			|| vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
					!= CONTENT_AIR)
			{
				// Cannot continue walking here
				randomizeDir();
				continue;
			}
			// Move there
			m_pos = p;
		}
		return false;
	}

	bool findPlaceForRoomDoor(v3s16 roomsize, v3s16 &result_doorplace,
			v3s16 &result_doordir, v3s16 &result_roomplace)
	{
		for(s16 trycount=0; trycount<30; trycount++)
		{
			v3s16 doorplace;
			v3s16 doordir;
			bool r = findPlaceForDoor(doorplace, doordir);
			if(r == false)
				continue;
			v3s16 roomplace;
			// X east, Z north, Y up
			if(doordir == v3s16(1,0,0)) // X+
				roomplace = doorplace + v3s16(0,-1,-roomsize.Z/2+myrand_range(-roomsize.Z/2,roomsize.Z/2));
			if(doordir == v3s16(-1,0,0)) // X-
				roomplace = doorplace + v3s16(-roomsize.X+1,-1,-roomsize.Z/2+myrand_range(-roomsize.Z/2,roomsize.Z/2));
			if(doordir == v3s16(0,0,1)) // Z+
				roomplace = doorplace + v3s16(-roomsize.X/2+myrand_range(-roomsize.X/2,roomsize.X/2),-1,0);
			if(doordir == v3s16(0,0,-1)) // Z-
				roomplace = doorplace + v3s16(-roomsize.X/2+myrand_range(-roomsize.X/2,roomsize.X/2),-1,-roomsize.Z+1);
			
			// Check fit
			bool fits = true;
			for(s16 z=1; z<roomsize.Z-1; z++)
			for(s16 y=1; y<roomsize.Y-1; y++)
			for(s16 x=1; x<roomsize.X-1; x++)
			{
				v3s16 p = roomplace + v3s16(x,y,z);
				if(vmanip.m_area.contains(p) == false)
				{
					fits = false;
					break;
				}
				if(vmanip.m_flags[vmanip.m_area.index(p)]
						& VMANIP_FLAG_DUNGEON_INSIDE)
				{
					fits = false;
					break;
				}
			}
			if(fits == false)
			{
				// Find new place
				continue;
			}
			result_doorplace = doorplace;
			result_doordir = doordir;
			result_roomplace = roomplace;
			return true;
		}
		return false;
	}

private:
	VoxelManipulator &vmanip;
	v3s16 m_pos;
	v3s16 m_dir;	
};

void make_dungeon1(VoxelManipulator &vmanip)
{
	v3s16 areasize = vmanip.m_area.getExtent();
	v3s16 roomsize;
	v3s16 roomplace;
	
	roomsize = v3s16(myrand_range(4,8),myrand_range(4,6),myrand_range(4,8));
	roomplace = vmanip.m_area.MinEdge + v3s16(
			myrand_range(0,areasize.X-roomsize.X-1),
			myrand_range(0,areasize.Y-roomsize.Y-1),
			myrand_range(0,areasize.Z-roomsize.Z-1));
	
	u32 room_count = myrand_range(2,7);
	for(u32 i=0; i<room_count; i++)
	{
		make_room1(vmanip, roomsize, roomplace);

		RoomWalker walker(vmanip, roomplace+v3s16(roomsize.X/2,1,roomsize.Z/2));
		v3s16 doorplace;
		v3s16 doordir;
		bool r = walker.findPlaceForDoor(doorplace, doordir);
		if(r == false)
		{
			//dstream<<"walker.findPlaceForDoor failed"<<std::endl;
			return;
		}
		//dstream<<"walker.findPlaceForDoor succeeded"<<std::endl;
		
		make_door1(vmanip, doorplace, doordir);

		v3s16 corridor_end;
		v3s16 corridor_end_dir;
		make_corridor(vmanip, doorplace, doordir, corridor_end, corridor_end_dir);
		
		roomsize = v3s16(myrand_range(4,8),myrand_range(4,6),myrand_range(4,8));
		walker.setPos(corridor_end);
		walker.setDir(corridor_end_dir);
		r = walker.findPlaceForRoomDoor(roomsize, doorplace, doordir, roomplace);
		if(r == false)
		{
			//dstream<<"walker.findPlaceForRoomDoor failed"<<std::endl;
			return;
		}
		//dstream<<"walker.findPlaceForRoomDoor succeeded"<<std::endl;
		make_door1(vmanip, doorplace, doordir);
	}
	
	make_room1(vmanip, roomsize, roomplace);
	
}

/*
	Noise functions. Make sure seed is mangled differently in each one.
*/

// This affects the shape of the contour
//#define CAVE_NOISE_SCALE 10.0
#define CAVE_NOISE_SCALE 5.0

NoiseParams get_cave_noise1_params(u64 seed)
{
	/*return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 5, 0.7,
			200, CAVE_NOISE_SCALE);*/
	return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 4, 0.7,
			100, CAVE_NOISE_SCALE);
}

NoiseParams get_cave_noise2_params(u64 seed)
{
	/*return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 5, 0.7,
			200, CAVE_NOISE_SCALE);*/
	return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 4, 0.7,
			100, CAVE_NOISE_SCALE);
}

//#define CAVE_NOISE_THRESHOLD (2.5/CAVE_NOISE_SCALE)
#define CAVE_NOISE_THRESHOLD (2.0/CAVE_NOISE_SCALE)

NoiseParams get_ground_noise1_params(u64 seed)
{
	return NoiseParams(NOISE_PERLIN, seed+983240, 5,
			0.60, 100.0, 30.0);
}

NoiseParams get_ground_crumbleness_params(u64 seed)
{
	return NoiseParams(NOISE_PERLIN, seed+34413, 3,
			1.3, 20.0, 1.0);
}

NoiseParams get_ground_wetness_params(u64 seed)
{
	return NoiseParams(NOISE_PERLIN, seed+32474, 4,
			1.1, 40.0, 1.0);
}

bool is_cave(u64 seed, v3s16 p)
{
	double d1 = noise3d_param(get_cave_noise1_params(seed), p.X,p.Y,p.Z);
	double d2 = noise3d_param(get_cave_noise2_params(seed), p.X,p.Y,p.Z);
	return d1*d2 > CAVE_NOISE_THRESHOLD;
}

/*
	Ground density noise shall be interpreted by using this.

	TODO: No perlin noises here, they should be outsourced
	      and buffered
*/
bool val_is_ground(double ground_noise1_val, v3s16 p, u64 seed)
{
	//return ((double)p.Y < ground_noise1_val);

	double f = 1.0 + noise2d_perlin(
			0.5+(float)p.X/250, 0.5+(float)p.Z/250,
			seed+920381, 3, 0.5);
	if(f < 0.01)
		f = 0.01;
	else if(f >= 1.0)
		f *= 2.0;
	double h = WATER_LEVEL + 10 * noise2d_perlin(
			0.5+(float)p.X/250, 0.5+(float)p.Z/250,
			seed+84174, 4, 0.5);
	return ((double)p.Y - h < ground_noise1_val * f);
}

/*
	Queries whether a position is ground or not.
*/
bool is_ground(u64 seed, v3s16 p)
{
	double val1 = noise3d_param(get_ground_noise1_params(seed), p.X,p.Y,p.Z);
	return val_is_ground(val1, p, seed);
}

// 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 noise = noise2d_perlin(
			0.5+(float)p.X/125, 0.5+(float)p.Y/125,
			seed+2, 4, 0.66);
	double zeroval = -0.35;
	if(noise < zeroval)
		return 0;
	else
		return 0.04 * (noise-zeroval) / (1.0-zeroval);
}

#if 0
double randomstone_amount_2d(u64 seed, v2s16 p)
{
	double noise = noise2d_perlin(
			0.5+(float)p.X/250, 0.5+(float)p.Y/250,
			seed+3829434, 5, 0.66);
	double zeroval = 0.1;
	if(noise < zeroval)
		return 0;
	else
		return 0.01 * (noise-zeroval) / (1.0-zeroval);
}
#endif

double largestone_amount_2d(u64 seed, v2s16 p)
{
	double noise = noise2d_perlin(
			0.5+(float)p.X/250, 0.5+(float)p.Y/250,
			seed+14143242, 5, 0.66);
	double zeroval = 0.3;
	if(noise < zeroval)
		return 0;
	else
		return 0.005 * (noise-zeroval) / (1.0-zeroval);
}

/*
	Incrementally find ground level from 3d noise
*/
s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision)
{
	// Start a bit fuzzy to make averaging lower precision values
	// more useful
	s16 level = myrand_range(-precision/2, precision/2);
	s16 dec[] = {31000, 100, 20, 4, 1, 0};
	s16 i;
	for(i = 1; dec[i] != 0 && precision <= dec[i]; i++)
	{
		// First find non-ground by going upwards
		// Don't stop in caves.
		{
			s16 max = level+dec[i-1]*2;
			v3s16 p(p2d.X, level, p2d.Y);
			for(; p.Y < max; p.Y += dec[i])
			{
				if(!is_ground(seed, p))
				{
					level = p.Y;
					break;
				}
			}
		}
		// Then find ground by going downwards from there.
		// Go in caves, too, when precision is 1.
		{
			s16 min = level-dec[i-1]*2;
			v3s16 p(p2d.X, level, p2d.Y);
			for(; p.Y>min; p.Y-=dec[i])
			{
				bool ground = is_ground(seed, p);
				/*if(dec[i] == 1 && is_cave(seed, p))
					ground = false;*/
				if(ground)
				{
					level = p.Y;
					break;
				}
			}
		}
	}
	
	// This is more like the actual ground level
	level += dec[i-1]/2;

	return level;
}

double get_sector_average_ground_level(u64 seed, v2s16 sectorpos, double p=4);

double get_sector_average_ground_level(u64 seed, v2s16 sectorpos, double p)
{
	v2s16 node_min = sectorpos*MAP_BLOCKSIZE;
	v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1);
	double a = 0;
	a += find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_min.Y), p);
	a += find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_max.Y), p);
	a += find_ground_level_from_noise(seed,
			v2s16(node_max.X, node_max.Y), p);
	a += find_ground_level_from_noise(seed,
			v2s16(node_max.X, node_min.Y), p);
	a += find_ground_level_from_noise(seed,
			v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2), p);
	a /= 5;
	return a;
}

double get_sector_maximum_ground_level(u64 seed, v2s16 sectorpos, double p=4);

double get_sector_maximum_ground_level(u64 seed, v2s16 sectorpos, double p)
{
	v2s16 node_min = sectorpos*MAP_BLOCKSIZE;
	v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1);
	double a = -31000;
	a = MYMAX(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_min.Y), p));
	a = MYMAX(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_max.Y), p));
	a = MYMAX(a, find_ground_level_from_noise(seed,
			v2s16(node_max.X, node_max.Y), p));
	a = MYMAX(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_min.Y), p));
	a = MYMAX(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2), p));
	return a;
}

double get_sector_minimum_ground_level(u64 seed, v2s16 sectorpos, double p=4);

double get_sector_minimum_ground_level(u64 seed, v2s16 sectorpos, double p)
{
	v2s16 node_min = sectorpos*MAP_BLOCKSIZE;
	v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1);
	double a = 31000;
	a = MYMIN(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_min.Y), p));
	a = MYMIN(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_max.Y), p));
	a = MYMIN(a, find_ground_level_from_noise(seed,
			v2s16(node_max.X, node_max.Y), p));
	a = MYMIN(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X, node_min.Y), p));
	a = MYMIN(a, find_ground_level_from_noise(seed,
			v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2), p));
	return a;
}

#if 0
#define AVERAGE_MUD_AMOUNT 4

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);

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

	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));
}
#endif

bool get_have_sand(u64 seed, v2s16 p2d)
{
	// Determine whether to have sand here
	double sandnoise = noise2d_perlin(
			0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500,
			seed+59420, 3, 0.50);

	return (sandnoise > -0.15);
}

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

void makeBlock(BlockMakeData *data)
{
	if(data->no_op)
	{
		dstream<<"makeBlock: no-op"<<std::endl;
		return;
	}

	v3s16 blockpos = data->blockpos;
	
	/*dstream<<"makeBlock(): ("<<blockpos.X<<","<<blockpos.Y<<","
			<<blockpos.Z<<")"<<std::endl;*/

	ManualMapVoxelManipulator &vmanip = data->vmanip;
	v3s16 blockpos_min = blockpos - v3s16(1,1,1);
	v3s16 blockpos_max = blockpos + v3s16(1,1,1);
	// Area of center block
	v3s16 node_min = blockpos*MAP_BLOCKSIZE;
	v3s16 node_max = (blockpos+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1);
	// Full allocated area
	v3s16 full_node_min = (blockpos-1)*MAP_BLOCKSIZE;
	v3s16 full_node_max = (blockpos+2)*MAP_BLOCKSIZE-v3s16(1,1,1);
	// Area of a block
	double block_area_nodes = MAP_BLOCKSIZE*MAP_BLOCKSIZE;

	v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2);

	/*
		Get average ground level from noise
	*/
	
	s16 approx_groundlevel = (s16)get_sector_average_ground_level(
			data->seed, v2s16(blockpos.X, blockpos.Z));
	//dstream<<"approx_groundlevel="<<approx_groundlevel<<std::endl;
	
	s16 approx_ground_depth = approx_groundlevel - (node_min.Y+MAP_BLOCKSIZE/2);
	
	/*s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level(
			data->seed, v2s16(blockpos.X, blockpos.Z));
	// Minimum amount of ground above the central block
	s16 minimum_ground_depth = minimum_groundlevel - node_max.Y;*/
	
	s16 maximum_groundlevel = (s16)get_sector_maximum_ground_level(
			data->seed, v2s16(blockpos.X, blockpos.Z), 1);
	// Minimum amount of ground above the central block
	s16 maximum_ground_depth = maximum_groundlevel - node_min.Y;
	
	/*
		Special case for high air or water
	*/
	if(maximum_ground_depth < -20)
	{
		for(s16 x=node_min.X; x<=node_max.X; x++)
		for(s16 z=node_min.Z; z<=node_max.Z; z++)
		{
			// Node position
			v2s16 p2d(x,z);
			{
				// Use fast index incrementing
				v3s16 em = vmanip.m_area.getExtent();
				u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y));
				for(s16 y=node_min.Y; y<=node_max.Y; y++)
				{
					// Only modify places that have no content
					if(vmanip.m_data[i].d == CONTENT_IGNORE)
					{
						if(y <= WATER_LEVEL)
							vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE);
						else
							vmanip.m_data[i] = MapNode(CONTENT_AIR);
					}
				
					data->vmanip.m_area.add_y(em, i, 1);
				}
			}
		}
		
		// We're done
		return;
	}
	
	/*
		Make some 3D noise
	*/
	
	//NoiseBuffer noisebuf1;
	//NoiseBuffer noisebuf2;
	NoiseBuffer noisebuf_cave;
	NoiseBuffer noisebuf_ground;
	NoiseBuffer noisebuf_ground_crumbleness;
	NoiseBuffer noisebuf_ground_wetness;
	{
		v3f minpos_f(node_min.X, node_min.Y, node_min.Z);
		v3f maxpos_f(node_max.X, node_max.Y, node_max.Z);

		//TimeTaker timer("noisebuf.create");

		/*
			Cave noise
		*/

		noisebuf_cave.create(get_cave_noise1_params(data->seed),
				minpos_f.X, minpos_f.Y, minpos_f.Z,
				maxpos_f.X, maxpos_f.Y, maxpos_f.Z,
				4, 4, 4);
				//3.5, 3.5, 3.5);
		
		noisebuf_cave.multiply(get_cave_noise2_params(data->seed));

		/*
			Ground noise
		*/
		
		// Sample length
		v3f sl = v3f(4.0, 4.0, 4.0);
		
		/*
			Density
		*/
		//noisebuf_ground.create(data->seed+983240, 6, 0.60, false,
		noisebuf_ground.create(get_ground_noise1_params(data->seed),
				minpos_f.X, minpos_f.Y, minpos_f.Z,
				maxpos_f.X, maxpos_f.Y, maxpos_f.Z,
				sl.X, sl.Y, sl.Z);
		
		/*
			Content
		*/
		sl = v3f(2.5, 2.5, 2.5);
		noisebuf_ground_crumbleness.create(
				get_ground_crumbleness_params(data->seed),
				minpos_f.X, minpos_f.Y, minpos_f.Z,
				maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z,
				sl.X, sl.Y, sl.Z);
		noisebuf_ground_wetness.create(
				get_ground_wetness_params(data->seed),
				minpos_f.X, minpos_f.Y, minpos_f.Z,
				maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z,
				sl.X, sl.Y, sl.Z);
	}
	
	/*
		Make base ground level
	*/

	for(s16 x=node_min.X; x<=node_max.X; x++)
	for(s16 z=node_min.Z; z<=node_max.Z; z++)
	{
		// Node position
		v2s16 p2d(x,z);
		{
			// Use fast index incrementing
			v3s16 em = vmanip.m_area.getExtent();
			u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y));
			for(s16 y=node_min.Y; y<=node_max.Y; y++)
			{
				// Only modify places that have no content
				if(vmanip.m_data[i].d == CONTENT_IGNORE)
				{
					if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD)
						vmanip.m_data[i] = MapNode(CONTENT_AIR);
					else if(val_is_ground(noisebuf_ground.get(x,y,z),
							v3s16(x,y,z), data->seed))
						vmanip.m_data[i] = MapNode(CONTENT_STONE);
					else if(y <= WATER_LEVEL)
						vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE);
					else
						vmanip.m_data[i] = MapNode(CONTENT_AIR);
				}

				/*if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD)
				{
					// Only modify places that have no content
					if(vmanip.m_data[i].d == CONTENT_IGNORE)
						vmanip.m_data[i] = MapNode(CONTENT_AIR);
				}
				else if(is_ground(noisebuf_ground.get(x,y,z), y))
				{
					// Only modify places that have no content
					if(vmanip.m_data[i].d == CONTENT_IGNORE)
						vmanip.m_data[i] = MapNode(CONTENT_STONE);
				}
				else if(y <= WATER_LEVEL)
				{
					// Only modify places that have air or no content
					if(vmanip.m_data[i].d == CONTENT_IGNORE
							|| vmanip.m_data[i].d == CONTENT_AIR)
					vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE);
				}
				else
				{
					// Only modify places that have no content
					if(vmanip.m_data[i].d == CONTENT_IGNORE)
						vmanip.m_data[i] = MapNode(CONTENT_AIR);
				}*/
			
				data->vmanip.m_area.add_y(em, i, 1);
			}
		}
	}

	/*
		Add minerals
	*/

	{
		/*
			Add meseblocks
		*/
		for(s16 i=0; i<approx_ground_depth/4; i++)
		{
			if(myrand()%50 == 0)
			{
				s16 x = myrand_range(node_min.X+1, node_max.X-1);
				s16 y = myrand_range(node_min.Y+1, node_max.Y-1);
				s16 z = myrand_range(node_min.Z+1, node_max.Z-1);
				for(u16 i=0; i<27; i++)
				{
					v3s16 p = v3s16(x,y,z) + g_27dirs[i];
					u32 vi = vmanip.m_area.index(p);
					if(vmanip.m_data[vi].d == CONTENT_STONE)
						if(myrand()%8 == 0)
							vmanip.m_data[vi] = MapNode(CONTENT_MESE);
				}
					
			}
		}
		/*
			Add others
		*/
		{
			u16 a = myrand_range(0,15);
			a = a*a*a;
			u16 amount = 20 * a/1000;
			for(s16 i=0; i<amount; i++)
			{
				s16 x = myrand_range(node_min.X+1, node_max.X-1);
				s16 y = myrand_range(node_min.Y+1, node_max.Y-1);
				s16 z = myrand_range(node_min.Z+1, node_max.Z-1);

				u8 base_content = CONTENT_STONE;
				MapNode new_content(CONTENT_IGNORE);
				u32 sparseness = 6;

				if(noisebuf_ground_crumbleness.get(x,y+5,z) < -0.1)
				{
					new_content = MapNode(CONTENT_STONE, MINERAL_COAL);
				}
				else
				{
					if(noisebuf_ground_wetness.get(x,y+5,z) > 0.0)
						new_content = MapNode(CONTENT_STONE, MINERAL_IRON);
					/*if(noisebuf_ground_wetness.get(x,y,z) > 0.0)
						vmanip.m_data[i] = MapNode(CONTENT_MUD);
					else
						vmanip.m_data[i] = MapNode(CONTENT_SAND);*/
				}
				/*else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.1)
				{
				}*/

				if(new_content.d != CONTENT_IGNORE)
				{
					for(u16 i=0; i<27; i++)
					{
						v3s16 p = v3s16(x,y,z) + g_27dirs[i];
						u32 vi = vmanip.m_area.index(p);
						if(vmanip.m_data[vi].d == base_content)
						{
							if(myrand()%sparseness == 0)
								vmanip.m_data[vi] = new_content;
						}
					}
				}
			}
		}
		/*
			Add coal
		*/
		//for(s16 i=0; i < MYMAX(0, 50 - abs(node_min.Y+8 - (-30))); i++)
		//for(s16 i=0; i<50; i++)
		u16 coal_amount = 30;
		u16 coal_rareness = 60 / coal_amount;
		if(coal_rareness == 0)
			coal_rareness = 1;
		if(myrand()%coal_rareness == 0)
		{
			u16 a = myrand() % 16;
			u16 amount = coal_amount * a*a*a / 1000;
			for(s16 i=0; i<amount; i++)
			{
				s16 x = myrand_range(node_min.X+1, node_max.X-1);
				s16 y = myrand_range(node_min.Y+1, node_max.Y-1);
				s16 z = myrand_range(node_min.Z+1, node_max.Z-1);
				for(u16 i=0; i<27; i++)
				{
					v3s16 p = v3s16(x,y,z) + g_27dirs[i];
					u32 vi = vmanip.m_area.index(p);
					if(vmanip.m_data[vi].d == CONTENT_STONE)
						if(myrand()%8 == 0)
							vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_COAL);
				}
			}
		}
		/*
			Add iron
		*/
		u16 iron_amount = 8;
		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++)
			{
				s16 x = myrand_range(node_min.X+1, node_max.X-1);
				s16 y = myrand_range(node_min.Y+1, node_max.Y-1);
				s16 z = myrand_range(node_min.Z+1, node_max.Z-1);
				for(u16 i=0; i<27; i++)
				{
					v3s16 p = v3s16(x,y,z) + g_27dirs[i];
					u32 vi = vmanip.m_area.index(p);
					if(vmanip.m_data[vi].d == CONTENT_STONE)
						if(myrand()%8 == 0)
							vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_IRON);
				}
			}
		}
	}

	/*
		Add mud and sand and others underground (in place of stone)
	*/

	for(s16 x=node_min.X; x<=node_max.X; x++)
	for(s16 z=node_min.Z; z<=node_max.Z; z++)
	{
		// Node position
		v2s16 p2d(x,z);
		{
			// Use fast index incrementing
			v3s16 em = vmanip.m_area.getExtent();
			u32 i = vmanip.m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y));
			for(s16 y=node_max.Y; y>=node_min.Y; y--)
			{
				if(vmanip.m_data[i].d == CONTENT_STONE)
				{
					if(noisebuf_ground_crumbleness.get(x,y,z) > 1.3)
					{
						if(noisebuf_ground_wetness.get(x,y,z) > 0.0)
							vmanip.m_data[i] = MapNode(CONTENT_MUD);
						else
							vmanip.m_data[i] = MapNode(CONTENT_SAND);
					}
					else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.7)
					{
						if(noisebuf_ground_wetness.get(x,y,z) < -0.6)
							vmanip.m_data[i] = MapNode(CONTENT_GRAVEL);
					}
				}

				data->vmanip.m_area.add_y(em, i, -1);
			}
		}
	}

	/*
		Add dungeons
	*/
	
	//if(node_min.Y < approx_groundlevel)
	//if(myrand() % 3 == 0)
	//if(myrand() % 3 == 0 && node_min.Y < approx_groundlevel)
	if(myrand() % 100 == 0 && node_min.Y < approx_groundlevel)
	{
		// Dungeon generator doesn't modify places which have this set
		data->vmanip.clearFlag(VMANIP_FLAG_DUNGEON_INSIDE
				| VMANIP_FLAG_DUNGEON_PRESERVE);
		
		// Set all air and water to be untouchable to make dungeons open
		// to caves and open air
		for(s16 x=full_node_min.X; x<=full_node_max.X; x++)
		for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++)
		{
			// Node position
			v2s16 p2d(x,z);
			{
				// Use fast index incrementing
				v3s16 em = vmanip.m_area.getExtent();
				u32 i = vmanip.m_area.index(v3s16(p2d.X, full_node_max.Y, p2d.Y));
				for(s16 y=node_max.Y; y>=full_node_min.Y; y--)
				{
					if(vmanip.m_data[i].d == CONTENT_AIR)
						vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE;
					else if(vmanip.m_data[i].d == CONTENT_WATERSOURCE)
						vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE;
					data->vmanip.m_area.add_y(em, i, -1);
				}
			}
		}
		
		/*s16 x = myrand_range(node_min.X, node_max.X);
		s16 z = myrand_range(node_min.Z, node_max.Z);
		s16 y = myrand_range(node_min.Y, node_max.Y);*/
		// Add it
		make_dungeon1(data->vmanip);
		
		// Take different seed for every dungeon for not blending their
		// mossyness together
		//u32 mossyseed = z*38134234+y*42123+x*23;
		u32 mossyseed = full_node_min.Z*38134234
				+full_node_min.Y*42123+full_node_min.X*23;

		// Convert some cobble to mossy cobble
		for(s16 x=full_node_min.X; x<=full_node_max.X; x++)
		for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++)
		{
			// Node position
			v2s16 p2d(x,z);
			{
				// Use fast index incrementing
				v3s16 em = vmanip.m_area.getExtent();
				u32 i = vmanip.m_area.index(v3s16(p2d.X, full_node_max.Y, p2d.Y));
				for(s16 y=node_max.Y; y>=full_node_min.Y; y--)
				{
					// No mossy in dry places
					// (noisebuf not used because it's smaller in size)
					if(noise3d_param(get_ground_wetness_params(data->seed), x,y,z)
							< -0.6)
						continue;
					double d = noise3d_perlin((float)x/4.,
							(float)y/4.,(float)z/4.,
							mossyseed, 2, 0.9);
					if(d < 0.0)
						continue;
					if(vmanip.m_data[i].d == CONTENT_COBBLE)
						vmanip.m_data[i].d = CONTENT_MOSSYCOBBLE;
					data->vmanip.m_area.add_y(em, i, -1);
				}
			}
		}
	}
	
	/*
		Add top and bottom side of water to transforming_liquid queue
	*/

	for(s16 x=node_min.X; x<=node_max.X; x++)
	for(s16 z=node_min.Z; z<=node_max.Z; z++)
	{
		// Node position
		v2s16 p2d(x,z);
		{
			bool water_found = false;
			// Use fast index incrementing
			v3s16 em = vmanip.m_area.getExtent();
			u32 i = vmanip.m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y));
			for(s16 y=node_max.Y; y>=node_min.Y; y--)
			{
				if(water_found == false)
				{
					if(vmanip.m_data[i].d == CONTENT_WATERSOURCE)
					{
						v3s16 p = v3s16(p2d.X, y, p2d.Y);
						data->transforming_liquid.push_back(p);
						water_found = true;
					}
				}
				else
				{
					// This can be done because water_found can only
					// turn to true and end up here after going through
					// a single block.
					if(vmanip.m_data[i+1].d != CONTENT_WATERSOURCE)
					{
						v3s16 p = v3s16(p2d.X, y+1, p2d.Y);
						data->transforming_liquid.push_back(p);
						water_found = false;
					}
				}

				data->vmanip.m_area.add_y(em, i, -1);
			}
		}
	}

	/*
		If close to ground level
	*/

	if(abs(approx_ground_depth) < 20)
	{
		/*
			Add grass and mud
		*/

		for(s16 x=node_min.X; x<=node_max.X; x++)
		for(s16 z=node_min.Z; z<=node_max.Z; z++)
		{
			// Node position
			v2s16 p2d(x,z);
			{
				bool possibly_have_sand = get_have_sand(data->seed, p2d);
				bool have_sand = false;
				u32 mud_count = 0;
				bool air_detected = false;
				bool water_detected = false;
				// Use fast index incrementing
				s16 start_y = node_max.Y+2;
				v3s16 em = vmanip.m_area.getExtent();
				u32 i = vmanip.m_area.index(v3s16(p2d.X, start_y, p2d.Y));
				for(s16 y=start_y; y>=node_min.Y-2; y--)
				{
					if(vmanip.m_data[i].d == CONTENT_WATERSOURCE)
						water_detected = true;
					if(vmanip.m_data[i].d == CONTENT_AIR)
						air_detected = true;

					if((vmanip.m_data[i].d == CONTENT_STONE
							|| vmanip.m_data[i].d == CONTENT_GRASS
							|| vmanip.m_data[i].d == CONTENT_MUD
							|| vmanip.m_data[i].d == CONTENT_SAND
							|| vmanip.m_data[i].d == CONTENT_GRAVEL
							) && (air_detected || water_detected))
					{
						if(mud_count == 0 && y <= WATER_LEVEL+2
								&& possibly_have_sand)
							have_sand = true;

						if(have_sand)
						{
							vmanip.m_data[i] = MapNode(CONTENT_SAND);
						}
						else if(mud_count==0 && !water_detected && y >= WATER_LEVEL)
							vmanip.m_data[i] = MapNode(CONTENT_GRASS);
						else
							vmanip.m_data[i] = MapNode(CONTENT_MUD);

						mud_count++;
						if(mud_count >= 4)
							break;
					}
					else if(mud_count != 0)
						break;

					data->vmanip.m_area.add_y(em, i, -1);
				}
			}
		}

		/*
			Add trees
		*/
		
		// Amount of trees
		u32 tree_count = block_area_nodes * 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(node_min.X, node_max.X);
			s16 z = myrand_range(node_min.Z, node_max.Z);
			//s16 y = find_ground_level(data->vmanip, v2s16(x,z));
			s16 y = find_ground_level_from_noise(data->seed, v2s16(x,z), 4);
			// Don't make a tree under water level
			if(y < WATER_LEVEL)
				continue;
			// Make sure tree fits (only trees whose starting point is
			// at this block are added)
			if(y < node_min.Y || y > node_max.Y)
				continue;
			/*
				Find exact ground level
			*/
			v3s16 p(x,y+6,z);
			bool found = false;
			for(; p.Y >= y-6; p.Y--)
			{
				u32 i = data->vmanip.m_area.index(p);
				MapNode *n = &data->vmanip.m_data[i];
				if(n->d != CONTENT_AIR && n->d != CONTENT_IGNORE)
				{
					found = true;
					break;
				}
			}
			// If not found, handle next one
			if(found == false)
				continue;
			/*
				Trees grow only on mud and grass
			*/
			{
				u32 i = data->vmanip.m_area.index(p);
				MapNode *n = &data->vmanip.m_data[i];
				if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
					continue;
			}
			// Tree will be placed one higher
			p.Y++;
			// Make a tree
			make_tree(data->vmanip, p);
		}

#if 0
		/*
			Add some kind of random stones
		*/
		
		u32 random_stone_count = block_area_nodes *
				randomstone_amount_2d(data->seed, p2d_center);
		// Put in random places on part of division
		for(u32 i=0; i<random_stone_count; i++)
		{
			s16 x = myrand_range(node_min.X, node_max.X);
			s16 z = myrand_range(node_min.Z, node_max.Z);
			s16 y = find_ground_level_from_noise(data->seed, v2s16(x,z), 1);
			// Don't add under water level
			/*if(y < WATER_LEVEL)
				continue;*/
			// Don't add if doesn't belong to this block
			if(y < node_min.Y || y > node_max.Y)
				continue;
			v3s16 p(x,y,z);
			// Filter placement
			/*{
				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;
			}*/
			// Will be placed one higher
			p.Y++;
			// Add it
			make_randomstone(data->vmanip, p);
		}
#endif

#if 0
		/*
			Add larger stones
		*/
		
		u32 large_stone_count = block_area_nodes *
				largestone_amount_2d(data->seed, p2d_center);
		//u32 large_stone_count = 1;
		// Put in random places on part of division
		for(u32 i=0; i<large_stone_count; i++)
		{
			s16 x = myrand_range(node_min.X, node_max.X);
			s16 z = myrand_range(node_min.Z, node_max.Z);
			s16 y = find_ground_level_from_noise(data->seed, v2s16(x,z), 1);
			// Don't add under water level
			/*if(y < WATER_LEVEL)
				continue;*/
			// Don't add if doesn't belong to this block
			if(y < node_min.Y || y > node_max.Y)
				continue;
			v3s16 p(x,y,z);
			// Filter placement
			/*{
				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;
			}*/
			// Will be placed one lower
			p.Y--;
			// Add it
			make_largestone(data->vmanip, p);
		}
#endif
	}

}

void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
{
	/*dstream<<"initBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
			<<blockpos.Z<<")"<<std::endl;*/

	data->no_op = false;
	data->seed = m_seed;
	data->blockpos = blockpos;

	/*
		Create the whole area of this and the neighboring blocks
	*/
	{
		//TimeTaker timer("initBlockMake() create area");
		
		for(s16 x=-1; x<=1; x++)
		for(s16 z=-1; z<=1; z++)
		{
			v2s16 sectorpos(blockpos.X+x, blockpos.Z+z);
			// Sector metadata is loaded from disk if not already loaded.
			ServerMapSector *sector = createSector(sectorpos);
			assert(sector);

			for(s16 y=-1; y<=1; 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.
				*/
				block->setIsUnderground(false);
			}
		}
	}
	
	/*
		Now we have a big empty area.

		Make a ManualMapVoxelManipulator that contains this and the
		neighboring blocks
	*/
	
	v3s16 bigarea_blocks_min = blockpos - v3s16(1,1,1);
	v3s16 bigarea_blocks_max = blockpos + v3s16(1,1,1);
	
	data->vmanip.setMap(this);

	// Add the area
	{
		//TimeTaker timer("initBlockMake() initialEmerge");
		data->vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
	}

	// Data is ready now.
}

MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
		core::map<v3s16, MapBlock*> &changed_blocks)
{
	v3s16 blockpos = data->blockpos;
	/*dstream<<"finishBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
			<<blockpos.Z<<")"<<std::endl;*/

	if(data->no_op)
	{
		dstream<<"finishBlockMake(): no-op"<<std::endl;
		return NULL;
	}

	/*dstream<<"Resulting vmanip:"<<std::endl;
	data->vmanip.print(dstream);*/
	
	/*
		Blit generated stuff to map
	*/
	{
		// 70ms @cs=8
		//TimeTaker timer("finishBlockMake() blitBackAll");
		data->vmanip.blitBackAll(&changed_blocks);
	}

	//dstream<<"changed_blocks.size()="<<changed_blocks.size()<<std::endl;

	/*
		Copy transforming liquid information
	*/
	while(data->transforming_liquid.size() > 0)
	{
		v3s16 p = data->transforming_liquid.pop_front();
		m_transforming_liquid.push_back(p);
	}
	
	/*
		Get central block
	*/
	MapBlock *block = getBlockNoCreateNoEx(data->blockpos);
	assert(block);

	/*
		Set is_underground flag for lighting with sunlight
	*/

	s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level(
			data->seed, v2s16(blockpos.X, blockpos.Z));
	
	if(blockpos.Y*MAP_BLOCKSIZE + MAP_BLOCKSIZE <= minimum_groundlevel)
		block->setIsUnderground(true);
	else
		block->setIsUnderground(false);

	/*
		Add sunlight to central block.
		This makes in-dark-spawning monsters to not flood the whole thing.
		Do not spread the light, though.
	*/
	/*core::map<v3s16, bool> light_sources;
	bool black_air_left = false;
	block->propagateSunlight(light_sources, true, &black_air_left);*/

	/*
		NOTE: Lighting and object adding shouldn't really be here, but
		lighting is a bit tricky to move properly to makeBlock.
		TODO: Do this the right way anyway.
	*/

	/*
		Update lighting
	*/
	core::map<v3s16, MapBlock*> lighting_update_blocks;
	lighting_update_blocks.insert(block->getPos(), block);
	/*for(core::map<v3s16, MapBlock*>::Iterator
			i = modified_blocks.getIterator();
			i.atEnd() == false; i++)
	{
		lighting_update_blocks.insert(i.getNode()->getKey(),
				i.getNode()->getValue());
	}*/
	updateLighting(lighting_update_blocks, changed_blocks);
	
	/*
		Add random objects to block
	*/
	addRandomObjects(block);

	/*
		Go through changed blocks
	*/
	for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
			i.atEnd() == false; i++)
	{
		MapBlock *block = i.getNode()->getValue();
		assert(block);
		/*
			Update day/night difference cache of the MapBlocks
		*/
		block->updateDayNightDiff();
		/*
			Set block as modified
		*/
		block->raiseModified(MOD_STATE_WRITE_NEEDED);
	}

	/*
		Set central block as generated
	*/
	block->setGenerated(true);
	
	/*
		Save changed parts of map
		NOTE: Will be saved later.
	*/
	//save(true);

	/*dstream<<"finishBlockMake() done for ("<<blockpos.X<<","<<blockpos.Y<<","
			<<blockpos.Z<<")"<<std::endl;*/
	
	return block;
}

ServerMapSector * ServerMap::createSector(v2s16 p2d)
{
	DSTACKF("%s: p2d=(%d,%d)",
			__FUNCTION_NAME,
			p2d.X, p2d.Y);
	
	/*
		Check if it exists already in memory
	*/
	ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
	if(sector != NULL)
		return sector;
	
	/*
		Try to load it from disk (with blocks)
	*/
	//if(loadSectorFull(p2d) == true)

	/*
		Try to load metadata from disk
	*/
	if(loadSectorMeta(p2d) == true)
	{
		ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
		if(sector == NULL)
		{
			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
	*/
	m_sectors.insert(p2d, sector);
	
	return sector;
}

/*
	This is a quick-hand function for calling makeBlock().
*/
MapBlock * ServerMap::generateBlock(
		v3s16 p,
		core::map<v3s16, MapBlock*> &modified_blocks
)
{
	DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
	
	/*dstream<<"generateBlock(): "
			<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
			<<std::endl;*/
	
	//MapBlock *block = original_dummy;
			
	v2s16 p2d(p.X, p.Z);
	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");
	}

	/*
		Create block make data
	*/
	BlockMakeData data;
	initBlockMake(&data, p);

	/*
		Generate block
	*/
	{
		TimeTaker t("makeBlock()");
		makeBlock(&data);
	}

	/*
		Blit data back on map, update lighting, add mobs and whatever this does
	*/
	finishBlockMake(&data, modified_blocks);

	/*
		Get central block
	*/
	MapBlock *block = getBlockNoCreateNoEx(p);
	assert(block);

#if 0
	/*
		Check result
	*/
	bool erroneus_content = false;
	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
	for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
	{
		v3s16 p(x0,y0,z0);
		MapNode n = block->getNode(p);
		if(n.d == CONTENT_IGNORE)
		{
			dstream<<"CONTENT_IGNORE at "
					<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
					<<std::endl;
			erroneus_content = true;
			assert(0);
		}
	}
	if(erroneus_content)
	{
		assert(0);
	}
#endif

#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;
			if(y0%2==0)
				n.d = CONTENT_AIR;
			else
				n.d = CONTENT_STONE;
			block->setNode(v3s16(x0,y0,z0), n);
		}
	}
#endif

	return block;
}

MapBlock * ServerMap::createBlock(v3s16 p)
{
	DSTACKF("%s: p=(%d,%d,%d)",
			__FUNCTION_NAME, p.X, p.Y, p.Z);
	
	/*
		Do not create 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("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)
	{
		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;
	}*/

	/*
		Try to get a block from the sector
	*/

	MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
	if(block)
	{
		if(block->isDummy())
			block->unDummify();
		return block;
	}
	// Create blank
	block = sector->createBlankBlock(block_y);
	return block;
}

#if 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);
	
	// This has to be redone or removed
	assert(0);
	return NULL;
}
#endif

#if 0
	/*
		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 = createSector(p2d);
		//sector = emergeSector(p2d, changed_blocks);
	}
	catch(InvalidPositionException &e)
	{
		dstream<<"emergeBlock: createSector() 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: createSector() 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 to get a block from the sector
	*/

	bool does_not_exist = false;
	bool lighting_expired = false;
	MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
	
	// If not found, try loading from disk
	if(block == NULL)
	{
		block = loadBlock(p);
	}
	
	// Handle result
	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(block == NULL)
		{
			// Create dummy block
			block = new MapBlock(this, p, true);

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

	if(lighting_expired)
	{
		lighting_invalidated_blocks.insert(p, block);
	}

#if 0
	/*
		Initially update sunlight
	*/
	{
		core::map<v3s16, bool> light_sources;
		bool black_air_left = false;
		bool bottom_invalid =
				block->propagateSunlight(light_sources, true,
				&black_air_left);

		// 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)
		{
			lighting_invalidated_blocks[block->getPos()] = block;
		}

		if(bottom_invalid)
		{
			lighting_invalidated_blocks[block->getPos()] = block;
		}
	}
#endif
	
	return block;
}
#endif

s16 ServerMap::findGroundLevel(v2s16 p2d)
{
#if 0
	/*
		Uh, just do something random...
	*/
	// 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--)
	{
		MapNode n = getNodeNoEx(p);
		if(n.d != CONTENT_IGNORE)
			break;
	}
	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--)
	{
		MapNode n = getNodeNoEx(p);
		if(content_walkable(n.d) && n.d != CONTENT_IGNORE)
			return p.Y;
	}

	// Move to plan b
plan_b:
#endif

	/*
		Determine from map generator noise functions
	*/
	
	s16 level = find_ground_level_from_noise(m_seed, p2d, 1);
	return level;

	//double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
	//return (s16)level;
}

void ServerMap::createDirs(std::string path)
{
	if(fs::CreateAllDirs(path) == false)
	{
		m_dout<<DTIME<<"ServerMap: Failed to create directory "
				<<"\""<<path<<"\""<<std::endl;
		throw BaseException("ServerMap failed to create directory");
	}
}

std::string ServerMap::getSectorDir(v2s16 pos, int layout)
{
	char cc[9];
	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)
{
	unsigned int x, y;
	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;
}

v3s16 ServerMap::getBlockPos(std::string sectordir, std::string blockfile)
{
	v2s16 p2d = getSectorPos(sectordir);

	if(blockfile.size() != 4){
		throw InvalidFilenameException("Invalid block filename");
	}
	unsigned int y;
	int r = sscanf(blockfile.c_str(), "%4x", &y);
	if(r != 1)
		throw InvalidFilenameException("Invalid block filename");
	return v3s16(p2d.X, y, p2d.Y);
}

std::string ServerMap::getBlockFilename(v3s16 p)
{
	char cc[5];
	snprintf(cc, 5, "%.4x", (unsigned int)p.Y&0xffff);
	return cc;
}

void ServerMap::save(bool only_changed)
{
	DSTACK(__FUNCTION_NAME);
	if(m_map_saving_enabled == false)
	{
		dstream<<DTIME<<"WARNING: Not saving map, saving disabled."<<std::endl;
		return;
	}
	
	if(only_changed == false)
		dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
				<<std::endl;
	
	if(only_changed == false || m_map_metadata_changed)
	{
		saveMapMeta();
	}

	u32 sector_meta_count = 0;
	u32 block_count = 0;
	u32 block_count_all = 0; // Number of blocks in memory
	
	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(sector->differs_from_disk || only_changed == false)
		{
			saveSectorMeta(sector);
			sector_meta_count++;
		}
		core::list<MapBlock*> blocks;
		sector->getBlocks(blocks);
		core::list<MapBlock*>::Iterator j;
		for(j=blocks.begin(); j!=blocks.end(); j++)
		{
			MapBlock *block = *j;
			
			block_count_all++;

			if(block->getModified() >= MOD_STATE_WRITE_NEEDED 
					|| only_changed == false)
			{
				saveBlock(block);
				block_count++;

				/*dstream<<"ServerMap: Written block ("
						<<block->getPos().X<<","
						<<block->getPos().Y<<","
						<<block->getPos().Z<<")"
						<<std::endl;*/
			}
		}
	}

	/*
		Only print if something happened or saved whole map
	*/
	if(only_changed == false || sector_meta_count != 0
			|| block_count != 0)
	{
		dstream<<DTIME<<"ServerMap: Written: "
				<<sector_meta_count<<" sector metadata files, "
				<<block_count<<" block files"
				<<", "<<block_count_all<<" blocks in memory."
				<<std::endl;
	}
}

void ServerMap::saveMapMeta()
{
	DSTACK(__FUNCTION_NAME);
	
	dstream<<"INFO: ServerMap::saveMapMeta(): "
			<<"seed="<<m_seed
			<<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.writeLines(os);

	os<<"[end_of_params]\n";
	
	m_map_metadata_changed = false;
}

void ServerMap::loadMapMeta()
{
	DSTACK(__FUNCTION_NAME);
	
	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)
	{
		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");

	dstream<<"INFO: ServerMap::loadMapMeta(): "
			<<"seed="<<m_seed
			<<std::endl;
}

void ServerMap::saveSectorMeta(ServerMapSector *sector)
{
	DSTACK(__FUNCTION_NAME);
	// Format used for writing
	u8 version = SER_FMT_VER_HIGHEST;
	// Get destination
	v2s16 pos = sector->getPos();
	std::string dir = getSectorDir(pos);
	createDirs(dir);
	
	std::string fullpath = dir + "/meta";
	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
	if(o.good() == false)
		throw FileNotGoodException("Cannot open sector metafile");

	sector->serialize(o, version);
	
	sector->differs_from_disk = false;
}

MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load)
{
	DSTACK(__FUNCTION_NAME);
	// Get destination
	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)
	{
		// 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;

	return sector;
}

bool ServerMap::loadSectorMeta(v2s16 p2d)
{
	DSTACK(__FUNCTION_NAME);

	MapSector *sector = NULL;

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

	try{
		sector = loadSectorMeta(sectordir, loadlayout != 2);
	}
	catch(InvalidFilenameException &e)
	{
		return false;
	}
	catch(FileNotGoodException &e)
	{
		return false;
	}
	catch(std::exception &e)
	{
		return false;
	}
	
	return true;
}

#if 0
bool ServerMap::loadSectorFull(v2s16 p2d)
{
	DSTACK(__FUNCTION_NAME);

	MapSector *sector = NULL;

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

	try{
		sector = loadSectorMeta(sectordir, loadlayout != 2);
	}
	catch(InvalidFilenameException &e)
	{
		return false;
	}
	catch(FileNotGoodException &e)
	{
		return false;
	}
	catch(std::exception &e)
	{
		return false;
	}
	
	/*
		Load blocks
	*/
	std::vector<fs::DirListNode> list2 = fs::GetDirListing
			(sectordir);
	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)
		{
			// This catches unknown crap in directory
		}
	}

	if(loadlayout != 2)
	{
		dstream<<"Sector converted to new layout - deleting "<<
			sectordir1<<std::endl;
		fs::RecursiveDelete(sectordir1);
	}

	return true;
}
#endif

void ServerMap::saveBlock(MapBlock *block)
{
	DSTACK(__FUNCTION_NAME);
	/*
		Dummy blocks are not written
	*/
	if(block->isDummy())
	{
		/*v3s16 p = block->getPos();
		dstream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block "
				<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
		return;
	}

	// Format used for writing
	u8 version = SER_FMT_VER_HIGHEST;
	// Get destination
	v3s16 p3d = block->getPos();
	
	v2s16 p2d(p3d.X, p3d.Z);
	std::string sectordir = getSectorDir(p2d);

	createDirs(sectordir);

	std::string fullpath = sectordir+"/"+getBlockFilename(p3d);
	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
	if(o.good() == false)
		throw FileNotGoodException("Cannot open block data");

	/*
		[0] u8 serialization version
		[1] data
	*/
	o.write((char*)&version, 1);
	
	// Write basic data
	block->serialize(o, version);
	
	// Write extra data stored on disk
	block->serializeDiskExtra(o, version);

	// We just wrote it to the disk so clear modified flag
	block->resetModified();
}

void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load)
{
	DSTACK(__FUNCTION_NAME);

	std::string fullpath = sectordir+"/"+blockfile;
	try{

		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);

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

		// 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;
		}
		
		// Read basic data
		block->deSerialize(is, version);

		// Read extra data stored on disk
		block->deSerializeDiskExtra(is, version);
		
		// If it's a new block, insert it to the map
		if(created_new)
			sector->insertBlock(block);
		
		/*
			Save blocks loaded in old format in new format
		*/

		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->resetModified();

	}
	catch(SerializationError &e)
	{
		dstream<<"WARNING: Invalid block data on disk "
				<<"fullpath="<<fullpath
				<<" (SerializationError). "
				<<"what()="<<e.what()
				<<std::endl;
				//" Ignoring. A new one will be generated.
		assert(0);

		// TODO: Backup file; name is in fullpath.
	}
}

MapBlock* ServerMap::loadBlock(v3s16 blockpos)
{
	DSTACK(__FUNCTION_NAME);

	v2s16 p2d(blockpos.X, blockpos.Z);

	// 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);
	}
	
	/*
		Make sure sector is loaded
	*/
	MapSector *sector = getSectorNoGenerateNoEx(p2d);
	if(sector == NULL)
	{
		try{
			sector = loadSectorMeta(sectordir, loadlayout != 2);
		}
		catch(InvalidFilenameException &e)
		{
			return false;
		}
		catch(FileNotGoodException &e)
		{
			return false;
		}
		catch(std::exception &e)
		{
			return false;
		}
	}
	
	/*
		Make sure file exists
	*/

	std::string blockfilename = getBlockFilename(blockpos);
	if(fs::PathExists(sectordir+"/"+blockfilename) == false)
		return NULL;

	/*
		Load block
	*/
	loadBlock(sectordir, blockfilename, sector, loadlayout != 2);
	return getBlockNoCreateNoEx(blockpos);
}

void ServerMap::PrintInfo(std::ostream &out)
{
	out<<"ServerMap: ";
}

#ifndef SERVER

/*
	ClientMap
*/

ClientMap::ClientMap(
		Client *client,
		MapDrawControl &control,
		scene::ISceneNode* parent,
		scene::ISceneManager* mgr,
		s32 id
):
	Map(dout_client),
	scene::ISceneNode(parent, mgr, id),
	m_client(client),
	m_control(control),
	m_camera_position(0,0,0),
	m_camera_direction(0,0,1)
{
	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);
}

ClientMap::~ClientMap()
{
	/*JMutexAutoLock lock(mesh_mutex);
	
	if(mesh != NULL)
	{
		mesh->drop();
		mesh = NULL;
	}*/
}

MapSector * ClientMap::emergeSector(v2s16 p2d)
{
	DSTACK(__FUNCTION_NAME);
	// Check that it doesn't exist already
	try{
		return getSectorNoGenerate(p2d);
	}
	catch(InvalidPositionException &e)
	{
	}
	
	// Create a sector
	ClientMapSector *sector = new ClientMapSector(this, p2d);
	
	{
		//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
		m_sectors.insert(p2d, sector);
	}
	
	return sector;
}

void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is)
{
	DSTACK(__FUNCTION_NAME);
	ClientMapSector *sector = NULL;

	//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
	
	core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p2d);

	if(n != NULL)
	{
		sector = (ClientMapSector*)n->getValue();
		assert(sector->getId() == MAPSECTOR_CLIENT);
	}
	else
	{
		sector = new ClientMapSector(this, p2d);
		{
			//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
			m_sectors.insert(p2d, sector);
		}
	}

	sector->deSerialize(is);
}

void ClientMap::OnRegisterSceneNode()
{
	if(IsVisible)
	{
		SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
		SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
	}

	ISceneNode::OnRegisterSceneNode();
}

void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
{
	//m_dout<<DTIME<<"Rendering map..."<<std::endl;
	DSTACK(__FUNCTION_NAME);

	bool is_transparent_pass = pass == scene::ESNRP_TRANSPARENT;
	
	/*
		This is called two times per frame, reset on the non-transparent one
	*/
	if(pass == scene::ESNRP_SOLID)
	{
		m_last_drawn_sectors.clear();
	}

	/*
		Get time for measuring timeout.
		
		Measuring time is very useful for long delays when the
		machine is swapping a lot.
	*/
	int time1 = time(0);

	//u32 daynight_ratio = m_client->getDayNightRatio();

	m_camera_mutex.Lock();
	v3f camera_position = m_camera_position;
	v3f camera_direction = m_camera_direction;
	m_camera_mutex.Unlock();

	/*
		Get all blocks and draw all visible ones
	*/

	v3s16 cam_pos_nodes(
			camera_position.X / BS,
			camera_position.Y / BS,
			camera_position.Z / BS);

	v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1);

	v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d;
	v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d;

	// Take a fair amount as we will be dropping more out later
	v3s16 p_blocks_min(
			p_nodes_min.X / MAP_BLOCKSIZE - 1,
			p_nodes_min.Y / MAP_BLOCKSIZE - 1,
			p_nodes_min.Z / MAP_BLOCKSIZE - 1);
	v3s16 p_blocks_max(
			p_nodes_max.X / MAP_BLOCKSIZE,
			p_nodes_max.Y / MAP_BLOCKSIZE,
			p_nodes_max.Z / MAP_BLOCKSIZE);
	
	u32 vertex_count = 0;
	
	// For limiting number of mesh updates per frame
	u32 mesh_update_count = 0;
	
	u32 blocks_would_have_drawn = 0;
	u32 blocks_drawn = 0;

	int timecheck_counter = 0;
	core::map<v2s16, MapSector*>::Iterator si;
	si = m_sectors.getIterator();
	for(; si.atEnd() == false; si++)
	{
		{
			timecheck_counter++;
			if(timecheck_counter > 50)
			{
				timecheck_counter = 0;
				int time2 = time(0);
				if(time2 > time1 + 4)
				{
					dstream<<"ClientMap::renderMap(): "
						"Rendering takes ages, returning."
						<<std::endl;
					return;
				}
			}
		}

		MapSector *sector = si.getNode()->getValue();
		v2s16 sp = sector->getPos();
		
		if(m_control.range_all == false)
		{
			if(sp.X < p_blocks_min.X
			|| sp.X > p_blocks_max.X
			|| sp.Y < p_blocks_min.Z
			|| sp.Y > p_blocks_max.Z)
				continue;
		}

		core::list< MapBlock * > sectorblocks;
		sector->getBlocks(sectorblocks);
		
		/*
			Draw blocks
		*/
		
		u32 sector_blocks_drawn = 0;

		core::list< MapBlock * >::Iterator i;
		for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
		{
			MapBlock *block = *i;

			/*
				Compare block position to camera position, skip
				if not seen on display
			*/
			
			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, &d) == false)
			{
				continue;
			}
			
			// This is ugly (spherical distance limit?)
			/*if(m_control.range_all == false &&
					d - 0.5*BS*MAP_BLOCKSIZE > range)
				continue;*/

#if 1
			/*
				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;
			
			{
				JMutexAutoLock lock(block->mesh_mutex);

				mesh_expired = block->getMeshExpired();

				// Mesh has not been expired and there is no mesh:
				// block has no content
				if(block->mesh == NULL && mesh_expired == false)
					continue;
			}

			f32 faraway = BS*50;
			//f32 faraway = m_control.wanted_range * BS;
			
			/*
				This has to be done with the mesh_mutex unlocked
			*/
			// Pretty random but this should work somewhat nicely
			if(mesh_expired && (
					(mesh_update_count < 3
						&& (d < faraway || mesh_update_count < 2)
					)
					|| 
					(m_control.range_all && mesh_update_count < 20)
				)
			)
			/*if(mesh_expired && mesh_update_count < 6
					&& (d < faraway || mesh_update_count < 3))*/
			{
				mesh_update_count++;

				// Mesh has been expired: generate new mesh
				//block->updateMesh(daynight_ratio);
				m_client->addUpdateMeshTask(block->getPos());

				mesh_expired = false;
			}
			
#endif
			/*
				Draw the faces of the block
			*/
			{
				JMutexAutoLock lock(block->mesh_mutex);

				scene::SMesh *mesh = block->mesh;

				if(mesh == NULL)
					continue;
				
				blocks_would_have_drawn++;
				if(blocks_drawn >= m_control.wanted_max_blocks
						&& m_control.range_all == false
						&& d > m_control.wanted_min_range * BS)
					continue;

				blocks_drawn++;
				sector_blocks_drawn++;

				u32 c = mesh->getMeshBufferCount();

				for(u32 i=0; i<c; i++)
				{
					scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
					const video::SMaterial& material = buf->getMaterial();
					video::IMaterialRenderer* rnd =
							driver->getMaterialRenderer(material.MaterialType);
					bool transparent = (rnd && rnd->isTransparent());
					// 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();
					}
				}
			}
		} // foreach sectorblocks

		if(sector_blocks_drawn != 0)
		{
			m_last_drawn_sectors[sp] = true;
		}
	}
	
	m_control.blocks_drawn = blocks_drawn;
	m_control.blocks_would_have_drawn = blocks_would_have_drawn;

	/*dstream<<"renderMap(): is_transparent_pass="<<is_transparent_pass
			<<", rendered "<<vertex_count<<" vertices."<<std::endl;*/
}

bool ClientMap::setTempMod(v3s16 p, NodeMod mod,
		core::map<v3s16, MapBlock*> *affected_blocks)
{
	bool changed = false;
	/*
		Add it to all blocks touching it
	*/
	v3s16 dirs[7] = {
		v3s16(0,0,0), // this
		v3s16(0,0,1), // back
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};
	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;
		// Relative position of requested node
		v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
		if(blockref->setTempMod(relpos, mod))
		{
			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;
}

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
		v3s16(0,1,0), // top
		v3s16(1,0,0), // right
		v3s16(0,0,-1), // front
		v3s16(0,-1,0), // bottom
		v3s16(-1,0,0), // left
	};
	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;
		// Relative position of requested node
		v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
		if(blockref->clearTempMod(relpos))
		{
			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);
	}
}
#endif

void ClientMap::PrintInfo(std::ostream &out)
{
	out<<"ClientMap: ";
}

#endif // !SERVER

/*
	MapVoxelManipulator
*/

MapVoxelManipulator::MapVoxelManipulator(Map *map)
{
	m_map = map;
}

MapVoxelManipulator::~MapVoxelManipulator()
{
	/*dstream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
			<<std::endl;*/
}

void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
{
	TimeTaker timer1("emerge", &emerge_time);

	// Units of these are MapBlocks
	v3s16 p_min = getNodeBlockPos(a.MinEdge);
	v3s16 p_max = getNodeBlockPos(a.MaxEdge);

	VoxelArea block_area_nodes
			(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));

	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);

			/*dstream<<"Loading block (caller_id="<<caller_id<<")"
					<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
					<<" wanted area: ";
			a.print(dstream);
			dstream<<std::endl;*/
			
			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)
		{
			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);
	}

	//dstream<<"emerge done"<<std::endl;
}

/*
	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.
*/
void MapVoxelManipulator::blitBack
		(core::map<v3s16, MapBlock*> & modified_blocks)
{
	if(m_area.getExtent() == v3s16(0,0,0))
		return;
	
	//TimeTaker timer1("blitBack");

	/*dstream<<"blitBack(): m_loaded_blocks.size()="
			<<m_loaded_blocks.size()<<std::endl;*/
	
	/*
		Initialize block cache
	*/
	v3s16 blockpos_last;
	MapBlock *block = NULL;
	bool block_checked_in_modified = false;

	for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
	for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
	for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
	{
		v3s16 p(x,y,z);

		u8 f = m_flags[m_area.index(p)];
		if(f & (VOXELFLAG_NOT_LOADED|VOXELFLAG_INEXISTENT))
			continue;

		MapNode &n = m_data[m_area.index(p)];
			
		v3s16 blockpos = getNodeBlockPos(p);
		
		try
		{
			// Get block
			if(block == NULL || blockpos != blockpos_last){
				block = m_map->getBlockNoCreate(blockpos);
				blockpos_last = blockpos;
				block_checked_in_modified = false;
			}
			
			// Calculate relative position in block
			v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;

			// Don't continue if nothing has changed here
			if(block->getNode(relpos) == n)
				continue;

			//m_map->setNode(m_area.MinEdge + p, n);
			block->setNode(relpos, n);
			
			/*
				Make sure block is in modified_blocks
			*/
			if(block_checked_in_modified == false)
			{
				modified_blocks[blockpos] = block;
				block_checked_in_modified = true;
			}
		}
		catch(InvalidPositionException &e)
		{
		}
	}
}

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