X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=b817be5961cb188dcfa562359251ad99e29585ae;hb=d82d18bfb1a51e0f2f0a89999474e98890addf7e;hp=74666eb486de7539e9eecdf1e18eff5fab57ddc5;hpb=9b565b6bc427673437c28518d1f61c13b58be42e;p=minetest.git

diff --git a/src/mapblock.h b/src/mapblock.h
index 74666eb48..b817be596 100644
--- a/src/mapblock.h
+++ b/src/mapblock.h
@@ -1,334 +1,220 @@
 /*
-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
+#pragma once
 
-#include <jmutex.h>
-#include <jmutexautolock.h>
-#include <exception>
-#include "debug.h"
-#include "common_irrlicht.h"
+#include <set>
+#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 "nodemetadata.h"
+#include "nodetimer.h"
+#include "modifiedstate.h"
+#include "util/numeric.h" // getContainerPos
+#include "settings.h"
+#include "mapgen/mapgen.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
-};
-
-struct FastFace
+////
+//// 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_VMANIP                    (1 << 19)
+#define MOD_REASON_UNKNOWN                   (1 << 20)
+
+////
+//// MapBlock itself
+////
+
+class MapBlock
 {
-	TileSpec tile;
-	video::S3DVertex vertices[4]; // Precalculated vertices
-};
-
-enum NodeModType
-{
-	NODEMOD_NONE,
-	NODEMOD_CHANGECONTENT, //param is content id
-	NODEMOD_CRACK // param is crack progression
-};
+public:
+	MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef);
+	~MapBlock();
 
-struct NodeMod
-{
-	NodeMod(enum NodeModType a_type=NODEMOD_NONE, u16 a_param=0)
+	/*virtual u16 nodeContainerId() const
 	{
-		type = a_type;
-		param = a_param;
-	}
-	bool operator==(const NodeMod &other)
-	{
-		return (type == other.type && param == other.param);
-	}
-	enum NodeModType type;
-	u16 param;
-};
+		return NODECONTAINER_ID_MAPBLOCK;
+	}*/
 
-class NodeModMap
-{
-public:
-	/*
-		returns true if the mod was different last time
-	*/
-	bool set(v3s16 p, const NodeMod &mod)
+	Map * getParent()
 	{
-		// 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;
+		return m_parent;
 	}
-	bool clear()
+
+	void reallocate()
 	{
-		if(m_mods.size() == 0)
-			return false;
-		m_mods.clear();
-		return true;
+		for (u32 i = 0; i < nodecount; i++)
+			data[i] = MapNode(CONTENT_IGNORE);
+		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
 	}
-	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());
-		}
+	MapNode* getData()
+	{
+		return data;
 	}
 
-private:
-	core::map<v3s16, NodeMod> m_mods;
-};
-
-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)
+	////
+	//// Modification tracking methods
+	////
+	void raiseModified(u32 mod, u32 reason=MOD_REASON_UNKNOWN)
 	{
-		try{
-			return getNode(p);
-		}
-		catch(InvalidPositionException &e){
-			return MapNode(CONTENT_IGNORE);
+		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;
 		}
+		if (mod == MOD_STATE_WRITE_NEEDED)
+			contents_cached = false;
 	}
-};
-
-/*
-	Mesh making stuff
-*/
-
-class MapBlock;
-
-#ifndef SERVER
-
-struct MeshMakeData
-{
-	u32 m_daynight_ratio;
-	NodeModMap m_temp_mods;
-	VoxelManipulator m_vmanip;
-	v3s16 m_blockpos;
-	
-	/*
-		Copy central data directly from block, and other data from
-		parent of block.
-	*/
-	void fill(u32 daynight_ratio, MapBlock *block);
-};
-
-scene::SMesh* makeMapBlockMesh(MeshMakeData *data);
-
-#endif
-
-u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
-		v3s16 face_dir);
-
-/*
-	MapBlock itself
-*/
 
-class MapBlock : public NodeContainer
-{
-public:
-	MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false);
-	~MapBlock();
-	
-	virtual u16 nodeContainerId() const
+	inline u32 getModified()
 	{
-		return NODECONTAINER_ID_MAPBLOCK;
-	}
-	
-	NodeContainer * getParent()
-	{
-		return m_parent;
+		return m_modified;
 	}
 
