#include "exceptions.h"
#include "serialization.h"
#include "constants.h"
-#include "mapblockobject.h"
#include "voxel.h"
-#include "nodemetadata.h"
#include "staticobject.h"
#include "mapblock_nodemod.h"
#ifndef SERVER
#include "mapblock_mesh.h"
#endif
+class Map;
+class NodeMetadataList;
+class IGameDef;
#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
FACE_LEFT
};*/
+enum ModifiedState
+{
+ // Has not been modified.
+ MOD_STATE_CLEAN = 0,
+ MOD_RESERVED1 = 1,
+ // Has been modified, and will be saved when being unloaded.
+ MOD_STATE_WRITE_AT_UNLOAD = 2,
+ MOD_RESERVED3 = 3,
+ // Has been modified, and will be saved as soon as possible.
+ MOD_STATE_WRITE_NEEDED = 4,
+ MOD_RESERVED5 = 5,
+};
+
+// 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,
}
}
};
+#endif
/*
MapBlock itself
*/
-class MapBlock : public NodeContainer
+class MapBlock /*: public NodeContainer*/
{
public:
- MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false);
+ MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
~MapBlock();
- virtual u16 nodeContainerId() const
+ /*virtual u16 nodeContainerId() const
{
return NODECONTAINER_ID_MAPBLOCK;
- }
+ }*/
- NodeContainer * getParent()
+ Map * getParent()
{
return m_parent;
}
u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
data = new MapNode[l];
for(u32 i=0; i<l; i++){
- data[i] = MapNode();
+ //data[i] = MapNode();
+ data[i] = MapNode(CONTENT_IGNORE);
}
- setChangedFlag();
+ raiseModified(MOD_STATE_WRITE_NEEDED);
}
/*
modified, so that the block is saved and possibly not deleted from
memory.
*/
+ // DEPRECATED, use *Modified()
void setChangedFlag()
{
- changed = true;
+ //dstream<<"Deprecated setChangedFlag() called"<<std::endl;
+ raiseModified(MOD_STATE_WRITE_NEEDED);
}
+ // DEPRECATED, use *Modified()
void resetChangedFlag()
{
- changed = false;
+ //dstream<<"Deprecated resetChangedFlag() called"<<std::endl;
+ resetModified();
}
+ // DEPRECATED, use *Modified()
bool getChangedFlag()
{
- return changed;
+ //dstream<<"Deprecated getChangedFlag() called"<<std::endl;
+ if(getModified() == MOD_STATE_CLEAN)
+ return false;
+ else
+ return true;
}
-
+
+ // m_modified methods
+ void raiseModified(u32 mod)
+ {
+ m_modified = MYMAX(m_modified, mod);
+ }
+ u32 getModified()
+ {
+ return m_modified;
+ }
+ void resetModified()
+ {
+ m_modified = MOD_STATE_CLEAN;
+ }
+
+ // is_underground getter/setter
bool getIsUnderground()
{
return is_underground;
void setIsUnderground(bool a_is_underground)
{
is_underground = a_is_underground;
- setChangedFlag();
+ raiseModified(MOD_STATE_WRITE_NEEDED);
}
#ifndef SERVER
void setLightingExpired(bool expired)
{
- m_lighting_expired = expired;
- setChangedFlag();
+ if(expired != m_lighting_expired){
+ m_lighting_expired = expired;
+ raiseModified(MOD_STATE_WRITE_NEEDED);
+ }
}
bool getLightingExpired()
{
return m_lighting_expired;
}
- /*bool isFullyGenerated()
+ bool isGenerated()
{
- return !m_not_fully_generated;
+ return m_generated;
}
- void setFullyGenerated(bool b)
+ void setGenerated(bool b)
{
- setChangedFlag();
- m_not_fully_generated = !b;
- }*/
+ if(b != m_generated){
+ raiseModified(MOD_STATE_WRITE_NEEDED);
+ m_generated = b;
+ }
+ }
bool isValid()
{
if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
- setChangedFlag();
+ raiseModified(MOD_STATE_WRITE_NEEDED);
}
void setNode(v3s16 p, MapNode & n)
if(data == NULL)
throw InvalidPositionException();
data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
- setChangedFlag();
+ raiseModified(MOD_STATE_WRITE_NEEDED);
}
void setNodeNoCheck(v3s16 p, MapNode & n)
getNodeParentNoEx(p + face_dir),
face_dir);
}*/
- u8 getFaceLight2(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
+ u8 getFaceLight2(u32 daynight_ratio, v3s16 p, v3s16 face_dir,
+ INodeDefManager *nodemgr)
{
return getFaceLight(daynight_ratio,
getNodeParentNoEx(p),
getNodeParentNoEx(p + face_dir),
- face_dir);
+ face_dir, nodemgr);
}
#ifndef SERVER // Only on client
// Copies data from VoxelManipulator getPosRelative()
void copyFrom(VoxelManipulator &dst);
- /*
- MapBlockObject stuff
- DEPRECATED
- */
-
- void serializeObjects(std::ostream &os, u8 version)
- {
- m_objects.serialize(os, version);
- }
- // If smgr!=NULL, new objects are added to the scene
- void updateObjects(std::istream &is, u8 version,
- scene::ISceneManager *smgr, u32 daynight_ratio)
- {
- m_objects.update(is, version, smgr, daynight_ratio);
-
- setChangedFlag();
- }
- void clearObjects()
- {
- m_objects.clear();
-
- setChangedFlag();
- }
- void addObject(MapBlockObject *object)
- throw(ContainerFullException, AlreadyExistsException)
- {
- m_objects.add(object);
-
- setChangedFlag();
- }
- void removeObject(s16 id)
- {
- m_objects.remove(id);
-
- setChangedFlag();
- }
- MapBlockObject * getObject(s16 id)
- {
- return m_objects.get(id);
- }
- JMutexAutoLock * getObjectLock()
- {
- return m_objects.getLock();
- }
-
- /*
- Moves objects, deletes objects and spawns new objects
- */
- void stepObjects(float dtime, bool server, u32 daynight_ratio);
-
- // origin is relative to block
- void getObjects(v3f origin, f32 max_d,
- core::array<DistanceSortedObject> &dest)
- {
- m_objects.getObjects(origin, max_d, dest);
- }
-
- s32 getObjectCount()
- {
- return m_objects.getCount();
- }
-
#ifndef SERVER // Only on client
/*
Methods for setting temporary modifications to nodes for
void setTimestamp(u32 time)
{
m_timestamp = time;
- setChangedFlag();
+ raiseModified(MOD_STATE_WRITE_AT_UNLOAD);
}
void setTimestampNoChangedFlag(u32 time)
{
{
return m_timestamp;
}
+
+ /*
+ See m_usage_timer
+ */
+ void resetUsageTimer()
+ {
+ m_usage_timer = 0;
+ }
+ void incrementUsageTimer(float dtime)
+ {
+ m_usage_timer += dtime;
+ }
+ u32 getUsageTimer()
+ {
+ return m_usage_timer;
+ }
/*
Serialization
JMutex mesh_mutex;
#endif
- NodeMetadataList m_node_metadata;
+ NodeMetadataList *m_node_metadata;
StaticObjectList m_static_objects;
private:
*/
// NOTE: Lots of things rely on this being the Map
- NodeContainer *m_parent;
+ Map *m_parent;
// Position in blocks on parent
v3s16 m_pos;
+
+ IGameDef *m_gamedef;
/*
If NULL, block is a dummy block.
/*
- On the server, this is used for telling whether the
- block has been changed from the one on disk.
+ block has been modified from the one on disk.
- On the client, this is used for nothing.
*/
- bool changed;
+ u32 m_modified;
/*
When propagating sunlight and the above block doesn't exist,
// Whether day and night lighting differs
bool m_day_night_differs;
-
- // DEPRECATED
- MapBlockObjectList m_objects;
+ bool m_generated;
+
#ifndef SERVER // Only on client
/*
Set to true if the mesh has been ordered to be updated
Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
*/
u32 m_timestamp;
+
+ /*
+ When the block is accessed, this is set to 0.
+ Map will unload the block when this reaches a timeout.
+ */
+ float m_usage_timer;
};
inline bool blockpos_over_limit(v3s16 p)
return getContainerPos(y, MAP_BLOCKSIZE);
}
+/*
+ Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block);
+
#endif
projects / oweals / minetest.git / blobdiff