src/emerge.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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
  21 #include "server.h"
  22 #include <iostream>
  23 #include <queue>
  24 #include "clientserver.h"
  25 #include "map.h"
  26 #include "jmutexautolock.h"
  27 #include "main.h"
  28 #include "constants.h"
  29 #include "voxel.h"
  30 #include "config.h"
  31 #include "mapblock.h"
  32 #include "serverobject.h"
  33 #include "settings.h"
  34 #include "script.h"
  35 #include "scriptapi.h"
  36 #include "profiler.h"
  37 #include "log.h"
  38 #include "nodedef.h"
  39 #include "biome.h"
  40 #include "emerge.h"
  41 #include "mapgen_v6.h"
  42
  43
  44 EmergeManager::EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef) {
  45         //register built-in mapgens
  46         registerMapgen("v6", new MapgenFactoryV6());
  47
  48         this->biomedef = bdef ? bdef : new BiomeDefManager(gamedef);
  49         this->params   = NULL;
  50         this->mapgen   = NULL;
  51
  52         qlimit_total    = g_settings->getU16("emergequeue_limit_total");
  53         qlimit_diskonly = g_settings->getU16("emergequeue_limit_diskonly");
  54         qlimit_generate = g_settings->getU16("emergequeue_limit_generate");
  55
  56         queuemutex.Init();
  57         emergethread = new EmergeThread((Server *)gamedef);
  58 }
  59
  60
  61 EmergeManager::~EmergeManager() {
  62         emergethread->setRun(false);
  63         emergethread->qevent.signal();
  64         emergethread->stop();
  65
  66         delete emergethread;
  67         delete biomedef;
  68         delete mapgen;
  69         delete params;
  70 }
  71
  72
  73 void EmergeManager::initMapgens(MapgenParams *mgparams) {
  74         if (mapgen)
  75                 return;
  76
  77         this->params = mgparams;
  78         this->mapgen = getMapgen(); //only one mapgen for now!
  79 }
  80
  81
  82 Mapgen *EmergeManager::getMapgen() {
  83         if (!mapgen) {
  84                 mapgen = createMapgen(params->mg_name, 0, params, this);
  85                 if (!mapgen) {
  86                         infostream << "EmergeManager: falling back to mapgen v6" << std::endl;
  87                         delete params;
  88                         params = createMapgenParams("v6");
  89                         mapgen = createMapgen("v6", 0, params, this);
  90                 }
  91         }
  92         return mapgen;
  93 }
  94
  95
  96 bool EmergeManager::enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate) {
  97         std::map<v3s16, BlockEmergeData *>::const_iterator iter;
  98         BlockEmergeData *bedata;
  99         u16 count;
 100         u8 flags = 0;
 101
 102         if (allow_generate)
 103                 flags |= BLOCK_EMERGE_ALLOWGEN;
 104
 105         {
 106                 JMutexAutoLock queuelock(queuemutex);
 107
 108                 count = blocks_enqueued.size();
 109                 if (count >= qlimit_total)
 110                         return false;
 111
 112                 count = peer_queue_count[peer_id];
 113                 u16 qlimit_peer = allow_generate ? qlimit_generate : qlimit_diskonly;
 114                 if (count >= qlimit_peer)
 115                         return false;
 116
 117                 iter = blocks_enqueued.find(p);
 118                 if (iter != blocks_enqueued.end()) {
 119                         bedata = iter->second;
 120                         bedata->flags |= flags;
 121                         return true;
 122                 }
 123
 124                 bedata = new BlockEmergeData;
 125                 bedata->flags = flags;
 126                 bedata->peer_requested = peer_id;
 127                 blocks_enqueued.insert(std::make_pair(p, bedata));
 128
 129                 peer_queue_count[peer_id] = count + 1;
 130
 131                 emergethread->blockqueue.push(p);
 132         }
 133         emergethread->qevent.signal();
 134
 135         return true;
 136 }
 137
 138
 139 bool EmergeManager::popBlockEmerge(v3s16 *pos, u8 *flags) {
 140         std::map<v3s16, BlockEmergeData *>::iterator iter;
 141         JMutexAutoLock queuelock(queuemutex);
 142
 143         if (emergethread->blockqueue.empty())
 144                 return false;
 145         v3s16 p = emergethread->blockqueue.front();
 146         emergethread->blockqueue.pop();
 147
 148         *pos = p;
 149
 150         iter = blocks_enqueued.find(p);
 151         if (iter == blocks_enqueued.end())
 152                 return false; //uh oh, queue and map out of sync!!
 153
 154         BlockEmergeData *bedata = iter->second;
 155         *flags = bedata->flags;
 156
 157         peer_queue_count[bedata->peer_requested]--;
 158
 159         delete bedata;
 160         blocks_enqueued.erase(iter);
 161
 162         return true;
 163 }
 164
 165
 166 int EmergeManager::getGroundLevelAtPoint(v2s16 p) {
 167         if (!mapgen)
 168                 return 0;
 169         return mapgen->getGroundLevelAtPoint(p);
 170 }
 171
 172
 173 bool EmergeManager::isBlockUnderground(v3s16 blockpos) {
 174         /*
 175         v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
 176                                         (blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
 177         int ground_level = getGroundLevelAtPoint(p);
 178         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
 179         */
 180
 181         //yuck, but then again, should i bother being accurate?
 182         //the height of the nodes in a single block is quite variable
 183         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params->water_level;
 184 }
 185
 186
 187 u32 EmergeManager::getBlockSeed(v3s16 p) {
 188         return (u32)(params->seed & 0xFFFFFFFF) +
 189                 p.Z * 38134234 +
 190                 p.Y * 42123 +
 191                 p.Y * 23;
 192 }
 193
 194
 195 Mapgen *EmergeManager::createMapgen(std::string mgname, int mgid,
 196                                                                         MapgenParams *mgparams, EmergeManager *emerge) {
 197         std::map<std::string, MapgenFactory *>::const_iterator iter = mglist.find(mgname);
 198         if (iter == mglist.end()) {
 199                 errorstream << "EmergeManager; mapgen " << mgname <<
 200                  " not registered" << std::endl;
 201                 return NULL;
 202         }
 203
 204         MapgenFactory *mgfactory = iter->second;
 205         return mgfactory->createMapgen(mgid, mgparams, emerge);
 206 }
 207
 208
 209 MapgenParams *EmergeManager::createMapgenParams(std::string mgname) {
 210         std::map<std::string, MapgenFactory *>::const_iterator iter = mglist.find(mgname);
 211         if (iter == mglist.end()) {
 212                 errorstream << "EmergeManager: mapgen " << mgname <<
 213                  " not registered" << std::endl;
 214                 return NULL;
 215         }
 216
 217         MapgenFactory *mgfactory = iter->second;
 218         return mgfactory->createMapgenParams();
 219 }
 220
 221
 222 MapgenParams *EmergeManager::getParamsFromSettings(Settings *settings) {
 223         std::string mg_name = settings->get("mg_name");
 224         MapgenParams *mgparams = createMapgenParams(mg_name);
 225
 226         mgparams->mg_name     = mg_name;
 227         mgparams->seed        = settings->getU64(settings == g_settings ? "fixed_map_seed" : "seed");
 228         mgparams->water_level = settings->getS16("water_level");
 229         mgparams->chunksize   = settings->getS16("chunksize");
 230         mgparams->flags       = settings->getS32("mg_flags");
 231
 232         if (!mgparams->readParams(settings)) {
 233                 delete mgparams;
 234                 return NULL;
 235         }
 236         return mgparams;
 237 }
 238
 239
 240 void EmergeManager::setParamsToSettings(Settings *settings) {
 241         settings->set("mg_name",         params->mg_name);
 242         settings->setU64("seed",         params->seed);
 243         settings->setS16("water_level",  params->water_level);
 244         settings->setS16("chunksize",    params->chunksize);
 245         settings->setFlagStr("mg_flags", params->flags, flagdesc_mapgen);
 246
 247         params->writeParams(settings);
 248 }
 249
 250
 251 bool EmergeManager::registerMapgen(std::string mgname, MapgenFactory *mgfactory) {
 252         mglist.insert(std::make_pair(mgname, mgfactory));
 253         infostream << "EmergeManager: registered mapgen " << mgname << std::endl;
 254 }
 255
 256
 257
 258 class MapEditEventIgnorer
 259 {
 260 public:
 261         MapEditEventIgnorer(bool *flag):
 262                 m_flag(flag)
 263         {
 264                 if(*m_flag == false)
 265                         *m_flag = true;
 266                 else
 267                         m_flag = NULL;
 268         }
 269
 270         ~MapEditEventIgnorer()
 271         {
 272                 if(m_flag)
 273                 {
 274                         assert(*m_flag);
 275                         *m_flag = false;
 276                 }
 277         }
 278
 279 private:
 280         bool *m_flag;
 281 };
 282
 283 class MapEditEventAreaIgnorer
 284 {
 285 public:
 286         MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
 287                 m_ignorevariable(ignorevariable)
 288         {
 289                 if(m_ignorevariable->getVolume() == 0)
 290                         *m_ignorevariable = a;
 291                 else
 292                         m_ignorevariable = NULL;
 293         }
 294
 295         ~MapEditEventAreaIgnorer()
 296         {
 297                 if(m_ignorevariable)
 298                 {
 299                         assert(m_ignorevariable->getVolume() != 0);
 300                         *m_ignorevariable = VoxelArea();
 301                 }
 302         }
 303
 304 private:
 305         VoxelArea *m_ignorevariable;
 306 };
 307
 308
 309 #if 1
 310
 311 #define EMERGE_DBG_OUT(x) \
 312         { if (enable_mapgen_debug_info) \
 313         infostream << "EmergeThread: " x << std::endl; }
 314
 315 bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b,
 316                                                                         BlockMakeData *data, bool allow_gen) {
 317         v2s16 p2d(p.X, p.Z);
 318         //envlock: usually takes <=1ms, sometimes 90ms or ~400ms to acquire
 319         JMutexAutoLock envlock(m_server->m_env_mutex);
 320
 321         // Load sector if it isn't loaded
 322         if (map->getSectorNoGenerateNoEx(p2d) == NULL)
 323                 map->loadSectorMeta(p2d);
 324
 325         // Attempt to load block
 326         MapBlock *block = map->getBlockNoCreateNoEx(p);
 327         if (!block || block->isDummy() || !block->isGenerated()) {
 328                 EMERGE_DBG_OUT("not in memory, attempting to load from disk");
 329                 block = map->loadBlock(p);
 330         }
 331
 332         // If could not load and allowed to generate,
 333         // start generation inside this same envlock
 334         if (allow_gen && (block == NULL || !block->isGenerated())) {
 335                 EMERGE_DBG_OUT("generating");
 336                 map->initBlockMake(data, p);
 337                 return true;
 338         }
 339
 340         *b = block;
 341         return false;
 342 }
 343
 344
 345 void *EmergeThread::Thread() {
 346         ThreadStarted();
 347         log_register_thread("EmergeThread");
 348         DSTACK(__FUNCTION_NAME);
 349         BEGIN_DEBUG_EXCEPTION_HANDLER
 350
 351         v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
 352         v3s16 p;
 353         u8 flags;
 354
 355         map    = (ServerMap *)&(m_server->m_env->getMap());
 356         emerge = m_server->m_emerge;
 357         mapgen = emerge->getMapgen();
 358
 359         while (getRun())
 360         try {
 361                 while (!emerge->popBlockEmerge(&p, &flags)) {
 362                         qevent.wait();
 363                         if (!getRun())
 364                                 goto exit_emerge_loop;
 365                 }
 366
 367                 last_tried_pos = p;
 368                 if (blockpos_over_limit(p))
 369                         continue;
 370
 371                 bool allow_generate = flags & BLOCK_EMERGE_ALLOWGEN;
 372                 EMERGE_DBG_OUT("p=" PP(p) " allow_generate=" << allow_generate);
 373
 374                 /*
 375                         Try to fetch block from memory or disk.
 376                         If not found and asked to generate, initialize generator.
 377                 */
 378                 BlockMakeData data;
 379                 MapBlock *block = NULL;
 380                 core::map<v3s16, MapBlock *> modified_blocks;
 381
 382                 if (getBlockOrStartGen(p, &block, &data, allow_generate)) {
 383                         {
 384                                 ScopeProfiler sp(g_profiler, "EmergeThread: Mapgen::makeChunk", SPT_AVG);
 385                                 TimeTaker t("mapgen::make_block()");
 386
 387                                 mapgen->makeChunk(&data);
 388
 389                                 if (enable_mapgen_debug_info == false)
 390                                         t.stop(true); // Hide output
 391                         }
 392
 393                         {
 394                                 //envlock: usually 0ms, but can take either 30 or 400ms to acquire
 395                                 JMutexAutoLock envlock(m_server->m_env_mutex);
 396                                 ScopeProfiler sp(g_profiler, "EmergeThread: after "
 397                                                 "Mapgen::makeChunk (envlock)", SPT_AVG);
 398
 399                                 map->finishBlockMake(&data, modified_blocks);
 400
 401                                 block = map->getBlockNoCreateNoEx(p);
 402                                 if (block) {
 403                                         /*
 404                                                 Do some post-generate stuff
 405                                         */
 406                                         v3s16 minp = data.blockpos_min * MAP_BLOCKSIZE;
 407                                         v3s16 maxp = data.blockpos_max * MAP_BLOCKSIZE +
 408                                                                  v3s16(1,1,1) * (MAP_BLOCKSIZE - 1);
 409
 410                                         // Ignore map edit events, they will not need to be sent
 411                                         // to anybody because the block hasn't been sent to anybody
 412                                         MapEditEventAreaIgnorer
 413                                                 ign(&m_server->m_ignore_map_edit_events_area,
 414                                                 VoxelArea(minp, maxp));
 415                                         {  // takes about 90ms with -O1 on an e3-1230v2
 416                                                 scriptapi_environment_on_generated(m_server->m_lua,
 417                                                                 minp, maxp, emerge->getBlockSeed(minp));
 418                                         }
 419
 420                                         EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
 421
 422                                         m_server->m_env->activateBlock(block, 0);
 423                                 }
 424                         }
 425                 }
 426
 427                 /*
 428                         Set sent status of modified blocks on clients
 429                 */
 430
 431                 // NOTE: Server's clients are also behind the connection mutex
 432                 //conlock: consistently takes 30-40ms to acquire
 433                 JMutexAutoLock lock(m_server->m_con_mutex);
 434                 // Add the originally fetched block to the modified list
 435                 if (block)
 436                         modified_blocks.insert(p, block);
 437
 438                 // Set the modified blocks unsent for all the clients
 439                 for (core::map<u16, RemoteClient*>::Iterator
 440                          i = m_server->m_clients.getIterator();
 441                          i.atEnd() == false; i++) {
 442                         RemoteClient *client = i.getNode()->getValue();
 443                         if (modified_blocks.size() > 0) {
 444                                 // Remove block from sent history
 445                                 client->SetBlocksNotSent(modified_blocks);
 446                         }
 447                 }
 448         }
 449         catch (VersionMismatchException &e) {
 450                 std::ostringstream err;
 451                 err << "World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
 452                 err << "----"<<std::endl;
 453                 err << "\""<<e.what()<<"\""<<std::endl;
 454                 err << "See debug.txt."<<std::endl;
 455                 err << "World probably saved by a newer version of Minetest."<<std::endl;
 456                 m_server->setAsyncFatalError(err.str());
 457         }
 458         catch (SerializationError &e) {
 459                 std::ostringstream err;
 460                 err << "Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
 461                 err << "----"<<std::endl;
 462                 err << "\""<<e.what()<<"\""<<std::endl;
 463                 err << "See debug.txt."<<std::endl;
 464                 err << "You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
 465                 m_server->setAsyncFatalError(err.str());
 466         }
 467
 468         END_DEBUG_EXCEPTION_HANDLER(errorstream)
 469 exit_emerge_loop:
 470         log_deregister_thread();
 471         return NULL;
 472 }
 473
 474 #else
 475
 476 void *EmergeThread::Thread() {
 477         ThreadStarted();
 478         log_register_thread("EmergeThread");
 479         DSTACK(__FUNCTION_NAME);
 480         BEGIN_DEBUG_EXCEPTION_HANDLER
 481
 482         bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 483
 484         v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
 485         ServerMap &map = ((ServerMap&)m_server->m_env->getMap());
 486         EmergeManager *emerge = m_server->m_emerge;
 487         Mapgen *mapgen = emerge->getMapgen();
 488
 489         while(getRun())
 490         try {
 491                 QueuedBlockEmerge *qptr = m_server->m_emerge_queue.pop();
 492                 if(qptr == NULL)
 493                         break;
 494                 SharedPtr<QueuedBlockEmerge> q(qptr);
 495
 496                 v3s16 &p = q->pos;
 497                 v2s16 p2d(p.X,p.Z);
 498
 499                 last_tried_pos = p;
 500
 501                 /*
 502                         Do not generate over-limit
 503                 */
 504                 if (blockpos_over_limit(p))
 505                         continue;
 506
 507                 //infostream<<"EmergeThread::Thread(): running"<<std::endl;
 508
 509                 //TimeTaker timer("block emerge");
 510
 511                 /*
 512                         Try to emerge it from somewhere.
 513
 514                         If it is only wanted as optional, only loading from disk
 515                         will be allowed.
 516                 */
 517
 518                 /*
 519                         Check if any peer wants it as non-optional. In that case it
 520                         will be generated.
 521
 522                         Also decrement the emerge queue count in clients.
 523                 */
 524
 525                 bool only_from_disk = true;
 526                 {
 527                         core::map<u16, u8>::Iterator i;
 528                         for (i=q->s.getIterator(); !i.atEnd(); i++) {
 529                                 u8 flags = i.getNode()->getValue();
 530                                 if (!(flags & BLOCK_EMERGE_FLAG_FROMDISK)) {
 531                                         only_from_disk = false;
 532                                         break;
 533                                 }
 534                         }
 535                 }
 536
 537                 if (enable_mapgen_debug_info)
 538                         infostream<<"EmergeThread: p="
 539                                         <<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
 540                                         <<"only_from_disk="<<only_from_disk<<std::endl;
 541
 542                 MapBlock *block = NULL;
 543                 bool got_block = true;
 544                 core::map<v3s16, MapBlock*> modified_blocks;
 545
 546                 /*
 547                         Try to fetch block from memory or disk.
 548                         If not found and asked to generate, initialize generator.
 549                 */
 550
 551                 bool started_generate = false;
 552                 BlockMakeData data;
 553                 {
 554                         JMutexAutoLock envlock(m_server->m_env_mutex);
 555
 556                         // Load sector if it isn't loaded
 557                         if(map.getSectorNoGenerateNoEx(p2d) == NULL)
 558                                 map.loadSectorMeta(p2d);
 559
 560                         // Attempt to load block
 561                         block = map.getBlockNoCreateNoEx(p);
 562                         if(!block || block->isDummy() || !block->isGenerated()) {
 563                                 if(enable_mapgen_debug_info)
 564                                         infostream<<"EmergeThread: not in memory, "
 565                                                         <<"attempting to load from disk"<<std::endl;
 566
 567                                 block = map.loadBlock(p);
 568                         }
 569
 570                         // If could not load and allowed to generate, start generation
 571                         // inside this same envlock
 572                         if(only_from_disk == false &&
 573                                         (block == NULL || block->isGenerated() == false)){
 574                                 if(enable_mapgen_debug_info)
 575                                         infostream<<"EmergeThread: generating"<<std::endl;
 576                                 started_generate = true;
 577
 578                                 map.initBlockMake(&data, p);
 579                         }
 580                 }
 581
 582                 /*
 583                         If generator was initialized, generate now when envlock is free.
 584                 */
 585                 if(started_generate) {
 586                         {
 587                                 ScopeProfiler sp(g_profiler, "EmergeThread: mapgen::make_block",
 588                                                 SPT_AVG);
 589                                 TimeTaker t("mapgen::make_block()");
 590
 591                                 mapgen->makeChunk(&data);
 592
 593                                 if (enable_mapgen_debug_info == false)
 594                                         t.stop(true); // Hide output
 595                         }
 596
 597                         do{ // enable break
 598                                 // Lock environment again to access the map
 599                                 JMutexAutoLock envlock(m_server->m_env_mutex);
 600
 601                                 ScopeProfiler sp(g_profiler, "EmergeThread: after "
 602                                                 "mapgen::make_block (envlock)", SPT_AVG);
 603
 604                                 // Blit data back on map, update lighting, add mobs and
 605                                 // whatever this does
 606                                 map.finishBlockMake(&data, modified_blocks);
 607
 608                                 // Get central block
 609                                 block = map.getBlockNoCreateNoEx(p);
 610
 611                                 // If block doesn't exist, don't try doing anything with it
 612                                 // This happens if the block is not in generation boundaries
 613                                 if(!block)
 614                                         break;
 615
 616                                 /*
 617                                         Do some post-generate stuff
 618                                 */
 619                                 v3s16 minp = data.blockpos_min * MAP_BLOCKSIZE;
 620                                 v3s16 maxp = data.blockpos_max * MAP_BLOCKSIZE +
 621                                                 v3s16(1,1,1) * (MAP_BLOCKSIZE - 1);
 622
 623                                 /*
 624                                         Ignore map edit events, they will not need to be
 625                                         sent to anybody because the block hasn't been sent
 626                                         to anybody
 627                                 */
 628                                 MapEditEventAreaIgnorer ign(
 629                                                 &m_server->m_ignore_map_edit_events_area,
 630                                                 VoxelArea(minp, maxp));
 631                                 {
 632                                         TimeTaker timer("on_generated");
 633                                         scriptapi_environment_on_generated(m_server->m_lua,
 634                                                         minp, maxp, emerge->getBlockSeed(minp));
 635                                         //int t = timer.stop(true);
 636                                         //dstream<<"on_generated took "<<t<<"ms"<<std::endl;
 637                                 }
 638
 639                                 if (enable_mapgen_debug_info)
 640                                         infostream << "EmergeThread: ended up with: "
 641                                                         << analyze_block(block) << std::endl;
 642
 643                                 // Activate objects and stuff
 644                                 m_server->m_env->activateBlock(block, 0);
 645                         }while(false);
 646                 }
 647
 648                 if(block == NULL)
 649                         got_block = false;
 650
 651                 /*
 652                         Set sent status of modified blocks on clients
 653                 */
 654
 655                 // NOTE: Server's clients are also behind the connection mutex
 656                 JMutexAutoLock lock(m_server->m_con_mutex);
 657
 658                 /*
 659                         Add the originally fetched block to the modified list
 660                 */
 661                 if(got_block)
 662                         modified_blocks.insert(p, block);
 663
 664                 /*
 665                         Set the modified blocks unsent for all the clients
 666                 */
 667                 for(core::map<u16, RemoteClient*>::Iterator
 668                                 i = m_server->m_clients.getIterator();
 669                                 i.atEnd() == false; i++) {
 670                         RemoteClient *client = i.getNode()->getValue();
 671                         if(modified_blocks.size() > 0) {
 672                                 // Remove block from sent history
 673                                 client->SetBlocksNotSent(modified_blocks);
 674                         }
 675                 }
 676
 677
 678 niters++;
 679         }
 680         catch (VersionMismatchException &e) {
 681                 std::ostringstream err;
 682                 err << "World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
 683                 err << "----"<<std::endl;
 684                 err << "\""<<e.what()<<"\""<<std::endl;
 685                 err << "See debug.txt."<<std::endl;
 686                 err << "World probably saved by a newer version of Minetest."<<std::endl;
 687                 m_server->setAsyncFatalError(err.str());
 688         }
 689         catch (SerializationError &e) {
 690                 std::ostringstream err;
 691                 err << "Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
 692                 err << "----"<<std::endl;
 693                 err << "\""<<e.what()<<"\""<<std::endl;
 694                 err << "See debug.txt."<<std::endl;
 695                 err << "You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
 696                 m_server->setAsyncFatalError(err.str());
 697         }
 698 printf("emergethread iterated %d times\n", niters);
 699         END_DEBUG_EXCEPTION_HANDLER(errorstream)
 700         log_deregister_thread();
 701         return NULL;
 702 }
 703
 704 #endif