Map
*/
-Map::Map(std::ostream &dout, IGameDef *gamedef):
- m_dout(dout),
+Map::Map(IGameDef *gamedef):
m_gamedef(gamedef),
m_nodedef(gamedef->ndef())
{
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 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,
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;
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)) {
*/
delete dbase;
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
}
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)
+void ServerMap::reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks)
{
-#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;
-}
-
-void ServerMap::createDirs(const std::string &path)
-{
- if (!fs::CreateAllDirs(path)) {
- m_dout<<"ServerMap: Failed to create directory "
- <<"\""<<path<<"\""<<std::endl;
- throw BaseException("ServerMap failed to create directory");
- }
+ 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)
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) {
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