X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=ba4130ca29e860a9b6196cc66a1be5ecdb990988;hb=9b907dd65a2c045d10605894fdaea504200e2be7;hp=4204c2a02ee88b055e018284188c5b6e96c7bb85;hpb=570a8dbf22e8e33fed22292941edfaa38d41c289;p=minetest.git

diff --git a/src/map.cpp b/src/map.cpp
index 4204c2a02..ba4130ca2 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -28,13 +28,31 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "porting.h"
 #include "mapgen.h"
 #include "nodemetadata.h"
+#include "content_mapnode.h"
+#ifndef SERVER
+#include <IMaterialRenderer.h>
+#endif
+#include "settings.h"
+#include "log.h"
+#include "profiler.h"
+
+#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
 
-extern "C" {
-	#include "sqlite3.h"
-}
 /*
 	SQLite format specification:
 	- Initially only replaces sectors/ and sectors2/
+	
+	If map.sqlite does not exist in the save dir
+	or the block was not found in the database
+	the map will try to load from sectors folder.
+	In either case, map.sqlite will be created
+	and all future saves will save there.
+	
+	Structure of map.sqlite:
+	Tables:
+		blocks
+			(PK) INT pos
+			BLOB data
 */
 
 /*
@@ -332,7 +350,7 @@ void Map::unspreadLight(enum LightBank bank,
 						*/
 						/*if(light_sources.find(n2pos))
 						{
-							std::cout<<"Removed from light_sources"<<std::endl;
+							infostream<<"Removed from light_sources"<<std::endl;
 							light_sources.remove(n2pos);
 						}*/
 					}
@@ -363,7 +381,7 @@ void Map::unspreadLight(enum LightBank bank,
 		}
 	}
 
-	/*dstream<<"unspreadLight(): Changed block "
+	/*infostream<<"unspreadLight(): Changed block "
 			<<blockchangecount<<" times"
 			<<" for "<<from_nodes.size()<<" nodes"
 			<<std::endl;*/
@@ -425,7 +443,7 @@ void Map::spreadLight(enum LightBank bank,
 	{
 		v3s16 pos = j.getNode()->getKey();
 		//v3s16 pos = *j;
-		//dstream<<"pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
+		//infostream<<"pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
 		v3s16 blockpos = getNodeBlockPos(pos);
 
 		// Only fetch a new block if the block position has changed
@@ -530,7 +548,7 @@ void Map::spreadLight(enum LightBank bank,
 		}
 	}
 
-	/*dstream<<"spreadLight(): Changed block "
+	/*infostream<<"spreadLight(): Changed block "
 			<<blockchangecount<<" times"
 			<<" for "<<from_nodes.size()<<" nodes"
 			<<std::endl;*/
@@ -714,7 +732,7 @@ void Map::updateLighting(enum LightBank bank,
 						dummy block.
 					*/
 					//assert(0);
-					dstream<<"updateLighting(): InvalidPositionException"
+					infostream<<"updateLighting(): InvalidPositionException"
 							<<std::endl;
 				}
 			}
@@ -738,7 +756,7 @@ void Map::updateLighting(enum LightBank bank,
 				assert(0);
 			}
 
-			/*dstream<<"Bottom for sunlight-propagated block ("
+			/*infostream<<"Bottom for sunlight-propagated block ("
 					<<pos.X<<","<<pos.Y<<","<<pos.Z<<") not valid"
 					<<std::endl;*/
 
