src/mapblock.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 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 #ifndef MAPBLOCK_HEADER
  21 #define MAPBLOCK_HEADER
  22
  23 #include <jmutex.h>
  24 #include <jmutexautolock.h>
  25 #include <exception>
  26 #include "debug.h"
  27 #include "common_irrlicht.h"
  28 #include "mapnode.h"
  29 #include "exceptions.h"
  30 #include "serialization.h"
  31 #include "constants.h"
  32 #include "voxel.h"
  33 #include "staticobject.h"
  34 #include "modifiedstate.h"
  35
  36 class Map;
  37 class NodeMetadataList;
  38 class IGameDef;
  39 class MapBlockMesh;
  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         u32 getModified()
 170         {
 171                 return m_modified;
 172         }
 173         std::string getModifiedReason()
 174         {
 175                 return m_modified_reason;
 176         }
 177         void resetModified()
 178         {
 179                 m_modified = MOD_STATE_CLEAN;
 180                 m_modified_reason = "none";
 181                 m_modified_reason_too_long = false;
 182         }
 183
 184         // is_underground getter/setter
 185         bool getIsUnderground()
 186         {
 187                 return is_underground;
 188         }
 189         void setIsUnderground(bool a_is_underground)
 190         {
 191                 is_underground = a_is_underground;
 192                 raiseModified(MOD_STATE_WRITE_NEEDED, "setIsUnderground");
 193         }
 194
 195         void setLightingExpired(bool expired)
 196         {
 197                 if(expired != m_lighting_expired){
 198                         m_lighting_expired = expired;
 199                         raiseModified(MOD_STATE_WRITE_NEEDED, "setLightingExpired");
 200                 }
 201         }
 202         bool getLightingExpired()
 203         {
 204                 return m_lighting_expired;
 205         }
 206
 207         bool isGenerated()
 208         {
 209                 return m_generated;
 210         }
 211         void setGenerated(bool b)
 212         {
 213                 if(b != m_generated){
 214                         raiseModified(MOD_STATE_WRITE_NEEDED, "setGenerated");
 215                         m_generated = b;
 216                 }
 217         }
 218
 219         bool isValid()
 220         {
 221                 if(m_lighting_expired)
 222                         return false;
 223                 if(data == NULL)
 224                         return false;
 225                 return true;
 226         }
 227
 228         /*
 229                 Position stuff
 230         */
 231
 232         v3s16 getPos()
 233         {
 234                 return m_pos;
 235         }
 236
 237         v3s16 getPosRelative()
 238         {
 239                 return m_pos * MAP_BLOCKSIZE;
 240         }
 241
 242         core::aabbox3d<s16> getBox()
 243         {
 244                 return core::aabbox3d<s16>(getPosRelative(),
 245                                 getPosRelative()
 246                                 + v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
 247                                 - v3s16(1,1,1));
 248         }
 249
 250         /*
 251                 Regular MapNode get-setters
 252         */
 253
 254         bool isValidPosition(v3s16 p)
 255         {
 256                 if(data == NULL)
 257                         return false;
 258                 return (p.X >= 0 && p.X < MAP_BLOCKSIZE
 259                                 && p.Y >= 0 && p.Y < MAP_BLOCKSIZE
 260                                 && p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
 261         }
 262
 263         MapNode getNode(s16 x, s16 y, s16 z)
 264         {
 265                 if(data == NULL)
 266                         throw InvalidPositionException();
 267                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 268                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 269                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 270                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 271         }
 272
 273         MapNode getNode(v3s16 p)
 274         {
 275                 return getNode(p.X, p.Y, p.Z);
 276         }
 277
 278         MapNode getNodeNoEx(v3s16 p)
 279         {
 280                 try{
 281                         return getNode(p.X, p.Y, p.Z);
 282                 }catch(InvalidPositionException &e){
 283                         return MapNode(CONTENT_IGNORE);
 284                 }
 285         }
 286
 287         void setNode(s16 x, s16 y, s16 z, MapNode & n)
 288         {
 289                 if(data == NULL)
 290                         throw InvalidPositionException();
 291                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 292                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 293                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 294                 data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
 295                 raiseModified(MOD_STATE_WRITE_NEEDED, "setNode");
 296         }
 297
 298         void setNode(v3s16 p, MapNode & n)
 299         {
 300                 setNode(p.X, p.Y, p.Z, n);
 301         }
 302
 303         /*
 304                 Non-checking variants of the above
 305         */
 306
 307         MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
 308         {
 309                 if(data == NULL)
 310                         throw InvalidPositionException();
 311                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 312         }
 313
 314         MapNode getNodeNoCheck(v3s16 p)
 315         {
 316                 return getNodeNoCheck(p.X, p.Y, p.Z);
 317         }
 318
 319         void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
 320         {
 321                 if(data == NULL)
 322                         throw InvalidPositionException();
 323                 data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
 324                 raiseModified(MOD_STATE_WRITE_NEEDED, "setNodeNoCheck");
 325         }
 326
 327         void setNodeNoCheck(v3s16 p, MapNode & n)
 328         {
 329                 setNodeNoCheck(p.X, p.Y, p.Z, n);
 330         }
 331
 332         /*
 333                 These functions consult the parent container if the position
 334                 is not valid on this MapBlock.
 335         */
 336         bool isValidPositionParent(v3s16 p);
 337         MapNode getNodeParent(v3s16 p);
 338         void setNodeParent(v3s16 p, MapNode & n);
 339         MapNode getNodeParentNoEx(v3s16 p);
 340
 341         void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
 342         {
 343                 for(u16 z=0; z<d; z++)
 344                         for(u16 y=0; y<h; y++)
 345                                 for(u16 x=0; x<w; x++)
 346                                         setNode(x0+x, y0+y, z0+z, node);
 347         }
 348
 349         // See comments in mapblock.cpp
 350         bool propagateSunlight(core::map<v3s16, bool> & light_sources,
 351                         bool remove_light=false, bool *black_air_left=NULL);
 352
 353         // Copies data to VoxelManipulator to getPosRelative()
 354         void copyTo(VoxelManipulator &dst);
 355         // Copies data from VoxelManipulator getPosRelative()
 356         void copyFrom(VoxelManipulator &dst);
 357
 358         /*
 359                 Update day-night lighting difference flag.
 360                 Sets m_day_night_differs to appropriate value.
 361                 These methods don't care about neighboring blocks.
 362         */
 363         void actuallyUpdateDayNightDiff();
 364         /*
 365                 Call this to schedule what the previous function does to be done
 366                 when the value is actually needed.
 367         */
 368         void expireDayNightDiff();
 369
 370         bool getDayNightDiff()
 371         {
 372                 if(m_day_night_differs_expired)
 373                         actuallyUpdateDayNightDiff();
 374                 return m_day_night_differs;
 375         }
 376
 377         /*
 378                 Miscellaneous stuff
 379         */
 380
 381         /*
 382                 Tries to measure ground level.
 383                 Return value:
 384                         -1 = only air
 385                         -2 = only ground
 386                         -3 = random fail
 387                         0...MAP_BLOCKSIZE-1 = ground level
 388         */
 389         s16 getGroundLevel(v2s16 p2d);
 390
 391         /*
 392                 Timestamp (see m_timestamp)
 393                 NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 394         */
 395         void setTimestamp(u32 time)
 396         {
 397                 m_timestamp = time;
 398                 raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "setTimestamp");
 399         }
 400         void setTimestampNoChangedFlag(u32 time)
 401         {
 402                 m_timestamp = time;
 403         }
 404         u32 getTimestamp()
 405         {
 406                 return m_timestamp;
 407         }
 408         u32 getDiskTimestamp()
 409         {
 410                 return m_disk_timestamp;
 411         }
 412
 413         /*
 414                 See m_usage_timer
 415         */
 416         void resetUsageTimer()
 417         {
 418                 m_usage_timer = 0;
 419         }
 420         void incrementUsageTimer(float dtime)
 421         {
 422                 m_usage_timer += dtime;
 423         }
 424         u32 getUsageTimer()
 425         {
 426                 return m_usage_timer;
 427         }
 428
 429         /*
 430                 Serialization
 431         */
 432
 433         // These don't write or read version by itself
 434         // Set disk to true for on-disk format, false for over-the-network format
 435         void serialize(std::ostream &os, u8 version, bool disk);
 436         // If disk == true: In addition to doing other things, will add
 437         // unknown blocks from id-name mapping to wndef
 438         void deSerialize(std::istream &is, u8 version, bool disk);
 439
 440 private:
 441         /*
 442                 Private methods
 443         */
 444
 445         void serialize_pre22(std::ostream &os, u8 version, bool disk);
 446         void deSerialize_pre22(std::istream &is, u8 version, bool disk);
 447
 448         /*
 449                 Used only internally, because changes can't be tracked
 450         */
 451
 452         MapNode & getNodeRef(s16 x, s16 y, s16 z)
 453         {
 454                 if(data == NULL)
 455                         throw InvalidPositionException();
 456                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 457                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 458                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 459                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 460         }
 461         MapNode & getNodeRef(v3s16 &p)
 462         {
 463                 return getNodeRef(p.X, p.Y, p.Z);
 464         }
 465
 466 public:
 467         /*
 468                 Public member variables
 469         */
 470
 471 #ifndef SERVER // Only on client
 472         MapBlockMesh *mesh;
 473         //JMutex mesh_mutex;
 474 #endif
 475
 476         NodeMetadataList *m_node_metadata;
 477         StaticObjectList m_static_objects;
 478
 479 private:
 480         /*
 481                 Private member variables
 482         */
 483
 484         // NOTE: Lots of things rely on this being the Map
 485         Map *m_parent;
 486         // Position in blocks on parent
 487         v3s16 m_pos;
 488
 489         IGameDef *m_gamedef;
 490
 491         /*
 492                 If NULL, block is a dummy block.
 493                 Dummy blocks are used for caching not-found-on-disk blocks.
 494         */
 495         MapNode * data;
 496
 497         /*
 498                 - On the server, this is used for telling whether the
 499                   block has been modified from the one on disk.
 500                 - On the client, this is used for nothing.
 501         */
 502         u32 m_modified;
 503         std::string m_modified_reason;
 504         bool m_modified_reason_too_long;
 505
 506         /*
 507                 When propagating sunlight and the above block doesn't exist,
 508                 sunlight is assumed if this is false.
 509
 510                 In practice this is set to true if the block is completely
 511                 undeground with nothing visible above the ground except
 512                 caves.
 513         */
 514         bool is_underground;
 515
 516         /*
 517                 Set to true if changes has been made that make the old lighting
 518                 values wrong but the lighting hasn't been actually updated.
 519
 520                 If this is false, lighting is exactly right.
 521                 If this is true, lighting might be wrong or right.
 522         */
 523         bool m_lighting_expired;
 524
 525         // Whether day and night lighting differs
 526         bool m_day_night_differs;
 527         bool m_day_night_differs_expired;
 528
 529         bool m_generated;
 530
 531         /*
 532                 When block is removed from active blocks, this is set to gametime.
 533                 Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 534         */
 535         u32 m_timestamp;
 536         // The on-disk (or to-be on-disk) timestamp value
 537         u32 m_disk_timestamp;
 538
 539         /*
 540                 When the block is accessed, this is set to 0.
 541                 Map will unload the block when this reaches a timeout.
 542         */
 543         float m_usage_timer;
 544 };
 545
 546 inline bool blockpos_over_limit(v3s16 p)
 547 {
 548         return
 549           (p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 550         || p.X >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 551         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 552         || p.Y >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 553         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 554         || p.Z >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE);
 555 }
 556
 557 /*
 558         Returns the position of the block where the node is located
 559 */
 560 inline v3s16 getNodeBlockPos(v3s16 p)
 561 {
 562         return getContainerPos(p, MAP_BLOCKSIZE);
 563 }
 564
 565 inline v2s16 getNodeSectorPos(v2s16 p)
 566 {
 567         return getContainerPos(p, MAP_BLOCKSIZE);
 568 }
 569
 570 inline s16 getNodeBlockY(s16 y)
 571 {
 572         return getContainerPos(y, MAP_BLOCKSIZE);
 573 }
 574
 575 /*
 576         Get a quick string to describe what a block actually contains
 577 */
 578 std::string analyze_block(MapBlock *block);
 579
 580 #endif
 581