#include "modifiedstate.h"
#include "util/numeric.h" // getContainerPos
#include "settings.h"
+#include "mapgen.h"
class Map;
class NodeMetadataList;
#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_EXPIRED (1 << 3)
+#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)
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
}
+ MapNode* getData()
+ {
+ return data;
+ }
+
////
//// Modification tracking methods
////
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND);
}
- inline void setLightingExpired(bool expired)
+ 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)
{
- if (expired != m_lighting_expired){
- m_lighting_expired = expired;
- raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_EXPIRED);
+ 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 getLightingExpired()
+ inline bool isLightingComplete(LightBank bank, u8 direction)
{
- return m_lighting_expired;
+ assert(direction >= 0 && direction <= 5);
+ if (bank == LIGHTBANK_NIGHT) {
+ direction += 6;
+ }
+ return (m_lighting_complete & (1 << direction)) != 0;
}
inline bool isGenerated()
}
}
- inline bool isValid()
- {
- if (m_lighting_expired)
- return false;
- if (data == NULL)
- return false;
- return true;
- }
-
////
//// Position stuff
////
inline MapNode getNodeNoEx(v3s16 p)
{
bool is_valid;
- MapNode node = getNode(p.X, p.Y, p.Z, &is_valid);
- return is_valid ? node : MapNode(CONTENT_IGNORE);
+ return getNode(p.X, p.Y, p.Z, &is_valid);
}
inline void setNode(s16 x, s16 y, s16 z, MapNode & n)
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)
m_node_timers.remove(p);
}
- inline void setNodeTimer(v3s16 p, NodeTimer t)
+ inline void setNodeTimer(const NodeTimer &t)
{
- m_node_timers.set(p,t);
+ m_node_timers.set(t);
}
inline void clearNodeTimers()
// 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 serializeNetworkSpecific(std::ostream &os);
void deSerializeNetworkSpecific(std::istream &is);
-
private:
/*
Private methods
*/
bool is_underground;
- /*
- Set to true if changes has been made that make the old lighting
- values wrong but the lighting hasn't been actually updated.
-
- If this is false, lighting is exactly right.
- If this is true, lighting might be wrong or right.
+ /*!
+ * Each bit indicates if light spreading was finished
+ * in a direction. (Because the neighbor could also be unloaded.)
+ * Bits (most significant first):
+ * nothing, nothing, nothing, nothing,
+ * night X-, night Y-, night Z-, night Z+, night Y+, night X+,
+ * day X-, day Y-, day Z-, day Z+, day Y+, day X+.
*/
- bool m_lighting_expired;
+ u16 m_lighting_complete;
// Whether day and night lighting differs
bool m_day_night_differs;
typedef std::vector<MapBlock*> MapBlockVect;
-inline bool blockpos_over_limit(v3s16 p)
+inline bool objectpos_over_limit(v3f p)
+{
+ const float max_limit_bs = MAX_MAP_GENERATION_LIMIT * BS;
+ return p.X < -max_limit_bs ||
+ p.X > max_limit_bs ||
+ p.Y < -max_limit_bs ||
+ p.Y > max_limit_bs ||
+ p.Z < -max_limit_bs ||
+ p.Z > max_limit_bs;
+}
+
+inline bool blockpos_over_max_limit(v3s16 p)
{
- const static u16 map_gen_limit = MYMIN(MAX_MAP_GENERATION_LIMIT,
- g_settings->getU16("map_generation_limit"));
- return (p.X < -map_gen_limit / MAP_BLOCKSIZE
- || p.X > map_gen_limit / MAP_BLOCKSIZE
- || p.Y < -map_gen_limit / MAP_BLOCKSIZE
- || p.Y > map_gen_limit / MAP_BLOCKSIZE
- || p.Z < -map_gen_limit / MAP_BLOCKSIZE
- || p.Z > map_gen_limit / MAP_BLOCKSIZE);
+ const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
+ return p.X < -max_limit_bp ||
+ p.X > max_limit_bp ||
+ p.Y < -max_limit_bp ||
+ p.Y > max_limit_bp ||
+ p.Z < -max_limit_bp ||
+ p.Z > max_limit_bp;
}
/*
projects / oweals / minetest.git / blobdiff