3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
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.
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.
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.
25 #include "exceptions.h"
26 #include "constants.h"
27 #include "staticobject.h"
28 #include "nodemetadata.h"
29 #include "nodetimer.h"
30 #include "modifiedstate.h"
31 #include "util/numeric.h" // getContainerPos
36 class NodeMetadataList;
39 class VoxelManipulator;
41 #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
44 //// MapBlock modified reason flags
47 #define MOD_REASON_INITIAL (1 << 0)
48 #define MOD_REASON_REALLOCATE (1 << 1)
49 #define MOD_REASON_SET_IS_UNDERGROUND (1 << 2)
50 #define MOD_REASON_SET_LIGHTING_COMPLETE (1 << 3)
51 #define MOD_REASON_SET_GENERATED (1 << 4)
52 #define MOD_REASON_SET_NODE (1 << 5)
53 #define MOD_REASON_SET_NODE_NO_CHECK (1 << 6)
54 #define MOD_REASON_SET_TIMESTAMP (1 << 7)
55 #define MOD_REASON_REPORT_META_CHANGE (1 << 8)
56 #define MOD_REASON_CLEAR_ALL_OBJECTS (1 << 9)
57 #define MOD_REASON_BLOCK_EXPIRED (1 << 10)
58 #define MOD_REASON_ADD_ACTIVE_OBJECT_RAW (1 << 11)
59 #define MOD_REASON_REMOVE_OBJECTS_REMOVE (1 << 12)
60 #define MOD_REASON_REMOVE_OBJECTS_DEACTIVATE (1 << 13)
61 #define MOD_REASON_TOO_MANY_OBJECTS (1 << 14)
62 #define MOD_REASON_STATIC_DATA_ADDED (1 << 15)
63 #define MOD_REASON_STATIC_DATA_REMOVED (1 << 16)
64 #define MOD_REASON_STATIC_DATA_CHANGED (1 << 17)
65 #define MOD_REASON_EXPIRE_DAYNIGHTDIFF (1 << 18)
66 #define MOD_REASON_UNKNOWN (1 << 19)
75 MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
78 /*virtual u16 nodeContainerId() const
80 return NODECONTAINER_ID_MAPBLOCK;
91 data = new MapNode[nodecount];
92 for (u32 i = 0; i < nodecount; i++)
93 data[i] = MapNode(CONTENT_IGNORE);
95 raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
104 //// Modification tracking methods
106 void raiseModified(u32 mod, u32 reason=MOD_REASON_UNKNOWN)
108 if (mod > m_modified) {
110 m_modified_reason = reason;
111 if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD)
112 m_disk_timestamp = m_timestamp;
113 } else if (mod == m_modified) {
114 m_modified_reason |= reason;
118 inline u32 getModified()
123 inline u32 getModifiedReason()
125 return m_modified_reason;
128 std::string getModifiedReasonString();
130 inline void resetModified()
132 m_modified = MOD_STATE_CLEAN;
133 m_modified_reason = 0;
140 inline bool isDummy()
145 inline void unDummify()
147 assert(isDummy()); // Pre-condition
151 // is_underground getter/setter
152 inline bool getIsUnderground()
154 return is_underground;
157 inline void setIsUnderground(bool a_is_underground)
159 is_underground = a_is_underground;
160 raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND);
163 inline void setLightingComplete(u16 newflags)
165 if (newflags != m_lighting_complete) {
166 m_lighting_complete = newflags;
167 raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE);
171 inline u16 getLightingComplete()
173 return m_lighting_complete;
176 inline void setLightingComplete(LightBank bank, u8 direction,
179 assert(direction >= 0 && direction <= 5);
180 if (bank == LIGHTBANK_NIGHT) {
183 u16 newflags = m_lighting_complete;
185 newflags |= 1 << direction;
187 newflags &= ~(1 << direction);
189 setLightingComplete(newflags);
192 inline bool isLightingComplete(LightBank bank, u8 direction)
194 assert(direction >= 0 && direction <= 5);
195 if (bank == LIGHTBANK_NIGHT) {
198 return (m_lighting_complete & (1 << direction)) != 0;
201 inline bool isGenerated()
206 inline void setGenerated(bool b)
208 if (b != m_generated) {
209 raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED);
218 inline v3s16 getPos()
223 inline v3s16 getPosRelative()
225 return m_pos_relative;
228 inline core::aabbox3d<s16> getBox()
230 return core::aabbox3d<s16>(getPosRelative(),
232 + v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
237 //// Regular MapNode get-setters
240 inline bool isValidPosition(s16 x, s16 y, s16 z)
243 && x >= 0 && x < MAP_BLOCKSIZE
244 && y >= 0 && y < MAP_BLOCKSIZE
245 && z >= 0 && z < MAP_BLOCKSIZE;
248 inline bool isValidPosition(v3s16 p)
250 return isValidPosition(p.X, p.Y, p.Z);
253 inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
255 *valid_position = isValidPosition(x, y, z);
257 if (!*valid_position)
258 return MapNode(CONTENT_IGNORE);
260 return data[z * zstride + y * ystride + x];
263 inline MapNode getNode(v3s16 p, bool *valid_position)
265 return getNode(p.X, p.Y, p.Z, valid_position);
268 inline MapNode getNodeNoEx(v3s16 p)
271 return getNode(p.X, p.Y, p.Z, &is_valid);
274 inline void setNode(s16 x, s16 y, s16 z, MapNode & n)
276 if (!isValidPosition(x, y, z))
277 throw InvalidPositionException();
279 data[z * zstride + y * ystride + x] = n;
280 raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE);
283 inline void setNode(v3s16 p, MapNode & n)
285 setNode(p.X, p.Y, p.Z, n);
289 //// Non-checking variants of the above
292 inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position)
294 *valid_position = data != nullptr;
296 return MapNode(CONTENT_IGNORE);
298 return data[z * zstride + y * ystride + x];
301 inline MapNode getNodeNoCheck(v3s16 p, bool *valid_position)
303 return getNodeNoCheck(p.X, p.Y, p.Z, valid_position);
307 //// Non-checking, unsafe variants of the above
308 //// MapBlock must be loaded by another function in the same scope/function
309 //// Caller must ensure that this is not a dummy block (by calling isDummy())
312 inline const MapNode &getNodeUnsafe(s16 x, s16 y, s16 z)
314 return data[z * zstride + y * ystride + x];
317 inline const MapNode &getNodeUnsafe(v3s16 &p)
319 return getNodeUnsafe(p.X, p.Y, p.Z);
322 inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
325 throw InvalidPositionException();
327 data[z * zstride + y * ystride + x] = n;
328 raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK);
331 inline void setNodeNoCheck(v3s16 p, MapNode & n)
333 setNodeNoCheck(p.X, p.Y, p.Z, n);
336 // These functions consult the parent container if the position
337 // is not valid on this MapBlock.
338 bool isValidPositionParent(v3s16 p);
339 MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL);
340 void setNodeParent(v3s16 p, MapNode & n);
342 inline void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
344 for (u16 z = 0; z < d; z++)
345 for (u16 y = 0; y < h; y++)
346 for (u16 x = 0; x < w; x++)
347 setNode(x0 + x, y0 + y, z0 + z, node);
350 // See comments in mapblock.cpp
351 bool propagateSunlight(std::set<v3s16> &light_sources,
352 bool remove_light=false, bool *black_air_left=NULL);
354 // Copies data to VoxelManipulator to getPosRelative()
355 void copyTo(VoxelManipulator &dst);
357 // Copies data from VoxelManipulator getPosRelative()
358 void copyFrom(VoxelManipulator &dst);
360 // Update day-night lighting difference flag.
361 // Sets m_day_night_differs to appropriate value.
362 // These methods don't care about neighboring blocks.
363 void actuallyUpdateDayNightDiff();
365 // Call this to schedule what the previous function does to be done
366 // when the value is actually needed.
367 void expireDayNightDiff();
369 inline bool getDayNightDiff()
371 if (m_day_night_differs_expired)
372 actuallyUpdateDayNightDiff();
373 return m_day_night_differs;
377 //// Miscellaneous stuff
381 Tries to measure ground level.
386 0...MAP_BLOCKSIZE-1 = ground level
388 s16 getGroundLevel(v2s16 p2d);
391 //// Timestamp (see m_timestamp)
394 // NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
396 inline void setTimestamp(u32 time)
399 raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP);
402 inline void setTimestampNoChangedFlag(u32 time)
407 inline u32 getTimestamp()
412 inline u32 getDiskTimestamp()
414 return m_disk_timestamp;
418 //// Usage timer (see m_usage_timer)
421 inline void resetUsageTimer()
426 inline void incrementUsageTimer(float dtime)
428 m_usage_timer += dtime;
431 inline float getUsageTimer()
433 return m_usage_timer;
437 //// Reference counting (see m_refcount)
440 inline void refGrab()
445 inline void refDrop()
459 inline NodeTimer getNodeTimer(v3s16 p)
461 return m_node_timers.get(p);
464 inline void removeNodeTimer(v3s16 p)
466 m_node_timers.remove(p);
469 inline void setNodeTimer(const NodeTimer &t)
471 m_node_timers.set(t);
474 inline void clearNodeTimers()
476 m_node_timers.clear();
483 // These don't write or read version by itself
484 // Set disk to true for on-disk format, false for over-the-network format
485 // Precondition: version >= SER_FMT_VER_LOWEST_WRITE
486 void serialize(std::ostream &os, u8 version, bool disk);
487 // If disk == true: In addition to doing other things, will add
488 // unknown blocks from id-name mapping to wndef
489 void deSerialize(std::istream &is, u8 version, bool disk);
491 void serializeNetworkSpecific(std::ostream &os);
492 void deSerializeNetworkSpecific(std::istream &is);
498 void deSerialize_pre22(std::istream &is, u8 version, bool disk);
501 Used only internally, because changes can't be tracked
504 inline MapNode &getNodeRef(s16 x, s16 y, s16 z)
506 if (!isValidPosition(x, y, z))
507 throw InvalidPositionException();
509 return data[z * zstride + y * ystride + x];
512 inline MapNode &getNodeRef(v3s16 &p)
514 return getNodeRef(p.X, p.Y, p.Z);
519 Public member variables
522 #ifndef SERVER // Only on client
523 MapBlockMesh *mesh = nullptr;
526 NodeMetadataList m_node_metadata;
527 NodeTimerList m_node_timers;
528 StaticObjectList m_static_objects;
530 static const u32 ystride = MAP_BLOCKSIZE;
531 static const u32 zstride = MAP_BLOCKSIZE * MAP_BLOCKSIZE;
533 static const u32 nodecount = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
537 Private member variables
540 // NOTE: Lots of things rely on this being the Map
542 // Position in blocks on parent
545 /* This is the precalculated m_pos_relative value
546 * This caches the value, improving performance by removing 3 s16 multiplications
547 * at runtime on each getPosRelative call
548 * For a 5 minutes runtime with valgrind this removes 3 * 19M s16 multiplications
549 * The gain can be estimated in Release Build to 3 * 100M multiply operations for 5 mins
551 v3s16 m_pos_relative;
556 If NULL, block is a dummy block.
557 Dummy blocks are used for caching not-found-on-disk blocks.
559 MapNode *data = nullptr;
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.
566 u32 m_modified = MOD_STATE_WRITE_NEEDED;
567 u32 m_modified_reason = MOD_REASON_INITIAL;
570 When propagating sunlight and the above block doesn't exist,
571 sunlight is assumed if this is false.
573 In practice this is set to true if the block is completely
574 undeground with nothing visible above the ground except
577 bool is_underground = false;
580 * Each bit indicates if light spreading was finished
581 * in a direction. (Because the neighbor could also be unloaded.)
582 * Bits (most significant first):
583 * nothing, nothing, nothing, nothing,
584 * night X-, night Y-, night Z-, night Z+, night Y+, night X+,
585 * day X-, day Y-, day Z-, day Z+, day Y+, day X+.
587 u16 m_lighting_complete = 0xFFFF;
589 // Whether day and night lighting differs
590 bool m_day_night_differs = false;
591 bool m_day_night_differs_expired = true;
593 bool m_generated = false;
596 When block is removed from active blocks, this is set to gametime.
597 Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
599 u32 m_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
600 // The on-disk (or to-be on-disk) timestamp value
601 u32 m_disk_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
604 When the block is accessed, this is set to 0.
605 Map will unload the block when this reaches a timeout.
607 float m_usage_timer = 0;
610 Reference count; currently used for determining if this block is in
611 the list of blocks to be drawn.
616 typedef std::vector<MapBlock*> MapBlockVect;
618 inline bool objectpos_over_limit(v3f p)
620 const float max_limit_bs = MAX_MAP_GENERATION_LIMIT * BS;
621 return p.X < -max_limit_bs ||
622 p.X > max_limit_bs ||
623 p.Y < -max_limit_bs ||
624 p.Y > max_limit_bs ||
625 p.Z < -max_limit_bs ||
629 inline bool blockpos_over_max_limit(v3s16 p)
631 const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
632 return p.X < -max_limit_bp ||
633 p.X > max_limit_bp ||
634 p.Y < -max_limit_bp ||
635 p.Y > max_limit_bp ||
636 p.Z < -max_limit_bp ||
641 Returns the position of the block where the node is located
643 inline v3s16 getNodeBlockPos(v3s16 p)
645 return getContainerPos(p, MAP_BLOCKSIZE);
648 inline v2s16 getNodeSectorPos(v2s16 p)
650 return getContainerPos(p, MAP_BLOCKSIZE);
653 inline s16 getNodeBlockY(s16 y)
655 return getContainerPos(y, MAP_BLOCKSIZE);
658 inline void getNodeBlockPosWithOffset(const v3s16 &p, v3s16 &block, v3s16 &offset)
660 getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
663 inline void getNodeSectorPosWithOffset(const v2s16 &p, v2s16 &block, v2s16 &offset)
665 getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
669 Get a quick string to describe what a block actually contains
671 std::string analyze_block(MapBlock *block);