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