-	void reallocate()
+	inline u32 getModifiedReason()
 	{
-		if(data != NULL)
-			delete[] data;
-		u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
-		data = new MapNode[l];
-		for(u32 i=0; i<l; i++){
-			data[i] = MapNode();
-		}
-		setChangedFlag();
+		return m_modified_reason;
 	}
 
-	/*
-		Flags
-	*/
+	std::string getModifiedReasonString();
 
-	bool isDummy()
+	inline void resetModified()
 	{
-		return (data == NULL);
-	}
-	void unDummify()
-	{
-		assert(isDummy());
-		reallocate();
-	}
-	
-	/*
-		This is called internally or externally after the block is
-		modified, so that the block is saved and possibly not deleted from
-		memory.
-	*/
-	void setChangedFlag()
-	{
-		changed = true;
-	}
-	void resetChangedFlag()
-	{
-		changed = false;
-	}
-	bool getChangedFlag()
-	{
-		return changed;
+		m_modified = MOD_STATE_CLEAN;
+		m_modified_reason = 0;
 	}
 
-	bool getIsUnderground()
+	////
+	//// Flags
+	////
+
+	// is_underground getter/setter
+	inline bool getIsUnderground()
 	{
 		return is_underground;
 	}
-	void setIsUnderground(bool a_is_underground)
+
+	inline void setIsUnderground(bool a_is_underground)
 	{
 		is_underground = a_is_underground;
-		setChangedFlag();
+		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND);
 	}
 
-#ifndef SERVER
-	void setMeshExpired(bool expired)
+	inline void setLightingComplete(u16 newflags)
 	{
-		m_mesh_expired = expired;
+		if (newflags != m_lighting_complete) {
+			m_lighting_complete = newflags;
+			raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE);
+		}
 	}
-	
-	bool getMeshExpired()
+
+	inline u16 getLightingComplete()
 	{
-		return m_mesh_expired;
+		return m_lighting_complete;
 	}
-#endif
 
-	void setLightingExpired(bool expired)
+	inline void setLightingComplete(LightBank bank, u8 direction,
+		bool is_complete)
 	{
-		m_lighting_expired = expired;
-		setChangedFlag();
+		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);
 	}
-	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;
 	}
 
-	/*bool isFullyGenerated()
+	inline bool isGenerated()
 	{
-		return !m_not_fully_generated;
+		return m_generated;
 	}
-	void setFullyGenerated(bool b)
-	{
-		setChangedFlag();
-		m_not_fully_generated = !b;
-	}*/
 
-	bool isValid()
+	inline void setGenerated(bool b)
 	{
-		if(m_lighting_expired)
-			return false;
-		if(data == NULL)
-			return false;
-		return true;
+		if (b != m_generated) {
+			raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED);
+			m_generated = b;
+		}
 	}
 
-	/*
-		Position stuff
-	*/
+	////
+	//// Position stuff
+	////
 
-	v3s16 getPos()
+	inline v3s16 getPos()
 	{
 		return m_pos;
 	}
-		
-	v3s16 getPosRelative()
+
+	inline v3s16 getPosRelative()
 	{
-		return m_pos * MAP_BLOCKSIZE;
+		return m_pos_relative;
 	}
-		
-	core::aabbox3d<s16> getBox()
+
+	inline core::aabbox3d<s16> getBox()
 	{
 		return core::aabbox3d<s16>(getPosRelative(),
 				getPosRelative()
@@ -336,340 +222,228 @@ class MapBlock : public NodeContainer
 				- v3s16(1,1,1));
 	}
 
