X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=4be094326f182e47243699107f704cbfa96876ef;hb=5917e862977518b80cb7a2a4b9dfbeda59c3656b;hp=32675f08d96523c5b2f640a2912ffcb0279a79ca;hpb=0ccc0ac927bdbfcc97c1b5c9d5dc64754946f817;p=dragonfireclient.git diff --git a/src/map.cpp b/src/map.cpp index 32675f08d..4be094326 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ @@ -21,24 +21,33 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "mapsector.h" #include "mapblock.h" #include "main.h" -#include "client.h" #include "filesys.h" -#include "utility.h" #include "voxel.h" #include "porting.h" #include "mapgen.h" #include "nodemetadata.h" +#include "settings.h" +#include "log.h" +#include "profiler.h" +#include "nodedef.h" +#include "gamedef.h" +#include "util/directiontables.h" +#include "rollback_interface.h" +#include "emerge.h" +#include "mapgen_v6.h" + +#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")" /* SQLite format specification: - Initially only replaces sectors/ and sectors2/ - + If map.sqlite does not exist in the save dir or the block was not found in the database the map will try to load from sectors folder. In either case, map.sqlite will be created and all future saves will save there. - + Structure of map.sqlite: Tables: blocks @@ -50,8 +59,9 @@ with this program; if not, write to the Free Software Foundation, Inc., Map */ -Map::Map(std::ostream &dout): +Map::Map(std::ostream &dout, IGameDef *gamedef): m_dout(dout), + m_gamedef(gamedef), m_sector_cache(NULL) { /*m_sector_mutex.Init(); @@ -100,14 +110,14 @@ MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p) MapSector * sector = m_sector_cache; return sector; } - + core::map::Node *n = m_sectors.find(p); - + if(n == NULL) return NULL; - + MapSector *sector = n->getValue(); - + // Cache the last result m_sector_cache_p = p; m_sector_cache = sector; @@ -125,7 +135,7 @@ MapSector * Map::getSectorNoGenerate(v2s16 p) MapSector *sector = getSectorNoGenerateNoEx(p); if(sector == NULL) throw InvalidPositionException(); - + return sector; } @@ -140,7 +150,7 @@ MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d) } MapBlock * Map::getBlockNoCreate(v3s16 p3d) -{ +{ MapBlock *block = getBlockNoCreateNoEx(p3d); if(block == NULL) throw InvalidPositionException(); @@ -195,6 +205,15 @@ 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 + if(n.getContent() == CONTENT_IGNORE){ + errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE" + <<" while trying to replace \"" + <ndef()->get(block->getNodeNoCheck(relpos)).name + <<"\" at "<setNodeNoCheck(relpos, n); } @@ -221,6 +240,8 @@ void Map::unspreadLight(enum LightBank bank, core::map & light_sources, core::map & modified_blocks) { + INodeDefManager *nodemgr = m_gamedef->ndef(); + v3s16 dirs[6] = { v3s16(0,0,1), // back v3s16(0,1,0), // top @@ -229,10 +250,10 @@ void Map::unspreadLight(enum LightBank bank, v3s16(0,-1,0), // bottom v3s16(-1,0,0), // left }; - + if(from_nodes.size() == 0) return; - + u32 blockchangecount = 0; core::map unlighted_nodes; @@ -246,12 +267,12 @@ void Map::unspreadLight(enum LightBank bank, MapBlock *block = NULL; // Cache this a bit, too bool block_checked_in_modified = false; - + for(; j.atEnd() == false; j++) { v3s16 pos = j.getNode()->getKey(); v3s16 blockpos = getNodeBlockPos(pos); - + // Only fetch a new block if the block position has changed try{ if(block == NULL || blockpos != blockpos_last){ @@ -317,19 +338,20 @@ void Map::unspreadLight(enum LightBank bank, If the neighbor is dimmer than what was specified as oldlight (the light of the previous node) */ - if(n2.getLight(bank) < oldlight) + if(n2.getLight(bank, nodemgr) < oldlight) { /* And the neighbor is transparent and it has some light */ - if(n2.light_propagates() && n2.getLight(bank) != 0) + 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); - n2.setLight(bank, 0); + u8 current_light = n2.getLight(bank, nodemgr); + n2.setLight(bank, 0, nodemgr); block->setNode(relpos, n2); unlighted_nodes.insert(n2pos, current_light); @@ -341,7 +363,7 @@ void Map::unspreadLight(enum LightBank bank, */ /*if(light_sources.find(n2pos)) { - std::cout<<"Removed from light_sources"< & from_nodes, core::map & modified_blocks) { + INodeDefManager *nodemgr = m_gamedef->ndef(); + const v3s16 dirs[6] = { v3s16(0,0,1), // back v3s16(0,1,0), // top @@ -434,7 +458,7 @@ void Map::spreadLight(enum LightBank bank, { v3s16 pos = j.getNode()->getKey(); //v3s16 pos = *j; - //dstream<<"pos=("<getNode(relpos); - u8 oldlight = n.getLight(bank); + u8 oldlight = n.getLight(bank, nodemgr); u8 newlight = diminish_light(oldlight); // Loop through 6 neighbors @@ -499,7 +523,7 @@ void Map::spreadLight(enum LightBank bank, 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) > undiminish_light(oldlight)) + if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight)) { lighted_nodes.insert(n2pos, true); //lighted_nodes.push_back(n2pos); @@ -509,11 +533,11 @@ void Map::spreadLight(enum LightBank bank, If the neighbor is dimmer than how much light this node would spread on it, add to list */ - if(n2.getLight(bank) < newlight) + if(n2.getLight(bank, nodemgr) < newlight) { - if(n2.light_propagates()) + if(nodemgr->get(n2).light_propagates) { - n2.setLight(bank, newlight); + n2.setLight(bank, newlight, nodemgr); block->setNode(relpos, n2); lighted_nodes.insert(n2pos, true); //lighted_nodes.push_back(n2pos); @@ -539,7 +563,7 @@ void Map::spreadLight(enum LightBank bank, } } - /*dstream<<"spreadLight(): Changed block " + /*infostream<<"spreadLight(): Changed block " <ndef(); + v3s16 dirs[6] = { v3s16(0,0,1), // back v3s16(0,1,0), // top @@ -587,8 +613,8 @@ v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p) { continue; } - if(n2.getLight(bank) > brightest_light || found_something == false){ - brightest_light = n2.getLight(bank); + if(n2.getLight(bank, nodemgr) > brightest_light || found_something == false){ + brightest_light = n2.getLight(bank, nodemgr); brightest_pos = n2pos; found_something = true; } @@ -611,6 +637,8 @@ v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p) s16 Map::propagateSunlight(v3s16 start, core::map & modified_blocks) { + INodeDefManager *nodemgr = m_gamedef->ndef(); + s16 y = start.Y; for(; ; y--) { @@ -629,23 +657,15 @@ s16 Map::propagateSunlight(v3s16 start, v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE; MapNode n = block->getNode(relpos); - if(n.sunlight_propagates()) + if(nodemgr->get(n).sunlight_propagates) { - n.setLight(LIGHTBANK_DAY, LIGHT_SUN); + n.setLight(LIGHTBANK_DAY, LIGHT_SUN, nodemgr); block->setNode(relpos, n); modified_blocks.insert(blockpos, block); } else { - /*// Turn mud into grass - if(n.getContent() == CONTENT_MUD) - { - n.setContent(CONTENT_GRASS); - block->setNode(relpos, n); - modified_blocks.insert(blockpos, block); - }*/ - // Sunlight goes no further break; } @@ -657,6 +677,8 @@ void Map::updateLighting(enum LightBank bank, core::map & a_blocks, core::map & modified_blocks) { + INodeDefManager *nodemgr = m_gamedef->ndef(); + /*m_dout< unlight_from; + int num_bottom_invalid = 0; + + { + //TimeTaker t("first stuff"); + core::map::Iterator i; i = a_blocks.getIterator(); for(; i.atEnd() == false; i++) @@ -685,6 +712,7 @@ void Map::updateLighting(enum LightBank bank, break; v3s16 pos = block->getPos(); + v3s16 posnodes = block->getPosRelative(); modified_blocks.insert(pos, block); blocks_to_update.insert(pos, block); @@ -699,20 +727,23 @@ void Map::updateLighting(enum LightBank bank, try{ v3s16 p(x,y,z); - MapNode n = block->getNode(v3s16(x,y,z)); - u8 oldlight = n.getLight(bank); - n.setLight(bank, 0); - block->setNode(v3s16(x,y,z), n); + MapNode n = block->getNode(p); + u8 oldlight = n.getLight(bank, nodemgr); + n.setLight(bank, 0, nodemgr); + block->setNode(p, n); + + // If node sources light, add to list + u8 source = nodemgr->get(n).light_source; + if(source != 0) + light_sources[p + posnodes] = true; // Collect borders for unlighting - if(x==0 || x == MAP_BLOCKSIZE-1 + 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 + v3s16( - MAP_BLOCKSIZE*pos.X, - MAP_BLOCKSIZE*pos.Y, - MAP_BLOCKSIZE*pos.Z); + v3s16 p_map = p + posnodes; unlight_from.insert(p_map, oldlight); } } @@ -723,7 +754,7 @@ void Map::updateLighting(enum LightBank bank, dummy block. */ //assert(0); - dstream<<"updateLighting(): InvalidPositionException" + infostream<<"updateLighting(): InvalidPositionException" <propagateSunlight(light_sources); + if(!bottom_valid) + num_bottom_invalid++; + // If bottom is valid, we're done. if(bottom_valid) break; @@ -747,7 +781,7 @@ void Map::updateLighting(enum LightBank bank, assert(0); } - /*dstream<<"Bottom for sunlight-propagated block (" + /*infostream<<"Bottom for sunlight-propagated block (" <get("")) { core::map::Iterator i; i = blocks_to_update.getIterator(); @@ -784,38 +820,43 @@ void Map::updateLighting(enum LightBank bank, } #endif -#if 0 +#if 1 { - TimeTaker timer("unspreadLight"); + //TimeTaker timer("unspreadLight"); unspreadLight(bank, unlight_from, light_sources, modified_blocks); } - if(debug) + /*if(debug) { u32 diff = modified_blocks.size() - count_was; count_was = modified_blocks.size(); - dstream<<"unspreadLight modified "<::Iterator i; i = blocks_to_update.getIterator(); for(; i.atEnd() == false; i++) @@ -835,36 +876,38 @@ void Map::updateLighting(enum LightBank bank, for(s16 y=-1; y<=1; y++) for(s16 x=-1; x<=1; x++) { - v3s16 p(x,y,z); - MapBlock *block = getBlockNoCreateNoEx(p); + 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(p, p); + vmanip.initialEmerge(p2, p2); }*/ // Lighting of block will be updated completely block->setLightingExpired(false); } + } { //TimeTaker timer("unSpreadLight"); - vmanip.unspreadLight(bank, unlight_from, light_sources); + vmanip.unspreadLight(bank, unlight_from, light_sources, nodemgr); } { //TimeTaker timer("spreadLight"); - vmanip.spreadLight(bank, light_sources); + vmanip.spreadLight(bank, light_sources, nodemgr); } { //TimeTaker timer("blitBack"); vmanip.blitBack(modified_blocks); } - /*dstream<<"emerge_time="< & a_blocks, i.atEnd() == false; i++) { MapBlock *block = i.getNode()->getValue(); - block->updateDayNightDiff(); + block->expireDayNightDiff(); } } /* */ void Map::addNodeAndUpdate(v3s16 p, MapNode n, - core::map &modified_blocks, std::string &player_name) + core::map &modified_blocks) { + INodeDefManager *ndef = m_gamedef->ndef(); + /*PrintInfo(m_dout); m_dout< light_sources; + /* + Collect old node for rollback + */ + RollbackNode rollback_oldnode(this, p, m_gamedef); + /* If there is a node at top and it doesn't have sunlight, there has not been any sunlight going down. @@ -918,46 +968,13 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, try{ MapNode topnode = getNode(toppos); - if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN) + if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN) node_under_sunlight = false; } catch(InvalidPositionException &e) { } -#if 0 - /* - If the new node is solid and there is grass below, change it to mud - */ - if(content_features(n).walkable == true) - { - try{ - MapNode bottomnode = getNode(bottompos); - - if(bottomnode.getContent() == CONTENT_GRASS - || bottomnode.getContent() == CONTENT_GRASS_FOOTSTEPS) - { - bottomnode.setContent(CONTENT_MUD); - setNode(bottompos, bottomnode); - } - } - catch(InvalidPositionException &e) - { - } - } -#endif - -#if 0 - /* - If the new node is mud and it is under sunlight, change it - to grass - */ - if(n.getContent() == CONTENT_MUD && node_under_sunlight) - { - n.setContent(CONTENT_GRASS); - } -#endif - /* Remove all light that has come out of this node */ @@ -971,7 +988,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, { enum LightBank bank = banks[i]; - u8 lightwas = getNode(p).getLight(bank); + u8 lightwas = getNode(p).getLight(bank, ndef); // Add the block of the added node to modified_blocks v3s16 blockpos = getNodeBlockPos(p); @@ -988,35 +1005,29 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, // light again into this. unLightNeighbors(bank, p, lightwas, light_sources, modified_blocks); - n.setLight(bank, 0); + n.setLight(bank, 0, ndef); } /* If node lets sunlight through and is under sunlight, it has sunlight too. */ - if(node_under_sunlight && content_features(n).sunlight_propagates) + if(node_under_sunlight && ndef->get(n).sunlight_propagates) { - n.setLight(LIGHTBANK_DAY, LIGHT_SUN); + n.setLight(LIGHTBANK_DAY, LIGHT_SUN, ndef); } /* - Set the node on the map + Remove node metadata */ - setNode(p, n); + removeNodeMetadata(p); /* - Add intial metadata + Set the node on the map */ - NodeMetadata *meta_proto = content_features(n).initial_metadata; - if(meta_proto) - { - NodeMetadata *meta = meta_proto->clone(); - meta->setOwner(player_name); - setNodeMetadata(p, meta); - } + setNode(p, n); /* If node is under sunlight and doesn't let sunlight through, @@ -1025,7 +1036,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, TODO: This could be optimized by mass-unlighting instead of looping */ - if(node_under_sunlight && !content_features(n).sunlight_propagates) + if(node_under_sunlight && !ndef->get(n).sunlight_propagates) { s16 y = p.Y - 1; for(;; y--){ @@ -1041,12 +1052,12 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, break; } - if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN) + if(n2.getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN) { unLightNeighbors(LIGHTBANK_DAY, - n2pos, n2.getLight(LIGHTBANK_DAY), + n2pos, n2.getLight(LIGHTBANK_DAY, ndef), light_sources, modified_blocks); - n2.setLight(LIGHTBANK_DAY, 0); + n2.setLight(LIGHTBANK_DAY, 0, ndef); setNode(n2pos, n2); } else @@ -1072,7 +1083,18 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, i.atEnd() == false; i++) { MapBlock *block = i.getNode()->getValue(); - block->updateDayNightDiff(); + block->expireDayNightDiff(); + } + + /* + Report for rollback + */ + if(m_gamedef->rollback()) + { + RollbackNode rollback_newnode(this, p, m_gamedef); + RollbackAction action; + action.setSetNode(p, rollback_oldnode, rollback_newnode); + m_gamedef->rollback()->reportAction(action); } /* @@ -1096,7 +1118,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, v3s16 p2 = p + dirs[i]; MapNode n2 = getNode(p2); - if(content_liquid(n2.getContent()) || n2.getContent() == CONTENT_AIR) + if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR) { m_transforming_liquid.push_back(p2); } @@ -1112,6 +1134,8 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, void Map::removeNodeAndUpdate(v3s16 p, core::map &modified_blocks) { + INodeDefManager *ndef = m_gamedef->ndef(); + /*PrintInfo(m_dout); m_dout<getValue(); - block->updateDayNightDiff(); + block->expireDayNightDiff(); + } + + /* + Report for rollback + */ + if(m_gamedef->rollback()) + { + RollbackNode rollback_newnode(this, p, m_gamedef); + RollbackAction action; + action.setSetNode(p, rollback_oldnode, rollback_newnode); + m_gamedef->rollback()->reportAction(action); } /* @@ -1270,7 +1310,7 @@ void Map::removeNodeAndUpdate(v3s16 p, v3s16 p2 = p + dirs[i]; MapNode n2 = getNode(p2); - if(content_liquid(n2.getContent()) || n2.getContent() == CONTENT_AIR) + if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR) { m_transforming_liquid.push_back(p2); } @@ -1291,8 +1331,7 @@ bool Map::addNodeWithEvent(v3s16 p, MapNode n) bool succeeded = true; try{ core::map modified_blocks; - std::string st = std::string(""); - addNodeAndUpdate(p, n, modified_blocks, st); + addNodeAndUpdate(p, n, modified_blocks); // Copy modified_blocks to event for(core::map::Iterator @@ -1339,12 +1378,12 @@ bool Map::removeNodeWithEvent(v3s16 p) return succeeded; } -bool Map::dayNightDiffed(v3s16 blockpos) +bool Map::getDayNightDiff(v3s16 blockpos) { try{ v3s16 p = blockpos + v3s16(0,0,0); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} @@ -1352,21 +1391,21 @@ bool Map::dayNightDiffed(v3s16 blockpos) try{ v3s16 p = blockpos + v3s16(-1,0,0); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} try{ v3s16 p = blockpos + v3s16(0,-1,0); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} try{ v3s16 p = blockpos + v3s16(0,0,-1); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} @@ -1374,21 +1413,21 @@ bool Map::dayNightDiffed(v3s16 blockpos) try{ v3s16 p = blockpos + v3s16(1,0,0); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} try{ v3s16 p = blockpos + v3s16(0,1,0); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} try{ v3s16 p = blockpos + v3s16(0,0,1); MapBlock *b = getBlockNoCreate(p); - if(b->dayNightDiffed()) + if(b->getDayNightDiff()) return true; } catch(InvalidPositionException &e){} @@ -1403,10 +1442,14 @@ void Map::timerUpdate(float dtime, float unload_timeout, core::list *unloaded_blocks) { bool save_before_unloading = (mapType() == MAPTYPE_SERVER); - + + // Profile modified reasons + Profiler modprofiler; + core::list sector_deletion_queue; u32 deleted_blocks_count = 0; u32 saved_blocks_count = 0; + u32 block_count_all = 0; core::map::Iterator si; @@ -1420,15 +1463,15 @@ void Map::timerUpdate(float dtime, float unload_timeout, core::list blocks; sector->getBlocks(blocks); - + for(core::list::Iterator i = blocks.begin(); i != blocks.end(); i++) { MapBlock *block = (*i); - + block->incrementUsageTimer(dtime); - - if(block->getUsageTimer() > unload_timeout) + + if(block->refGet() == 0 && block->getUsageTimer() > unload_timeout) { v3s16 p = block->getPos(); @@ -1436,6 +1479,7 @@ void Map::timerUpdate(float dtime, float unload_timeout, if(block->getModified() != MOD_STATE_CLEAN && save_before_unloading) { + modprofiler.add(block->getModifiedReason(), 1); saveBlock(block); saved_blocks_count++; } @@ -1451,6 +1495,7 @@ void Map::timerUpdate(float dtime, float unload_timeout, else { all_blocks_deleted = false; + block_count_all++; } } @@ -1460,18 +1505,24 @@ void Map::timerUpdate(float dtime, float unload_timeout, } } endSave(); - + // Finally delete the empty sectors deleteSectors(sector_deletion_queue); - + if(deleted_blocks_count != 0) { - PrintInfo(dstream); // ServerMap/ClientMap: - dstream<<"Unloaded "<getUsageTimer() > timeout) { // Save if modified @@ -1538,7 +1589,7 @@ void Map::unloadUnusedData(float timeout, deleteSectors(sector_deletion_queue); - dstream<<"Map: Unloaded "< & modified_blocks) +{ + INodeDefManager *nodemgr = m_gamedef->ndef(); + + DSTACK(__FUNCTION_NAME); + //TimeTaker timer("transformLiquids()"); + + u32 loopcount = 0; + u32 initial_size = m_transforming_liquid.size(); + + u8 relax = g_settings->getS16("liquid_relax"); + bool fast_flood = g_settings->getS16("liquid_fast_flood"); + int water_level = g_settings->getS16("water_level"); + + /*if(initial_size != 0) + infostream<<"transformLiquids(): initial_size="< must_reflow, must_reflow_second; + + // List of MapBlocks that will require a lighting update (due to lava) + core::map lighting_modified_blocks; + + while(m_transforming_liquid.size() > 0) + { + // This should be done here so that it is done when continue is used + if(loopcount >= initial_size || loopcount >= 1000) + break; + loopcount++; + /* + Get a queued transforming liquid node + */ + v3s16 p0 = m_transforming_liquid.pop_front(); + u16 total_level = 0; + NodeNeighbor neighbors[7]; // surrounding flowing liquid nodes + s8 liquid_levels[7] = {-1, -1, -1, -1, -1, -1, -1}; // current level of every block + s8 liquid_levels_want[7] = {-1, -1, -1, -1, -1, -1, -1}; // target levels + s8 can_liquid_same_level = 0; + content_t liquid_kind = CONTENT_IGNORE; + content_t liquid_kind_flowing = CONTENT_IGNORE; + /* + Collect information about the environment + */ + const v3s16 *dirs = g_7dirs; + for (u16 i = 0; i < 7; i++) { + NeighborType nt = NEIGHBOR_SAME_LEVEL; + switch (i) { + case D_TOP: + nt = NEIGHBOR_UPPER; + break; + case D_BOTTOM: + nt = NEIGHBOR_LOWER; + break; + } + v3s16 npos = p0 + dirs[i]; + + neighbors[i].n = getNodeNoEx(npos); + neighbors[i].t = nt; + neighbors[i].p = npos; + neighbors[i].l = 0; + neighbors[i].i = 0; + NodeNeighbor & nb = neighbors[i]; + + switch (nodemgr->get(nb.n.getContent()).liquid_type) { + case LIQUID_NONE: + if (nb.n.getContent() == CONTENT_AIR) { + liquid_levels[i] = 0; + nb.l = 1; + } + break; + case LIQUID_SOURCE: + // if this node is not (yet) of a liquid type, choose the first liquid type we encounter + if (liquid_kind_flowing == CONTENT_IGNORE) + liquid_kind_flowing = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing); + if (liquid_kind == CONTENT_IGNORE) + liquid_kind = nb.n.getContent(); + if (nb.n.getContent() == liquid_kind) { + liquid_levels[i] = LIQUID_LEVEL_SOURCE; + nb.l = 1; + nb.i = (nb.n.param2 & LIQUID_INFINITY_MASK); + } + break; + case LIQUID_FLOWING: + // if this node is not (yet) of a liquid type, choose the first liquid type we encounter + if (liquid_kind_flowing == CONTENT_IGNORE) + liquid_kind_flowing = nb.n.getContent(); + if (liquid_kind == CONTENT_IGNORE) + liquid_kind = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_source); + if (nb.n.getContent() == liquid_kind_flowing) { + liquid_levels[i] = (nb.n.param2 & LIQUID_LEVEL_MASK); + nb.l = 1; + } + break; + } + if (nb.l && nb.t == NEIGHBOR_SAME_LEVEL) ++can_liquid_same_level; + if (liquid_levels[i] > 0) total_level += liquid_levels[i]; + + /* + infostream << "get node i=" <<(int)i<<" " << PP(npos) << " c="<ndef(); + DSTACK(__FUNCTION_NAME); //TimeTaker timer("transformLiquids()"); @@ -1574,18 +1939,18 @@ void Map::transformLiquids(core::map & modified_blocks) u32 initial_size = m_transforming_liquid.size(); /*if(initial_size != 0) - dstream<<"transformLiquids(): initial_size="<m_node_metadata.remove(p_rel); } -void Map::nodeMetadataStep(float dtime, - core::map &changed_blocks) +NodeTimer Map::getNodeTimer(v3s16 p) { - /* - NOTE: - Currently there is no way to ensure that all the necessary - blocks are loaded when this is run. (They might get unloaded) - NOTE: ^- Actually, that might not be so. In a quick test it - reloaded a block with a furnace when I walked back to it from - a distance. - */ - core::map::Iterator si; - si = m_sectors.getIterator(); - for(; si.atEnd() == false; si++) + v3s16 blockpos = getNodeBlockPos(p); + v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE; + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if(!block){ + infostream<<"Map::getNodeTimer(): Need to emerge " + <getValue(); - core::list< MapBlock * > sectorblocks; - sector->getBlocks(sectorblocks); - core::list< MapBlock * >::Iterator i; - for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) - { - MapBlock *block = *i; - bool changed = block->m_node_metadata.step(dtime); - if(changed) - changed_blocks[block->getPos()] = block; - } + infostream<<"WARNING: Map::getNodeTimer(): Block not found" + <m_node_timers.get(p_rel); + return t; +} + +void Map::setNodeTimer(v3s16 p, NodeTimer t) +{ + v3s16 blockpos = getNodeBlockPos(p); + v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE; + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if(!block){ + infostream<<"Map::setNodeTimer(): Need to emerge " + <m_node_timers.set(p_rel, t); +} + +void Map::removeNodeTimer(v3s16 p) +{ + v3s16 blockpos = getNodeBlockPos(p); + v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE; + MapBlock *block = getBlockNoCreateNoEx(blockpos); + if(block == NULL) + { + infostream<<"WARNING: Map::removeNodeTimer(): Block not found" + <m_node_timers.remove(p_rel); } /* ServerMap */ - -ServerMap::ServerMap(std::string savedir): - Map(dout_server), +ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge): + Map(dout_server, gamedef), m_seed(0), m_map_metadata_changed(true), m_database(NULL), m_database_read(NULL), m_database_write(NULL) { - dstream<<__FUNCTION_NAME<getParamsFromSettings(g_settings); + if (!m_mgparams) + m_mgparams = new MapgenV6Params(); - if (g_settings.get("fixed_map_seed").empty()) - { - m_seed = (((u64)(myrand()%0xffff)<<0) - + ((u64)(myrand()%0xffff)<<16) - + ((u64)(myrand()%0xffff)<<32) - + ((u64)(myrand()%0xffff)<<48)); - } - else + m_seed = m_mgparams->seed; + + if (g_settings->get("fixed_map_seed").empty()) { - m_seed = g_settings.getU64("fixed_map_seed"); + m_seed = (((u64)(myrand() & 0xffff) << 0) + | ((u64)(myrand() & 0xffff) << 16) + | ((u64)(myrand() & 0xffff) << 32) + | ((u64)(myrand() & 0xffff) << 48)); + m_mgparams->seed = m_seed; } /* @@ -1930,7 +2355,7 @@ ServerMap::ServerMap(std::string savedir): // If directory is empty, it is safe to save into it. if(fs::GetDirListing(m_savedir).size() == 0) { - dstream<mapgen_debug_info; + EMERGE_DBG_OUT("initBlockMake(): " PP(blockpos) " - " PP(blockpos)); + + //s16 chunksize = 3; + //v3s16 chunk_offset(-1,-1,-1); + //s16 chunksize = 4; + //v3s16 chunk_offset(-1,-1,-1); + s16 chunksize = 5; + v3s16 chunk_offset(-2,-2,-2); + v3s16 blockpos_div = getContainerPos(blockpos - chunk_offset, chunksize); + v3s16 blockpos_min = blockpos_div * chunksize; + v3s16 blockpos_max = blockpos_div * chunksize + v3s16(1,1,1)*(chunksize-1); + blockpos_min += chunk_offset; + blockpos_max += chunk_offset; + + //v3s16 extra_borders(1,1,1); + v3s16 extra_borders(1,1,1); + // Do nothing if not inside limits (+-1 because of neighbors) - if(blockpos_over_limit(blockpos - v3s16(1,1,1)) || - blockpos_over_limit(blockpos + v3s16(1,1,1))) - { - data->no_op = true; - return; - } - - data->no_op = false; + if(blockpos_over_limit(blockpos_min - extra_borders) || + blockpos_over_limit(blockpos_max + extra_borders)) + return false; + data->seed = m_seed; - data->blockpos = blockpos; + data->blockpos_min = blockpos_min; + data->blockpos_max = blockpos_max; + data->blockpos_requested = blockpos; + data->nodedef = m_gamedef->ndef(); /* Create the whole area of this and the neighboring blocks */ { //TimeTaker timer("initBlockMake() create area"); - - for(s16 x=-1; x<=1; x++) - for(s16 z=-1; z<=1; z++) + + for(s16 x=blockpos_min.X-extra_borders.X; + x<=blockpos_max.X+extra_borders.X; x++) + for(s16 z=blockpos_min.Z-extra_borders.Z; + z<=blockpos_max.Z+extra_borders.Z; z++) { - v2s16 sectorpos(blockpos.X+x, blockpos.Z+z); + v2s16 sectorpos(x, z); // Sector metadata is loaded from disk if not already loaded. ServerMapSector *sector = createSector(sectorpos); assert(sector); - for(s16 y=-1; y<=1; y++) + for(s16 y=blockpos_min.Y-extra_borders.Y; + y<=blockpos_max.Y+extra_borders.Y; y++) { - v3s16 p(blockpos.X+x, blockpos.Y+y, blockpos.Z+z); + v3s16 p(x,y,z); //MapBlock *block = createBlock(p); // 1) get from memory, 2) load from disk MapBlock *block = emergeBlock(p, false); @@ -2090,7 +2519,7 @@ void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos) Refer to the map generator heuristics. */ - bool ug = mapgen::block_is_underground(data->seed, p); + bool ug = m_emerge->isBlockUnderground(p); block->setIsUnderground(ug); } @@ -2101,18 +2530,18 @@ void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos) } } } - + /* Now we have a big empty area. Make a ManualMapVoxelManipulator that contains this and the neighboring blocks */ - + // The area that contains this block and it's neighbors - v3s16 bigarea_blocks_min = blockpos - v3s16(1,1,1); - v3s16 bigarea_blocks_max = blockpos + v3s16(1,1,1); - + v3s16 bigarea_blocks_min = blockpos_min - extra_borders; + v3s16 bigarea_blocks_max = blockpos_max + extra_borders; + data->vmanip = new ManualMapVoxelManipulator(this); //data->vmanip->setMap(this); @@ -2121,28 +2550,56 @@ void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos) //TimeTaker timer("initBlockMake() initialEmerge"); data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max); } + + // 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::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); + } + } + }*/ // Data is ready now. + return true; } -MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data, +MapBlock* ServerMap::finishBlockMake(BlockMakeData *data, core::map &changed_blocks) { - v3s16 blockpos = data->blockpos; - /*dstream<<"finishBlockMake(): ("<blockpos_min; + v3s16 blockpos_max = data->blockpos_max; + v3s16 blockpos_requested = data->blockpos_requested; + /*infostream<<"finishBlockMake(): ("<no_op) + bool enable_mapgen_debug_info = m_emerge->mapgen_debug_info; + + /*infostream<<"Resulting vmanip:"<vmanip.print(infostream);*/ + + // Make sure affected blocks are loaded + for(s16 x=blockpos_min.X-extra_borders.X; + x<=blockpos_max.X+extra_borders.X; x++) + for(s16 z=blockpos_min.Z-extra_borders.Z; + z<=blockpos_max.Z+extra_borders.Z; z++) + for(s16 y=blockpos_min.Y-extra_borders.Y; + y<=blockpos_max.Y+extra_borders.Y; y++) { - //dstream<<"finishBlockMake(): no-op"<vmanip.print(dstream);*/ - /* Blit generated stuff to map NOTE: blitBackAll adds nearly everything to changed_blocks @@ -2153,9 +2610,7 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data, data->vmanip->blitBackAll(&changed_blocks); } - if(enable_mapgen_debug_info) - dstream<<"finishBlockMake: changed_blocks.size()=" - < lighting_update_blocks; -#if 1 - // Center block - lighting_update_blocks.insert(block->getPos(), block); - - /*{ - s16 x = 0; - s16 z = 0; - v3s16 p = block->getPos()+v3s16(x,1,z); - lighting_update_blocks[p] = getBlockNoCreateNoEx(p); - }*/ -#endif -#if 0 - // All modified blocks - // NOTE: Should this be done? If this is not done, then the lighting - // of the others will be updated in a different place, one by one, i - // think... or they might not? Well, at least they are left marked as - // "lighting expired"; it seems that is not handled at all anywhere, - // so enabling this will slow it down A LOT because otherwise it - // would not do this at all. This causes the black trees. - for(core::map::Iterator - i = changed_blocks.getIterator(); - i.atEnd() == false; i++) + + // Center blocks + for(s16 x=blockpos_min.X-extra_borders.X; + x<=blockpos_max.X+extra_borders.X; x++) + for(s16 z=blockpos_min.Z-extra_borders.Z; + z<=blockpos_max.Z+extra_borders.Z; z++) + for(s16 y=blockpos_min.Y-extra_borders.Y; + y<=blockpos_max.Y+extra_borders.Y; y++) { - lighting_update_blocks.insert(i.getNode()->getKey(), - i.getNode()->getValue()); + v3s16 p(x, y, z); + MapBlock *block = getBlockNoCreateNoEx(p); + assert(block); + lighting_update_blocks.insert(block->getPos(), block); } - /*// Also force-add all the upmost blocks for proper sunlight - for(s16 x=-1; x<=1; x++) - for(s16 z=-1; z<=1; z++) - { - v3s16 p = block->getPos()+v3s16(x,1,z); - lighting_update_blocks[p] = getBlockNoCreateNoEx(p); - }*/ -#endif + updateLighting(lighting_update_blocks, changed_blocks); - +#endif + /* 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=-1; x<=1; x++) - for(s16 y=-1; y<=1; y++) - for(s16 z=-1; z<=1; z++) + for(s16 x=blockpos_min.X-extra_borders.X; + x<=blockpos_max.X+extra_borders.X; x++) + for(s16 z=blockpos_min.Z-extra_borders.Z; + z<=blockpos_max.Z+extra_borders.Z; z++) + for(s16 y=blockpos_min.Y-extra_borders.Y; + y<=blockpos_max.Y+extra_borders.Y; y++) { - v3s16 p = block->getPos()+v3s16(x,y,z); + v3s16 p(x, y, z); getBlockNoCreateNoEx(p)->setLightingExpired(false); } +#if 0 if(enable_mapgen_debug_info == false) t.stop(true); // Hide output +#endif } - /* - Add random objects to block - */ - mapgen::add_random_objects(block); - /* Go through changed blocks */ @@ -2277,46 +2684,62 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data, /* Update day/night difference cache of the MapBlocks */ - block->updateDayNightDiff(); + block->expireDayNightDiff(); /* Set block as modified */ - block->raiseModified(MOD_STATE_WRITE_NEEDED); + block->raiseModified(MOD_STATE_WRITE_NEEDED, + "finishBlockMake expireDayNightDiff"); } /* - Set central block as generated + Set central blocks as generated */ - block->setGenerated(true); - + for(s16 x=blockpos_min.X; x<=blockpos_max.X; x++) + for(s16 z=blockpos_min.Z; z<=blockpos_max.Z; z++) + for(s16 y=blockpos_min.Y; y<=blockpos_max.Y; y++) + { + v3s16 p(x, y, z); + MapBlock *block = getBlockNoCreateNoEx(p); + assert(block); + block->setGenerated(true); + } + /* Save changed parts of map NOTE: Will be saved later. */ - //save(true); + //save(MOD_STATE_WRITE_AT_UNLOAD); - /*dstream<<"finishBlockMake() done for ("<getPos()+v3s16(x,y,z); + v3s16 p = v3s16(x,y,z); MapBlock *block = getBlockNoCreateNoEx(p); char spos[20]; snprintf(spos, 20, "(%2d,%2d,%2d)", x, y, z); - dstream<<"Generated "<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)) { - dstream<<__FUNCTION_NAME<<": Block position over limit"<makeChunk(&data); + //mapgen::make_block(&data); if(enable_mapgen_debug_info == false) t.stop(true); // Hide output @@ -2453,7 +2878,7 @@ MapBlock * ServerMap::generateBlock( MapNode n = block->getNode(p); if(n.getContent() == CONTENT_IGNORE) { - dstream<<"CONTENT_IGNORE at " + infostream<<"CONTENT_IGNORE at " <<"("<setNode(v3s16(x0,y0,z0), n); } } @@ -2494,12 +2916,13 @@ MapBlock * ServerMap::generateBlock( return block; } +#endif MapBlock * ServerMap::createBlock(v3s16 p) { DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z); - + /* Do not create over-limit */ @@ -2510,7 +2933,7 @@ MapBlock * ServerMap::createBlock(v3s16 p) || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) throw InvalidPositionException("createBlock(): pos. over limit"); - + v2s16 p2d(p.X, p.Z); s16 block_y = p.Y; /* @@ -2527,7 +2950,7 @@ MapBlock * ServerMap::createBlock(v3s16 p) } catch(InvalidPositionException &e) { - dstream<<"createBlock: createSector() failed"<createBlankBlock(block_y); + return block; } -MapBlock * ServerMap::emergeBlock(v3s16 p, bool allow_generate) +MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank) { - DSTACKF("%s: p=(%d,%d,%d), allow_generate=%d", + DSTACKF("%s: p=(%d,%d,%d), create_blank=%d", __FUNCTION_NAME, - p.X, p.Y, p.Z, allow_generate); - + p.X, p.Y, p.Z, create_blank); + { MapBlock *block = getBlockNoCreateNoEx(p); if(block && block->isDummy() == false) @@ -2576,7 +3000,13 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool allow_generate) return block; } - if(allow_generate) + if (create_blank) { + ServerMapSector *sector = createSector(v2s16(p.X, p.Z)); + MapBlock *block = sector->createBlankBlock(p.Y); + + return block; + } + /*if(allow_generate) { core::map modified_blocks; MapBlock *block = generateBlock(p, modified_blocks); @@ -2596,160 +3026,14 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool allow_generate) // Queue event dispatchEvent(&event); - + return block; } - } + }*/ return NULL; } -#if 0 - /* - Do not generate over-limit - */ - if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) - throw InvalidPositionException("emergeBlock(): pos. over limit"); - - v2s16 p2d(p.X, p.Z); - s16 block_y = p.Y; - /* - This will create or load a sector if not found in memory. - If block exists on disk, it will be loaded. - */ - ServerMapSector *sector; - try{ - sector = createSector(p2d); - //sector = emergeSector(p2d, changed_blocks); - } - catch(InvalidPositionException &e) - { - dstream<<"emergeBlock: createSector() failed: " - <getBlockNoCreateNoEx(block_y); - - // If not found, try loading from disk - if(block == NULL) - { - block = loadBlock(p); - } - - // Handle result - if(block == NULL) - { - does_not_exist = true; - } - else if(block->isDummy() == true) - { - does_not_exist = true; - } - else if(block->getLightingExpired()) - { - lighting_expired = true; - } - else - { - // Valid block - //dstream<<"emergeBlock(): Returning already valid block"<insertBlock(block); - } - // Done. - return block; - } - - //dstream<<"Not found on disk, generating."< making one"< light_sources; - bool black_air_left = false; - bool bottom_invalid = - block->propagateSunlight(light_sources, true, - &black_air_left); - - // If sunlight didn't reach everywhere and part of block is - // above ground, lighting has to be properly updated - //if(black_air_left && some_part_underground) - if(black_air_left) - { - lighting_invalidated_blocks[block->getPos()] = block; - } - - if(bottom_invalid) - { - lighting_invalidated_blocks[block->getPos()] = block; - } - } -#endif - - return block; -} -#endif - s16 ServerMap::findGroundLevel(v2s16 p2d) { #if 0 @@ -2786,8 +3070,8 @@ s16 ServerMap::findGroundLevel(v2s16 p2d) /* Determine from map generator noise functions */ - - s16 level = mapgen::find_ground_level_from_noise(m_seed, p2d, 1); + + s16 level = m_emerge->getGroundLevelAtPoint(p2d); return level; //double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT; @@ -2806,54 +3090,60 @@ void ServerMap::createDatabase() { if(e == SQLITE_ABORT) throw FileNotGoodException("Could not create database structure"); else - dstream<<"Server: Database structure was created"; + infostream<<"ServerMap: Database structure was created"; } void ServerMap::verifyDatabase() { if(m_database) return; - + { - std::string dbp = m_savedir + "/map.sqlite"; + std::string dbp = m_savedir + DIR_DELIM + "map.sqlite"; bool needs_create = false; int d; - + /* Open the database connection */ - + createDirs(m_savedir); - + if(!fs::PathExists(dbp)) needs_create = true; - + d = sqlite3_open_v2(dbp.c_str(), &m_database, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL); if(d != SQLITE_OK) { - dstream<<"WARNING: Database failed to open: "<::Iterator i = m_sectors.getIterator(); for(; i.atEnd() == false; i++) { ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue(); assert(sector->getId() == MAPSECTOR_SERVER); - - if(sector->differs_from_disk || only_changed == false) + + if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN) { saveSectorMeta(sector); sector_meta_count++; @@ -2981,86 +3276,141 @@ void ServerMap::save(bool only_changed) core::list blocks; sector->getBlocks(blocks); core::list::Iterator j; - - //sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL); + for(j=blocks.begin(); j!=blocks.end(); j++) { MapBlock *block = *j; - + block_count_all++; - if(block->getModified() >= MOD_STATE_WRITE_NEEDED - || only_changed == false) + if(block->getModified() >= (u32)save_level) { + // Lazy beginSave() + if(!save_started){ + beginSave(); + save_started = true; + } + + modprofiler.add(block->getModifiedReason(), 1); + saveBlock(block); block_count++; - /*dstream<<"ServerMap: Written block (" + /*infostream<<"ServerMap: Written block (" <getPos().X<<"," <getPos().Y<<"," <getPos().Z<<")" <= 0) + return i % mod; + return mod - ((-i) % mod); +} + +v3s16 ServerMap::getIntegerAsBlock(sqlite3_int64 i) +{ + s32 x = unsignedToSigned(pythonmodulo(i, 4096), 2048); + i = (i - x) / 4096; + s32 y = unsignedToSigned(pythonmodulo(i, 4096), 2048); + i = (i - y) / 4096; + s32 z = unsignedToSigned(pythonmodulo(i, 4096), 2048); + return v3s16(x,y,z); +} + +void ServerMap::listAllLoadableBlocks(core::list &dst) +{ + if(loadFromFolders()){ + errorstream<<"Map::listAllLoadableBlocks(): Result will be missing " + <<"all blocks that are stored in flat files"<setParamsToSettings(¶ms); params.writeLines(os); os<<"[end_of_params]\n"; - + m_map_metadata_changed = false; } void ServerMap::loadMapMeta() { DSTACK(__FUNCTION_NAME); - - dstream<<"INFO: ServerMap::loadMapMeta(): Loading map metadata" - <getParamsFromSettings(¶ms); + if (mgparams) { + if (m_mgparams) + delete m_mgparams; + m_mgparams = mgparams; + m_seed = mgparams->seed; + } else { + if (params.exists("seed")) { + m_seed = params.getU64("seed"); + m_mgparams->seed = m_seed; + } + } - dstream<<"INFO: ServerMap::loadMapMeta(): " - <<"seed="<serialize(o, version); - + sector->differs_from_disk = false; } @@ -3115,7 +3474,7 @@ MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load ServerMapSector *sector = NULL; - std::string fullpath = sectordir + "/meta"; + std::string fullpath = sectordir + DIR_DELIM + "meta"; std::ifstream is(fullpath.c_str(), std::ios_base::binary); if(is.good() == false) { @@ -3123,11 +3482,11 @@ MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load // format. Just go ahead and create the sector. if(fs::PathExists(sectordir)) { - /*dstream<<"ServerMap::loadSectorMeta(): Sector metafile " + /*infostream<<"ServerMap::loadSectorMeta(): Sector metafile " <differs_from_disk = false; return sector; @@ -3187,7 +3546,7 @@ bool ServerMap::loadSectorMeta(v2s16 p2d) { return false; } - + return true; } @@ -3231,7 +3590,7 @@ bool ServerMap::loadSectorFull(v2s16 p2d) { return false; } - + /* Load blocks */ @@ -3254,7 +3613,7 @@ bool ServerMap::loadSectorFull(v2s16 p2d) if(loadlayout != 2) { - dstream<<"Sector converted to new layout - deleting "<< + infostream<<"Sector converted to new layout - deleting "<< sectordir1<isDummy()) { /*v3s16 p = block->getPos(); - dstream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block " + infostream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block " <<"("<getPos(); - - + + #if 0 v2s16 p2d(p3d.X, p3d.Z); std::string sectordir = getSectorDir(p2d); createDirs(sectordir); - std::string fullpath = sectordir+"/"+getBlockFilename(p3d); + std::string fullpath = sectordir+DIR_DELIM+getBlockFilename(p3d); std::ofstream o(fullpath.c_str(), std::ios_base::binary); if(o.good() == false) throw FileNotGoodException("Cannot open block data"); @@ -3310,55 +3669,60 @@ void ServerMap::saveBlock(MapBlock *block) [0] u8 serialization version [1] data */ - + verifyDatabase(); - + std::ostringstream o(std::ios_base::binary); - + o.write((char*)&version, 1); - + // Write basic data - block->serialize(o, version); - - // Write extra data stored on disk - block->serializeDiskExtra(o, version); - + block->serialize(o, version, true); + // Write block to database - + std::string tmp = o.str(); const char *bytes = tmp.c_str(); - - if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK) - dstream<<"WARNING: Block position failed to bind: "<resetModified(); + if (success) + block->resetModified(); } void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load) { DSTACK(__FUNCTION_NAME); - std::string fullpath = sectordir+"/"+blockfile; + 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); @@ -3381,17 +3745,14 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto block = sector->createBlankBlockNoInsert(p3d.Y); created_new = true; } - + // Read basic data - block->deSerialize(is, version); + block->deSerialize(is, version, true); - // Read extra data stored on disk - block->deSerializeDiskExtra(is, version); - // 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 */ @@ -3399,18 +3760,18 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto if(version < SER_FMT_VER_HIGHEST || 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) { - dstream<<"WARNING: Invalid block data on disk " + infostream<<"WARNING: Invalid block data on disk " <<"fullpath="<getBool("ignore_world_load_errors")){ + errorstream<<"Ignoring block load error. Duck and cover! " + <<"(ignore_world_load_errors)"<(-BS*1000000,-BS*1000000,-BS*1000000, - BS*1000000,BS*1000000,BS*1000000); -} - -ClientMap::~ClientMap() -{ - /*JMutexAutoLock lock(mesh_mutex); - - if(mesh != NULL) - { - mesh->drop(); - mesh = NULL; - }*/ -} - -MapSector * ClientMap::emergeSector(v2s16 p2d) -{ - DSTACK(__FUNCTION_NAME); - // Check that it doesn't exist already - try{ - return getSectorNoGenerate(p2d); - } - catch(InvalidPositionException &e) - { - } - - // Create a sector - ClientMapSector *sector = new ClientMapSector(this, p2d); - - { - //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out - m_sectors.insert(p2d, sector); - } - - return sector; -} - -#if 0 -void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is) -{ - DSTACK(__FUNCTION_NAME); - ClientMapSector *sector = NULL; - - //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out - - core::map::Node *n = m_sectors.find(p2d); - - if(n != NULL) - { - sector = (ClientMapSector*)n->getValue(); - assert(sector->getId() == MAPSECTOR_CLIENT); - } - else - { - sector = new ClientMapSector(this, p2d); - { - //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out - m_sectors.insert(p2d, sector); - } - } - - sector->deSerialize(is); -} -#endif - -void ClientMap::OnRegisterSceneNode() -{ - if(IsVisible) - { - SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID); - SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT); - } - - ISceneNode::OnRegisterSceneNode(); -} - -void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) -{ - //m_dout<getDayNightRatio(); - - m_camera_mutex.Lock(); - v3f camera_position = m_camera_position; - v3f camera_direction = m_camera_direction; - m_camera_mutex.Unlock(); - - /* - Get all blocks and draw all visible ones - */ - - v3s16 cam_pos_nodes( - camera_position.X / BS, - camera_position.Y / BS, - camera_position.Z / BS); - - v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1); - - v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d; - v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d; - - // Take a fair amount as we will be dropping more out later - v3s16 p_blocks_min( - p_nodes_min.X / MAP_BLOCKSIZE - 2, - p_nodes_min.Y / MAP_BLOCKSIZE - 2, - p_nodes_min.Z / MAP_BLOCKSIZE - 2); - v3s16 p_blocks_max( - p_nodes_max.X / MAP_BLOCKSIZE + 1, - p_nodes_max.Y / MAP_BLOCKSIZE + 1, - p_nodes_max.Z / MAP_BLOCKSIZE + 1); - - u32 vertex_count = 0; - - // For limiting number of mesh updates per frame - u32 mesh_update_count = 0; - - u32 blocks_would_have_drawn = 0; - u32 blocks_drawn = 0; - - int timecheck_counter = 0; - core::map::Iterator si; - si = m_sectors.getIterator(); - for(; si.atEnd() == false; si++) - { - { - timecheck_counter++; - if(timecheck_counter > 50) - { - timecheck_counter = 0; - int time2 = time(0); - if(time2 > time1 + 4) - { - dstream<<"ClientMap::renderMap(): " - "Rendering takes ages, returning." - <getValue(); - v2s16 sp = sector->getPos(); - - if(m_control.range_all == false) - { - if(sp.X < p_blocks_min.X - || sp.X > p_blocks_max.X - || sp.Y < p_blocks_min.Z - || sp.Y > p_blocks_max.Z) - continue; - } - - core::list< MapBlock * > sectorblocks; - sector->getBlocks(sectorblocks); - - /* - Draw blocks - */ - - u32 sector_blocks_drawn = 0; - - core::list< MapBlock * >::Iterator i; - for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) - { - MapBlock *block = *i; - - /* - Compare block position to camera position, skip - if not seen on display - */ - - float range = 100000 * BS; - if(m_control.range_all == false) - range = m_control.wanted_range * BS; - - float d = 0.0; - if(isBlockInSight(block->getPos(), camera_position, - camera_direction, range, &d) == false) - { - continue; - } - - // Okay, this block will be drawn. Reset usage timer. - block->resetUsageTimer(); - - // This is ugly (spherical distance limit?) - /*if(m_control.range_all == false && - d - 0.5*BS*MAP_BLOCKSIZE > range) - continue;*/ - -#if 1 - /* - Update expired mesh (used for day/night change) - - It doesn't work exactly like it should now with the - tasked mesh update but whatever. - */ - - bool mesh_expired = false; - - { - JMutexAutoLock lock(block->mesh_mutex); - - mesh_expired = block->getMeshExpired(); - - // Mesh has not been expired and there is no mesh: - // block has no content - if(block->mesh == NULL && mesh_expired == false) - continue; - } - - f32 faraway = BS*50; - //f32 faraway = m_control.wanted_range * BS; - - /* - This has to be done with the mesh_mutex unlocked - */ - // Pretty random but this should work somewhat nicely - if(mesh_expired && ( - (mesh_update_count < 3 - && (d < faraway || mesh_update_count < 2) - ) - || - (m_control.range_all && mesh_update_count < 20) - ) - ) - /*if(mesh_expired && mesh_update_count < 6 - && (d < faraway || mesh_update_count < 3))*/ - { - mesh_update_count++; - - // Mesh has been expired: generate new mesh - //block->updateMesh(daynight_ratio); - m_client->addUpdateMeshTask(block->getPos()); - - mesh_expired = false; - } - -#endif - /* - Draw the faces of the block - */ - { - JMutexAutoLock lock(block->mesh_mutex); - - scene::SMesh *mesh = block->mesh; - - if(mesh == NULL) - continue; - - blocks_would_have_drawn++; - if(blocks_drawn >= m_control.wanted_max_blocks - && m_control.range_all == false - && d > m_control.wanted_min_range * BS) - continue; - - blocks_drawn++; - sector_blocks_drawn++; - - u32 c = mesh->getMeshBufferCount(); - - for(u32 i=0; igetMeshBuffer(i); - const video::SMaterial& material = buf->getMaterial(); - video::IMaterialRenderer* rnd = - driver->getMaterialRenderer(material.MaterialType); - bool transparent = (rnd && rnd->isTransparent()); - // Render transparent on transparent pass and likewise. - if(transparent == is_transparent_pass) - { - /* - This *shouldn't* hurt too much because Irrlicht - doesn't change opengl textures if the old - material is set again. - */ - driver->setMaterial(buf->getMaterial()); - driver->drawMeshBuffer(buf); - vertex_count += buf->getVertexCount(); - } - } - } - } // foreach sectorblocks - - if(sector_blocks_drawn != 0) - { - m_last_drawn_sectors[sp] = true; - } - } - - m_control.blocks_drawn = blocks_drawn; - m_control.blocks_would_have_drawn = blocks_would_have_drawn; - - /*dstream<<"renderMap(): is_transparent_pass="< *affected_blocks) -{ - bool changed = false; - /* - Add it to all blocks touching it - */ - v3s16 dirs[7] = { - v3s16(0,0,0), // this - 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 - }; - for(u16 i=0; i<7; i++) - { - v3s16 p2 = p + dirs[i]; - // Block position of neighbor (or requested) node - v3s16 blockpos = getNodeBlockPos(p2); - MapBlock * blockref = getBlockNoCreateNoEx(blockpos); - if(blockref == NULL) - continue; - // Relative position of requested node - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - if(blockref->setTempMod(relpos, mod)) - { - changed = true; - } - } - if(changed && affected_blocks!=NULL) - { - for(u16 i=0; i<7; i++) - { - v3s16 p2 = p + dirs[i]; - // Block position of neighbor (or requested) node - v3s16 blockpos = getNodeBlockPos(p2); - MapBlock * blockref = getBlockNoCreateNoEx(blockpos); - if(blockref == NULL) - continue; - affected_blocks->insert(blockpos, blockref); - } - } - return changed; -} - -bool ClientMap::clearTempMod(v3s16 p, - core::map *affected_blocks) -{ - bool changed = false; - v3s16 dirs[7] = { - v3s16(0,0,0), // this - 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 - }; - for(u16 i=0; i<7; i++) - { - v3s16 p2 = p + dirs[i]; - // Block position of neighbor (or requested) node - v3s16 blockpos = getNodeBlockPos(p2); - MapBlock * blockref = getBlockNoCreateNoEx(blockpos); - if(blockref == NULL) - continue; - // Relative position of requested node - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - if(blockref->clearTempMod(relpos)) - { - changed = true; - } - } - if(changed && affected_blocks!=NULL) - { - for(u16 i=0; i<7; i++) - { - v3s16 p2 = p + dirs[i]; - // Block position of neighbor (or requested) node - v3s16 blockpos = getNodeBlockPos(p2); - MapBlock * blockref = getBlockNoCreateNoEx(blockpos); - if(blockref == NULL) - continue; - affected_blocks->insert(blockpos, blockref); - } - } - return changed; -} - -void ClientMap::expireMeshes(bool only_daynight_diffed) -{ - TimeTaker timer("expireMeshes()"); - - core::map::Iterator si; - si = m_sectors.getIterator(); - for(; si.atEnd() == false; si++) - { - MapSector *sector = si.getNode()->getValue(); - - core::list< MapBlock * > sectorblocks; - sector->getBlocks(sectorblocks); - - core::list< MapBlock * >::Iterator i; - for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) - { - MapBlock *block = *i; - - if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false) - { - continue; - } - - { - JMutexAutoLock lock(block->mesh_mutex); - if(block->mesh != NULL) - { - /*block->mesh->drop(); - block->mesh = NULL;*/ - block->setMeshExpired(true); - } - } - } - } -} - -void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio) -{ - assert(mapType() == MAPTYPE_CLIENT); - - try{ - v3s16 p = blockpos + v3s16(0,0,0); - MapBlock *b = getBlockNoCreate(p); - b->updateMesh(daynight_ratio); - //b->setMeshExpired(true); - } - catch(InvalidPositionException &e){} - // Leading edge - try{ - v3s16 p = blockpos + v3s16(-1,0,0); - MapBlock *b = getBlockNoCreate(p); - b->updateMesh(daynight_ratio); - //b->setMeshExpired(true); - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,-1,0); - MapBlock *b = getBlockNoCreate(p); - b->updateMesh(daynight_ratio); - //b->setMeshExpired(true); - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,0,-1); - MapBlock *b = getBlockNoCreate(p); - b->updateMesh(daynight_ratio); - //b->setMeshExpired(true); - } - catch(InvalidPositionException &e){} -} - -#if 0 -/* - Update mesh of block in which the node is, and if the node is at the - leading edge, update the appropriate leading blocks too. -*/ -void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio) -{ - v3s16 dirs[4] = { - v3s16(0,0,0), - v3s16(-1,0,0), - v3s16(0,-1,0), - v3s16(0,0,-1), - }; - v3s16 blockposes[4]; - for(u32 i=0; i<4; i++) - { - v3s16 np = nodepos + dirs[i]; - blockposes[i] = getNodeBlockPos(np); - // Don't update mesh of block if it has been done already - bool already_updated = false; - for(u32 j=0; jupdateMesh(daynight_ratio); - } -} -#endif - -void ClientMap::PrintInfo(std::ostream &out) -{ - out<<"ClientMap: "; -} - -#endif // !SERVER - /* MapVoxelManipulator */ @@ -4144,7 +3963,7 @@ MapVoxelManipulator::MapVoxelManipulator(Map *map) MapVoxelManipulator::~MapVoxelManipulator() { - /*dstream<<"MapVoxelManipulator: blocks: "<::Node *n; + core::map::Node *n; n = m_loaded_blocks.find(p); if(n != NULL) continue; - + bool block_data_inexistent = false; try { TimeTaker timer1("emerge load", &emerge_load_time); - /*dstream<<"Loading block (caller_id="<getBlockNoCreate(p); + a.print(infostream); + infostream<getBlockNoCreate(p); if(block->isDummy()) block_data_inexistent = true; else @@ -4195,6 +4016,8 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id) if(block_data_inexistent) { + flags |= VMANIP_BLOCK_DATA_INEXIST; + VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1)); // Fill with VOXELFLAG_INEXISTENT for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++) @@ -4204,11 +4027,16 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id) memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE); } } + /*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE) + { + // Mark that block was loaded as blank + flags |= VMANIP_BLOCK_CONTAINS_CIGNORE; + }*/ - m_loaded_blocks.insert(p, !block_data_inexistent); + m_loaded_blocks.insert(p, flags); } - //dstream<<"emerge done"<::Node *n; + core::map::Node *n; n = m_loaded_blocks.find(p); if(n != NULL) continue; - + bool block_data_inexistent = false; try { TimeTaker timer1("emerge load", &emerge_load_time); - MapBlock *block = m_map->getBlockNoCreate(p); + block = m_map->getBlockNoCreate(p); if(block->isDummy()) block_data_inexistent = true; else @@ -4349,6 +4179,8 @@ void ManualMapVoxelManipulator::initialEmerge( if(block_data_inexistent) { + flags |= VMANIP_BLOCK_DATA_INEXIST; + /* Mark area inexistent */ @@ -4361,8 +4193,13 @@ void ManualMapVoxelManipulator::initialEmerge( memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE); } } + /*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE) + { + // Mark that block was loaded as blank + flags |= VMANIP_BLOCK_CONTAINS_CIGNORE; + }*/ - m_loaded_blocks.insert(p, !block_data_inexistent); + m_loaded_blocks.insert(p, flags); } } @@ -4371,28 +4208,31 @@ void ManualMapVoxelManipulator::blitBackAll( { if(m_area.getExtent() == v3s16(0,0,0)) return; - + /* Copy data of all blocks */ - for(core::map::Iterator + for(core::map::Iterator i = m_loaded_blocks.getIterator(); i.atEnd() == false; i++) { v3s16 p = i.getNode()->getKey(); - bool existed = i.getNode()->getValue(); + u8 flags = i.getNode()->getValue(); + + bool existed = !(flags & VMANIP_BLOCK_DATA_INEXIST); if(existed == false) { // The Great Bug was found using this - /*dstream<<"ManualMapVoxelManipulator::blitBackAll: " + /*infostream<<"ManualMapVoxelManipulator::blitBackAll: " <<"Inexistent ("<getBlockNoCreateNoEx(p); if(block == NULL) { - dstream<<"WARNING: "<<__FUNCTION_NAME + infostream<<"WARNING: "<<__FUNCTION_NAME <<": got NULL block " <<"("<copyFrom(*this); - + if(modified_blocks) modified_blocks->insert(p, block); }