src/map.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "map.h"
  21 #include "mapsector.h"
  22 #include "mapblock.h"
  23 #include "filesys.h"
  24 #include "voxel.h"
  25 #include "voxelalgorithms.h"
  26 #include "porting.h"
  27 #include "serialization.h"
  28 #include "nodemetadata.h"
  29 #include "settings.h"
  30 #include "log.h"
  31 #include "profiler.h"
  32 #include "nodedef.h"
  33 #include "gamedef.h"
  34 #include "util/directiontables.h"
  35 #include "util/basic_macros.h"
  36 #include "rollback_interface.h"
  37 #include "environment.h"
  38 #include "reflowscan.h"
  39 #include "emerge.h"
  40 #include "mapgen/mapgen_v6.h"
  41 #include "mapgen/mg_biome.h"
  42 #include "config.h"
  43 #include "server.h"
  44 #include "database/database.h"
  45 #include "database/database-dummy.h"
  46 #include "database/database-sqlite3.h"
  47 #include "script/scripting_server.h"
  48 #include <deque>
  49 #include <queue>
  50 #if USE_LEVELDB
  51 #include "database/database-leveldb.h"
  52 #endif
  53 #if USE_REDIS
  54 #include "database/database-redis.h"
  55 #endif
  56 #if USE_POSTGRESQL
  57 #include "database/database-postgresql.h"
  58 #endif
  59
  60
  61 /*
  62         Map
  63 */
  64
  65 Map::Map(std::ostream &dout, IGameDef *gamedef):
  66         m_dout(dout),
  67         m_gamedef(gamedef),
  68         m_nodedef(gamedef->ndef())
  69 {
  70 }
  71
  72 Map::~Map()
  73 {
  74         /*
  75                 Free all MapSectors
  76         */
  77         for (auto &sector : m_sectors) {
  78                 delete sector.second;
  79         }
  80 }
  81
  82 void Map::addEventReceiver(MapEventReceiver *event_receiver)
  83 {
  84         m_event_receivers.insert(event_receiver);
  85 }
  86
  87 void Map::removeEventReceiver(MapEventReceiver *event_receiver)
  88 {
  89         m_event_receivers.erase(event_receiver);
  90 }
  91
  92 void Map::dispatchEvent(MapEditEvent *event)
  93 {
  94         for (MapEventReceiver *event_receiver : m_event_receivers) {
  95                 event_receiver->onMapEditEvent(event);
  96         }
  97 }
  98
  99 MapSector * Map::getSectorNoGenerateNoLock(v2s16 p)
 100 {
 101         if(m_sector_cache != NULL && p == m_sector_cache_p){
 102                 MapSector * sector = m_sector_cache;
 103                 return sector;
 104         }
 105
 106         std::map<v2s16, MapSector*>::iterator n = m_sectors.find(p);
 107
 108         if (n == m_sectors.end())
 109                 return NULL;
 110
 111         MapSector *sector = n->second;
 112
 113         // Cache the last result
 114         m_sector_cache_p = p;
 115         m_sector_cache = sector;
 116
 117         return sector;
 118 }
 119
 120 MapSector * Map::getSectorNoGenerate(v2s16 p)
 121 {
 122         return getSectorNoGenerateNoLock(p);
 123 }
 124
 125 MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d)
 126 {
 127         v2s16 p2d(p3d.X, p3d.Z);
 128         MapSector * sector = getSectorNoGenerate(p2d);
 129         if(sector == NULL)
 130                 return NULL;
 131         MapBlock *block = sector->getBlockNoCreateNoEx(p3d.Y);
 132         return block;
 133 }
 134
 135 MapBlock * Map::getBlockNoCreate(v3s16 p3d)
 136 {
 137         MapBlock *block = getBlockNoCreateNoEx(p3d);
 138         if(block == NULL)
 139                 throw InvalidPositionException();
 140         return block;
 141 }
 142
 143 bool Map::isNodeUnderground(v3s16 p)
 144 {
 145         v3s16 blockpos = getNodeBlockPos(p);
 146         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 147         return block && block->getIsUnderground();
 148 }
 149
 150 bool Map::isValidPosition(v3s16 p)
 151 {
 152         v3s16 blockpos = getNodeBlockPos(p);
 153         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 154         return (block != NULL);
 155 }
 156
 157 // Returns a CONTENT_IGNORE node if not found
 158 MapNode Map::getNode(v3s16 p, bool *is_valid_position)
 159 {
 160         v3s16 blockpos = getNodeBlockPos(p);
 161         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 162         if (block == NULL) {
 163                 if (is_valid_position != NULL)
 164                         *is_valid_position = false;
 165                 return {CONTENT_IGNORE};
 166         }
 167
 168         v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 169         bool is_valid_p;
 170         MapNode node = block->getNodeNoCheck(relpos, &is_valid_p);
 171         if (is_valid_position != NULL)
 172                 *is_valid_position = is_valid_p;
 173         return node;
 174 }
 175
 176 // throws InvalidPositionException if not found
 177 void Map::setNode(v3s16 p, MapNode & n)
 178 {
 179         v3s16 blockpos = getNodeBlockPos(p);
 180         MapBlock *block = getBlockNoCreate(blockpos);
 181         v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 182         // Never allow placing CONTENT_IGNORE, it fucks up stuff
 183         if(n.getContent() == CONTENT_IGNORE){
 184                 bool temp_bool;
 185                 errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
 186                                 <<" while trying to replace \""
 187                                 <<m_nodedef->get(block->getNodeNoCheck(relpos, &temp_bool)).name
 188                                 <<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
 189                 return;
 190         }
 191         block->setNodeNoCheck(relpos, n);
 192 }
 193
 194 void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 195                 std::map<v3s16, MapBlock*> &modified_blocks,
 196                 bool remove_metadata)
 197 {
 198         // Collect old node for rollback
 199         RollbackNode rollback_oldnode(this, p, m_gamedef);
 200
 201         // This is needed for updating the lighting
 202         MapNode oldnode = getNode(p);
 203
 204         // Remove node metadata
 205         if (remove_metadata) {
 206                 removeNodeMetadata(p);
 207         }
 208
 209         // Set the node on the map
 210         // Ignore light (because calling voxalgo::update_lighting_nodes)
 211         n.setLight(LIGHTBANK_DAY, 0, m_nodedef);
 212         n.setLight(LIGHTBANK_NIGHT, 0, m_nodedef);
 213         setNode(p, n);
 214
 215         // Update lighting
 216         std::vector<std::pair<v3s16, MapNode> > oldnodes;
 217         oldnodes.emplace_back(p, oldnode);
 218         voxalgo::update_lighting_nodes(this, oldnodes, modified_blocks);
 219
 220         for (auto &modified_block : modified_blocks) {
 221                 modified_block.second->expireDayNightDiff();
 222         }
 223
 224         // Report for rollback
 225         if(m_gamedef->rollback())
 226         {
 227                 RollbackNode rollback_newnode(this, p, m_gamedef);
 228                 RollbackAction action;
 229                 action.setSetNode(p, rollback_oldnode, rollback_newnode);
 230                 m_gamedef->rollback()->reportAction(action);
 231         }
 232
 233         /*
 234                 Add neighboring liquid nodes and this node to transform queue.
 235                 (it's vital for the node itself to get updated last, if it was removed.)
 236          */
 237
 238         for (const v3s16 &dir : g_7dirs) {
 239                 v3s16 p2 = p + dir;
 240
 241                 bool is_valid_position;
 242                 MapNode n2 = getNode(p2, &is_valid_position);
 243                 if(is_valid_position &&
 244                                 (m_nodedef->get(n2).isLiquid() ||
 245                                 n2.getContent() == CONTENT_AIR))
 246                         m_transforming_liquid.push_back(p2);
 247         }
 248 }
 249
 250 void Map::removeNodeAndUpdate(v3s16 p,
 251                 std::map<v3s16, MapBlock*> &modified_blocks)
 252 {
 253         addNodeAndUpdate(p, MapNode(CONTENT_AIR), modified_blocks, true);
 254 }
 255
 256 bool Map::addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata)
 257 {
 258         MapEditEvent event;
 259         event.type = remove_metadata ? MEET_ADDNODE : MEET_SWAPNODE;
 260         event.p = p;
 261         event.n = n;
 262
 263         bool succeeded = true;
 264         try{
 265                 std::map<v3s16, MapBlock*> modified_blocks;
 266                 addNodeAndUpdate(p, n, modified_blocks, remove_metadata);
 267
 268                 // Copy modified_blocks to event
 269                 for (auto &modified_block : modified_blocks) {
 270                         event.modified_blocks.insert(modified_block.first);
 271                 }
 272         }
 273         catch(InvalidPositionException &e){
 274                 succeeded = false;
 275         }
 276
 277         dispatchEvent(&event);
 278
 279         return succeeded;
 280 }
 281
 282 bool Map::removeNodeWithEvent(v3s16 p)
 283 {
 284         MapEditEvent event;
 285         event.type = MEET_REMOVENODE;
 286         event.p = p;
 287
 288         bool succeeded = true;
 289         try{
 290                 std::map<v3s16, MapBlock*> modified_blocks;
 291                 removeNodeAndUpdate(p, modified_blocks);
 292
 293                 // Copy modified_blocks to event
 294                 for (auto &modified_block : modified_blocks) {
 295                         event.modified_blocks.insert(modified_block.first);
 296                 }
 297         }
 298         catch(InvalidPositionException &e){
 299                 succeeded = false;
 300         }
 301
 302         dispatchEvent(&event);
 303
 304         return succeeded;
 305 }
 306
 307 struct TimeOrderedMapBlock {
 308         MapSector *sect;
 309         MapBlock *block;
 310
 311         TimeOrderedMapBlock(MapSector *sect, MapBlock *block) :
 312                 sect(sect),
 313                 block(block)
 314         {}
 315
 316         bool operator<(const TimeOrderedMapBlock &b) const
 317         {
 318                 return block->getUsageTimer() < b.block->getUsageTimer();
 319         };
 320 };
 321
 322 /*
 323         Updates usage timers
 324 */
 325 void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks,
 326                 std::vector<v3s16> *unloaded_blocks)
 327 {
 328         bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
 329
 330         // Profile modified reasons
 331         Profiler modprofiler;
 332
 333         std::vector<v2s16> sector_deletion_queue;
 334         u32 deleted_blocks_count = 0;
 335         u32 saved_blocks_count = 0;
 336         u32 block_count_all = 0;
 337
 338         beginSave();
 339
 340         // If there is no practical limit, we spare creation of mapblock_queue
 341         if (max_loaded_blocks == U32_MAX) {
 342                 for (auto &sector_it : m_sectors) {
 343                         MapSector *sector = sector_it.second;
 344
 345                         bool all_blocks_deleted = true;
 346
 347                         MapBlockVect blocks;
 348                         sector->getBlocks(blocks);
 349
 350                         for (MapBlock *block : blocks) {
 351                                 block->incrementUsageTimer(dtime);
 352
 353                                 if (block->refGet() == 0
 354                                                 && block->getUsageTimer() > unload_timeout) {
 355                                         v3s16 p = block->getPos();
 356
 357                                         // Save if modified
 358                                         if (block->getModified() != MOD_STATE_CLEAN
 359                                                         && save_before_unloading) {
 360                                                 modprofiler.add(block->getModifiedReasonString(), 1);
 361                                                 if (!saveBlock(block))
 362                                                         continue;
 363                                                 saved_blocks_count++;
 364                                         }
 365
 366                                         // Delete from memory
 367                                         sector->deleteBlock(block);
 368
 369                                         if (unloaded_blocks)
 370                                                 unloaded_blocks->push_back(p);
 371
 372                                         deleted_blocks_count++;
 373                                 } else {
 374                                         all_blocks_deleted = false;
 375                                         block_count_all++;
 376                                 }
 377                         }
 378
 379                         if (all_blocks_deleted) {
 380                                 sector_deletion_queue.push_back(sector_it.first);
 381                         }
 382                 }
 383         } else {
 384                 std::priority_queue<TimeOrderedMapBlock> mapblock_queue;
 385                 for (auto &sector_it : m_sectors) {
 386                         MapSector *sector = sector_it.second;
 387
 388                         MapBlockVect blocks;
 389                         sector->getBlocks(blocks);
 390
 391                         for (MapBlock *block : blocks) {
 392                                 block->incrementUsageTimer(dtime);
 393                                 mapblock_queue.push(TimeOrderedMapBlock(sector, block));
 394                         }
 395                 }
 396                 block_count_all = mapblock_queue.size();
 397                 // Delete old blocks, and blocks over the limit from the memory
 398                 while (!mapblock_queue.empty() && (mapblock_queue.size() > max_loaded_blocks
 399                                 || mapblock_queue.top().block->getUsageTimer() > unload_timeout)) {
 400                         TimeOrderedMapBlock b = mapblock_queue.top();
 401                         mapblock_queue.pop();
 402
 403                         MapBlock *block = b.block;
 404
 405                         if (block->refGet() != 0)
 406                                 continue;
 407
 408                         v3s16 p = block->getPos();
 409
 410                         // Save if modified
 411                         if (block->getModified() != MOD_STATE_CLEAN && save_before_unloading) {
 412                                 modprofiler.add(block->getModifiedReasonString(), 1);
 413                                 if (!saveBlock(block))
 414                                         continue;
 415                                 saved_blocks_count++;
 416                         }
 417
 418                         // Delete from memory
 419                         b.sect->deleteBlock(block);
 420
 421                         if (unloaded_blocks)
 422                                 unloaded_blocks->push_back(p);
 423
 424                         deleted_blocks_count++;
 425                         block_count_all--;
 426                 }
 427                 // Delete empty sectors
 428                 for (auto &sector_it : m_sectors) {
 429                         if (sector_it.second->empty()) {
 430                                 sector_deletion_queue.push_back(sector_it.first);
 431                         }
 432                 }
 433         }
 434         endSave();
 435
 436         // Finally delete the empty sectors
 437         deleteSectors(sector_deletion_queue);
 438
 439         if(deleted_blocks_count != 0)
 440         {
 441                 PrintInfo(infostream); // ServerMap/ClientMap:
 442                 infostream<<"Unloaded "<<deleted_blocks_count
 443                                 <<" blocks from memory";
 444                 if(save_before_unloading)
 445                         infostream<<", of which "<<saved_blocks_count<<" were written";
 446                 infostream<<", "<<block_count_all<<" blocks in memory";
 447                 infostream<<"."<<std::endl;
 448                 if(saved_blocks_count != 0){
 449                         PrintInfo(infostream); // ServerMap/ClientMap:
 450                         infostream<<"Blocks modified by: "<<std::endl;
 451                         modprofiler.print(infostream);
 452                 }
 453         }
 454 }
 455
 456 void Map::unloadUnreferencedBlocks(std::vector<v3s16> *unloaded_blocks)
 457 {
 458         timerUpdate(0.0, -1.0, 0, unloaded_blocks);
 459 }
 460
 461 void Map::deleteSectors(std::vector<v2s16> &sectorList)
 462 {
 463         for (v2s16 j : sectorList) {
 464                 MapSector *sector = m_sectors[j];
 465                 // If sector is in sector cache, remove it from there
 466                 if(m_sector_cache == sector)
 467                         m_sector_cache = NULL;
 468                 // Remove from map and delete
 469                 m_sectors.erase(j);
 470                 delete sector;
 471         }
 472 }
 473
 474 void Map::PrintInfo(std::ostream &out)
 475 {
 476         out<<"Map: ";
 477 }
 478
 479 #define WATER_DROP_BOOST 4
 480
 481 enum NeighborType : u8 {
 482         NEIGHBOR_UPPER,
 483         NEIGHBOR_SAME_LEVEL,
 484         NEIGHBOR_LOWER
 485 };
 486
 487 struct NodeNeighbor {
 488         MapNode n;
 489         NeighborType t;
 490         v3s16 p;
 491
 492         NodeNeighbor()
 493                 : n(CONTENT_AIR), t(NEIGHBOR_SAME_LEVEL)
 494         { }
 495
 496         NodeNeighbor(const MapNode &node, NeighborType n_type, const v3s16 &pos)
 497                 : n(node),
 498                   t(n_type),
 499                   p(pos)
 500         { }
 501 };
 502
 503 void Map::transforming_liquid_add(v3s16 p) {
 504         m_transforming_liquid.push_back(p);
 505 }
 506
 507 void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks,
 508                 ServerEnvironment *env)
 509 {
 510         u32 loopcount = 0;
 511         u32 initial_size = m_transforming_liquid.size();
 512
 513         /*if(initial_size != 0)
 514                 infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
 515
 516         // list of nodes that due to viscosity have not reached their max level height
 517         std::deque<v3s16> must_reflow;
 518
 519         std::vector<std::pair<v3s16, MapNode> > changed_nodes;
 520
 521         u32 liquid_loop_max = g_settings->getS32("liquid_loop_max");
 522         u32 loop_max = liquid_loop_max;
 523
 524 #if 0
 525
 526         /* If liquid_loop_max is not keeping up with the queue size increase
 527          * loop_max up to a maximum of liquid_loop_max * dedicated_server_step.
 528          */
 529         if (m_transforming_liquid.size() > loop_max * 2) {
 530                 // "Burst" mode
 531                 float server_step = g_settings->getFloat("dedicated_server_step");
 532                 if (m_transforming_liquid_loop_count_multiplier - 1.0 < server_step)
 533                         m_transforming_liquid_loop_count_multiplier *= 1.0 + server_step / 10;
 534         } else {
 535                 m_transforming_liquid_loop_count_multiplier = 1.0;
 536         }
 537
 538         loop_max *= m_transforming_liquid_loop_count_multiplier;
 539 #endif
 540
 541         while (m_transforming_liquid.size() != 0)
 542         {
 543                 // This should be done here so that it is done when continue is used
 544                 if (loopcount >= initial_size || loopcount >= loop_max)
 545                         break;
 546                 loopcount++;
 547
 548                 /*
 549                         Get a queued transforming liquid node
 550                 */
 551                 v3s16 p0 = m_transforming_liquid.front();
 552                 m_transforming_liquid.pop_front();
 553
 554                 MapNode n0 = getNode(p0);
 555
 556                 /*
 557                         Collect information about current node
 558                  */
 559                 s8 liquid_level = -1;
 560                 // The liquid node which will be placed there if
 561                 // the liquid flows into this node.
 562                 content_t liquid_kind = CONTENT_IGNORE;
 563                 // The node which will be placed there if liquid
 564                 // can't flow into this node.
 565                 content_t floodable_node = CONTENT_AIR;
 566                 const ContentFeatures &cf = m_nodedef->get(n0);
 567                 LiquidType liquid_type = cf.liquid_type;
 568                 switch (liquid_type) {
 569                         case LIQUID_SOURCE:
 570                                 liquid_level = LIQUID_LEVEL_SOURCE;
 571                                 liquid_kind = m_nodedef->getId(cf.liquid_alternative_flowing);
 572                                 break;
 573                         case LIQUID_FLOWING:
 574                                 liquid_level = (n0.param2 & LIQUID_LEVEL_MASK);
 575                                 liquid_kind = n0.getContent();
 576                                 break;
 577                         case LIQUID_NONE:
 578                                 // if this node is 'floodable', it *could* be transformed
 579                                 // into a liquid, otherwise, continue with the next node.
 580                                 if (!cf.floodable)
 581                                         continue;
 582                                 floodable_node = n0.getContent();
 583                                 liquid_kind = CONTENT_AIR;
 584                                 break;
 585                 }
 586
 587                 /*
 588                         Collect information about the environment
 589                  */
 590                 const v3s16 *dirs = g_6dirs;
 591                 NodeNeighbor sources[6]; // surrounding sources
 592                 int num_sources = 0;
 593                 NodeNeighbor flows[6]; // surrounding flowing liquid nodes
 594                 int num_flows = 0;
 595                 NodeNeighbor airs[6]; // surrounding air
 596                 int num_airs = 0;
 597                 NodeNeighbor neutrals[6]; // nodes that are solid or another kind of liquid
 598                 int num_neutrals = 0;
 599                 bool flowing_down = false;
 600                 bool ignored_sources = false;
 601                 for (u16 i = 0; i < 6; i++) {
 602                         NeighborType nt = NEIGHBOR_SAME_LEVEL;
 603                         switch (i) {
 604                                 case 1:
 605                                         nt = NEIGHBOR_UPPER;
 606                                         break;
 607                                 case 4:
 608                                         nt = NEIGHBOR_LOWER;
 609                                         break;
 610                                 default:
 611                                         break;
 612                         }
 613                         v3s16 npos = p0 + dirs[i];
 614                         NodeNeighbor nb(getNode(npos), nt, npos);
 615                         const ContentFeatures &cfnb = m_nodedef->get(nb.n);
 616                         switch (m_nodedef->get(nb.n.getContent()).liquid_type) {
 617                                 case LIQUID_NONE:
 618                                         if (cfnb.floodable) {
 619                                                 airs[num_airs++] = nb;
 620                                                 // if the current node is a water source the neighbor
 621                                                 // should be enqueded for transformation regardless of whether the
 622                                                 // current node changes or not.
 623                                                 if (nb.t != NEIGHBOR_UPPER && liquid_type != LIQUID_NONE)
 624                                                         m_transforming_liquid.push_back(npos);
 625                                                 // if the current node happens to be a flowing node, it will start to flow down here.
 626                                                 if (nb.t == NEIGHBOR_LOWER)
 627                                                         flowing_down = true;
 628                                         } else {
 629                                                 neutrals[num_neutrals++] = nb;
 630                                                 if (nb.n.getContent() == CONTENT_IGNORE) {
 631                                                         // If node below is ignore prevent water from
 632                                                         // spreading outwards and otherwise prevent from
 633                                                         // flowing away as ignore node might be the source
 634                                                         if (nb.t == NEIGHBOR_LOWER)
 635                                                                 flowing_down = true;
 636                                                         else
 637                                                                 ignored_sources = true;
 638                                                 }
 639                                         }
 640                                         break;
 641                                 case LIQUID_SOURCE:
 642                                         // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
 643                                         if (liquid_kind == CONTENT_AIR)
 644                                                 liquid_kind = m_nodedef->getId(cfnb.liquid_alternative_flowing);
 645                                         if (m_nodedef->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
 646                                                 neutrals[num_neutrals++] = nb;
 647                                         } else {
 648                                                 // Do not count bottom source, it will screw things up
 649                                                 if(dirs[i].Y != -1)
 650                                                         sources[num_sources++] = nb;
 651                                         }
 652                                         break;
 653                                 case LIQUID_FLOWING:
 654                                         // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
 655                                         if (liquid_kind == CONTENT_AIR)
 656                                                 liquid_kind = m_nodedef->getId(cfnb.liquid_alternative_flowing);
 657                                         if (m_nodedef->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
 658                                                 neutrals[num_neutrals++] = nb;
 659                                         } else {
 660                                                 flows[num_flows++] = nb;
 661                                                 if (nb.t == NEIGHBOR_LOWER)
 662                                                         flowing_down = true;
 663                                         }
 664                                         break;
 665                         }
 666                 }
 667
 668                 /*
 669                         decide on the type (and possibly level) of the current node
 670                  */
 671                 content_t new_node_content;
 672                 s8 new_node_level = -1;
 673                 s8 max_node_level = -1;
 674
 675                 u8 range = m_nodedef->get(liquid_kind).liquid_range;
 676                 if (range > LIQUID_LEVEL_MAX + 1)
 677                         range = LIQUID_LEVEL_MAX + 1;
 678
 679                 if ((num_sources >= 2 && m_nodedef->get(liquid_kind).liquid_renewable) || liquid_type == LIQUID_SOURCE) {
 680                         // liquid_kind will be set to either the flowing alternative of the node (if it's a liquid)
 681                         // or the flowing alternative of the first of the surrounding sources (if it's air), so
 682                         // it's perfectly safe to use liquid_kind here to determine the new node content.
 683                         new_node_content = m_nodedef->getId(m_nodedef->get(liquid_kind).liquid_alternative_source);
 684                 } else if (num_sources >= 1 && sources[0].t != NEIGHBOR_LOWER) {
 685                         // liquid_kind is set properly, see above
 686                         max_node_level = new_node_level = LIQUID_LEVEL_MAX;
 687                         if (new_node_level >= (LIQUID_LEVEL_MAX + 1 - range))
 688                                 new_node_content = liquid_kind;
 689                         else
 690                                 new_node_content = floodable_node;
 691                 } else if (ignored_sources && liquid_level >= 0) {
 692                         // Maybe there are neighbouring sources that aren't loaded yet
 693                         // so prevent flowing away.
 694                         new_node_level = liquid_level;
 695                         new_node_content = liquid_kind;
 696                 } else {
 697                         // no surrounding sources, so get the maximum level that can flow into this node
 698                         for (u16 i = 0; i < num_flows; i++) {
 699                                 u8 nb_liquid_level = (flows[i].n.param2 & LIQUID_LEVEL_MASK);
 700                                 switch (flows[i].t) {
 701                                         case NEIGHBOR_UPPER:
 702                                                 if (nb_liquid_level + WATER_DROP_BOOST > max_node_level) {
 703                                                         max_node_level = LIQUID_LEVEL_MAX;
 704                                                         if (nb_liquid_level + WATER_DROP_BOOST < LIQUID_LEVEL_MAX)
 705                                                                 max_node_level = nb_liquid_level + WATER_DROP_BOOST;
 706                                                 } else if (nb_liquid_level > max_node_level) {
 707                                                         max_node_level = nb_liquid_level;
 708                                                 }
 709                                                 break;
 710                                         case NEIGHBOR_LOWER:
 711                                                 break;
 712                                         case NEIGHBOR_SAME_LEVEL:
 713                                                 if ((flows[i].n.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK &&
 714                                                                 nb_liquid_level > 0 && nb_liquid_level - 1 > max_node_level)
 715                                                         max_node_level = nb_liquid_level - 1;
 716                                                 break;
 717                                 }
 718                         }
 719
 720                         u8 viscosity = m_nodedef->get(liquid_kind).liquid_viscosity;
 721                         if (viscosity > 1 && max_node_level != liquid_level) {
 722                                 // amount to gain, limited by viscosity
 723                                 // must be at least 1 in absolute value
 724                                 s8 level_inc = max_node_level - liquid_level;
 725                                 if (level_inc < -viscosity || level_inc > viscosity)
 726                                         new_node_level = liquid_level + level_inc/viscosity;
 727                                 else if (level_inc < 0)
 728                                         new_node_level = liquid_level - 1;
 729                                 else if (level_inc > 0)
 730                                         new_node_level = liquid_level + 1;
 731                                 if (new_node_level != max_node_level)
 732                                         must_reflow.push_back(p0);
 733                         } else {
 734                                 new_node_level = max_node_level;
 735                         }
 736
 737                         if (max_node_level >= (LIQUID_LEVEL_MAX + 1 - range))
 738                                 new_node_content = liquid_kind;
 739                         else
 740                                 new_node_content = floodable_node;
 741
 742                 }
 743
 744                 /*
 745                         check if anything has changed. if not, just continue with the next node.
 746                  */
 747                 if (new_node_content == n0.getContent() &&
 748                                 (m_nodedef->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
 749                                 ((n0.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level &&
 750                                 ((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK)
 751                                 == flowing_down)))
 752                         continue;
 753
 754
 755                 /*
 756                         update the current node
 757                  */
 758                 MapNode n00 = n0;
 759                 //bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK));
 760                 if (m_nodedef->get(new_node_content).liquid_type == LIQUID_FLOWING) {
 761                         // set level to last 3 bits, flowing down bit to 4th bit
 762                         n0.param2 = (flowing_down ? LIQUID_FLOW_DOWN_MASK : 0x00) | (new_node_level & LIQUID_LEVEL_MASK);
 763                 } else {
 764                         // set the liquid level and flow bit to 0
 765                         n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
 766                 }
 767
 768                 // change the node.
 769                 n0.setContent(new_node_content);
 770
 771                 // on_flood() the node
 772                 if (floodable_node != CONTENT_AIR) {
 773                         if (env->getScriptIface()->node_on_flood(p0, n00, n0))
 774                                 continue;
 775                 }
 776
 777                 // Ignore light (because calling voxalgo::update_lighting_nodes)
 778                 n0.setLight(LIGHTBANK_DAY, 0, m_nodedef);
 779                 n0.setLight(LIGHTBANK_NIGHT, 0, m_nodedef);
 780
 781                 // Find out whether there is a suspect for this action
 782                 std::string suspect;
 783                 if (m_gamedef->rollback())
 784                         suspect = m_gamedef->rollback()->getSuspect(p0, 83, 1);
 785
 786                 if (m_gamedef->rollback() && !suspect.empty()) {
 787                         // Blame suspect
 788                         RollbackScopeActor rollback_scope(m_gamedef->rollback(), suspect, true);
 789                         // Get old node for rollback
 790                         RollbackNode rollback_oldnode(this, p0, m_gamedef);
 791                         // Set node
 792                         setNode(p0, n0);
 793                         // Report
 794                         RollbackNode rollback_newnode(this, p0, m_gamedef);
 795                         RollbackAction action;
 796                         action.setSetNode(p0, rollback_oldnode, rollback_newnode);
 797                         m_gamedef->rollback()->reportAction(action);
 798                 } else {
 799                         // Set node
 800                         setNode(p0, n0);
 801                 }
 802
 803                 v3s16 blockpos = getNodeBlockPos(p0);
 804                 MapBlock *block = getBlockNoCreateNoEx(blockpos);
 805                 if (block != NULL) {
 806                         modified_blocks[blockpos] =  block;
 807                         changed_nodes.emplace_back(p0, n00);
 808                 }
 809
 810                 /*
 811                         enqueue neighbors for update if neccessary
 812                  */
 813                 switch (m_nodedef->get(n0.getContent()).liquid_type) {
 814                         case LIQUID_SOURCE:
 815                         case LIQUID_FLOWING:
 816                                 // make sure source flows into all neighboring nodes
 817                                 for (u16 i = 0; i < num_flows; i++)
 818                                         if (flows[i].t != NEIGHBOR_UPPER)
 819                                                 m_transforming_liquid.push_back(flows[i].p);
 820                                 for (u16 i = 0; i < num_airs; i++)
 821                                         if (airs[i].t != NEIGHBOR_UPPER)
 822                                                 m_transforming_liquid.push_back(airs[i].p);
 823                                 break;
 824                         case LIQUID_NONE:
 825                                 // this flow has turned to air; neighboring flows might need to do the same
 826                                 for (u16 i = 0; i < num_flows; i++)
 827                                         m_transforming_liquid.push_back(flows[i].p);
 828                                 break;
 829                 }
 830         }
 831         //infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
 832
 833         for (auto &iter : must_reflow)
 834                 m_transforming_liquid.push_back(iter);
 835
 836         voxalgo::update_lighting_nodes(this, changed_nodes, modified_blocks);
 837
 838
 839         /* ----------------------------------------------------------------------
 840          * Manage the queue so that it does not grow indefinately
 841          */
 842         u16 time_until_purge = g_settings->getU16("liquid_queue_purge_time");
 843
 844         if (time_until_purge == 0)
 845                 return; // Feature disabled
 846
 847         time_until_purge *= 1000;       // seconds -> milliseconds
 848
 849         u64 curr_time = porting::getTimeMs();
 850         u32 prev_unprocessed = m_unprocessed_count;
 851         m_unprocessed_count = m_transforming_liquid.size();
 852
 853         // if unprocessed block count is decreasing or stable
 854         if (m_unprocessed_count <= prev_unprocessed) {
 855                 m_queue_size_timer_started = false;
 856         } else {
 857                 if (!m_queue_size_timer_started)
 858                         m_inc_trending_up_start_time = curr_time;
 859                 m_queue_size_timer_started = true;
 860         }
 861
 862         // Account for curr_time overflowing
 863         if (m_queue_size_timer_started && m_inc_trending_up_start_time > curr_time)
 864                 m_queue_size_timer_started = false;
 865
 866         /* If the queue has been growing for more than liquid_queue_purge_time seconds
 867          * and the number of unprocessed blocks is still > liquid_loop_max then we
 868          * cannot keep up; dump the oldest blocks from the queue so that the queue
 869          * has liquid_loop_max items in it
 870          */
 871         if (m_queue_size_timer_started
 872                         && curr_time - m_inc_trending_up_start_time > time_until_purge
 873                         && m_unprocessed_count > liquid_loop_max) {
 874
 875                 size_t dump_qty = m_unprocessed_count - liquid_loop_max;
 876
 877                 infostream << "transformLiquids(): DUMPING " << dump_qty
 878                            << " blocks from the queue" << std::endl;
 879
 880                 while (dump_qty--)
 881                         m_transforming_liquid.pop_front();
 882
 883                 m_queue_size_timer_started = false; // optimistically assume we can keep up now
 884                 m_unprocessed_count = m_transforming_liquid.size();
 885         }
 886 }
 887
 888 std::vector<v3s16> Map::findNodesWithMetadata(v3s16 p1, v3s16 p2)
 889 {
 890         std::vector<v3s16> positions_with_meta;
 891
 892         sortBoxVerticies(p1, p2);
 893         v3s16 bpmin = getNodeBlockPos(p1);
 894         v3s16 bpmax = getNodeBlockPos(p2);
 895
 896         VoxelArea area(p1, p2);
 897
 898         for (s16 z = bpmin.Z; z <= bpmax.Z; z++)
 899         for (s16 y = bpmin.Y; y <= bpmax.Y; y++)
 900         for (s16 x = bpmin.X; x <= bpmax.X; x++) {
 901                 v3s16 blockpos(x, y, z);
 902
 903                 MapBlock *block = getBlockNoCreateNoEx(blockpos);
 904                 if (!block) {
 905                         verbosestream << "Map::getNodeMetadata(): Need to emerge "
 906                                 << PP(blockpos) << std::endl;
 907                         block = emergeBlock(blockpos, false);
 908                 }
 909                 if (!block) {
 910                         infostream << "WARNING: Map::getNodeMetadata(): Block not found"
 911                                 << std::endl;
 912                         continue;
 913                 }
 914
 915                 v3s16 p_base = blockpos * MAP_BLOCKSIZE;
 916                 std::vector<v3s16> keys = block->m_node_metadata.getAllKeys();
 917                 for (size_t i = 0; i != keys.size(); i++) {
 918                         v3s16 p(keys[i] + p_base);
 919                         if (!area.contains(p))
 920                                 continue;
 921
 922                         positions_with_meta.push_back(p);
 923                 }
 924         }
 925
 926         return positions_with_meta;
 927 }
 928
 929 NodeMetadata *Map::getNodeMetadata(v3s16 p)
 930 {
 931         v3s16 blockpos = getNodeBlockPos(p);
 932         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
 933         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 934         if(!block){
 935                 infostream<<"Map::getNodeMetadata(): Need to emerge "
 936                                 <<PP(blockpos)<<std::endl;
 937                 block = emergeBlock(blockpos, false);
 938         }
 939         if(!block){
 940                 warningstream<<"Map::getNodeMetadata(): Block not found"
 941                                 <<std::endl;
 942                 return NULL;
 943         }
 944         NodeMetadata *meta = block->m_node_metadata.get(p_rel);
 945         return meta;
 946 }
 947
 948 bool Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
 949 {
 950         v3s16 blockpos = getNodeBlockPos(p);
 951         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
 952         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 953         if(!block){
 954                 infostream<<"Map::setNodeMetadata(): Need to emerge "
 955                                 <<PP(blockpos)<<std::endl;
 956                 block = emergeBlock(blockpos, false);
 957         }
 958         if(!block){
 959                 warningstream<<"Map::setNodeMetadata(): Block not found"
 960                                 <<std::endl;
 961                 return false;
 962         }
 963         block->m_node_metadata.set(p_rel, meta);
 964         return true;
 965 }
 966
 967 void Map::removeNodeMetadata(v3s16 p)
 968 {
 969         v3s16 blockpos = getNodeBlockPos(p);
 970         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
 971         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 972         if(block == NULL)
 973         {
 974                 warningstream<<"Map::removeNodeMetadata(): Block not found"
 975                                 <<std::endl;
 976                 return;
 977         }
 978         block->m_node_metadata.remove(p_rel);
 979 }
 980
 981 NodeTimer Map::getNodeTimer(v3s16 p)
 982 {
 983         v3s16 blockpos = getNodeBlockPos(p);
 984         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
 985         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 986         if(!block){
 987                 infostream<<"Map::getNodeTimer(): Need to emerge "
 988                                 <<PP(blockpos)<<std::endl;
 989                 block = emergeBlock(blockpos, false);
 990         }
 991         if(!block){
 992                 warningstream<<"Map::getNodeTimer(): Block not found"
 993                                 <<std::endl;
 994                 return NodeTimer();
 995         }
 996         NodeTimer t = block->m_node_timers.get(p_rel);
 997         NodeTimer nt(t.timeout, t.elapsed, p);
 998         return nt;
 999 }
1000
1001 void Map::setNodeTimer(const NodeTimer &t)
1002 {
1003         v3s16 p = t.position;
1004         v3s16 blockpos = getNodeBlockPos(p);
1005         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
1006         MapBlock *block = getBlockNoCreateNoEx(blockpos);
1007         if(!block){
1008                 infostream<<"Map::setNodeTimer(): Need to emerge "
1009                                 <<PP(blockpos)<<std::endl;
1010                 block = emergeBlock(blockpos, false);
1011         }
1012         if(!block){
1013                 warningstream<<"Map::setNodeTimer(): Block not found"
1014                                 <<std::endl;
1015                 return;
1016         }
1017         NodeTimer nt(t.timeout, t.elapsed, p_rel);
1018         block->m_node_timers.set(nt);
1019 }
1020
1021 void Map::removeNodeTimer(v3s16 p)
1022 {
1023         v3s16 blockpos = getNodeBlockPos(p);
1024         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
1025         MapBlock *block = getBlockNoCreateNoEx(blockpos);
1026         if(block == NULL)
1027         {
1028                 warningstream<<"Map::removeNodeTimer(): Block not found"
1029                                 <<std::endl;
1030                 return;
1031         }
1032         block->m_node_timers.remove(p_rel);
1033 }
1034
1035 bool Map::isOccluded(v3s16 p0, v3s16 p1, float step, float stepfac,
1036                 float start_off, float end_off, u32 needed_count)
1037 {
1038         float d0 = (float)BS * p0.getDistanceFrom(p1);
1039         v3s16 u0 = p1 - p0;
1040         v3f uf = v3f(u0.X, u0.Y, u0.Z) * BS;
1041         uf.normalize();
1042         v3f p0f = v3f(p0.X, p0.Y, p0.Z) * BS;
1043         u32 count = 0;
1044         for(float s=start_off; s<d0+end_off; s+=step){
1045                 v3f pf = p0f + uf * s;
1046                 v3s16 p = floatToInt(pf, BS);
1047                 MapNode n = getNode(p);
1048                 const ContentFeatures &f = m_nodedef->get(n);
1049                 if(f.drawtype == NDT_NORMAL){
1050                         // not transparent, see ContentFeature::updateTextures
1051                         count++;
1052                         if(count >= needed_count)
1053                                 return true;
1054                 }
1055                 step *= stepfac;
1056         }
1057         return false;
1058 }
1059
1060 bool Map::isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes) {
1061         v3s16 cpn = block->getPos() * MAP_BLOCKSIZE;
1062         cpn += v3s16(MAP_BLOCKSIZE / 2, MAP_BLOCKSIZE / 2, MAP_BLOCKSIZE / 2);
1063         float step = BS * 1;
1064         float stepfac = 1.1;
1065         float startoff = BS * 1;
1066         // The occlusion search of 'isOccluded()' must stop short of the target
1067         // point by distance 'endoff' (end offset) to not enter the target mapblock.
1068         // For the 8 mapblock corners 'endoff' must therefore be the maximum diagonal
1069         // of a mapblock, because we must consider all view angles.
1070         // sqrt(1^2 + 1^2 + 1^2) = 1.732
1071         float endoff = -BS * MAP_BLOCKSIZE * 1.732050807569;
1072         s16 bs2 = MAP_BLOCKSIZE / 2 + 1;
1073         // to reduce the likelihood of falsely occluded blocks
1074         // require at least two solid blocks
1075         // this is a HACK, we should think of a more precise algorithm
1076         u32 needed_count = 2;
1077
1078         return (
1079                 // For the central point of the mapblock 'endoff' can be halved
1080                 isOccluded(cam_pos_nodes, cpn,
1081                         step, stepfac, startoff, endoff / 2.0f, needed_count) &&
1082                 isOccluded(cam_pos_nodes, cpn + v3s16(bs2,bs2,bs2),
1083                         step, stepfac, startoff, endoff, needed_count) &&
1084                 isOccluded(cam_pos_nodes, cpn + v3s16(bs2,bs2,-bs2),
1085                         step, stepfac, startoff, endoff, needed_count) &&
1086                 isOccluded(cam_pos_nodes, cpn + v3s16(bs2,-bs2,bs2),
1087                         step, stepfac, startoff, endoff, needed_count) &&
1088                 isOccluded(cam_pos_nodes, cpn + v3s16(bs2,-bs2,-bs2),
1089                         step, stepfac, startoff, endoff, needed_count) &&
1090                 isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,bs2,bs2),
1091                         step, stepfac, startoff, endoff, needed_count) &&
1092                 isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,bs2,-bs2),
1093                         step, stepfac, startoff, endoff, needed_count) &&
1094                 isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,-bs2,bs2),
1095                         step, stepfac, startoff, endoff, needed_count) &&
1096                 isOccluded(cam_pos_nodes, cpn + v3s16(-bs2,-bs2,-bs2),
1097                         step, stepfac, startoff, endoff, needed_count));
1098 }
1099
1100 /*
1101         ServerMap
1102 */
1103 ServerMap::ServerMap(const std::string &savedir, IGameDef *gamedef,
1104                 EmergeManager *emerge):
1105         Map(dout_server, gamedef),
1106         settings_mgr(g_settings, savedir + DIR_DELIM + "map_meta.txt"),
1107         m_emerge(emerge)
1108 {
1109         verbosestream<<FUNCTION_NAME<<std::endl;
1110
1111         // Tell the EmergeManager about our MapSettingsManager
1112         emerge->map_settings_mgr = &settings_mgr;
1113
1114         /*
1115                 Try to load map; if not found, create a new one.
1116         */
1117
1118         // Determine which database backend to use
1119         std::string conf_path = savedir + DIR_DELIM + "world.mt";
1120         Settings conf;
1121         bool succeeded = conf.readConfigFile(conf_path.c_str());
1122         if (!succeeded || !conf.exists("backend")) {
1123                 // fall back to sqlite3
1124                 conf.set("backend", "sqlite3");
1125         }
1126         std::string backend = conf.get("backend");
1127         dbase = createDatabase(backend, savedir, conf);
1128         if (conf.exists("readonly_backend")) {
1129                 std::string readonly_dir = savedir + DIR_DELIM + "readonly";
1130                 dbase_ro = createDatabase(conf.get("readonly_backend"), readonly_dir, conf);
1131         }
1132         if (!conf.updateConfigFile(conf_path.c_str()))
1133                 errorstream << "ServerMap::ServerMap(): Failed to update world.mt!" << std::endl;
1134
1135         m_savedir = savedir;
1136         m_map_saving_enabled = false;
1137
1138         try {
1139                 // If directory exists, check contents and load if possible
1140                 if (fs::PathExists(m_savedir)) {
1141                         // If directory is empty, it is safe to save into it.
1142                         if (fs::GetDirListing(m_savedir).empty()) {
1143                                 infostream<<"ServerMap: Empty save directory is valid."
1144                                                 <<std::endl;
1145                                 m_map_saving_enabled = true;
1146                         }
1147                         else
1148                         {
1149
1150                                 if (settings_mgr.loadMapMeta()) {
1151                                         infostream << "ServerMap: Metadata loaded from "
1152                                                 << savedir << std::endl;
1153                                 } else {
1154                                         infostream << "ServerMap: Metadata could not be loaded "
1155                                                 "from " << savedir << ", assuming valid save "
1156                                                 "directory." << std::endl;
1157                                 }
1158
1159                                 m_map_saving_enabled = true;
1160                                 // Map loaded, not creating new one
1161                                 return;
1162                         }
1163                 }
1164                 // If directory doesn't exist, it is safe to save to it
1165                 else{
1166                         m_map_saving_enabled = true;
1167                 }
1168         }
1169         catch(std::exception &e)
1170         {
1171                 warningstream<<"ServerMap: Failed to load map from "<<savedir
1172                                 <<", exception: "<<e.what()<<std::endl;
1173                 infostream<<"Please remove the map or fix it."<<std::endl;
1174                 warningstream<<"Map saving will be disabled."<<std::endl;
1175         }
1176 }
1177
1178 ServerMap::~ServerMap()
1179 {
1180         verbosestream<<FUNCTION_NAME<<std::endl;
1181
1182         try
1183         {
1184                 if (m_map_saving_enabled) {
1185                         // Save only changed parts
1186                         save(MOD_STATE_WRITE_AT_UNLOAD);
1187                         infostream << "ServerMap: Saved map to " << m_savedir << std::endl;
1188                 } else {
1189                         infostream << "ServerMap: Map not saved" << std::endl;
1190                 }
1191         }
1192         catch(std::exception &e)
1193         {
1194                 infostream<<"ServerMap: Failed to save map to "<<m_savedir
1195                                 <<", exception: "<<e.what()<<std::endl;
1196         }
1197
1198         /*
1199                 Close database if it was opened
1200         */
1201         delete dbase;
1202         if (dbase_ro)
1203                 delete dbase_ro;
1204
1205 #if 0
1206         /*
1207                 Free all MapChunks
1208         */
1209         core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
1210         for(; i.atEnd() == false; i++)
1211         {
1212                 MapChunk *chunk = i.getNode()->getValue();
1213                 delete chunk;
1214         }
1215 #endif
1216 }
1217
1218 MapgenParams *ServerMap::getMapgenParams()
1219 {
1220         // getMapgenParams() should only ever be called after Server is initialized
1221         assert(settings_mgr.mapgen_params != NULL);
1222         return settings_mgr.mapgen_params;
1223 }
1224
1225 u64 ServerMap::getSeed()
1226 {
1227         return getMapgenParams()->seed;
1228 }
1229
1230 s16 ServerMap::getWaterLevel()
1231 {
1232         return getMapgenParams()->water_level;
1233 }
1234
1235 bool ServerMap::blockpos_over_mapgen_limit(v3s16 p)
1236 {
1237         const s16 mapgen_limit_bp = rangelim(
1238                 getMapgenParams()->mapgen_limit, 0, MAX_MAP_GENERATION_LIMIT) /
1239                 MAP_BLOCKSIZE;
1240         return p.X < -mapgen_limit_bp ||
1241                 p.X >  mapgen_limit_bp ||
1242                 p.Y < -mapgen_limit_bp ||
1243                 p.Y >  mapgen_limit_bp ||
1244                 p.Z < -mapgen_limit_bp ||
1245                 p.Z >  mapgen_limit_bp;
1246 }
1247
1248 bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data)
1249 {
1250         s16 csize = getMapgenParams()->chunksize;
1251         v3s16 bpmin = EmergeManager::getContainingChunk(blockpos, csize);
1252         v3s16 bpmax = bpmin + v3s16(1, 1, 1) * (csize - 1);
1253
1254         bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
1255         EMERGE_DBG_OUT("initBlockMake(): " PP(bpmin) " - " PP(bpmax));
1256
1257         v3s16 extra_borders(1, 1, 1);
1258         v3s16 full_bpmin = bpmin - extra_borders;
1259         v3s16 full_bpmax = bpmax + extra_borders;
1260
1261         // Do nothing if not inside mapgen limits (+-1 because of neighbors)
1262         if (blockpos_over_mapgen_limit(full_bpmin) ||
1263                         blockpos_over_mapgen_limit(full_bpmax))
1264                 return false;
1265
1266         data->seed = getSeed();
1267         data->blockpos_min = bpmin;
1268         data->blockpos_max = bpmax;
1269         data->blockpos_requested = blockpos;
1270         data->nodedef = m_nodedef;
1271
1272         /*
1273                 Create the whole area of this and the neighboring blocks
1274         */
1275         for (s16 x = full_bpmin.X; x <= full_bpmax.X; x++)
1276         for (s16 z = full_bpmin.Z; z <= full_bpmax.Z; z++) {
1277                 v2s16 sectorpos(x, z);
1278                 // Sector metadata is loaded from disk if not already loaded.
1279                 MapSector *sector = createSector(sectorpos);
1280                 FATAL_ERROR_IF(sector == NULL, "createSector() failed");
1281
1282                 for (s16 y = full_bpmin.Y; y <= full_bpmax.Y; y++) {
1283                         v3s16 p(x, y, z);
1284
1285                         MapBlock *block = emergeBlock(p, false);
1286                         if (block == NULL) {
1287                                 block = createBlock(p);
1288
1289                                 // Block gets sunlight if this is true.
1290                                 // Refer to the map generator heuristics.
1291                                 bool ug = m_emerge->isBlockUnderground(p);
1292                                 block->setIsUnderground(ug);
1293                         }
1294                 }
1295         }
1296
1297         /*
1298                 Now we have a big empty area.
1299
1300                 Make a ManualMapVoxelManipulator that contains this and the
1301                 neighboring blocks
1302         */
1303
1304         data->vmanip = new MMVManip(this);
1305         data->vmanip->initialEmerge(full_bpmin, full_bpmax);
1306
1307         // Note: we may need this again at some point.
1308 #if 0
1309         // Ensure none of the blocks to be generated were marked as
1310         // containing CONTENT_IGNORE
1311         for (s16 z = blockpos_min.Z; z <= blockpos_max.Z; z++) {
1312                 for (s16 y = blockpos_min.Y; y <= blockpos_max.Y; y++) {
1313                         for (s16 x = blockpos_min.X; x <= blockpos_max.X; x++) {
1314                                 core::map<v3s16, u8>::Node *n;
1315                                 n = data->vmanip->m_loaded_blocks.find(v3s16(x, y, z));
1316                                 if (n == NULL)
1317                                         continue;
1318                                 u8 flags = n->getValue();
1319                                 flags &= ~VMANIP_BLOCK_CONTAINS_CIGNORE;
1320                                 n->setValue(flags);
1321                         }
1322                 }
1323         }
1324 #endif
1325
1326         // Data is ready now.
1327         return true;
1328 }
1329
1330 void ServerMap::finishBlockMake(BlockMakeData *data,
1331         std::map<v3s16, MapBlock*> *changed_blocks)
1332 {
1333         v3s16 bpmin = data->blockpos_min;
1334         v3s16 bpmax = data->blockpos_max;
1335
1336         v3s16 extra_borders(1, 1, 1);
1337
1338         bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
1339         EMERGE_DBG_OUT("finishBlockMake(): " PP(bpmin) " - " PP(bpmax));
1340
1341         /*
1342                 Blit generated stuff to map
1343                 NOTE: blitBackAll adds nearly everything to changed_blocks
1344         */
1345         data->vmanip->blitBackAll(changed_blocks);
1346
1347         EMERGE_DBG_OUT("finishBlockMake: changed_blocks.size()="
1348                 << changed_blocks->size());
1349
1350         /*
1351                 Copy transforming liquid information
1352         */
1353         while (data->transforming_liquid.size()) {
1354                 m_transforming_liquid.push_back(data->transforming_liquid.front());
1355                 data->transforming_liquid.pop_front();
1356         }
1357
1358         for (auto &changed_block : *changed_blocks) {
1359                 MapBlock *block = changed_block.second;
1360                 if (!block)
1361                         continue;
1362                 /*
1363                         Update day/night difference cache of the MapBlocks
1364                 */
1365                 block->expireDayNightDiff();
1366                 /*
1367                         Set block as modified
1368                 */
1369                 block->raiseModified(MOD_STATE_WRITE_NEEDED,
1370                         MOD_REASON_EXPIRE_DAYNIGHTDIFF);
1371         }
1372
1373         /*
1374                 Set central blocks as generated
1375         */
1376         for (s16 x = bpmin.X; x <= bpmax.X; x++)
1377         for (s16 z = bpmin.Z; z <= bpmax.Z; z++)
1378         for (s16 y = bpmin.Y; y <= bpmax.Y; y++) {
1379                 MapBlock *block = getBlockNoCreateNoEx(v3s16(x, y, z));
1380                 if (!block)
1381                         continue;
1382
1383                 block->setGenerated(true);
1384         }
1385
1386         /*
1387                 Save changed parts of map
1388                 NOTE: Will be saved later.
1389         */
1390         //save(MOD_STATE_WRITE_AT_UNLOAD);
1391 }
1392
1393 MapSector *ServerMap::createSector(v2s16 p2d)
1394 {
1395         /*
1396                 Check if it exists already in memory
1397         */
1398         MapSector *sector = getSectorNoGenerate(p2d);
1399         if (sector)
1400                 return sector;
1401
1402         /*
1403                 Do not create over max mapgen limit
1404         */
1405         const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
1406         if (p2d.X < -max_limit_bp ||
1407                         p2d.X >  max_limit_bp ||
1408                         p2d.Y < -max_limit_bp ||
1409                         p2d.Y >  max_limit_bp)
1410                 throw InvalidPositionException("createSector(): pos. over max mapgen limit");
1411
1412         /*
1413                 Generate blank sector
1414         */
1415
1416         sector = new MapSector(this, p2d, m_gamedef);
1417
1418         // Sector position on map in nodes
1419         //v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
1420
1421         /*
1422                 Insert to container
1423         */
1424         m_sectors[p2d] = sector;
1425
1426         return sector;
1427 }
1428
1429 #if 0
1430 /*
1431         This is a quick-hand function for calling makeBlock().
1432 */
1433 MapBlock * ServerMap::generateBlock(
1434                 v3s16 p,
1435                 std::map<v3s16, MapBlock*> &modified_blocks
1436 )
1437 {
1438         bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
1439
1440         TimeTaker timer("generateBlock");
1441
1442         //MapBlock *block = original_dummy;
1443
1444         v2s16 p2d(p.X, p.Z);
1445         v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
1446
1447         /*
1448                 Do not generate over-limit
1449         */
1450         if(blockpos_over_limit(p))
1451         {
1452                 infostream<<FUNCTION_NAME<<": Block position over limit"<<std::endl;
1453                 throw InvalidPositionException("generateBlock(): pos. over limit");
1454         }
1455
1456         /*
1457                 Create block make data
1458         */
1459         BlockMakeData data;
1460         initBlockMake(&data, p);
1461
1462         /*
1463                 Generate block
1464         */
1465         {
1466                 TimeTaker t("mapgen::make_block()");
1467                 mapgen->makeChunk(&data);
1468                 //mapgen::make_block(&data);
1469
1470                 if(enable_mapgen_debug_info == false)
1471                         t.stop(true); // Hide output
1472         }
1473
1474         /*
1475                 Blit data back on map, update lighting, add mobs and whatever this does
1476         */
1477         finishBlockMake(&data, modified_blocks);
1478
1479         /*
1480                 Get central block
1481         */
1482         MapBlock *block = getBlockNoCreateNoEx(p);
1483
1484 #if 0
1485         /*
1486                 Check result
1487         */
1488         if(block)
1489         {
1490                 bool erroneus_content = false;
1491                 for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
1492                 for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
1493                 for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
1494                 {
1495                         v3s16 p(x0,y0,z0);
1496                         MapNode n = block->getNode(p);
1497                         if(n.getContent() == CONTENT_IGNORE)
1498                         {
1499                                 infostream<<"CONTENT_IGNORE at "
1500                                                 <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
1501                                                 <<std::endl;
1502                                 erroneus_content = true;
1503                                 assert(0);
1504                         }
1505                 }
1506                 if(erroneus_content)
1507                 {
1508                         assert(0);
1509                 }
1510         }
1511 #endif
1512
1513 #if 0
1514         /*
1515                 Generate a completely empty block
1516         */
1517         if(block)
1518         {
1519                 for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
1520                 for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
1521                 {
1522                         for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
1523                         {
1524                                 MapNode n;
1525                                 n.setContent(CONTENT_AIR);
1526                                 block->setNode(v3s16(x0,y0,z0), n);
1527                         }
1528                 }
1529         }
1530 #endif
1531
1532         if(enable_mapgen_debug_info == false)
1533                 timer.stop(true); // Hide output
1534
1535         return block;
1536 }
1537 #endif
1538
1539 MapBlock * ServerMap::createBlock(v3s16 p)
1540 {
1541         /*
1542                 Do not create over max mapgen limit
1543         */
1544         if (blockpos_over_max_limit(p))
1545                 throw InvalidPositionException("createBlock(): pos. over max mapgen limit");
1546
1547         v2s16 p2d(p.X, p.Z);
1548         s16 block_y = p.Y;
1549         /*
1550                 This will create or load a sector if not found in memory.
1551                 If block exists on disk, it will be loaded.
1552
1553                 NOTE: On old save formats, this will be slow, as it generates
1554                       lighting on blocks for them.
1555         */
1556         MapSector *sector;
1557         try {
1558                 sector = createSector(p2d);
1559         } catch (InvalidPositionException &e) {
1560                 infostream<<"createBlock: createSector() failed"<<std::endl;
1561                 throw e;
1562         }
1563
1564         /*
1565                 Try to get a block from the sector
1566         */
1567
1568         MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
1569         if (block) {
1570                 if(block->isDummy())
1571                         block->unDummify();
1572                 return block;
1573         }
1574         // Create blank
1575         block = sector->createBlankBlock(block_y);
1576
1577         return block;
1578 }
1579
1580 MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
1581 {
1582         {
1583                 MapBlock *block = getBlockNoCreateNoEx(p);
1584                 if (block && !block->isDummy())
1585                         return block;
1586         }
1587
1588         {
1589                 MapBlock *block = loadBlock(p);
1590                 if(block)
1591                         return block;
1592         }
1593
1594         if (create_blank) {
1595                 MapSector *sector = createSector(v2s16(p.X, p.Z));
1596                 MapBlock *block = sector->createBlankBlock(p.Y);
1597
1598                 return block;
1599         }
1600
1601         return NULL;
1602 }
1603
1604 MapBlock *ServerMap::getBlockOrEmerge(v3s16 p3d)
1605 {
1606         MapBlock *block = getBlockNoCreateNoEx(p3d);
1607         if (block == NULL)
1608                 m_emerge->enqueueBlockEmerge(PEER_ID_INEXISTENT, p3d, false);
1609
1610         return block;
1611 }
1612
1613 // N.B.  This requires no synchronization, since data will not be modified unless
1614 // the VoxelManipulator being updated belongs to the same thread.
1615 void ServerMap::updateVManip(v3s16 pos)
1616 {
1617         Mapgen *mg = m_emerge->getCurrentMapgen();
1618         if (!mg)
1619                 return;
1620
1621         MMVManip *vm = mg->vm;
1622         if (!vm)
1623                 return;
1624
1625         if (!vm->m_area.contains(pos))
1626                 return;
1627
1628         s32 idx = vm->m_area.index(pos);
1629         vm->m_data[idx] = getNode(pos);
1630         vm->m_flags[idx] &= ~VOXELFLAG_NO_DATA;
1631
1632         vm->m_is_dirty = true;
1633 }
1634
1635 s16 ServerMap::findGroundLevel(v2s16 p2d)
1636 {
1637 #if 0
1638         /*
1639                 Uh, just do something random...
1640         */
1641         // Find existing map from top to down
1642         s16 max=63;
1643         s16 min=-64;
1644         v3s16 p(p2d.X, max, p2d.Y);
1645         for(; p.Y>min; p.Y--)
1646         {
1647                 MapNode n = getNodeNoEx(p);
1648                 if(n.getContent() != CONTENT_IGNORE)
1649                         break;
1650         }
1651         if(p.Y == min)
1652                 goto plan_b;
1653         // If this node is not air, go to plan b
1654         if(getNodeNoEx(p).getContent() != CONTENT_AIR)
1655                 goto plan_b;
1656         // Search existing walkable and return it
1657         for(; p.Y>min; p.Y--)
1658         {
1659                 MapNode n = getNodeNoEx(p);
1660                 if(content_walkable(n.d) && n.getContent() != CONTENT_IGNORE)
1661                         return p.Y;
1662         }
1663
1664         // Move to plan b
1665 plan_b:
1666 #endif
1667
1668         /*
1669                 Determine from map generator noise functions
1670         */
1671
1672         s16 level = m_emerge->getGroundLevelAtPoint(p2d);
1673         return level;
1674
1675         //double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
1676         //return (s16)level;
1677 }
1678
1679 bool ServerMap::loadFromFolders() {
1680         if (!dbase->initialized() &&
1681                         !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite"))
1682                 return true;
1683         return false;
1684 }
1685
1686 void ServerMap::createDirs(const std::string &path)
1687 {
1688         if (!fs::CreateAllDirs(path)) {
1689                 m_dout<<"ServerMap: Failed to create directory "
1690                                 <<"\""<<path<<"\""<<std::endl;
1691                 throw BaseException("ServerMap failed to create directory");
1692         }
1693 }
1694
1695 std::string ServerMap::getSectorDir(v2s16 pos, int layout)
1696 {
1697         char cc[9];
1698         switch(layout)
1699         {
1700                 case 1:
1701                         porting::mt_snprintf(cc, sizeof(cc), "%.4x%.4x",
1702                                 (unsigned int) pos.X & 0xffff,
1703                                 (unsigned int) pos.Y & 0xffff);
1704
1705                         return m_savedir + DIR_DELIM + "sectors" + DIR_DELIM + cc;
1706                 case 2:
1707                         porting::mt_snprintf(cc, sizeof(cc), (std::string("%.3x") + DIR_DELIM + "%.3x").c_str(),
1708                                 (unsigned int) pos.X & 0xfff,
1709                                 (unsigned int) pos.Y & 0xfff);
1710
1711                         return m_savedir + DIR_DELIM + "sectors2" + DIR_DELIM + cc;
1712                 default:
1713                         assert(false);
1714                         return "";
1715         }
1716 }
1717
1718 v2s16 ServerMap::getSectorPos(const std::string &dirname)
1719 {
1720         unsigned int x = 0, y = 0;
1721         int r;
1722         std::string component;
1723         fs::RemoveLastPathComponent(dirname, &component, 1);
1724         if(component.size() == 8)
1725         {
1726                 // Old layout
1727                 r = sscanf(component.c_str(), "%4x%4x", &x, &y);
1728         }
1729         else if(component.size() == 3)
1730         {
1731                 // New layout
1732                 fs::RemoveLastPathComponent(dirname, &component, 2);
1733                 r = sscanf(component.c_str(), (std::string("%3x") + DIR_DELIM + "%3x").c_str(), &x, &y);
1734                 // Sign-extend the 12 bit values up to 16 bits...
1735                 if(x & 0x800) x |= 0xF000;
1736                 if(y & 0x800) y |= 0xF000;
1737         }
1738         else
1739         {
1740                 r = -1;
1741         }
1742
1743         FATAL_ERROR_IF(r != 2, "getSectorPos()");
1744         v2s16 pos((s16)x, (s16)y);
1745         return pos;
1746 }
1747
1748 v3s16 ServerMap::getBlockPos(const std::string &sectordir, const std::string &blockfile)
1749 {
1750         v2s16 p2d = getSectorPos(sectordir);
1751
1752         if(blockfile.size() != 4){
1753                 throw InvalidFilenameException("Invalid block filename");
1754         }
1755         unsigned int y;
1756         int r = sscanf(blockfile.c_str(), "%4x", &y);
1757         if(r != 1)
1758                 throw InvalidFilenameException("Invalid block filename");
1759         return v3s16(p2d.X, y, p2d.Y);
1760 }
1761
1762 std::string ServerMap::getBlockFilename(v3s16 p)
1763 {
1764         char cc[5];
1765         porting::mt_snprintf(cc, sizeof(cc), "%.4x", (unsigned int)p.Y&0xffff);
1766         return cc;
1767 }
1768
1769 void ServerMap::save(ModifiedState save_level)
1770 {
1771         if (!m_map_saving_enabled) {
1772                 warningstream<<"Not saving map, saving disabled."<<std::endl;
1773                 return;
1774         }
1775
1776         if(save_level == MOD_STATE_CLEAN)
1777                 infostream<<"ServerMap: Saving whole map, this can take time."
1778                                 <<std::endl;
1779
1780         if (m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
1781                 if (settings_mgr.saveMapMeta())
1782                         m_map_metadata_changed = false;
1783         }
1784
1785         // Profile modified reasons
1786         Profiler modprofiler;
1787
1788         u32 block_count = 0;
1789         u32 block_count_all = 0; // Number of blocks in memory
1790
1791         // Don't do anything with sqlite unless something is really saved
1792         bool save_started = false;
1793
1794         for (auto &sector_it : m_sectors) {
1795                 MapSector *sector = sector_it.second;
1796
1797                 MapBlockVect blocks;
1798                 sector->getBlocks(blocks);
1799
1800                 for (MapBlock *block : blocks) {
1801                         block_count_all++;
1802
1803                         if(block->getModified() >= (u32)save_level) {
1804                                 // Lazy beginSave()
1805                                 if(!save_started) {
1806                                         beginSave();
1807                                         save_started = true;
1808                                 }
1809
1810                                 modprofiler.add(block->getModifiedReasonString(), 1);
1811
1812                                 saveBlock(block);
1813                                 block_count++;
1814                         }
1815                 }
1816         }
1817
1818         if(save_started)
1819                 endSave();
1820
1821         /*
1822                 Only print if something happened or saved whole map
1823         */
1824         if(save_level == MOD_STATE_CLEAN
1825                         || block_count != 0) {
1826                 infostream<<"ServerMap: Written: "
1827                                 <<block_count<<" block files"
1828                                 <<", "<<block_count_all<<" blocks in memory."
1829                                 <<std::endl;
1830                 PrintInfo(infostream); // ServerMap/ClientMap:
1831                 infostream<<"Blocks modified by: "<<std::endl;
1832                 modprofiler.print(infostream);
1833         }
1834 }
1835
1836 void ServerMap::listAllLoadableBlocks(std::vector<v3s16> &dst)
1837 {
1838         if (loadFromFolders()) {
1839                 errorstream << "Map::listAllLoadableBlocks(): Result will be missing "
1840                                 << "all blocks that are stored in flat files." << std::endl;
1841         }
1842         dbase->listAllLoadableBlocks(dst);
1843         if (dbase_ro)
1844                 dbase_ro->listAllLoadableBlocks(dst);
1845 }
1846
1847 void ServerMap::listAllLoadedBlocks(std::vector<v3s16> &dst)
1848 {
1849         for (auto &sector_it : m_sectors) {
1850                 MapSector *sector = sector_it.second;
1851
1852                 MapBlockVect blocks;
1853                 sector->getBlocks(blocks);
1854
1855                 for (MapBlock *block : blocks) {
1856                         v3s16 p = block->getPos();
1857                         dst.push_back(p);
1858                 }
1859         }
1860 }
1861
1862 MapDatabase *ServerMap::createDatabase(
1863         const std::string &name,
1864         const std::string &savedir,
1865         Settings &conf)
1866 {
1867         if (name == "sqlite3")
1868                 return new MapDatabaseSQLite3(savedir);
1869         if (name == "dummy")
1870                 return new Database_Dummy();
1871         #if USE_LEVELDB
1872         if (name == "leveldb")
1873                 return new Database_LevelDB(savedir);
1874         #endif
1875         #if USE_REDIS
1876         if (name == "redis")
1877                 return new Database_Redis(conf);
1878         #endif
1879         #if USE_POSTGRESQL
1880         if (name == "postgresql") {
1881                 std::string connect_string;
1882                 conf.getNoEx("pgsql_connection", connect_string);
1883                 return new MapDatabasePostgreSQL(connect_string);
1884         }
1885         #endif
1886
1887         throw BaseException(std::string("Database backend ") + name + " not supported.");
1888 }
1889
1890 void ServerMap::beginSave()
1891 {
1892         dbase->beginSave();
1893 }
1894
1895 void ServerMap::endSave()
1896 {
1897         dbase->endSave();
1898 }
1899
1900 bool ServerMap::saveBlock(MapBlock *block)
1901 {
1902         return saveBlock(block, dbase);
1903 }
1904
1905 bool ServerMap::saveBlock(MapBlock *block, MapDatabase *db)
1906 {
1907         v3s16 p3d = block->getPos();
1908
1909         // Dummy blocks are not written
1910         if (block->isDummy()) {
1911                 warningstream << "saveBlock: Not writing dummy block "
1912                         << PP(p3d) << std::endl;
1913                 return true;
1914         }
1915
1916         // Format used for writing
1917         u8 version = SER_FMT_VER_HIGHEST_WRITE;
1918
1919         /*
1920                 [0] u8 serialization version
1921                 [1] data
1922         */
1923         std::ostringstream o(std::ios_base::binary);
1924         o.write((char*) &version, 1);
1925         block->serialize(o, version, true);
1926
1927         bool ret = db->saveBlock(p3d, o.str());
1928         if (ret) {
1929                 // We just wrote it to the disk so clear modified flag
1930                 block->resetModified();
1931         }
1932         return ret;
1933 }
1934
1935 void ServerMap::loadBlock(const std::string &sectordir, const std::string &blockfile,
1936                 MapSector *sector, bool save_after_load)
1937 {
1938         std::string fullpath = sectordir + DIR_DELIM + blockfile;
1939         try {
1940                 std::ifstream is(fullpath.c_str(), std::ios_base::binary);
1941                 if (!is.good())
1942                         throw FileNotGoodException("Cannot open block file");
1943
1944                 v3s16 p3d = getBlockPos(sectordir, blockfile);
1945                 v2s16 p2d(p3d.X, p3d.Z);
1946
1947                 assert(sector->getPos() == p2d);
1948
1949                 u8 version = SER_FMT_VER_INVALID;
1950                 is.read((char*)&version, 1);
1951
1952                 if(is.fail())
1953                         throw SerializationError("ServerMap::loadBlock(): Failed"
1954                                         " to read MapBlock version");
1955
1956                 /*u32 block_size = MapBlock::serializedLength(version);
1957                 SharedBuffer<u8> data(block_size);
1958                 is.read((char*)*data, block_size);*/
1959
1960                 // This will always return a sector because we're the server
1961                 //MapSector *sector = emergeSector(p2d);
1962
1963                 MapBlock *block = NULL;
1964                 bool created_new = false;
1965                 block = sector->getBlockNoCreateNoEx(p3d.Y);
1966                 if(block == NULL)
1967                 {
1968                         block = sector->createBlankBlockNoInsert(p3d.Y);
1969                         created_new = true;
1970                 }
1971
1972                 // Read basic data
1973                 block->deSerialize(is, version, true);
1974
1975                 // If it's a new block, insert it to the map
1976                 if (created_new) {
1977                         sector->insertBlock(block);
1978                         ReflowScan scanner(this, m_emerge->ndef);
1979                         scanner.scan(block, &m_transforming_liquid);
1980                 }
1981
1982                 /*
1983                         Save blocks loaded in old format in new format
1984                 */
1985
1986                 if(version < SER_FMT_VER_HIGHEST_WRITE || save_after_load)
1987                 {
1988                         saveBlock(block);
1989
1990                         // Should be in database now, so delete the old file
1991                         fs::RecursiveDelete(fullpath);
1992                 }
1993
1994                 // We just loaded it from the disk, so it's up-to-date.
1995                 block->resetModified();
1996
1997         }
1998         catch(SerializationError &e)
1999         {
2000                 warningstream<<"Invalid block data on disk "
2001                                 <<"fullpath="<<fullpath
2002                                 <<" (SerializationError). "
2003                                 <<"what()="<<e.what()
2004                                 <<std::endl;
2005                                 // Ignoring. A new one will be generated.
2006                 abort();
2007
2008                 // TODO: Backup file; name is in fullpath.
2009         }
2010 }
2011
2012 void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load)
2013 {
2014         try {
2015                 std::istringstream is(*blob, std::ios_base::binary);
2016
2017                 u8 version = SER_FMT_VER_INVALID;
2018                 is.read((char*)&version, 1);
2019
2020                 if(is.fail())
2021                         throw SerializationError("ServerMap::loadBlock(): Failed"
2022                                         " to read MapBlock version");
2023
2024                 MapBlock *block = NULL;
2025                 bool created_new = false;
2026                 block = sector->getBlockNoCreateNoEx(p3d.Y);
2027                 if(block == NULL)
2028                 {
2029                         block = sector->createBlankBlockNoInsert(p3d.Y);
2030                         created_new = true;
2031                 }
2032
2033                 // Read basic data
2034                 block->deSerialize(is, version, true);
2035
2036                 // If it's a new block, insert it to the map
2037                 if (created_new) {
2038                         sector->insertBlock(block);
2039                         ReflowScan scanner(this, m_emerge->ndef);
2040                         scanner.scan(block, &m_transforming_liquid);
2041                 }
2042
2043                 /*
2044                         Save blocks loaded in old format in new format
2045                 */
2046
2047                 //if(version < SER_FMT_VER_HIGHEST_READ || save_after_load)
2048                 // Only save if asked to; no need to update version
2049                 if(save_after_load)
2050                         saveBlock(block);
2051
2052                 // We just loaded it from, so it's up-to-date.
2053                 block->resetModified();
2054         }
2055         catch(SerializationError &e)
2056         {
2057                 errorstream<<"Invalid block data in database"
2058                                 <<" ("<<p3d.X<<","<<p3d.Y<<","<<p3d.Z<<")"
2059                                 <<" (SerializationError): "<<e.what()<<std::endl;
2060
2061                 // TODO: Block should be marked as invalid in memory so that it is
2062                 // not touched but the game can run
2063
2064                 if(g_settings->getBool("ignore_world_load_errors")){
2065                         errorstream<<"Ignoring block load error. Duck and cover! "
2066                                         <<"(ignore_world_load_errors)"<<std::endl;
2067                 } else {
2068                         throw SerializationError("Invalid block data in database");
2069                 }
2070         }
2071 }
2072
2073 MapBlock* ServerMap::loadBlock(v3s16 blockpos)
2074 {
2075         bool created_new = (getBlockNoCreateNoEx(blockpos) == NULL);
2076
2077         v2s16 p2d(blockpos.X, blockpos.Z);
2078
2079         std::string ret;
2080         dbase->loadBlock(blockpos, &ret);
2081         if (!ret.empty()) {
2082                 loadBlock(&ret, blockpos, createSector(p2d), false);
2083         } else if (dbase_ro) {
2084                 dbase_ro->loadBlock(blockpos, &ret);
2085                 if (!ret.empty()) {
2086                         loadBlock(&ret, blockpos, createSector(p2d), false);
2087                 }
2088         } else {
2089                 // Not found in database, try the files
2090
2091                 // The directory layout we're going to load from.
2092                 //  1 - original sectors/xxxxzzzz/
2093                 //  2 - new sectors2/xxx/zzz/
2094                 //  If we load from anything but the latest structure, we will
2095                 //  immediately save to the new one, and remove the old.
2096                 std::string sectordir1 = getSectorDir(p2d, 1);
2097                 std::string sectordir;
2098                 if (fs::PathExists(sectordir1)) {
2099                         sectordir = sectordir1;
2100                 } else {
2101                         sectordir = getSectorDir(p2d, 2);
2102                 }
2103
2104                 /*
2105                 Make sure sector is loaded
2106                  */
2107
2108                 MapSector *sector = getSectorNoGenerate(p2d);
2109
2110                 /*
2111                 Make sure file exists
2112                  */
2113
2114                 std::string blockfilename = getBlockFilename(blockpos);
2115                 if (!fs::PathExists(sectordir + DIR_DELIM + blockfilename))
2116                         return NULL;
2117
2118                 /*
2119                 Load block and save it to the database
2120                  */
2121                 loadBlock(sectordir, blockfilename, sector, true);
2122         }
2123
2124         MapBlock *block = getBlockNoCreateNoEx(blockpos);
2125         if (created_new && (block != NULL)) {
2126                 std::map<v3s16, MapBlock*> modified_blocks;
2127                 // Fix lighting if necessary
2128                 voxalgo::update_block_border_lighting(this, block, modified_blocks);
2129                 if (!modified_blocks.empty()) {
2130                         //Modified lighting, send event
2131                         MapEditEvent event;
2132                         event.type = MEET_OTHER;
2133                         std::map<v3s16, MapBlock *>::iterator it;
2134                         for (it = modified_blocks.begin();
2135                                         it != modified_blocks.end(); ++it)
2136                                 event.modified_blocks.insert(it->first);
2137                         dispatchEvent(&event);
2138                 }
2139         }
2140         return block;
2141 }
2142
2143 bool ServerMap::deleteBlock(v3s16 blockpos)
2144 {
2145         if (!dbase->deleteBlock(blockpos))
2146                 return false;
2147
2148         MapBlock *block = getBlockNoCreateNoEx(blockpos);
2149         if (block) {
2150                 v2s16 p2d(blockpos.X, blockpos.Z);
2151                 MapSector *sector = getSectorNoGenerate(p2d);
2152                 if (!sector)
2153                         return false;
2154                 sector->deleteBlock(block);
2155         }
2156
2157         return true;
2158 }
2159
2160 void ServerMap::PrintInfo(std::ostream &out)
2161 {
2162         out<<"ServerMap: ";
2163 }
2164
2165 bool ServerMap::repairBlockLight(v3s16 blockpos,
2166         std::map<v3s16, MapBlock *> *modified_blocks)
2167 {
2168         MapBlock *block = emergeBlock(blockpos, false);
2169         if (!block || !block->isGenerated())
2170                 return false;
2171         voxalgo::repair_block_light(this, block, modified_blocks);
2172         return true;
2173 }
2174
2175 MMVManip::MMVManip(Map *map):
2176                 VoxelManipulator(),
2177                 m_map(map)
2178 {
2179 }
2180
2181 void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
2182         bool load_if_inexistent)
2183 {
2184         TimeTaker timer1("initialEmerge", &emerge_time);
2185
2186         // Units of these are MapBlocks
2187         v3s16 p_min = blockpos_min;
2188         v3s16 p_max = blockpos_max;
2189
2190         VoxelArea block_area_nodes
2191                         (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
2192
2193         u32 size_MB = block_area_nodes.getVolume()*4/1000000;
2194         if(size_MB >= 1)
2195         {
2196                 infostream<<"initialEmerge: area: ";
2197                 block_area_nodes.print(infostream);
2198                 infostream<<" ("<<size_MB<<"MB)";
2199                 infostream<<std::endl;
2200         }
2201
2202         addArea(block_area_nodes);
2203
2204         for(s32 z=p_min.Z; z<=p_max.Z; z++)
2205         for(s32 y=p_min.Y; y<=p_max.Y; y++)
2206         for(s32 x=p_min.X; x<=p_max.X; x++)
2207         {
2208                 u8 flags = 0;
2209                 MapBlock *block;
2210                 v3s16 p(x,y,z);
2211                 std::map<v3s16, u8>::iterator n;
2212                 n = m_loaded_blocks.find(p);
2213                 if(n != m_loaded_blocks.end())
2214                         continue;
2215
2216                 bool block_data_inexistent = false;
2217                 {
2218                         TimeTaker timer2("emerge load", &emerge_load_time);
2219
2220                         block = m_map->getBlockNoCreateNoEx(p);
2221                         if (!block || block->isDummy())
2222                                 block_data_inexistent = true;
2223                         else
2224                                 block->copyTo(*this);
2225                 }
2226
2227                 if(block_data_inexistent)
2228                 {
2229
2230                         if (load_if_inexistent && !blockpos_over_max_limit(p)) {
2231                                 ServerMap *svrmap = (ServerMap *)m_map;
2232                                 block = svrmap->emergeBlock(p, false);
2233                                 if (block == NULL)
2234                                         block = svrmap->createBlock(p);
2235                                 block->copyTo(*this);
2236                         } else {
2237                                 flags |= VMANIP_BLOCK_DATA_INEXIST;
2238
2239                                 /*
2240                                         Mark area inexistent
2241                                 */
2242                                 VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
2243                                 // Fill with VOXELFLAG_NO_DATA
2244                                 for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
2245                                 for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
2246                                 {
2247                                         s32 i = m_area.index(a.MinEdge.X,y,z);
2248                                         memset(&m_flags[i], VOXELFLAG_NO_DATA, MAP_BLOCKSIZE);
2249                                 }
2250                         }
2251                 }
2252                 /*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
2253                 {
2254                         // Mark that block was loaded as blank
2255                         flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
2256                 }*/
2257
2258                 m_loaded_blocks[p] = flags;
2259         }
2260
2261         m_is_dirty = false;
2262 }
2263
2264 void MMVManip::blitBackAll(std::map<v3s16, MapBlock*> *modified_blocks,
2265         bool overwrite_generated)
2266 {
2267         if(m_area.getExtent() == v3s16(0,0,0))
2268                 return;
2269
2270         /*
2271                 Copy data of all blocks
2272         */
2273         for (auto &loaded_block : m_loaded_blocks) {
2274                 v3s16 p = loaded_block.first;
2275                 MapBlock *block = m_map->getBlockNoCreateNoEx(p);
2276                 bool existed = !(loaded_block.second & VMANIP_BLOCK_DATA_INEXIST);
2277                 if (!existed || (block == NULL) ||
2278                         (!overwrite_generated && block->isGenerated()))
2279                         continue;
2280
2281                 block->copyFrom(*this);
2282                 block->raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_VMANIP);
2283
2284                 if(modified_blocks)
2285                         (*modified_blocks)[p] = block;
2286         }
2287 }
2288
2289 //END