-	/*
-		Regular MapNode get-setters
-	*/
-	
-	bool isValidPosition(v3s16 p)
+	////
+	//// Regular MapNode get-setters
+	////
+
+	inline bool isValidPosition(s16 x, s16 y, s16 z)
 	{
-		if(data == NULL)
-			return false;
-		return (p.X >= 0 && p.X < MAP_BLOCKSIZE
-				&& p.Y >= 0 && p.Y < MAP_BLOCKSIZE
-				&& p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
+		return x >= 0 && x < MAP_BLOCKSIZE
+			&& y >= 0 && y < MAP_BLOCKSIZE
+			&& z >= 0 && z < MAP_BLOCKSIZE;
 	}
 
-	MapNode getNode(s16 x, s16 y, s16 z)
+	inline bool isValidPosition(v3s16 p)
 	{
-		if(data == NULL)
-			throw InvalidPositionException();
-		if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
+		return isValidPosition(p.X, p.Y, p.Z);
 	}
-	
-	MapNode getNode(v3s16 p)
+
+	inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
 	{
-		return getNode(p.X, p.Y, p.Z);
+		*valid_position = isValidPosition(x, y, z);
+
+		if (!*valid_position)
+			return {CONTENT_IGNORE};
+
+		return data[z * zstride + y * ystride + x];
 	}
-	
-	MapNode getNodeNoEx(v3s16 p)
+
+	inline MapNode getNode(v3s16 p, bool *valid_position)
 	{
-		try{
-			return getNode(p.X, p.Y, p.Z);
-		}catch(InvalidPositionException &e){
-			return MapNode(CONTENT_IGNORE);
-		}
+		return getNode(p.X, p.Y, p.Z, valid_position);
 	}
-	
-	void setNode(s16 x, s16 y, s16 z, MapNode & n)
+
+	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(data == NULL)
+		if (!isValidPosition(x, y, z))
 			throw InvalidPositionException();
-		if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		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();
+
+		data[z * zstride + y * ystride + x] = n;
+		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE);
 	}
-	
-	void setNode(v3s16 p, MapNode & n)
+
+	inline void setNode(v3s16 p, MapNode n)
 	{
 		setNode(p.X, p.Y, p.Z, n);
 	}
 
-	/*
-		Non-checking variants of the above
-	*/
+	////
+	//// Non-checking variants of the above
+	////
 
-	MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
+	inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
 	{
-		if(data == NULL)
-			throw InvalidPositionException();
-		return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
+		return data[z * zstride + y * ystride + x];
 	}
-	
-	MapNode getNodeNoCheck(v3s16 p)
+
+	inline MapNode getNodeNoCheck(v3s16 p)
 	{
 		return getNodeNoCheck(p.X, p.Y, p.Z);
 	}
-	
-	void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
+
+	inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode n)
 	{
-		if(data == NULL)
-			throw InvalidPositionException();
-		data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
-		setChangedFlag();
+		data[z * zstride + y * ystride + x] = n;
+		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK);
 	}
-	
-	void setNodeNoCheck(v3s16 p, MapNode & n)
+
+	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.
-	*/
+	// These functions consult the parent container if the position
+	// is not valid on this MapBlock.
 	bool isValidPositionParent(v3s16 p);
-	MapNode getNodeParent(v3s16 p);
-	void setNodeParent(v3s16 p, MapNode & n);
-	MapNode getNodeParentNoEx(v3s16 p);
+	MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL);
 
-	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);
-	}
-
-	/*
-		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 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);
 
-	/*
-		MapBlockObject stuff
-		DEPRECATED
-	*/
-	
-	void serializeObjects(std::ostream &os, u8 version)
+	// 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()
 	{
-		m_objects.serialize(os, version);
+		if (m_day_night_differs_expired)
+			actuallyUpdateDayNightDiff();
+		return m_day_night_differs;
 	}
-	// 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();
+	bool onObjectsActivation();
+	bool saveStaticObject(u16 id, const StaticObject &obj, u32 reason);
 
-		setChangedFlag();
-	}
-	void addObject(MapBlockObject *object)
-			throw(ContainerFullException, AlreadyExistsException)
-	{
-		m_objects.add(object);
+	void step(float dtime, const std::function<bool(v3s16, MapNode, f32)> &on_timer_cb);
 
-		setChangedFlag();
-	}
-	void removeObject(s16 id)
-	{
-		m_objects.remove(id);
+	////
+	//// Timestamp (see m_timestamp)
+	////
 
-		setChangedFlag();
-	}
-	MapBlockObject * getObject(s16 id)
+	// NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
+
+	inline void setTimestamp(u32 time)
 	{
-		return m_objects.get(id);
+		m_timestamp = time;
+		raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP);
 	}
-	JMutexAutoLock * getObjectLock()
+
+	inline void setTimestampNoChangedFlag(u32 time)
 	{
-		return m_objects.getLock();
+		m_timestamp = time;
 	}
 