@@ -761,7 +779,7 @@ void Map::updateLighting(enum LightBank bank,
 		generation for testing or whatever
 	*/
 #if 0
-	//if(g_settings.get(""))
+	//if(g_settings->get(""))
 	{
 		core::map<v3s16, MapBlock*>::Iterator i;
 		i = blocks_to_update.getIterator();
@@ -785,7 +803,7 @@ void Map::updateLighting(enum LightBank bank,
 	{
 		u32 diff = modified_blocks.size() - count_was;
 		count_was = modified_blocks.size();
-		dstream<<"unspreadLight modified "<<diff<<std::endl;
+		infostream<<"unspreadLight modified "<<diff<<std::endl;
 	}
 
 	{
@@ -797,7 +815,7 @@ void Map::updateLighting(enum LightBank bank,
 	{
 		u32 diff = modified_blocks.size() - count_was;
 		count_was = modified_blocks.size();
-		dstream<<"spreadLight modified "<<diff<<std::endl;
+		infostream<<"spreadLight modified "<<diff<<std::endl;
 	}
 #endif
 
@@ -853,7 +871,7 @@ void Map::updateLighting(enum LightBank bank,
 			//TimeTaker timer("blitBack");
 			vmanip.blitBack(modified_blocks);
 		}
-		/*dstream<<"emerge_time="<<emerge_time<<std::endl;
+		/*infostream<<"emerge_time="<<emerge_time<<std::endl;
 		emerge_time = 0;*/
 	}
 
@@ -881,7 +899,7 @@ void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
 /*
 */
 void Map::addNodeAndUpdate(v3s16 p, MapNode n,
-		core::map<v3s16, MapBlock*> &modified_blocks)
+		core::map<v3s16, MapBlock*> &modified_blocks, std::string &player_name)
 {
 	/*PrintInfo(m_dout);
 	m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
@@ -1005,6 +1023,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 	if(meta_proto)
 	{
 		NodeMetadata *meta = meta_proto->clone();
+		meta->setOwner(player_name);
 		setNodeMetadata(p, meta);
 	}
 
@@ -1281,7 +1300,8 @@ bool Map::addNodeWithEvent(v3s16 p, MapNode n)
 	bool succeeded = true;
 	try{
 		core::map<v3s16, MapBlock*> modified_blocks;
-		addNodeAndUpdate(p, n, modified_blocks);
+		std::string st = std::string("");
+		addNodeAndUpdate(p, n, modified_blocks, st);
 
 		// Copy modified_blocks to event
 		for(core::map<v3s16, MapBlock*>::Iterator
@@ -1399,6 +1419,7 @@ void Map::timerUpdate(float dtime, float unload_timeout,
 
 	core::map<v2s16, MapSector*>::Iterator si;
 
+	beginSave();
 	si = m_sectors.getIterator();
 	for(; si.atEnd() == false; si++)
 	{
@@ -1408,6 +1429,7 @@ void Map::timerUpdate(float dtime, float unload_timeout,
 
 		core::list<MapBlock*> blocks;
 		sector->getBlocks(blocks);
+		
 		for(core::list<MapBlock*>::Iterator i = blocks.begin();
 				i != blocks.end(); i++)
 		{
@@ -1446,18 +1468,19 @@ void Map::timerUpdate(float dtime, float unload_timeout,
 			sector_deletion_queue.push_back(si.getNode()->getKey());
 		}
 	}
+	endSave();
 	
 	// Finally delete the empty sectors
 	deleteSectors(sector_deletion_queue);
 	
 	if(deleted_blocks_count != 0)
 	{
-		PrintInfo(dstream); // ServerMap/ClientMap:
-		dstream<<"Unloaded "<<deleted_blocks_count
+		PrintInfo(infostream); // ServerMap/ClientMap:
+		infostream<<"Unloaded "<<deleted_blocks_count
 				<<" blocks from memory";
 		if(save_before_unloading)
-			dstream<<", of which "<<saved_blocks_count<<" were written";
-		dstream<<"."<<std::endl;
+			infostream<<", of which "<<saved_blocks_count<<" were written";
+		infostream<<"."<<std::endl;
 	}
 }
 
@@ -1524,7 +1547,7 @@ void Map::unloadUnusedData(float timeout,
 
 	deleteSectors(sector_deletion_queue);
 
-	dstream<<"Map: Unloaded "<<deleted_blocks_count<<" blocks from memory"
+	infostream<<"Map: Unloaded "<<deleted_blocks_count<<" blocks from memory"
 			<<", of which "<<saved_blocks_count<<" were wr."
 			<<std::endl;
 
@@ -1560,7 +1583,7 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 	u32 initial_size = m_transforming_liquid.size();
 
 	/*if(initial_size != 0)
-		dstream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
+		infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
 
 	// list of nodes that due to viscosity have not reached their max level height
 	UniqueQueue<v3s16> must_reflow;
@@ -1788,7 +1811,7 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 				break;
 		}
 	}
-	//dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
+	//infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
 	while (must_reflow.size() > 0)
 		m_transforming_liquid.push_back(must_reflow.pop_front());
 	updateLighting(lighting_modified_blocks, modified_blocks);
@@ -1799,9 +1822,14 @@ NodeMetadata* Map::getNodeMetadata(v3s16 p)
 	v3s16 blockpos = getNodeBlockPos(p);
 	v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
 	MapBlock *block = getBlockNoCreateNoEx(blockpos);
-	if(block == NULL)
+	if(!block){
+		infostream<<"Map::getNodeMetadata(): Need to emerge "
+				<<PP(blockpos)<<std::endl;
+		block = emergeBlock(blockpos, false);
+	}
+	if(!block)
 	{
-		dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+		infostream<<"WARNING: Map::getNodeMetadata(): Block not found"
 				<<std::endl;
 		return NULL;
 	}
@@ -1814,9 +1842,14 @@ 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)
+	if(!block){
+		infostream<<"Map::setNodeMetadata(): Need to emerge "
+				<<PP(blockpos)<<std::endl;
+		block = emergeBlock(blockpos, false);
+	}
+	if(!block)
 	{
-		dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+		infostream<<"WARNING: Map::setNodeMetadata(): Block not found"
 				<<std::endl;
 		return;
 	}
@@ -1830,7 +1863,7 @@ void Map::removeNodeMetadata(v3s16 p)
 	MapBlock *block = getBlockNoCreateNoEx(blockpos);
 	if(block == NULL)
 	{
-		dstream<<"WARNING: Map::removeNodeMetadata(): Block not found"
+		infostream<<"WARNING: Map::removeNodeMetadata(): Block not found"
 				<<std::endl;
 		return;
 	}
@@ -1873,13 +1906,16 @@ void Map::nodeMetadataStep(float dtime,
 ServerMap::ServerMap(std::string savedir):
 	Map(dout_server),
 	m_seed(0),
-	m_map_metadata_changed(true)
+	m_map_metadata_changed(true),
+	m_database(NULL),
+	m_database_read(NULL),
+	m_database_write(NULL)
 {
-	dstream<<__FUNCTION_NAME<<std::endl;
+	infostream<<__FUNCTION_NAME<<std::endl;
 
 	//m_chunksize = 8; // Takes a few seconds
 
-	if (g_settings.get("fixed_map_seed").empty())
+	if (g_settings->get("fixed_map_seed").empty())
 	{
 		m_seed = (((u64)(myrand()%0xffff)<<0)
 				+ ((u64)(myrand()%0xffff)<<16)
@@ -1888,7 +1924,7 @@ ServerMap::ServerMap(std::string savedir):
 	}
 	else
 	{
-		m_seed = g_settings.getU64("fixed_map_seed");
+		m_seed = g_settings->getU64("fixed_map_seed");
 	}
 
 	/*
@@ -1913,7 +1949,7 @@ ServerMap::ServerMap(std::string 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."
+				infostream<<"Server: Empty save directory is valid."
 						<<std::endl;
 				m_map_saving_enabled = true;
 			}
@@ -1924,7 +1960,7 @@ ServerMap::ServerMap(std::string savedir):
 					loadMapMeta();
 				}
 				catch(FileNotGoodException &e){
-					dstream<<DTIME<<"WARNING: Could not load map metadata"
+					infostream<<"WARNING: Could not load map metadata"
 							//<<" Disabling chunk-based generator."
 							<<std::endl;
 					//m_chunksize = 0;
@@ -1935,18 +1971,18 @@ ServerMap::ServerMap(std::string savedir):
 					loadChunkMeta();
 				}
 				catch(FileNotGoodException &e){
-					dstream<<DTIME<<"WARNING: Could not load chunk metadata."
+					infostream<<"WARNING: Could not load chunk metadata."
 							<<" Disabling chunk-based generator."
 							<<std::endl;
 					m_chunksize = 0;
 				}*/
 
-				/*dstream<<DTIME<<"Server: Successfully loaded chunk "
+				/*infostream<<"Server: Successfully loaded chunk "
 						"metadata and sector (0,0) from "<<savedir<<
 						", assuming valid save directory."
 						<<std::endl;*/
 
-				dstream<<DTIME<<"INFO: Server: Successfully loaded map "
+				infostream<<"Server: Successfully loaded map "
 						<<"and chunk metadata from "<<savedir
 						<<", assuming valid save directory."
 						<<std::endl;
@@ -1963,13 +1999,13 @@ ServerMap::ServerMap(std::string savedir):
 	}
 	catch(std::exception &e)
 	{
-		dstream<<DTIME<<"WARNING: Server: Failed to load map from "<<savedir
+		infostream<<"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;
+		infostream<<"Please remove the map or fix it."<<std::endl;
+		infostream<<"WARNING: Map saving will be disabled."<<std::endl;
 	}
 
-	dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;
+	infostream<<"Initializing new map."<<std::endl;
 
 	// Create zero sector
 	emergeSector(v2s16(0,0));
@@ -1980,7 +2016,7 @@ ServerMap::ServerMap(std::string savedir):
 
 ServerMap::~ServerMap()
 {
-	dstream<<__FUNCTION_NAME<<std::endl;
+	infostream<<__FUNCTION_NAME<<std::endl;
 
 	try
 	{
@@ -1988,19 +2024,29 @@ ServerMap::~ServerMap()
 		{
 			// Save only changed parts
 			save(true);
-			dstream<<DTIME<<"Server: saved map to "<<m_savedir<<std::endl;
+			infostream<<"Server: saved map to "<<m_savedir<<std::endl;
 		}
 		else
 		{
-			dstream<<DTIME<<"Server: map not saved"<<std::endl;
+			infostream<<"Server: map not saved"<<std::endl;
 		}
 	}
 	catch(std::exception &e)
 	{
-		dstream<<DTIME<<"Server: Failed to save map to "<<m_savedir
+		infostream<<"Server: Failed to save map to "<<m_savedir
 				<<", exception: "<<e.what()<<std::endl;
 	}
 
+	/*
+		Close database if it was opened
+	*/
+	if(m_database_read)
+		sqlite3_finalize(m_database_read);
+	if(m_database_write)
+		sqlite3_finalize(m_database_write);
+	if(m_database)
+		sqlite3_close(m_database);
+
 #if 0
 	/*
 		Free all MapChunks
@@ -2016,9 +2062,9 @@ ServerMap::~ServerMap()
 
 void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos)
 {
-	bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
+	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 	if(enable_mapgen_debug_info)
-		dstream<<"initBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
+		infostream<<"initBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
 				<<blockpos.Z<<")"<<std::endl;
 	
 	// Do nothing if not inside limits (+-1 because of neighbors)
@@ -2102,19 +2148,19 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
 		core::map<v3s16, MapBlock*> &changed_blocks)
 {
 	v3s16 blockpos = data->blockpos;
-	/*dstream<<"finishBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
+	/*infostream<<"finishBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
 			<<blockpos.Z<<")"<<std::endl;*/
 
 	if(data->no_op)
 	{
-		//dstream<<"finishBlockMake(): no-op"<<std::endl;
+		//infostream<<"finishBlockMake(): no-op"<<std::endl;
 		return NULL;
 	}
 
-	bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
+	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 
-	/*dstream<<"Resulting vmanip:"<<std::endl;
-	data->vmanip.print(dstream);*/
+	/*infostream<<"Resulting vmanip:"<<std::endl;
+	data->vmanip.print(infostream);*/
 	
 	/*
 		Blit generated stuff to map
@@ -2127,7 +2173,7 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
 	}
 
 	if(enable_mapgen_debug_info)
-		dstream<<"finishBlockMake: changed_blocks.size()="
+		infostream<<"finishBlockMake: changed_blocks.size()="
 				<<changed_blocks.size()<<std::endl;
 
 	/*
@@ -2268,7 +2314,7 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
 	*/
 	//save(true);
 
-	/*dstream<<"finishBlockMake() done for ("<<blockpos.X<<","<<blockpos.Y<<","
+	/*infostream<<"finishBlockMake() done for ("<<blockpos.X<<","<<blockpos.Y<<","
 			<<blockpos.Z<<")"<<std::endl;*/
 #if 0
 	if(enable_mapgen_debug_info)
@@ -2284,7 +2330,7 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
 			MapBlock *block = getBlockNoCreateNoEx(p);
 			char spos[20];
 			snprintf(spos, 20, "(%2d,%2d,%2d)", x, y, z);
-			dstream<<"Generated "<<spos<<": "
+			infostream<<"Generated "<<spos<<": "
 					<<analyze_block(block)<<std::endl;
 		}
 	}
@@ -2314,17 +2360,18 @@ ServerMapSector * ServerMap::createSector(v2s16 p2d)
 	/*
 		Try to load metadata from disk
 	*/
+#if 0
 	if(loadSectorMeta(p2d) == true)
 	{
 		ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
 		if(sector == NULL)
 		{
-			dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<<std::endl;
+			infostream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<<std::endl;
 			throw InvalidPositionException("");
 		}
 		return sector;
 	}
-
+#endif
 	/*
 		Do not create over-limit
 	*/
@@ -2361,11 +2408,11 @@ MapBlock * ServerMap::generateBlock(
 {
 	DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
 	
-	/*dstream<<"generateBlock(): "
+	/*infostream<<"generateBlock(): "
 			<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 			<<std::endl;*/
 	
-	bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
+	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 
 	TimeTaker timer("generateBlock");
 	
@@ -2379,7 +2426,7 @@ MapBlock * ServerMap::generateBlock(
 	*/
 	if(blockpos_over_limit(p))
 	{
-		dstream<<__FUNCTION_NAME<<": Block position over limit"<<std::endl;
+		infostream<<__FUNCTION_NAME<<": Block position over limit"<<std::endl;
 		throw InvalidPositionException("generateBlock(): pos. over limit");
 	}
 
@@ -2425,7 +2472,7 @@ MapBlock * ServerMap::generateBlock(
 			MapNode n = block->getNode(p);
 			if(n.getContent() == CONTENT_IGNORE)
 			{
-				dstream<<"CONTENT_IGNORE at "
+				infostream<<"CONTENT_IGNORE at "
 						<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 						<<std::endl;
 				erroneus_content = true;
@@ -2499,7 +2546,7 @@ MapBlock * ServerMap::createBlock(v3s16 p)
 	}
 	catch(InvalidPositionException &e)
 	{
-		dstream<<"createBlock: createSector() failed"<<std::endl;
+		infostream<<"createBlock: createSector() failed"<<std::endl;
 		throw e;
 	}
 	/*
@@ -2509,7 +2556,7 @@ MapBlock * ServerMap::createBlock(v3s16 p)
 	*/
 	/*catch(std::exception &e)
 	{
-		dstream<<"createBlock: createSector() failed: "
+		infostream<<"createBlock: createSector() failed: "
 				<<e.what()<<std::endl;
 		throw e;
 	}*/
@@ -2576,152 +2623,6 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool allow_generate)
 	return NULL;
 }
 
-#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
@@ -2766,6 +2667,81 @@ s16 ServerMap::findGroundLevel(v2s16 p2d)
 	//return (s16)level;
 }
 
+void ServerMap::createDatabase() {
+	int e;
+	assert(m_database);
+	e = sqlite3_exec(m_database,
+		"CREATE TABLE IF NOT EXISTS `blocks` ("
+			"`pos` INT NOT NULL PRIMARY KEY,"
+			"`data` BLOB"
+		");"
+	, NULL, NULL, NULL);
+	if(e == SQLITE_ABORT)
+		throw FileNotGoodException("Could not create database structure");
+	else
+		infostream<<"Server: Database structure was created";
+}
+
+void ServerMap::verifyDatabase() {
+	if(m_database)
+		return;
+	
+	{
+		std::string dbp = m_savedir + DIR_DELIM + "map.sqlite";
+		bool needs_create = false;
+		int d;
+		
+		/*
+			Open the database connection
+		*/
+	
+		createDirs(m_savedir);
+	
+		if(!fs::PathExists(dbp))
+			needs_create = true;
+	
+		d = sqlite3_open_v2(dbp.c_str(), &m_database, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
+		if(d != SQLITE_OK) {
+			infostream<<"WARNING: Database failed to open: "<<sqlite3_errmsg(m_database)<<std::endl;
+			throw FileNotGoodException("Cannot open database file");
+		}
+		
+		if(needs_create)
+			createDatabase();
+	
+		d = sqlite3_prepare(m_database, "SELECT `data` FROM `blocks` WHERE `pos`=? LIMIT 1", -1, &m_database_read, NULL);
+		if(d != SQLITE_OK) {
+			infostream<<"WARNING: Database read statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
+			throw FileNotGoodException("Cannot prepare read statement");
+		}
+		
+		d = sqlite3_prepare(m_database, "REPLACE INTO `blocks` VALUES(?, ?)", -1, &m_database_write, NULL);
+		if(d != SQLITE_OK) {
+			infostream<<"WARNING: Database write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
+			throw FileNotGoodException("Cannot prepare write statement");
+		}
+		
+		d = sqlite3_prepare(m_database, "SELECT `pos` FROM `blocks`", -1, &m_database_list, NULL);
+		if(d != SQLITE_OK) {
+			infostream<<"WARNING: Database list statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
+			throw FileNotGoodException("Cannot prepare read statement");
+		}
+		
+		infostream<<"Server: Database opened"<<std::endl;
+	}
+}
+
+bool ServerMap::loadFromFolders() {
+	if(!m_database && !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite"))
+		return true;
+	return false;
+}
+
+sqlite3_int64 ServerMap::getBlockAsInteger(const v3s16 pos) {
+	return (sqlite3_int64)pos.Z*16777216 +
+		(sqlite3_int64)pos.Y*4096 + (sqlite3_int64)pos.X;
+}
+
 void ServerMap::createDirs(std::string path)
 {
 	if(fs::CreateAllDirs(path) == false)
@@ -2786,13 +2762,13 @@ std::string ServerMap::getSectorDir(v2s16 pos, int layout)
 				(unsigned int)pos.X&0xffff,
 				(unsigned int)pos.Y&0xffff);
 
-			return m_savedir + "/sectors/" + cc;
+			return m_savedir + DIR_DELIM + "sectors" + DIR_DELIM + cc;
 		case 2:
-			snprintf(cc, 9, "%.3x/%.3x",
+			snprintf(cc, 9, "%.3x" DIR_DELIM "%.3x",
 				(unsigned int)pos.X&0xfff,
 				(unsigned int)pos.Y&0xfff);
 
-			return m_savedir + "/sectors2/" + cc;
+			return m_savedir + DIR_DELIM + "sectors2" + DIR_DELIM + cc;
 		default:
 			assert(false);
 	}
@@ -2802,7 +2778,7 @@ v2s16 ServerMap::getSectorPos(std::string dirname)
 {
 	unsigned int x, y;
 	int r;
-	size_t spos = dirname.rfind('/') + 1;
+	size_t spos = dirname.rfind(DIR_DELIM_C) + 1;
 	assert(spos != std::string::npos);
 	if(dirname.size() - spos == 8)
 	{
@@ -2812,7 +2788,7 @@ v2s16 ServerMap::getSectorPos(std::string dirname)
 	else if(dirname.size() - spos == 3)
 	{
 		// New layout
-		r = sscanf(dirname.substr(spos-4).c_str(), "%3x/%3x", &x, &y);
+		r = sscanf(dirname.substr(spos-4).c_str(), "%3x" DIR_DELIM "%3x", &x, &y);
 		// Sign-extend the 12 bit values up to 16 bits...
 		if(x&0x800) x|=0xF000;
 		if(y&0x800) y|=0xF000;
@@ -2852,12 +2828,12 @@ 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;
+		infostream<<"WARNING: Not saving map, saving disabled."<<std::endl;
 		return;
 	}
 	
 	if(only_changed == false)
-		dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
+		infostream<<"ServerMap: Saving whole map, this can take time."
 				<<std::endl;
 	
 	if(only_changed == false || m_map_metadata_changed)
@@ -2869,6 +2845,7 @@ void ServerMap::save(bool only_changed)
 	u32 block_count = 0;
 	u32 block_count_all = 0; // Number of blocks in memory
 	
+	beginSave();
 	core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
 	for(; i.atEnd() == false; i++)
 	{
@@ -2883,6 +2860,8 @@ void ServerMap::save(bool only_changed)
 		core::list<MapBlock*> blocks;
 		sector->getBlocks(blocks);
 		core::list<MapBlock*>::Iterator j;
+		
+		//sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL);
 		for(j=blocks.begin(); j!=blocks.end(); j++)
 		{
 			MapBlock *block = *j;
@@ -2895,14 +2874,16 @@ void ServerMap::save(bool only_changed)
 				saveBlock(block);
 				block_count++;
 
-				/*dstream<<"ServerMap: Written block ("
+				/*infostream<<"ServerMap: Written block ("
 						<<block->getPos().X<<","
 						<<block->getPos().Y<<","
 						<<block->getPos().Z<<")"
 						<<std::endl;*/
 			}
+		//sqlite3_exec(m_database, "COMMIT;", NULL, NULL, NULL);
 		}
 	}
+	endSave();
 
 	/*
 		Only print if something happened or saved whole map
@@ -2910,7 +2891,7 @@ void ServerMap::save(bool only_changed)
 	if(only_changed == false || sector_meta_count != 0
 			|| block_count != 0)
 	{
-		dstream<<DTIME<<"ServerMap: Written: "
+		infostream<<"ServerMap: Written: "
 				<<sector_meta_count<<" sector metadata files, "
 				<<block_count<<" block files"
 				<<", "<<block_count_all<<" blocks in memory."
@@ -2918,21 +2899,67 @@ void ServerMap::save(bool only_changed)
 	}
 }
 
+static s32 unsignedToSigned(s32 i, s32 max_positive)
+{
+	if(i < max_positive)
+		return i;
+	else
+		return i - 2*max_positive;
+}
+
+// modulo of a negative number does not work consistently in C
+static sqlite3_int64 pythonmodulo(sqlite3_int64 i, sqlite3_int64 mod)
+{
+	if(i >= 0)
+		return i % mod;
+	return mod - ((-i) % mod);
+}
+
+v3s16 ServerMap::getIntegerAsBlock(sqlite3_int64 i)
+{
+	s32 x = unsignedToSigned(pythonmodulo(i, 4096), 2048);
+	i = (i - x) / 4096;
+	s32 y = unsignedToSigned(pythonmodulo(i, 4096), 2048);
+	i = (i - y) / 4096;
+	s32 z = unsignedToSigned(pythonmodulo(i, 4096), 2048);
+	return v3s16(x,y,z);
+}
+
+void ServerMap::listAllLoadableBlocks(core::list<v3s16> &dst)
+{
+	if(loadFromFolders()){
+		errorstream<<"Map::listAllLoadableBlocks(): Result will be missing "
+				<<"all blocks that are stored in flat files"<<std::endl;
+	}
+	
+	{
+		verifyDatabase();
+		
+		while(sqlite3_step(m_database_list) == SQLITE_ROW)
+		{
+			sqlite3_int64 block_i = sqlite3_column_int64(m_database_list, 0);
+			v3s16 p = getIntegerAsBlock(block_i);
+			//dstream<<"block_i="<<block_i<<" p="<<PP(p)<<std::endl;
+			dst.push_back(p);
+		}
+	}
+}
+
 void ServerMap::saveMapMeta()
 {
 	DSTACK(__FUNCTION_NAME);
 	
-	dstream<<"INFO: ServerMap::saveMapMeta(): "
+	infostream<<"ServerMap::saveMapMeta(): "
 			<<"seed="<<m_seed
 			<<std::endl;
 
 	createDirs(m_savedir);
 	
-	std::string fullpath = m_savedir + "/map_meta.txt";
+	std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
 	std::ofstream os(fullpath.c_str(), std::ios_base::binary);
 	if(os.good() == false)
 	{
-		dstream<<"ERROR: ServerMap::saveMapMeta(): "
+		infostream<<"ERROR: ServerMap::saveMapMeta(): "
 				<<"could not open"<<fullpath<<std::endl;
 		throw FileNotGoodException("Cannot open chunk metadata");
 	}
@@ -2951,14 +2978,14 @@ void ServerMap::loadMapMeta()
 {
 	DSTACK(__FUNCTION_NAME);
 	
-	dstream<<"INFO: ServerMap::loadMapMeta(): Loading map metadata"
+	infostream<<"ServerMap::loadMapMeta(): Loading map metadata"
 			<<std::endl;
 
-	std::string fullpath = m_savedir + "/map_meta.txt";
+	std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
 	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
 	if(is.good() == false)
 	{
-		dstream<<"ERROR: ServerMap::loadMapMeta(): "
+		infostream<<"ERROR: ServerMap::loadMapMeta(): "
 				<<"could not open"<<fullpath<<std::endl;
 		throw FileNotGoodException("Cannot open map metadata");
 	}
@@ -2980,9 +3007,7 @@ void ServerMap::loadMapMeta()
 
 	m_seed = params.getU64("seed");
 
-	dstream<<"INFO: ServerMap::loadMapMeta(): "
-			<<"seed="<<m_seed
-			<<std::endl;
+	infostream<<"ServerMap::loadMapMeta(): "<<"seed="<<m_seed<<std::endl;
 }
 
 void ServerMap::saveSectorMeta(ServerMapSector *sector)
@@ -2995,7 +3020,7 @@ void ServerMap::saveSectorMeta(ServerMapSector *sector)
 	std::string dir = getSectorDir(pos);
 	createDirs(dir);
 	
-	std::string fullpath = dir + "/meta";
+	std::string fullpath = dir + DIR_DELIM + "meta";
 	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
 	if(o.good() == false)
 		throw FileNotGoodException("Cannot open sector metafile");
@@ -3013,7 +3038,7 @@ MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load
 
 	ServerMapSector *sector = NULL;
 
-	std::string fullpath = sectordir + "/meta";
+	std::string fullpath = sectordir + DIR_DELIM + "meta";
 	std::ifstream is(fullpath.c_str(), std::ios_base::binary);
 	if(is.good() == false)
 	{
@@ -3021,7 +3046,7 @@ MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load
 		// format. Just go ahead and create the sector.
 		if(fs::PathExists(sectordir))
 		{
-			/*dstream<<"ServerMap::loadSectorMeta(): Sector metafile "
+			/*infostream<<"ServerMap::loadSectorMeta(): Sector metafile "
 					<<fullpath<<" doesn't exist but directory does."
 					<<" Continuing with a sector with no metadata."
 					<<std::endl;*/
@@ -3152,7 +3177,7 @@ bool ServerMap::loadSectorFull(v2s16 p2d)
 
 	if(loadlayout != 2)
 	{
-		dstream<<"Sector converted to new layout - deleting "<<
+		infostream<<"Sector converted to new layout - deleting "<<
 			sectordir1<<std::endl;
 		fs::RecursiveDelete(sectordir1);
 	}
@@ -3161,6 +3186,18 @@ bool ServerMap::loadSectorFull(v2s16 p2d)
 }
 #endif
 
+void ServerMap::beginSave() {
+	verifyDatabase();
+	if(sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL) != SQLITE_OK)
+		infostream<<"WARNING: beginSave() failed, saving might be slow.";
+}
+
+void ServerMap::endSave() {
+	verifyDatabase();
+	if(sqlite3_exec(m_database, "COMMIT;", NULL, NULL, NULL) != SQLITE_OK)
+		infostream<<"WARNING: endSave() failed, map might not have saved.";
+}
+
 void ServerMap::saveBlock(MapBlock *block)
 {
 	DSTACK(__FUNCTION_NAME);
@@ -3170,7 +3207,7 @@ void ServerMap::saveBlock(MapBlock *block)
 	if(block->isDummy())
 	{
 		/*v3s16 p = block->getPos();
-		dstream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block "
+		infostream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block "
 				<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
 		return;
 	}
@@ -3180,20 +3217,27 @@ void ServerMap::saveBlock(MapBlock *block)
 	// Get destination
 	v3s16 p3d = block->getPos();
 	
+	
+#if 0
 	v2s16 p2d(p3d.X, p3d.Z);
 	std::string sectordir = getSectorDir(p2d);
 
 	createDirs(sectordir);
 
-	std::string fullpath = sectordir+"/"+getBlockFilename(p3d);
+	std::string fullpath = sectordir+DIR_DELIM+getBlockFilename(p3d);
 	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
 	if(o.good() == false)
 		throw FileNotGoodException("Cannot open block data");
-
+#endif
 	/*
 		[0] u8 serialization version
 		[1] data
 	*/
+	
+	verifyDatabase();
+	
+	std::ostringstream o(std::ios_base::binary);
+	
 	o.write((char*)&version, 1);
 	
 	// Write basic data
@@ -3201,7 +3245,23 @@ void ServerMap::saveBlock(MapBlock *block)
 	
 	// Write extra data stored on disk
 	block->serializeDiskExtra(o, version);
-
+	
+	// Write block to database
+	
+	std::string tmp = o.str();
+	const char *bytes = tmp.c_str();
+	
+	if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK)
+		infostream<<"WARNING: Block position failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
+	if(sqlite3_bind_blob(m_database_write, 2, (void *)bytes, o.tellp(), NULL) != SQLITE_OK) // TODO this mught not be the right length
+		infostream<<"WARNING: Block data failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
+	int written = sqlite3_step(m_database_write);
+	if(written != SQLITE_DONE)
+		infostream<<"WARNING: Block failed to save ("<<p3d.X<<", "<<p3d.Y<<", "<<p3d.Z<<") "
+		<<sqlite3_errmsg(m_database)<<std::endl;
+	// Make ready for later reuse
+	sqlite3_reset(m_database_write);
+	
 	// We just wrote it to the disk so clear modified flag
 	block->resetModified();
 }
@@ -3210,7 +3270,7 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 {
 	DSTACK(__FUNCTION_NAME);
 
-	std::string fullpath = sectordir+"/"+blockfile;
+	std::string fullpath = sectordir+DIR_DELIM+blockfile;
 	try{
 
 		std::ifstream is(fullpath.c_str(), std::ios_base::binary);
@@ -3262,6 +3322,9 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 		if(version < SER_FMT_VER_HIGHEST || save_after_load)
 		{
 			saveBlock(block);
+			
+			// Should be in database now, so delete the old file
+			fs::RecursiveDelete(fullpath);
 		}
 		
 		// We just loaded it from the disk, so it's up-to-date.
@@ -3270,7 +3333,7 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 	}
 	catch(SerializationError &e)
 	{
-		dstream<<"WARNING: Invalid block data on disk "
+		infostream<<"WARNING: Invalid block data on disk "
 				<<"fullpath="<<fullpath
 				<<" (SerializationError). "
 				<<"what()="<<e.what()
@@ -3282,12 +3345,111 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto
 	}
 }
 
+void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load)
+{
+	DSTACK(__FUNCTION_NAME);
+
+	try {
+		std::istringstream is(*blob, std::ios_base::binary);
+		
+		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;
+		block = sector->getBlockNoCreateNoEx(p3d.Y);
+		if(block == NULL)
+		{
+			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, so it's up-to-date.
+		block->resetModified();
+
+	}
+	catch(SerializationError &e)
+	{
+		infostream<<"WARNING: Invalid block data in database "
+				<<" (SerializationError). "
+				<<"what()="<<e.what()
+				<<std::endl;
+				//" Ignoring. A new one will be generated.
+		assert(0);
+
+		// TODO: Copy to a backup database.
+	}
+}
+
 MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 {
 	DSTACK(__FUNCTION_NAME);
 
 	v2s16 p2d(blockpos.X, blockpos.Z);
 
+	if(!loadFromFolders()) {
+		verifyDatabase();
+		
+		if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK)
+			infostream<<"WARNING: Could not bind block position for load: "
+				<<sqlite3_errmsg(m_database)<<std::endl;
+		if(sqlite3_step(m_database_read) == SQLITE_ROW) {
+			/*
+				Make sure sector is loaded
+			*/
+			MapSector *sector = createSector(p2d);
+			
+			/*
+				Load block
+			*/
+			const char * data = (const char *)sqlite3_column_blob(m_database_read, 0);
+			size_t len = sqlite3_column_bytes(m_database_read, 0);
+			
+			std::string datastr(data, len);
+			
+			loadBlock(&datastr, blockpos, sector, false);
+
+			sqlite3_step(m_database_read);
+			// We should never get more than 1 row, so ok to reset
+			sqlite3_reset(m_database_read);
+
+			return getBlockNoCreateNoEx(blockpos);
+		}
+		sqlite3_reset(m_database_read);
+		
+		// Not found in database, try the files
+	}
+
 	// The directory layout we're going to load from.
 	//  1 - original sectors/xxxxzzzz/
 	//  2 - new sectors2/xxx/zzz/
@@ -3334,13 +3496,13 @@ MapBlock* ServerMap::loadBlock(v3s16 blockpos)
 	*/
 
 	std::string blockfilename = getBlockFilename(blockpos);
-	if(fs::PathExists(sectordir+"/"+blockfilename) == false)
+	if(fs::PathExists(sectordir+DIR_DELIM+blockfilename) == false)
 		return NULL;
 
 	/*
-		Load block
+		Load block and save it to the database
 	*/
-	loadBlock(sectordir, blockfilename, sector, loadlayout != 2);
+	loadBlock(sectordir, blockfilename, sector, true);
 	return getBlockNoCreateNoEx(blockpos);
 }
 
@@ -3367,7 +3529,8 @@ ClientMap::ClientMap(
 	m_client(client),
 	m_control(control),
 	m_camera_position(0,0,0),
-	m_camera_direction(0,0,1)
+	m_camera_direction(0,0,1),
+	m_camera_fov(PI)
 {
 	m_camera_mutex.Init();
 	assert(m_camera_mutex.IsInitialized());
@@ -3476,6 +3639,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 	m_camera_mutex.Lock();
 	v3f camera_position = m_camera_position;
 	v3f camera_direction = m_camera_direction;
+	f32 camera_fov = m_camera_fov;
 	m_camera_mutex.Unlock();
 
 	/*
@@ -3493,22 +3657,35 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 	v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d;
 
 	// Take a fair amount as we will be dropping more out later
+	// Umm... these additions are a bit strange but they are needed.
 	v3s16 p_blocks_min(
-			p_nodes_min.X / MAP_BLOCKSIZE - 2,
-			p_nodes_min.Y / MAP_BLOCKSIZE - 2,
-			p_nodes_min.Z / MAP_BLOCKSIZE - 2);
+			p_nodes_min.X / MAP_BLOCKSIZE - 3,
+			p_nodes_min.Y / MAP_BLOCKSIZE - 3,
+			p_nodes_min.Z / MAP_BLOCKSIZE - 3);
 	v3s16 p_blocks_max(
 			p_nodes_max.X / MAP_BLOCKSIZE + 1,
 			p_nodes_max.Y / MAP_BLOCKSIZE + 1,
 			p_nodes_max.Z / MAP_BLOCKSIZE + 1);
 	
 	u32 vertex_count = 0;
+	u32 meshbuffer_count = 0;
 	
 	// For limiting number of mesh updates per frame
 	u32 mesh_update_count = 0;
 	
+	// Number of blocks in rendering range
+	u32 blocks_in_range = 0;
+	// Number of blocks in rendering range but don't have a mesh
+	u32 blocks_in_range_without_mesh = 0;
+	// Blocks that had mesh that would have been drawn according to
+	// rendering range (if max blocks limit didn't kick in)
 	u32 blocks_would_have_drawn = 0;
+	// Blocks that were drawn and had a mesh
 	u32 blocks_drawn = 0;
+	// Blocks which had a corresponding meshbuffer for this pass
+	u32 blocks_had_pass_meshbuf = 0;
+	// Blocks from which stuff was actually drawn
+	u32 blocks_without_stuff = 0;
 
 	int timecheck_counter = 0;
 	core::map<v2s16, MapSector*>::Iterator si;
@@ -3523,7 +3700,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 				int time2 = time(0);
 				if(time2 > time1 + 4)
 				{
-					dstream<<"ClientMap::renderMap(): "
+					infostream<<"ClientMap::renderMap(): "
 						"Rendering takes ages, returning."
 						<<std::endl;
 					return;
@@ -3568,7 +3745,8 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 			
 			float d = 0.0;
 			if(isBlockInSight(block->getPos(), camera_position,
-					camera_direction, range, &d) == false)
+					camera_direction, camera_fov,
+					range, &d) == false)
 			{
 				continue;
 			}
@@ -3580,6 +3758,8 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 			/*if(m_control.range_all == false &&
 					d - 0.5*BS*MAP_BLOCKSIZE > range)
 				continue;*/
+			
+			blocks_in_range++;
 
 #if 1
 			/*
@@ -3598,8 +3778,10 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 
 				// Mesh has not been expired and there is no mesh:
 				// block has no content
-				if(block->mesh == NULL && mesh_expired == false)
+				if(block->mesh == NULL && mesh_expired == false){
+					blocks_in_range_without_mesh++;
 					continue;
+				}
 			}
 
 			f32 faraway = BS*50;
@@ -3637,9 +3819,11 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 				JMutexAutoLock lock(block->mesh_mutex);
 
 				scene::SMesh *mesh = block->mesh;
-
-				if(mesh == NULL)
+				
+				if(mesh == NULL){
+					blocks_in_range_without_mesh++;
 					continue;
+				}
 				
 				blocks_would_have_drawn++;
 				if(blocks_drawn >= m_control.wanted_max_blocks
@@ -3651,7 +3835,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 				sector_blocks_drawn++;
 
 				u32 c = mesh->getMeshBufferCount();
-
+				bool stuff_actually_drawn = false;
 				for(u32 i=0; i<c; i++)
 				{
 					scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
@@ -3662,16 +3846,25 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 					// Render transparent on transparent pass and likewise.
 					if(transparent == is_transparent_pass)
 					{
+						if(buf->getVertexCount() == 0)
+							errorstream<<"Block ["<<analyze_block(block)
+									<<"] contains an empty meshbuf"<<std::endl;
 						/*
 							This *shouldn't* hurt too much because Irrlicht
 							doesn't change opengl textures if the old
-							material is set again.
+							material has the same texture.
 						*/
 						driver->setMaterial(buf->getMaterial());
 						driver->drawMeshBuffer(buf);
 						vertex_count += buf->getVertexCount();
+						meshbuffer_count++;
+						stuff_actually_drawn = true;
 					}
 				}
+				if(stuff_actually_drawn)
+					blocks_had_pass_meshbuf++;
+				else
+					blocks_without_stuff++;
 			}
 		} // foreach sectorblocks
 
@@ -3681,13 +3874,66 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 		}
 	}
 	
