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

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

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

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

#include "map.h"
#include "mapsector.h"
#include "mapblock.h"
#include "filesys.h"
#include "voxel.h"
#include "voxelalgorithms.h"
#include "porting.h"
#include "serialization.h"
#include "nodemetadata.h"
#include "settings.h"
#include "log.h"
#include "profiler.h"
#include "nodedef.h"
#include "gamedef.h"
#include "util/directiontables.h"
#include "util/basic_macros.h"
#include "rollback_interface.h"
#include "environment.h"
#include "reflowscan.h"
#include "emerge.h"
#include "mapgen/mapgen_v6.h"
#include "mapgen/mg_biome.h"
#include "config.h"
#include "server.h"
#include "database/database.h"
#include "database/database-dummy.h"
#include "database/database-sqlite3.h"
#include "script/scripting_server.h"
#include <deque>
#include <queue>
#if USE_LEVELDB
#include "database/database-leveldb.h"
#endif
#if USE_REDIS
#include "database/database-redis.h"
#endif
#if USE_POSTGRESQL
#include "database/database-postgresql.h"
#endif


/*
	Map
*/

Map::Map(IGameDef *gamedef):
	m_gamedef(gamedef),
	m_nodedef(gamedef->ndef())
{
}

Map::~Map()
{
	/*
		Free all MapSectors
	*/
	for (auto &sector : m_sectors) {
		delete sector.second;
	}
}

void Map::addEventReceiver(MapEventReceiver *event_receiver)
{
	m_event_receivers.insert(event_receiver);
}

void Map::removeEventReceiver(MapEventReceiver *event_receiver)
{
	m_event_receivers.erase(event_receiver);
}

void Map::dispatchEvent(const MapEditEvent &event)
{
	for (MapEventReceiver *event_receiver : m_event_receivers) {
		event_receiver->onMapEditEvent(event);
	}
}

MapSector * Map::getSectorNoGenerateNoLock(v2s16 p)
{
	if(m_sector_cache != NULL && p == m_sector_cache_p){
		MapSector * sector = m_sector_cache;
		return sector;
	}

	std::map<v2s16, MapSector*>::iterator n = m_sectors.find(p);

	if (n == m_sectors.end())
		return NULL;

	MapSector *sector = n->second;

	// Cache the last result
	m_sector_cache_p = p;
	m_sector_cache = sector;

	return sector;
}

MapSector * Map::getSectorNoGenerate(v2s16 p)
{
	return getSectorNoGenerateNoLock(p);
}

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

MapBlock * Map::getBlockNoCreate(v3s16 p3d)
{
	MapBlock *block = getBlockNoCreateNoEx(p3d);
	if(block == NULL)
		throw InvalidPositionException();
	return block;
}

bool Map::isNodeUnderground(v3s16 p)
{
	v3s16 blockpos = getNodeBlockPos(p);
	MapBlock *block = getBlockNoCreateNoEx(blockpos);
	return block && block->getIsUnderground();
}

bool Map::isValidPosition(v3s16 p)
{
	v3s16 blockpos = getNodeBlockPos(p);
	MapBlock *block = getBlockNoCreateNoEx(blockpos);
	return (block != NULL);
}

// Returns a CONTENT_IGNORE node if not found
MapNode Map::getNode(v3s16 p, bool *is_valid_position)
{
	v3s16 blockpos = getNodeBlockPos(p);
	MapBlock *block = getBlockNoCreateNoEx(blockpos);
	if (block == NULL) {
		if (is_valid_position != NULL)
			*is_valid_position = false;
		return {CONTENT_IGNORE};
	}

	v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
	bool is_valid_p;
	MapNode node = block->getNodeNoCheck(relpos, &is_valid_p);
	if (is_valid_position != NULL)
		*is_valid_position = is_valid_p;
	return node;
}

// throws InvalidPositionException if not found
void Map::setNode(v3s16 p, MapNode & n)
{
	v3s16 blockpos = getNodeBlockPos(p);
	MapBlock *block = getBlockNoCreate(blockpos);
	v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
	// Never allow placing CONTENT_IGNORE, it causes problems
	if(n.getContent() == CONTENT_IGNORE){
		bool temp_bool;
		errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
				<<" while trying to replace \""
				<<m_nodedef->get(block->getNodeNoCheck(relpos, &temp_bool)).name
				<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
		return;
	}
	block->setNodeNoCheck(relpos, n);
}

void Map::addNodeAndUpdate(v3s16 p, MapNode n,
		std::map<v3s16, MapBlock*> &modified_blocks,
		bool remove_metadata)
{
	// Collect old node for rollback
	RollbackNode rollback_oldnode(this, p, m_gamedef);

	// This is needed for updating the lighting
	MapNode oldnode = getNode(p);

	// Remove node metadata
	if (remove_metadata) {
		removeNodeMetadata(p);
	}

	// Set the node on the map
	// Ignore light (because calling voxalgo::update_lighting_nodes)
	n.setLight(LIGHTBANK_DAY, 0, m_nodedef);
	n.setLight(LIGHTBANK_NIGHT, 0, m_nodedef);
	setNode(p, n);

	// Update lighting
	std::vector<std::pair<v3s16, MapNode> > oldnodes;
	oldnodes.emplace_back(p, oldnode);
	voxalgo::update_lighting_nodes(this, oldnodes, modified_blocks);

	for (auto &modified_block : modified_blocks) {
		modified_block.second->expireDayNightDiff();
	}

	// Report for rollback
	if(m_gamedef->rollback())
	{
		RollbackNode rollback_newnode(this, p, m_gamedef);
		RollbackAction action;
		action.setSetNode(p, rollback_oldnode, rollback_newnode);
		m_gamedef->rollback()->reportAction(action);
	}

	/*
		Add neighboring liquid nodes and this node to transform queue.
		(it's vital for the node itself to get updated last, if it was removed.)
	 */

	for (const v3s16 &dir : g_7dirs) {
		v3s16 p2 = p + dir;

		bool is_valid_position;
		MapNode n2 = getNode(p2, &is_valid_position);
		if(is_valid_position &&
				(m_nodedef->get(n2).isLiquid() ||
				n2.getContent() == CONTENT_AIR))
			m_transforming_liquid.push_back(p2);
	}
}

void Map::removeNodeAndUpdate(v3s16 p,
		std::map<v3s16, MapBlock*> &modified_blocks)
{
	addNodeAndUpdate(p, MapNode(CONTENT_AIR), modified_blocks, true);
}

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

	bool succeeded = true;
	try{
		std::map<v3s16, MapBlock*> modified_blocks;
		addNodeAndUpdate(p, n, modified_blocks, remove_metadata);

		// Copy modified_blocks to event
		for (auto &modified_block : modified_blocks) {
			event.modified_blocks.insert(modified_block.first);
		}
	}
	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{
		std::map<v3s16, MapBlock*> modified_blocks;
		removeNodeAndUpdate(p, modified_blocks);

		// Copy modified_blocks to event
		for (auto &modified_block : modified_blocks) {
			event.modified_blocks.insert(modified_block.first);
		}
	}
	catch(InvalidPositionException &e){
		succeeded = false;
	}

	dispatchEvent(event);

	return succeeded;
}