-	/*
-		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)
+	inline u32 getTimestamp()
 	{
-		m_objects.getObjects(origin, max_d, dest);
+		return m_timestamp;
 	}
 
-	s32 getObjectCount()
+	inline u32 getDiskTimestamp()
 	{
-		return m_objects.getCount();
+		return m_disk_timestamp;
 	}
 
-#ifndef SERVER // Only on client
-	/*
-		Methods for setting temporary modifications to nodes for
-		drawing
+	////
+	//// Usage timer (see m_usage_timer)
+	////
 
-		returns true if the mod was different last time
-	*/
-	bool setTempMod(v3s16 p, const NodeMod &mod)
+	inline void resetUsageTimer()
 	{
-		/*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);
+		m_usage_timer = 0;
 	}
-	// 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);
+	inline void incrementUsageTimer(float dtime)
+	{
+		m_usage_timer += dtime;
 	}
-	bool clearTempMod(v3s16 p)
+
+	inline float getUsageTimer()
 	{
-		JMutexAutoLock lock(m_temp_mods_mutex);
+		return m_usage_timer;
+	}
 
-		return m_temp_mods.clear(p);
+	////
+	//// Reference counting (see m_refcount)
+	////
+
+	inline void refGrab()
+	{
+		m_refcount++;
 	}
-	bool clearTempMods()
+
+	inline void refDrop()
 	{
-		JMutexAutoLock lock(m_temp_mods_mutex);
-		
-		return m_temp_mods.clear();
+		m_refcount--;
 	}
-	void copyTempMods(NodeModMap &dst)
+
+	inline int refGet()
 	{
-		JMutexAutoLock lock(m_temp_mods_mutex);
-		m_temp_mods.copy(dst);
+		return m_refcount;
 	}
-#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();
+	////
+	//// Node Timers
+	////
 
-	bool dayNightDiffed()
+	inline NodeTimer getNodeTimer(v3s16 p)
 	{
-		return m_day_night_differs;
+		return m_node_timers.get(p);
 	}
 
-	/*
-		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.
-	*/
-	void setTimestamp(u32 time)
+	inline void removeNodeTimer(v3s16 p)
 	{
-		m_timestamp = time;
-		setChangedFlag();
+		m_node_timers.remove(p);
 	}
-	void setTimestampNoChangedFlag(u32 time)
+
+	inline void setNodeTimer(const NodeTimer &t)
 	{
-		m_timestamp = time;
+		m_node_timers.set(t);
 	}
-	u32 getTimestamp()
+
+	inline void clearNodeTimers()
 	{
-		return m_timestamp;
+		m_node_timers.clear();
 	}
 
-	/*
-		Serialization
-	*/
-	
+	////
+	//// 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
+	// Precondition: version >= SER_FMT_VER_LOWEST_WRITE
+	void serialize(std::ostream &result, u8 version, bool disk, int compression_level);
+	// 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);
+	void deSerializeNetworkSpecific(std::istream &is);
+
+	bool storeActiveObject(u16 id);
+	// clearObject and return removed objects count
+	u32 clearObjects();
 
 private:
 	/*
 		Private methods
 	*/
 
-	/*
-		Used only internally, because changes can't be tracked
-	*/
-
-	MapNode & getNodeRef(s16 x, s16 y, s16 z)
-	{
-		if(data == NULL)
-			throw InvalidPositionException();
-		if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
-		return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
-	}
-	MapNode & getNodeRef(v3s16 &p)
-	{
-		return getNodeRef(p.X, p.Y, p.Z);
-	}
+	void deSerialize_pre22(std::istream &is, u8 version, bool disk);
 
 public:
 	/*
@@ -677,35 +451,54 @@ class MapBlock : public NodeContainer
 	*/
 
 #ifndef SERVER // Only on client
-	scene::SMesh *mesh;
-	JMutex mesh_mutex;
+	MapBlockMesh *mesh = nullptr;
 #endif
-	
+
 	NodeMetadataList m_node_metadata;
 	StaticObjectList m_static_objects;
-	
+
+	static const u32 ystride = MAP_BLOCKSIZE;
+	static const u32 zstride = MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+
+	static const u32 nodecount = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+
+	//// ABM optimizations ////
+	// Cache of content types
+	std::unordered_set<content_t> contents;
+	// True if content types are cached
+	bool contents_cached = false;
+	// True if we never want to cache content types for this block
+	bool do_not_cache_contents = false;
+	// marks the sides which are opaque: 00+Z-Z+Y-Y+X-X
+	u8 solid_sides {0};
+
 private:
 	/*
 		Private member variables
 	*/
 
 	// NOTE: Lots of things rely on this being the Map
-	NodeContainer *m_parent;
+	Map *m_parent;
 	// Position in blocks on parent
 	v3s16 m_pos;
-	
-	/*
-		If NULL, block is a dummy block.
-		Dummy blocks are used for caching not-found-on-disk blocks.
+
+	/* This is the precalculated m_pos_relative value
+	* This caches the value, improving performance by removing 3 s16 multiplications
+	* at runtime on each getPosRelative call
+	* For a 5 minutes runtime with valgrind this removes 3 * 19M s16 multiplications
+	* The gain can be estimated in Release Build to 3 * 100M multiply operations for 5 mins
 	*/
-	MapNode * data;
+	v3s16 m_pos_relative;
+
+	IGameDef *m_gamedef;
 
 	/*
 		- 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 = MOD_STATE_WRITE_NEEDED;
+	u32 m_modified_reason = MOD_REASON_INITIAL;
 
 	/*
 		When propagating sunlight and the above block doesn't exist,
@@ -715,53 +508,70 @@ class MapBlock : public NodeContainer
 		undeground with nothing visible above the ground except
 		caves.
 	*/
-	bool is_underground;
+	bool is_underground = false;
+
+	/*!
+	 * 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+.
+	*/
+	u16 m_lighting_complete = 0xFFFF;
 
-	/*
-		Set to true if changes has been made that make the old lighting
-		values wrong but the lighting hasn't been actually updated.
+	// Whether day and night lighting differs
+	bool m_day_night_differs = false;
+	bool m_day_night_differs_expired = true;
+
+	bool m_generated = false;
 
-		If this is false, lighting is exactly right.
-		If this is true, lighting might be wrong or right.
+	/*
+		When block is removed from active blocks, this is set to gametime.
+		Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 	*/
-	bool m_lighting_expired;
-	
-	// Whether day and night lighting differs
-	bool m_day_night_differs;
-	
-	// DEPRECATED
-	MapBlockObjectList m_objects;
+	u32 m_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
+	// The on-disk (or to-be on-disk) timestamp value
+	u32 m_disk_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
 
-#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.
+		When the block is accessed, this is set to 0.
+		Map will unload the block when this reaches a timeout.
 	*/
-	bool m_mesh_expired;
-	
-	// Temporary modifications to nodes
-	// These are only used when drawing
-	NodeModMap m_temp_mods;
-	JMutex m_temp_mods_mutex;
-#endif
-	
+	float m_usage_timer = 0;
+
 	/*
-		When block is removed from active blocks, this is set to gametime.
-		Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
+		Reference count; currently used for determining if this block is in
+		the list of blocks to be drawn.
 	*/
-	u32 m_timestamp;
+	int m_refcount = 0;
+
+	MapNode data[nodecount];
+	NodeTimerList m_node_timers;
 };
 
-inline bool blockpos_over_limit(v3s16 p)
+typedef std::vector<MapBlock*> MapBlockVect;
+
+inline bool objectpos_over_limit(v3f p)
 {
-	return
-	  (p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p.X >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p.Y >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-	|| p.Z >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE);
+	const float max_limit_bs = (MAX_MAP_GENERATION_LIMIT + 0.5f) * 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 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;
 }
 
 /*
@@ -772,15 +582,12 @@ inline v3s16 getNodeBlockPos(v3s16 p)
 	return getContainerPos(p, MAP_BLOCKSIZE);
 }
 
-inline v2s16 getNodeSectorPos(v2s16 p)
-{
-	return getContainerPos(p, MAP_BLOCKSIZE);
-}
-
-inline s16 getNodeBlockY(s16 y)
+inline void getNodeBlockPosWithOffset(v3s16 p, v3s16 &block, v3s16 &offset)
 {
-	return getContainerPos(y, MAP_BLOCKSIZE);
+	getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
 }
 
-#endif
-
+/*
+	Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block);