+	std::string prefix = "CM: ";
+
+	// Log only on solid pass because values are the same
+	if(pass == scene::ESNRP_SOLID){
+		g_profiler->avg(prefix+"blocks in range", blocks_in_range);
+		if(blocks_in_range != 0)
+			g_profiler->avg(prefix+"blocks in range without mesh (frac)",
+					(float)blocks_in_range_without_mesh/blocks_in_range);
+		g_profiler->avg(prefix+"blocks drawn", blocks_drawn);
+	}
+	
+	if(pass == scene::ESNRP_SOLID)
+		prefix = "CM: solid: ";
+	else
+		prefix = "CM: transparent: ";
+
+	g_profiler->avg(prefix+"vertices drawn", vertex_count);
+	if(blocks_had_pass_meshbuf != 0)
+		g_profiler->avg(prefix+"meshbuffers per block",
+				(float)meshbuffer_count / (float)blocks_had_pass_meshbuf);
+	if(blocks_drawn != 0)
+		g_profiler->avg(prefix+"empty blocks (frac)",
+				(float)blocks_without_stuff / blocks_drawn);
+
 	m_control.blocks_drawn = blocks_drawn;
 	m_control.blocks_would_have_drawn = blocks_would_have_drawn;
 
-	/*dstream<<"renderMap(): is_transparent_pass="<<is_transparent_pass
+	/*infostream<<"renderMap(): is_transparent_pass="<<is_transparent_pass
 			<<", rendered "<<vertex_count<<" vertices."<<std::endl;*/
 }
 
