src/mapblock.h

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifndef MAPBLOCK_HEADER
  21 #define MAPBLOCK_HEADER
  22
  23 #include <set>
  24 #include "debug.h"
  25 #include "irr_v3d.h"
  26 #include "mapnode.h"
  27 #include "exceptions.h"
  28 #include "constants.h"
  29 #include "staticobject.h"
  30 #include "nodemetadata.h"
  31 #include "nodetimer.h"
  32 #include "modifiedstate.h"
  33 #include "util/numeric.h" // getContainerPos
  34
  35 class Map;
  36 class NodeMetadataList;
  37 class IGameDef;
  38 class MapBlockMesh;
  39 class VoxelManipulator;
  40
  41 #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
  42
  43 /*// Named by looking towards z+
  44 enum{
  45         FACE_BACK=0,
  46         FACE_TOP,
  47         FACE_RIGHT,
  48         FACE_FRONT,
  49         FACE_BOTTOM,
  50         FACE_LEFT
  51 };*/
  52
  53 // NOTE: If this is enabled, set MapBlock to be initialized with
  54 //       CONTENT_IGNORE.
  55 /*enum BlockGenerationStatus
  56 {
  57         // Completely non-generated (filled with CONTENT_IGNORE).
  58         BLOCKGEN_UNTOUCHED=0,
  59         // Trees or similar might have been blitted from other blocks to here.
  60         // Otherwise, the block contains CONTENT_IGNORE
  61         BLOCKGEN_FROM_NEIGHBORS=2,
  62         // Has been generated, but some neighbors might put some stuff in here
  63         // when they are generated.
  64         // Does not contain any CONTENT_IGNORE
  65         BLOCKGEN_SELF_GENERATED=4,
  66         // The block and all its neighbors have been generated
  67         BLOCKGEN_FULLY_GENERATED=6
  68 };*/
  69
  70 #if 0
  71 enum
  72 {
  73         NODECONTAINER_ID_MAPBLOCK,
  74         NODECONTAINER_ID_MAPSECTOR,
  75         NODECONTAINER_ID_MAP,
  76         NODECONTAINER_ID_MAPBLOCKCACHE,
  77         NODECONTAINER_ID_VOXELMANIPULATOR,
  78 };
  79
  80 class NodeContainer
  81 {
  82 public:
  83         virtual bool isValidPosition(v3s16 p) = 0;
  84         virtual MapNode getNode(v3s16 p) = 0;
  85         virtual void setNode(v3s16 p, MapNode & n) = 0;
  86         virtual u16 nodeContainerId() const = 0;
  87
  88         MapNode getNodeNoEx(v3s16 p)
  89         {
  90                 try{
  91                         return getNode(p);
  92                 }
  93                 catch(InvalidPositionException &e){
  94                         return MapNode(CONTENT_IGNORE);
  95                 }
  96         }
  97 };
  98 #endif
  99
 100 /*
 101         MapBlock itself
 102 */
 103
 104 class MapBlock /*: public NodeContainer*/
 105 {
 106 public:
 107         MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
 108         ~MapBlock();
 109
 110         /*virtual u16 nodeContainerId() const
 111         {
 112                 return NODECONTAINER_ID_MAPBLOCK;
 113         }*/
 114
 115         Map * getParent()
 116         {
 117                 return m_parent;
 118         }
 119
 120         void reallocate()
 121         {
 122                 if(data != NULL)
 123                         delete[] data;
 124                 u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
 125                 data = new MapNode[l];
 126                 for(u32 i=0; i<l; i++){
 127                         //data[i] = MapNode();
 128                         data[i] = MapNode(CONTENT_IGNORE);
 129                 }
 130                 raiseModified(MOD_STATE_WRITE_NEEDED, "reallocate");
 131         }
 132
 133         /*
 134                 Flags
 135         */
 136
 137         bool isDummy()
 138         {
 139                 return (data == NULL);
 140         }
 141         void unDummify()
 142         {
 143                 assert(isDummy());
 144                 reallocate();
 145         }
 146
 147         // m_modified methods
 148         void raiseModified(u32 mod, const std::string &reason="unknown")
 149         {
 150                 if(mod > m_modified){
 151                         m_modified = mod;
 152                         m_modified_reason = reason;
 153                         m_modified_reason_too_long = false;
 154
 155                         if(m_modified >= MOD_STATE_WRITE_AT_UNLOAD){
 156                                 m_disk_timestamp = m_timestamp;
 157                         }
 158                 } else if(mod == m_modified){
 159                         if(!m_modified_reason_too_long){
 160                                 if(m_modified_reason.size() < 40)
 161                                         m_modified_reason += ", " + reason;
 162                                 else{
 163                                         m_modified_reason += "...";
 164                                         m_modified_reason_too_long = true;
 165                                 }
 166                         }
 167                 }
 168         }
 169         void raiseModified(u32 mod, const char *reason)
 170         {
 171                 if (mod > m_modified){
 172                         m_modified = mod;
 173                         m_modified_reason = reason;
 174                         m_modified_reason_too_long = false;
 175
 176                         if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD){
 177                                 m_disk_timestamp = m_timestamp;
 178                         }
 179                 }
 180                 else if (mod == m_modified){
 181                         if (!m_modified_reason_too_long){
 182                                 if (m_modified_reason.size() < 40)
 183                                         m_modified_reason += ", " + std::string(reason);
 184                                 else{
 185                                         m_modified_reason += "...";
 186                                         m_modified_reason_too_long = true;
 187                                 }
 188                         }
 189                 }
 190         }
 191
 192         u32 getModified()
 193         {
 194                 return m_modified;
 195         }
 196         std::string getModifiedReason()
 197         {
 198                 return m_modified_reason;
 199         }
 200         void resetModified()
 201         {
 202                 m_modified = MOD_STATE_CLEAN;
 203                 m_modified_reason = "none";
 204                 m_modified_reason_too_long = false;
 205         }
 206
 207         // is_underground getter/setter
 208         bool getIsUnderground()
 209         {
 210                 return is_underground;
 211         }
 212         void setIsUnderground(bool a_is_underground)
 213         {
 214                 is_underground = a_is_underground;
 215                 raiseModified(MOD_STATE_WRITE_NEEDED, "setIsUnderground");
 216         }
 217
 218         void setLightingExpired(bool expired)
 219         {
 220                 if(expired != m_lighting_expired){
 221                         m_lighting_expired = expired;
 222                         raiseModified(MOD_STATE_WRITE_NEEDED, "setLightingExpired");
 223                 }
 224         }
 225         bool getLightingExpired()
 226         {
 227                 return m_lighting_expired;
 228         }
 229
 230         bool isGenerated()
 231         {
 232                 return m_generated;
 233         }
 234         void setGenerated(bool b)
 235         {
 236                 if(b != m_generated){
 237                         raiseModified(MOD_STATE_WRITE_NEEDED, "setGenerated");
 238                         m_generated = b;
 239                 }
 240         }
 241
 242         bool isValid()
 243         {
 244                 if(m_lighting_expired)
 245                         return false;
 246                 if(data == NULL)
 247                         return false;
 248                 return true;
 249         }
 250
 251         /*
 252                 Position stuff
 253         */
 254
 255         v3s16 getPos()
 256         {
 257                 return m_pos;
 258         }
 259
 260         v3s16 getPosRelative()
 261         {
 262                 return m_pos * MAP_BLOCKSIZE;
 263         }
 264
 265         core::aabbox3d<s16> getBox()
 266         {
 267                 return core::aabbox3d<s16>(getPosRelative(),
 268                                 getPosRelative()
 269                                 + v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
 270                                 - v3s16(1,1,1));
 271         }
 272
 273         /*
 274                 Regular MapNode get-setters
 275         */
 276
 277         bool isValidPosition(s16 x, s16 y, s16 z)
 278         {
 279                 return data != NULL
 280                                 && x >= 0 && x < MAP_BLOCKSIZE
 281                                 && y >= 0 && y < MAP_BLOCKSIZE
 282                                 && z >= 0 && z < MAP_BLOCKSIZE;
 283         }
 284
 285         bool isValidPosition(v3s16 p)
 286         {
 287                 return isValidPosition(p.X, p.Y, p.Z);
 288         }
 289
 290         MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
 291         {
 292                 *valid_position = isValidPosition(x, y, z);
 293
 294                 if (!*valid_position)
 295                         return MapNode(CONTENT_IGNORE);
 296
 297                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 298         }
 299
 300         MapNode getNode(v3s16 p, bool *valid_position)
 301         {
 302                 return getNode(p.X, p.Y, p.Z, valid_position);
 303         }
 304
 305         MapNode getNodeNoEx(v3s16 p)
 306         {
 307                 bool is_valid;
 308                 MapNode node = getNode(p.X, p.Y, p.Z, &is_valid);
 309                 return is_valid ? node : MapNode(CONTENT_IGNORE);
 310         }
 311
 312         void setNode(s16 x, s16 y, s16 z, MapNode & n)
 313         {
 314                 if(data == NULL)
 315                         throw InvalidPositionException();
 316                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 317                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 318                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 319                 data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
 320                 raiseModified(MOD_STATE_WRITE_NEEDED, "setNode");
 321         }
 322
 323         void setNode(v3s16 p, MapNode & n)
 324         {
 325                 setNode(p.X, p.Y, p.Z, n);
 326         }
 327
 328         /*
 329                 Non-checking variants of the above
 330         */
 331
 332         MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position)
 333         {
 334                 *valid_position = data != NULL;
 335                 if(!valid_position)
 336                         return MapNode(CONTENT_IGNORE);
 337
 338                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 339         }
 340
 341         MapNode getNodeNoCheck(v3s16 p, bool *valid_position)
 342         {
 343                 return getNodeNoCheck(p.X, p.Y, p.Z, valid_position);
 344         }
 345
 346         void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
 347         {
 348                 if(data == NULL)
 349                         throw InvalidPositionException();
 350                 data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
 351                 raiseModified(MOD_STATE_WRITE_NEEDED, "setNodeNoCheck");
 352         }
 353
 354         void setNodeNoCheck(v3s16 p, MapNode & n)
 355         {
 356                 setNodeNoCheck(p.X, p.Y, p.Z, n);
 357         }
 358
 359         /*
 360                 These functions consult the parent container if the position
 361                 is not valid on this MapBlock.
 362         */
 363         bool isValidPositionParent(v3s16 p);
 364         MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL);
 365         void setNodeParent(v3s16 p, MapNode & n);
 366
 367         void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
 368         {
 369                 for(u16 z=0; z<d; z++)
 370                         for(u16 y=0; y<h; y++)
 371                                 for(u16 x=0; x<w; x++)
 372                                         setNode(x0+x, y0+y, z0+z, node);
 373         }
 374
 375         // See comments in mapblock.cpp
 376         bool propagateSunlight(std::set<v3s16> & light_sources,
 377                         bool remove_light=false, bool *black_air_left=NULL);
 378
 379         // Copies data to VoxelManipulator to getPosRelative()
 380         void copyTo(VoxelManipulator &dst);
 381         // Copies data from VoxelManipulator getPosRelative()
 382         void copyFrom(VoxelManipulator &dst);
 383
 384         /*
 385                 Update day-night lighting difference flag.
 386                 Sets m_day_night_differs to appropriate value.
 387                 These methods don't care about neighboring blocks.
 388         */
 389         void actuallyUpdateDayNightDiff();
 390         /*
 391                 Call this to schedule what the previous function does to be done
 392                 when the value is actually needed.
 393         */
 394         void expireDayNightDiff();
 395
 396         bool getDayNightDiff()
 397         {
 398                 if(m_day_night_differs_expired)
 399                         actuallyUpdateDayNightDiff();
 400                 return m_day_night_differs;
 401         }
 402
 403         /*
 404                 Miscellaneous stuff
 405         */
 406
 407         /*
 408                 Tries to measure ground level.
 409                 Return value:
 410                         -1 = only air
 411                         -2 = only ground
 412                         -3 = random fail
 413                         0...MAP_BLOCKSIZE-1 = ground level
 414         */
 415         s16 getGroundLevel(v2s16 p2d);
 416
 417         /*
 418                 Timestamp (see m_timestamp)
 419                 NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 420         */
 421         void setTimestamp(u32 time)
 422         {
 423                 m_timestamp = time;
 424                 raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "setTimestamp");
 425         }
 426         void setTimestampNoChangedFlag(u32 time)
 427         {
 428                 m_timestamp = time;
 429         }
 430         u32 getTimestamp()
 431         {
 432                 return m_timestamp;
 433         }
 434         u32 getDiskTimestamp()
 435         {
 436                 return m_disk_timestamp;
 437         }
 438
 439         /*
 440                 See m_usage_timer
 441         */
 442         void resetUsageTimer()
 443         {
 444                 m_usage_timer = 0;
 445         }
 446         void incrementUsageTimer(float dtime)
 447         {
 448                 m_usage_timer += dtime;
 449         }
 450         float getUsageTimer()
 451         {
 452                 return m_usage_timer;
 453         }
 454
 455         /*
 456                 See m_refcount
 457         */
 458         void refGrab()
 459         {
 460                 m_refcount++;
 461         }
 462         void refDrop()
 463         {
 464                 m_refcount--;
 465         }
 466         int refGet()
 467         {
 468                 return m_refcount;
 469         }
 470
 471         /*
 472                 Node Timers
 473         */
 474         // Get timer
 475         NodeTimer getNodeTimer(v3s16 p){
 476                 return m_node_timers.get(p);
 477         }
 478         // Deletes timer
 479         void removeNodeTimer(v3s16 p){
 480                 m_node_timers.remove(p);
 481         }
 482         // Deletes old timer and sets a new one
 483         void setNodeTimer(v3s16 p, NodeTimer t){
 484                 m_node_timers.set(p,t);
 485         }
 486         // Deletes all timers
 487         void clearNodeTimers(){
 488                 m_node_timers.clear();
 489         }
 490
 491         /*
 492                 Serialization
 493         */
 494
 495         // These don't write or read version by itself
 496         // Set disk to true for on-disk format, false for over-the-network format
 497         void serialize(std::ostream &os, u8 version, bool disk);
 498         // If disk == true: In addition to doing other things, will add
 499         // unknown blocks from id-name mapping to wndef
 500         void deSerialize(std::istream &is, u8 version, bool disk);
 501
 502         void serializeNetworkSpecific(std::ostream &os, u16 net_proto_version);
 503         void deSerializeNetworkSpecific(std::istream &is);
 504
 505 private:
 506         /*
 507                 Private methods
 508         */
 509
 510         void deSerialize_pre22(std::istream &is, u8 version, bool disk);
 511
 512         /*
 513                 Used only internally, because changes can't be tracked
 514         */
 515
 516         MapNode & getNodeRef(s16 x, s16 y, s16 z)
 517         {
 518                 if(data == NULL)
 519                         throw InvalidPositionException();
 520                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 521                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 522                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 523                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 524         }
 525         MapNode & getNodeRef(v3s16 &p)
 526         {
 527                 return getNodeRef(p.X, p.Y, p.Z);
 528         }
 529
 530 public:
 531         /*
 532                 Public member variables
 533         */
 534
 535 #ifndef SERVER // Only on client
 536         MapBlockMesh *mesh;
 537 #endif
 538
 539         NodeMetadataList m_node_metadata;
 540         NodeTimerList m_node_timers;
 541         StaticObjectList m_static_objects;
 542
 543 private:
 544         /*
 545                 Private member variables
 546         */
 547
 548         // NOTE: Lots of things rely on this being the Map
 549         Map *m_parent;
 550         // Position in blocks on parent
 551         v3s16 m_pos;
 552
 553         IGameDef *m_gamedef;
 554
 555         /*
 556                 If NULL, block is a dummy block.
 557                 Dummy blocks are used for caching not-found-on-disk blocks.
 558         */
 559         MapNode * data;
 560
 561         /*
 562                 - On the server, this is used for telling whether the
 563                   block has been modified from the one on disk.
 564                 - On the client, this is used for nothing.
 565         */
 566         u32 m_modified;
 567         std::string m_modified_reason;
 568         bool m_modified_reason_too_long;
 569
 570         /*
 571                 When propagating sunlight and the above block doesn't exist,
 572                 sunlight is assumed if this is false.
 573
 574                 In practice this is set to true if the block is completely
 575                 undeground with nothing visible above the ground except
 576                 caves.
 577         */
 578         bool is_underground;
 579
 580         /*
 581                 Set to true if changes has been made that make the old lighting
 582                 values wrong but the lighting hasn't been actually updated.
 583
 584                 If this is false, lighting is exactly right.
 585                 If this is true, lighting might be wrong or right.
 586         */
 587         bool m_lighting_expired;
 588
 589         // Whether day and night lighting differs
 590         bool m_day_night_differs;
 591         bool m_day_night_differs_expired;
 592
 593         bool m_generated;
 594
 595         /*
 596                 When block is removed from active blocks, this is set to gametime.
 597                 Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 598         */
 599         u32 m_timestamp;
 600         // The on-disk (or to-be on-disk) timestamp value
 601         u32 m_disk_timestamp;
 602
 603         /*
 604                 When the block is accessed, this is set to 0.
 605                 Map will unload the block when this reaches a timeout.
 606         */
 607         float m_usage_timer;
 608
 609         /*
 610                 Reference count; currently used for determining if this block is in
 611                 the list of blocks to be drawn.
 612         */
 613         int m_refcount;
 614 };
 615
 616 inline bool blockpos_over_limit(v3s16 p)
 617 {
 618         return
 619           (p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 620         || p.X >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 621         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 622         || p.Y >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 623         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 624         || p.Z >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE);
 625 }
 626
 627 /*
 628         Returns the position of the block where the node is located
 629 */
 630 inline v3s16 getNodeBlockPos(v3s16 p)
 631 {
 632         return getContainerPos(p, MAP_BLOCKSIZE);
 633 }
 634
 635 inline v2s16 getNodeSectorPos(v2s16 p)
 636 {
 637         return getContainerPos(p, MAP_BLOCKSIZE);
 638 }
 639
 640 inline s16 getNodeBlockY(s16 y)
 641 {
 642         return getContainerPos(y, MAP_BLOCKSIZE);
 643 }
 644
 645 inline void getNodeBlockPosWithOffset(const v3s16 &p, v3s16 &block, v3s16 &offset)
 646 {
 647         getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
 648 }
 649
 650 inline void getNodeSectorPosWithOffset(const v2s16 &p, v2s16 &block, v2s16 &offset)
 651 {
 652         getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
 653 }
 654
 655 /*
 656         Get a quick string to describe what a block actually contains
 657 */
 658 std::string analyze_block(MapBlock *block);
 659
 660 #endif
 661