Map
*/
-Map::Map(std::ostream &dout, IGameDef *gamedef):
- m_dout(dout),
+Map::Map(IGameDef *gamedef):
m_gamedef(gamedef),
m_nodedef(gamedef->ndef())
{
m_event_receivers.erase(event_receiver);
}
-void Map::dispatchEvent(MapEditEvent *event)
+void Map::dispatchEvent(const MapEditEvent &event)
{
for (MapEventReceiver *event_receiver : m_event_receivers) {
event_receiver->onMapEditEvent(event);
return block;
}
-bool Map::isNodeUnderground(v3s16 p)
+void Map::listAllLoadedBlocks(std::vector<v3s16> &dst)
{
- v3s16 blockpos = getNodeBlockPos(p);
- MapBlock *block = getBlockNoCreateNoEx(blockpos);
- return block && block->getIsUnderground();
+ for (auto §or_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);
+ }
+ }
}
bool Map::isValidPosition(v3s16 p)
return node;
}
-// throws InvalidPositionException if not found
-void Map::setNode(v3s16 p, MapNode & n)
+static void set_node_in_block(MapBlock *block, v3s16 relpos, MapNode n)
{
- v3s16 blockpos = getNodeBlockPos(p);
- MapBlock *block = getBlockNoCreate(blockpos);
- v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
- // Never allow placing CONTENT_IGNORE, it fucks up stuff
+ // Never allow placing CONTENT_IGNORE, it causes problems
if(n.getContent() == CONTENT_IGNORE){
+ const NodeDefManager *nodedef = block->getParent()->getNodeDefManager();
+ v3s16 blockpos = block->getPos();
+ v3s16 p = blockpos * MAP_BLOCKSIZE + relpos;
bool temp_bool;
- errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
+ errorstream<<"Not allowing to place CONTENT_IGNORE"
<<" while trying to replace \""
- <<m_nodedef->get(block->getNodeNoCheck(relpos, &temp_bool)).name
+ <<nodedef->get(block->getNodeNoCheck(relpos, &temp_bool)).name
<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
return;
}
block->setNodeNoCheck(relpos, n);
}
+// 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;
+ set_node_in_block(block, 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);
+ v3s16 blockpos = getNodeBlockPos(p);
+ MapBlock *block = getBlockNoCreate(blockpos);
+ if (block->isDummy())
+ throw InvalidPositionException();
+ v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
+
// This is needed for updating the lighting
- MapNode oldnode = getNode(p);
+ MapNode oldnode = block->getNodeUnsafe(relpos);
// Remove node metadata
if (remove_metadata) {
}
// 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);
+ const ContentFeatures &cf = m_nodedef->get(n);
+ const ContentFeatures &oldcf = m_nodedef->get(oldnode);
+ if (cf.lightingEquivalent(oldcf)) {
+ // No light update needed, just copy over the old light.
+ n.setLight(LIGHTBANK_DAY, oldnode.getLightRaw(LIGHTBANK_DAY, oldcf), cf);
+ n.setLight(LIGHTBANK_NIGHT, oldnode.getLightRaw(LIGHTBANK_NIGHT, oldcf), cf);
+ set_node_in_block(block, relpos, n);
+
+ modified_blocks[blockpos] = block;
+ } else {
+ // Ignore light (because calling voxalgo::update_lighting_nodes)
+ n.setLight(LIGHTBANK_DAY, 0, cf);
+ n.setLight(LIGHTBANK_NIGHT, 0, cf);
+ set_node_in_block(block, relpos, n);
- // Update lighting
- std::vector<std::pair<v3s16, MapNode> > oldnodes;
- oldnodes.emplace_back(p, oldnode);
- voxalgo::update_lighting_nodes(this, oldnodes, modified_blocks);
+ // 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();
+ for (auto &modified_block : modified_blocks) {
+ modified_block.second->expireDayNightDiff();
+ }
}
// Report for rollback
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,
succeeded = false;
}
- dispatchEvent(&event);
+ dispatchEvent(event);
return succeeded;
}
succeeded = false;
}
- dispatchEvent(&event);
+ dispatchEvent(event);
return succeeded;
}
void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks,
std::vector<v3s16> *unloaded_blocks)
{
- bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
+ bool save_before_unloading = maySaveBlocks();
// Profile modified reasons
Profiler modprofiler;
u32 saved_blocks_count = 0;
u32 block_count_all = 0;
+ const auto start_time = porting::getTimeUs();
beginSave();
// If there is no practical limit, we spare creation of mapblock_queue
}
}
+ // Delete sector if we emptied it
if (all_blocks_deleted) {
sector_deletion_queue.push_back(sector_it.first);
}
}
}
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)) {
deleted_blocks_count++;
block_count_all--;
}
+
// Delete empty sectors
for (auto §or_it : m_sectors) {
if (sector_it.second->empty()) {
}
}
}
+
endSave();
+ const auto end_time = porting::getTimeUs();
+
+ reportMetrics(end_time - start_time, saved_blocks_count, block_count_all);
// Finally delete the empty sectors
deleteSectors(sector_deletion_queue);
#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,
{ }
};
-void Map::transforming_liquid_add(v3s16 p) {
+void ServerMap::transforming_liquid_add(v3s16 p) {
m_transforming_liquid.push_back(p);
}
-void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks,
+void ServerMap::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks,
ServerEnvironment *env)
{
u32 loopcount = 0;
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)
{
// This should be done here so that it is done when continue is used
switch (liquid_type) {
case LIQUID_SOURCE:
liquid_level = LIQUID_LEVEL_SOURCE;
- liquid_kind = m_nodedef->getId(cf.liquid_alternative_flowing);
+ liquid_kind = cf.liquid_alternative_flowing_id;
break;
case LIQUID_FLOWING:
liquid_level = (n0.param2 & LIQUID_LEVEL_MASK);
/*
Collect information about the environment
*/
- const v3s16 *dirs = g_6dirs;
NodeNeighbor sources[6]; // surrounding sources
int num_sources = 0;
NodeNeighbor flows[6]; // surrounding flowing liquid nodes
for (u16 i = 0; i < 6; i++) {
NeighborType nt = NEIGHBOR_SAME_LEVEL;
switch (i) {
- case 1:
+ case 0:
nt = NEIGHBOR_UPPER;
break;
- case 4:
+ case 5:
nt = NEIGHBOR_LOWER;
break;
default:
break;
}
- v3s16 npos = p0 + dirs[i];
+ v3s16 npos = p0 + liquid_6dirs[i];
NodeNeighbor nb(getNode(npos), nt, npos);
const ContentFeatures &cfnb = m_nodedef->get(nb.n);
switch (m_nodedef->get(nb.n.getContent()).liquid_type) {
case LIQUID_SOURCE:
// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
if (liquid_kind == CONTENT_AIR)
- liquid_kind = m_nodedef->getId(cfnb.liquid_alternative_flowing);
- if (m_nodedef->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
+ liquid_kind = cfnb.liquid_alternative_flowing_id;
+ if (cfnb.liquid_alternative_flowing_id != liquid_kind) {
neutrals[num_neutrals++] = nb;
} else {
// Do not count bottom source, it will screw things up
- if(dirs[i].Y != -1)
+ if(nt != NEIGHBOR_LOWER)
sources[num_sources++] = nb;
}
break;
case LIQUID_FLOWING:
- // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
- if (liquid_kind == CONTENT_AIR)
- liquid_kind = m_nodedef->getId(cfnb.liquid_alternative_flowing);
- if (m_nodedef->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
+ if (nb.t != NEIGHBOR_SAME_LEVEL ||
+ (nb.n.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK) {
+ // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
+ // but exclude falling liquids on the same level, they cannot flow here anyway
+ if (liquid_kind == CONTENT_AIR)
+ liquid_kind = cfnb.liquid_alternative_flowing_id;
+ }
+ if (cfnb.liquid_alternative_flowing_id != liquid_kind) {
neutrals[num_neutrals++] = nb;
} else {
flows[num_flows++] = nb;
// 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
// it's perfectly safe to use liquid_kind here to determine the new node content.
- new_node_content = m_nodedef->getId(m_nodedef->get(liquid_kind).liquid_alternative_source);
+ new_node_content = m_nodedef->get(liquid_kind).liquid_alternative_source_id;
} else if (num_sources >= 1 && sources[0].t != NEIGHBOR_LOWER) {
// liquid_kind is set properly, see above
max_node_level = new_node_level = LIQUID_LEVEL_MAX;
// set level to last 3 bits, flowing down bit to 4th bit
n0.param2 = (flowing_down ? LIQUID_FLOW_DOWN_MASK : 0x00) | (new_node_level & LIQUID_LEVEL_MASK);
} else {
- // set the liquid level and flow bit to 0
- n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
+ // set the liquid level and flow bits to 0
+ n0.param2 &= ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
}
// change the node.
m_transforming_liquid.push_back(iter);
voxalgo::update_lighting_nodes(this, changed_nodes, modified_blocks);
-
+ env->getScriptIface()->on_liquid_transformed(changed_nodes);
/* ----------------------------------------------------------------------
* Manage the queue so that it does not grow indefinately
ServerMap
*/
ServerMap::ServerMap(const std::string &savedir, IGameDef *gamedef,
- EmergeManager *emerge):
- Map(dout_server, gamedef),
- settings_mgr(g_settings, savedir + DIR_DELIM + "map_meta.txt"),
+ EmergeManager *emerge, MetricsBackend *mb):
+ Map(gamedef),
+ settings_mgr(savedir + DIR_DELIM + "map_meta.txt"),
m_emerge(emerge)
{
verbosestream<<FUNCTION_NAME<<std::endl;
m_savedir = savedir;
m_map_saving_enabled = false;
+ m_save_time_counter = mb->addCounter(
+ "minetest_map_save_time", "Time spent saving blocks (in microseconds)");
+ m_save_count_counter = mb->addCounter(
+ "minetest_map_saved_blocks", "Number of blocks saved");
+ m_loaded_blocks_gauge = mb->addGauge(
+ "minetest_map_loaded_blocks", "Number of loaded blocks");
+
+ m_map_compression_level = rangelim(g_settings->getS16("map_compression_level_disk"), -1, 9);
+
try {
// If directory exists, check contents and load if possible
if (fs::PathExists(m_savedir)) {
Close database if it was opened
*/
delete dbase;
- if (dbase_ro)
- delete dbase_ro;
-
-#if 0
- /*
- Free all MapChunks
- */
- core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
- for(; i.atEnd() == false; i++)
- {
- MapChunk *chunk = i.getNode()->getValue();
- delete chunk;
- }
-#endif
+ delete dbase_ro;
}
MapgenParams *ServerMap::getMapgenParams()
return getMapgenParams()->seed;
}
-s16 ServerMap::getWaterLevel()
-{
- return getMapgenParams()->water_level;
-}
-
bool ServerMap::blockpos_over_mapgen_limit(v3s16 p)
{
const s16 mapgen_limit_bp = rangelim(
v3s16 bpmin = EmergeManager::getContainingChunk(blockpos, csize);
v3s16 bpmax = bpmin + v3s16(1, 1, 1) * (csize - 1);
+ if (!m_chunks_in_progress.insert(bpmin).second)
+ return false;
+
bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
EMERGE_DBG_OUT("initBlockMake(): " PP(bpmin) " - " PP(bpmax));
data->seed = getSeed();
data->blockpos_min = bpmin;
data->blockpos_max = bpmax;
- data->blockpos_requested = blockpos;
data->nodedef = m_nodedef;
/*
data->vmanip = new MMVManip(this);
data->vmanip->initialEmerge(full_bpmin, full_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;
}
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));
NOTE: Will be saved later.
*/
//save(MOD_STATE_WRITE_AT_UNLOAD);
+ m_chunks_in_progress.erase(bpmin);
}
MapSector *ServerMap::createSector(v2s16 p2d)
/*
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)
+ if (blockpos_over_max_limit(v3s16(p2d.X, 0, p2d.Y)))
throw InvalidPositionException("createSector(): pos. over max mapgen limit");
/*
sector = new MapSector(this, p2d, m_gamedef);
- // Sector position on map in nodes
- //v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
-
/*
Insert to container
*/
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)
{
/*
return block;
}
+bool ServerMap::isBlockInQueue(v3s16 pos)
+{
+ return m_emerge && m_emerge->isBlockInQueue(pos);
+}
+
+void ServerMap::addNodeAndUpdate(v3s16 p, MapNode n,
+ std::map<v3s16, MapBlock*> &modified_blocks,
+ bool remove_metadata)
+{
+ Map::addNodeAndUpdate(p, n, modified_blocks, remove_metadata);
+
+ /*
+ 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);
+ }
+}
+
// 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)
vm->m_is_dirty = true;
}
-s16 ServerMap::findGroundLevel(v2s16 p2d)
-{
-#if 0
- /*
- Uh, just do something random...
- */
- // Find existing map from top to down
- s16 max=63;
- s16 min=-64;
- v3s16 p(p2d.X, max, p2d.Y);
- for(; p.Y>min; p.Y--)
- {
- MapNode n = getNodeNoEx(p);
- if(n.getContent() != CONTENT_IGNORE)
- break;
- }
- if(p.Y == min)
- goto plan_b;
- // If this node is not air, go to plan b
- if(getNodeNoEx(p).getContent() != CONTENT_AIR)
- goto plan_b;
- // Search existing walkable and return it
- for(; p.Y>min; p.Y--)
- {
- MapNode n = getNodeNoEx(p);
- if(content_walkable(n.d) && n.getContent() != CONTENT_IGNORE)
- return p.Y;
- }
-
- // Move to plan b
-plan_b:
-#endif
-
- /*
- Determine from map generator noise functions
- */
-
- s16 level = m_emerge->getGroundLevelAtPoint(p2d);
- return level;
-
- //double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
- //return (s16)level;
-}
-
-bool ServerMap::loadFromFolders() {
- if (!dbase->initialized() &&
- !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite"))
- return true;
- return false;
-}
-
-void ServerMap::createDirs(const std::string &path)
+void ServerMap::reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks)
{
- if (!fs::CreateAllDirs(path)) {
- m_dout<<"ServerMap: Failed to create directory "
- <<"\""<<path<<"\""<<std::endl;
- throw BaseException("ServerMap failed to create directory");
- }
-}
-
-std::string ServerMap::getSectorDir(v2s16 pos, int layout)
-{
- char cc[9];
- switch(layout)
- {
- case 1:
- porting::mt_snprintf(cc, sizeof(cc), "%.4x%.4x",
- (unsigned int) pos.X & 0xffff,
- (unsigned int) pos.Y & 0xffff);
-
- return m_savedir + DIR_DELIM + "sectors" + DIR_DELIM + cc;
- case 2:
- porting::mt_snprintf(cc, sizeof(cc), (std::string("%.3x") + DIR_DELIM + "%.3x").c_str(),
- (unsigned int) pos.X & 0xfff,
- (unsigned int) pos.Y & 0xfff);
-
- return m_savedir + DIR_DELIM + "sectors2" + DIR_DELIM + cc;
- default:
- assert(false);
- return "";
- }
-}
-
-v2s16 ServerMap::getSectorPos(const std::string &dirname)
-{
- unsigned int x = 0, y = 0;
- int r;
- std::string component;
- fs::RemoveLastPathComponent(dirname, &component, 1);
- if(component.size() == 8)
- {
- // Old layout
- r = sscanf(component.c_str(), "%4x%4x", &x, &y);
- }
- else if(component.size() == 3)
- {
- // New layout
- fs::RemoveLastPathComponent(dirname, &component, 2);
- r = sscanf(component.c_str(), (std::string("%3x") + DIR_DELIM + "%3x").c_str(), &x, &y);
- // Sign-extend the 12 bit values up to 16 bits...
- if(x & 0x800) x |= 0xF000;
- if(y & 0x800) y |= 0xF000;
- }
- else
- {
- r = -1;
- }
-
- FATAL_ERROR_IF(r != 2, "getSectorPos()");
- v2s16 pos((s16)x, (s16)y);
- return pos;
-}
-
-v3s16 ServerMap::getBlockPos(const std::string §ordir, const std::string &blockfile)
-{
- v2s16 p2d = getSectorPos(sectordir);
-
- if(blockfile.size() != 4){
- throw InvalidFilenameException("Invalid block filename");
- }
- unsigned int y;
- int r = sscanf(blockfile.c_str(), "%4x", &y);
- if(r != 1)
- throw InvalidFilenameException("Invalid block filename");
- return v3s16(p2d.X, y, p2d.Y);
-}
-
-std::string ServerMap::getBlockFilename(v3s16 p)
-{
- char cc[5];
- porting::mt_snprintf(cc, sizeof(cc), "%.4x", (unsigned int)p.Y&0xffff);
- return cc;
+ m_loaded_blocks_gauge->set(all_blocks);
+ m_save_time_counter->increment(save_time_us);
+ m_save_count_counter->increment(saved_blocks);
}
void ServerMap::save(ModifiedState save_level)
return;
}
+ const auto start_time = porting::getTimeUs();
+
if(save_level == MOD_STATE_CLEAN)
infostream<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
*/
if(save_level == MOD_STATE_CLEAN
|| block_count != 0) {
- infostream<<"ServerMap: Written: "
- <<block_count<<" block files"
- <<", "<<block_count_all<<" blocks in memory."
- <<std::endl;
+ 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);
}
+
+ const auto end_time = porting::getTimeUs();
+ reportMetrics(end_time - start_time, block_count, block_count_all);
}
void ServerMap::listAllLoadableBlocks(std::vector<v3s16> &dst)
{
- if (loadFromFolders()) {
- errorstream << "Map::listAllLoadableBlocks(): Result will be missing "
- << "all blocks that are stored in flat files." << std::endl;
- }
dbase->listAllLoadableBlocks(dst);
if (dbase_ro)
dbase_ro->listAllLoadableBlocks(dst);
}
-void ServerMap::listAllLoadedBlocks(std::vector<v3s16> &dst)
-{
- for (auto §or_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,
bool ServerMap::saveBlock(MapBlock *block)
{
- return saveBlock(block, dbase);
+ return saveBlock(block, dbase, m_map_compression_level);
}
-bool ServerMap::saveBlock(MapBlock *block, MapDatabase *db)
+bool ServerMap::saveBlock(MapBlock *block, MapDatabase *db, int compression_level)
{
v3s16 p3d = block->getPos();
*/
std::ostringstream o(std::ios_base::binary);
o.write((char*) &version, 1);
- block->serialize(o, version, true);
+ block->serialize(o, version, true, compression_level);
bool ret = db->saveBlock(p3d, o.str());
if (ret) {
return ret;
}
-void ServerMap::loadBlock(const std::string §ordir, const std::string &blockfile,
- MapSector *sector, bool save_after_load)
-{
- std::string fullpath = sectordir + DIR_DELIM + blockfile;
- try {
- std::ifstream is(fullpath.c_str(), std::ios_base::binary);
- if (!is.good())
- throw FileNotGoodException("Cannot open block file");
-
- v3s16 p3d = getBlockPos(sectordir, blockfile);
- v2s16 p2d(p3d.X, p3d.Z);
-
- assert(sector->getPos() == p2d);
-
- u8 version = SER_FMT_VER_INVALID;
- is.read((char*)&version, 1);
-
- if(is.fail())
- throw SerializationError("ServerMap::loadBlock(): Failed"
- " to read MapBlock version");
-
- /*u32 block_size = MapBlock::serializedLength(version);
- SharedBuffer<u8> data(block_size);
- is.read((char*)*data, block_size);*/
-
- // This will always return a sector because we're the server
- //MapSector *sector = emergeSector(p2d);
-
- MapBlock *block = NULL;
- bool created_new = false;
- 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_WRITE || 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.
- block->resetModified();
-
- }
- catch(SerializationError &e)
- {
- warningstream<<"Invalid block data on disk "
- <<"fullpath="<<fullpath
- <<" (SerializationError). "
- <<"what()="<<e.what()
- <<std::endl;
- // Ignoring. A new one will be generated.
- abort();
-
- // TODO: Backup file; name is in fullpath.
- }
-}
-
void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load)
{
try {
loadBlock(&ret, blockpos, createSector(p2d), false);
}
} else {
- // 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/
- // If we load from anything but the latest structure, we will
- // immediately save to the new one, and remove the old.
- std::string sectordir1 = getSectorDir(p2d, 1);
- std::string sectordir;
- if (fs::PathExists(sectordir1)) {
- sectordir = sectordir1;
- } else {
- sectordir = getSectorDir(p2d, 2);
- }
-
- /*
- Make sure sector is loaded
- */
-
- MapSector *sector = getSectorNoGenerate(p2d);
-
- /*
- Make sure file exists
- */
-
- std::string blockfilename = getBlockFilename(blockpos);
- if (!fs::PathExists(sectordir + DIR_DELIM + blockfilename))
- return NULL;
-
- /*
- Load block and save it to the database
- */
- loadBlock(sectordir, blockfilename, sector, true);
+ return NULL;
}
MapBlock *block = getBlockNoCreateNoEx(blockpos);
for (it = modified_blocks.begin();
it != modified_blocks.end(); ++it)
event.modified_blocks.insert(it->first);
- dispatchEvent(&event);
+ dispatchEvent(event);
}
}
return block;
VoxelManipulator(),
m_map(map)
{
+ assert(map);
}
void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
{
TimeTaker timer1("initialEmerge", &emerge_time);
+ assert(m_map);
+
// Units of these are MapBlocks
v3s16 p_min = blockpos_min;
v3s16 p_max = blockpos_max;
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
+ assert(m_map);
/*
Copy data of all blocks
}
}
+MMVManip *MMVManip::clone() const
+{
+ MMVManip *ret = new MMVManip();
+
+ const s32 size = m_area.getVolume();
+ ret->m_area = m_area;
+ if (m_data) {
+ ret->m_data = new MapNode[size];
+ memcpy(ret->m_data, m_data, size * sizeof(MapNode));
+ }
+ if (m_flags) {
+ ret->m_flags = new u8[size];
+ memcpy(ret->m_flags, m_flags, size * sizeof(u8));
+ }
+
+ ret->m_is_dirty = m_is_dirty;
+ // Even if the copy is disconnected from a map object keep the information
+ // needed to write it back to one
+ ret->m_loaded_blocks = m_loaded_blocks;
+
+ return ret;
+}
+
+void MMVManip::reparent(Map *map)
+{
+ assert(map && !m_map);
+ m_map = map;
+}
+
//END