+void ClientMap::renderPostFx()
+{
+	// Sadly ISceneManager has no "post effects" render pass, in that case we
+	// could just register for that and handle it in renderMap().
+
+	m_camera_mutex.Lock();
+	v3f camera_position = m_camera_position;
+	m_camera_mutex.Unlock();
+
+	MapNode n = getNodeNoEx(floatToInt(camera_position, BS));
+
+	// - If the player is in a solid node, make everything black.
+	// - If the player is in liquid, draw a semi-transparent overlay.
+	ContentFeatures& features = content_features(n);
+	video::SColor post_effect_color = features.post_effect_color;
+	if(features.solidness == 2 && g_settings->getBool("free_move") == false)
+	{
+		post_effect_color = video::SColor(255, 0, 0, 0);
+	}
+	if (post_effect_color.getAlpha() != 0)
+	{
+		// Draw a full-screen rectangle
+		video::IVideoDriver* driver = SceneManager->getVideoDriver();
+		v2u32 ss = driver->getScreenSize();
+		core::rect<s32> rect(0,0, ss.X, ss.Y);
+		driver->draw2DRectangle(post_effect_color, rect);
+	}
+}
+
 bool ClientMap::setTempMod(v3s16 p, NodeMod mod,
 		core::map<v3s16, MapBlock*> *affected_blocks)
 {
@@ -3905,7 +4151,7 @@ MapVoxelManipulator::MapVoxelManipulator(Map *map)
 
 MapVoxelManipulator::~MapVoxelManipulator()
 {
-	/*dstream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
+	/*infostream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
 			<<std::endl;*/
 }
 
@@ -3937,11 +4183,11 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 		{
 			TimeTaker timer1("emerge load", &emerge_load_time);
 
-			/*dstream<<"Loading block (caller_id="<<caller_id<<")"
+			/*infostream<<"Loading block (caller_id="<<caller_id<<")"
 					<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 					<<" wanted area: ";
-			a.print(dstream);
-			dstream<<std::endl;*/
+			a.print(infostream);
+			infostream<<std::endl;*/
 			
 			MapBlock *block = m_map->getBlockNoCreate(p);
 			if(block->isDummy())
@@ -3969,7 +4215,7 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 		m_loaded_blocks.insert(p, !block_data_inexistent);
 	}
 
-	//dstream<<"emerge done"<<std::endl;
+	//infostream<<"emerge done"<<std::endl;
 }
 
 /*
@@ -3985,7 +4231,7 @@ void MapVoxelManipulator::blitBack
 	
 	//TimeTaker timer1("blitBack");
 
-	/*dstream<<"blitBack(): m_loaded_blocks.size()="
+	/*infostream<<"blitBack(): m_loaded_blocks.size()="
 			<<m_loaded_blocks.size()<<std::endl;*/
 	
 	/*
@@ -4074,10 +4320,10 @@ void ManualMapVoxelManipulator::initialEmerge(
 	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;
+		infostream<<"initialEmerge: area: ";
+		block_area_nodes.print(infostream);
+		infostream<<" ("<<size_MB<<"MB)";
+		infostream<<std::endl;
 	}
 
 	addArea(block_area_nodes);
@@ -4145,7 +4391,7 @@ void ManualMapVoxelManipulator::blitBackAll(
 		if(existed == false)
 		{
 			// The Great Bug was found using this
-			/*dstream<<"ManualMapVoxelManipulator::blitBackAll: "
+			/*infostream<<"ManualMapVoxelManipulator::blitBackAll: "
 					<<"Inexistent ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 					<<std::endl;*/
 			continue;
@@ -4153,7 +4399,7 @@ void ManualMapVoxelManipulator::blitBackAll(
 		MapBlock *block = m_map->getBlockNoCreateNoEx(p);
 		if(block == NULL)
 		{
-			dstream<<"WARNING: "<<__FUNCTION_NAME
+			infostream<<"WARNING: "<<__FUNCTION_NAME
 					<<": got NULL block "
 					<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 					<<std::endl;