minetest.git - modified minetest for gpcfs purposes

diff options

author	Loïc Blot <nerzhul@users.noreply.github.com>	2017-08-20 17:20:11 +0200
committer	GitHub <noreply@github.com>	2017-08-20 17:20:11 +0200
commit	c99dcbaca99c0bf3cf90efb6670d946898e23ae6 (patch)
tree	7b00dfc421be40af049b09f3f1e41f35a4f7ff34 /src/database.h
parent	1c1c97cbd1d7913ac12bf550ec02c97f843a0fd3 (diff)
download	minetest-c99dcbaca99c0bf3cf90efb6670d946898e23ae6.tar.gz minetest-c99dcbaca99c0bf3cf90efb6670d946898e23ae6.tar.bz2 minetest-c99dcbaca99c0bf3cf90efb6670d946898e23ae6.zip

New version scheme (#6292)

* Version changes: current dev version is now 0.5.0 * This change permit to have multi branches with various versions * Dev version is 0.5.0-dev and next release will be 0.5.0

Diffstat (limited to 'src/database.h')

0 files changed, 0 insertions, 0 deletions

/* Minetest Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #ifndef MAPBLOCK_HEADER #define MAPBLOCK_HEADER #include <set> #include "debug.h" #include "irr_v3d.h" #include "mapnode.h" #include "exceptions.h" #include "constants.h" #include "staticobject.h" #include "nodemetadata.h" #include "nodetimer.h" #include "modifiedstate.h" #include "util/numeric.h" // getContainerPos #include "settings.h" class Map; class NodeMetadataList; class IGameDef; class MapBlockMesh; class VoxelManipulator; #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff /*// Named by looking towards z+ enum{ FACE_BACK=0, FACE_TOP, FACE_RIGHT, FACE_FRONT, FACE_BOTTOM, FACE_LEFT };*/ // NOTE: If this is enabled, set MapBlock to be initialized with // CONTENT_IGNORE. /*enum BlockGenerationStatus { // Completely non-generated (filled with CONTENT_IGNORE). BLOCKGEN_UNTOUCHED=0, // Trees or similar might have been blitted from other blocks to here. // Otherwise, the block contains CONTENT_IGNORE BLOCKGEN_FROM_NEIGHBORS=2, // Has been generated, but some neighbors might put some stuff in here // when they are generated. // Does not contain any CONTENT_IGNORE BLOCKGEN_SELF_GENERATED=4, // The block and all its neighbors have been generated BLOCKGEN_FULLY_GENERATED=6 };*/ #if 0 enum { NODECONTAINER_ID_MAPBLOCK, NODECONTAINER_ID_MAPSECTOR, NODECONTAINER_ID_MAP, NODECONTAINER_ID_MAPBLOCKCACHE, NODECONTAINER_ID_VOXELMANIPULATOR, }; class NodeContainer { public: virtual bool isValidPosition(v3s16 p) = 0; virtual MapNode getNode(v3s16 p) = 0; virtual void setNode(v3s16 p, MapNode & n) = 0; virtual u16 nodeContainerId() const = 0; MapNode getNodeNoEx(v3s16 p) { try{ return getNode(p); } catch(InvalidPositionException &e){ return MapNode(CONTENT_IGNORE); } } }; #endif //// //// MapBlock modified reason flags //// #define MOD_REASON_INITIAL (1 << 0) #define MOD_REASON_REALLOCATE (1 << 1) #define MOD_REASON_SET_IS_UNDERGROUND (1 << 2) #define MOD_REASON_SET_LIGHTING_COMPLETE (1 << 3) #define MOD_REASON_SET_GENERATED (1 << 4) #define MOD_REASON_SET_NODE (1 << 5) #define MOD_REASON_SET_NODE_NO_CHECK (1 << 6) #define MOD_REASON_SET_TIMESTAMP (1 << 7) #define MOD_REASON_REPORT_META_CHANGE (1 << 8) #define MOD_REASON_CLEAR_ALL_OBJECTS (1 << 9) #define MOD_REASON_BLOCK_EXPIRED (1 << 10) #define MOD_REASON_ADD_ACTIVE_OBJECT_RAW (1 << 11) #define MOD_REASON_REMOVE_OBJECTS_REMOVE (1 << 12) #define MOD_REASON_REMOVE_OBJECTS_DEACTIVATE (1 << 13) #define MOD_REASON_TOO_MANY_OBJECTS (1 << 14) #define MOD_REASON_STATIC_DATA_ADDED (1 << 15) #define MOD_REASON_STATIC_DATA_REMOVED (1 << 16) #define MOD_REASON_STATIC_DATA_CHANGED (1 << 17) #define MOD_REASON_EXPIRE_DAYNIGHTDIFF (1 << 18) #define MOD_REASON_UNKNOWN (1 << 19) //// //// MapBlock itself //// class MapBlock /*: public NodeContainer*/ { public: MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false); ~MapBlock(); /*virtual u16 nodeContainerId() const { return NODECONTAINER_ID_MAPBLOCK; }*/ Map * getParent() { return m_parent; } void reallocate() { delete[] data; data = new MapNode[nodecount]; for (u32 i = 0; i < nodecount; i++) data[i] = MapNode(CONTENT_IGNORE); raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE); } //// //// Modification tracking methods //// void raiseModified(u32 mod, u32 reason=MOD_REASON_UNKNOWN) { if (mod > m_modified) { m_modified = mod; m_modified_reason = reason; if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD) m_disk_timestamp = m_timestamp; } else if (mod == m_modified) { m_modified_reason |= reason; } } inline u32 getModified() { return m_modified; } inline u32 getModifiedReason() { return m_modified_reason; } std::string getModifiedReasonString(); inline void resetModified() { m_modified = MOD_STATE_CLEAN; m_modified_reason = 0; } //// //// Flags //// inline bool isDummy() { return (data == NULL); } inline void unDummify() { assert(isDummy()); // Pre-condition reallocate(); } // is_underground getter/setter inline bool getIsUnderground() { return is_underground; } inline void setIsUnderground(bool a_is_underground) { is_underground = a_is_underground; raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND); } inline void setLightingComplete(u16 newflags) { if (newflags != m_lighting_complete) { m_lighting_complete = newflags; raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE); } } inline u16 getLightingComplete() { return m_lighting_complete; } inline void setLightingComplete(LightBank bank, u8 direction, bool is_complete) { assert(direction >= 0 && direction <= 5); if (bank == LIGHTBANK_NIGHT) { direction += 6; } u16 newflags = m_lighting_complete; if (is_complete) { newflags |= 1 << direction; } else { newflags &= ~(1 << direction); } setLightingComplete(newflags); } inline bool isLightingComplete(LightBank bank, u8 direction) { assert(direction >= 0 && direction <= 5); if (bank == LIGHTBANK_NIGHT) { direction += 6; } return (m_lighting_complete & (1 << direction)) != 0; } inline bool isGenerated() { return m_generated; } inline void setGenerated(bool b) { if (b != m_generated) { raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED); m_generated = b; } } //// //// Position stuff //// inline v3s16 getPos() { return m_pos; } inline v3s16 getPosRelative() { return m_pos_relative; } inline core::aabbox3d<s16> getBox() { return core::aabbox3d<s16>(getPosRelative(), getPosRelative() + v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE) - v3s16(1,1,1)); } //// //// Regular MapNode get-setters //// inline bool isValidPosition(s16 x, s16 y, s16 z) { return data != NULL && x >= 0 && x < MAP_BLOCKSIZE && y >= 0 && y < MAP_BLOCKSIZE && z >= 0 && z < MAP_BLOCKSIZE; } inline bool isValidPosition(v3s16 p) { return isValidPosition(p.X, p.Y, p.Z); } inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position) { *valid_position = isValidPosition(x, y, z); if (!*valid_position) return MapNode(CONTENT_IGNORE); return data[z * zstride + y * ystride + x]; } inline MapNode getNode(v3s16 p, bool *valid_position) { return getNode(p.X, p.Y, p.Z, valid_position); } inline MapNode getNodeNoEx(v3s16 p) { bool is_valid; return getNode(p.X, p.Y, p.Z, &is_valid); } inline void setNode(s16 x, s16 y, s16 z, MapNode & n) { if (!isValidPosition(x, y, z)) throw InvalidPositionException(); data[z * zstride + y * ystride + x] = n; raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE); } inline void setNode(v3s16 p, MapNode & n) { setNode(p.X, p.Y, p.Z, n); } //// //// Non-checking variants of the above //// inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position) { *valid_position = data != NULL; if (!valid_position) return MapNode(CONTENT_IGNORE); return data[z * zstride + y * ystride + x]; } inline MapNode getNodeNoCheck(v3s16 p, bool *valid_position) { return getNodeNoCheck(p.X, p.Y, p.Z, valid_position); } //// //// Non-checking, unsafe variants of the above //// MapBlock must be loaded by another function in the same scope/function //// Caller must ensure that this is not a dummy block (by calling isDummy()) //// inline const MapNode &getNodeUnsafe(s16 x, s16 y, s16 z) { return data[z * zstride + y * ystride + x]; } inline const MapNode &getNodeUnsafe(v3s16 &p) { return getNodeUnsafe(p.X, p.Y, p.Z); } inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n) { if (data == NULL) throw InvalidPositionException(); data[z * zstride + y * ystride + x] = n; raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK); } inline void setNodeNoCheck(v3s16 p, MapNode & n) { setNodeNoCheck(p.X, p.Y, p.Z, n); } // These functions consult the parent container if the position // is not valid on this MapBlock. bool isValidPositionParent(v3s16 p); MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL); void setNodeParent(v3s16 p, MapNode & n); inline void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node) { for (u16 z = 0; z < d; z++) for (u16 y = 0; y < h; y++) for (u16 x = 0; x < w; x++) setNode(x0 + x, y0 + y, z0 + z, node); } // See comments in mapblock.cpp bool propagateSunlight(std::set<v3s16> &light_sources, bool remove_light=false, bool *black_air_left=NULL); // Copies data to VoxelManipulator to getPosRelative() void copyTo(VoxelManipulator &dst); // Copies data from VoxelManipulator getPosRelative() void copyFrom(VoxelManipulator &dst); // Update day-night lighting difference flag. // Sets m_day_night_differs to appropriate value. // These methods don't care about neighboring blocks. void actuallyUpdateDayNightDiff(); // Call this to schedule what the previous function does to be done // when the value is actually needed. void expireDayNightDiff(); inline bool getDayNightDiff() { if (m_day_night_differs_expired) actuallyUpdateDayNightDiff(); return m_day_night_differs; } //// //// Miscellaneous stuff //// /* Tries to measure ground level. Return value: -1 = only air -2 = only ground -3 = random fail 0...MAP_BLOCKSIZE-1 = ground level */ s16 getGroundLevel(v2s16 p2d); //// //// Timestamp (see m_timestamp) //// // NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. inline void setTimestamp(u32 time) { m_timestamp = time; raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP); } inline void setTimestampNoChangedFlag(u32 time) { m_timestamp = time; } inline u32 getTimestamp() { return m_timestamp; } inline u32 getDiskTimestamp() { return m_disk_timestamp; } //// //// Usage timer (see m_usage_timer) //// inline void resetUsageTimer() { m_usage_timer = 0; } inline void incrementUsageTimer(float dtime) { m_usage_timer += dtime; } inline float getUsageTimer() { return m_usage_timer; } //// //// Reference counting (see m_refcount) //// inline void refGrab() { m_refcount++; } inline void refDrop() { m_refcount--; } inline int refGet() { return m_refcount; } //// //// Node Timers //// inline NodeTimer getNodeTimer(v3s16 p) { return m_node_timers.get(p); } inline void removeNodeTimer(v3s16 p) { m_node_timers.remove(p); } inline void setNodeTimer(const NodeTimer &t) { m_node_timers.set(t); } inline void clearNodeTimers() { m_node_timers.clear(); } //// //// Serialization /// // These don't write or read version by itself // Set disk to true for on-disk format, false for over-the-network format // Precondition: version >= SER_FMT_VER_LOWEST_WRITE void serialize(std::ostream &os, u8 version, bool disk); // If disk == true: In addition to doing other things, will add // unknown blocks from id-name mapping to wndef void deSerialize(std::istream &is, u8 version, bool disk); void serializeNetworkSpecific(std::ostream &os, u16 net_proto_version); void deSerializeNetworkSpecific(std::istream &is); private: /* Private methods */ void deSerialize_pre22(std::istream &is, u8 version, bool disk); /* Used only internally, because changes can't be tracked */ inline MapNode &getNodeRef(s16 x, s16 y, s16 z) { if (!isValidPosition(x, y, z)) throw InvalidPositionException(); return data[z * zstride + y * ystride + x]; } inline MapNode &getNodeRef(v3s16 &p) { return getNodeRef(p.X, p.Y, p.Z); } public: /* Public member variables */ #ifndef SERVER // Only on client MapBlockMesh *mesh; #endif NodeMetadataList m_node_metadata; NodeTimerList m_node_timers; StaticObjectList m_static_objects; static const u32 ystride = MAP_BLOCKSIZE;


context:
space:
mode: