#include "database.h"
#include "database-dummy.h"
#include "database-sqlite3.h"
+#include <deque>
#if USE_LEVELDB
#include "database-leveldb.h"
#endif
Map::Map(std::ostream &dout, IGameDef *gamedef):
m_dout(dout),
m_gamedef(gamedef),
- m_sector_cache(NULL)
+ m_sector_cache(NULL),
+ m_transforming_liquid_loop_count_multiplier(1.0f),
+ m_unprocessed_count(0),
+ m_inc_trending_up_start_time(0),
+ m_queue_size_timer_started(false)
{
}
v3s16(-1,0,0), // left
};
- if(from_nodes.size() == 0)
+ if(from_nodes.empty())
return;
u32 blockchangecount = 0;
v3s16 n2pos = pos + dirs[i];
// Get the block where the node is located
- v3s16 blockpos = getNodeBlockPos(n2pos);
+ v3s16 blockpos, relpos;
+ getNodeBlockPosWithOffset(n2pos, blockpos, relpos);
// Only fetch a new block if the block position has changed
try {
continue;
}
- // Calculate relative position in block
- v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
// Get node straight from the block
bool is_valid_position;
MapNode n2 = block->getNode(relpos, &is_valid_position);
}
/*infostream<<"unspreadLight(): Changed block "
- <<blockchangecount<<" times"
- <<" for "<<from_nodes.size()<<" nodes"
- <<std::endl;*/
+ <<blockchangecount<<" times"
+ <<" for "<<from_nodes.size()<<" nodes"
+ <<std::endl;*/
- if(unlighted_nodes.size() > 0)
+ if(!unlighted_nodes.empty())
unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
}
v3s16(-1,0,0), // left
};
- if(from_nodes.size() == 0)
+ if(from_nodes.empty())
return;
u32 blockchangecount = 0;
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
- // Cache this a bit, too
+ // Cache this a bit, too
bool block_checked_in_modified = false;
for(std::set<v3s16>::iterator j = from_nodes.begin();
j != from_nodes.end(); ++j)
{
v3s16 pos = *j;
- v3s16 blockpos = getNodeBlockPos(pos);
+ v3s16 blockpos, relpos;
+
+ getNodeBlockPosWithOffset(pos, blockpos, relpos);
// Only fetch a new block if the block position has changed
try {
if(block->isDummy())
continue;
- // Calculate relative position in block
- v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
-
// Get node straight from the block
bool is_valid_position;
MapNode n = block->getNode(relpos, &is_valid_position);
v3s16 n2pos = pos + dirs[i];
// Get the block where the node is located
- v3s16 blockpos = getNodeBlockPos(n2pos);
+ v3s16 blockpos, relpos;
+ getNodeBlockPosWithOffset(n2pos, blockpos, relpos);
// Only fetch a new block if the block position has changed
try {
continue;
}
- // Calculate relative position in block
- v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
// Get node straight from the block
MapNode n2 = block->getNode(relpos, &is_valid_position);
if (!is_valid_position)
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
- if(lighted_nodes.size() > 0)
+ if(!lighted_nodes.empty())
spreadLight(bank, lighted_nodes, modified_blocks);
}
//bool debug=true;
//u32 count_was = modified_blocks.size();
- std::map<v3s16, MapBlock*> blocks_to_update;
+ //std::map<v3s16, MapBlock*> blocks_to_update;
std::set<v3s16> light_sources;
v3s16 pos = block->getPos();
v3s16 posnodes = block->getPosRelative();
modified_blocks[pos] = block;
- blocks_to_update[pos] = block;
+ //blocks_to_update[pos] = block;
/*
Clear all light from block
This also clears the lighting.
*/
- MapNode n;
- n.setContent(replace_material);
+ MapNode n(replace_material);
setNode(p, n);
for(s32 i=0; i<2; i++)
NeighborType t;
v3s16 p;
bool l; //can liquid
+
+ NodeNeighbor()
+ : n(CONTENT_AIR)
+ { }
+
+ NodeNeighbor(const MapNode &node, NeighborType n_type, v3s16 pos)
+ : n(node),
+ t(n_type),
+ p(pos)
+ { }
};
void Map::transforming_liquid_add(v3s16 p) {
void Map::transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks)
{
+
INodeDefManager *nodemgr = m_gamedef->ndef();
DSTACK(__FUNCTION_NAME);
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;
+ std::deque<v3s16> must_reflow;
// List of MapBlocks that will require a lighting update (due to lava)
std::map<v3s16, MapBlock*> lighting_modified_blocks;
- u16 loop_max = g_settings->getU16("liquid_loop_max");
+ 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_settings->getFloat("dedicated_server_step");
+ if (m_transforming_liquid_loop_count_multiplier - 1.0 < server_step)
+ m_transforming_liquid_loop_count_multiplier *= 1.0 + server_step / 10;
+ } else {
+ m_transforming_liquid_loop_count_multiplier = 1.0;
+ }
+
+ loop_max *= m_transforming_liquid_loop_count_multiplier;
+#endif
while(m_transforming_liquid.size() != 0)
{
/*
Get a queued transforming liquid node
*/
- v3s16 p0 = m_transforming_liquid.pop_front();
+ v3s16 p0 = m_transforming_liquid.front();
+ m_transforming_liquid.pop_front();
MapNode n0 = getNodeNoEx(p0);
break;
}
v3s16 npos = p0 + dirs[i];
- NodeNeighbor nb = {getNodeNoEx(npos), nt, npos};
+ NodeNeighbor nb(getNodeNoEx(npos), nt, npos);
switch (nodemgr->get(nb.n.getContent()).liquid_type) {
case LIQUID_NONE:
if (nb.n.getContent() == CONTENT_AIR) {
content_t new_node_content;
s8 new_node_level = -1;
s8 max_node_level = -1;
- u8 range = rangelim(nodemgr->get(liquid_kind).liquid_range, 0, LIQUID_LEVEL_MAX+1);
+
+ u8 range = nodemgr->get(liquid_kind).liquid_range;
+ if (range > LIQUID_LEVEL_MAX+1)
+ range = LIQUID_LEVEL_MAX+1;
+
if ((num_sources >= 2 && nodemgr->get(liquid_kind).liquid_renewable) || liquid_type == LIQUID_SOURCE) {
// liquid_kind will be set to either the flowing alternative of the node (if it's a liquid)
// or the flowing alternative of the first of the surrounding sources (if it's air), so
}
}
//infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
- while (must_reflow.size() > 0)
- m_transforming_liquid.push_back(must_reflow.pop_front());
+
+ for (std::deque<v3s16>::iterator iter = must_reflow.begin(); iter != must_reflow.end(); ++iter)
+ m_transforming_liquid.push_back(*iter);
+
updateLighting(lighting_modified_blocks, modified_blocks);
+
+
+ /* ----------------------------------------------------------------------
+ * Manage the queue so that it does not grow indefinately
+ */
+ u16 time_until_purge = g_settings->getU16("liquid_queue_purge_time");
+
+ if (time_until_purge == 0)
+ return; // Feature disabled
+
+ time_until_purge *= 1000; // seconds -> milliseconds
+
+ u32 curr_time = getTime(PRECISION_MILLI);
+ u32 prev_unprocessed = m_unprocessed_count;
+ m_unprocessed_count = m_transforming_liquid.size();
+
+ // if unprocessed block count is decreasing or stable
+ if (m_unprocessed_count <= prev_unprocessed) {
+ m_queue_size_timer_started = false;
+ } else {
+ if (!m_queue_size_timer_started)
+ m_inc_trending_up_start_time = curr_time;
+ m_queue_size_timer_started = true;
+ }
+
+ // Account for curr_time overflowing
+ if (m_queue_size_timer_started && m_inc_trending_up_start_time > curr_time)
+ m_queue_size_timer_started = false;
+
+ /* If the queue has been growing for more than liquid_queue_purge_time seconds
+ * and the number of unprocessed blocks is still > liquid_loop_max then we
+ * cannot keep up; dump the oldest blocks from the queue so that the queue
+ * has liquid_loop_max items in it
+ */
+ if (m_queue_size_timer_started
+ && curr_time - m_inc_trending_up_start_time > time_until_purge
+ && m_unprocessed_count > liquid_loop_max) {
+
+ size_t dump_qty = m_unprocessed_count - liquid_loop_max;
+
+ infostream << "transformLiquids(): DUMPING " << dump_qty
+ << " blocks from the queue" << std::endl;
+
+ while (dump_qty--)
+ m_transforming_liquid.pop_front();
+
+ m_queue_size_timer_started = false; // optimistically assume we can keep up now
+ m_unprocessed_count = m_transforming_liquid.size();
+ }
}
NodeMetadata *Map::getNodeMetadata(v3s16 p)
v3s16 bigarea_blocks_min = blockpos_min - extra_borders;
v3s16 bigarea_blocks_max = blockpos_max + extra_borders;
- data->vmanip = new ManualMapVoxelManipulator(this);
+ data->vmanip = new MMVManip(this);
//data->vmanip->setMap(this);
// Add the area
{
//TimeTaker timer("initBlockMake() initialEmerge");
- data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max, false);
+ data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
}
// Ensure none of the blocks to be generated were marked as containing CONTENT_IGNORE
*/
while(data->transforming_liquid.size() > 0)
{
- v3s16 p = data->transforming_liquid.pop_front();
- m_transforming_liquid.push_back(p);
+ m_transforming_liquid.push_back(data->transforming_liquid.front());
+ data->transforming_liquid.pop_front();
}
/*
if (!mg)
return;
- ManualMapVoxelManipulator *vm = mg->vm;
+ MMVManip *vm = mg->vm;
if (!vm)
return;
createDirs(m_savedir);
- std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
+ std::string fullpath = m_savedir + DIR_DELIM "map_meta.txt";
std::ostringstream ss(std::ios_base::binary);
Settings params;
{
DSTACK(__FUNCTION_NAME);
+ Settings params;
std::string fullpath = m_savedir + DIR_DELIM "map_meta.txt";
- std::ifstream is(fullpath.c_str(), std::ios_base::binary);
- if (!is.good()) {
- errorstream << "ServerMap::loadMapMeta(): "
- << "could not open" << fullpath << std::endl;
- throw FileNotGoodException("Cannot open map metadata");
- }
- Settings params;
+ if (fs::PathExists(fullpath)) {
+ std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+ if (!is.good()) {
+ errorstream << "ServerMap::loadMapMeta(): "
+ "could not open " << fullpath << std::endl;
+ throw FileNotGoodException("Cannot open map metadata");
+ }
- if (!params.parseConfigLines(is, "[end_of_params]")) {
- throw SerializationError("ServerMap::loadMapMeta(): "
+ if (!params.parseConfigLines(is, "[end_of_params]")) {
+ throw SerializationError("ServerMap::loadMapMeta(): "
"[end_of_params] not found!");
+ }
}
m_emerge->loadParamsFromSettings(¶ms);
{
DSTACK(__FUNCTION_NAME);
- MapSector *sector = NULL;
-
// The directory layout we're going to load from.
// 1 - original sectors/xxxxzzzz/
// 2 - new sectors2/xxx/zzz/
}
try{
- sector = loadSectorMeta(sectordir, loadlayout != 2);
+ loadSectorMeta(sectordir, loadlayout != 2);
}
catch(InvalidFilenameException &e)
{
return getBlockNoCreateNoEx(blockpos);
}
+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 = getSectorNoGenerateNoEx(p2d);
+ if (!sector)
+ return false;
+ sector->deleteBlock(block);
+ }
+
+ return true;
+}
+
void ServerMap::PrintInfo(std::ostream &out)
{
out<<"ServerMap: ";
}
-ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
+MMVManip::MMVManip(Map *map):
VoxelManipulator(),
m_is_dirty(false),
m_create_area(false),
{
}
-ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
+MMVManip::~MMVManip()
{
}
-void ManualMapVoxelManipulator::initialEmerge(v3s16 blockpos_min,
- v3s16 blockpos_max, bool load_if_inexistent)
+void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
+ bool load_if_inexistent)
{
TimeTaker timer1("initialEmerge", &emerge_time);
block = svrmap->emergeBlock(p, false);
if (block == NULL)
block = svrmap->createBlock(p);
- else
- block->copyTo(*this);
+ block->copyTo(*this);
} else {
flags |= VMANIP_BLOCK_DATA_INEXIST;
m_is_dirty = false;
}
-void ManualMapVoxelManipulator::blitBackAll(
- std::map<v3s16, MapBlock*> *modified_blocks,
- bool overwrite_generated)
+void MMVManip::blitBackAll(std::map<v3s16, MapBlock*> *modified_blocks,
+ bool overwrite_generated)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
projects / dragonfireclient.git / blobdiff