src/emerge.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "emerge.h"
  22
  23 #include <iostream>
  24 #include <queue>
  25
  26 #include "util/container.h"
  27 #include "util/thread.h"
  28 #include "threading/event.h"
  29
  30 #include "config.h"
  31 #include "constants.h"
  32 #include "environment.h"
  33 #include "log.h"
  34 #include "map.h"
  35 #include "mapblock.h"
  36 #include "mapgen/mg_biome.h"
  37 #include "mapgen/mg_ore.h"
  38 #include "mapgen/mg_decoration.h"
  39 #include "mapgen/mg_schematic.h"
  40 #include "nodedef.h"
  41 #include "profiler.h"
  42 #include "scripting_server.h"
  43 #include "server.h"
  44 #include "settings.h"
  45 #include "voxel.h"
  46
  47 class EmergeThread : public Thread
  48 {
  49 public:
  50         bool enable_mapgen_debug_info;
  51         int id;
  52
  53         EmergeThread(Server *server, int ethreadid);
  54         ~EmergeThread() = default;
  55
  56         void *run();
  57         void signal();
  58
  59         // Requires queue mutex held
  60         bool pushBlock(const v3s16 &pos);
  61
  62         void cancelPendingItems();
  63
  64         static void runCompletionCallbacks(const v3s16 &pos, EmergeAction action,
  65                         const EmergeCallbackList &callbacks);
  66
  67 private:
  68         Server *m_server;
  69         ServerMap *m_map;
  70         EmergeManager *m_emerge;
  71         Mapgen *m_mapgen;
  72
  73         Event m_queue_event;
  74         std::queue<v3s16> m_block_queue;
  75
  76         bool popBlockEmerge(v3s16 *pos, BlockEmergeData *bedata);
  77
  78         EmergeAction getBlockOrStartGen(const v3s16 &pos, bool allow_gen,
  79                         MapBlock **block, BlockMakeData *data);
  80         MapBlock *finishGen(v3s16 pos, BlockMakeData *bmdata,
  81                         std::map<v3s16, MapBlock *> *modified_blocks);
  82
  83         friend class EmergeManager;
  84 };
  85
  86 class MapEditEventAreaIgnorer
  87 {
  88 public:
  89         MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a) :
  90                         m_ignorevariable(ignorevariable)
  91         {
  92                 if (m_ignorevariable->getVolume() == 0)
  93                         *m_ignorevariable = a;
  94                 else
  95                         m_ignorevariable = NULL;
  96         }
  97
  98         ~MapEditEventAreaIgnorer()
  99         {
 100                 if (m_ignorevariable) {
 101                         assert(m_ignorevariable->getVolume() != 0);
 102                         *m_ignorevariable = VoxelArea();
 103                 }
 104         }
 105
 106 private:
 107         VoxelArea *m_ignorevariable;
 108 };
 109
 110 EmergeParams::~EmergeParams()
 111 {
 112         infostream << "EmergeParams: destroying " << this << std::endl;
 113         // Delete everything that was cloned on creation of EmergeParams
 114         delete biomemgr;
 115         delete oremgr;
 116         delete decomgr;
 117         delete schemmgr;
 118 }
 119
 120 EmergeParams::EmergeParams(EmergeManager *parent, const BiomeManager *biomemgr,
 121                 const OreManager *oremgr, const DecorationManager *decomgr,
 122                 const SchematicManager *schemmgr) :
 123                 ndef(parent->ndef),
 124                 enable_mapgen_debug_info(parent->enable_mapgen_debug_info),
 125                 gen_notify_on(parent->gen_notify_on),
 126                 gen_notify_on_deco_ids(&parent->gen_notify_on_deco_ids),
 127                 biomemgr(biomemgr->clone()), oremgr(oremgr->clone()),
 128                 decomgr(decomgr->clone()), schemmgr(schemmgr->clone())
 129 {
 130 }
 131
 132 ////
 133 //// EmergeManager
 134 ////
 135
 136 EmergeManager::EmergeManager(Server *server)
 137 {
 138         this->ndef = server->getNodeDefManager();
 139         this->biomemgr = new BiomeManager(server);
 140         this->oremgr = new OreManager(server);
 141         this->decomgr = new DecorationManager(server);
 142         this->schemmgr = new SchematicManager(server);
 143
 144         // Note that accesses to this variable are not synchronized.
 145         // This is because the *only* thread ever starting or stopping
 146         // EmergeThreads should be the ServerThread.
 147
 148         enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 149
 150         s16 nthreads = 1;
 151         g_settings->getS16NoEx("num_emerge_threads", nthreads);
 152         // If automatic, leave a proc for the main thread and one for
 153         // some other misc thread
 154         if (nthreads == 0)
 155                 nthreads = Thread::getNumberOfProcessors() - 2;
 156         if (nthreads < 1)
 157                 nthreads = 1;
 158
 159         m_qlimit_total = g_settings->getU16("emergequeue_limit_total");
 160         // FIXME: these fallback values are probably not good
 161         if (!g_settings->getU16NoEx("emergequeue_limit_diskonly", m_qlimit_diskonly))
 162                 m_qlimit_diskonly = nthreads * 5 + 1;
 163         if (!g_settings->getU16NoEx("emergequeue_limit_generate", m_qlimit_generate))
 164                 m_qlimit_generate = nthreads + 1;
 165
 166         // don't trust user input for something very important like this
 167         if (m_qlimit_total < 1)
 168                 m_qlimit_total = 1;
 169         if (m_qlimit_diskonly < 1)
 170                 m_qlimit_diskonly = 1;
 171         if (m_qlimit_generate < 1)
 172                 m_qlimit_generate = 1;
 173
 174         for (s16 i = 0; i < nthreads; i++)
 175                 m_threads.push_back(new EmergeThread(server, i));
 176
 177         infostream << "EmergeManager: using " << nthreads << " threads" << std::endl;
 178 }
 179
 180 EmergeManager::~EmergeManager()
 181 {
 182         for (u32 i = 0; i != m_threads.size(); i++) {
 183                 EmergeThread *thread = m_threads[i];
 184
 185                 if (m_threads_active) {
 186                         thread->stop();
 187                         thread->signal();
 188                         thread->wait();
 189                 }
 190
 191                 delete thread;
 192
 193                 // Mapgen init might not be finished if there is an error during startup.
 194                 if (m_mapgens.size() > i)
 195                         delete m_mapgens[i];
 196         }
 197
 198         delete biomemgr;
 199         delete oremgr;
 200         delete decomgr;
 201         delete schemmgr;
 202 }
 203
 204 BiomeManager *EmergeManager::getWritableBiomeManager()
 205 {
 206         FATAL_ERROR_IF(!m_mapgens.empty(),
 207                         "Writable managers can only be returned before mapgen init");
 208         return biomemgr;
 209 }
 210
 211 OreManager *EmergeManager::getWritableOreManager()
 212 {
 213         FATAL_ERROR_IF(!m_mapgens.empty(),
 214                         "Writable managers can only be returned before mapgen init");
 215         return oremgr;
 216 }
 217
 218 DecorationManager *EmergeManager::getWritableDecorationManager()
 219 {
 220         FATAL_ERROR_IF(!m_mapgens.empty(),
 221                         "Writable managers can only be returned before mapgen init");
 222         return decomgr;
 223 }
 224
 225 SchematicManager *EmergeManager::getWritableSchematicManager()
 226 {
 227         FATAL_ERROR_IF(!m_mapgens.empty(),
 228                         "Writable managers can only be returned before mapgen init");
 229         return schemmgr;
 230 }
 231
 232 void EmergeManager::initMapgens(MapgenParams *params)
 233 {
 234         FATAL_ERROR_IF(!m_mapgens.empty(), "Mapgen already initialised.");
 235
 236         mgparams = params;
 237
 238         for (u32 i = 0; i != m_threads.size(); i++) {
 239                 EmergeParams *p = new EmergeParams(
 240                                 this, biomemgr, oremgr, decomgr, schemmgr);
 241                 infostream << "EmergeManager: Created params " << p << " for thread " << i
 242                            << std::endl;
 243                 m_mapgens.push_back(Mapgen::createMapgen(params->mgtype, params, p));
 244         }
 245 }
 246
 247 Mapgen *EmergeManager::getCurrentMapgen()
 248 {
 249         if (!m_threads_active)
 250                 return nullptr;
 251
 252         for (u32 i = 0; i != m_threads.size(); i++) {
 253                 EmergeThread *t = m_threads[i];
 254                 if (t->isRunning() && t->isCurrentThread())
 255                         return t->m_mapgen;
 256         }
 257
 258         return nullptr;
 259 }
 260
 261 void EmergeManager::startThreads()
 262 {
 263         if (m_threads_active)
 264                 return;
 265
 266         for (u32 i = 0; i != m_threads.size(); i++)
 267                 m_threads[i]->start();
 268
 269         m_threads_active = true;
 270 }
 271
 272 void EmergeManager::stopThreads()
 273 {
 274         if (!m_threads_active)
 275                 return;
 276
 277         // Request thread stop in parallel
 278         for (u32 i = 0; i != m_threads.size(); i++) {
 279                 m_threads[i]->stop();
 280                 m_threads[i]->signal();
 281         }
 282
 283         // Then do the waiting for each
 284         for (u32 i = 0; i != m_threads.size(); i++)
 285                 m_threads[i]->wait();
 286
 287         m_threads_active = false;
 288 }
 289
 290 bool EmergeManager::isRunning()
 291 {
 292         return m_threads_active;
 293 }
 294
 295 bool EmergeManager::enqueueBlockEmerge(session_t peer_id, v3s16 blockpos,
 296                 bool allow_generate, bool ignore_queue_limits)
 297 {
 298         u16 flags = 0;
 299         if (allow_generate)
 300                 flags |= BLOCK_EMERGE_ALLOW_GEN;
 301         if (ignore_queue_limits)
 302                 flags |= BLOCK_EMERGE_FORCE_QUEUE;
 303
 304         return enqueueBlockEmergeEx(blockpos, peer_id, flags, NULL, NULL);
 305 }
 306
 307 bool EmergeManager::enqueueBlockEmergeEx(v3s16 blockpos, session_t peer_id, u16 flags,
 308                 EmergeCompletionCallback callback, void *callback_param)
 309 {
 310         EmergeThread *thread = NULL;
 311         bool entry_already_exists = false;
 312
 313         {
 314                 MutexAutoLock queuelock(m_queue_mutex);
 315
 316                 if (!pushBlockEmergeData(blockpos, peer_id, flags, callback,
 317                                     callback_param, &entry_already_exists))
 318                         return false;
 319
 320                 if (entry_already_exists)
 321                         return true;
 322
 323                 thread = getOptimalThread();
 324                 thread->pushBlock(blockpos);
 325         }
 326
 327         thread->signal();
 328
 329         return true;
 330 }
 331
 332 //
 333 // Mapgen-related helper functions
 334 //
 335
 336 // TODO(hmmmm): Move this to ServerMap
 337 v3s16 EmergeManager::getContainingChunk(v3s16 blockpos)
 338 {
 339         return getContainingChunk(blockpos, mgparams->chunksize);
 340 }
 341
 342 // TODO(hmmmm): Move this to ServerMap
 343 v3s16 EmergeManager::getContainingChunk(v3s16 blockpos, s16 chunksize)
 344 {
 345         s16 coff = -chunksize / 2;
 346         v3s16 chunk_offset(coff, coff, coff);
 347
 348         return getContainerPos(blockpos - chunk_offset, chunksize) * chunksize +
 349                chunk_offset;
 350 }
 351
 352 int EmergeManager::getSpawnLevelAtPoint(v2s16 p)
 353 {
 354         if (m_mapgens.empty() || !m_mapgens[0]) {
 355                 errorstream << "EmergeManager: getSpawnLevelAtPoint() called"
 356                                " before mapgen init"
 357                             << std::endl;
 358                 return 0;
 359         }
 360
 361         return m_mapgens[0]->getSpawnLevelAtPoint(p);
 362 }
 363
 364 int EmergeManager::getGroundLevelAtPoint(v2s16 p)
 365 {
 366         if (m_mapgens.empty() || !m_mapgens[0]) {
 367                 errorstream << "EmergeManager: getGroundLevelAtPoint() called"
 368                                " before mapgen init"
 369                             << std::endl;
 370                 return 0;
 371         }
 372
 373         return m_mapgens[0]->getGroundLevelAtPoint(p);
 374 }
 375
 376 // TODO(hmmmm): Move this to ServerMap
 377 bool EmergeManager::isBlockUnderground(v3s16 blockpos)
 378 {
 379 #if 0
 380         v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
 381                                         (blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
 382         int ground_level = getGroundLevelAtPoint(p);
 383         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
 384 #endif
 385
 386         // Use a simple heuristic; the above method is wildly inaccurate anyway.
 387         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= mgparams->water_level;
 388 }
 389
 390 bool EmergeManager::pushBlockEmergeData(v3s16 pos, u16 peer_requested, u16 flags,
 391                 EmergeCompletionCallback callback, void *callback_param,
 392                 bool *entry_already_exists)
 393 {
 394         u16 &count_peer = m_peer_queue_count[peer_requested];
 395
 396         if ((flags & BLOCK_EMERGE_FORCE_QUEUE) == 0) {
 397                 if (m_blocks_enqueued.size() >= m_qlimit_total)
 398                         return false;
 399
 400                 if (peer_requested != PEER_ID_INEXISTENT) {
 401                         u16 qlimit_peer = (flags & BLOCK_EMERGE_ALLOW_GEN)
 402                                                           ? m_qlimit_generate
 403                                                           : m_qlimit_diskonly;
 404                         if (count_peer >= qlimit_peer)
 405                                 return false;
 406                 }
 407         }
 408
 409         std::pair<std::map<v3s16, BlockEmergeData>::iterator, bool> findres;
 410         findres = m_blocks_enqueued.insert(std::make_pair(pos, BlockEmergeData()));
 411
 412         BlockEmergeData &bedata = findres.first->second;
 413         *entry_already_exists = !findres.second;
 414
 415         if (callback)
 416                 bedata.callbacks.emplace_back(callback, callback_param);
 417
 418         if (*entry_already_exists) {
 419                 bedata.flags |= flags;
 420         } else {
 421                 bedata.flags = flags;
 422                 bedata.peer_requested = peer_requested;
 423
 424                 count_peer++;
 425         }
 426
 427         return true;
 428 }
 429
 430 bool EmergeManager::popBlockEmergeData(v3s16 pos, BlockEmergeData *bedata)
 431 {
 432         std::map<v3s16, BlockEmergeData>::iterator it;
 433         std::unordered_map<u16, u16>::iterator it2;
 434
 435         it = m_blocks_enqueued.find(pos);
 436         if (it == m_blocks_enqueued.end())
 437                 return false;
 438
 439         *bedata = it->second;
 440
 441         it2 = m_peer_queue_count.find(bedata->peer_requested);
 442         if (it2 == m_peer_queue_count.end())
 443                 return false;
 444
 445         u16 &count_peer = it2->second;
 446         assert(count_peer != 0);
 447         count_peer--;
 448
 449         m_blocks_enqueued.erase(it);
 450
 451         return true;
 452 }
 453
 454 EmergeThread *EmergeManager::getOptimalThread()
 455 {
 456         size_t nthreads = m_threads.size();
 457
 458         FATAL_ERROR_IF(nthreads == 0, "No emerge threads!");
 459
 460         size_t index = 0;
 461         size_t nitems_lowest = m_threads[0]->m_block_queue.size();
 462
 463         for (size_t i = 1; i < nthreads; i++) {
 464                 size_t nitems = m_threads[i]->m_block_queue.size();
 465                 if (nitems < nitems_lowest) {
 466                         index = i;
 467                         nitems_lowest = nitems;
 468                 }
 469         }
 470
 471         return m_threads[index];
 472 }
 473
 474 ////
 475 //// EmergeThread
 476 ////
 477
 478 EmergeThread::EmergeThread(Server *server, int ethreadid) :
 479                 enable_mapgen_debug_info(false), id(ethreadid), m_server(server),
 480                 m_map(NULL), m_emerge(NULL), m_mapgen(NULL)
 481 {
 482         m_name = "Emerge-" + itos(ethreadid);
 483 }
 484
 485 void EmergeThread::signal()
 486 {
 487         m_queue_event.signal();
 488 }
 489
 490 bool EmergeThread::pushBlock(const v3s16 &pos)
 491 {
 492         m_block_queue.push(pos);
 493         return true;
 494 }
 495
 496 void EmergeThread::cancelPendingItems()
 497 {
 498         MutexAutoLock queuelock(m_emerge->m_queue_mutex);
 499
 500         while (!m_block_queue.empty()) {
 501                 BlockEmergeData bedata;
 502                 v3s16 pos;
 503
 504                 pos = m_block_queue.front();
 505                 m_block_queue.pop();
 506
 507                 m_emerge->popBlockEmergeData(pos, &bedata);
 508
 509                 runCompletionCallbacks(pos, EMERGE_CANCELLED, bedata.callbacks);
 510         }
 511 }
 512
 513 void EmergeThread::runCompletionCallbacks(const v3s16 &pos, EmergeAction action,
 514                 const EmergeCallbackList &callbacks)
 515 {
 516         for (size_t i = 0; i != callbacks.size(); i++) {
 517                 EmergeCompletionCallback callback;
 518                 void *param;
 519
 520                 callback = callbacks[i].first;
 521                 param = callbacks[i].second;
 522
 523                 callback(pos, action, param);
 524         }
 525 }
 526
 527 bool EmergeThread::popBlockEmerge(v3s16 *pos, BlockEmergeData *bedata)
 528 {
 529         MutexAutoLock queuelock(m_emerge->m_queue_mutex);
 530
 531         if (m_block_queue.empty())
 532                 return false;
 533
 534         *pos = m_block_queue.front();
 535         m_block_queue.pop();
 536
 537         m_emerge->popBlockEmergeData(*pos, bedata);
 538
 539         return true;
 540 }
 541
 542 EmergeAction EmergeThread::getBlockOrStartGen(
 543                 const v3s16 &pos, bool allow_gen, MapBlock **block, BlockMakeData *bmdata)
 544 {
 545         MutexAutoLock envlock(m_server->m_env_mutex);
 546
 547         // 1). Attempt to fetch block from memory
 548         *block = m_map->getBlockNoCreateNoEx(pos);
 549         if (*block && !(*block)->isDummy()) {
 550                 if ((*block)->isGenerated())
 551                         return EMERGE_FROM_MEMORY;
 552         } else {
 553                 // 2). Attempt to load block from disk if it was not in the memory
 554                 *block = m_map->loadBlock(pos);
 555                 if (*block && (*block)->isGenerated())
 556                         return EMERGE_FROM_DISK;
 557         }
 558
 559         // 3). Attempt to start generation
 560         if (allow_gen && m_map->initBlockMake(pos, bmdata))
 561                 return EMERGE_GENERATED;
 562
 563         // All attempts failed; cancel this block emerge
 564         return EMERGE_CANCELLED;
 565 }
 566
 567 MapBlock *EmergeThread::finishGen(v3s16 pos, BlockMakeData *bmdata,
 568                 std::map<v3s16, MapBlock *> *modified_blocks)
 569 {
 570         MutexAutoLock envlock(m_server->m_env_mutex);
 571         ScopeProfiler sp(g_profiler, "EmergeThread: after Mapgen::makeChunk", SPT_AVG);
 572
 573         /*
 574                 Perform post-processing on blocks (invalidate lighting, queue liquid
 575                 transforms, etc.) to finish block make
 576         */
 577         m_map->finishBlockMake(bmdata, modified_blocks);
 578
 579         MapBlock *block = m_map->getBlockNoCreateNoEx(pos);
 580         if (!block) {
 581                 errorstream << "EmergeThread::finishGen: Couldn't grab block we "
 582                                "just generated: "
 583                             << PP(pos) << std::endl;
 584                 return NULL;
 585         }
 586
 587         v3s16 minp = bmdata->blockpos_min * MAP_BLOCKSIZE;
 588         v3s16 maxp = bmdata->blockpos_max * MAP_BLOCKSIZE +
 589                      v3s16(1, 1, 1) * (MAP_BLOCKSIZE - 1);
 590
 591         // Ignore map edit events, they will not need to be sent
 592         // to anybody because the block hasn't been sent to anybody
 593         MapEditEventAreaIgnorer ign(
 594                         &m_server->m_ignore_map_edit_events_area, VoxelArea(minp, maxp));
 595
 596         /*
 597                 Run Lua on_generated callbacks
 598         */
 599         try {
 600                 m_server->getScriptIface()->environment_OnGenerated(
 601                                 minp, maxp, m_mapgen->blockseed);
 602         } catch (LuaError &e) {
 603                 m_server->setAsyncFatalError("Lua: finishGen" + std::string(e.what()));
 604         }
 605
 606         /*
 607                 Clear generate notifier events
 608         */
 609         m_mapgen->gennotify.clearEvents();
 610
 611         EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
 612
 613         /*
 614                 Activate the block
 615         */
 616         m_server->m_env->activateBlock(block, 0);
 617
 618         return block;
 619 }
 620
 621 void *EmergeThread::run()
 622 {
 623         BEGIN_DEBUG_EXCEPTION_HANDLER
 624
 625         v3s16 pos;
 626
 627         m_map = (ServerMap *)&(m_server->m_env->getMap());
 628         m_emerge = m_server->m_emerge;
 629         m_mapgen = m_emerge->m_mapgens[id];
 630         enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
 631
 632         try {
 633                 while (!stopRequested()) {
 634                         std::map<v3s16, MapBlock *> modified_blocks;
 635                         BlockEmergeData bedata;
 636                         BlockMakeData bmdata;
 637                         EmergeAction action;
 638                         MapBlock *block;
 639
 640                         if (!popBlockEmerge(&pos, &bedata)) {
 641                                 m_queue_event.wait();
 642                                 continue;
 643                         }
 644
 645                         if (blockpos_over_max_limit(pos))
 646                                 continue;
 647
 648                         bool allow_gen = bedata.flags & BLOCK_EMERGE_ALLOW_GEN;
 649                         EMERGE_DBG_OUT("pos=" PP(pos) " allow_gen=" << allow_gen);
 650
 651                         action = getBlockOrStartGen(pos, allow_gen, &block, &bmdata);
 652                         if (action == EMERGE_GENERATED) {
 653                                 {
 654                                         ScopeProfiler sp(g_profiler,
 655                                                         "EmergeThread: Mapgen::makeChunk",
 656                                                         SPT_AVG);
 657
 658                                         m_mapgen->makeChunk(&bmdata);
 659                                 }
 660
 661                                 block = finishGen(pos, &bmdata, &modified_blocks);
 662                         }
 663
 664                         runCompletionCallbacks(pos, action, bedata.callbacks);
 665
 666                         if (block)
 667                                 modified_blocks[pos] = block;
 668
 669                         if (!modified_blocks.empty())
 670                                 m_server->SetBlocksNotSent(modified_blocks);
 671                 }
 672         } catch (VersionMismatchException &e) {
 673                 std::ostringstream err;
 674                 err << "World data version mismatch in MapBlock " << PP(pos) << std::endl
 675                     << "----" << std::endl
 676                     << "\"" << e.what() << "\"" << std::endl
 677                     << "See debug.txt." << std::endl
 678                     << "World probably saved by a newer version of " PROJECT_NAME_C "."
 679                     << std::endl;
 680                 m_server->setAsyncFatalError(err.str());
 681         } catch (SerializationError &e) {
 682                 std::ostringstream err;
 683                 err << "Invalid data in MapBlock " << PP(pos) << std::endl
 684                     << "----" << std::endl
 685                     << "\"" << e.what() << "\"" << std::endl
 686                     << "See debug.txt." << std::endl
 687                     << "You can ignore this using [ignore_world_load_errors = true]."
 688                     << std::endl;
 689                 m_server->setAsyncFatalError(err.str());
 690         }
 691
 692         END_DEBUG_EXCEPTION_HANDLER
 693         return NULL;
 694 }