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);
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
- return block && block->getIsUnderground();
+ return block && block->getIsUnderground();
}
bool Map::isValidPosition(v3s16 p)
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){
bool temp_bool;
errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
succeeded = false;
}
- dispatchEvent(&event);
+ dispatchEvent(event);
return succeeded;
}
succeeded = false;
}
- dispatchEvent(&event);
+ dispatchEvent(event);
return succeeded;
}
#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,
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
block->m_node_timers.remove(p_rel);
}
-bool Map::isOccluded(v3s16 p0, v3s16 p1, float step, float stepfac,
- float start_off, float end_off, u32 needed_count)
+bool Map::determineAdditionalOcclusionCheck(const v3s16 &pos_camera,
+ const core::aabbox3d<s16> &block_bounds, v3s16 &check)
{
- float d0 = (float)BS * p0.getDistanceFrom(p1);
- v3s16 u0 = p1 - p0;
- v3f uf = v3f(u0.X, u0.Y, u0.Z) * BS;
- uf.normalize();
- v3f p0f = v3f(p0.X, p0.Y, p0.Z) * BS;
+ /*
+ This functions determines the node inside the target block that is
+ closest to the camera position. This increases the occlusion culling
+ accuracy in straight and diagonal corridors.
+ The returned position will be occlusion checked first in addition to the
+ others (8 corners + center).
+ No position is returned if
+ - the closest node is a corner, corners are checked anyway.
+ - the camera is inside the target block, it will never be occluded.
+ */
+#define CLOSEST_EDGE(pos, bounds, axis) \
+ ((pos).axis <= (bounds).MinEdge.axis) ? (bounds).MinEdge.axis : \
+ (bounds).MaxEdge.axis
+
+ bool x_inside = (block_bounds.MinEdge.X <= pos_camera.X) &&
+ (pos_camera.X <= block_bounds.MaxEdge.X);
+ bool y_inside = (block_bounds.MinEdge.Y <= pos_camera.Y) &&
+ (pos_camera.Y <= block_bounds.MaxEdge.Y);
+ bool z_inside = (block_bounds.MinEdge.Z <= pos_camera.Z) &&
+ (pos_camera.Z <= block_bounds.MaxEdge.Z);
+
+ if (x_inside && y_inside && z_inside)
+ return false; // Camera inside target mapblock
+
+ // straight
+ if (x_inside && y_inside) {
+ check = v3s16(pos_camera.X, pos_camera.Y, 0);
+ check.Z = CLOSEST_EDGE(pos_camera, block_bounds, Z);
+ return true;
+ } else if (y_inside && z_inside) {
+ check = v3s16(0, pos_camera.Y, pos_camera.Z);
+ check.X = CLOSEST_EDGE(pos_camera, block_bounds, X);
+ return true;
+ } else if (x_inside && z_inside) {
+ check = v3s16(pos_camera.X, 0, pos_camera.Z);
+ check.Y = CLOSEST_EDGE(pos_camera, block_bounds, Y);
+ return true;
+ }
+
+ // diagonal
+ if (x_inside) {
+ check = v3s16(pos_camera.X, 0, 0);
+ check.Y = CLOSEST_EDGE(pos_camera, block_bounds, Y);
+ check.Z = CLOSEST_EDGE(pos_camera, block_bounds, Z);
+ return true;
+ } else if (y_inside) {
+ check = v3s16(0, pos_camera.Y, 0);
+ check.X = CLOSEST_EDGE(pos_camera, block_bounds, X);
+ check.Z = CLOSEST_EDGE(pos_camera, block_bounds, Z);
+ return true;
+ } else if (z_inside) {
+ check = v3s16(0, 0, pos_camera.Z);
+ check.X = CLOSEST_EDGE(pos_camera, block_bounds, X);
+ check.Y = CLOSEST_EDGE(pos_camera, block_bounds, Y);
+ return true;
+ }
+
+ // Closest node would be a corner, none returned
+ return false;
+}
+
+bool Map::isOccluded(const v3s16 &pos_camera, const v3s16 &pos_target,
+ float step, float stepfac, float offset, float end_offset, u32 needed_count)
+{
+ v3f direction = intToFloat(pos_target - pos_camera, BS);
+ float distance = direction.getLength();
+
+ // Normalize direction vector
+ if (distance > 0.0f)
+ direction /= distance;
+
+ v3f pos_origin_f = intToFloat(pos_camera, BS);
u32 count = 0;
- for(float s=start_off; s<d0+end_off; s+=step){
- v3f pf = p0f + uf * s;
- v3s16 p = floatToInt(pf, BS);
- MapNode n = getNode(p);
- const ContentFeatures &f = m_nodedef->get(n);
- if(f.drawtype == NDT_NORMAL){
- // not transparent, see ContentFeature::updateTextures
+ bool is_valid_position;
+
+ for (; offset < distance + end_offset; offset += step) {
+ v3f pos_node_f = pos_origin_f + direction * offset;
+ v3s16 pos_node = floatToInt(pos_node_f, BS);
+
+ MapNode node = getNode(pos_node, &is_valid_position);
+
+ if (is_valid_position &&
+ !m_nodedef->get(node).light_propagates) {
+ // Cannot see through light-blocking nodes --> occluded
count++;
- if(count >= needed_count)
+ if (count >= needed_count)
return true;
}
step *= stepfac;
return false;
}
-bool Map::isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes) {
- v3s16 cpn = block->getPos() * MAP_BLOCKSIZE;
- cpn += v3s16(MAP_BLOCKSIZE / 2, MAP_BLOCKSIZE / 2, MAP_BLOCKSIZE / 2);
- float step = BS * 1;
- float stepfac = 1.1;
- float startoff = BS * 1;
+bool Map::isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes)
+{
+ // Check occlusion for center and all 8 corners of the mapblock
+ // Overshoot a little for less flickering
+ static const s16 bs2 = MAP_BLOCKSIZE / 2 + 1;
+ static const v3s16 dir9[9] = {
+ v3s16( 0, 0, 0),
+ v3s16( 1, 1, 1) * bs2,
+ v3s16( 1, 1, -1) * bs2,
+ v3s16( 1, -1, 1) * bs2,
+ v3s16( 1, -1, -1) * bs2,
+ v3s16(-1, 1, 1) * bs2,
+ v3s16(-1, 1, -1) * bs2,
+ v3s16(-1, -1, 1) * bs2,
+ v3s16(-1, -1, -1) * bs2,
+ };
+
+ v3s16 pos_blockcenter = block->getPosRelative() + (MAP_BLOCKSIZE / 2);
+
+ // Starting step size, value between 1m and sqrt(3)m
+ float step = BS * 1.2f;
+ // Multiply step by each iteraction by 'stepfac' to reduce checks in distance
+ float stepfac = 1.05f;
+
+ float start_offset = BS * 1.0f;
+
// The occlusion search of 'isOccluded()' must stop short of the target
- // point by distance 'endoff' (end offset) to not enter the target mapblock.
- // For the 8 mapblock corners 'endoff' must therefore be the maximum diagonal
- // of a mapblock, because we must consider all view angles.
+ // point by distance 'end_offset' to not enter the target mapblock.
+ // For the 8 mapblock corners 'end_offset' must therefore be the maximum
+ // diagonal of a mapblock, because we must consider all view angles.
// sqrt(1^2 + 1^2 + 1^2) = 1.732
- float endoff = -BS * MAP_BLOCKSIZE * 1.732050807569;
- s16 bs2 = MAP_BLOCKSIZE / 2 + 1;
+ float end_offset = -BS * MAP_BLOCKSIZE * 1.732f;
+
// to reduce the likelihood of falsely occluded blocks
// require at least two solid blocks
// this is a HACK, we should think of a more precise algorithm
u32 needed_count = 2;
- return (
- // For the central point of the mapblock 'endoff' can be halved
- isOccluded(cam_pos_nodes, cpn,
- step, stepfac, startoff, endoff / 2.0f, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(bs2,bs2,bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(bs2,bs2,-bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(bs2,-bs2,bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(bs2,-bs2,-bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,bs2,bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,bs2,-bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,-bs2,bs2),
- step, stepfac, startoff, endoff, needed_count) &&
- isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,-bs2,-bs2),
- step, stepfac, startoff, endoff, needed_count));
+ // Additional occlusion check, see comments in that function
+ v3s16 check;
+ if (determineAdditionalOcclusionCheck(cam_pos_nodes, block->getBox(), check)) {
+ // node is always on a side facing the camera, end_offset can be lower
+ if (!isOccluded(cam_pos_nodes, check, step, stepfac, start_offset,
+ -1.0f, needed_count))
+ return false;
+ }
+
+ for (const v3s16 &dir : dir9) {
+ if (!isOccluded(cam_pos_nodes, pos_blockcenter + dir, step, stepfac,
+ start_offset, end_offset, needed_count))
+ return false;
+ }
+ return true;
}
/*
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_core_map_save_time", "Map save time (in nanoseconds)");
+
+ 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)
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);
+}
+
// 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)
-{
- 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;
-}
-
void ServerMap::save(ModifiedState save_level)
{
if (!m_map_saving_enabled) {
return;
}
+ u64 start_time = porting::getTimeNs();
+
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);
}
+
+ auto end_time = porting::getTimeNs();
+ m_save_time_counter->increment(end_time - start_time);
}
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);
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;
projects / dragonfireclient.git / blobdiff