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