src/map.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 General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 "main.h"
  24 #include "client.h"
  25 #include "filesys.h"
  26 #include "utility.h"
  27 #include "voxel.h"
  28 #include "porting.h"
  29 #include "mapgen.h"
  30 #include "nodemetadata.h"
  31
  32 extern "C" {
  33         #include "sqlite3.h"
  34 }
  35 /*
  36         SQLite format specification:
  37         - Initially only replaces sectors/ and sectors2/
  38 */
  39
  40 /*
  41         Map
  42 */
  43
  44 Map::Map(std::ostream &dout):
  45         m_dout(dout),
  46         m_sector_cache(NULL)
  47 {
  48         /*m_sector_mutex.Init();
  49         assert(m_sector_mutex.IsInitialized());*/
  50 }
  51
  52 Map::~Map()
  53 {
  54         /*
  55                 Free all MapSectors
  56         */
  57         core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
  58         for(; i.atEnd() == false; i++)
  59         {
  60                 MapSector *sector = i.getNode()->getValue();
  61                 delete sector;
  62         }
  63 }
  64
  65 void Map::addEventReceiver(MapEventReceiver *event_receiver)
  66 {
  67         m_event_receivers.insert(event_receiver, false);
  68 }
  69
  70 void Map::removeEventReceiver(MapEventReceiver *event_receiver)
  71 {
  72         if(m_event_receivers.find(event_receiver) == NULL)
  73                 return;
  74         m_event_receivers.remove(event_receiver);
  75 }
  76
  77 void Map::dispatchEvent(MapEditEvent *event)
  78 {
  79         for(core::map<MapEventReceiver*, bool>::Iterator
  80                         i = m_event_receivers.getIterator();
  81                         i.atEnd()==false; i++)
  82         {
  83                 MapEventReceiver* event_receiver = i.getNode()->getKey();
  84                 event_receiver->onMapEditEvent(event);
  85         }
  86 }
  87
  88 MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p)
  89 {
  90         if(m_sector_cache != NULL && p == m_sector_cache_p){
  91                 MapSector * sector = m_sector_cache;
  92                 return sector;
  93         }
  94
  95         core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
  96
  97         if(n == NULL)
  98                 return NULL;
  99
 100         MapSector *sector = n->getValue();
 101
 102         // Cache the last result
 103         m_sector_cache_p = p;
 104         m_sector_cache = sector;
 105
 106         return sector;
 107 }
 108
 109 MapSector * Map::getSectorNoGenerateNoEx(v2s16 p)
 110 {
 111         return getSectorNoGenerateNoExNoLock(p);
 112 }
 113
 114 MapSector * Map::getSectorNoGenerate(v2s16 p)
 115 {
 116         MapSector *sector = getSectorNoGenerateNoEx(p);
 117         if(sector == NULL)
 118                 throw InvalidPositionException();
 119
 120         return sector;
 121 }
 122
 123 MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d)
 124 {
 125         v2s16 p2d(p3d.X, p3d.Z);
 126         MapSector * sector = getSectorNoGenerateNoEx(p2d);
 127         if(sector == NULL)
 128                 return NULL;
 129         MapBlock *block = sector->getBlockNoCreateNoEx(p3d.Y);
 130         return block;
 131 }
 132
 133 MapBlock * Map::getBlockNoCreate(v3s16 p3d)
 134 {
 135         MapBlock *block = getBlockNoCreateNoEx(p3d);
 136         if(block == NULL)
 137                 throw InvalidPositionException();
 138         return block;
 139 }
 140
 141 bool Map::isNodeUnderground(v3s16 p)
 142 {
 143         v3s16 blockpos = getNodeBlockPos(p);
 144         try{
 145                 MapBlock * block = getBlockNoCreate(blockpos);
 146                 return block->getIsUnderground();
 147         }
 148         catch(InvalidPositionException &e)
 149         {
 150                 return false;
 151         }
 152 }
 153
 154 bool Map::isValidPosition(v3s16 p)
 155 {
 156         v3s16 blockpos = getNodeBlockPos(p);
 157         MapBlock *block = getBlockNoCreate(blockpos);
 158         return (block != NULL);
 159 }
 160
 161 // Returns a CONTENT_IGNORE node if not found
 162 MapNode Map::getNodeNoEx(v3s16 p)
 163 {
 164         v3s16 blockpos = getNodeBlockPos(p);
 165         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 166         if(block == NULL)
 167                 return MapNode(CONTENT_IGNORE);
 168         v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 169         return block->getNodeNoCheck(relpos);
 170 }
 171
 172 // throws InvalidPositionException if not found
 173 MapNode Map::getNode(v3s16 p)
 174 {
 175         v3s16 blockpos = getNodeBlockPos(p);
 176         MapBlock *block = getBlockNoCreateNoEx(blockpos);
 177         if(block == NULL)
 178                 throw InvalidPositionException();
 179         v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 180         return block->getNodeNoCheck(relpos);
 181 }
 182
 183 // throws InvalidPositionException if not found
 184 void Map::setNode(v3s16 p, MapNode & n)
 185 {
 186         v3s16 blockpos = getNodeBlockPos(p);
 187         MapBlock *block = getBlockNoCreate(blockpos);
 188         v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
 189         block->setNodeNoCheck(relpos, n);
 190 }
 191
 192
 193 /*
 194         Goes recursively through the neighbours of the node.
 195
 196         Alters only transparent nodes.
 197
 198         If the lighting of the neighbour is lower than the lighting of
 199         the node was (before changing it to 0 at the step before), the
 200         lighting of the neighbour is set to 0 and then the same stuff
 201         repeats for the neighbour.
 202
 203         The ending nodes of the routine are stored in light_sources.
 204         This is useful when a light is removed. In such case, this
 205         routine can be called for the light node and then again for
 206         light_sources to re-light the area without the removed light.
 207
 208         values of from_nodes are lighting values.
 209 */
 210 void Map::unspreadLight(enum LightBank bank,
 211                 core::map<v3s16, u8> & from_nodes,
 212                 core::map<v3s16, bool> & light_sources,
 213                 core::map<v3s16, MapBlock*>  & modified_blocks)
 214 {
 215         v3s16 dirs[6] = {
 216                 v3s16(0,0,1), // back
 217                 v3s16(0,1,0), // top
 218                 v3s16(1,0,0), // right
 219                 v3s16(0,0,-1), // front
 220                 v3s16(0,-1,0), // bottom
 221                 v3s16(-1,0,0), // left
 222         };
 223
 224         if(from_nodes.size() == 0)
 225                 return;
 226
 227         u32 blockchangecount = 0;
 228
 229         core::map<v3s16, u8> unlighted_nodes;
 230         core::map<v3s16, u8>::Iterator j;
 231         j = from_nodes.getIterator();
 232
 233         /*
 234                 Initialize block cache
 235         */
 236         v3s16 blockpos_last;
 237         MapBlock *block = NULL;
 238         // Cache this a bit, too
 239         bool block_checked_in_modified = false;
 240
 241         for(; j.atEnd() == false; j++)
 242         {
 243                 v3s16 pos = j.getNode()->getKey();
 244                 v3s16 blockpos = getNodeBlockPos(pos);
 245
 246                 // Only fetch a new block if the block position has changed
 247                 try{
 248                         if(block == NULL || blockpos != blockpos_last){
 249                                 block = getBlockNoCreate(blockpos);
 250                                 blockpos_last = blockpos;
 251
 252                                 block_checked_in_modified = false;
 253                                 blockchangecount++;
 254                         }
 255                 }
 256                 catch(InvalidPositionException &e)
 257                 {
 258                         continue;
 259                 }
 260
 261                 if(block->isDummy())
 262                         continue;
 263
 264                 // Calculate relative position in block
 265                 v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
 266
 267                 // Get node straight from the block
 268                 MapNode n = block->getNode(relpos);
 269
 270                 u8 oldlight = j.getNode()->getValue();
 271
 272                 // Loop through 6 neighbors
 273                 for(u16 i=0; i<6; i++)
 274                 {
 275                         // Get the position of the neighbor node
 276                         v3s16 n2pos = pos + dirs[i];
 277
 278                         // Get the block where the node is located
 279                         v3s16 blockpos = getNodeBlockPos(n2pos);
 280
 281                         try
 282                         {
 283                                 // Only fetch a new block if the block position has changed
 284                                 try{
 285                                         if(block == NULL || blockpos != blockpos_last){
 286                                                 block = getBlockNoCreate(blockpos);
 287                                                 blockpos_last = blockpos;
 288
 289                                                 block_checked_in_modified = false;
 290                                                 blockchangecount++;
 291                                         }
 292                                 }
 293                                 catch(InvalidPositionException &e)
 294                                 {
 295                                         continue;
 296                                 }
 297
 298                                 // Calculate relative position in block
 299                                 v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
 300                                 // Get node straight from the block
 301                                 MapNode n2 = block->getNode(relpos);
 302
 303                                 bool changed = false;
 304
 305                                 //TODO: Optimize output by optimizing light_sources?
 306
 307                                 /*
 308                                         If the neighbor is dimmer than what was specified
 309                                         as oldlight (the light of the previous node)
 310                                 */
 311                                 if(n2.getLight(bank) < oldlight)
 312                                 {
 313                                         /*
 314                                                 And the neighbor is transparent and it has some light
 315                                         */
 316                                         if(n2.light_propagates() && n2.getLight(bank) != 0)
 317                                         {
 318                                                 /*
 319                                                         Set light to 0 and add to queue
 320                                                 */
 321
 322                                                 u8 current_light = n2.getLight(bank);
 323                                                 n2.setLight(bank, 0);
 324                                                 block->setNode(relpos, n2);
 325
 326                                                 unlighted_nodes.insert(n2pos, current_light);
 327                                                 changed = true;
 328
 329                                                 /*
 330                                                         Remove from light_sources if it is there
 331                                                         NOTE: This doesn't happen nearly at all
 332                                                 */
 333                                                 /*if(light_sources.find(n2pos))
 334                                                 {
 335                                                         std::cout<<"Removed from light_sources"<<std::endl;
 336                                                         light_sources.remove(n2pos);
 337                                                 }*/
 338                                         }
 339
 340                                         /*// DEBUG
 341                                         if(light_sources.find(n2pos) != NULL)
 342                                                 light_sources.remove(n2pos);*/
 343                                 }
 344                                 else{
 345                                         light_sources.insert(n2pos, true);
 346                                 }
 347
 348                                 // Add to modified_blocks
 349                                 if(changed == true && block_checked_in_modified == false)
 350                                 {
 351                                         // If the block is not found in modified_blocks, add.
 352                                         if(modified_blocks.find(blockpos) == NULL)
 353                                         {
 354                                                 modified_blocks.insert(blockpos, block);
 355                                         }
 356                                         block_checked_in_modified = true;
 357                                 }
 358                         }
 359                         catch(InvalidPositionException &e)
 360                         {
 361                                 continue;
 362                         }
 363                 }
 364         }
 365
 366         /*dstream<<"unspreadLight(): Changed block "
 367                         <<blockchangecount<<" times"
 368                         <<" for "<<from_nodes.size()<<" nodes"
 369                         <<std::endl;*/
 370
 371         if(unlighted_nodes.size() > 0)
 372                 unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
 373 }
 374
 375 /*
 376         A single-node wrapper of the above
 377 */
 378 void Map::unLightNeighbors(enum LightBank bank,
 379                 v3s16 pos, u8 lightwas,
 380                 core::map<v3s16, bool> & light_sources,
 381                 core::map<v3s16, MapBlock*>  & modified_blocks)
 382 {
 383         core::map<v3s16, u8> from_nodes;
 384         from_nodes.insert(pos, lightwas);
 385
 386         unspreadLight(bank, from_nodes, light_sources, modified_blocks);
 387 }
 388
 389 /*
 390         Lights neighbors of from_nodes, collects all them and then
 391         goes on recursively.
 392 */
 393 void Map::spreadLight(enum LightBank bank,
 394                 core::map<v3s16, bool> & from_nodes,
 395                 core::map<v3s16, MapBlock*> & modified_blocks)
 396 {
 397         const v3s16 dirs[6] = {
 398                 v3s16(0,0,1), // back
 399                 v3s16(0,1,0), // top
 400                 v3s16(1,0,0), // right
 401                 v3s16(0,0,-1), // front
 402                 v3s16(0,-1,0), // bottom
 403                 v3s16(-1,0,0), // left
 404         };
 405
 406         if(from_nodes.size() == 0)
 407                 return;
 408
 409         u32 blockchangecount = 0;
 410
 411         core::map<v3s16, bool> lighted_nodes;
 412         core::map<v3s16, bool>::Iterator j;
 413         j = from_nodes.getIterator();
 414
 415         /*
 416                 Initialize block cache
 417         */
 418         v3s16 blockpos_last;
 419         MapBlock *block = NULL;
 420         // Cache this a bit, too
 421         bool block_checked_in_modified = false;
 422
 423         for(; j.atEnd() == false; j++)
 424         //for(; j != from_nodes.end(); j++)
 425         {
 426                 v3s16 pos = j.getNode()->getKey();
 427                 //v3s16 pos = *j;
 428                 //dstream<<"pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
 429                 v3s16 blockpos = getNodeBlockPos(pos);
 430
 431                 // Only fetch a new block if the block position has changed
 432                 try{
 433                         if(block == NULL || blockpos != blockpos_last){
 434                                 block = getBlockNoCreate(blockpos);
 435                                 blockpos_last = blockpos;
 436
 437                                 block_checked_in_modified = false;
 438                                 blockchangecount++;
 439                         }
 440                 }
 441                 catch(InvalidPositionException &e)
 442                 {
 443                         continue;
 444                 }
 445
 446                 if(block->isDummy())
 447                         continue;
 448
 449                 // Calculate relative position in block
 450                 v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
 451
 452                 // Get node straight from the block
 453                 MapNode n = block->getNode(relpos);
 454
 455                 u8 oldlight = n.getLight(bank);
 456                 u8 newlight = diminish_light(oldlight);
 457
 458                 // Loop through 6 neighbors
 459                 for(u16 i=0; i<6; i++){
 460                         // Get the position of the neighbor node
 461                         v3s16 n2pos = pos + dirs[i];
 462
 463                         // Get the block where the node is located
 464                         v3s16 blockpos = getNodeBlockPos(n2pos);
 465
 466                         try
 467                         {
 468                                 // Only fetch a new block if the block position has changed
 469                                 try{
 470                                         if(block == NULL || blockpos != blockpos_last){
 471                                                 block = getBlockNoCreate(blockpos);
 472                                                 blockpos_last = blockpos;
 473
 474                                                 block_checked_in_modified = false;
 475                                                 blockchangecount++;
 476                                         }
 477                                 }
 478                                 catch(InvalidPositionException &e)
 479                                 {
 480                                         continue;
 481                                 }
 482
 483                                 // Calculate relative position in block
 484                                 v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
 485                                 // Get node straight from the block
 486                                 MapNode n2 = block->getNode(relpos);
 487
 488                                 bool changed = false;
 489                                 /*
 490                                         If the neighbor is brighter than the current node,
 491                                         add to list (it will light up this node on its turn)
 492                                 */
 493                                 if(n2.getLight(bank) > undiminish_light(oldlight))
 494                                 {
 495                                         lighted_nodes.insert(n2pos, true);
 496                                         //lighted_nodes.push_back(n2pos);
 497                                         changed = true;
 498                                 }
 499                                 /*
 500                                         If the neighbor is dimmer than how much light this node
 501                                         would spread on it, add to list
 502                                 */
 503                                 if(n2.getLight(bank) < newlight)
 504                                 {
 505                                         if(n2.light_propagates())
 506                                         {
 507                                                 n2.setLight(bank, newlight);
 508                                                 block->setNode(relpos, n2);
 509                                                 lighted_nodes.insert(n2pos, true);
 510                                                 //lighted_nodes.push_back(n2pos);
 511                                                 changed = true;
 512                                         }
 513                                 }
 514
 515                                 // Add to modified_blocks
 516                                 if(changed == true && block_checked_in_modified == false)
 517                                 {
 518                                         // If the block is not found in modified_blocks, add.
 519                                         if(modified_blocks.find(blockpos) == NULL)
 520                                         {
 521                                                 modified_blocks.insert(blockpos, block);
 522                                         }
 523                                         block_checked_in_modified = true;
 524                                 }
 525                         }
 526                         catch(InvalidPositionException &e)
 527                         {
 528                                 continue;
 529                         }
 530                 }
 531         }
 532
 533         /*dstream<<"spreadLight(): Changed block "
 534                         <<blockchangecount<<" times"
 535                         <<" for "<<from_nodes.size()<<" nodes"
 536                         <<std::endl;*/
 537
 538         if(lighted_nodes.size() > 0)
 539                 spreadLight(bank, lighted_nodes, modified_blocks);
 540 }
 541
 542 /*
 543         A single-node source variation of the above.
 544 */
 545 void Map::lightNeighbors(enum LightBank bank,
 546                 v3s16 pos,
 547                 core::map<v3s16, MapBlock*> & modified_blocks)
 548 {
 549         core::map<v3s16, bool> from_nodes;
 550         from_nodes.insert(pos, true);
 551         spreadLight(bank, from_nodes, modified_blocks);
 552 }
 553
 554 v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p)
 555 {
 556         v3s16 dirs[6] = {
 557                 v3s16(0,0,1), // back
 558                 v3s16(0,1,0), // top
 559                 v3s16(1,0,0), // right
 560                 v3s16(0,0,-1), // front
 561                 v3s16(0,-1,0), // bottom
 562                 v3s16(-1,0,0), // left
 563         };
 564
 565         u8 brightest_light = 0;
 566         v3s16 brightest_pos(0,0,0);
 567         bool found_something = false;
 568
 569         // Loop through 6 neighbors
 570         for(u16 i=0; i<6; i++){
 571                 // Get the position of the neighbor node
 572                 v3s16 n2pos = p + dirs[i];
 573                 MapNode n2;
 574                 try{
 575                         n2 = getNode(n2pos);
 576                 }
 577                 catch(InvalidPositionException &e)
 578                 {
 579                         continue;
 580                 }
 581                 if(n2.getLight(bank) > brightest_light || found_something == false){
 582                         brightest_light = n2.getLight(bank);
 583                         brightest_pos = n2pos;
 584                         found_something = true;
 585                 }
 586         }
 587
 588         if(found_something == false)
 589                 throw InvalidPositionException();
 590
 591         return brightest_pos;
 592 }
 593
 594 /*
 595         Propagates sunlight down from a node.
 596         Starting point gets sunlight.
 597
 598         Returns the lowest y value of where the sunlight went.
 599
 600         Mud is turned into grass in where the sunlight stops.
 601 */
 602 s16 Map::propagateSunlight(v3s16 start,
 603                 core::map<v3s16, MapBlock*> & modified_blocks)
 604 {
 605         s16 y = start.Y;
 606         for(; ; y--)
 607         {
 608                 v3s16 pos(start.X, y, start.Z);
 609
 610                 v3s16 blockpos = getNodeBlockPos(pos);
 611                 MapBlock *block;
 612                 try{
 613                         block = getBlockNoCreate(blockpos);
 614                 }
 615                 catch(InvalidPositionException &e)
 616                 {
 617                         break;
 618                 }
 619
 620                 v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE;
 621                 MapNode n = block->getNode(relpos);
 622
 623                 if(n.sunlight_propagates())
 624                 {
 625                         n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
 626                         block->setNode(relpos, n);
 627
 628                         modified_blocks.insert(blockpos, block);
 629                 }
 630                 else
 631                 {
 632                         /*// Turn mud into grass
 633                         if(n.d == CONTENT_MUD)
 634                         {
 635                                 n.d = CONTENT_GRASS;
 636                                 block->setNode(relpos, n);
 637                                 modified_blocks.insert(blockpos, block);
 638                         }*/
 639
 640                         // Sunlight goes no further
 641                         break;
 642                 }
 643         }
 644         return y + 1;
 645 }
 646
 647 void Map::updateLighting(enum LightBank bank,
 648                 core::map<v3s16, MapBlock*> & a_blocks,
 649                 core::map<v3s16, MapBlock*> & modified_blocks)
 650 {
 651         /*m_dout<<DTIME<<"Map::updateLighting(): "
 652                         <<a_blocks.size()<<" blocks."<<std::endl;*/
 653
 654         //TimeTaker timer("updateLighting");
 655
 656         // For debugging
 657         //bool debug=true;
 658         //u32 count_was = modified_blocks.size();
 659
 660         core::map<v3s16, MapBlock*> blocks_to_update;
 661
 662         core::map<v3s16, bool> light_sources;
 663
 664         core::map<v3s16, u8> unlight_from;
 665
 666         core::map<v3s16, MapBlock*>::Iterator i;
 667         i = a_blocks.getIterator();
 668         for(; i.atEnd() == false; i++)
 669         {
 670                 MapBlock *block = i.getNode()->getValue();
 671
 672                 for(;;)
 673                 {
 674                         // Don't bother with dummy blocks.
 675                         if(block->isDummy())
 676                                 break;
 677
 678                         v3s16 pos = block->getPos();
 679                         modified_blocks.insert(pos, block);
 680
 681                         blocks_to_update.insert(pos, block);
 682
 683                         /*
 684                                 Clear all light from block
 685                         */
 686                         for(s16 z=0; z<MAP_BLOCKSIZE; z++)
 687                         for(s16 x=0; x<MAP_BLOCKSIZE; x++)
 688                         for(s16 y=0; y<MAP_BLOCKSIZE; y++)
 689                         {
 690
 691                                 try{
 692                                         v3s16 p(x,y,z);
 693                                         MapNode n = block->getNode(v3s16(x,y,z));
 694                                         u8 oldlight = n.getLight(bank);
 695                                         n.setLight(bank, 0);
 696                                         block->setNode(v3s16(x,y,z), n);
 697
 698                                         // Collect borders for unlighting
 699                                         if(x==0 || x == MAP_BLOCKSIZE-1
 700                                         || y==0 || y == MAP_BLOCKSIZE-1
 701                                         || z==0 || z == MAP_BLOCKSIZE-1)
 702                                         {
 703                                                 v3s16 p_map = p + v3s16(
 704                                                                 MAP_BLOCKSIZE*pos.X,
 705                                                                 MAP_BLOCKSIZE*pos.Y,
 706                                                                 MAP_BLOCKSIZE*pos.Z);
 707                                                 unlight_from.insert(p_map, oldlight);
 708                                         }
 709                                 }
 710                                 catch(InvalidPositionException &e)
 711                                 {
 712                                         /*
 713                                                 This would happen when dealing with a
 714                                                 dummy block.
 715                                         */
 716                                         //assert(0);
 717                                         dstream<<"updateLighting(): InvalidPositionException"
 718                                                         <<std::endl;
 719                                 }
 720                         }
 721
 722                         if(bank == LIGHTBANK_DAY)
 723                         {
 724                                 bool bottom_valid = block->propagateSunlight(light_sources);
 725
 726                                 // If bottom is valid, we're done.
 727                                 if(bottom_valid)
 728                                         break;
 729                         }
 730                         else if(bank == LIGHTBANK_NIGHT)
 731                         {
 732                                 // For night lighting, sunlight is not propagated
 733                                 break;
 734                         }
 735                         else
 736                         {
 737                                 // Invalid lighting bank
 738                                 assert(0);
 739                         }
 740
 741                         /*dstream<<"Bottom for sunlight-propagated block ("
 742                                         <<pos.X<<","<<pos.Y<<","<<pos.Z<<") not valid"
 743                                         <<std::endl;*/
 744
 745                         // Bottom sunlight is not valid; get the block and loop to it
 746
 747                         pos.Y--;
 748                         try{
 749                                 block = getBlockNoCreate(pos);
 750                         }
 751                         catch(InvalidPositionException &e)
 752                         {
 753                                 assert(0);
 754                         }
 755
 756                 }
 757         }
 758
 759         /*
 760                 Enable this to disable proper lighting for speeding up map
 761                 generation for testing or whatever
 762         */
 763 #if 0
 764         //if(g_settings.get(""))
 765         {
 766                 core::map<v3s16, MapBlock*>::Iterator i;
 767                 i = blocks_to_update.getIterator();
 768                 for(; i.atEnd() == false; i++)
 769                 {
 770                         MapBlock *block = i.getNode()->getValue();
 771                         v3s16 p = block->getPos();
 772                         block->setLightingExpired(false);
 773                 }
 774                 return;
 775         }
 776 #endif
 777
 778 #if 0
 779         {
 780                 TimeTaker timer("unspreadLight");
 781                 unspreadLight(bank, unlight_from, light_sources, modified_blocks);
 782         }
 783
 784         if(debug)
 785         {
 786                 u32 diff = modified_blocks.size() - count_was;
 787                 count_was = modified_blocks.size();
 788                 dstream<<"unspreadLight modified "<<diff<<std::endl;
 789         }
 790
 791         {
 792                 TimeTaker timer("spreadLight");
 793                 spreadLight(bank, light_sources, modified_blocks);
 794         }
 795
 796         if(debug)
 797         {
 798                 u32 diff = modified_blocks.size() - count_was;
 799                 count_was = modified_blocks.size();
 800                 dstream<<"spreadLight modified "<<diff<<std::endl;
 801         }
 802 #endif
 803
 804         {
 805                 //MapVoxelManipulator vmanip(this);
 806
 807                 // Make a manual voxel manipulator and load all the blocks
 808                 // that touch the requested blocks
 809                 ManualMapVoxelManipulator vmanip(this);
 810                 core::map<v3s16, MapBlock*>::Iterator i;
 811                 i = blocks_to_update.getIterator();
 812                 for(; i.atEnd() == false; i++)
 813                 {
 814                         MapBlock *block = i.getNode()->getValue();
 815                         v3s16 p = block->getPos();
 816
 817                         // Add all surrounding blocks
 818                         vmanip.initialEmerge(p - v3s16(1,1,1), p + v3s16(1,1,1));
 819
 820                         /*
 821                                 Add all surrounding blocks that have up-to-date lighting
 822                                 NOTE: This doesn't quite do the job (not everything
 823                                           appropriate is lighted)
 824                         */
 825                         /*for(s16 z=-1; z<=1; z++)
 826                         for(s16 y=-1; y<=1; y++)
 827                         for(s16 x=-1; x<=1; x++)
 828                         {
 829                                 v3s16 p(x,y,z);
 830                                 MapBlock *block = getBlockNoCreateNoEx(p);
 831                                 if(block == NULL)
 832                                         continue;
 833                                 if(block->isDummy())
 834                                         continue;
 835                                 if(block->getLightingExpired())
 836                                         continue;
 837                                 vmanip.initialEmerge(p, p);
 838                         }*/
 839
 840                         // Lighting of block will be updated completely
 841                         block->setLightingExpired(false);
 842                 }
 843
 844                 {
 845                         //TimeTaker timer("unSpreadLight");
 846                         vmanip.unspreadLight(bank, unlight_from, light_sources);
 847                 }
 848                 {
 849                         //TimeTaker timer("spreadLight");
 850                         vmanip.spreadLight(bank, light_sources);
 851                 }
 852                 {
 853                         //TimeTaker timer("blitBack");
 854                         vmanip.blitBack(modified_blocks);
 855                 }
 856                 /*dstream<<"emerge_time="<<emerge_time<<std::endl;
 857                 emerge_time = 0;*/
 858         }
 859
 860         //m_dout<<"Done ("<<getTimestamp()<<")"<<std::endl;
 861 }
 862
 863 void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
 864                 core::map<v3s16, MapBlock*> & modified_blocks)
 865 {
 866         updateLighting(LIGHTBANK_DAY, a_blocks, modified_blocks);
 867         updateLighting(LIGHTBANK_NIGHT, a_blocks, modified_blocks);
 868
 869         /*
 870                 Update information about whether day and night light differ
 871         */
 872         for(core::map<v3s16, MapBlock*>::Iterator
 873                         i = modified_blocks.getIterator();
 874                         i.atEnd() == false; i++)
 875         {
 876                 MapBlock *block = i.getNode()->getValue();
 877                 block->updateDayNightDiff();
 878         }
 879 }
 880
 881 /*
 882 */
 883 void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 884                 core::map<v3s16, MapBlock*> &modified_blocks)
 885 {
 886         /*PrintInfo(m_dout);
 887         m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
 888                         <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
 889
 890         /*
 891                 From this node to nodes underneath:
 892                 If lighting is sunlight (1.0), unlight neighbours and
 893                 set lighting to 0.
 894                 Else discontinue.
 895         */
 896
 897         v3s16 toppos = p + v3s16(0,1,0);
 898         v3s16 bottompos = p + v3s16(0,-1,0);
 899
 900         bool node_under_sunlight = true;
 901         core::map<v3s16, bool> light_sources;
 902
 903         /*
 904                 If there is a node at top and it doesn't have sunlight,
 905                 there has not been any sunlight going down.
 906
 907                 Otherwise there probably is.
 908         */
 909         try{
 910                 MapNode topnode = getNode(toppos);
 911
 912                 if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
 913                         node_under_sunlight = false;
 914         }
 915         catch(InvalidPositionException &e)
 916         {
 917         }
 918
 919 #if 0
 920         /*
 921                 If the new node is solid and there is grass below, change it to mud
 922         */
 923         if(content_features(n.d).walkable == true)
 924         {
 925                 try{
 926                         MapNode bottomnode = getNode(bottompos);
 927
 928                         if(bottomnode.d == CONTENT_GRASS
 929                                         || bottomnode.d == CONTENT_GRASS_FOOTSTEPS)
 930                         {
 931                                 bottomnode.d = CONTENT_MUD;
 932                                 setNode(bottompos, bottomnode);
 933                         }
 934                 }
 935                 catch(InvalidPositionException &e)
 936                 {
 937                 }
 938         }
 939 #endif
 940
 941 #if 0
 942         /*
 943                 If the new node is mud and it is under sunlight, change it
 944                 to grass
 945         */
 946         if(n.d == CONTENT_MUD && node_under_sunlight)
 947         {
 948                 n.d = CONTENT_GRASS;
 949         }
 950 #endif
 951
 952         /*
 953                 Remove all light that has come out of this node
 954         */
 955
 956         enum LightBank banks[] =
 957         {
 958                 LIGHTBANK_DAY,
 959                 LIGHTBANK_NIGHT
 960         };
 961         for(s32 i=0; i<2; i++)
 962         {
 963                 enum LightBank bank = banks[i];
 964
 965                 u8 lightwas = getNode(p).getLight(bank);
 966
 967                 // Add the block of the added node to modified_blocks
 968                 v3s16 blockpos = getNodeBlockPos(p);
 969                 MapBlock * block = getBlockNoCreate(blockpos);
 970                 assert(block != NULL);
 971                 modified_blocks.insert(blockpos, block);
 972
 973                 assert(isValidPosition(p));
 974
 975                 // Unlight neighbours of node.
 976                 // This means setting light of all consequent dimmer nodes
 977                 // to 0.
 978                 // This also collects the nodes at the border which will spread
 979                 // light again into this.
 980                 unLightNeighbors(bank, p, lightwas, light_sources, modified_blocks);
 981
 982                 n.setLight(bank, 0);
 983         }
 984
 985         /*
 986                 If node lets sunlight through and is under sunlight, it has
 987                 sunlight too.
 988         */
 989         if(node_under_sunlight && content_features(n.d).sunlight_propagates)
 990         {
 991                 n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
 992         }
 993
 994         /*
 995                 Set the node on the map
 996         */
 997
 998         setNode(p, n);
 999
1000         /*
1001                 Add intial metadata
1002         */
1003
1004         NodeMetadata *meta_proto = content_features(n.d).initial_metadata;
1005         if(meta_proto)
1006         {
1007                 NodeMetadata *meta = meta_proto->clone();
1008                 setNodeMetadata(p, meta);
1009         }
1010
1011         /*
1012                 If node is under sunlight and doesn't let sunlight through,
1013                 take all sunlighted nodes under it and clear light from them
1014                 and from where the light has been spread.
1015                 TODO: This could be optimized by mass-unlighting instead
1016                           of looping
1017         */
1018         if(node_under_sunlight && !content_features(n.d).sunlight_propagates)
1019         {
1020                 s16 y = p.Y - 1;
1021                 for(;; y--){
1022                         //m_dout<<DTIME<<"y="<<y<<std::endl;
1023                         v3s16 n2pos(p.X, y, p.Z);
1024
1025                         MapNode n2;
1026                         try{
1027                                 n2 = getNode(n2pos);
1028                         }
1029                         catch(InvalidPositionException &e)
1030                         {
1031                                 break;
1032                         }
1033
1034                         if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN)
1035                         {
1036                                 unLightNeighbors(LIGHTBANK_DAY,
1037                                                 n2pos, n2.getLight(LIGHTBANK_DAY),
1038                                                 light_sources, modified_blocks);
1039                                 n2.setLight(LIGHTBANK_DAY, 0);
1040                                 setNode(n2pos, n2);
1041                         }
1042                         else
1043                                 break;
1044                 }
1045         }
1046
1047         for(s32 i=0; i<2; i++)
1048         {
1049                 enum LightBank bank = banks[i];
1050
1051                 /*
1052                         Spread light from all nodes that might be capable of doing so
1053                 */
1054                 spreadLight(bank, light_sources, modified_blocks);
1055         }
1056
1057         /*
1058                 Update information about whether day and night light differ
1059         */
1060         for(core::map<v3s16, MapBlock*>::Iterator
1061                         i = modified_blocks.getIterator();
1062                         i.atEnd() == false; i++)
1063         {
1064                 MapBlock *block = i.getNode()->getValue();
1065                 block->updateDayNightDiff();
1066         }
1067
1068         /*
1069                 Add neighboring liquid nodes and the node itself if it is
1070                 liquid (=water node was added) to transform queue.
1071         */
1072         v3s16 dirs[7] = {
1073                 v3s16(0,0,0), // self
1074                 v3s16(0,0,1), // back
1075                 v3s16(0,1,0), // top
1076                 v3s16(1,0,0), // right
1077                 v3s16(0,0,-1), // front
1078                 v3s16(0,-1,0), // bottom
1079                 v3s16(-1,0,0), // left
1080         };
1081         for(u16 i=0; i<7; i++)
1082         {
1083                 try
1084                 {
1085
1086                 v3s16 p2 = p + dirs[i];
1087
1088                 MapNode n2 = getNode(p2);
1089                 if(content_liquid(n2.d) || n2.d == CONTENT_AIR)
1090                 {
1091                         m_transforming_liquid.push_back(p2);
1092                 }
1093
1094                 }catch(InvalidPositionException &e)
1095                 {
1096                 }
1097         }
1098 }
1099
1100 /*
1101 */
1102 void Map::removeNodeAndUpdate(v3s16 p,
1103                 core::map<v3s16, MapBlock*> &modified_blocks)
1104 {
1105         /*PrintInfo(m_dout);
1106         m_dout<<DTIME<<"Map::removeNodeAndUpdate(): p=("
1107                         <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
1108
1109         bool node_under_sunlight = true;
1110
1111         v3s16 toppos = p + v3s16(0,1,0);
1112
1113         // Node will be replaced with this
1114         u8 replace_material = CONTENT_AIR;
1115
1116         /*
1117                 If there is a node at top and it doesn't have sunlight,
1118                 there will be no sunlight going down.
1119         */
1120         try{
1121                 MapNode topnode = getNode(toppos);
1122
1123                 if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
1124                         node_under_sunlight = false;
1125         }
1126         catch(InvalidPositionException &e)
1127         {
1128         }
1129
1130         core::map<v3s16, bool> light_sources;
1131
1132         enum LightBank banks[] =
1133         {
1134                 LIGHTBANK_DAY,
1135                 LIGHTBANK_NIGHT
1136         };
1137         for(s32 i=0; i<2; i++)
1138         {
1139                 enum LightBank bank = banks[i];
1140
1141                 /*
1142                         Unlight neighbors (in case the node is a light source)
1143                 */
1144                 unLightNeighbors(bank, p,
1145                                 getNode(p).getLight(bank),
1146                                 light_sources, modified_blocks);
1147         }
1148
1149         /*
1150                 Remove node metadata
1151         */
1152
1153         removeNodeMetadata(p);
1154
1155         /*
1156                 Remove the node.
1157                 This also clears the lighting.
1158         */
1159
1160         MapNode n;
1161         n.d = replace_material;
1162         setNode(p, n);
1163
1164         for(s32 i=0; i<2; i++)
1165         {
1166                 enum LightBank bank = banks[i];
1167
1168                 /*
1169                         Recalculate lighting
1170                 */
1171                 spreadLight(bank, light_sources, modified_blocks);
1172         }
1173
1174         // Add the block of the removed node to modified_blocks
1175         v3s16 blockpos = getNodeBlockPos(p);
1176         MapBlock * block = getBlockNoCreate(blockpos);
1177         assert(block != NULL);
1178         modified_blocks.insert(blockpos, block);
1179
1180         /*
1181                 If the removed node was under sunlight, propagate the
1182                 sunlight down from it and then light all neighbors
1183                 of the propagated blocks.
1184         */
1185         if(node_under_sunlight)
1186         {
1187                 s16 ybottom = propagateSunlight(p, modified_blocks);
1188                 /*m_dout<<DTIME<<"Node was under sunlight. "
1189                                 "Propagating sunlight";
1190                 m_dout<<DTIME<<" -> ybottom="<<ybottom<<std::endl;*/
1191                 s16 y = p.Y;
1192                 for(; y >= ybottom; y--)
1193                 {
1194                         v3s16 p2(p.X, y, p.Z);
1195                         /*m_dout<<DTIME<<"lighting neighbors of node ("
1196                                         <<p2.X<<","<<p2.Y<<","<<p2.Z<<")"
1197                                         <<std::endl;*/
1198                         lightNeighbors(LIGHTBANK_DAY, p2, modified_blocks);
1199                 }
1200         }
1201         else
1202         {
1203                 // Set the lighting of this node to 0
1204                 // TODO: Is this needed? Lighting is cleared up there already.
1205                 try{
1206                         MapNode n = getNode(p);
1207                         n.setLight(LIGHTBANK_DAY, 0);
1208                         setNode(p, n);
1209                 }
1210                 catch(InvalidPositionException &e)
1211                 {
1212                         assert(0);
1213                 }
1214         }
1215
1216         for(s32 i=0; i<2; i++)
1217         {
1218                 enum LightBank bank = banks[i];
1219
1220                 // Get the brightest neighbour node and propagate light from it
1221                 v3s16 n2p = getBrightestNeighbour(bank, p);
1222                 try{
1223                         MapNode n2 = getNode(n2p);
1224                         lightNeighbors(bank, n2p, modified_blocks);
1225                 }
1226                 catch(InvalidPositionException &e)
1227                 {
1228                 }
1229         }
1230
1231         /*
1232                 Update information about whether day and night light differ
1233         */
1234         for(core::map<v3s16, MapBlock*>::Iterator
1235                         i = modified_blocks.getIterator();
1236                         i.atEnd() == false; i++)
1237         {
1238                 MapBlock *block = i.getNode()->getValue();
1239                 block->updateDayNightDiff();
1240         }
1241
1242         /*
1243                 Add neighboring liquid nodes and this node to transform queue.
1244                 (it's vital for the node itself to get updated last.)
1245         */
1246         v3s16 dirs[7] = {
1247                 v3s16(0,0,1), // back
1248                 v3s16(0,1,0), // top
1249                 v3s16(1,0,0), // right
1250                 v3s16(0,0,-1), // front
1251                 v3s16(0,-1,0), // bottom
1252                 v3s16(-1,0,0), // left
1253                 v3s16(0,0,0), // self
1254         };
1255         for(u16 i=0; i<7; i++)
1256         {
1257                 try
1258                 {
1259
1260                 v3s16 p2 = p + dirs[i];
1261
1262                 MapNode n2 = getNode(p2);
1263                 if(content_liquid(n2.d) || n2.d == CONTENT_AIR)
1264                 {
1265                         m_transforming_liquid.push_back(p2);
1266                 }
1267
1268                 }catch(InvalidPositionException &e)
1269                 {
1270                 }
1271         }
1272 }
1273
1274 bool Map::addNodeWithEvent(v3s16 p, MapNode n)
1275 {
1276         MapEditEvent event;
1277         event.type = MEET_ADDNODE;
1278         event.p = p;
1279         event.n = n;
1280
1281         bool succeeded = true;
1282         try{
1283                 core::map<v3s16, MapBlock*> modified_blocks;
1284                 addNodeAndUpdate(p, n, modified_blocks);
1285
1286                 // Copy modified_blocks to event
1287                 for(core::map<v3s16, MapBlock*>::Iterator
1288                                 i = modified_blocks.getIterator();
1289                                 i.atEnd()==false; i++)
1290                 {
1291                         event.modified_blocks.insert(i.getNode()->getKey(), false);
1292                 }
1293         }
1294         catch(InvalidPositionException &e){
1295                 succeeded = false;
1296         }
1297
1298         dispatchEvent(&event);
1299
1300         return succeeded;
1301 }
1302
1303 bool Map::removeNodeWithEvent(v3s16 p)
1304 {
1305         MapEditEvent event;
1306         event.type = MEET_REMOVENODE;
1307         event.p = p;
1308
1309         bool succeeded = true;
1310         try{
1311                 core::map<v3s16, MapBlock*> modified_blocks;
1312                 removeNodeAndUpdate(p, modified_blocks);
1313
1314                 // Copy modified_blocks to event
1315                 for(core::map<v3s16, MapBlock*>::Iterator
1316                                 i = modified_blocks.getIterator();
1317                                 i.atEnd()==false; i++)
1318                 {
1319                         event.modified_blocks.insert(i.getNode()->getKey(), false);
1320                 }
1321         }
1322         catch(InvalidPositionException &e){
1323                 succeeded = false;
1324         }
1325
1326         dispatchEvent(&event);
1327
1328         return succeeded;
1329 }
1330
1331 bool Map::dayNightDiffed(v3s16 blockpos)
1332 {
1333         try{
1334                 v3s16 p = blockpos + v3s16(0,0,0);
1335                 MapBlock *b = getBlockNoCreate(p);
1336                 if(b->dayNightDiffed())
1337                         return true;
1338         }
1339         catch(InvalidPositionException &e){}
1340         // Leading edges
1341         try{
1342                 v3s16 p = blockpos + v3s16(-1,0,0);
1343                 MapBlock *b = getBlockNoCreate(p);
1344                 if(b->dayNightDiffed())
1345                         return true;
1346         }
1347         catch(InvalidPositionException &e){}
1348         try{
1349                 v3s16 p = blockpos + v3s16(0,-1,0);
1350                 MapBlock *b = getBlockNoCreate(p);
1351                 if(b->dayNightDiffed())
1352                         return true;
1353         }
1354         catch(InvalidPositionException &e){}
1355         try{
1356                 v3s16 p = blockpos + v3s16(0,0,-1);
1357                 MapBlock *b = getBlockNoCreate(p);
1358                 if(b->dayNightDiffed())
1359                         return true;
1360         }
1361         catch(InvalidPositionException &e){}
1362         // Trailing edges
1363         try{
1364                 v3s16 p = blockpos + v3s16(1,0,0);
1365                 MapBlock *b = getBlockNoCreate(p);
1366                 if(b->dayNightDiffed())
1367                         return true;
1368         }
1369         catch(InvalidPositionException &e){}
1370         try{
1371                 v3s16 p = blockpos + v3s16(0,1,0);
1372                 MapBlock *b = getBlockNoCreate(p);
1373                 if(b->dayNightDiffed())
1374                         return true;
1375         }
1376         catch(InvalidPositionException &e){}
1377         try{
1378                 v3s16 p = blockpos + v3s16(0,0,1);
1379                 MapBlock *b = getBlockNoCreate(p);
1380                 if(b->dayNightDiffed())
1381                         return true;
1382         }
1383         catch(InvalidPositionException &e){}
1384
1385         return false;
1386 }
1387
1388 /*
1389         Updates usage timers
1390 */
1391 void Map::timerUpdate(float dtime, float unload_timeout,
1392                 core::list<v3s16> *unloaded_blocks)
1393 {
1394         bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
1395
1396         core::list<v2s16> sector_deletion_queue;
1397         u32 deleted_blocks_count = 0;
1398         u32 saved_blocks_count = 0;
1399
1400         core::map<v2s16, MapSector*>::Iterator si;
1401
1402         si = m_sectors.getIterator();
1403         for(; si.atEnd() == false; si++)
1404         {
1405                 MapSector *sector = si.getNode()->getValue();
1406
1407                 bool all_blocks_deleted = true;
1408
1409                 core::list<MapBlock*> blocks;
1410                 sector->getBlocks(blocks);
1411                 for(core::list<MapBlock*>::Iterator i = blocks.begin();
1412                                 i != blocks.end(); i++)
1413                 {
1414                         MapBlock *block = (*i);
1415
1416                         block->incrementUsageTimer(dtime);
1417
1418                         if(block->getUsageTimer() > unload_timeout)
1419                         {
1420                                 v3s16 p = block->getPos();
1421
1422                                 // Save if modified
1423                                 if(block->getModified() != MOD_STATE_CLEAN
1424                                                 && save_before_unloading)
1425                                 {
1426                                         saveBlock(block);
1427                                         saved_blocks_count++;
1428                                 }
1429
1430                                 // Delete from memory
1431                                 sector->deleteBlock(block);
1432
1433                                 if(unloaded_blocks)
1434                                         unloaded_blocks->push_back(p);
1435
1436                                 deleted_blocks_count++;
1437                         }
1438                         else
1439                         {
1440                                 all_blocks_deleted = false;
1441                         }
1442                 }
1443
1444                 if(all_blocks_deleted)
1445                 {
1446                         sector_deletion_queue.push_back(si.getNode()->getKey());
1447                 }
1448         }
1449
1450         // Finally delete the empty sectors
1451         deleteSectors(sector_deletion_queue);
1452
1453         if(deleted_blocks_count != 0)
1454         {
1455                 PrintInfo(dstream); // ServerMap/ClientMap:
1456                 dstream<<"Unloaded "<<deleted_blocks_count
1457                                 <<" blocks from memory";
1458                 if(save_before_unloading)
1459                         dstream<<", of which "<<saved_blocks_count<<" were written";
1460                 dstream<<"."<<std::endl;
1461         }
1462 }
1463
1464 void Map::deleteSectors(core::list<v2s16> &list)
1465 {
1466         core::list<v2s16>::Iterator j;
1467         for(j=list.begin(); j!=list.end(); j++)
1468         {
1469                 MapSector *sector = m_sectors[*j];
1470                 // If sector is in sector cache, remove it from there
1471                 if(m_sector_cache == sector)
1472                         m_sector_cache = NULL;
1473                 // Remove from map and delete
1474                 m_sectors.remove(*j);
1475                 delete sector;
1476         }
1477 }
1478
1479 #if 0
1480 void Map::unloadUnusedData(float timeout,
1481                 core::list<v3s16> *deleted_blocks)
1482 {
1483         core::list<v2s16> sector_deletion_queue;
1484         u32 deleted_blocks_count = 0;
1485         u32 saved_blocks_count = 0;
1486
1487         core::map<v2s16, MapSector*>::Iterator si = m_sectors.getIterator();
1488         for(; si.atEnd() == false; si++)
1489         {
1490                 MapSector *sector = si.getNode()->getValue();
1491
1492                 bool all_blocks_deleted = true;
1493
1494                 core::list<MapBlock*> blocks;
1495                 sector->getBlocks(blocks);
1496                 for(core::list<MapBlock*>::Iterator i = blocks.begin();
1497                                 i != blocks.end(); i++)
1498                 {
1499                         MapBlock *block = (*i);
1500
1501                         if(block->getUsageTimer() > timeout)
1502                         {
1503                                 // Save if modified
1504                                 if(block->getModified() != MOD_STATE_CLEAN)
1505                                 {
1506                                         saveBlock(block);
1507                                         saved_blocks_count++;
1508                                 }
1509                                 // Delete from memory
1510                                 sector->deleteBlock(block);
1511                                 deleted_blocks_count++;
1512                         }
1513                         else
1514                         {
1515                                 all_blocks_deleted = false;
1516                         }
1517                 }
1518
1519                 if(all_blocks_deleted)
1520                 {
1521                         sector_deletion_queue.push_back(si.getNode()->getKey());
1522                 }
1523         }
1524
1525         deleteSectors(sector_deletion_queue);
1526
1527         dstream<<"Map: Unloaded "<<deleted_blocks_count<<" blocks from memory"
1528                         <<", of which "<<saved_blocks_count<<" were wr."
1529                         <<std::endl;
1530
1531         //return sector_deletion_queue.getSize();
1532         //return deleted_blocks_count;
1533 }
1534 #endif
1535
1536 void Map::PrintInfo(std::ostream &out)
1537 {
1538         out<<"Map: ";
1539 }
1540
1541 #define WATER_DROP_BOOST 4
1542
1543 enum NeighborType {
1544         NEIGHBOR_UPPER,
1545         NEIGHBOR_SAME_LEVEL,
1546         NEIGHBOR_LOWER
1547 };
1548 struct NodeNeighbor {
1549         MapNode n;
1550         NeighborType t;
1551         v3s16 p;
1552 };
1553
1554 void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
1555 {
1556         DSTACK(__FUNCTION_NAME);
1557         //TimeTaker timer("transformLiquids()");
1558
1559         u32 loopcount = 0;
1560         u32 initial_size = m_transforming_liquid.size();
1561
1562         /*if(initial_size != 0)
1563                 dstream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
1564
1565         while(m_transforming_liquid.size() != 0)
1566         {
1567                 /*
1568                         Get a queued transforming liquid node
1569                 */
1570                 v3s16 p0 = m_transforming_liquid.pop_front();
1571
1572                 MapNode n0 = getNodeNoEx(p0);
1573
1574                 /*
1575                         Collect information about current node
1576                  */
1577                 s8 liquid_level = -1;
1578                 u8 liquid_kind = CONTENT_IGNORE;
1579                 LiquidType liquid_type = content_features(n0.d).liquid_type;
1580                 switch (liquid_type) {
1581                         case LIQUID_SOURCE:
1582                                 liquid_level = 8;
1583                                 liquid_kind = content_features(n0.d).liquid_alternative_flowing;
1584                                 break;
1585                         case LIQUID_FLOWING:
1586                                 liquid_level = (n0.param2 & LIQUID_LEVEL_MASK);
1587                                 liquid_kind = n0.d;
1588                                 break;
1589                         case LIQUID_NONE:
1590                                 // if this is an air node, it *could* be transformed into a liquid. otherwise,
1591                                 // continue with the next node.
1592                                 if (n0.d != CONTENT_AIR)
1593                                         continue;
1594                                 liquid_kind = CONTENT_AIR;
1595                                 break;
1596                 }
1597
1598                 /*
1599                         Collect information about the environment
1600                  */
1601                 v3s16 dirs[6] = {
1602                         v3s16( 0, 1, 0), // top
1603                         v3s16( 0,-1, 0), // bottom
1604                         v3s16( 1, 0, 0), // right
1605                         v3s16(-1, 0, 0), // left
1606                         v3s16( 0, 0, 1), // back
1607                         v3s16( 0, 0,-1), // front
1608                 };
1609                 NodeNeighbor sources[6]; // surrounding sources
1610                 int num_sources = 0;
1611                 NodeNeighbor flows[6]; // surrounding flowing liquid nodes
1612                 int num_flows = 0;
1613                 NodeNeighbor airs[6]; // surrounding air
1614                 int num_airs = 0;
1615                 NodeNeighbor neutrals[6]; // nodes that are solid or another kind of liquid
1616                 int num_neutrals = 0;
1617                 bool flowing_down = false;
1618                 for (u16 i = 0; i < 6; i++) {
1619                         NeighborType nt = NEIGHBOR_SAME_LEVEL;
1620                         switch (i) {
1621                                 case 0:
1622                                         nt = NEIGHBOR_UPPER;
1623                                         break;
1624                                 case 1:
1625                                         nt = NEIGHBOR_LOWER;
1626                                         break;
1627                         }
1628                         v3s16 npos = p0 + dirs[i];
1629                         NodeNeighbor nb = {getNodeNoEx(npos), nt, npos};
1630                         switch (content_features(nb.n.d).liquid_type) {
1631                                 case LIQUID_NONE:
1632                                         if (nb.n.d == CONTENT_AIR) {
1633                                                 airs[num_airs++] = nb;
1634                                                 // if the current node happens to be a flowing node, it will start to flow down here.
1635                                                 if (nb.t == NEIGHBOR_LOWER)
1636                                                         flowing_down = true;
1637                                         } else {
1638                                                 neutrals[num_neutrals++] = nb;
1639                                         }
1640                                         break;
1641                                 case LIQUID_SOURCE:
1642                                         // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
1643                                         if (liquid_kind == CONTENT_AIR)
1644                                                 liquid_kind = content_features(nb.n.d).liquid_alternative_flowing;
1645                                         if (content_features(nb.n.d).liquid_alternative_flowing !=liquid_kind) {
1646                                                 neutrals[num_neutrals++] = nb;
1647                                         } else {
1648                                                 sources[num_sources++] = nb;
1649                                         }
1650                                         break;
1651                                 case LIQUID_FLOWING:
1652                                         // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
1653                                         if (liquid_kind == CONTENT_AIR)
1654                                                 liquid_kind = content_features(nb.n.d).liquid_alternative_flowing;
1655                                         if (content_features(nb.n.d).liquid_alternative_flowing != liquid_kind) {
1656                                                 neutrals[num_neutrals++] = nb;
1657                                         } else {
1658                                                 flows[num_flows++] = nb;
1659                                                 if (nb.t == NEIGHBOR_LOWER)
1660                                                         flowing_down = true;
1661                                         }
1662                                         break;
1663                         }
1664                 }
1665
1666                 /*
1667                         decide on the type (and possibly level) of the current node
1668                  */
1669                 u8 new_node_content;
1670                 s8 new_node_level = -1;
1671                 if (num_sources >= 2 || liquid_type == LIQUID_SOURCE) {
1672                         // liquid_kind will be set to either the flowing alternative of the node (if it's a liquid)
1673                         // or the flowing alternative of the first of the surrounding sources (if it's air), so
1674                         // it's perfectly safe to use liquid_kind here to determine the new node content.
1675                         new_node_content = content_features(liquid_kind).liquid_alternative_source;
1676                 } else if (num_sources == 1 && sources[0].t != NEIGHBOR_LOWER) {
1677                         // liquid_kind is set properly, see above
1678                         new_node_content = liquid_kind;
1679                         new_node_level = 7;
1680                 } else {
1681                         // no surrounding sources, so get the maximum level that can flow into this node
1682                         for (u16 i = 0; i < num_flows; i++) {
1683                                 u8 nb_liquid_level = (flows[i].n.param2 & LIQUID_LEVEL_MASK);
1684                                 switch (flows[i].t) {
1685                                         case NEIGHBOR_UPPER:
1686                                                 if (nb_liquid_level + WATER_DROP_BOOST > new_node_level) {
1687                                                         new_node_level = 7;
1688                                                         if (nb_liquid_level + WATER_DROP_BOOST < 7)
1689                                                                 new_node_level = nb_liquid_level + WATER_DROP_BOOST;
1690                                                 }
1691                                                 break;
1692                                         case NEIGHBOR_LOWER:
1693                                                 break;
1694                                         case NEIGHBOR_SAME_LEVEL:
1695                                                 if ((flows[i].n.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK &&
1696                                                         nb_liquid_level > 0 && nb_liquid_level - 1 > new_node_level) {
1697                                                         new_node_level = nb_liquid_level - 1;
1698                                                 }
1699                                                 break;
1700                                 }
1701                         }
1702                         // don't flow as far in open terrain - if there isn't at least one adjacent solid block,
1703                         // substract another unit from the resulting water level.
1704                         if (!flowing_down && new_node_level >= 1) {
1705                                 bool at_wall = false;
1706                                 for (u16 i = 0; i < num_neutrals; i++) {
1707                                         if (neutrals[i].t == NEIGHBOR_SAME_LEVEL) {
1708                                                 at_wall = true;
1709                                                 break;
1710                                         }
1711                                 }
1712                                 if (!at_wall)
1713                                         new_node_level -= 1;
1714                         }
1715
1716                         if (new_node_level >= 0)
1717                                 new_node_content = liquid_kind;
1718                         else
1719                                 new_node_content = CONTENT_AIR;
1720                 }
1721
1722                 /*
1723                         check if anything has changed. if not, just continue with the next node.
1724                  */
1725                 if (new_node_content == n0.d && (content_features(n0.d).liquid_type != LIQUID_FLOWING ||
1726                                                                                  ((n0.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level &&
1727                                                                                  ((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK)
1728                                                                                  == flowing_down)))
1729                         continue;
1730
1731
1732                 /*
1733                         update the current node
1734                  */
1735                 bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK));
1736                 n0.d = new_node_content;
1737                 if (content_features(n0.d).liquid_type == LIQUID_FLOWING) {
1738                         // set level to last 3 bits, flowing down bit to 4th bit
1739                         n0.param2 = (flowing_down ? LIQUID_FLOW_DOWN_MASK : 0x00) | (new_node_level & LIQUID_LEVEL_MASK);
1740                 } else {
1741                         n0.param2 = 0;
1742                 }
1743                 setNode(p0, n0);
1744                 v3s16 blockpos = getNodeBlockPos(p0);
1745                 MapBlock *block = getBlockNoCreateNoEx(blockpos);
1746                 if(block != NULL)
1747                         modified_blocks.insert(blockpos, block);
1748
1749                 /*
1750                         enqueue neighbors for update if neccessary
1751                  */
1752                 switch (content_features(n0.d).liquid_type) {
1753                         case LIQUID_SOURCE:
1754                                 // make sure source flows into all neighboring nodes
1755                                 for (u16 i = 0; i < num_flows; i++)
1756                                         if (flows[i].t != NEIGHBOR_UPPER)
1757                                                 m_transforming_liquid.push_back(flows[i].p);
1758                                 for (u16 i = 0; i < num_airs; i++)
1759                                         if (airs[i].t != NEIGHBOR_UPPER)
1760                                                 m_transforming_liquid.push_back(airs[i].p);
1761                                 break;
1762                         case LIQUID_NONE:
1763                                 // this flow has turned to air; neighboring flows might need to do the same
1764                                 for (u16 i = 0; i < num_flows; i++)
1765                                         m_transforming_liquid.push_back(flows[i].p);
1766                                 break;
1767                         case LIQUID_FLOWING:
1768                                 for (u16 i = 0; i < num_flows; i++) {
1769                                         u8 flow_level = (flows[i].n.param2 & LIQUID_LEVEL_MASK);
1770                                         // liquid_level is still the ORIGINAL level of this node.
1771                                         if (flows[i].t != NEIGHBOR_UPPER && ((flow_level < liquid_level || flow_level < new_node_level) ||
1772                                                 flow_down_enabled))
1773                                                 m_transforming_liquid.push_back(flows[i].p);
1774                                 }
1775                                 for (u16 i = 0; i < num_airs; i++) {
1776                                         if (airs[i].t != NEIGHBOR_UPPER && (airs[i].t == NEIGHBOR_LOWER || new_node_level > 0))
1777                                                 m_transforming_liquid.push_back(airs[i].p);
1778                                 }
1779                                 break;
1780                 }
1781
1782                 loopcount++;
1783                 //if(loopcount >= 100000)
1784                 if(loopcount >= initial_size * 10) {
1785                         break;
1786                 }
1787         }
1788         //dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
1789 }
1790
1791 NodeMetadata* Map::getNodeMetadata(v3s16 p)
1792 {
1793         v3s16 blockpos = getNodeBlockPos(p);
1794         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
1795         MapBlock *block = getBlockNoCreateNoEx(blockpos);
1796         if(block == NULL)
1797         {
1798                 dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
1799                                 <<std::endl;
1800                 return NULL;
1801         }
1802         NodeMetadata *meta = block->m_node_metadata.get(p_rel);
1803         return meta;
1804 }
1805
1806 void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
1807 {
1808         v3s16 blockpos = getNodeBlockPos(p);
1809         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
1810         MapBlock *block = getBlockNoCreateNoEx(blockpos);
1811         if(block == NULL)
1812         {
1813                 dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
1814                                 <<std::endl;
1815                 return;
1816         }
1817         block->m_node_metadata.set(p_rel, meta);
1818 }
1819
1820 void Map::removeNodeMetadata(v3s16 p)
1821 {
1822         v3s16 blockpos = getNodeBlockPos(p);
1823         v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
1824         MapBlock *block = getBlockNoCreateNoEx(blockpos);
1825         if(block == NULL)
1826         {
1827                 dstream<<"WARNING: Map::removeNodeMetadata(): Block not found"
1828                                 <<std::endl;
1829                 return;
1830         }
1831         block->m_node_metadata.remove(p_rel);
1832 }
1833
1834 void Map::nodeMetadataStep(float dtime,
1835                 core::map<v3s16, MapBlock*> &changed_blocks)
1836 {
1837         /*
1838                 NOTE:
1839                 Currently there is no way to ensure that all the necessary
1840                 blocks are loaded when this is run. (They might get unloaded)
1841                 NOTE: ^- Actually, that might not be so. In a quick test it
1842                 reloaded a block with a furnace when I walked back to it from
1843                 a distance.
1844         */
1845         core::map<v2s16, MapSector*>::Iterator si;
1846         si = m_sectors.getIterator();
1847         for(; si.atEnd() == false; si++)
1848         {
1849                 MapSector *sector = si.getNode()->getValue();
1850                 core::list< MapBlock * > sectorblocks;
1851                 sector->getBlocks(sectorblocks);
1852                 core::list< MapBlock * >::Iterator i;
1853                 for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
1854                 {
1855                         MapBlock *block = *i;
1856                         bool changed = block->m_node_metadata.step(dtime);
1857                         if(changed)
1858                                 changed_blocks[block->getPos()] = block;
1859                 }
1860         }
1861 }
1862
1863 /*
1864         ServerMap
1865 */
1866
1867 ServerMap::ServerMap(std::string savedir):
1868         Map(dout_server),
1869         m_seed(0),
1870         m_map_metadata_changed(true)
1871 {
1872         dstream<<__FUNCTION_NAME<<std::endl;
1873
1874         //m_chunksize = 8; // Takes a few seconds
1875
1876         m_seed = (((u64)(myrand()%0xffff)<<0)
1877                         + ((u64)(myrand()%0xffff)<<16)
1878                         + ((u64)(myrand()%0xffff)<<32)
1879                         + ((u64)(myrand()%0xffff)<<48));
1880
1881         /*
1882                 Experimental and debug stuff
1883         */
1884
1885         {
1886         }
1887
1888         /*
1889                 Try to load map; if not found, create a new one.
1890         */
1891
1892         m_savedir = savedir;
1893         m_map_saving_enabled = false;
1894
1895         try
1896         {
1897                 // If directory exists, check contents and load if possible
1898                 if(fs::PathExists(m_savedir))
1899                 {
1900                         // If directory is empty, it is safe to save into it.
1901                         if(fs::GetDirListing(m_savedir).size() == 0)
1902                         {
1903                                 dstream<<DTIME<<"Server: Empty save directory is valid."
1904                                                 <<std::endl;
1905                                 m_map_saving_enabled = true;
1906                         }
1907                         else
1908                         {
1909                                 try{
1910                                         // Load map metadata (seed, chunksize)
1911                                         loadMapMeta();
1912                                 }
1913                                 catch(FileNotGoodException &e){
1914                                         dstream<<DTIME<<"WARNING: Could not load map metadata"
1915                                                         //<<" Disabling chunk-based generator."
1916                                                         <<std::endl;
1917                                         //m_chunksize = 0;
1918                                 }
1919
1920                                 /*try{
1921                                         // Load chunk metadata
1922                                         loadChunkMeta();
1923                                 }
1924                                 catch(FileNotGoodException &e){
1925                                         dstream<<DTIME<<"WARNING: Could not load chunk metadata."
1926                                                         <<" Disabling chunk-based generator."
1927                                                         <<std::endl;
1928                                         m_chunksize = 0;
1929                                 }*/
1930
1931                                 /*dstream<<DTIME<<"Server: Successfully loaded chunk "
1932                                                 "metadata and sector (0,0) from "<<savedir<<
1933                                                 ", assuming valid save directory."
1934                                                 <<std::endl;*/
1935
1936                                 dstream<<DTIME<<"INFO: Server: Successfully loaded map "
1937                                                 <<"and chunk metadata from "<<savedir
1938                                                 <<", assuming valid save directory."
1939                                                 <<std::endl;
1940
1941                                 m_map_saving_enabled = true;
1942                                 // Map loaded, not creating new one
1943                                 return;
1944                         }
1945                 }
1946                 // If directory doesn't exist, it is safe to save to it
1947                 else{
1948                         m_map_saving_enabled = true;
1949                 }
1950         }
1951         catch(std::exception &e)
1952         {
1953                 dstream<<DTIME<<"WARNING: Server: Failed to load map from "<<savedir
1954                                 <<", exception: "<<e.what()<<std::endl;
1955                 dstream<<"Please remove the map or fix it."<<std::endl;
1956                 dstream<<"WARNING: Map saving will be disabled."<<std::endl;
1957         }
1958
1959         dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;
1960
1961         // Create zero sector
1962         emergeSector(v2s16(0,0));
1963
1964         // Initially write whole map
1965         save(false);
1966 }
1967
1968 ServerMap::~ServerMap()
1969 {
1970         dstream<<__FUNCTION_NAME<<std::endl;
1971
1972         try
1973         {
1974                 if(m_map_saving_enabled)
1975                 {
1976                         // Save only changed parts
1977                         save(true);
1978                         dstream<<DTIME<<"Server: saved map to "<<m_savedir<<std::endl;
1979                 }
1980                 else
1981                 {
1982                         dstream<<DTIME<<"Server: map not saved"<<std::endl;
1983                 }
1984         }
1985         catch(std::exception &e)
1986         {
1987                 dstream<<DTIME<<"Server: Failed to save map to "<<m_savedir
1988                                 <<", exception: "<<e.what()<<std::endl;
1989         }
1990
1991 #if 0
1992         /*
1993                 Free all MapChunks
1994         */
1995         core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
1996         for(; i.atEnd() == false; i++)
1997         {
1998                 MapChunk *chunk = i.getNode()->getValue();
1999                 delete chunk;
2000         }
2001 #endif
2002 }
2003
2004 void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos)
2005 {
2006         /*dstream<<"initBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
2007                         <<blockpos.Z<<")"<<std::endl;*/
2008
2009         // Do nothing if not inside limits (+-1 because of neighbors)
2010         if(blockpos_over_limit(blockpos - v3s16(1,1,1)) ||
2011                 blockpos_over_limit(blockpos + v3s16(1,1,1)))
2012         {
2013                 data->no_op = true;
2014                 return;
2015         }
2016
2017         data->no_op = false;
2018         data->seed = m_seed;
2019         data->blockpos = blockpos;
2020
2021         /*
2022                 Create the whole area of this and the neighboring blocks
2023         */
2024         {
2025                 //TimeTaker timer("initBlockMake() create area");
2026
2027                 for(s16 x=-1; x<=1; x++)
2028                 for(s16 z=-1; z<=1; z++)
2029                 {
2030                         v2s16 sectorpos(blockpos.X+x, blockpos.Z+z);
2031                         // Sector metadata is loaded from disk if not already loaded.
2032                         ServerMapSector *sector = createSector(sectorpos);
2033                         assert(sector);
2034
2035                         for(s16 y=-1; y<=1; y++)
2036                         {
2037                                 //MapBlock *block = createBlock(blockpos);
2038                                 // 1) get from memory, 2) load from disk
2039                                 MapBlock *block = emergeBlock(blockpos, false);
2040                                 // 3) create a blank one
2041                                 if(block == NULL)
2042                                         block = createBlock(blockpos);
2043
2044                                 // Lighting will not be valid after make_chunk is called
2045                                 block->setLightingExpired(true);
2046                                 // Lighting will be calculated
2047                                 //block->setLightingExpired(false);
2048
2049                                 /*
2050                                         Block gets sunlight if this is true.
2051
2052                                         This should be set to true when the top side of a block
2053                                         is completely exposed to the sky.
2054                                 */
2055                                 block->setIsUnderground(false);
2056                         }
2057                 }
2058         }
2059
2060         /*
2061                 Now we have a big empty area.
2062
2063                 Make a ManualMapVoxelManipulator that contains this and the
2064                 neighboring blocks
2065         */
2066
2067         // The area that contains this block and it's neighbors
2068         v3s16 bigarea_blocks_min = blockpos - v3s16(1,1,1);
2069         v3s16 bigarea_blocks_max = blockpos + v3s16(1,1,1);
2070
2071         data->vmanip = new ManualMapVoxelManipulator(this);
2072         //data->vmanip->setMap(this);
2073
2074         // Add the area
2075         {
2076                 //TimeTaker timer("initBlockMake() initialEmerge");
2077                 data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
2078         }
2079
2080         // Data is ready now.
2081 }
2082
2083 MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
2084                 core::map<v3s16, MapBlock*> &changed_blocks)
2085 {
2086         v3s16 blockpos = data->blockpos;
2087         /*dstream<<"finishBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
2088                         <<blockpos.Z<<")"<<std::endl;*/
2089
2090         if(data->no_op)
2091         {
2092                 //dstream<<"finishBlockMake(): no-op"<<std::endl;
2093                 return NULL;
2094         }
2095
2096         bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
2097
2098         /*dstream<<"Resulting vmanip:"<<std::endl;
2099         data->vmanip.print(dstream);*/
2100
2101         /*
2102                 Blit generated stuff to map
2103                 NOTE: blitBackAll adds nearly everything to changed_blocks
2104         */
2105         {
2106                 // 70ms @cs=8
2107                 //TimeTaker timer("finishBlockMake() blitBackAll");
2108                 data->vmanip->blitBackAll(&changed_blocks);
2109         }
2110
2111         if(enable_mapgen_debug_info)
2112                 dstream<<"finishBlockMake: changed_blocks.size()="
2113                                 <<changed_blocks.size()<<std::endl;
2114
2115         /*
2116                 Copy transforming liquid information
2117         */
2118         while(data->transforming_liquid.size() > 0)
2119         {
2120                 v3s16 p = data->transforming_liquid.pop_front();
2121                 m_transforming_liquid.push_back(p);
2122         }
2123
2124         /*
2125                 Get central block
2126         */
2127         MapBlock *block = getBlockNoCreateNoEx(data->blockpos);
2128         assert(block);
2129
2130         /*
2131                 Set is_underground flag for lighting with sunlight
2132         */
2133
2134         block->setIsUnderground(mapgen::block_is_underground(data->seed, blockpos));
2135
2136         /*
2137                 Add sunlight to central block.
2138                 This makes in-dark-spawning monsters to not flood the whole thing.
2139                 Do not spread the light, though.
2140         */
2141         /*core::map<v3s16, bool> light_sources;
2142         bool black_air_left = false;
2143         block->propagateSunlight(light_sources, true, &black_air_left);*/
2144
2145         /*
2146                 NOTE: Lighting and object adding shouldn't really be here, but
2147                 lighting is a bit tricky to move properly to makeBlock.
2148                 TODO: Do this the right way anyway, that is, move it to makeBlock.
2149                       - There needs to be some way for makeBlock to report back if
2150                             the lighting update is going further down because of the
2151                                 new block blocking light
2152         */
2153
2154         /*
2155                 Update lighting
2156                 NOTE: This takes ~60ms, TODO: Investigate why
2157         */
2158         {
2159                 TimeTaker t("finishBlockMake lighting update");
2160
2161                 core::map<v3s16, MapBlock*> lighting_update_blocks;
2162 #if 1
2163                 // Center block
2164                 lighting_update_blocks.insert(block->getPos(), block);
2165 #endif
2166 #if 0
2167                 // All modified blocks
2168                 // NOTE: Should this be done? If this is not done, then the lighting
2169                 // of the others will be updated in a different place, one by one, i
2170                 // think... or they might not? Well, at least they are left marked as
2171                 // "lighting expired"; it seems that is not handled at all anywhere,
2172                 // so enabling this will slow it down A LOT because otherwise it
2173                 // would not do this at all. This causes the black trees.
2174                 for(core::map<v3s16, MapBlock*>::Iterator
2175                                 i = changed_blocks.getIterator();
2176                                 i.atEnd() == false; i++)
2177                 {
2178                         lighting_update_blocks.insert(i.getNode()->getKey(),
2179                                         i.getNode()->getValue());
2180                 }
2181 #endif
2182                 updateLighting(lighting_update_blocks, changed_blocks);
2183
2184                 if(enable_mapgen_debug_info == false)
2185                         t.stop(true); // Hide output
2186         }
2187
2188         /*
2189                 Add random objects to block
2190         */
2191         mapgen::add_random_objects(block);
2192
2193         /*
2194                 Go through changed blocks
2195         */
2196         for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
2197                         i.atEnd() == false; i++)
2198         {
2199                 MapBlock *block = i.getNode()->getValue();
2200                 assert(block);
2201                 /*
2202                         Update day/night difference cache of the MapBlocks
2203                 */
2204                 block->updateDayNightDiff();
2205                 /*
2206                         Set block as modified
2207                 */
2208                 block->raiseModified(MOD_STATE_WRITE_NEEDED);
2209         }
2210
2211         /*
2212                 Set central block as generated
2213         */
2214         block->setGenerated(true);
2215
2216         /*
2217                 Save changed parts of map
2218                 NOTE: Will be saved later.
2219         */
2220         //save(true);
2221
2222         /*dstream<<"finishBlockMake() done for ("<<blockpos.X<<","<<blockpos.Y<<","
2223                         <<blockpos.Z<<")"<<std::endl;*/
2224
2225         return block;
2226 }
2227
2228 ServerMapSector * ServerMap::createSector(v2s16 p2d)
2229 {
2230         DSTACKF("%s: p2d=(%d,%d)",
2231                         __FUNCTION_NAME,
2232                         p2d.X, p2d.Y);
2233
2234         /*
2235                 Check if it exists already in memory
2236         */
2237         ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
2238         if(sector != NULL)
2239                 return sector;
2240
2241         /*
2242                 Try to load it from disk (with blocks)
2243         */
2244         //if(loadSectorFull(p2d) == true)
2245
2246         /*
2247                 Try to load metadata from disk
2248         */
2249         if(loadSectorMeta(p2d) == true)
2250         {
2251                 ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
2252                 if(sector == NULL)
2253                 {
2254                         dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<<std::endl;
2255                         throw InvalidPositionException("");
2256                 }
2257                 return sector;
2258         }
2259
2260         /*
2261                 Do not create over-limit
2262         */
2263         if(p2d.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2264         || p2d.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2265         || p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2266         || p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
2267                 throw InvalidPositionException("createSector(): pos. over limit");
2268
2269         /*
2270                 Generate blank sector
2271         */
2272
2273         sector = new ServerMapSector(this, p2d);
2274
2275         // Sector position on map in nodes
2276         v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
2277
2278         /*
2279                 Insert to container
2280         */
2281         m_sectors.insert(p2d, sector);
2282
2283         return sector;
2284 }
2285
2286 /*
2287         This is a quick-hand function for calling makeBlock().
2288 */
2289 MapBlock * ServerMap::generateBlock(
2290                 v3s16 p,
2291                 core::map<v3s16, MapBlock*> &modified_blocks
2292 )
2293 {
2294         DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
2295
2296         /*dstream<<"generateBlock(): "
2297                         <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
2298                         <<std::endl;*/
2299
2300         bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
2301
2302         TimeTaker timer("generateBlock");
2303
2304         //MapBlock *block = original_dummy;
2305
2306         v2s16 p2d(p.X, p.Z);
2307         v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
2308
2309         /*
2310                 Do not generate over-limit
2311         */
2312         if(blockpos_over_limit(p))
2313         {
2314                 dstream<<__FUNCTION_NAME<<": Block position over limit"<<std::endl;
2315                 throw InvalidPositionException("generateBlock(): pos. over limit");
2316         }
2317
2318         /*
2319                 Create block make data
2320         */
2321         mapgen::BlockMakeData data;
2322         initBlockMake(&data, p);
2323
2324         /*
2325                 Generate block
2326         */
2327         {
2328                 TimeTaker t("mapgen::make_block()");
2329                 mapgen::make_block(&data);
2330
2331                 if(enable_mapgen_debug_info == false)
2332                         t.stop(true); // Hide output
2333         }
2334
2335         /*
2336                 Blit data back on map, update lighting, add mobs and whatever this does
2337         */
2338         finishBlockMake(&data, modified_blocks);
2339
2340         /*
2341                 Get central block
2342         */
2343         MapBlock *block = getBlockNoCreateNoEx(p);
2344
2345 #if 0
2346         /*
2347                 Check result
2348         */
2349         if(block)
2350         {
2351                 bool erroneus_content = false;
2352                 for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
2353                 for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
2354                 for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
2355                 {
2356                         v3s16 p(x0,y0,z0);
2357                         MapNode n = block->getNode(p);
2358                         if(n.d == CONTENT_IGNORE)
2359                         {
2360                                 dstream<<"CONTENT_IGNORE at "
2361                                                 <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
2362                                                 <<std::endl;
2363                                 erroneus_content = true;
2364                                 assert(0);
2365                         }
2366                 }
2367                 if(erroneus_content)
2368                 {
2369                         assert(0);
2370                 }
2371         }
2372 #endif
2373
2374 #if 0
2375         /*
2376                 Generate a completely empty block
2377         */
2378         if(block)
2379         {
2380                 for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
2381                 for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
2382                 {
2383                         for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
2384                         {
2385                                 MapNode n;
2386                                 if(y0%2==0)
2387                                         n.d = CONTENT_AIR;
2388                                 else
2389                                         n.d = CONTENT_STONE;
2390                                 block->setNode(v3s16(x0,y0,z0), n);
2391                         }
2392                 }
2393         }
2394 #endif
2395
2396         if(enable_mapgen_debug_info == false)
2397                 timer.stop(true); // Hide output
2398
2399         return block;
2400 }
2401
2402 MapBlock * ServerMap::createBlock(v3s16 p)
2403 {
2404         DSTACKF("%s: p=(%d,%d,%d)",
2405                         __FUNCTION_NAME, p.X, p.Y, p.Z);
2406
2407         /*
2408                 Do not create over-limit
2409         */
2410         if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2411         || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2412         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2413         || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2414         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2415         || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
2416                 throw InvalidPositionException("createBlock(): pos. over limit");
2417
2418         v2s16 p2d(p.X, p.Z);
2419         s16 block_y = p.Y;
2420         /*
2421                 This will create or load a sector if not found in memory.
2422                 If block exists on disk, it will be loaded.
2423
2424                 NOTE: On old save formats, this will be slow, as it generates
2425                       lighting on blocks for them.
2426         */
2427         ServerMapSector *sector;
2428         try{
2429                 sector = (ServerMapSector*)createSector(p2d);
2430                 assert(sector->getId() == MAPSECTOR_SERVER);
2431         }
2432         catch(InvalidPositionException &e)
2433         {
2434                 dstream<<"createBlock: createSector() failed"<<std::endl;
2435                 throw e;
2436         }
2437         /*
2438                 NOTE: This should not be done, or at least the exception
2439                 should not be passed on as std::exception, because it
2440                 won't be catched at all.
2441         */
2442         /*catch(std::exception &e)
2443         {
2444                 dstream<<"createBlock: createSector() failed: "
2445                                 <<e.what()<<std::endl;
2446                 throw e;
2447         }*/
2448
2449         /*
2450                 Try to get a block from the sector
2451         */
2452
2453         MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
2454         if(block)
2455         {
2456                 if(block->isDummy())
2457                         block->unDummify();
2458                 return block;
2459         }
2460         // Create blank
2461         block = sector->createBlankBlock(block_y);
2462         return block;
2463 }
2464
2465 MapBlock * ServerMap::emergeBlock(v3s16 p, bool allow_generate)
2466 {
2467         DSTACKF("%s: p=(%d,%d,%d), allow_generate=%d",
2468                         __FUNCTION_NAME,
2469                         p.X, p.Y, p.Z, allow_generate);
2470
2471         {
2472                 MapBlock *block = getBlockNoCreateNoEx(p);
2473                 if(block)
2474                         return block;
2475         }
2476
2477         {
2478                 MapBlock *block = loadBlock(p);
2479                 if(block)
2480                         return block;
2481         }
2482
2483         if(allow_generate)
2484         {
2485                 core::map<v3s16, MapBlock*> modified_blocks;
2486                 MapBlock *block = generateBlock(p, modified_blocks);
2487                 if(block)
2488                 {
2489                         MapEditEvent event;
2490                         event.type = MEET_OTHER;
2491                         event.p = p;
2492
2493                         // Copy modified_blocks to event
2494                         for(core::map<v3s16, MapBlock*>::Iterator
2495                                         i = modified_blocks.getIterator();
2496                                         i.atEnd()==false; i++)
2497                         {
2498                                 event.modified_blocks.insert(i.getNode()->getKey(), false);
2499                         }
2500
2501                         // Queue event
2502                         dispatchEvent(&event);
2503
2504                         return block;
2505                 }
2506         }
2507
2508         return NULL;
2509 }
2510
2511 #if 0
2512         /*
2513                 Do not generate over-limit
2514         */
2515         if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2516         || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2517         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2518         || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2519         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
2520         || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
2521                 throw InvalidPositionException("emergeBlock(): pos. over limit");
2522
2523         v2s16 p2d(p.X, p.Z);
2524         s16 block_y = p.Y;
2525         /*
2526                 This will create or load a sector if not found in memory.
2527                 If block exists on disk, it will be loaded.
2528         */
2529         ServerMapSector *sector;
2530         try{
2531                 sector = createSector(p2d);
2532                 //sector = emergeSector(p2d, changed_blocks);
2533         }
2534         catch(InvalidPositionException &e)
2535         {
2536                 dstream<<"emergeBlock: createSector() failed: "
2537                                 <<e.what()<<std::endl;
2538                 dstream<<"Path to failed sector: "<<getSectorDir(p2d)
2539                                 <<std::endl
2540                                 <<"You could try to delete it."<<std::endl;
2541                 throw e;
2542         }
2543         catch(VersionMismatchException &e)
2544         {
2545                 dstream<<"emergeBlock: createSector() failed: "
2546                                 <<e.what()<<std::endl;
2547                 dstream<<"Path to failed sector: "<<getSectorDir(p2d)
2548                                 <<std::endl
2549                                 <<"You could try to delete it."<<std::endl;
2550                 throw e;
2551         }
2552
2553         /*
2554                 Try to get a block from the sector
2555         */
2556
2557         bool does_not_exist = false;
2558         bool lighting_expired = false;
2559         MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
2560
2561         // If not found, try loading from disk
2562         if(block == NULL)
2563         {
2564                 block = loadBlock(p);
2565         }
2566
2567         // Handle result
2568         if(block == NULL)
2569         {
2570                 does_not_exist = true;
2571         }
2572         else if(block->isDummy() == true)
2573         {
2574                 does_not_exist = true;
2575         }
2576         else if(block->getLightingExpired())
2577         {
2578                 lighting_expired = true;
2579         }
2580         else
2581         {
2582                 // Valid block
2583                 //dstream<<"emergeBlock(): Returning already valid block"<<std::endl;
2584                 return block;
2585         }
2586
2587         /*
2588                 If block was not found on disk and not going to generate a
2589                 new one, make sure there is a dummy block in place.
2590         */
2591         if(only_from_disk && (does_not_exist || lighting_expired))
2592         {
2593                 //dstream<<"emergeBlock(): Was not on disk but not generating"<<std::endl;
2594
2595                 if(block == NULL)
2596                 {
2597                         // Create dummy block
2598                         block = new MapBlock(this, p, true);
2599
2600                         // Add block to sector
2601                         sector->insertBlock(block);
2602                 }
2603                 // Done.
2604                 return block;
2605         }
2606
2607         //dstream<<"Not found on disk, generating."<<std::endl;
2608         // 0ms
2609         //TimeTaker("emergeBlock() generate");
2610
2611         //dstream<<"emergeBlock(): Didn't find valid block -> making one"<<std::endl;
2612
2613         /*
2614                 If the block doesn't exist, generate the block.
2615         */
2616         if(does_not_exist)
2617         {
2618                 block = generateBlock(p, block, sector, changed_blocks,
2619                                 lighting_invalidated_blocks);
2620         }
2621
2622         if(lighting_expired)
2623         {
2624                 lighting_invalidated_blocks.insert(p, block);
2625         }
2626
2627 #if 0
2628         /*
2629                 Initially update sunlight
2630         */
2631         {
2632                 core::map<v3s16, bool> light_sources;
2633                 bool black_air_left = false;
2634                 bool bottom_invalid =
2635                                 block->propagateSunlight(light_sources, true,
2636                                 &black_air_left);
2637
2638                 // If sunlight didn't reach everywhere and part of block is
2639                 // above ground, lighting has to be properly updated
2640                 //if(black_air_left && some_part_underground)
2641                 if(black_air_left)
2642                 {
2643                         lighting_invalidated_blocks[block->getPos()] = block;
2644                 }
2645
2646                 if(bottom_invalid)
2647                 {
2648                         lighting_invalidated_blocks[block->getPos()] = block;
2649                 }
2650         }
2651 #endif
2652
2653         return block;
2654 }
2655 #endif
2656
2657 s16 ServerMap::findGroundLevel(v2s16 p2d)
2658 {
2659 #if 0
2660         /*
2661                 Uh, just do something random...
2662         */
2663         // Find existing map from top to down
2664         s16 max=63;
2665         s16 min=-64;
2666         v3s16 p(p2d.X, max, p2d.Y);
2667         for(; p.Y>min; p.Y--)
2668         {
2669                 MapNode n = getNodeNoEx(p);
2670                 if(n.d != CONTENT_IGNORE)
2671                         break;
2672         }
2673         if(p.Y == min)
2674                 goto plan_b;
2675         // If this node is not air, go to plan b
2676         if(getNodeNoEx(p).d != CONTENT_AIR)
2677                 goto plan_b;
2678         // Search existing walkable and return it
2679         for(; p.Y>min; p.Y--)
2680         {
2681                 MapNode n = getNodeNoEx(p);
2682                 if(content_walkable(n.d) && n.d != CONTENT_IGNORE)
2683                         return p.Y;
2684         }
2685
2686         // Move to plan b
2687 plan_b:
2688 #endif
2689
2690         /*
2691                 Determine from map generator noise functions
2692         */
2693
2694         s16 level = mapgen::find_ground_level_from_noise(m_seed, p2d, 1);
2695         return level;
2696
2697         //double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
2698         //return (s16)level;
2699 }
2700
2701 void ServerMap::createDirs(std::string path)
2702 {
2703         if(fs::CreateAllDirs(path) == false)
2704         {
2705                 m_dout<<DTIME<<"ServerMap: Failed to create directory "
2706                                 <<"\""<<path<<"\""<<std::endl;
2707                 throw BaseException("ServerMap failed to create directory");
2708         }
2709 }
2710
2711 std::string ServerMap::getSectorDir(v2s16 pos, int layout)
2712 {
2713         char cc[9];
2714         switch(layout)
2715         {
2716                 case 1:
2717                         snprintf(cc, 9, "%.4x%.4x",
2718                                 (unsigned int)pos.X&0xffff,
2719                                 (unsigned int)pos.Y&0xffff);
2720
2721                         return m_savedir + "/sectors/" + cc;
2722                 case 2:
2723                         snprintf(cc, 9, "%.3x/%.3x",
2724                                 (unsigned int)pos.X&0xfff,
2725                                 (unsigned int)pos.Y&0xfff);
2726
2727                         return m_savedir + "/sectors2/" + cc;
2728                 default:
2729                         assert(false);
2730         }
2731 }
2732
2733 v2s16 ServerMap::getSectorPos(std::string dirname)
2734 {
2735         unsigned int x, y;
2736         int r;
2737         size_t spos = dirname.rfind('/') + 1;
2738         assert(spos != std::string::npos);
2739         if(dirname.size() - spos == 8)
2740         {
2741                 // Old layout
2742                 r = sscanf(dirname.substr(spos).c_str(), "%4x%4x", &x, &y);
2743         }
2744         else if(dirname.size() - spos == 3)
2745         {
2746                 // New layout
2747                 r = sscanf(dirname.substr(spos-4).c_str(), "%3x/%3x", &x, &y);
2748                 // Sign-extend the 12 bit values up to 16 bits...
2749                 if(x&0x800) x|=0xF000;
2750                 if(y&0x800) y|=0xF000;
2751         }
2752         else
2753         {
2754                 assert(false);
2755         }
2756         assert(r == 2);
2757         v2s16 pos((s16)x, (s16)y);
2758         return pos;
2759 }
2760
2761 v3s16 ServerMap::getBlockPos(std::string sectordir, std::string blockfile)
2762 {
2763         v2s16 p2d = getSectorPos(sectordir);
2764
2765         if(blockfile.size() != 4){
2766                 throw InvalidFilenameException("Invalid block filename");
2767         }
2768         unsigned int y;
2769         int r = sscanf(blockfile.c_str(), "%4x", &y);
2770         if(r != 1)
2771                 throw InvalidFilenameException("Invalid block filename");
2772         return v3s16(p2d.X, y, p2d.Y);
2773 }
2774
2775 std::string ServerMap::getBlockFilename(v3s16 p)
2776 {
2777         char cc[5];
2778         snprintf(cc, 5, "%.4x", (unsigned int)p.Y&0xffff);
2779         return cc;
2780 }
2781
2782 void ServerMap::save(bool only_changed)
2783 {
2784         DSTACK(__FUNCTION_NAME);
2785         if(m_map_saving_enabled == false)
2786         {
2787                 dstream<<DTIME<<"WARNING: Not saving map, saving disabled."<<std::endl;
2788                 return;
2789         }
2790
2791         if(only_changed == false)
2792                 dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
2793                                 <<std::endl;
2794
2795         if(only_changed == false || m_map_metadata_changed)
2796         {
2797                 saveMapMeta();
2798         }
2799
2800         u32 sector_meta_count = 0;
2801         u32 block_count = 0;
2802         u32 block_count_all = 0; // Number of blocks in memory
2803
2804         core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
2805         for(; i.atEnd() == false; i++)
2806         {
2807                 ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
2808                 assert(sector->getId() == MAPSECTOR_SERVER);
2809
2810                 if(sector->differs_from_disk || only_changed == false)
2811                 {
2812                         saveSectorMeta(sector);
2813                         sector_meta_count++;
2814                 }
2815                 core::list<MapBlock*> blocks;
2816                 sector->getBlocks(blocks);
2817                 core::list<MapBlock*>::Iterator j;
2818                 for(j=blocks.begin(); j!=blocks.end(); j++)
2819                 {
2820                         MapBlock *block = *j;
2821
2822                         block_count_all++;
2823
2824                         if(block->getModified() >= MOD_STATE_WRITE_NEEDED
2825                                         || only_changed == false)
2826                         {
2827                                 saveBlock(block);
2828                                 block_count++;
2829
2830                                 /*dstream<<"ServerMap: Written block ("
2831                                                 <<block->getPos().X<<","
2832                                                 <<block->getPos().Y<<","
2833                                                 <<block->getPos().Z<<")"
2834                                                 <<std::endl;*/
2835                         }
2836                 }
2837         }
2838
2839         /*
2840                 Only print if something happened or saved whole map
2841         */
2842         if(only_changed == false || sector_meta_count != 0
2843                         || block_count != 0)
2844         {
2845                 dstream<<DTIME<<"ServerMap: Written: "
2846                                 <<sector_meta_count<<" sector metadata files, "
2847                                 <<block_count<<" block files"
2848                                 <<", "<<block_count_all<<" blocks in memory."
2849                                 <<std::endl;
2850         }
2851 }
2852
2853 void ServerMap::saveMapMeta()
2854 {
2855         DSTACK(__FUNCTION_NAME);
2856
2857         dstream<<"INFO: ServerMap::saveMapMeta(): "
2858                         <<"seed="<<m_seed
2859                         <<std::endl;
2860
2861         createDirs(m_savedir);
2862
2863         std::string fullpath = m_savedir + "/map_meta.txt";
2864         std::ofstream os(fullpath.c_str(), std::ios_base::binary);
2865         if(os.good() == false)
2866         {
2867                 dstream<<"ERROR: ServerMap::saveMapMeta(): "
2868                                 <<"could not open"<<fullpath<<std::endl;
2869                 throw FileNotGoodException("Cannot open chunk metadata");
2870         }
2871
2872         Settings params;
2873         params.setU64("seed", m_seed);
2874
2875         params.writeLines(os);
2876
2877         os<<"[end_of_params]\n";
2878
2879         m_map_metadata_changed = false;
2880 }
2881
2882 void ServerMap::loadMapMeta()
2883 {
2884         DSTACK(__FUNCTION_NAME);
2885
2886         dstream<<"INFO: ServerMap::loadMapMeta(): Loading map metadata"
2887                         <<std::endl;
2888
2889         std::string fullpath = m_savedir + "/map_meta.txt";
2890         std::ifstream is(fullpath.c_str(), std::ios_base::binary);
2891         if(is.good() == false)
2892         {
2893                 dstream<<"ERROR: ServerMap::loadMapMeta(): "
2894                                 <<"could not open"<<fullpath<<std::endl;
2895                 throw FileNotGoodException("Cannot open map metadata");
2896         }
2897
2898         Settings params;
2899
2900         for(;;)
2901         {
2902                 if(is.eof())
2903                         throw SerializationError
2904                                         ("ServerMap::loadMapMeta(): [end_of_params] not found");
2905                 std::string line;
2906                 std::getline(is, line);
2907                 std::string trimmedline = trim(line);
2908                 if(trimmedline == "[end_of_params]")
2909                         break;
2910                 params.parseConfigLine(line);
2911         }
2912
2913         m_seed = params.getU64("seed");
2914
2915         dstream<<"INFO: ServerMap::loadMapMeta(): "
2916                         <<"seed="<<m_seed
2917                         <<std::endl;
2918 }
2919
2920 void ServerMap::saveSectorMeta(ServerMapSector *sector)
2921 {
2922         DSTACK(__FUNCTION_NAME);
2923         // Format used for writing
2924         u8 version = SER_FMT_VER_HIGHEST;
2925         // Get destination
2926         v2s16 pos = sector->getPos();
2927         std::string dir = getSectorDir(pos);
2928         createDirs(dir);
2929
2930         std::string fullpath = dir + "/meta";
2931         std::ofstream o(fullpath.c_str(), std::ios_base::binary);
2932         if(o.good() == false)
2933                 throw FileNotGoodException("Cannot open sector metafile");
2934
2935         sector->serialize(o, version);
2936
2937         sector->differs_from_disk = false;
2938 }
2939
2940 MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load)
2941 {
2942         DSTACK(__FUNCTION_NAME);
2943         // Get destination
2944         v2s16 p2d = getSectorPos(sectordir);
2945
2946         ServerMapSector *sector = NULL;
2947
2948         std::string fullpath = sectordir + "/meta";
2949         std::ifstream is(fullpath.c_str(), std::ios_base::binary);
2950         if(is.good() == false)
2951         {
2952                 // If the directory exists anyway, it probably is in some old
2953                 // format. Just go ahead and create the sector.
2954                 if(fs::PathExists(sectordir))
2955                 {
2956                         /*dstream<<"ServerMap::loadSectorMeta(): Sector metafile "
2957                                         <<fullpath<<" doesn't exist but directory does."
2958                                         <<" Continuing with a sector with no metadata."
2959                                         <<std::endl;*/
2960                         sector = new ServerMapSector(this, p2d);
2961                         m_sectors.insert(p2d, sector);
2962                 }
2963                 else
2964                 {
2965                         throw FileNotGoodException("Cannot open sector metafile");
2966                 }
2967         }
2968         else
2969         {
2970                 sector = ServerMapSector::deSerialize
2971                                 (is, this, p2d, m_sectors);
2972                 if(save_after_load)
2973                         saveSectorMeta(sector);
2974         }
2975
2976         sector->differs_from_disk = false;
2977
2978         return sector;
2979 }
2980
2981 bool ServerMap::loadSectorMeta(v2s16 p2d)
2982 {
2983         DSTACK(__FUNCTION_NAME);
2984
2985         MapSector *sector = NULL;
2986
2987         // The directory layout we're going to load from.
2988         //  1 - original sectors/xxxxzzzz/
2989         //  2 - new sectors2/xxx/zzz/
2990         //  If we load from anything but the latest structure, we will
2991         //  immediately save to the new one, and remove the old.
2992         int loadlayout = 1;
2993         std::string sectordir1 = getSectorDir(p2d, 1);
2994         std::string sectordir;
2995         if(fs::PathExists(sectordir1))
2996         {
2997                 sectordir = sectordir1;
2998         }
2999         else
3000         {
3001                 loadlayout = 2;
3002                 sectordir = getSectorDir(p2d, 2);
3003         }
3004
3005         try{
3006                 sector = loadSectorMeta(sectordir, loadlayout != 2);
3007         }
3008         catch(InvalidFilenameException &e)
3009         {
3010                 return false;
3011         }
3012         catch(FileNotGoodException &e)
3013         {
3014                 return false;
3015         }
3016         catch(std::exception &e)
3017         {
3018                 return false;
3019         }
3020
3021         return true;
3022 }
3023
3024 #if 0
3025 bool ServerMap::loadSectorFull(v2s16 p2d)
3026 {
3027         DSTACK(__FUNCTION_NAME);
3028
3029         MapSector *sector = NULL;
3030
3031         // The directory layout we're going to load from.
3032         //  1 - original sectors/xxxxzzzz/
3033         //  2 - new sectors2/xxx/zzz/
3034         //  If we load from anything but the latest structure, we will
3035         //  immediately save to the new one, and remove the old.
3036         int loadlayout = 1;
3037         std::string sectordir1 = getSectorDir(p2d, 1);
3038         std::string sectordir;
3039         if(fs::PathExists(sectordir1))
3040         {
3041                 sectordir = sectordir1;
3042         }
3043         else
3044         {
3045                 loadlayout = 2;
3046                 sectordir = getSectorDir(p2d, 2);
3047         }
3048
3049         try{
3050                 sector = loadSectorMeta(sectordir, loadlayout != 2);
3051         }
3052         catch(InvalidFilenameException &e)
3053         {
3054                 return false;
3055         }
3056         catch(FileNotGoodException &e)
3057         {
3058                 return false;
3059         }
3060         catch(std::exception &e)
3061         {
3062                 return false;
3063         }
3064
3065         /*
3066                 Load blocks
3067         */
3068         std::vector<fs::DirListNode> list2 = fs::GetDirListing
3069                         (sectordir);
3070         std::vector<fs::DirListNode>::iterator i2;
3071         for(i2=list2.begin(); i2!=list2.end(); i2++)
3072         {
3073                 // We want files
3074                 if(i2->dir)
3075                         continue;
3076                 try{
3077                         loadBlock(sectordir, i2->name, sector, loadlayout != 2);
3078                 }
3079                 catch(InvalidFilenameException &e)
3080                 {
3081                         // This catches unknown crap in directory
3082                 }
3083         }
3084
3085         if(loadlayout != 2)
3086         {
3087                 dstream<<"Sector converted to new layout - deleting "<<
3088                         sectordir1<<std::endl;
3089                 fs::RecursiveDelete(sectordir1);
3090         }
3091
3092         return true;
3093 }
3094 #endif
3095
3096 void ServerMap::saveBlock(MapBlock *block)
3097 {
3098         DSTACK(__FUNCTION_NAME);
3099         /*
3100                 Dummy blocks are not written
3101         */
3102         if(block->isDummy())
3103         {
3104                 /*v3s16 p = block->getPos();
3105                 dstream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block "
3106                                 <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
3107                 return;
3108         }
3109
3110         // Format used for writing
3111         u8 version = SER_FMT_VER_HIGHEST;
3112         // Get destination
3113         v3s16 p3d = block->getPos();
3114
3115         v2s16 p2d(p3d.X, p3d.Z);
3116         std::string sectordir = getSectorDir(p2d);
3117
3118         createDirs(sectordir);
3119
3120         std::string fullpath = sectordir+"/"+getBlockFilename(p3d);
3121         std::ofstream o(fullpath.c_str(), std::ios_base::binary);
3122         if(o.good() == false)
3123                 throw FileNotGoodException("Cannot open block data");
3124
3125         /*
3126                 [0] u8 serialization version
3127                 [1] data
3128         */
3129         o.write((char*)&version, 1);
3130
3131         // Write basic data
3132         block->serialize(o, version);
3133
3134         // Write extra data stored on disk
3135         block->serializeDiskExtra(o, version);
3136
3137         // We just wrote it to the disk so clear modified flag
3138         block->resetModified();
3139 }
3140
3141 void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load)
3142 {
3143         DSTACK(__FUNCTION_NAME);
3144
3145         std::string fullpath = sectordir+"/"+blockfile;
3146         try{
3147
3148                 std::ifstream is(fullpath.c_str(), std::ios_base::binary);
3149                 if(is.good() == false)
3150                         throw FileNotGoodException("Cannot open block file");
3151
3152                 v3s16 p3d = getBlockPos(sectordir, blockfile);
3153                 v2s16 p2d(p3d.X, p3d.Z);
3154
3155                 assert(sector->getPos() == p2d);
3156
3157                 u8 version = SER_FMT_VER_INVALID;
3158                 is.read((char*)&version, 1);
3159
3160                 if(is.fail())
3161                         throw SerializationError("ServerMap::loadBlock(): Failed"
3162                                         " to read MapBlock version");
3163
3164                 /*u32 block_size = MapBlock::serializedLength(version);
3165                 SharedBuffer<u8> data(block_size);
3166                 is.read((char*)*data, block_size);*/
3167
3168                 // This will always return a sector because we're the server
3169                 //MapSector *sector = emergeSector(p2d);
3170
3171                 MapBlock *block = NULL;
3172                 bool created_new = false;
3173                 block = sector->getBlockNoCreateNoEx(p3d.Y);
3174                 if(block == NULL)
3175                 {
3176                         block = sector->createBlankBlockNoInsert(p3d.Y);
3177                         created_new = true;
3178                 }
3179
3180                 // Read basic data
3181                 block->deSerialize(is, version);
3182
3183                 // Read extra data stored on disk
3184                 block->deSerializeDiskExtra(is, version);
3185
3186                 // If it's a new block, insert it to the map
3187                 if(created_new)
3188                         sector->insertBlock(block);
3189
3190                 /*
3191                         Save blocks loaded in old format in new format
3192                 */
3193
3194                 if(version < SER_FMT_VER_HIGHEST || save_after_load)
3195                 {
3196                         saveBlock(block);
3197                 }
3198
3199                 // We just loaded it from the disk, so it's up-to-date.
3200                 block->resetModified();
3201
3202         }
3203         catch(SerializationError &e)
3204         {
3205                 dstream<<"WARNING: Invalid block data on disk "
3206                                 <<"fullpath="<<fullpath
3207                                 <<" (SerializationError). "
3208                                 <<"what()="<<e.what()
3209                                 <<std::endl;
3210                                 //" Ignoring. A new one will be generated.
3211                 assert(0);
3212
3213                 // TODO: Backup file; name is in fullpath.
3214         }
3215 }
3216
3217 MapBlock* ServerMap::loadBlock(v3s16 blockpos)
3218 {
3219         DSTACK(__FUNCTION_NAME);
3220
3221         v2s16 p2d(blockpos.X, blockpos.Z);
3222
3223         // The directory layout we're going to load from.
3224         //  1 - original sectors/xxxxzzzz/
3225         //  2 - new sectors2/xxx/zzz/
3226         //  If we load from anything but the latest structure, we will
3227         //  immediately save to the new one, and remove the old.
3228         int loadlayout = 1;
3229         std::string sectordir1 = getSectorDir(p2d, 1);
3230         std::string sectordir;
3231         if(fs::PathExists(sectordir1))
3232         {
3233                 sectordir = sectordir1;
3234         }
3235         else
3236         {
3237                 loadlayout = 2;
3238                 sectordir = getSectorDir(p2d, 2);
3239         }
3240
3241         /*
3242                 Make sure sector is loaded
3243         */
3244         MapSector *sector = getSectorNoGenerateNoEx(p2d);
3245         if(sector == NULL)
3246         {
3247                 try{
3248                         sector = loadSectorMeta(sectordir, loadlayout != 2);
3249                 }
3250                 catch(InvalidFilenameException &e)
3251                 {
3252                         return false;
3253                 }
3254                 catch(FileNotGoodException &e)
3255                 {
3256                         return false;
3257                 }
3258                 catch(std::exception &e)
3259                 {
3260                         return false;
3261                 }
3262         }
3263
3264         /*
3265                 Make sure file exists
3266         */
3267
3268         std::string blockfilename = getBlockFilename(blockpos);
3269         if(fs::PathExists(sectordir+"/"+blockfilename) == false)
3270                 return NULL;
3271
3272         /*
3273                 Load block
3274         */
3275         loadBlock(sectordir, blockfilename, sector, loadlayout != 2);
3276         return getBlockNoCreateNoEx(blockpos);
3277 }
3278
3279 void ServerMap::PrintInfo(std::ostream &out)
3280 {
3281         out<<"ServerMap: ";
3282 }
3283
3284 #ifndef SERVER
3285
3286 /*
3287         ClientMap
3288 */
3289
3290 ClientMap::ClientMap(
3291                 Client *client,
3292                 MapDrawControl &control,
3293                 scene::ISceneNode* parent,
3294                 scene::ISceneManager* mgr,
3295                 s32 id
3296 ):
3297         Map(dout_client),
3298         scene::ISceneNode(parent, mgr, id),
3299         m_client(client),
3300         m_control(control),
3301         m_camera_position(0,0,0),
3302         m_camera_direction(0,0,1)
3303 {
3304         m_camera_mutex.Init();
3305         assert(m_camera_mutex.IsInitialized());
3306
3307         m_box = core::aabbox3d<f32>(-BS*1000000,-BS*1000000,-BS*1000000,
3308                         BS*1000000,BS*1000000,BS*1000000);
3309 }
3310
3311 ClientMap::~ClientMap()
3312 {
3313         /*JMutexAutoLock lock(mesh_mutex);
3314
3315         if(mesh != NULL)
3316         {
3317                 mesh->drop();
3318                 mesh = NULL;
3319         }*/
3320 }
3321
3322 MapSector * ClientMap::emergeSector(v2s16 p2d)
3323 {
3324         DSTACK(__FUNCTION_NAME);
3325         // Check that it doesn't exist already
3326         try{
3327                 return getSectorNoGenerate(p2d);
3328         }
3329         catch(InvalidPositionException &e)
3330         {
3331         }
3332
3333         // Create a sector
3334         ClientMapSector *sector = new ClientMapSector(this, p2d);
3335
3336         {
3337                 //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
3338                 m_sectors.insert(p2d, sector);
3339         }
3340
3341         return sector;
3342 }
3343
3344 #if 0
3345 void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is)
3346 {
3347         DSTACK(__FUNCTION_NAME);
3348         ClientMapSector *sector = NULL;
3349
3350         //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
3351
3352         core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p2d);
3353
3354         if(n != NULL)
3355         {
3356                 sector = (ClientMapSector*)n->getValue();
3357                 assert(sector->getId() == MAPSECTOR_CLIENT);
3358         }
3359         else
3360         {
3361                 sector = new ClientMapSector(this, p2d);
3362                 {
3363                         //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
3364                         m_sectors.insert(p2d, sector);
3365                 }
3366         }
3367
3368         sector->deSerialize(is);
3369 }
3370 #endif
3371
3372 void ClientMap::OnRegisterSceneNode()
3373 {
3374         if(IsVisible)
3375         {
3376                 SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
3377                 SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
3378         }
3379
3380         ISceneNode::OnRegisterSceneNode();
3381 }
3382
3383 void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
3384 {
3385         //m_dout<<DTIME<<"Rendering map..."<<std::endl;
3386         DSTACK(__FUNCTION_NAME);
3387
3388         bool is_transparent_pass = pass == scene::ESNRP_TRANSPARENT;
3389
3390         /*
3391                 This is called two times per frame, reset on the non-transparent one
3392         */
3393         if(pass == scene::ESNRP_SOLID)
3394         {
3395                 m_last_drawn_sectors.clear();
3396         }
3397
3398         /*
3399                 Get time for measuring timeout.
3400
3401                 Measuring time is very useful for long delays when the
3402                 machine is swapping a lot.
3403         */
3404         int time1 = time(0);
3405
3406         //u32 daynight_ratio = m_client->getDayNightRatio();
3407
3408         m_camera_mutex.Lock();
3409         v3f camera_position = m_camera_position;
3410         v3f camera_direction = m_camera_direction;
3411         m_camera_mutex.Unlock();
3412
3413         /*
3414                 Get all blocks and draw all visible ones
3415         */
3416
3417         v3s16 cam_pos_nodes(
3418                         camera_position.X / BS,
3419                         camera_position.Y / BS,
3420                         camera_position.Z / BS);
3421
3422         v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1);
3423
3424         v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d;
3425         v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d;
3426
3427         // Take a fair amount as we will be dropping more out later
3428         v3s16 p_blocks_min(
3429                         p_nodes_min.X / MAP_BLOCKSIZE - 2,
3430                         p_nodes_min.Y / MAP_BLOCKSIZE - 2,
3431                         p_nodes_min.Z / MAP_BLOCKSIZE - 2);
3432         v3s16 p_blocks_max(
3433                         p_nodes_max.X / MAP_BLOCKSIZE + 1,
3434                         p_nodes_max.Y / MAP_BLOCKSIZE + 1,
3435                         p_nodes_max.Z / MAP_BLOCKSIZE + 1);
3436
3437         u32 vertex_count = 0;
3438
3439         // For limiting number of mesh updates per frame
3440         u32 mesh_update_count = 0;
3441
3442         u32 blocks_would_have_drawn = 0;
3443         u32 blocks_drawn = 0;
3444
3445         int timecheck_counter = 0;
3446         core::map<v2s16, MapSector*>::Iterator si;
3447         si = m_sectors.getIterator();
3448         for(; si.atEnd() == false; si++)
3449         {
3450                 {
3451                         timecheck_counter++;
3452                         if(timecheck_counter > 50)
3453                         {
3454                                 timecheck_counter = 0;
3455                                 int time2 = time(0);
3456                                 if(time2 > time1 + 4)
3457                                 {
3458                                         dstream<<"ClientMap::renderMap(): "
3459                                                 "Rendering takes ages, returning."
3460                                                 <<std::endl;
3461                                         return;
3462                                 }
3463                         }
3464                 }
3465
3466                 MapSector *sector = si.getNode()->getValue();
3467                 v2s16 sp = sector->getPos();
3468
3469                 if(m_control.range_all == false)
3470                 {
3471                         if(sp.X < p_blocks_min.X
3472                         || sp.X > p_blocks_max.X
3473                         || sp.Y < p_blocks_min.Z
3474                         || sp.Y > p_blocks_max.Z)
3475                                 continue;
3476                 }
3477
3478                 core::list< MapBlock * > sectorblocks;
3479                 sector->getBlocks(sectorblocks);
3480
3481                 /*
3482                         Draw blocks
3483                 */
3484
3485                 u32 sector_blocks_drawn = 0;
3486
3487                 core::list< MapBlock * >::Iterator i;
3488                 for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
3489                 {
3490                         MapBlock *block = *i;
3491
3492                         /*
3493                                 Compare block position to camera position, skip
3494                                 if not seen on display
3495                         */
3496
3497                         float range = 100000 * BS;
3498                         if(m_control.range_all == false)
3499                                 range = m_control.wanted_range * BS;
3500
3501                         float d = 0.0;
3502                         if(isBlockInSight(block->getPos(), camera_position,
3503                                         camera_direction, range, &d) == false)
3504                         {
3505                                 continue;
3506                         }
3507
3508                         // Okay, this block will be drawn. Reset usage timer.
3509                         block->resetUsageTimer();
3510
3511                         // This is ugly (spherical distance limit?)
3512                         /*if(m_control.range_all == false &&
3513                                         d - 0.5*BS*MAP_BLOCKSIZE > range)
3514                                 continue;*/
3515
3516 #if 1
3517                         /*
3518                                 Update expired mesh (used for day/night change)
3519
3520                                 It doesn't work exactly like it should now with the
3521                                 tasked mesh update but whatever.
3522                         */
3523
3524                         bool mesh_expired = false;
3525
3526                         {
3527                                 JMutexAutoLock lock(block->mesh_mutex);
3528
3529                                 mesh_expired = block->getMeshExpired();
3530
3531                                 // Mesh has not been expired and there is no mesh:
3532                                 // block has no content
3533                                 if(block->mesh == NULL && mesh_expired == false)
3534                                         continue;
3535                         }
3536
3537                         f32 faraway = BS*50;
3538                         //f32 faraway = m_control.wanted_range * BS;
3539
3540                         /*
3541                                 This has to be done with the mesh_mutex unlocked
3542                         */
3543                         // Pretty random but this should work somewhat nicely
3544                         if(mesh_expired && (
3545                                         (mesh_update_count < 3
3546                                                 && (d < faraway || mesh_update_count < 2)
3547                                         )
3548                                         ||
3549                                         (m_control.range_all && mesh_update_count < 20)
3550                                 )
3551                         )
3552                         /*if(mesh_expired && mesh_update_count < 6
3553                                         && (d < faraway || mesh_update_count < 3))*/
3554                         {
3555                                 mesh_update_count++;
3556
3557                                 // Mesh has been expired: generate new mesh
3558                                 //block->updateMesh(daynight_ratio);
3559                                 m_client->addUpdateMeshTask(block->getPos());
3560
3561                                 mesh_expired = false;
3562                         }
3563
3564 #endif
3565                         /*
3566                                 Draw the faces of the block
3567                         */
3568                         {
3569                                 JMutexAutoLock lock(block->mesh_mutex);
3570
3571                                 scene::SMesh *mesh = block->mesh;
3572
3573                                 if(mesh == NULL)
3574                                         continue;
3575
3576                                 blocks_would_have_drawn++;
3577                                 if(blocks_drawn >= m_control.wanted_max_blocks
3578                                                 && m_control.range_all == false
3579                                                 && d > m_control.wanted_min_range * BS)
3580                                         continue;
3581
3582                                 blocks_drawn++;
3583                                 sector_blocks_drawn++;
3584
3585                                 u32 c = mesh->getMeshBufferCount();
3586
3587                                 for(u32 i=0; i<c; i++)
3588                                 {
3589                                         scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
3590                                         const video::SMaterial& material = buf->getMaterial();
3591                                         video::IMaterialRenderer* rnd =
3592                                                         driver->getMaterialRenderer(material.MaterialType);
3593                                         bool transparent = (rnd && rnd->isTransparent());
3594                                         // Render transparent on transparent pass and likewise.
3595                                         if(transparent == is_transparent_pass)
3596                                         {
3597                                                 /*
3598                                                         This *shouldn't* hurt too much because Irrlicht
3599                                                         doesn't change opengl textures if the old
3600                                                         material is set again.
3601                                                 */
3602                                                 driver->setMaterial(buf->getMaterial());
3603                                                 driver->drawMeshBuffer(buf);
3604                                                 vertex_count += buf->getVertexCount();
3605                                         }
3606                                 }
3607                         }
3608                 } // foreach sectorblocks
3609
3610                 if(sector_blocks_drawn != 0)
3611                 {
3612                         m_last_drawn_sectors[sp] = true;
3613                 }
3614         }
3615
3616         m_control.blocks_drawn = blocks_drawn;
3617         m_control.blocks_would_have_drawn = blocks_would_have_drawn;
3618
3619         /*dstream<<"renderMap(): is_transparent_pass="<<is_transparent_pass
3620                         <<", rendered "<<vertex_count<<" vertices."<<std::endl;*/
3621 }
3622
3623 bool ClientMap::setTempMod(v3s16 p, NodeMod mod,
3624                 core::map<v3s16, MapBlock*> *affected_blocks)
3625 {
3626         bool changed = false;
3627         /*
3628                 Add it to all blocks touching it
3629         */
3630         v3s16 dirs[7] = {
3631                 v3s16(0,0,0), // this
3632                 v3s16(0,0,1), // back
3633                 v3s16(0,1,0), // top
3634                 v3s16(1,0,0), // right
3635                 v3s16(0,0,-1), // front
3636                 v3s16(0,-1,0), // bottom
3637                 v3s16(-1,0,0), // left
3638         };
3639         for(u16 i=0; i<7; i++)
3640         {
3641                 v3s16 p2 = p + dirs[i];
3642                 // Block position of neighbor (or requested) node
3643                 v3s16 blockpos = getNodeBlockPos(p2);
3644                 MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
3645                 if(blockref == NULL)
3646                         continue;
3647                 // Relative position of requested node
3648                 v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
3649                 if(blockref->setTempMod(relpos, mod))
3650                 {
3651                         changed = true;
3652                 }
3653         }
3654         if(changed && affected_blocks!=NULL)
3655         {
3656                 for(u16 i=0; i<7; i++)
3657                 {
3658                         v3s16 p2 = p + dirs[i];
3659                         // Block position of neighbor (or requested) node
3660                         v3s16 blockpos = getNodeBlockPos(p2);
3661                         MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
3662                         if(blockref == NULL)
3663                                 continue;
3664                         affected_blocks->insert(blockpos, blockref);
3665                 }
3666         }
3667         return changed;
3668 }
3669
3670 bool ClientMap::clearTempMod(v3s16 p,
3671                 core::map<v3s16, MapBlock*> *affected_blocks)
3672 {
3673         bool changed = false;
3674         v3s16 dirs[7] = {
3675                 v3s16(0,0,0), // this
3676                 v3s16(0,0,1), // back
3677                 v3s16(0,1,0), // top
3678                 v3s16(1,0,0), // right
3679                 v3s16(0,0,-1), // front
3680                 v3s16(0,-1,0), // bottom
3681                 v3s16(-1,0,0), // left
3682         };
3683         for(u16 i=0; i<7; i++)
3684         {
3685                 v3s16 p2 = p + dirs[i];
3686                 // Block position of neighbor (or requested) node
3687                 v3s16 blockpos = getNodeBlockPos(p2);
3688                 MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
3689                 if(blockref == NULL)
3690                         continue;
3691                 // Relative position of requested node
3692                 v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
3693                 if(blockref->clearTempMod(relpos))
3694                 {
3695                         changed = true;
3696                 }
3697         }
3698         if(changed && affected_blocks!=NULL)
3699         {
3700                 for(u16 i=0; i<7; i++)
3701                 {
3702                         v3s16 p2 = p + dirs[i];
3703                         // Block position of neighbor (or requested) node
3704                         v3s16 blockpos = getNodeBlockPos(p2);
3705                         MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
3706                         if(blockref == NULL)
3707                                 continue;
3708                         affected_blocks->insert(blockpos, blockref);
3709                 }
3710         }
3711         return changed;
3712 }
3713
3714 void ClientMap::expireMeshes(bool only_daynight_diffed)
3715 {
3716         TimeTaker timer("expireMeshes()");
3717
3718         core::map<v2s16, MapSector*>::Iterator si;
3719         si = m_sectors.getIterator();
3720         for(; si.atEnd() == false; si++)
3721         {
3722                 MapSector *sector = si.getNode()->getValue();
3723
3724                 core::list< MapBlock * > sectorblocks;
3725                 sector->getBlocks(sectorblocks);
3726
3727                 core::list< MapBlock * >::Iterator i;
3728                 for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
3729                 {
3730                         MapBlock *block = *i;
3731
3732                         if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false)
3733                         {
3734                                 continue;
3735                         }
3736
3737                         {
3738                                 JMutexAutoLock lock(block->mesh_mutex);
3739                                 if(block->mesh != NULL)
3740                                 {
3741                                         /*block->mesh->drop();
3742                                         block->mesh = NULL;*/
3743                                         block->setMeshExpired(true);
3744                                 }
3745                         }
3746                 }
3747         }
3748 }
3749
3750 void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio)
3751 {
3752         assert(mapType() == MAPTYPE_CLIENT);
3753
3754         try{
3755                 v3s16 p = blockpos + v3s16(0,0,0);
3756                 MapBlock *b = getBlockNoCreate(p);
3757                 b->updateMesh(daynight_ratio);
3758                 //b->setMeshExpired(true);
3759         }
3760         catch(InvalidPositionException &e){}
3761         // Leading edge
3762         try{
3763                 v3s16 p = blockpos + v3s16(-1,0,0);
3764                 MapBlock *b = getBlockNoCreate(p);
3765                 b->updateMesh(daynight_ratio);
3766                 //b->setMeshExpired(true);
3767         }
3768         catch(InvalidPositionException &e){}
3769         try{
3770                 v3s16 p = blockpos + v3s16(0,-1,0);
3771                 MapBlock *b = getBlockNoCreate(p);
3772                 b->updateMesh(daynight_ratio);
3773                 //b->setMeshExpired(true);
3774         }
3775         catch(InvalidPositionException &e){}
3776         try{
3777                 v3s16 p = blockpos + v3s16(0,0,-1);
3778                 MapBlock *b = getBlockNoCreate(p);
3779                 b->updateMesh(daynight_ratio);
3780                 //b->setMeshExpired(true);
3781         }
3782         catch(InvalidPositionException &e){}
3783 }
3784
3785 #if 0
3786 /*
3787         Update mesh of block in which the node is, and if the node is at the
3788         leading edge, update the appropriate leading blocks too.
3789 */
3790 void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio)
3791 {
3792         v3s16 dirs[4] = {
3793                 v3s16(0,0,0),
3794                 v3s16(-1,0,0),
3795                 v3s16(0,-1,0),
3796                 v3s16(0,0,-1),
3797         };
3798         v3s16 blockposes[4];
3799         for(u32 i=0; i<4; i++)
3800         {
3801                 v3s16 np = nodepos + dirs[i];
3802                 blockposes[i] = getNodeBlockPos(np);
3803                 // Don't update mesh of block if it has been done already
3804                 bool already_updated = false;
3805                 for(u32 j=0; j<i; j++)
3806                 {
3807                         if(blockposes[j] == blockposes[i])
3808                         {
3809                                 already_updated = true;
3810                                 break;
3811                         }
3812                 }
3813                 if(already_updated)
3814                         continue;
3815                 // Update mesh
3816                 MapBlock *b = getBlockNoCreate(blockposes[i]);
3817                 b->updateMesh(daynight_ratio);
3818         }
3819 }
3820 #endif
3821
3822 void ClientMap::PrintInfo(std::ostream &out)
3823 {
3824         out<<"ClientMap: ";
3825 }
3826
3827 #endif // !SERVER
3828
3829 /*
3830         MapVoxelManipulator
3831 */
3832
3833 MapVoxelManipulator::MapVoxelManipulator(Map *map)
3834 {
3835         m_map = map;
3836 }
3837
3838 MapVoxelManipulator::~MapVoxelManipulator()
3839 {
3840         /*dstream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
3841                         <<std::endl;*/
3842 }
3843
3844 void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
3845 {
3846         TimeTaker timer1("emerge", &emerge_time);
3847
3848         // Units of these are MapBlocks
3849         v3s16 p_min = getNodeBlockPos(a.MinEdge);
3850         v3s16 p_max = getNodeBlockPos(a.MaxEdge);
3851
3852         VoxelArea block_area_nodes
3853                         (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
3854
3855         addArea(block_area_nodes);
3856
3857         for(s32 z=p_min.Z; z<=p_max.Z; z++)
3858         for(s32 y=p_min.Y; y<=p_max.Y; y++)
3859         for(s32 x=p_min.X; x<=p_max.X; x++)
3860         {
3861                 v3s16 p(x,y,z);
3862                 core::map<v3s16, bool>::Node *n;
3863                 n = m_loaded_blocks.find(p);
3864                 if(n != NULL)
3865                         continue;
3866
3867                 bool block_data_inexistent = false;
3868                 try
3869                 {
3870                         TimeTaker timer1("emerge load", &emerge_load_time);
3871
3872                         /*dstream<<"Loading block (caller_id="<<caller_id<<")"
3873                                         <<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
3874                                         <<" wanted area: ";
3875                         a.print(dstream);
3876                         dstream<<std::endl;*/
3877
3878                         MapBlock *block = m_map->getBlockNoCreate(p);
3879                         if(block->isDummy())
3880                                 block_data_inexistent = true;
3881                         else
3882                                 block->copyTo(*this);
3883                 }
3884                 catch(InvalidPositionException &e)
3885                 {
3886                         block_data_inexistent = true;
3887                 }
3888
3889                 if(block_data_inexistent)
3890                 {
3891                         VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
3892                         // Fill with VOXELFLAG_INEXISTENT
3893                         for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
3894                         for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
3895                         {
3896                                 s32 i = m_area.index(a.MinEdge.X,y,z);
3897                                 memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
3898                         }
3899                 }
3900
3901                 m_loaded_blocks.insert(p, !block_data_inexistent);
3902         }
3903
3904         //dstream<<"emerge done"<<std::endl;
3905 }
3906
3907 /*
3908         SUGG: Add an option to only update eg. water and air nodes.
3909               This will make it interfere less with important stuff if
3910                   run on background.
3911 */
3912 void MapVoxelManipulator::blitBack
3913                 (core::map<v3s16, MapBlock*> & modified_blocks)
3914 {
3915         if(m_area.getExtent() == v3s16(0,0,0))
3916                 return;
3917
3918         //TimeTaker timer1("blitBack");
3919
3920         /*dstream<<"blitBack(): m_loaded_blocks.size()="
3921                         <<m_loaded_blocks.size()<<std::endl;*/
3922
3923         /*
3924                 Initialize block cache
3925         */
3926         v3s16 blockpos_last;
3927         MapBlock *block = NULL;
3928         bool block_checked_in_modified = false;
3929
3930         for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
3931         for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
3932         for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
3933         {
3934                 v3s16 p(x,y,z);
3935
3936                 u8 f = m_flags[m_area.index(p)];
3937                 if(f & (VOXELFLAG_NOT_LOADED|VOXELFLAG_INEXISTENT))
3938                         continue;
3939
3940                 MapNode &n = m_data[m_area.index(p)];
3941
3942                 v3s16 blockpos = getNodeBlockPos(p);
3943
3944                 try
3945                 {
3946                         // Get block
3947                         if(block == NULL || blockpos != blockpos_last){
3948                                 block = m_map->getBlockNoCreate(blockpos);
3949                                 blockpos_last = blockpos;
3950                                 block_checked_in_modified = false;
3951                         }
3952
3953                         // Calculate relative position in block
3954                         v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
3955
3956                         // Don't continue if nothing has changed here
3957                         if(block->getNode(relpos) == n)
3958                                 continue;
3959
3960                         //m_map->setNode(m_area.MinEdge + p, n);
3961                         block->setNode(relpos, n);
3962
3963                         /*
3964                                 Make sure block is in modified_blocks
3965                         */
3966                         if(block_checked_in_modified == false)
3967                         {
3968                                 modified_blocks[blockpos] = block;
3969                                 block_checked_in_modified = true;
3970                         }
3971                 }
3972                 catch(InvalidPositionException &e)
3973                 {
3974                 }
3975         }
3976 }
3977
3978 ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
3979                 MapVoxelManipulator(map),
3980                 m_create_area(false)
3981 {
3982 }
3983
3984 ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
3985 {
3986 }
3987
3988 void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
3989 {
3990         // Just create the area so that it can be pointed to
3991         VoxelManipulator::emerge(a, caller_id);
3992 }
3993
3994 void ManualMapVoxelManipulator::initialEmerge(
3995                 v3s16 blockpos_min, v3s16 blockpos_max)
3996 {
3997         TimeTaker timer1("initialEmerge", &emerge_time);
3998
3999         // Units of these are MapBlocks
4000         v3s16 p_min = blockpos_min;
4001         v3s16 p_max = blockpos_max;
4002
4003         VoxelArea block_area_nodes
4004                         (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
4005
4006         u32 size_MB = block_area_nodes.getVolume()*4/1000000;
4007         if(size_MB >= 1)
4008         {
4009                 dstream<<"initialEmerge: area: ";
4010                 block_area_nodes.print(dstream);
4011                 dstream<<" ("<<size_MB<<"MB)";
4012                 dstream<<std::endl;
4013         }
4014
4015         addArea(block_area_nodes);
4016
4017         for(s32 z=p_min.Z; z<=p_max.Z; z++)
4018         for(s32 y=p_min.Y; y<=p_max.Y; y++)
4019         for(s32 x=p_min.X; x<=p_max.X; x++)
4020         {
4021                 v3s16 p(x,y,z);
4022                 core::map<v3s16, bool>::Node *n;
4023                 n = m_loaded_blocks.find(p);
4024                 if(n != NULL)
4025                         continue;
4026
4027                 bool block_data_inexistent = false;
4028                 try
4029                 {
4030                         TimeTaker timer1("emerge load", &emerge_load_time);
4031
4032                         MapBlock *block = m_map->getBlockNoCreate(p);
4033                         if(block->isDummy())
4034                                 block_data_inexistent = true;
4035                         else
4036                                 block->copyTo(*this);
4037                 }
4038                 catch(InvalidPositionException &e)
4039                 {
4040                         block_data_inexistent = true;
4041                 }
4042
4043                 if(block_data_inexistent)
4044                 {
4045                         /*
4046                                 Mark area inexistent
4047                         */
4048                         VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
4049                         // Fill with VOXELFLAG_INEXISTENT
4050                         for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
4051                         for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
4052                         {
4053                                 s32 i = m_area.index(a.MinEdge.X,y,z);
4054                                 memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
4055                         }
4056                 }
4057
4058                 m_loaded_blocks.insert(p, !block_data_inexistent);
4059         }
4060 }
4061
4062 void ManualMapVoxelManipulator::blitBackAll(
4063                 core::map<v3s16, MapBlock*> * modified_blocks)
4064 {
4065         if(m_area.getExtent() == v3s16(0,0,0))
4066                 return;
4067
4068         /*
4069                 Copy data of all blocks
4070         */
4071         for(core::map<v3s16, bool>::Iterator
4072                         i = m_loaded_blocks.getIterator();
4073                         i.atEnd() == false; i++)
4074         {
4075                 bool existed = i.getNode()->getValue();
4076                 if(existed == false)
4077                         continue;
4078                 v3s16 p = i.getNode()->getKey();
4079                 MapBlock *block = m_map->getBlockNoCreateNoEx(p);
4080                 if(block == NULL)
4081                 {
4082                         dstream<<"WARNING: "<<__FUNCTION_NAME
4083                                         <<": got NULL block "
4084                                         <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
4085                                         <<std::endl;
4086                         continue;
4087                 }
4088
4089                 block->copyFrom(*this);
4090
4091                 if(modified_blocks)
4092                         modified_blocks->insert(p, block);
4093         }
4094 }
4095
4096 //END