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