struct TimeOrderedMapBlock {
	MapSector *sect;
	MapBlock *block;

	TimeOrderedMapBlock(MapSector *sect, MapBlock *block) :
		sect(sect),
		block(block)
	{}

	bool operator<(const TimeOrderedMapBlock &b) const
	{
		return block->getUsageTimer() < b.block->getUsageTimer();
	};
};

/*
	Updates usage timers
*/
void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks,
		std::vector<v3s16> *unloaded_blocks)
{
	bool save_before_unloading = (mapType() == MAPTYPE_SERVER);

	// Profile modified reasons
	Profiler modprofiler;

	std::vector<v2s16> sector_deletion_queue;
	u32 deleted_blocks_count = 0;
	u32 saved_blocks_count = 0;
	u32 block_count_all = 0;

	beginSave();

	// If there is no practical limit, we spare creation of mapblock_queue
	if (max_loaded_blocks == U32_MAX) {
		for (auto &sector_it : m_sectors) {
			MapSector *sector = sector_it.second;

			bool all_blocks_deleted = true;

			MapBlockVect blocks;
			sector->getBlocks(blocks);

			for (MapBlock *block : blocks) {
				block->incrementUsageTimer(dtime);

				if (block->refGet() == 0
						&& block->getUsageTimer() > unload_timeout) {
					v3s16 p = block->getPos();

					// Save if modified
					if (block->getModified() != MOD_STATE_CLEAN
							&& save_before_unloading) {
						modprofiler.add(block->getModifiedReasonString(), 1);
						if (!saveBlock(block))
							continue;
						saved_blocks_count++;
					}

					// Delete from memory
					sector->deleteBlock(block);

					if (unloaded_blocks)
						unloaded_blocks->push_back(p);

					deleted_blocks_count++;
				} else {
					all_blocks_deleted = false;
					block_count_all++;
				}
			}

			if (all_blocks_deleted) {
				sector_deletion_queue.push_back(sector_it.first);
			}
		}
	} else {
		std::priority_queue<TimeOrderedMapBlock> mapblock_queue;
		for (auto &sector_it : m_sectors) {
			MapSector *sector = sector_it.second;

			MapBlockVect blocks;
			sector->getBlocks(blocks);

			for (MapBlock *block : blocks) {
				block->incrementUsageTimer(dtime);
				mapblock_queue.push(TimeOrderedMapBlock(sector, block));
			}
		}
		block_count_all = mapblock_queue.size();
		// Delete old blocks, and blocks over the limit from the memory
		while (!mapblock_queue.empty() && (mapblock_queue.size() > max_loaded_blocks
				|| mapblock_queue.top().block->getUsageTimer() > unload_timeout)) {
			TimeOrderedMapBlock b = mapblock_queue.top();
			mapblock_queue.pop();

			MapBlock *block = b.block;

			if (block->refGet() != 0)
				continue;

			v3s16 p = block->getPos();

			// Save if modified
			if (block->getModified() != MOD_STATE_CLEAN && save_before_unloading) {
				modprofiler.add(block->getModifiedReasonString(), 1);
				if (!saveBlock(block))
					continue;
				saved_blocks_count++;
			}

			// Delete from memory
			b.sect->deleteBlock(block);

			if (unloaded_blocks)
				unloaded_blocks->push_back(p);

			deleted_blocks_count++;
			block_count_all--;
		}
		// Delete empty sectors
		for (auto &sector_it : m_sectors) {
			if (sector_it.second->empty()) {
				sector_deletion_queue.push_back(sector_it.first);
			}
		}
	}
	endSave();

	// Finally delete the empty sectors
	deleteSectors(sector_deletion_queue);

	if(deleted_blocks_count != 0)
	{
		PrintInfo(infostream); // ServerMap/ClientMap:
		infostream<<"Unloaded "<<deleted_blocks_count
				<<" blocks from memory";
		if(save_before_unloading)
			infostream<<", of which "<<saved_blocks_count<<" were written";
		infostream<<", "<<block_count_all<<" blocks in memory";
		infostream<<"."<<std::endl;
		if(saved_blocks_count != 0){
			PrintInfo(infostream); // ServerMap/ClientMap:
			infostream<<"Blocks modified by: "<<std::endl;
			modprofiler.print(infostream);
		}
	}
}

void Map::unloadUnreferencedBlocks(std::vector<v3s16> *unloaded_blocks)
{
	timerUpdate(0.0, -1.0, 0, unloaded_blocks);
}

void Map::deleteSectors(std::vector<v2s16> &sectorList)
{
	for (v2s16 j : sectorList) {
		MapSector *sector = m_sectors[j];
		// 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.erase(j);
		delete sector;
	}
}

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

#define WATER_DROP_BOOST 4

const static v3s16 liquid_6dirs[6] = {
	// order: upper before same level before lower
	v3s16( 0, 1, 0),
	v3s16( 0, 0, 1),
	v3s16( 1, 0, 0),
	v3s16( 0, 0,-1),
	v3s16(-1, 0, 0),
	v3s16( 0,-1, 0)
};

enum NeighborType : u8 {
	NEIGHBOR_UPPER,
	NEIGHBOR_SAME_LEVEL,
	NEIGHBOR_LOWER
};

struct NodeNeighbor {
	MapNode n;
	NeighborType t;
	v3s16 p;

	NodeNeighbor()
		: n(CONTENT_AIR), t(NEIGHBOR_SAME_LEVEL)
	{ }

	NodeNeighbor(const MapNode &node, NeighborType n_type, const v3s16 &pos)
		: n(node),
		  t(n_type),
		  p(pos)
	{ }
};

void Map::transforming_liquid_add(v3s16 p) {
        m_transforming_liquid.push_back(p);
}

