/*
-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 "staticobject.h"
+#include "nodemetadata.h"
+#include "nodetimer.h"
+#include "modifiedstate.h"
+#include "util/numeric.h" // getContainerPos
-// Named by looking towards z+
+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_FRONT,
FACE_BOTTOM,
FACE_LEFT
-};
-
-struct FastFace
-{
- TileSpec tile;
- video::S3DVertex vertices[4]; // Precalculated vertices
-};
+};*/
-enum NodeModType
+// NOTE: If this is enabled, set MapBlock to be initialized with
+// CONTENT_IGNORE.
+/*enum BlockGenerationStatus
{
- NODEMOD_NONE,
- NODEMOD_CHANGECONTENT, //param is content id
- NODEMOD_CRACK // param is crack progression
-};
-
-struct NodeMod
-{
- NodeMod(enum NodeModType a_type=NODEMOD_NONE, u16 a_param=0)
- {
- type = a_type;
- param = a_param;
- }
- bool operator==(const NodeMod &other)
- {
- return (type == other.type && param == other.param);
- }
- enum NodeModType type;
- u16 param;
-};
-
-class NodeModMap
-{
-public:
- /*
- returns true if the mod was different last time
- */
- bool set(v3s16 p, const NodeMod &mod)
- {
- // See if old is different, cancel if it is not different.
- core::map<v3s16, NodeMod>::Node *n = m_mods.find(p);
- if(n)
- {
- NodeMod old = n->getValue();
- if(old == mod)
- return false;
-
- n->setValue(mod);
- }
- else
- {
- m_mods.insert(p, mod);
- }
-
- return true;
- }
- // Returns true if there was one
- bool get(v3s16 p, NodeMod *mod)
- {
- core::map<v3s16, NodeMod>::Node *n;
- n = m_mods.find(p);
- if(n == NULL)
- return false;
- if(mod)
- *mod = n->getValue();
- return true;
- }
- bool clear(v3s16 p)
- {
- if(m_mods.find(p))
- {
- m_mods.remove(p);
- return true;
- }
- return false;
- }
- bool clear()
- {
- if(m_mods.size() == 0)
- return false;
- m_mods.clear();
- return true;
- }
- void copy(NodeModMap &dest)
- {
- dest.m_mods.clear();
-
- for(core::map<v3s16, NodeMod>::Iterator
- i = m_mods.getIterator();
- i.atEnd() == false; i++)
- {
- dest.m_mods.insert(i.getNode()->getKey(), i.getNode()->getValue());
- }
- }
-
-private:
- core::map<v3s16, NodeMod> m_mods;
-};
-
+ // 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,
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
-class MapBlock : public NodeContainer
+/*
+ MapBlock itself
+*/
+
+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, "reallocate");
}
/*
reallocate();
}
- bool getChangedFlag()
+ // m_modified methods
+ 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 changed;
+ return m_modified;
}
- void resetChangedFlag()
+ std::string getModifiedReason()
{
- changed = false;
+ return m_modified_reason;
}
- void setChangedFlag()
+ void resetModified()
{
- changed = true;
+ m_modified = MOD_STATE_CLEAN;
+ m_modified_reason = "none";
+ m_modified_reason_too_long = false;
}
-
+
+ // 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, "setIsUnderground");
}
-#ifndef SERVER
- void setMeshExpired(bool expired)
+ void setLightingExpired(bool expired)
{
- m_mesh_expired = expired;
+ if(expired != m_lighting_expired){
+ m_lighting_expired = expired;
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setLightingExpired");
+ }
}
-
- bool getMeshExpired()
+ bool getLightingExpired()
{
- return m_mesh_expired;
+ return m_lighting_expired;
}
-#endif
- void setLightingExpired(bool expired)
+ bool isGenerated()
{
- m_lighting_expired = expired;
- setChangedFlag();
+ return m_generated;
}
- bool getLightingExpired()
+ void setGenerated(bool b)
{
- return m_lighting_expired;
+ if(b != m_generated){
+ raiseModified(MOD_STATE_WRITE_NEEDED, "setGenerated");
+ m_generated = b;
+ }
}
bool isValid()
return getNode(p.X, p.Y, p.Z);
}
+ MapNode getNodeNoEx(v3s16 p)
+ {
+ try{
+ return getNode(p.X, p.Y, p.Z);
+ }catch(InvalidPositionException &e){
+ return MapNode(CONTENT_IGNORE);
+ }
+ }
+
void setNode(s16 x, s16 y, s16 z, MapNode & n)
{
if(data == NULL)
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, "setNode");
}
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, "setNodeNoCheck");
}
void setNodeNoCheck(v3s16 p, MapNode & n)
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);
+
/*
- Graphics-related methods
+ Update day-night lighting difference flag.
+ Sets m_day_night_differs to appropriate value.
+ These methods don't care about neighboring blocks.
*/
-
- // 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)
+ void actuallyUpdateDayNightDiff();
+ /*
+ Call this to schedule what the previous function does to be done
+ when the value is actually needed.
+ */
+ void expireDayNightDiff();
+
+ bool getDayNightDiff()
{
- return getFaceLight(daynight_ratio,
- getNodeParentNoEx(p),
- getNodeParentNoEx(p + face_dir),
- face_dir);
+ if(m_day_night_differs_expired)
+ actuallyUpdateDayNightDiff();
+ return m_day_night_differs;
}
-
-#ifndef SERVER
- // light = 0...255
- static void makeFastFace(TileSpec tile, u8 light, v3f p,
- v3s16 dir, v3f scale, v3f posRelative_f,
- core::array<FastFace> &dest);
-
- TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir,
- NodeModMap &temp_mods);
- u8 getNodeContent(v3s16 p, MapNode mn,
- NodeModMap &temp_mods);
/*
- Generates the FastFaces of a node row. This has a
- ridiculous amount of parameters because that way they
- can be precalculated by the caller.
-
- translate_dir: unit vector with only one of x, y or z
- face_dir: unit vector with only one of x, y or z
+ Miscellaneous stuff
*/
- void updateFastFaceRow(
- u32 daynight_ratio,
- v3f posRelative_f,
- v3s16 startpos,
- u16 length,
- v3s16 translate_dir,
- v3f translate_dir_f,
- v3s16 face_dir,
- v3f face_dir_f,
- core::array<FastFace> &dest,
- NodeModMap &temp_mods);
/*
- Thread-safely updates the whole mesh of the mapblock.
+ Tries to measure ground level.
+ Return value:
+ -1 = only air
+ -2 = only ground
+ -3 = random fail
+ 0...MAP_BLOCKSIZE-1 = ground level
*/
- void updateMesh(u32 daynight_ratio);
-
-#endif // !SERVER
-
- // See comments in mapblock.cpp
- bool propagateSunlight(core::map<v3s16, bool> & light_sources,
- bool remove_light=false, bool *black_air_left=NULL,
- bool grow_grass=false);
-
- // Copies data to VoxelManipulator to getPosRelative()
- void copyTo(VoxelManipulator &dst);
- // Copies data from VoxelManipulator getPosRelative()
- void copyFrom(VoxelManipulator &dst);
+ s16 getGroundLevel(v2s16 p2d);
/*
- MapBlockObject stuff
+ Timestamp (see m_timestamp)
+ NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
*/
-
- void serializeObjects(std::ostream &os, u8 version)
+ void setTimestamp(u32 time)
{
- m_objects.serialize(os, version);
+ m_timestamp = time;
+ raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "setTimestamp");
}
- // If smgr!=NULL, new objects are added to the scene
- void updateObjects(std::istream &is, u8 version,
- scene::ISceneManager *smgr, u32 daynight_ratio)
+ void setTimestampNoChangedFlag(u32 time)
{
- m_objects.update(is, version, smgr, daynight_ratio);
-
- setChangedFlag();
+ m_timestamp = time;
}
- void clearObjects()
+ u32 getTimestamp()
{
- m_objects.clear();
-
- setChangedFlag();
+ return m_timestamp;
}
- void addObject(MapBlockObject *object)
- throw(ContainerFullException, AlreadyExistsException)
+ u32 getDiskTimestamp()
{
- m_objects.add(object);
-
- setChangedFlag();
+ return m_disk_timestamp;
}
- void removeObject(s16 id)
+
+ /*
+ See m_usage_timer
+ */
+ void resetUsageTimer()
{
- m_objects.remove(id);
-
- setChangedFlag();
+ m_usage_timer = 0;
}
- MapBlockObject * getObject(s16 id)
+ void incrementUsageTimer(float dtime)
{
- return m_objects.get(id);
+ m_usage_timer += dtime;
}
- JMutexAutoLock * getObjectLock()
+ u32 getUsageTimer()
{
- return m_objects.getLock();
+ return m_usage_timer;
}
/*
- Moves objects, deletes objects and spawns new objects
+ See m_refcount
*/
- void stepObjects(float dtime, bool server, u32 daynight_ratio);
-
- /*void wrapObject(MapBlockObject *object)
+ void refGrab()
{
- m_objects.wrapObject(object);
-
- setChangedFlag();
- }*/
-
- // origin is relative to block
- void getObjects(v3f origin, f32 max_d,
- core::array<DistanceSortedObject> &dest)
+ m_refcount++;
+ }
+ void refDrop()
{
- m_objects.getObjects(origin, max_d, dest);
+ m_refcount--;
}
-
- s32 getObjectCount()
+ int refGet()
{
- return m_objects.getCount();
+ return m_refcount;
}
-
-#ifndef SERVER
+
/*
- Methods for setting temporary modifications to nodes for
- drawing
-
- returns true if the mod was different last time
+ Node Timers
*/
- 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);
+ // Get timer
+ NodeTimer getNodeTimer(v3s16 p){
+ return m_node_timers.get(p);
}
- // 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);
+ // Deletes timer
+ void removeNodeTimer(v3s16 p){
+ m_node_timers.remove(p);
}
- bool clearTempMod(v3s16 p)
- {
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.clear(p);
+ // Deletes old timer and sets a new one
+ void setNodeTimer(v3s16 p, NodeTimer t){
+ m_node_timers.set(p,t);
}
- bool clearTempMods()
- {
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.clear();
- }
-#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();
-
- bool dayNightDiffed()
- {
- return m_day_night_differs;
+ // Deletes all timers
+ void clearNodeTimers(){
+ m_node_timers.clear();
}
- /*
- 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);
-
/*
Serialization
*/
- // Doesn't write version by itself
- void serialize(std::ostream &os, u8 version);
+ // These don't write or read version by itself
+ // 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 deSerialize(std::istream &is, u8 version);
+ 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
*/
Public member variables
*/
-#ifndef SERVER
- scene::SMesh *mesh;
- JMutex mesh_mutex;
+#ifndef SERVER // Only on client
+ MapBlockMesh *mesh;
#endif
+ NodeMetadataList m_node_metadata;
+ NodeTimerList m_node_timers;
+ StaticObjectList m_static_objects;
+
+ s16 heat;
+ u32 heat_time;
+ s16 humidity;
+ u32 humidity_time;
+
private:
/*
Private member variables
*/
- // Parent container (practically the Map)
- // Not a MapSector, it is just a structural element.
- NodeContainer *m_parent;
+ // NOTE: Lots of things rely on this being the Map
+ 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;
+ 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;
-
- MapBlockObjectList m_objects;
+ bool m_day_night_differs_expired;
- // Object spawning stuff
- float m_spawn_timer;
+ bool m_generated;
-#ifndef SERVER
/*
- 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.
+ When block is removed from active blocks, this is set to gametime.
+ Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
*/
- bool m_mesh_expired;
-
- // Temporary modifications to nodes
- // These are only used when drawing
- NodeModMap m_temp_mods;
- JMutex m_temp_mods_mutex;
-#endif
+ 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
projects / dragonfireclient.git / blobdiff