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