void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks,
		ServerEnvironment *env)
{
	u32 loopcount = 0;
	u32 initial_size = m_transforming_liquid.size();

	/*if(initial_size != 0)
		infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/

	// list of nodes that due to viscosity have not reached their max level height
	std::deque<v3s16> must_reflow;

	std::vector<std::pair<v3s16, MapNode> > changed_nodes;

	u32 liquid_loop_max = g_settings->getS32("liquid_loop_max");
	u32 loop_max = liquid_loop_max;

#if 0

	/* If liquid_loop_max is not keeping up with the queue size increase
	 * loop_max up to a maximum of liquid_loop_max * dedicated_server_step.
	 */
	if (m_transforming_liquid.size() > loop_max * 2) {
		// "Burst" mode
		float server_step = g_settin</span>
<span class="hl com">This program is free software; you can redistribute it and/or modify</span>
<span class="hl com">it under the terms of the GNU Lesser General Public License as published by</span>
<span class="hl com">the Free Software Foundation; either version 2.1 of the License, or</span>
<span class="hl com">(at your option) any later version.</span>
<span class="hl com"></span>
<span class="hl com">This program is distributed in the hope that it will be useful,</span>
<span class="hl com">but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="hl com">MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="hl com">GNU Lesser General Public License for more details.</span>
<span class="hl com"></span>
<span class="hl com">You should have received a copy of the GNU Lesser General Public License along</span>
<span class="hl com">with this program; if not, write to the Free Software Foundation, Inc.,</span>
<span class="hl com">51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.</span>
<span class="hl com">*/</span>

<span class="hl ppc">#pragma once</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;noise.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;nodedef.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;util/string.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;util/container.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#define MAPGEN_DEFAULT MAPGEN_V7</span>
<span class="hl ppc">#define MAPGEN_DEFAULT_NAME</span> <span class="hl pps">&quot;v7&quot;</span><span class="hl ppc"></span>

<span class="hl slc">/////////////////// Mapgen flags</span>
<span class="hl ppc">#define MG_TREES       0x01</span>  <span class="hl slc">// Obsolete. Moved into mgv6 flags</span>
<span class="hl ppc"></span><span class="hl ppc">#define MG_CAVES       0x02</span>
<span class="hl ppc">#define MG_DUNGEONS    0x04</span>
<span class="hl ppc">#define MG_FLAT        0x08</span>  <span class="hl slc">// Obsolete. Moved into mgv6 flags</span>
<span class="hl ppc"></span><span class="hl ppc">#define MG_LIGHT       0x10</span>
<span class="hl ppc">#define MG_DECORATIONS 0x20</span>
<span class="hl ppc">#define MG_BIOMES      0x40</span>
<span class="hl ppc">#define MG_ORES        0x80</span>

<span class="hl kwc">typedef</span> u16 biome_t<span class="hl opt">;</span>  <span class="hl slc">// copy from mg_biome.h to avoid an unnecessary include</span>

<span class="hl kwc">class</span> Settings<span class="hl opt">;</span>
<span class="hl kwc">class</span> MMVManip<span class="hl opt">;</span>
<span class="hl kwc">class</span> NodeDefManager<span class="hl opt">;</span>

<span class="hl kwc">extern</span> FlagDesc flagdesc_mapgen<span class="hl opt">[];</span>
<span class="hl kwc">extern</span> FlagDesc flagdesc_gennotify<span class="hl opt">[];</span>

<span class="hl kwc">class</span> Biome<span class="hl opt">;</span>
<span class="hl kwc">class</span> BiomeGen<span class="hl opt">;</span>
<span class="hl kwb">struct</span> BiomeParams<span class="hl opt">;</span>
<span class="hl kwc">class</span> BiomeManager<span class="hl opt">;</span>
<span class="hl kwc">class</span> EmergeParams<span class="hl opt">;</span>
<span class="hl kwc">class</span> EmergeManager<span class="hl opt">;</span>
<span class="hl kwc">class</span> MapBlock<span class="hl opt">;</span>
<span class="hl kwc">class</span> VoxelManipulator<span class="hl opt">;</span>
<span class="hl kwb">struct</span> BlockMakeData<span class="hl opt">;</span>
<span class="hl kwc">class</span> VoxelArea<span class="hl opt">;</span>
<span class="hl kwc">class</span> Map<span class="hl opt">;</span>

<span class="hl kwb">enum</span> MapgenObject <span class="hl opt">{</span>
	MGOBJ_VMANIP<span class="hl opt">,</span>
	MGOBJ_HEIGHTMAP<span class="hl opt">,</span>
	MGOBJ_BIOMEMAP<span class="hl opt">,</span>
	MGOBJ_HEATMAP<span class="hl opt">,</span>
	MGOBJ_HUMIDMAP<span class="hl opt">,</span>
	MGOBJ_GENNOTIFY
<span class="hl opt">};</span>

<span class="hl kwb">enum</span> GenNotifyType <span class="hl opt">{</span>
	GENNOTIFY_DUNGEON<span class="hl opt">,</span>
	GENNOTIFY_TEMPLE<span class="hl opt">,</span>
	GENNOTIFY_CAVE_BEGIN<span class="hl opt">,</span>
	GENNOTIFY_CAVE_END<span class="hl opt">,</span>
	GENNOTIFY_LARGECAVE_BEGIN<span class="hl opt">,</span>
	GENNOTIFY_LARGECAVE_END<span class="hl opt">,</span>
	GENNOTIFY_DECORATION<span class="hl opt">,</span>
	NUM_GENNOTIFY_TYPES
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> GenNotifyEvent <span class="hl opt">{</span>
	GenNotifyType type<span class="hl opt">;</span>
	v3s16 pos<span class="hl opt">;</span>
	u32 id<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwc">class</span> GenerateNotifier <span class="hl opt">{</span>
<span class="hl kwc">public</span><span class="hl opt">:</span>
	<span class="hl slc">// Use only for temporary Mapgen objects with no map generation!</span>
	<span class="hl kwd">GenerateNotifier</span><span class="hl opt">() =</span> <span class="hl kwa">default</span><span class="hl opt">;</span>
	<span class="hl kwd">GenerateNotifier</span><span class="hl opt">(</span>u32 notify_on<span class="hl opt">,</span> <span class="hl kwb">const</span> <span class="hl kwc">std</span><span class="hl opt">::</span>set<span class="hl opt">&lt;</span>u32<span class="hl opt">&gt; *</span>notify_on_deco_ids<span class="hl opt">);</span>

	<span class="hl kwb">bool</span> <span class="hl kwd">addEvent</span><span class="hl opt">(</span>GenNotifyType type<span class="hl opt">,</span> v3s16 pos<span class="hl opt">,</span> u32 id<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">getEvents</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span>map<span class="hl opt">&lt;</span><span class="hl kwc">std</span><span class="hl opt">::</span>string<span class="hl opt">,</span> <span class="hl kwc">std</span><span class="hl opt">::</span>vector<span class="hl opt">&lt;</span>v3s16<span class="hl opt">&gt; &gt; &amp;</span>event_map<span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">clearEvents</span><span class="hl opt">();</span>

<span class="hl kwc">private</span><span class="hl opt">:</span>
	u32 m_notify_on <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl kwb">const</span> <span class="hl kwc">std</span><span class="hl opt">::</span>set<span class="hl opt">&lt;</span>u32<span class="hl opt">&gt; *</span>m_notify_on_deco_ids <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>
	<span class="hl kwc">std</span><span class="hl opt">::</span>list<span class="hl opt">&lt;</span>GenNotifyEvent<span class="hl opt">&gt;</span> m_notify_events<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl slc">// Order must match the order of &apos;static MapgenDesc g_reg_mapgens[]&apos; in mapgen.cpp</span>
<span class="hl kwb">enum</span> MapgenType <span class="hl opt">{</span>
	MAPGEN_V7<span class="hl opt">,</span>
	MAPGEN_VALLEYS<span class="hl opt">,</span>
	MAPGEN_CARPATHIAN<span class="hl opt">,</span>
	MAPGEN_V5<span class="hl opt">,</span>
	MAPGEN_FLAT<span class="hl opt">,</span>
	MAPGEN_FRACTAL<span class="hl opt">,</span>
	MAPGEN_SINGLENODE<span class="hl opt">,</span>
	MAPGEN_V6<span class="hl opt">,</span>
	MAPGEN_INVALID<span class="hl opt">,</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> MapgenParams <span class="hl opt">{</span>
	<span class="hl kwd">MapgenParams</span><span class="hl opt">() =</span> <span class="hl kwa">default</span><span class="hl opt">;</span>
	<span class="hl kwc">virtual</span> <span class="hl opt">~</span><span class="hl kwd">MapgenParams</span><span class="hl opt">();</span>

	MapgenType mgtype <span class="hl opt">=</span> MAPGEN_DEFAULT<span class="hl opt">;</span>
	s16 chunksize <span class="hl opt">=</span> <span class="hl num">5</span><span class="hl opt">;</span>
	u64 seed <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	s16 water_level <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
	s16 mapgen_limit <span class="hl opt">=</span> MAX_MAP_GENERATION_LIMIT<span class="hl opt">;</span>
	<span class="hl slc">// Flags set in readParams</span>
	u32 flags <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	u32 spflags <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

	BiomeParams <span class="hl opt">*</span>bparams <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>

	s16 mapgen_edge_min <span class="hl opt">= -</span>MAX_MAP_GENERATION_LIMIT<span class="hl opt">;</span>
	s16 mapgen_edge_max <span class="hl opt">=</span> MAX_MAP_GENERATION_LIMIT<span class="hl opt">;</span>

	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">readParams</span><span class="hl opt">(</span><span class="hl kwb">const</span> Settings <span class="hl opt">*</span>settings<span class="hl opt">);</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">writeParams</span><span class="hl opt">(</span>Settings <span class="hl opt">*</span>settings<span class="hl opt">)</span> <span class="hl kwb">const</span><span class="hl opt">;</span>
	<span class="hl slc">// Default settings for g_settings such as flags</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">setDefaultSettings</span><span class="hl opt">(</span>Settings <span class="hl opt">*</span>settings<span class="hl opt">) {};</span>

	s32 <span class="hl kwd">getSpawnRangeMax</span><span class="hl opt">();</span>

<span class="hl kwc">private</span><span class="hl opt">:</span>
	<span class="hl kwb">void</span> <span class="hl kwd">calcMapgenEdges</span><span class="hl opt">();</span>
	<span class="hl kwb">bool</span> m_mapgen_edges_calculated <span class="hl opt">=</span> <span class="hl kwa">false</span><span class="hl opt">;</span>
<span class="hl opt">};</span>


<span class="hl com">/*</span>
<span class="hl com">	Generic interface for map generators.  All mapgens must inherit this class.</span>
<span class="hl com">	If a feature exposed by a public member pointer is not supported by a</span>
<span class="hl com">	certain mapgen, it must be set to NULL.</span>
<span class="hl com"></span>
<span class="hl com">	Apart from makeChunk, getGroundLevelAtPoint, and getSpawnLevelAtPoint, all</span>
<span class="hl com">	methods can be used by constructing a Mapgen base class and setting the</span>
<span class="hl com">	appropriate public members (e.g. vm, ndef, and so on).</span>
<span class="hl com">*/</span>
<span class="hl kwc">class</span> Mapgen <span class="hl opt">{</span>
<span class="hl kwc">public</span><span class="hl opt">:</span>
	s32 seed <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl kwb">int</span> water_level <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl kwb">int</span> mapgen_limit <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	u32 flags <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl kwb">bool</span> generating <span class="hl opt">=</span> <span class="hl kwa">false</span><span class="hl opt">;</span>
	<span class="hl kwb">int</span> id <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>

	MMVManip <span class="hl opt">*</span>vm <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>
	<span class="hl kwb">const</span> NodeDefManager <span class="hl opt">*</span>ndef <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>

	u32 blockseed<span class="hl opt">;</span>
	s16 <span class="hl opt">*</span>heightmap <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>
	biome_t <span class="hl opt">*</span>biomemap <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>
	v3s16 csize<span class="hl opt">;</span>

	BiomeGen <span class="hl opt">*</span>biomegen <span class="hl opt">=</span> <span class="hl kwc">nullptr</span><span class="hl opt">;</span>
	GenerateNotifier gennotify<span class="hl opt">;</span>

	<span class="hl kwd">Mapgen</span><span class="hl opt">() =</span> <span class="hl kwa">default</span><span class="hl opt">;</span>
	<span class="hl kwd">Mapgen</span><span class="hl opt">(</span><span class="hl kwb">int</span> mapgenid<span class="hl opt">,</span> MapgenParams <span class="hl opt">*</span>params<span class="hl opt">,</span> EmergeParams <span class="hl opt">*</span>emerge<span class="hl opt">);</span>
	<span class="hl kwc">virtual</span> <span class="hl opt">~</span><span class="hl kwd">Mapgen</span><span class="hl opt">() =</span> <span class="hl kwa">default</span><span class="hl opt">;</span>
	<span class="hl kwd">DISABLE_CLASS_COPY</span><span class="hl opt">(</span>Mapgen<span class="hl opt">);</span>

	<span class="hl kwc">virtual</span> MapgenType <span class="hl kwd">getType</span><span class="hl opt">()</span> <span class="hl kwb">const</span> <span class="hl opt">{</span> <span class="hl kwa">return</span> MAPGEN_INVALID<span class="hl opt">; }</span>

	<span class="hl kwb">static</span> u32 <span class="hl kwd">getBlockSeed</span><span class="hl opt">(</span>v3s16 p<span class="hl opt">,</span> s32 seed<span class="hl opt">);</span>
	<span class="hl kwb">static</span> u32 <span class="hl kwd">getBlockSeed2</span><span class="hl opt">(</span>v3s16 p<span class="hl opt">,</span> s32 seed<span class="hl opt">);</span>
	s16 <span class="hl kwd">findGroundLevel</span><span class="hl opt">(</span>v2s16 p2d<span class="hl opt">,</span> s16 ymin<span class="hl opt">,</span> s16 ymax<span class="hl opt">);</span>
	s16 <span class="hl kwd">findLiquidSurface</span><span class="hl opt">(</span>v2s16 p2d<span class="hl opt">,</span> s16 ymin<span class="hl opt">,</span> s16 ymax<span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">updateHeightmap</span><span class="hl opt">(</span>v3s16 nmin<span class="hl opt">,</span> v3s16 nmax<span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">getSurfaces</span><span class="hl opt">(</span>v2s16 p2d<span class="hl opt">,</span> s16 ymin<span class="hl opt">,</span> s16 ymax<span class="hl opt">,</span>
		<span class="hl kwc">std</span><span class="hl opt">::</span>vector<span class="hl opt">&lt;</span>s16<span class="hl opt">&gt; &amp;</span>floors<span class="hl opt">,</span> <span class="hl kwc">std</span><span class="hl opt">::</span>vector<span class="hl opt">&lt;</span>s16<span class="hl opt">&gt; &amp;</span>ceilings<span class="hl opt">);</span>

	<span class="hl kwb">void</span> <span class="hl kwd">updateLiquid</span><span class="hl opt">(</span>UniqueQueue<span class="hl opt">&lt;</span>v3s16<span class="hl opt">&gt; *</span>trans_liquid<span class="hl opt">,</span> v3s16 nmin<span class="hl opt">,</span> v3s16 nmax<span class="hl opt">);</span>

	<span class="hl kwb">void</span> <span class="hl kwd">setLighting</span><span class="hl opt">(</span>u8 light<span class="hl opt">,</span> v3s16 nmin<span class="hl opt">,</span> v3s16 nmax<span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">lightSpread</span><span class="hl opt">(</span>VoxelArea <span class="hl opt">&amp;</span>a<span class="hl opt">,</span> <span class="hl kwc">std</span><span class="hl opt">::</span>queue<span class="hl opt">&lt;</span><span class="hl kwc">std</span><span class="hl opt">::</span>pair<span class="hl opt">&lt;</span>v3s16<span class="hl opt">,</span> u8<span class="hl opt">&gt;&gt; &amp;</span>queue<span class="hl opt">,</span>
		<span class="hl kwb">const</span> v3s16 <span class="hl opt">&amp;</span>p<span class="hl opt">,</span> u8 light<span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">calcLighting</span><span class="hl opt">(</span>v3s16 nmin<span class="hl opt">,</span> v3s16 nmax<span class="hl opt">,</span> v3s16 full_nmin<span class="hl opt">,</span> v3s16 full_nmax<span class="hl opt">,</span>
		<span class="hl kwb">bool</span> propagate_shadow <span class="hl opt">=</span> <span class="hl kwa">true</span><span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">propagateSunlight</span><span class="hl opt">(</span>v3s16 nmin<span class="hl opt">,</span> v3s16 nmax<span class="hl opt">,</span> <span class="hl kwb">bool</span> propagate_shadow<span class="hl opt">);</span>
	<span class="hl kwb">void</span> <span class="hl kwd">spreadLight</span><span class="hl opt">(</span><span class="hl kwb">const</span> v3s16 <span class="hl opt">&amp;</span>nmin<span class="hl opt">,</span> <span class="hl kwb">const</span> v3s16 <span class="hl opt">&amp;</span>nmax<span class="hl opt">);</span>

	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">makeChunk</span><span class="hl opt">(</span>BlockMakeData <span class="hl opt">*</span>data<span class="hl opt">) {}</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">int</span> <span class="hl kwd">getGroundLevelAtPoint</span><span class="hl opt">(</span>v2s16 p<span class="hl opt">) {</span> <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">; }</span>

	<span class="hl slc">// getSpawnLevelAtPoint() is a function within each mapgen that returns a</span>
	<span class="hl slc">// suitable y co-ordinate for player spawn (&apos;suitable&apos; usually meaning</span>
	<span class="hl slc">// within 16 nodes of water_level). If a suitable spawn level cannot be</span>
	<span class="hl slc">// found at the specified (X, Z) &apos;MAX_MAP_GENERATION_LIMIT&apos; is returned to</span>
	<span class="hl slc">// signify this and to cause Server::findSpawnPos() to try another (X, Z).</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">int</span> <span class="hl kwd">getSpawnLevelAtPoint</span><span class="hl opt">(</span>v2s16 p<span class="hl opt">) {</span> <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">; }</span>

	<span class="hl slc">// Mapgen management functions</span>
	<span class="hl kwb">static</span> MapgenType <span class="hl kwd">getMapgenType</span><span class="hl opt">(</span><span class="hl kwb">const</span> <span class="hl kwc">std</span><span class="hl opt">::</span>string <span class="hl opt">&amp;</span>mgname<span class="hl opt">);</span>
	<span class="hl kwb">static const char</span> <span class="hl opt">*</span><span class="hl kwd">getMapgenName</span><span class="hl opt">(</span>MapgenType mgtype<span class="hl opt">);</span>
	<span class="hl kwb">static</span> Mapgen <span class="hl opt">*</span><span class="hl kwd">createMapgen</span><span class="hl opt">(</span>MapgenType mgtype<span class="hl opt">,</span> MapgenParams <span class="hl opt">*</span>params<span class="hl opt">,</span>
		EmergeParams <span class="hl opt">*</span>emerge<span class="hl opt">);</span>
	<span class="hl kwb">static</span> MapgenParams <span class="hl opt">*</span><span class="hl kwd">createMapgenParams</span><span class="hl opt">(</span>MapgenType mgtype<span class="hl opt">);</span>
	<span class="hl kwb">static void</span> <span class="hl kwd">getMapgenNames</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span>vector<span class="hl opt">&lt;</span><span class="hl kwb">const char</span> <span class="hl opt">*&gt; *</span>mgnames<span class="hl opt">,</span> <span class="hl kwb">bool</span> include_hidden<span class="hl opt">);</span>
	<span class="hl kwb">static void</span> <span class="hl kwd">setDefaultSettings</span><span class="hl opt">(</span>Settings <span class="hl opt">*</span>settings<span class="hl opt">);</span>

<span class="hl kwc">private</span><span class="hl opt">:</span>
	<span class="hl slc">// isLiquidHorizontallyFlowable() is a helper function for updateLiquid()</span>
	<span class="hl slc">// that checks whether there are floodable nodes without liquid beneath</span>
	<span class="hl slc">// the node at index vi.</span>
	<span class="hl kwc">inline</span> <span class="hl kwb">bool</span> <span class="hl kwd">isLiquidHorizontallyFlowable</span><span class="hl opt">(</span>u32 vi<span class="hl opt">,</span> v3s16 em<span class="hl opt">);</span>
<span class="hl opt">};</span>

<span class="hl com">/*</span>
<span class="hl com">	MapgenBasic is a Mapgen implementation that handles basic functionality</span>
<span class="hl com">	the majority of conventional mapgens will probably want to use, but isn&apos;t</span>
<span class="hl com">	generic enough to be included as part of the base Mapgen class (such as</span>
<span class="hl com">	generating biome terrain over terrain node skeletons, generating caves,</span>
<span class="hl com">	dungeons, etc.)</span>
<span class="hl com"></span>
<span class="hl com">	Inherit MapgenBasic instead of Mapgen to add this basic functionality to</span>
<span class="hl com">	your mapgen without having to reimplement it.  Feel free to override any of</span>
<span class="hl com">	these methods if you desire different or more advanced behavior.</span>
<span class="hl com"></span>
<span class="hl com">	Note that you must still create your own generateTerrain implementation when</span>
<span class="hl com">	inheriting MapgenBasic.</span>
<span class="hl com">*/</span>
<span class="hl kwc">class</span> MapgenBasic <span class="hl opt">:</span> <span class="hl kwc">public</span> Mapgen <span class="hl opt">{</span>
<span class="hl kwc">public</span><span class="hl opt">:</span>
	<span class="hl kwd">MapgenBasic</span><span class="hl opt">(</span><span class="hl kwb">int</span> mapgenid<span class="hl opt">,</span> MapgenParams <span class="hl opt">*</span>params<span class="hl opt">,</span> EmergeParams <span class="hl opt">*</span>emerge<span class="hl opt">);</span>
	<span class="hl kwc">virtual</span> <span class="hl opt">~</span><span class="hl kwd">MapgenBasic</span><span class="hl opt">();</span>

	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">generateBiomes</span><span class="hl opt">();</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">dustTopNodes</span><span class="hl opt">();</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">generateCavesNoiseIntersection</span><span class="hl opt">(</span>s16 max_stone_y<span class="hl opt">);</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">generateCavesRandomWalk</span><span class="hl opt">(</span>s16 max_stone_y<span class="hl opt">,</span> s16 large_cave_ymax<span class="hl opt">);</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">bool</span> <span class="hl kwd">generateCavernsNoise</span><span class="hl opt">(</span>s16 max_stone_y<span class="hl opt">);</span>
	<span class="hl kwc">virtual</span> <span class="hl kwb">void</span> <span class="hl kwd">generateDungeons</span><span class="hl opt">(</span>s16 max_stone_y<span class="hl opt">);</span>

<span class="hl kwc">protected</span><span class="hl opt">:</span>
	EmergeParams <span class="hl opt">*</span>m_emerge<span class="hl opt">;</span>
	BiomeManager <span class="hl opt">*</span>m_bmgr<span class="hl opt">;</span>

	Noise <span class="hl opt">*</span>noise_filler_depth<span class="hl opt">;</span>

	v3s16 node_min<span class="hl opt">;</span>
	v3s16 node_max<span class="hl opt">;</span>
	v3s16 full_node_min<span class="hl opt">;</span>
	v3s16 full_node_max<span class="hl opt">;</span>

	content_t c_stone<span class="hl opt">;</span>
	content_t c_water_source<span class="hl opt">;</span>
	content_t c_river_water_source<span class="hl opt">;</span>
	content_t c_lava_source<span class="hl opt">;</span>
	content_t c_cobble<span class="hl opt">;</span>

	<span class="hl kwb">int</span> ystride<span class="hl opt">;</span>
	<span class="hl kwb">int</span> zstride<span class="hl opt">;</span>
	<span class="hl kwb">int</span> zstride_1d<span class="hl opt">;</span>
	<span class="hl kwb">int</span> zstride_1u1d<span class="hl opt">;</span>

	u32 spflags<span class="hl opt">;</span>

	NoiseParams np_cave1<span class="hl opt">;</span>
	NoiseParams np_cave2<span class="hl opt">;</span>
	NoiseParams np_cavern<span class="hl opt">;</span>
	NoiseParams np_dungeons<span class="hl opt">;</span>
	<span class="hl kwb">float</span> cave_width<span class="hl opt">;</span>
	<span class="hl kwb">float</span> cavern_limit<span class="hl opt">;</span>
	<span class="hl kwb">float</span> cavern_taper<span class="hl opt">;</span>
	<span class="hl kwb">float</span> cavern_threshold<span class="hl opt">;</span>
	<span class="hl kwb">int</span> small_cave_num_min<span class="hl opt">;</span>
	<span class="hl kwb">int</span> small_cave_num_max<span class="hl opt">;</span>
	<span class="hl kwb">int</span> large_cave_num_min<span class="hl opt">;</span>
	<span class="hl kwb">int</span> large_cave_num_max<span class="hl opt">;</span>
	<span class="hl kwb">float</span> large_cave_flooded<span class="hl opt">;</span>
	s16 large_cave_depth<span class="hl opt">;</span>
	s16 dungeon_ymin<span class="hl opt">;</span>
	s16 dungeon_ymax<span class="hl opt">;</span>
<span class="hl opt">};</span>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.39.1</a>) at 2024-12-25 21:34:03 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>
ull_bpmax);

	// Note: we may need this again at some point.
#if 0
	// Ensure none of the blocks to be generated were marked as
	// containing CONTENT_IGNORE
	for (s16 z = blockpos_min.Z; z <= blockpos_max.Z; z++) {
		for (s16 y = blockpos_min.Y; y <= blockpos_max.Y; y++) {
			for (s16 x = blockpos_min.X; x <= blockpos_max.X; x++) {
				core::map<v3s16, u8>::Node *n;
				n = data->vmanip->m_loaded_blocks.find(v3s16(x, y, z));
				if (n == NULL)
					continue;
				u8 flags = n->getValue();
				flags &= ~VMANIP_BLOCK_CONTAINS_CIGNORE;
				n->setValue(flags);
			}
		}
	}
#endif

	// Data is ready now.
	return true;
}

void ServerMap::finishBlockMake(BlockMakeData *data,
	std::map<v3s16, MapBlock*> *changed_blocks)
{
	v3s16 bpmin = data->blockpos_min;
	v3s16 bpmax = data->blockpos_max;

	v3s16 extra_borders(1, 1, 1);

	bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
	EMERGE_DBG_OUT("finishBlockMake(): " PP(bpmin) " - " PP(bpmax));

	/*
		Blit generated stuff to map
		NOTE: blitBackAll adds nearly everything to changed_blocks
	*/
	data->vmanip->blitBackAll(changed_blocks);

	EMERGE_DBG_OUT("finishBlockMake: changed_blocks.size()="
		<< changed_blocks->size());

	/*
		Copy transforming liquid information
	*/
	while (data->transforming_liquid.size()) {
		m_transforming_liquid.push_back(data->transforming_liquid.front());
		data->transforming_liquid.pop_front();
	}

	for (auto &changed_block : *changed_blocks) {
		MapBlock *block = changed_block.second;
		if (!block)
			continue;
		/*
			Update day/night difference cache of the MapBlocks
		*/
		block->expireDayNightDiff();
		/*
			Set block as modified
		*/
		block->raiseModified(MOD_STATE_WRITE_NEEDED,
			MOD_REASON_EXPIRE_DAYNIGHTDIFF);
	}

	/*
		Set central blocks as generated
	*/
	for (s16 x = bpmin.X; x <= bpmax.X; x++)
	for (s16 z = bpmin.Z; z <= bpmax.Z; z++)
	for (s16 y = bpmin.Y; y <= bpmax.Y; y++) {
		MapBlock *block = getBlockNoCreateNoEx(v3s16(x, y, z));
		if (!block)
			continue;

		block->setGenerated(true);
	}

	/*
		Save changed parts of map
		NOTE: Will be saved later.
	*/
	//save(MOD_STATE_WRITE_AT_UNLOAD);
	m_chunks_in_progress.erase(bpmin);
}

MapSector *ServerMap::createSector(v2s16 p2d)
{
	/*
		Check if it exists already in memory
	*/
	MapSector *sector = getSectorNoGenerate(p2d);
	if (sector)
		return sector;

	/*
		Do not create over max mapgen limit
	*/
	const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
	if (p2d.X < -max_limit_bp ||
			p2d.X >  max_limit_bp ||
			p2d.Y < -max_limit_bp ||
			p2d.Y >  max_limit_bp)
		throw InvalidPositionException("createSector(): pos. over max mapgen limit");

	/*
		Generate blank sector
	*/

	sector = new MapSector(this, p2d, m_gamedef);

	// Sector position on map in nodes
	//v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;

	/*
		Insert to container
	*/
	m_sectors[p2d] = sector;

	return sector;
}

#if 0
/*
	This is a quick-hand function for calling makeBlock().
*/
MapBlock * ServerMap::generateBlock(
		v3s16 p,
		std::map<v3s16, MapBlock*> &modified_blocks
)
{
	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");

	TimeTaker timer("generateBlock");

	//MapBlock *block = original_dummy;

	v2s16 p2d(p.X, p.Z);
	v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;

	/*
		Do not generate over-limit
	*/
	if(blockpos_over_limit(p))
	{
		infostream<<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("mapgen::make_block()");
		mapgen->makeChunk(&data);
		//mapgen::make_block(&data);

		if(enable_mapgen_debug_info == false)
			t.stop(true); // Hide output
	}

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

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

#if 0
	/*
		Check result
	*/
	if(block)
	{
		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.getContent() == CONTENT_IGNORE)
			{
				infostream<<"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
	*/
	if(block)
	{
		for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
		for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
		{
			for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
			{
				MapNode n;
				n.setContent(CONTENT_AIR);
				block->setNode(v3s16(x0,y0,z0), n);
			}
		}
	}
#endif

	if(enable_mapgen_debug_info == false)
		timer.stop(true); // Hide output

	return block;
}
#endif

MapBlock * ServerMap::createBlock(v3s16 p)
{
	/*
		Do not create over max mapgen limit
	*/
	if (blockpos_over_max_limit(p))
		throw InvalidPositionException("createBlock(): pos. over max mapgen 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.
	*/
	MapSector *sector;
	try {
		sector = createSector(p2d);
	} catch (InvalidPositionException &e) {
		infostream<<"createBlock: createSector() failed"<<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;
}

MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
{
	{
		MapBlock *block = getBlockNoCreateNoEx(p);
		if (block && !block->isDummy())
			return block;
	}

	{
		MapBlock *block = loadBlock(p);
		if(block)
			return block;
	}

	if (create_blank) {
		MapSector *sector = createSector(v2s16(p.X, p.Z));
		MapBlock *block = sector->createBlankBlock(p.Y);

		return block;
	}

	return NULL;
}

MapBlock *ServerMap::getBlockOrEmerge(v3s16 p3d)
{
	MapBlock *block = getBlockNoCreateNoEx(p3d);
	if (block == NULL)
		m_emerge->enqueueBlockEmerge(PEER_ID_INEXISTENT, p3d, false);

	return block;
}

// N.B.  This requires no synchronization, since data will not be modified unless
// the VoxelManipulator being updated belongs to the same thread.
void ServerMap::updateVManip(v3s16 pos)
{
	Mapgen *mg = m_emerge->getCurrentMapgen();
	if (!mg)
		return;

	MMVManip *vm = mg->vm;
	if (!vm)
		return;

	if (!vm->m_area.contains(pos))
		return;

	s32 idx = vm->m_area.index(pos);
	vm->m_data[idx] = getNode(pos);
	vm->m_flags[idx] &= ~VOXELFLAG_NO_DATA;

	vm->m_is_dirty = true;
}

void ServerMap::save(ModifiedState save_level)
{
	if (!m_map_saving_enabled) {
		warningstream<<"Not saving map, saving disabled."<<std::endl;
		return;
	}

	u64 start_time = porting::getTimeNs();

	if(save_level == MOD_STATE_CLEAN)
		infostream<<"ServerMap: Saving whole map, this can take time."
				<<std::endl;

	if (m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
		if (settings_mgr.saveMapMeta())
			m_map_metadata_changed = false;
	}

	// Profile modified reasons
	Profiler modprofiler;

	u32 block_count = 0;
	u32 block_count_all = 0; // Number of blocks in memory

	// Don't do anything with sqlite unless something is really saved
	bool save_started = false;

	for (auto &sector_it : m_sectors) {
		MapSector *sector = sector_it.second;

		MapBlockVect blocks;
		sector->getBlocks(blocks);

		for (MapBlock *block : blocks) {
			block_count_all++;

			if(block->getModified() >= (u32)save_level) {
				// Lazy beginSave()
				if(!save_started) {
					beginSave();
					save_started = true;
				}

				modprofiler.add(block->getModifiedReasonString(), 1);

				saveBlock(block);
				block_count++;
			}
		}
	}

	if(save_started)
		endSave();

	/*
		Only print if something happened or saved whole map
	*/
	if(save_level == MOD_STATE_CLEAN
			|| block_count != 0) {
		infostream << "ServerMap: Written: "
				<< block_count << " blocks"
				<< ", " << block_count_all << " blocks in memory."
				<< std::endl;
		PrintInfo(infostream); // ServerMap/ClientMap:
		infostream<<"Blocks modified by: "<<std::endl;
		modprofiler.print(infostream);
	}

	auto end_time = porting::getTimeNs();
	m_save_time_counter->increment(end_time - start_time);
}

void ServerMap::listAllLoadableBlocks(std::vector<v3s16> &dst)
{
	dbase->listAllLoadableBlocks(dst);
	if (dbase_ro)
		dbase_ro->listAllLoadableBlocks(dst);
}

void ServerMap::listAllLoadedBlocks(std::vector<v3s16> &dst)
{
	for (auto &sector_it : m_sectors) {
		MapSector *sector = sector_it.second;

		MapBlockVect blocks;
		sector->getBlocks(blocks);

		for (MapBlock *block : blocks) {
			v3s16 p = block->getPos();
			dst.push_back(p);
		}
	}
}

MapDatabase *ServerMap::createDatabase(
	const std::string &name,
	const std::string &savedir,
	Settings &conf)
{
	if (name == "sqlite3")
		return new MapDatabaseSQLite3(savedir);
	if (name == "dummy")
		return new Database_Dummy();
	#if USE_LEVELDB
	if (name == "leveldb")
		return new Database_LevelDB(savedir);
	#endif
	#if USE_REDIS
	if (name == "redis")
		return new Database_Redis(conf);
	#endif
	#if USE_POSTGRESQL
	if (name == "postgresql") {
		std::string connect_string;
		conf.getNoEx("pgsql_connection", connect_string);
		return new MapDatabasePostgreSQL(connect_string);
	}
	#endif

	throw BaseException(std::string("Database backend ") + name + " not supported.");
}

void ServerMap::beginSave()
{
	dbase->beginSave();
}

void ServerMap::endSave()
{
	dbase->endSave();
}

bool ServerMap::saveBlock(MapBlock *block)
{
	return saveBlock(block, dbase, m_map_compression_level);
}

bool ServerMap::saveBlock(MapBlock *block, MapDatabase *db, int compression_level)
{
	v3s16 p3d = block->getPos();

	// Dummy blocks are not written
	if (block->isDummy()) {
		warningstream << "saveBlock: Not writing dummy block "
			<< PP(p3d) << std::endl;
		return true;
	}

	// Format used for writing
	u8 version = SER_FMT_VER_HIGHEST_WRITE;

	/*
		[0] u8 serialization version
		[1] data
	*/
	std::ostringstream o(std::ios_base::binary);
	o.write((char*) &version, 1);
	block->serialize(o, version, true, compression_level);

	bool ret = db->saveBlock(p3d, o.str());
	if (ret) {
		// We just wrote it to the disk so clear modified flag
		block->resetModified();
	}
	return ret;
}

void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load)
{
	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");

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

		// If it's a new block, insert it to the map
		if (created_new) {
			sector->insertBlock(block);
			ReflowScan scanner(this, m_emerge->ndef);
			scanner.scan(block, &m_transforming_liquid);
		}

		/*
			Save blocks loaded in old format in new format
		*/

		//if(version < SER_FMT_VER_HIGHEST_READ || save_after_load)
		// Only save if asked to; no need to update version
		if(save_after_load)
			saveBlock(block);

		// We just loaded it from, so it's up-to-date.
		block->resetModified();
	}
	catch(SerializationError &e)
	{
		errorstream<<"Invalid block data in database"
				<<" ("<<p3d.X<<","<<p3d.Y<<","<<p3d.Z<<")"
				<<" (SerializationError): "<<e.what()<<std::endl;

		// TODO: Block should be marked as invalid in memory so that it is
		// not touched but the game can run

		if(g_settings->getBool("ignore_world_load_errors")){
			errorstream<<"Ignoring block load error. Duck and cover! "
					<<"(ignore_world_load_errors)"<<std::endl;
		} else {
			throw SerializationError("Invalid block data in database");
		}
	}
}

MapBlock* ServerMap::loadBlock(v3s16 blockpos)
{
	bool created_new = (getBlockNoCreateNoEx(blockpos) == NULL);

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

	std::string ret;
	dbase->loadBlock(blockpos, &ret);
	if (!ret.empty()) {
		loadBlock(&ret, blockpos, createSector(p2d), false);
	} else if (dbase_ro) {
		dbase_ro->loadBlock(blockpos, &ret);
		if (!ret.empty()) {
			loadBlock(&ret, blockpos, createSector(p2d), false);
		}
	} else {
		return NULL;
	}

	MapBlock *block = getBlockNoCreateNoEx(blockpos);
	if (created_new && (block != NULL)) {
		std::map<v3s16, MapBlock*> modified_blocks;
		// Fix lighting if necessary
		voxalgo::update_block_border_lighting(this, block, modified_blocks);
		if (!modified_blocks.empty()) {
			//Modified lighting, send event
			MapEditEvent event;
			event.type = MEET_OTHER;
			std::map<v3s16, MapBlock *>::iterator it;
			for (it = modified_blocks.begin();
					it != modified_blocks.end(); ++it)
				event.modified_blocks.insert(it->first);
			dispatchEvent(event);
		}
	}
	return block;
}

bool ServerMap::deleteBlock(v3s16 blockpos)
{
	if (!dbase->deleteBlock(blockpos))
		return false;

	MapBlock *block = getBlockNoCreateNoEx(blockpos);
	if (block) {
		v2s16 p2d(blockpos.X, blockpos.Z);
		MapSector *sector = getSectorNoGenerate(p2d);
		if (!sector)
			return false;
		sector->deleteBlock(block);
	}

	return true;
}

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

bool ServerMap::repairBlockLight(v3s16 blockpos,
	std::map<v3s16, MapBlock *> *modified_blocks)
{
	MapBlock *block = emergeBlock(blockpos, false);
	if (!block || !block->isGenerated())
		return false;
	voxalgo::repair_block_light(this, block, modified_blocks);
	return true;
}

MMVManip::MMVManip(Map *map):
		VoxelManipulator(),
		m_map(map)
{
}

void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
	bool load_if_inexistent)
{
	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)
	{
		infostream<<"initialEmerge: area: ";
		block_area_nodes.print(infostream);
		infostream<<" ("<<size_MB<<"MB)";
		infostream<<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++)
	{
		u8 flags = 0;
		MapBlock *block;
		v3s16 p(x,y,z);
		std::map<v3s16, u8>::iterator n;
		n = m_loaded_blocks.find(p);
		if(n != m_loaded_blocks.end())
			continue;

		bool block_data_inexistent = false;
		{
			TimeTaker timer2("emerge load", &emerge_load_time);

			block = m_map->getBlockNoCreateNoEx(p);
			if (!block || block->isDummy())
				block_data_inexistent = true;
			else
				block->copyTo(*this);
		}

		if(block_data_inexistent)
		{

			if (load_if_inexistent && !blockpos_over_max_limit(p)) {
				ServerMap *svrmap = (ServerMap *)m_map;
				block = svrmap->emergeBlock(p, false);
				if (block == NULL)
					block = svrmap->createBlock(p);
				block->copyTo(*this);
			} else {
				flags |= VMANIP_BLOCK_DATA_INEXIST;

				/*
					Mark area inexistent
				*/
				VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
				// Fill with VOXELFLAG_NO_DATA
				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_NO_DATA, MAP_BLOCKSIZE);
				}
			}
		}
		/*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
		{
			// Mark that block was loaded as blank
			flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
		}*/

		m_loaded_blocks[p] = flags;
	}

	m_is_dirty = false;
}

void MMVManip::blitBackAll(std::map<v3s16, MapBlock*> *modified_blocks,
	bool overwrite_generated)
{
	if(m_area.getExtent() == v3s16(0,0,0))
		return;

	/*
		Copy data of all blocks
	*/
	for (auto &loaded_block : m_loaded_blocks) {
		v3s16 p = loaded_block.first;
		MapBlock *block = m_map->getBlockNoCreateNoEx(p);
		bool existed = !(loaded_block.second & VMANIP_BLOCK_DATA_INEXIST);
		if (!existed || (block == NULL) ||
			(!overwrite_generated && block->isGenerated()))
			continue;

		block->copyFrom(*this);
		block->raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_VMANIP);

		if(modified_blocks)
			(*modified_blocks)[p] = block;
	}
}

//END