/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+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 General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+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 General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+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 <jmutex.h>
-#include <jmutexautolock.h>
-#include <exception>
+#include <set>
#include "debug.h"
-#include "common_irrlicht.h"
+#include "irr_v3d.h"
#include "mapnode.h"
#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
+#include "nodemetadata.h"
+#include "nodetimer.h"
+#include "modifiedstate.h"
+#include "util/numeric.h" // getContainerPos
class Map;
+class NodeMetadataList;
+class IGameDef;
+class MapBlockMesh;
+class VoxelManipulator;
#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
class MapBlock /*: public NodeContainer*/
{
public:
- MapBlock(Map *parent, v3s16 pos, bool dummy=false);
+ MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
~MapBlock();
/*virtual u16 nodeContainerId() const
//data[i] = MapNode();
data[i] = MapNode(CONTENT_IGNORE);
}
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ raiseModified(MOD_STATE_WRITE_NEEDED, "reallocate");
}
/*
reallocate();
}
- /*
- This is called internally or externally after the block is
- modified, so that the block is saved and possibly not deleted from
- memory.
- */
- // DEPRECATED, use *Modified()
- void setChangedFlag()
- {
- //dstream<<"Deprecated setChangedFlag() called"<<std::endl;
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- // DEPRECATED, use *Modified()
- void resetChangedFlag()
- {
- //dstream<<"Deprecated resetChangedFlag() called"<<std::endl;
- resetModified();
- }
- // DEPRECATED, use *Modified()
- bool getChangedFlag()
- {
- //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);
+ void raiseModified(u32 mod, const std::string &reason="unknown")
+ {
+ if(mod > m_modified){
+ m_modified = mod;
+ m_modified_reason = reason;
+ m_modified_reason_too_long = false;
+
+ if(m_modified >= MOD_STATE_WRITE_AT_UNLOAD){
+ m_disk_timestamp = m_timestamp;
+ }
+ } else if(mod == m_modified){
+ if(!m_modified_reason_too_long){
+ if(m_modified_reason.size() < 40)
+ m_modified_reason += ", " + reason;
+ else{
+ m_modified_reason += "...";
+ m_modified_reason_too_long = true;
+ }
+ }
+ }
}
u32 getModified()
{
return m_modified;
}
+ std::string getModifiedReason()
+ {
+ return m_modified_reason;
+ }
void resetModified()
{
m_modified = MOD_STATE_CLEAN;
+ m_modified_reason = "none";
+ m_modified_reason_too_long = false;
}
// is_underground getter/setter
void setIsUnderground(bool a_is_underground)
{
is_underground = a_is_underground;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setIsUnderground");
}
-#ifndef SERVER
- void setMeshExpired(bool expired)
- {
- m_mesh_expired = expired;
- }
-
- bool getMeshExpired()
- {
- return m_mesh_expired;
- }
-#endif
-
void setLightingExpired(bool expired)
{
- m_lighting_expired = expired;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ if(expired != m_lighting_expired){
+ m_lighting_expired = expired;
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setLightingExpired");
+ }
}
bool getLightingExpired()
{
}
void setGenerated(bool b)
{
- raiseModified(MOD_STATE_WRITE_NEEDED);
- m_generated = b;
+ if(b != m_generated){
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setGenerated");
+ 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;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setNode");
}
void setNode(v3s16 p, MapNode & n)
if(data == NULL)
throw InvalidPositionException();
data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setNodeNoCheck");
}
void setNodeNoCheck(v3s16 p, MapNode & n)
setNode(x0+x, y0+y, z0+z, node);
}
- /*
- Graphics-related methods
- */
-
- /*// A quick version with nodes passed as parameters
- u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
- v3s16 face_dir);*/
- /*// A more convenient version
- u8 getFaceLight(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
- {
- return getFaceLight(daynight_ratio,
- getNodeParentNoEx(p),
- getNodeParentNoEx(p + face_dir),
- face_dir);
- }*/
- u8 getFaceLight2(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
- {
- return getFaceLight(daynight_ratio,
- getNodeParentNoEx(p),
- getNodeParentNoEx(p + face_dir),
- face_dir);
- }
-
-#ifndef SERVER // Only on client
-
-#if 1
- /*
- Thread-safely updates the whole mesh of the mapblock.
- NOTE: Prefer generating the mesh separately and then using
- replaceMesh().
- */
- void updateMesh(u32 daynight_ratio);
-#endif
- // Replace the mesh with a new one
- void replaceMesh(scene::SMesh *mesh_new);
-#endif
-
// See comments in mapblock.cpp
- bool propagateSunlight(core::map<v3s16, bool> & light_sources,
+ bool propagateSunlight(std::set<v3s16> & light_sources,
bool remove_light=false, bool *black_air_left=NULL);
// Copies data to VoxelManipulator to getPosRelative()
// 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);
-
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- void clearObjects()
- {
- m_objects.clear();
-
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- void addObject(MapBlockObject *object)
- throw(ContainerFullException, AlreadyExistsException)
- {
- m_objects.add(object);
-
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- void removeObject(s16 id)
- {
- m_objects.remove(id);
-
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- 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
- drawing
-
- returns true if the mod was different last time
- */
- bool setTempMod(v3s16 p, const NodeMod &mod)
- {
- /*dstream<<"setTempMod called on block"
- <<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<", mod.type="<<mod.type
- <<", mod.param="<<mod.param
- <<std::endl;*/
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.set(p, mod);
- }
- // Returns true if there was one
- bool getTempMod(v3s16 p, NodeMod *mod)
- {
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.get(p, mod);
- }
- bool clearTempMod(v3s16 p)
- {
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.clear(p);
- }
- bool clearTempMods()
- {
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.clear();
- }
- void copyTempMods(NodeModMap &dst)
- {
- JMutexAutoLock lock(m_temp_mods_mutex);
- m_temp_mods.copy(dst);
- }
-#endif
-
/*
Update day-night lighting difference flag.
-
Sets m_day_night_differs to appropriate value.
-
These methods don't care about neighboring blocks.
- It means that to know if a block really doesn't need a mesh
- update between day and night, the neighboring blocks have
- to be taken into account. Use Map::dayNightDiffed().
*/
- void updateDayNightDiff();
+ void actuallyUpdateDayNightDiff();
+ /*
+ Call this to schedule what the previous function does to be done
+ when the value is actually needed.
+ */
+ void expireDayNightDiff();
- bool dayNightDiffed()
+ bool getDayNightDiff()
{
+ if(m_day_night_differs_expired)
+ actuallyUpdateDayNightDiff();
return m_day_night_differs;
}
void setTimestamp(u32 time)
{
m_timestamp = time;
- raiseModified(MOD_STATE_WRITE_AT_UNLOAD);
+ raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "setTimestamp");
}
void setTimestampNoChangedFlag(u32 time)
{
{
return m_timestamp;
}
+ u32 getDiskTimestamp()
+ {
+ return m_disk_timestamp;
+ }
/*
See m_usage_timer
return m_usage_timer;
}
+ /*
+ See m_refcount
+ */
+ void refGrab()
+ {
+ m_refcount++;
+ }
+ void refDrop()
+ {
+ m_refcount--;
+ }
+ int refGet()
+ {
+ return m_refcount;
+ }
+
+ /*
+ Node Timers
+ */
+ // Get timer
+ NodeTimer getNodeTimer(v3s16 p){
+ return m_node_timers.get(p);
+ }
+ // Deletes timer
+ void removeNodeTimer(v3s16 p){
+ m_node_timers.remove(p);
+ }
+ // Deletes old timer and sets a new one
+ void setNodeTimer(v3s16 p, NodeTimer t){
+ m_node_timers.set(p,t);
+ }
+ // Deletes all timers
+ void clearNodeTimers(){
+ m_node_timers.clear();
+ }
+
/*
Serialization
*/
// These don't write or read version by itself
- void serialize(std::ostream &os, u8 version);
- void deSerialize(std::istream &is, u8 version);
- // Used after the basic ones when writing on disk (serverside)
- void serializeDiskExtra(std::ostream &os, u8 version);
- void deSerializeDiskExtra(std::istream &is, u8 version);
+ // Set disk to true for on-disk format, false for over-the-network format
+ 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
*/
*/
#ifndef SERVER // Only on client
- scene::SMesh *mesh;
- JMutex mesh_mutex;
+ MapBlockMesh *mesh;
#endif
NodeMetadataList m_node_metadata;
+ NodeTimerList m_node_timers;
StaticObjectList m_static_objects;
+ s16 heat;
+ s16 humidity;
+ u32 weather_update_time;
+
private:
/*
Private member variables
Map *m_parent;
// Position in blocks on parent
v3s16 m_pos;
+
+ IGameDef *m_gamedef;
/*
If NULL, block is a dummy block.
- On the client, this is used for nothing.
*/
u32 m_modified;
+ std::string m_modified_reason;
+ bool m_modified_reason_too_long;
/*
When propagating sunlight and the above block doesn't exist,
// Whether day and night lighting differs
bool m_day_night_differs;
+ bool m_day_night_differs_expired;
bool m_generated;
- // DEPRECATED
- MapBlockObjectList m_objects;
-
-#ifndef SERVER // Only on client
- /*
- Set to true if the mesh has been ordered to be updated
- sometime in the background.
- In practice this is set when the day/night lighting switches.
- */
- bool m_mesh_expired;
-
- // Temporary modifications to nodes
- // These are only used when drawing
- NodeModMap m_temp_mods;
- JMutex m_temp_mods_mutex;
-#endif
-
/*
When block is removed from active blocks, this is set to gametime.
Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
*/
u32 m_timestamp;
+ // The on-disk (or to-be on-disk) timestamp value
+ u32 m_disk_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;
+
+ /*
+ Reference count; currently used for determining if this block is in
+ the list of blocks to be drawn.
+ */
+ int m_refcount;
};
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