X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=6d53351efeed2b1bc15ae8f773823063fff4686a;hb=89995efee487939d47e852d35a777e5dcfc28f35;hp=3c135cd4843f151d36086d16c18110131986f6b5;hpb=2829742ae8869276f000bdb64a9f14977e70038b;p=dragonfireclient.git diff --git a/src/map.cpp b/src/map.cpp index 3c135cd48..6d53351ef 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -32,44 +32,39 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "nodedef.h" #include "gamedef.h" #include "util/directiontables.h" -#include "util/mathconstants.h" +#include "util/basic_macros.h" #include "rollback_interface.h" #include "environment.h" +#include "reflowscan.h" #include "emerge.h" -#include "mapgen_v6.h" -#include "mg_biome.h" +#include "mapgen/mapgen_v6.h" +#include "mapgen/mg_biome.h" #include "config.h" #include "server.h" -#include "database.h" -#include "database-dummy.h" -#include "database-sqlite3.h" +#include "database/database.h" +#include "database/database-dummy.h" +#include "database/database-sqlite3.h" +#include "script/scripting_server.h" #include #include #if USE_LEVELDB -#include "database-leveldb.h" +#include "database/database-leveldb.h" #endif #if USE_REDIS -#include "database-redis.h" +#include "database/database-redis.h" #endif #if USE_POSTGRESQL -#include "database-postgresql.h" +#include "database/database-postgresql.h" #endif -#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")" - /* Map */ -Map::Map(std::ostream &dout, IGameDef *gamedef): - m_dout(dout), +Map::Map(IGameDef *gamedef): m_gamedef(gamedef), - 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) + m_nodedef(gamedef->ndef()) { } @@ -78,10 +73,8 @@ Map::~Map() /* Free all MapSectors */ - for(std::map::iterator i = m_sectors.begin(); - i != m_sectors.end(); ++i) - { - delete i->second; + for (auto §or : m_sectors) { + delete sector.second; } } @@ -95,17 +88,14 @@ void Map::removeEventReceiver(MapEventReceiver *event_receiver) m_event_receivers.erase(event_receiver); } -void Map::dispatchEvent(MapEditEvent *event) +void Map::dispatchEvent(const MapEditEvent &event) { - for(std::set::iterator - i = m_event_receivers.begin(); - i != m_event_receivers.end(); ++i) - { - (*i)->onMapEditEvent(event); + for (MapEventReceiver *event_receiver : m_event_receivers) { + event_receiver->onMapEditEvent(event); } } -MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p) +MapSector * Map::getSectorNoGenerateNoLock(v2s16 p) { if(m_sector_cache != NULL && p == m_sector_cache_p){ MapSector * sector = m_sector_cache; @@ -114,7 +104,7 @@ MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p) std::map::iterator n = m_sectors.find(p); - if(n == m_sectors.end()) + if (n == m_sectors.end()) return NULL; MapSector *sector = n->second; @@ -126,24 +116,15 @@ MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p) return sector; } -MapSector * Map::getSectorNoGenerateNoEx(v2s16 p) -{ - return getSectorNoGenerateNoExNoLock(p); -} - MapSector * Map::getSectorNoGenerate(v2s16 p) { - MapSector *sector = getSectorNoGenerateNoEx(p); - if(sector == NULL) - throw InvalidPositionException(); - - return sector; + return getSectorNoGenerateNoLock(p); } MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d) { v2s16 p2d(p3d.X, p3d.Z); - MapSector * sector = getSectorNoGenerateNoEx(p2d); + MapSector * sector = getSectorNoGenerate(p2d); if(sector == NULL) return NULL; MapBlock *block = sector->getBlockNoCreateNoEx(p3d.Y); @@ -158,17 +139,26 @@ MapBlock * Map::getBlockNoCreate(v3s16 p3d) return block; } +void Map::listAllLoadedBlocks(std::vector &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); + } + } +} + bool Map::isNodeUnderground(v3s16 p) { v3s16 blockpos = getNodeBlockPos(p); - try{ - MapBlock * block = getBlockNoCreate(blockpos); - return block->getIsUnderground(); - } - catch(InvalidPositionException &e) - { - return false; - } + MapBlock *block = getBlockNoCreateNoEx(blockpos); + return block && block->getIsUnderground(); } bool Map::isValidPosition(v3s16 p) @@ -179,14 +169,14 @@ bool Map::isValidPosition(v3s16 p) } // Returns a CONTENT_IGNORE node if not found -MapNode Map::getNodeNoEx(v3s16 p, bool *is_valid_position) +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 MapNode(CONTENT_IGNORE); + return {CONTENT_IGNORE}; } v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; @@ -197,626 +187,33 @@ MapNode Map::getNodeNoEx(v3s16 p, bool *is_valid_position) return node; } -#if 0 -// Deprecated -// throws InvalidPositionException if not found -// TODO: Now this is deprecated, getNodeNoEx should be renamed -MapNode Map::getNode(v3s16 p) -{ - v3s16 blockpos = getNodeBlockPos(p); - MapBlock *block = getBlockNoCreateNoEx(blockpos); - if (block == NULL) - throw InvalidPositionException(); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - bool is_valid_position; - MapNode node = block->getNodeNoCheck(relpos, &is_valid_position); - if (!is_valid_position) - throw InvalidPositionException(); - return node; -} -#endif - // 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 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" <<" while trying to replace \"" - <ndef()->get(block->getNodeNoCheck(relpos, &temp_bool)).name + <get(block->getNodeNoCheck(relpos, &temp_bool)).name <<"\" at "<setNodeNoCheck(relpos, n); } -/* - Goes recursively through the neighbours of the node. - - Alters only transparent nodes. - - If the lighting of the neighbour is lower than the lighting of - the node was (before changing it to 0 at the step before), the - lighting of the neighbour is set to 0 and then the same stuff - repeats for the neighbour. - - The ending nodes of the routine are stored in light_sources. - This is useful when a light is removed. In such case, this - routine can be called for the light node and then again for - light_sources to re-light the area without the removed light. - - values of from_nodes are lighting values. -*/ -void Map::unspreadLight(enum LightBank bank, - std::map & from_nodes, - std::set & light_sources, - std::map & modified_blocks) -{ - INodeDefManager *nodemgr = m_gamedef->ndef(); - - v3s16 dirs[6] = { - v3s16(0,0,1), // back - v3s16(0,1,0), // top - v3s16(1,0,0), // right - v3s16(0,0,-1), // front - v3s16(0,-1,0), // bottom - v3s16(-1,0,0), // left - }; - - if(from_nodes.empty()) - return; - - u32 blockchangecount = 0; - - std::map unlighted_nodes; - - /* - Initialize block cache - */ - v3s16 blockpos_last; - MapBlock *block = NULL; - // Cache this a bit, too - bool block_checked_in_modified = false; - - for(std::map::iterator j = from_nodes.begin(); - j != from_nodes.end(); ++j) - { - v3s16 pos = j->first; - v3s16 blockpos = getNodeBlockPos(pos); - - // Only fetch a new block if the block position has changed - try{ - if(block == NULL || blockpos != blockpos_last){ - block = getBlockNoCreate(blockpos); - blockpos_last = blockpos; - - block_checked_in_modified = false; - blockchangecount++; - } - } - catch(InvalidPositionException &e) - { - continue; - } - - if(block->isDummy()) - continue; - - // Calculate relative position in block - //v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE; - - // Get node straight from the block - //MapNode n = block->getNode(relpos); - - u8 oldlight = j->second; - - // Loop through 6 neighbors - for(u16 i=0; i<6; i++) - { - // Get the position of the neighbor node - v3s16 n2pos = pos + dirs[i]; - - // Get the block where the node is located - v3s16 blockpos, relpos; - getNodeBlockPosWithOffset(n2pos, blockpos, relpos); - - // Only fetch a new block if the block position has changed - try { - if(block == NULL || blockpos != blockpos_last){ - block = getBlockNoCreate(blockpos); - blockpos_last = blockpos; - - block_checked_in_modified = false; - blockchangecount++; - } - } - catch(InvalidPositionException &e) { - continue; - } - - // Get node straight from the block - bool is_valid_position; - MapNode n2 = block->getNode(relpos, &is_valid_position); - if (!is_valid_position) - continue; - - bool changed = false; - - //TODO: Optimize output by optimizing light_sources? - - /* - If the neighbor is dimmer than what was specified - as oldlight (the light of the previous node) - */ - if(n2.getLight(bank, nodemgr) < oldlight) - { - /* - And the neighbor is transparent and it has some light - */ - if(nodemgr->get(n2).light_propagates - && n2.getLight(bank, nodemgr) != 0) - { - /* - Set light to 0 and add to queue - */ - - u8 current_light = n2.getLight(bank, nodemgr); - n2.setLight(bank, 0, nodemgr); - block->setNode(relpos, n2); - - unlighted_nodes[n2pos] = current_light; - changed = true; - - /* - Remove from light_sources if it is there - NOTE: This doesn't happen nearly at all - */ - /*if(light_sources.find(n2pos)) - { - infostream<<"Removed from light_sources"< & from_nodes, - std::map & modified_blocks) -{ - INodeDefManager *nodemgr = m_gamedef->ndef(); - - const v3s16 dirs[6] = { - v3s16(0,0,1), // back - v3s16(0,1,0), // top - v3s16(1,0,0), // right - v3s16(0,0,-1), // front - v3s16(0,-1,0), // bottom - v3s16(-1,0,0), // left - }; - - if(from_nodes.empty()) - return; - - u32 blockchangecount = 0; - - std::set lighted_nodes; - - /* - Initialize block cache - */ - v3s16 blockpos_last; - MapBlock *block = NULL; - // Cache this a bit, too - bool block_checked_in_modified = false; - - for(std::set::iterator j = from_nodes.begin(); - j != from_nodes.end(); ++j) - { - v3s16 pos = *j; - v3s16 blockpos, relpos; - - getNodeBlockPosWithOffset(pos, blockpos, relpos); - - // Only fetch a new block if the block position has changed - try { - if(block == NULL || blockpos != blockpos_last){ - block = getBlockNoCreate(blockpos); - blockpos_last = blockpos; - - block_checked_in_modified = false; - blockchangecount++; - } - } - catch(InvalidPositionException &e) { - continue; - } - - if(block->isDummy()) - continue; - - // Get node straight from the block - bool is_valid_position; - MapNode n = block->getNode(relpos, &is_valid_position); - - u8 oldlight = is_valid_position ? n.getLight(bank, nodemgr) : 0; - u8 newlight = diminish_light(oldlight); - - // Loop through 6 neighbors - for(u16 i=0; i<6; i++){ - // Get the position of the neighbor node - v3s16 n2pos = pos + dirs[i]; - - // Get the block where the node is located - v3s16 blockpos, relpos; - getNodeBlockPosWithOffset(n2pos, blockpos, relpos); - - // Only fetch a new block if the block position has changed - try { - if(block == NULL || blockpos != blockpos_last){ - block = getBlockNoCreate(blockpos); - blockpos_last = blockpos; - - block_checked_in_modified = false; - blockchangecount++; - } - } - catch(InvalidPositionException &e) { - continue; - } - - // Get node straight from the block - MapNode n2 = block->getNode(relpos, &is_valid_position); - if (!is_valid_position) - continue; - - bool changed = false; - /* - If the neighbor is brighter than the current node, - add to list (it will light up this node on its turn) - */ - if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight)) - { - lighted_nodes.insert(n2pos); - changed = true; - } - /* - If the neighbor is dimmer than how much light this node - would spread on it, add to list - */ - if(n2.getLight(bank, nodemgr) < newlight) - { - if(nodemgr->get(n2).light_propagates) - { - n2.setLight(bank, newlight, nodemgr); - block->setNode(relpos, n2); - lighted_nodes.insert(n2pos); - changed = true; - } - } - - // Add to modified_blocks - if(changed == true && block_checked_in_modified == false) - { - // If the block is not found in modified_blocks, add. - if(modified_blocks.find(blockpos) == modified_blocks.end()) - { - modified_blocks[blockpos] = block; - } - block_checked_in_modified = true; - } - } - } - - /*infostream<<"spreadLight(): Changed block " - < & a_blocks, - std::map & modified_blocks) -{ - INodeDefManager *nodemgr = m_gamedef->ndef(); - - /*m_dout<<"Map::updateLighting(): " - < blocks_to_update; - - std::set light_sources; - - std::map unlight_from; - - int num_bottom_invalid = 0; - - { - //TimeTaker t("first stuff"); - - for(std::map::iterator i = a_blocks.begin(); - i != a_blocks.end(); ++i) - { - MapBlock *block = i->second; - - for(;;) - { - // Don't bother with dummy blocks. - if(block->isDummy()) - break; - - v3s16 pos = block->getPos(); - v3s16 posnodes = block->getPosRelative(); - modified_blocks[pos] = block; - //blocks_to_update[pos] = block; - - /* - Clear all light from block - */ - for(s16 z=0; zgetNode(p, &is_valid_position); - if (!is_valid_position) { - /* This would happen when dealing with a - dummy block. - */ - infostream<<"updateLighting(): InvalidPositionException" - <setNode(p, n); - - // If node sources light, add to list - u8 source = nodemgr->get(n).light_source; - if(source != 0) - light_sources.insert(p + posnodes); - - // Collect borders for unlighting - if((x==0 || x == MAP_BLOCKSIZE-1 - || y==0 || y == MAP_BLOCKSIZE-1 - || z==0 || z == MAP_BLOCKSIZE-1) - && oldlight != 0) - { - v3s16 p_map = p + posnodes; - unlight_from[p_map] = oldlight; - } - - - } - - if(bank == LIGHTBANK_DAY) - { - bool bottom_valid = block->propagateSunlight(light_sources); - - if(!bottom_valid) - num_bottom_invalid++; - - // If bottom is valid, we're done. - if(bottom_valid) - break; - } - else if(bank == LIGHTBANK_NIGHT) - { - // For night lighting, sunlight is not propagated - break; - } - else - { - assert("Invalid lighting bank" == NULL); - } - - /*infostream<<"Bottom for sunlight-propagated block (" - <get("")) - { - core::map::Iterator i; - i = blocks_to_update.getIterator(); - for(; i.atEnd() == false; i++) - { - MapBlock *block = i.getNode()->getValue(); - v3s16 p = block->getPos(); - block->setLightingExpired(false); - } - return; - } -#endif - -#if 1 - { - //TimeTaker timer("unspreadLight"); - unspreadLight(bank, unlight_from, light_sources, modified_blocks); - } - - /*if(debug) - { - u32 diff = modified_blocks.size() - count_was; - count_was = modified_blocks.size(); - infostream<<"unspreadLight modified "<::Iterator i; - i = blocks_to_update.getIterator(); - for(; i.atEnd() == false; i++) - { - MapBlock *block = i.getNode()->getValue(); - v3s16 p = block->getPos(); - - // Add all surrounding blocks - vmanip.initialEmerge(p - v3s16(1,1,1), p + v3s16(1,1,1)); - - /* - Add all surrounding blocks that have up-to-date lighting - NOTE: This doesn't quite do the job (not everything - appropriate is lighted) - */ - /*for(s16 z=-1; z<=1; z++) - for(s16 y=-1; y<=1; y++) - for(s16 x=-1; x<=1; x++) - { - v3s16 p2 = p + v3s16(x,y,z); - MapBlock *block = getBlockNoCreateNoEx(p2); - if(block == NULL) - continue; - if(block->isDummy()) - continue; - if(block->getLightingExpired()) - continue; - vmanip.initialEmerge(p2, p2); - }*/ - - // Lighting of block will be updated completely - block->setLightingExpired(false); - } - } - - { - //TimeTaker timer("unSpreadLight"); - vmanip.unspreadLight(bank, unlight_from, light_sources, nodemgr); - } - { - //TimeTaker timer("spreadLight"); - vmanip.spreadLight(bank, light_sources, nodemgr); - } - { - //TimeTaker timer("blitBack"); - vmanip.blitBack(modified_blocks); - } - /*infostream<<"emerge_time="< & a_blocks, - std::map & modified_blocks) -{ - updateLighting(LIGHTBANK_DAY, a_blocks, modified_blocks); - updateLighting(LIGHTBANK_NIGHT, a_blocks, modified_blocks); - - /* - Update information about whether day and night light differ - */ - for(std::map::iterator - i = modified_blocks.begin(); - i != modified_blocks.end(); ++i) - { - MapBlock *block = i->second; - block->expireDayNightDiff(); - } -} - void Map::addNodeAndUpdate(v3s16 p, MapNode n, std::map &modified_blocks, bool remove_metadata) { - INodeDefManager *ndef = m_gamedef->ndef(); - // Collect old node for rollback RollbackNode rollback_oldnode(this, p, m_gamedef); // This is needed for updating the lighting - MapNode oldnode = getNodeNoEx(p); + MapNode oldnode = getNode(p); // Remove node metadata if (remove_metadata) { @@ -825,20 +222,17 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, // Set the node on the map // Ignore light (because calling voxalgo::update_lighting_nodes) - n.setLight(LIGHTBANK_DAY, 0, ndef); - n.setLight(LIGHTBANK_NIGHT, 0, ndef); + n.setLight(LIGHTBANK_DAY, 0, m_nodedef); + n.setLight(LIGHTBANK_NIGHT, 0, m_nodedef); setNode(p, n); // Update lighting std::vector > oldnodes; - oldnodes.push_back(std::pair(p, oldnode)); - voxalgo::update_lighting_nodes(this, ndef, oldnodes, modified_blocks); + oldnodes.emplace_back(p, oldnode); + voxalgo::update_lighting_nodes(this, oldnodes, modified_blocks); - for(std::map::iterator - i = modified_blocks.begin(); - i != modified_blocks.end(); ++i) - { - i->second->expireDayNightDiff(); + for (auto &modified_block : modified_blocks) { + modified_block.second->expireDayNightDiff(); } // Report for rollback @@ -854,26 +248,16 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, 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.) */ - v3s16 dirs[7] = { - v3s16(0,0,1), // back - v3s16(0,1,0), // top - v3s16(1,0,0), // right - v3s16(0,0,-1), // front - v3s16(0,-1,0), // bottom - v3s16(-1,0,0), // left - v3s16(0,0,0), // self - }; - for(u16 i=0; i<7; i++) - { - v3s16 p2 = p + dirs[i]; + + for (const v3s16 &dir : g_7dirs) { + v3s16 p2 = p + dir; bool is_valid_position; - MapNode n2 = getNodeNoEx(p2, &is_valid_position); - if(is_valid_position - && (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)) - { + 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); - } } } @@ -896,18 +280,15 @@ bool Map::addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata) addNodeAndUpdate(p, n, modified_blocks, remove_metadata); // Copy modified_blocks to event - for(std::map::iterator - i = modified_blocks.begin(); - i != modified_blocks.end(); ++i) - { - event.modified_blocks.insert(i->first); + for (auto &modified_block : modified_blocks) { + event.modified_blocks.insert(modified_block.first); } } catch(InvalidPositionException &e){ succeeded = false; } - dispatchEvent(&event); + dispatchEvent(event); return succeeded; } @@ -924,79 +305,19 @@ bool Map::removeNodeWithEvent(v3s16 p) removeNodeAndUpdate(p, modified_blocks); // Copy modified_blocks to event - for(std::map::iterator - i = modified_blocks.begin(); - i != modified_blocks.end(); ++i) - { - event.modified_blocks.insert(i->first); + for (auto &modified_block : modified_blocks) { + event.modified_blocks.insert(modified_block.first); } } catch(InvalidPositionException &e){ succeeded = false; } - dispatchEvent(&event); + dispatchEvent(event); return succeeded; } -bool Map::getDayNightDiff(v3s16 blockpos) -{ - try{ - v3s16 p = blockpos + v3s16(0,0,0); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - // Leading edges - try{ - v3s16 p = blockpos + v3s16(-1,0,0); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,-1,0); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,0,-1); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - // Trailing edges - try{ - v3s16 p = blockpos + v3s16(1,0,0); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,1,0); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,0,1); - MapBlock *b = getBlockNoCreate(p); - if(b->getDayNightDiff()) - return true; - } - catch(InvalidPositionException &e){} - - return false; -} - struct TimeOrderedMapBlock { MapSector *sect; MapBlock *block; @@ -1032,19 +353,15 @@ void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks, // If there is no practical limit, we spare creation of mapblock_queue if (max_loaded_blocks == U32_MAX) { - for (std::map::iterator si = m_sectors.begin(); - si != m_sectors.end(); ++si) { - MapSector *sector = si->second; + for (auto §or_it : m_sectors) { + MapSector *sector = sector_it.second; bool all_blocks_deleted = true; MapBlockVect blocks; sector->getBlocks(blocks); - for (MapBlockVect::iterator i = blocks.begin(); - i != blocks.end(); ++i) { - MapBlock *block = (*i); - + for (MapBlock *block : blocks) { block->incrementUsageTimer(dtime); if (block->refGet() == 0 @@ -1074,22 +391,18 @@ void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks, } if (all_blocks_deleted) { - sector_deletion_queue.push_back(si->first); + sector_deletion_queue.push_back(sector_it.first); } } } else { std::priority_queue mapblock_queue; - for (std::map::iterator si = m_sectors.begin(); - si != m_sectors.end(); ++si) { - MapSector *sector = si->second; + for (auto §or_it : m_sectors) { + MapSector *sector = sector_it.second; MapBlockVect blocks; sector->getBlocks(blocks); - for(MapBlockVect::iterator i = blocks.begin(); - i != blocks.end(); ++i) { - MapBlock *block = (*i); - + for (MapBlock *block : blocks) { block->incrementUsageTimer(dtime); mapblock_queue.push(TimeOrderedMapBlock(sector, block)); } @@ -1126,10 +439,9 @@ void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks, block_count_all--; } // Delete empty sectors - for (std::map::iterator si = m_sectors.begin(); - si != m_sectors.end(); ++si) { - if (si->second->empty()) { - sector_deletion_queue.push_back(si->first); + for (auto §or_it : m_sectors) { + if (sector_it.second->empty()) { + sector_deletion_queue.push_back(sector_it.first); } } } @@ -1162,14 +474,13 @@ void Map::unloadUnreferencedBlocks(std::vector *unloaded_blocks) void Map::deleteSectors(std::vector §orList) { - for(std::vector::iterator j = sectorList.begin(); - j != sectorList.end(); ++j) { - MapSector *sector = m_sectors[*j]; + 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); + m_sectors.erase(j); delete sector; } } @@ -1181,22 +492,32 @@ void Map::PrintInfo(std::ostream &out) #define WATER_DROP_BOOST 4 -enum NeighborType { +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; - bool l; //can liquid NodeNeighbor() - : n(CONTENT_AIR) + : n(CONTENT_AIR), t(NEIGHBOR_SAME_LEVEL) { } - NodeNeighbor(const MapNode &node, NeighborType n_type, v3s16 pos) + NodeNeighbor(const MapNode &node, NeighborType n_type, const v3s16 &pos) : n(node), t(n_type), p(pos) @@ -1207,18 +528,9 @@ void Map::transforming_liquid_add(v3s16 p) { m_transforming_liquid.push_back(p); } -s32 Map::transforming_liquid_size() { - return m_transforming_liquid.size(); -} - -void Map::transformLiquids(std::map &modified_blocks) +void Map::transformLiquids(std::map &modified_blocks, + ServerEnvironment *env) { - - INodeDefManager *nodemgr = m_gamedef->ndef(); - - DSTACK(FUNCTION_NAME); - //TimeTaker timer("transformLiquids()"); - u32 loopcount = 0; u32 initial_size = m_transforming_liquid.size(); @@ -1263,7 +575,7 @@ void Map::transformLiquids(std::map &modified_blocks) v3s16 p0 = m_transforming_liquid.front(); m_transforming_liquid.pop_front(); - MapNode n0 = getNodeNoEx(p0); + MapNode n0 = getNode(p0); /* Collect information about current node @@ -1275,12 +587,12 @@ void Map::transformLiquids(std::map &modified_blocks) // The node which will be placed there if liquid // can't flow into this node. content_t floodable_node = CONTENT_AIR; - const ContentFeatures &cf = nodemgr->get(n0); + const ContentFeatures &cf = m_nodedef->get(n0); LiquidType liquid_type = cf.liquid_type; switch (liquid_type) { case LIQUID_SOURCE: liquid_level = LIQUID_LEVEL_SOURCE; - liquid_kind = nodemgr->getId(cf.liquid_alternative_flowing); + liquid_kind = cf.liquid_alternative_flowing_id; break; case LIQUID_FLOWING: liquid_level = (n0.param2 & LIQUID_LEVEL_MASK); @@ -1299,7 +611,6 @@ void Map::transformLiquids(std::map &modified_blocks) /* 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 @@ -1309,20 +620,23 @@ void Map::transformLiquids(std::map &modified_blocks) NodeNeighbor neutrals[6]; // nodes that are solid or another kind of liquid int num_neutrals = 0; bool flowing_down = false; + bool ignored_sources = false; 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]; - NodeNeighbor nb(getNodeNoEx(npos), nt, npos); - const ContentFeatures &cfnb = nodemgr->get(nb.n); - switch (nodemgr->get(nb.n.getContent()).liquid_type) { + 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_NONE: if (cfnb.floodable) { airs[num_airs++] = nb; @@ -1336,29 +650,38 @@ void Map::transformLiquids(std::map &modified_blocks) flowing_down = true; } else { neutrals[num_neutrals++] = nb; - // If neutral below is ignore prevent water spreading outwards - if (nb.t == NEIGHBOR_LOWER && - nb.n.getContent() == CONTENT_IGNORE) - flowing_down = true; + if (nb.n.getContent() == CONTENT_IGNORE) { + // If node below is ignore prevent water from + // spreading outwards and otherwise prevent from + // flowing away as ignore node might be the source + if (nb.t == NEIGHBOR_LOWER) + flowing_down = true; + else + ignored_sources = true; + } } break; 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 = nodemgr->getId(cfnb.liquid_alternative_flowing); - if (nodemgr->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 = nodemgr->getId(cfnb.liquid_alternative_flowing); - if (nodemgr->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; @@ -1376,15 +699,15 @@ void Map::transformLiquids(std::map &modified_blocks) s8 new_node_level = -1; s8 max_node_level = -1; - u8 range = nodemgr->get(liquid_kind).liquid_range; + u8 range = m_nodedef->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) { + if ((num_sources >= 2 && m_nodedef->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 // it's perfectly safe to use liquid_kind here to determine the new node content. - new_node_content = nodemgr->getId(nodemgr->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; @@ -1392,6 +715,11 @@ void Map::transformLiquids(std::map &modified_blocks) new_node_content = liquid_kind; else new_node_content = floodable_node; + } else if (ignored_sources && liquid_level >= 0) { + // Maybe there are neighbouring sources that aren't loaded yet + // so prevent flowing away. + new_node_level = liquid_level; + new_node_content = liquid_kind; } else { // no surrounding sources, so get the maximum level that can flow into this node for (u16 i = 0; i < num_flows; i++) { @@ -1416,7 +744,7 @@ void Map::transformLiquids(std::map &modified_blocks) } } - u8 viscosity = nodemgr->get(liquid_kind).liquid_viscosity; + u8 viscosity = m_nodedef->get(liquid_kind).liquid_viscosity; if (viscosity > 1 && max_node_level != liquid_level) { // amount to gain, limited by viscosity // must be at least 1 in absolute value @@ -1444,7 +772,7 @@ void Map::transformLiquids(std::map &modified_blocks) check if anything has changed. if not, just continue with the next node. */ if (new_node_content == n0.getContent() && - (nodemgr->get(n0.getContent()).liquid_type != LIQUID_FLOWING || + (m_nodedef->get(n0.getContent()).liquid_type != LIQUID_FLOWING || ((n0.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK) == flowing_down))) @@ -1456,18 +784,26 @@ void Map::transformLiquids(std::map &modified_blocks) */ MapNode n00 = n0; //bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK)); - if (nodemgr->get(new_node_content).liquid_type == LIQUID_FLOWING) { + if (m_nodedef->get(new_node_content).liquid_type == LIQUID_FLOWING) { // 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. n0.setContent(new_node_content); + // on_flood() the node + if (floodable_node != CONTENT_AIR) { + if (env->getScriptIface()->node_on_flood(p0, n00, n0)) + continue; + } + // Ignore light (because calling voxalgo::update_lighting_nodes) - n0.setLight(LIGHTBANK_DAY, 0, nodemgr); - n0.setLight(LIGHTBANK_NIGHT, 0, nodemgr); + n0.setLight(LIGHTBANK_DAY, 0, m_nodedef); + n0.setLight(LIGHTBANK_NIGHT, 0, m_nodedef); // Find out whether there is a suspect for this action std::string suspect; @@ -1495,13 +831,13 @@ void Map::transformLiquids(std::map &modified_blocks) MapBlock *block = getBlockNoCreateNoEx(blockpos); if (block != NULL) { modified_blocks[blockpos] = block; - changed_nodes.push_back(std::pair(p0, n00)); + changed_nodes.emplace_back(p0, n00); } /* enqueue neighbors for update if neccessary */ - switch (nodemgr->get(n0.getContent()).liquid_type) { + switch (m_nodedef->get(n0.getContent()).liquid_type) { case LIQUID_SOURCE: case LIQUID_FLOWING: // make sure source flows into all neighboring nodes @@ -1521,10 +857,10 @@ void Map::transformLiquids(std::map &modified_blocks) } //infostream<<"Map::transformLiquids(): loopcount="<::iterator iter = must_reflow.begin(); iter != must_reflow.end(); ++iter) - m_transforming_liquid.push_back(*iter); + for (auto &iter : must_reflow) + m_transforming_liquid.push_back(iter); - voxalgo::update_lighting_nodes(this, nodemgr, changed_nodes, modified_blocks); + voxalgo::update_lighting_nodes(this, changed_nodes, modified_blocks); /* ---------------------------------------------------------------------- @@ -1537,7 +873,7 @@ void Map::transformLiquids(std::map &modified_blocks) time_until_purge *= 1000; // seconds -> milliseconds - u32 curr_time = getTime(PRECISION_MILLI); + u64 curr_time = porting::getTimeMs(); u32 prev_unprocessed = m_unprocessed_count; m_unprocessed_count = m_transforming_liquid.size(); @@ -1723,14 +1059,165 @@ void Map::removeNodeTimer(v3s16 p) block->m_node_timers.remove(p_rel); } +bool Map::determineAdditionalOcclusionCheck(const v3s16 &pos_camera, + const core::aabbox3d &block_bounds, v3s16 &check) +{ + /* + 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; + 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) + return true; + } + step *= stepfac; + } + return false; +} + +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 '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 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; + + // 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(std::string savedir, IGameDef *gamedef, EmergeManager *emerge): - Map(dout_server, gamedef), +ServerMap::ServerMap(const std::string &savedir, IGameDef *gamedef, + EmergeManager *emerge, MetricsBackend *mb): + Map(gamedef), settings_mgr(g_settings, savedir + DIR_DELIM + "map_meta.txt"), - m_emerge(emerge), - m_map_metadata_changed(true) + m_emerge(emerge) { verbosestream<addCounter("minetest_core_map_save_time", "Map save time (in nanoseconds)"); + + try { // If directory exists, check contents and load if possible - if(fs::PathExists(m_savedir)) - { + if (fs::PathExists(m_savedir)) { // If directory is empty, it is safe to save into it. - if(fs::GetDirListing(m_savedir).size() == 0) - { + if (fs::GetDirListing(m_savedir).empty()) { infostream<<"ServerMap: Empty save directory is valid." <seed; } -s16 ServerMap::getWaterLevel() +bool ServerMap::blockpos_over_mapgen_limit(v3s16 p) { - return getMapgenParams()->water_level; + const s16 mapgen_limit_bp = rangelim( + getMapgenParams()->mapgen_limit, 0, MAX_MAP_GENERATION_LIMIT) / + MAP_BLOCKSIZE; + return p.X < -mapgen_limit_bp || + p.X > mapgen_limit_bp || + p.Y < -mapgen_limit_bp || + p.Y > mapgen_limit_bp || + p.Z < -mapgen_limit_bp || + p.Z > mapgen_limit_bp; } bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data) @@ -1873,6 +1360,9 @@ bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data) 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)); @@ -1880,16 +1370,15 @@ bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data) v3s16 full_bpmin = bpmin - extra_borders; v3s16 full_bpmax = bpmax + extra_borders; - // Do nothing if not inside limits (+-1 because of neighbors) - if (blockpos_over_limit(full_bpmin) || - blockpos_over_limit(full_bpmax)) + // Do nothing if not inside mapgen limits (+-1 because of neighbors) + if (blockpos_over_mapgen_limit(full_bpmin) || + blockpos_over_mapgen_limit(full_bpmax)) return false; data->seed = getSeed(); data->blockpos_min = bpmin; data->blockpos_max = bpmax; - data->blockpos_requested = blockpos; - data->nodedef = m_gamedef->ndef(); + data->nodedef = m_nodedef; /* Create the whole area of this and the neighboring blocks @@ -1898,7 +1387,7 @@ bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data) for (s16 z = full_bpmin.Z; z <= full_bpmax.Z; z++) { v2s16 sectorpos(x, z); // Sector metadata is loaded from disk if not already loaded. - ServerMapSector *sector = createSector(sectorpos); + MapSector *sector = createSector(sectorpos); FATAL_ERROR_IF(sector == NULL, "createSector() failed"); for (s16 y = full_bpmin.Y; y <= full_bpmax.Y; y++) { @@ -1956,27 +1445,10 @@ void ServerMap::finishBlockMake(BlockMakeData *data, v3s16 bpmax = data->blockpos_max; v3s16 extra_borders(1, 1, 1); - v3s16 full_bpmin = bpmin - extra_borders; - v3s16 full_bpmax = bpmax + extra_borders; bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info; EMERGE_DBG_OUT("finishBlockMake(): " PP(bpmin) " - " PP(bpmax)); - /* - Set lighting to non-expired state in all of them. - This is cheating, but it is not fast enough if all of them - would actually be updated. - */ - for (s16 x = full_bpmin.X; x <= full_bpmax.X; x++) - for (s16 z = full_bpmin.Z; z <= full_bpmax.Z; z++) - for (s16 y = full_bpmin.Y; y <= full_bpmax.Y; y++) { - MapBlock *block = emergeBlock(v3s16(x, y, z), false); - if (!block) - continue; - - block->setLightingExpired(false); - } - /* Blit generated stuff to map NOTE: blitBackAll adds nearly everything to changed_blocks @@ -1994,10 +1466,8 @@ void ServerMap::finishBlockMake(BlockMakeData *data, data->transforming_liquid.pop_front(); } - for (std::map::iterator - it = changed_blocks->begin(); - it != changed_blocks->end(); ++it) { - MapBlock *block = it->second; + for (auto &changed_block : *changed_blocks) { + MapBlock *block = changed_block.second; if (!block) continue; /* @@ -2029,57 +1499,33 @@ void ServerMap::finishBlockMake(BlockMakeData *data, NOTE: Will be saved later. */ //save(MOD_STATE_WRITE_AT_UNLOAD); + m_chunks_in_progress.erase(bpmin); } -ServerMapSector *ServerMap::createSector(v2s16 p2d) +MapSector *ServerMap::createSector(v2s16 p2d) { - DSTACKF("%s: p2d=(%d,%d)", - FUNCTION_NAME, - p2d.X, p2d.Y); - /* Check if it exists already in memory */ - ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); - if(sector != NULL) + MapSector *sector = getSectorNoGenerate(p2d); + if (sector) return sector; /* - Try to load it from disk (with blocks) - */ - //if(loadSectorFull(p2d) == true) - - /* - Try to load metadata from disk - */ -#if 0 - if(loadSectorMeta(p2d) == true) - { - ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); - if(sector == NULL) - { - infostream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<getU16("map_generation_limit")); - if(p2d.X < -map_gen_limit / MAP_BLOCKSIZE - || p2d.X > map_gen_limit / MAP_BLOCKSIZE - || p2d.Y < -map_gen_limit / MAP_BLOCKSIZE - || p2d.Y > map_gen_limit / MAP_BLOCKSIZE) - throw InvalidPositionException("createSector(): pos. over 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 ServerMapSector(this, p2d, m_gamedef); + sector = new MapSector(this, p2d, m_gamedef); // Sector position on map in nodes //v2s16 nodepos2d = p2d * MAP_BLOCKSIZE; @@ -2101,12 +1547,6 @@ MapBlock * ServerMap::generateBlock( std::map &modified_blocks ) { - DSTACKF("%s: p=(%d,%d,%d)", FUNCTION_NAME, p.X, p.Y, p.Z); - - /*infostream<<"generateBlock(): " - <<"("<getBool("enable_mapgen_debug_info"); TimeTaker timer("generateBlock"); @@ -2210,14 +1650,11 @@ MapBlock * ServerMap::generateBlock( MapBlock * ServerMap::createBlock(v3s16 p) { - DSTACKF("%s: p=(%d,%d,%d)", - FUNCTION_NAME, p.X, p.Y, p.Z); - /* - Do not create over-limit + Do not create over max mapgen limit */ - if (blockpos_over_limit(p)) - throw InvalidPositionException("createBlock(): pos. over 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; @@ -2228,35 +1665,20 @@ MapBlock * ServerMap::createBlock(v3s16 p) NOTE: On old save formats, this will be slow, as it generates lighting on blocks for them. */ - ServerMapSector *sector; + MapSector *sector; try { - sector = (ServerMapSector*)createSector(p2d); - assert(sector->getId() == MAPSECTOR_SERVER); - } - catch(InvalidPositionException &e) - { + sector = createSector(p2d); + } catch (InvalidPositionException &e) { infostream<<"createBlock: createSector() failed"<getBlockNoCreateNoEx(block_y); - if(block) - { + if (block) { if(block->isDummy()) block->unDummify(); return block; @@ -2269,13 +1691,9 @@ MapBlock * ServerMap::createBlock(v3s16 p) MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank) { - DSTACKF("%s: p=(%d,%d,%d), create_blank=%d", - FUNCTION_NAME, - p.X, p.Y, p.Z, create_blank); - { MapBlock *block = getBlockNoCreateNoEx(p); - if(block && block->isDummy() == false) + if (block && !block->isDummy()) return block; } @@ -2286,38 +1704,11 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank) } if (create_blank) { - ServerMapSector *sector = createSector(v2s16(p.X, p.Z)); + MapSector *sector = createSector(v2s16(p.X, p.Z)); MapBlock *block = sector->createBlankBlock(p.Y); - - return block; - } - -#if 0 - if(allow_generate) - { - std::map modified_blocks; - MapBlock *block = generateBlock(p, modified_blocks); - if(block) - { - MapEditEvent event; - event.type = MEET_OTHER; - event.p = p; - - // Copy modified_blocks to event - for(std::map::iterator - i = modified_blocks.begin(); - i != modified_blocks.end(); ++i) - { - event.modified_blocks.insert(i->first); - } - - // Queue event - dispatchEvent(&event); - - return block; - } + + return block; } -#endif return NULL; } @@ -2331,9 +1722,6 @@ MapBlock *ServerMap::getBlockOrEmerge(v3s16 p3d) return block; } -void ServerMap::prepareBlock(MapBlock *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) @@ -2350,155 +1738,21 @@ void ServerMap::updateVManip(v3s16 pos) return; s32 idx = vm->m_area.index(pos); - vm->m_data[idx] = getNodeNoEx(pos); + vm->m_data[idx] = getNode(pos); vm->m_flags[idx] &= ~VOXELFLAG_NO_DATA; 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(std::string path) -{ - if(fs::CreateAllDirs(path) == false) - { - m_dout<<"ServerMap: Failed to create directory " - <<"\""<::iterator i = m_sectors.begin(); - i != m_sectors.end(); ++i) { - ServerMapSector *sector = (ServerMapSector*)i->second; - assert(sector->getId() == MAPSECTOR_SERVER); - - if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN) { - saveSectorMeta(sector); - sector_meta_count++; - } + for (auto §or_it : m_sectors) { + MapSector *sector = sector_it.second; MapBlockVect blocks; sector->getBlocks(blocks); - for(MapBlockVect::iterator j = blocks.begin(); - j != blocks.end(); ++j) { - MapBlock *block = *j; - + for (MapBlock *block : blocks) { block_count_all++; if(block->getModified() >= (u32)save_level) { @@ -2548,12 +1791,6 @@ void ServerMap::save(ModifiedState save_level) saveBlock(block); block_count++; - - /*infostream<<"ServerMap: Written block (" - <getPos().X<<"," - <getPos().Y<<"," - <getPos().Z<<")" - <increment(end_time - start_time); } void ServerMap::listAllLoadableBlocks(std::vector &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 &dst) -{ - for(std::map::iterator si = m_sectors.begin(); - si != m_sectors.end(); ++si) - { - MapSector *sector = si->second; - - MapBlockVect blocks; - sector->getBlocks(blocks); - - for(MapBlockVect::iterator i = blocks.begin(); - i != blocks.end(); ++i) { - v3s16 p = (*i)->getPos(); - dst.push_back(p); - } - } -} - -void ServerMap::saveSectorMeta(ServerMapSector *sector) -{ - DSTACK(FUNCTION_NAME); - // Format used for writing - u8 version = SER_FMT_VER_HIGHEST_WRITE; - // Get destination - v2s16 pos = sector->getPos(); - std::string dir = getSectorDir(pos); - createDirs(dir); - - std::string fullpath = dir + DIR_DELIM + "meta"; - std::ostringstream ss(std::ios_base::binary); - - sector->serialize(ss, version); - - if(!fs::safeWriteToFile(fullpath, ss.str())) - throw FileNotGoodException("Cannot write sector metafile"); - - sector->differs_from_disk = false; -} - -MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load) -{ - DSTACK(FUNCTION_NAME); - // Get destination - v2s16 p2d = getSectorPos(sectordir); - - ServerMapSector *sector = NULL; - - std::string fullpath = sectordir + DIR_DELIM + "meta"; - std::ifstream is(fullpath.c_str(), std::ios_base::binary); - if(is.good() == false) - { - // If the directory exists anyway, it probably is in some old - // format. Just go ahead and create the sector. - if(fs::PathExists(sectordir)) - { - /*infostream<<"ServerMap::loadSectorMeta(): Sector metafile " - <differs_from_disk = false; - - return sector; -} - -bool ServerMap::loadSectorMeta(v2s16 p2d) -{ - DSTACK(FUNCTION_NAME); - - // 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. - int loadlayout = 1; - std::string sectordir1 = getSectorDir(p2d, 1); - std::string sectordir; - if(fs::PathExists(sectordir1)) - { - sectordir = sectordir1; - } - else - { - loadlayout = 2; - sectordir = getSectorDir(p2d, 2); - } - - try{ - loadSectorMeta(sectordir, loadlayout != 2); - } - catch(InvalidFilenameException &e) - { - return false; - } - catch(FileNotGoodException &e) - { - return false; - } - catch(std::exception &e) - { - return false; - } - - return true; -} - -#if 0 -bool ServerMap::loadSectorFull(v2s16 p2d) -{ - DSTACK(FUNCTION_NAME); - - MapSector *sector = NULL; - - // 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. - int loadlayout = 1; - std::string sectordir1 = getSectorDir(p2d, 1); - std::string sectordir; - if(fs::PathExists(sectordir1)) - { - sectordir = sectordir1; - } - else - { - loadlayout = 2; - sectordir = getSectorDir(p2d, 2); - } - - try{ - sector = loadSectorMeta(sectordir, loadlayout != 2); - } - catch(InvalidFilenameException &e) - { - return false; - } - catch(FileNotGoodException &e) - { - return false; - } - catch(std::exception &e) - { - return false; - } - - /* - Load blocks - */ - std::vector list2 = fs::GetDirListing - (sectordir); - std::vector::iterator i2; - for(i2=list2.begin(); i2!=list2.end(); i2++) - { - // We want files - if(i2->dir) - continue; - try{ - loadBlock(sectordir, i2->name, sector, loadlayout != 2); - } - catch(InvalidFilenameException &e) - { - // This catches unknown crap in directory - } - } - - if(loadlayout != 2) - { - infostream<<"Sector converted to new layout - deleting "<< - sectordir1<getPos(); @@ -2841,8 +1888,7 @@ bool ServerMap::saveBlock(MapBlock *block, Database *db) o.write((char*) &version, 1); block->serialize(o, version, true); - std::string data = o.str(); - bool ret = db->saveBlock(p3d, data); + bool ret = db->saveBlock(p3d, o.str()); if (ret) { // We just wrote it to the disk so clear modified flag block->resetModified(); @@ -2850,87 +1896,8 @@ bool ServerMap::saveBlock(MapBlock *block, Database *db) return ret; } -void ServerMap::loadBlock(std::string sectordir, std::string blockfile, - MapSector *sector, bool save_after_load) -{ - DSTACK(FUNCTION_NAME); - - std::string fullpath = sectordir + DIR_DELIM + blockfile; - try { - - std::ifstream is(fullpath.c_str(), std::ios_base::binary); - if(is.good() == false) - 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 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); - - /* - 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="< 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); @@ -2961,8 +1921,11 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool block->deSerialize(is, version, true); // If it's a new block, insert it to the map - if(created_new) + 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 @@ -2975,7 +1938,6 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool // We just loaded it from, so it's up-to-date. block->resetModified(); - } catch(SerializationError &e) { @@ -2997,73 +1959,40 @@ void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool MapBlock* ServerMap::loadBlock(v3s16 blockpos) { - DSTACK(FUNCTION_NAME); + bool created_new = (getBlockNoCreateNoEx(blockpos) == NULL); v2s16 p2d(blockpos.X, blockpos.Z); std::string ret; dbase->loadBlock(blockpos, &ret); - if (ret != "") { + if (!ret.empty()) { loadBlock(&ret, blockpos, createSector(p2d), false); - return getBlockNoCreateNoEx(blockpos); - } - // 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. - int loadlayout = 1; - std::string sectordir1 = getSectorDir(p2d, 1); - std::string sectordir; - if(fs::PathExists(sectordir1)) - { - sectordir = sectordir1; - } - else - { - loadlayout = 2; - sectordir = getSectorDir(p2d, 2); + } else if (dbase_ro) { + dbase_ro->loadBlock(blockpos, &ret); + if (!ret.empty()) { + loadBlock(&ret, blockpos, createSector(p2d), false); + } + } else { + return NULL; } - /* - Make sure sector is loaded - */ - - MapSector *sector = getSectorNoGenerateNoEx(p2d); - if(sector == NULL) - { - try{ - sector = loadSectorMeta(sectordir, loadlayout != 2); - } - catch(InvalidFilenameException &e) - { - return NULL; - } - catch(FileNotGoodException &e) - { - return NULL; - } - catch(std::exception &e) - { - return NULL; + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if (created_new && (block != NULL)) { + std::map 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::iterator it; + for (it = modified_blocks.begin(); + it != modified_blocks.end(); ++it) + event.modified_blocks.insert(it->first); + dispatchEvent(event); } } - - /* - Make sure file exists - */ - - std::string blockfilename = getBlockFilename(blockpos); - if(fs::PathExists(sectordir + DIR_DELIM + blockfilename) == false) - return NULL; - - /* - Load block and save it to the database - */ - loadBlock(sectordir, blockfilename, sector, true); - return getBlockNoCreateNoEx(blockpos); + return block; } bool ServerMap::deleteBlock(v3s16 blockpos) @@ -3074,7 +2003,7 @@ bool ServerMap::deleteBlock(v3s16 blockpos) MapBlock *block = getBlockNoCreateNoEx(blockpos); if (block) { v2s16 p2d(blockpos.X, blockpos.Z); - MapSector *sector = getSectorNoGenerateNoEx(p2d); + MapSector *sector = getSectorNoGenerate(p2d); if (!sector) return false; sector->deleteBlock(block); @@ -3088,15 +2017,19 @@ void ServerMap::PrintInfo(std::ostream &out) out<<"ServerMap: "; } -MMVManip::MMVManip(Map *map): - VoxelManipulator(), - m_is_dirty(false), - m_create_area(false), - m_map(map) +bool ServerMap::repairBlockLight(v3s16 blockpos, + std::map *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() +MMVManip::MMVManip(Map *map): + VoxelManipulator(), + m_map(map) { } @@ -3136,25 +2069,20 @@ void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max, continue; bool block_data_inexistent = false; - try { - TimeTaker timer1("emerge load", &emerge_load_time); + TimeTaker timer2("emerge load", &emerge_load_time); - block = m_map->getBlockNoCreate(p); - if(block->isDummy()) + block = m_map->getBlockNoCreateNoEx(p); + if (!block || block->isDummy()) block_data_inexistent = true; else block->copyTo(*this); } - catch(InvalidPositionException &e) - { - block_data_inexistent = true; - } if(block_data_inexistent) { - if (load_if_inexistent) { + if (load_if_inexistent && !blockpos_over_max_limit(p)) { ServerMap *svrmap = (ServerMap *)m_map; block = svrmap->emergeBlock(p, false); if (block == NULL) @@ -3197,18 +2125,16 @@ void MMVManip::blitBackAll(std::map *modified_blocks, /* Copy data of all blocks */ - for(std::map::iterator - i = m_loaded_blocks.begin(); - i != m_loaded_blocks.end(); ++i) - { - v3s16 p = i->first; + for (auto &loaded_block : m_loaded_blocks) { + v3s16 p = loaded_block.first; MapBlock *block = m_map->getBlockNoCreateNoEx(p); - bool existed = !(i->second & VMANIP_BLOCK_DATA_INEXIST); - if ((existed == false) || (block == NULL) || - (overwrite_generated == false && block->isGenerated() == true)) + 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;